@defrex/autobuild 0.12.0 → 0.14.0

package/packages/core/src/processes/execution-no-progress.ts

@@ -0,0 +1,176 @@
+import type { AbEvent } from '../events/catalog'
+import { DISPATCHER } from '../events/envelope'
+import type { EventType } from '../events/payloads'
+import type { IdSource } from '../ids'
+import type { Config } from '../config/schema'
+import { type Decision, decideNextFromFacts } from '../kernel/engine'
+import { defineReducer } from '../kernel/incremental'
+import type { RepoViewStore } from './repo-view'
+
+/** Every new event must explicitly choose whether it advances build work. */
+export const executionProgress = {
+  'build.created': 'progress',
+  'build.completed': 'progress',
+  'runner.attached': 'bookkeeping',
+  'runner.setup-failed': 'failure',
+  'workspace.provisioned': 'bookkeeping',
+  'workspace.provision-started': 'bookkeeping',
+  'workspace.released': 'bookkeeping',
+  'execution.started': 'bookkeeping',
+  'execution.ended': 'bookkeeping',
+  'infrastructure.failed': 'failure',
+  'infrastructure.cleanup-attempted': 'bookkeeping',
+  'pr-summary.requested': 'progress',
+  'pr-summary.attempted': 'progress',
+  'pr-summary.result': 'progress',
+  'pr-summary.settled': 'progress',
+  'finalize.step-started': 'progress',
+  'publication.requested': 'progress',
+  'publication.lost': 'progress',
+  'abort.remote-branch-deleted': 'progress',
+  'abort.local-branch-deleted': 'progress',
+  'abort.ticket-returned': 'progress',
+  'dispatch.failed': 'failure',
+  'dispatch.comment-posted': 'bookkeeping',
+  'build.pause-requested': 'progress',
+  'build.resume-requested': 'progress',
+  'build.abort-requested': 'progress',
+  'build.discard-requested': 'progress',
+  'build.auto-merge-requested': 'progress',
+  'build.auto-merge-cancelled': 'progress',
+  'build.auto-merge-default-observed': 'bookkeeping',
+  'build.paused': 'progress',
+  'build.resumed': 'progress',
+  'build.aborted': 'progress',
+  'spec.imported': 'progress',
+  'spec.authored': 'progress',
+  'spec.revised': 'progress',
+  'session.started': 'progress',
+  'session.ended': 'progress',
+  'plan.started': 'progress',
+  'plan.completed': 'progress',
+  'plan-review.started': 'progress',
+  'plan-review.verdict': 'progress',
+  'implement.started': 'progress',
+  'implement.completed': 'progress',
+  'code-review.started': 'progress',
+  'code-review.verdict': 'progress',
+  'verify.reconcile-policy-captured': 'progress',
+  'verify.started': 'progress',
+  'verify.completed': 'progress',
+  'finalize.started': 'progress',
+  'finalize.completed': 'progress',
+  'finalize.step-completed': 'progress',
+  'pr-attachment.designated': 'progress',
+  'pr-attachment.hosted': 'progress',
+  'pr-attachment.reclaimed': 'progress',
+  'pr-attachment.reclaim-failed': 'progress',
+  'pr.auto-merge-enabled': 'progress',
+  'pr.auto-merge-disabled': 'progress',
+  'pr.merged': 'progress',
+  'pr.closed': 'progress',
+  'pr.conflicted': 'progress',
+  'reconcile.progress-checked': 'progress',
+  'reconcile.started': 'progress',
+  'reconcile.completed': 'progress',
+  'observation.recorded': 'progress',
+  'escalation.raised': 'progress',
+  'escalation.answered': 'progress',
+  'phase.failed': 'failure',
+} satisfies Record<EventType, 'bookkeeping' | 'failure' | 'progress'>
+
+interface Accumulator {
+  active: { instance: string; seq: number; eligible: boolean } | null
+  count: number
+  open: string[]
+  latest: { instance: string; seq: number } | null
+}
+
+export const executionNoProgressReducer = defineReducer({
+  version: 1,
+  initial: (): Accumulator => ({ active: null, count: 0, open: [], latest: null }),
+  fold(acc, events: readonly AbEvent[]) {
+    for (const event of events) {
+      if (event.type === 'execution.started') {
+        // An abandoned start breaks the consecutive completed-execution streak.
+        if (acc.active !== null) acc.count = 0
+        acc.active = { instance: event.payload.instance, seq: event.seq, eligible: true }
+      } else if (event.type === 'execution.ended') {
+        if (acc.active?.instance !== event.payload.instance) continue
+        const clean = event.payload.outcome === 'completed' && event.payload.exitCode === 0
+        acc.count = clean && acc.active.eligible ? acc.count + 1 : 0
+        acc.latest = { instance: event.payload.instance, seq: event.seq }
+        acc.active = null
+      } else if (
+        event.type === 'escalation.raised' &&
+        event.payload.source === 'policy' &&
+        event.payload.policyCause === 'execution-no-progress'
+      ) {
+        if (!acc.open.includes(event.payload.id)) acc.open.push(event.payload.id)
+      } else if (event.type === 'escalation.answered') {
+        if (!acc.open.includes(event.payload.id)) continue
+        acc.open = acc.open.filter((id) => id !== event.payload.id)
+        acc.count = 0
+        acc.active = null
+      } else if (executionProgress[event.type] !== 'bookkeeping') {
+        acc.count = 0
+        if (acc.active !== null) acc.active.eligible = false
+      }
+    }
+  },
+  finish: (acc) => ({ ...acc, open: [...acc.open] }),
+})
+
+/** Describe routing without copying commands or phase feedback into the question. */
+function expectedAction(decision: Decision): string {
+  if (decision.kind === 'run-phase') return `${decision.kind} ${decision.phase}@${decision.round}`
+  if ('step' in decision)
+    return `${decision.kind} ${decision.step} (attempt ${'attempt' in decision ? decision.attempt : 1})`
+  if (decision.kind === 'raise-escalation') return `${decision.kind} ${decision.phase}`
+  return decision.kind
+}
+
+/** Repair the third-completion/raise crash gap without provisioning execution four. */
+export async function ensureExecutionProgress(
+  store: Pick<RepoViewStore, 'buildFacts' | 'appendIfCurrent' | 'refreshBuild'>,
+  ids: IdSource,
+  slug: string,
+  config: Config,
+  decide?: (
+    state: Parameters<typeof decideNextFromFacts>[0],
+    log: Parameters<typeof decideNextFromFacts>[1],
+  ) => Promise<Decision | undefined>,
+): Promise<boolean> {
+  for (;;) {
+    await store.refreshBuild(slug)
+    const facts = await store.buildFacts(slug)
+    const decision = decide
+      ? await decide(facts.state, facts.log)
+      : decideNextFromFacts(facts.state, facts.log, config)
+    if (decision === undefined) return false
+    // Commands must still be acknowledged even while this guard is parked.
+    if (decision.kind === 'acknowledge') return true
+    const streak = facts.executionNoProgress
+    if (streak.open.length > 0) return false
+    // Callers own wait routing, including publication-recovery launches. A
+    // legitimate wait is not dispatcher/runner disagreement.
+    if (decision.kind === 'wait') return true
+    if (streak.count < 3) return true
+    const raised = await store.appendIfCurrent(slug, facts.state.lastSeq, {
+      actor: DISPATCHER,
+      type: 'escalation.raised',
+      payload: {
+        id: ids('esc'),
+        phase: 'setup',
+        source: 'policy',
+        policyCause: 'execution-no-progress',
+        question: `${streak.count} consecutive executions ended normally without build progress. Dispatcher expected ${expectedAction(decision)}. Inspect the dispatcher/runner disagreement, then answer with guidance or retry.`,
+        refs:
+          streak.latest === null
+            ? []
+            : [`execution:${streak.latest.instance}`, `seq:${streak.latest.seq}`],
+      },
+    })
+    if (raised !== null) return false
+  }
+}

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

@@ -1,3 +1,4 @@
+import { ticketGrantRequest } from '../ports/tickets/grants'
 /**
  * Crash-safe repository-scoped harvest workflow: scan -> synthesize <-> review
  * -> file. It reuses `converge` for adversarial review semantics while every
@@ -56,6 +57,20 @@ export async function runHarvestChild(
   workspacePath: string = process.cwd(),
 ): Promise<void> {
   const fullStore: BuildStore = openStore(input.storeRef, env.AB_TOKEN)
+  const ticketAuthority =
+    env.AB_TICKET_URL && env.AB_TICKET_TOKEN
+      ? { url: env.AB_TICKET_URL, token: env.AB_TICKET_TOKEN }
+      : undefined
+  const renewTickets = ticketAuthority
+    ? setInterval(() => {
+        void ticketGrantRequest(ticketAuthority.url, ticketAuthority.token, {
+          action: 'renew',
+          repo: input.repo,
+        }).catch(() => {
+          // Expiry denies subsequent ticket operations; never regain project authority.
+        })
+      }, 60_000)
+    : undefined
   try {
     const config = await loadConfig(join(workspacePath, 'autobuild.toml'))
     // Full build-child composition parity, in the same order: plugins load
@@ -80,7 +95,7 @@ export async function runHarvestChild(
     const { targetRepo, localStateRoot } = guestTicketSourceArgs(input, workspacePath)
     const tickets = await createTicketSource(
       config.tickets,
-      env,
+      { ...env, AB_HARVEST: input.preparedRun?.run ?? input.instance },
       targetRepo,
       localStateRoot,
       plugins,
@@ -103,6 +118,8 @@ export async function runHarvestChild(
       ...(input.leaseHolder !== undefined ? { leaseHolder: input.leaseHolder } : {}),
       ...(input.environment !== undefined ? { environment: input.environment } : {}),
       sessionEnv: {
+        ...(env.AB_TICKET_URL ? { AB_TICKET_URL: env.AB_TICKET_URL } : {}),
+        ...(env.AB_TICKET_TOKEN ? { AB_TICKET_TOKEN: env.AB_TICKET_TOKEN } : {}),
         AB_STORE: input.storeRef,
         ...(env.AB_TOKEN !== undefined && env.AB_TOKEN !== '' ? { AB_TOKEN: env.AB_TOKEN } : {}),
       },
@@ -112,10 +129,19 @@ export async function runHarvestChild(
     })
     await runner.run()
   } finally {
+    if (renewTickets) clearInterval(renewTickets)
     try {
-      await fullStore.close()
-    } catch {
-      // Process teardown cannot change the already-durable runner outcome.
+      if (ticketAuthority)
+        await ticketGrantRequest(ticketAuthority.url, ticketAuthority.token, {
+          action: 'revoke',
+          repo: input.repo,
+        })
+    } finally {
+      try {
+        await fullStore.close()
+      } catch {
+        // Process teardown cannot change the already-durable runner outcome.
+      }
     }
   }
 }

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

@@ -1,3 +1,4 @@
+import type { RepositoryReadFacts } from '../store/reduced-reads'
 /**
  * Durable harvest execution state: the repository-journal projection that
  * hosted-harvest supervision (AUT-305) reads instead of process memory. The
@@ -88,22 +89,27 @@ export interface HarvestExecutionClassificationInput {
  * `held`; anything else is `idle`. The result feeds the same counters a
  * locally run harvest reports. */
 export function classifyHarvestOutcome(
-  events: readonly RepositoryEvent[],
+  events: readonly RepositoryEvent[] | RepositoryReadFacts,
   input: HarvestExecutionClassificationInput,
 ): HarvestRunnerResult {
-  const state = reduceHarvest(events)
-  const started = events.find(
+  const facts = !Array.isArray(events) ? (events as RepositoryReadFacts) : undefined
+  const raw = Array.isArray(events) ? events : []
+  const state = facts?.harvest ?? reduceHarvest(raw)
+  const started = raw.find(
     (event) =>
       event.type === 'harvest.execution.started' && event.seq === input.executionStartedSeq,
   )
+  const execution =
+    facts?.harvestExecutionStarts[String(input.executionStartedSeq)] ??
+    (started?.type === 'harvest.execution.started' ? started.payload.execution : undefined)
   const authorization =
-    started?.type === 'harvest.execution.started'
-      ? events.find(
+    execution === undefined
+      ? undefined
+      : (facts?.harvestAuthorizations[JSON.stringify(execution)] ??
+        raw.find(
           (event) =>
-            event.type === 'harvest.execution.authorized' &&
-            event.payload.execution === started.payload.execution,
-        )
-      : undefined
+            event.type === 'harvest.execution.authorized' && event.payload.execution === execution,
+        ))
   const selected =
     authorization?.type === 'harvest.execution.authorized' ? authorization.payload : undefined
   const latestRun = selected

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

@@ -1,3 +1,6 @@
+import { readRepositoryFacts } from '../store/reduced-reads'
+import { ticketIdentity } from '../ports/tickets/identity'
+import { issueTicketGrant } from '../ports/tickets/grants'
 import { delegateCredential } from '../store/remote/credentials'
 /**
  * Crash-safe repository-scoped harvest workflow:
@@ -20,7 +23,6 @@ import {
   decideHarvestControl,
   openHarvestRun,
   proposalArtifactForRound,
-  reduceHarvest,
   type HarvestRunState,
 } from '../kernel/harvest'
 import type { ArtifactRef, Feedback, Verdict } from '../ontology'
@@ -237,28 +239,23 @@ export class HarvestRunner {
       // Bounded read (AUT-489): reduceHarvest and the verdict/failure filters
       // below consume durable types only, so the subset is replay-equivalent.
       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,
-        )
+        const events = (await readRepositoryFacts(store, repo)).value
+        const authorization = events.harvestAuthorizations[JSON.stringify(instance)]
         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)
+        run = events.harvest.runs.find((run) => run.run === this.deps.preparedRun!.run)
         initial = authorization.payload.launch
       } else {
-        let events = await store.getRepoStateEvents(repo)
-        let state = reduceHarvest(events)
+        let events = (await readRepositoryFacts(store, repo)).value
+        let state = events.harvest
         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)
+        events = (await readRepositoryFacts(store, repo)).value
+        state = events.harvest
         run = openHarvestRun(state)
 
         if (!run) {
@@ -272,7 +269,7 @@ export class HarvestRunner {
           // 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),
+            readRepositoryFacts(store, repo).then((result) => result.value.harvest),
             store.getRepoBuildDigests(repo),
           ])
           const pressure = evaluateHarvestPressureFromDigests({
@@ -336,8 +333,8 @@ export class HarvestRunner {
             }),
           )
           // Bounded read (AUT-489): reduceHarvest consumes durable types only.
-          events = await store.getRepoStateEvents(repo)
-          run = reduceHarvest(events).runs.find((candidate) => candidate.run === runId)
+          events = (await readRepositoryFacts(store, repo)).value
+          run = events.harvest.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.
@@ -501,14 +498,8 @@ export class HarvestRunner {
           )
           // Bounded read (AUT-489): only harvest.review.verdict facts are
           // filtered here, and those are durable.
-          const event = (await this.deps.store.getRepoStateEvents(this.deps.repo)).find(
-            (
-              candidate,
-            ): candidate is Extract<RepositoryEvent, { type: 'harvest.review.verdict' }> =>
-              candidate.type === 'harvest.review.verdict' &&
-              candidate.payload.run === run.run &&
-              candidate.payload.round === round,
-          )
+          const event = (await readRepositoryFacts(this.deps.store, this.deps.repo)).value
+            .harvestVerdicts[JSON.stringify([run.run, round])]?.first
           if (!event) throw new Error('review reducer/event mismatch')
           await this.controlBoundary(run.run)
           return verdictFromEvent(event)
@@ -570,15 +561,8 @@ export class HarvestRunner {
     })
     // Bounded read (AUT-489): only harvest.review.verdict facts are filtered
     // here, and those are durable.
-    const events = await this.deps.store.getRepoStateEvents(this.deps.repo)
-    const verdict = [...events]
-      .reverse()
-      .find(
-        (event): event is Extract<RepositoryEvent, { type: 'harvest.review.verdict' }> =>
-          event.type === 'harvest.review.verdict' &&
-          event.payload.run === run.run &&
-          event.payload.round === round,
-      )
+    const events = (await readRepositoryFacts(this.deps.store, this.deps.repo)).value
+    const verdict = events.harvestVerdicts[JSON.stringify([run.run, round])]?.latest
     if (!verdict) throw new Error(`review@${round} terminal is missing`)
     await this.completeStep(
       run.run,
@@ -622,22 +606,16 @@ export class HarvestRunner {
     await this.ensureLease()
     // Bounded read (AUT-489): reduceHarvest and the harvest.failed filter
     // consume durable types only.
-    const events = await store.getRepoStateEvents(repo)
-    const matchingFailures = events.filter(
-      (event): event is Extract<RepositoryEvent, { type: 'harvest.failed' }> =>
-        event.type === 'harvest.failed' &&
-        event.payload.run === spec.run &&
-        event.payload.step === spec.step &&
-        event.payload.round === spec.round,
-    )
-    const failures = matchingFailures.length
-    const latestFailure = matchingFailures.at(-1)
-    const current = reduceHarvest(events).runs.find((candidate) => candidate.run === spec.run)
+    const events = (await readRepositoryFacts(store, repo)).value
+    const failureFacts = events.harvestFailures[JSON.stringify([spec.run, spec.step, spec.round])]
+    const failures = failureFacts?.count ?? 0
+    const latestFailure = failureFacts?.latest
+    const current = events.harvest.runs.find((candidate) => candidate.run === spec.run)
     const resumedAfterTerminalFailure =
       latestFailure?.payload.willRetry === false &&
       current?.status === 'running' &&
       current.failure === undefined &&
-      events.some((event) => event.type === 'harvest.resumed' && event.seq > latestFailure.seq)
+      events.latestHarvestResumedSeq > latestFailure.seq
     if (failures >= this.maxSessionAttempts && !resumedAfterTerminalFailure) {
       throw new SessionFailure(`${spec.step}@${spec.round} exhausted retries`)
     }
@@ -882,17 +860,11 @@ export class HarvestRunner {
     await this.ensureLease()
     // Bounded read (AUT-489): reduceHarvest and the harvest.failed filter
     // consume durable types only.
-    const events = await store.getRepoStateEvents(repo)
-    const matchingFailures = events.filter(
-      (event): event is Extract<RepositoryEvent, { type: 'harvest.failed' }> =>
-        event.type === 'harvest.failed' &&
-        event.payload.run === spec.run &&
-        event.payload.step === spec.step &&
-        event.payload.round === spec.round,
-    )
-    const failures = matchingFailures.length
-    const latestFailure = matchingFailures.at(-1)
-    const current = reduceHarvest(events).runs.find((candidate) => candidate.run === spec.run)
+    const events = (await readRepositoryFacts(store, repo)).value
+    const failureFacts = events.harvestFailures[JSON.stringify([spec.run, spec.step, spec.round])]
+    const failures = failureFacts?.count ?? 0
+    const latestFailure = failureFacts?.latest
+    const current = events.harvest.runs.find((candidate) => candidate.run === spec.run)
     // A stopping failure may already have consumed the ordinary retry budget.
     // harvest.resumed deliberately clears that reduced stop and grants one real
     // re-entry without deleting history or resetting attempt numbers. The next
@@ -901,7 +873,7 @@ export class HarvestRunner {
       latestFailure?.payload.willRetry === false &&
       current?.status === 'running' &&
       current.failure === undefined &&
-      events.some((event) => event.type === 'harvest.resumed' && event.seq > latestFailure.seq)
+      events.latestHarvestResumedSeq > latestFailure.seq
     if (failures >= this.maxSessionAttempts && !resumedAfterTerminalFailure) {
       throw new SessionFailure(`${spec.step}@${spec.round} exhausted retries`)
     }
@@ -1176,9 +1148,16 @@ export class HarvestRunner {
     )
     const packet = await loadScanPacket(store, repo, current.scan)
     const observations = packet.observations
-    const knownLedger = new Map(
-      packet.ledger.map((entry) => [`${entry.ticket.source}:${entry.ticket.id}`, entry]),
-    )
+    const identity = ticketIdentity(tickets)
+    const knownLedger = new Map<string, (typeof packet.ledger)[number]>()
+    for (const entry of packet.ledger) {
+      const current =
+        entry.ticket.source === tickets.name ? await tickets.get(entry.ticket.id) : null
+      knownLedger.set(await identity(entry.ticket), {
+        ...entry,
+        ticket: current?.ref ?? entry.ticket,
+      })
+    }
     const alreadyFiled = new Map(current.filed.map((entry) => [entry.proposalKey, entry]))
     const reservations = new Map(current.reservations.map((entry) => [entry.proposalKey, entry.id]))
     const dispositions: HarvestDisposition[] = []
@@ -1258,7 +1237,7 @@ export class HarvestRunner {
           ...(filed.blockers !== undefined ? { blockers: filed.blockers } : {}),
         })
       } else if (proposal.action === 'join') {
-        const known = knownLedger.get(`${proposal.ticket.source}:${proposal.ticket.id}`)
+        const known = knownLedger.get(await identity(proposal.ticket))
         if (!known) {
           throw new Error(
             `approved join target ${proposal.ticket.source}:${proposal.ticket.id} is not in the ledger context`,
@@ -1357,8 +1336,8 @@ export class HarvestRunner {
     await this.ensureLease()
     // Bounded read (AUT-489): reduceHarvest and the harvest.failed filter
     // consume durable types only.
-    const events = await this.deps.store.getRepoStateEvents(this.deps.repo)
-    const state = reduceHarvest(events)
+    const events = (await readRepositoryFacts(this.deps.store, this.deps.repo)).value
+    const state = events.harvest
     const current = state.runs.find((candidate) => candidate.run === run)
     if (current?.status !== 'running') return
     const open = [...current.steps]
@@ -1366,13 +1345,7 @@ export class HarvestRunner {
       .find((occurrence) => occurrence.completedSeq === undefined)
     const step = open?.step ?? 'file'
     const round = open?.round
-    const prior = events.filter(
-      (event) =>
-        event.type === 'harvest.failed' &&
-        event.payload.run === run &&
-        event.payload.step === step &&
-        event.payload.round === round,
-    ).length
+    const prior = events.harvestFailures[JSON.stringify([run, step, round])]?.count ?? 0
     const attempt = prior + 1
     const willRetry = attempt < this.maxSessionAttempts
     const message = errorMessage(error)
@@ -1412,7 +1385,7 @@ export class HarvestRunner {
     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))
+    const state = (await readRepositoryFacts(this.deps.store, this.deps.repo)).value.harvest
     const decision = decideHarvestControl(state, this.maxRecoveryAttempts)
     if (decision.kind !== 'exhaust-recovery' || decision.run !== run) return
     await this.finalizeRecoveryExhaustion(decision.run, decision.attempts, decision.limit)
@@ -1438,7 +1411,7 @@ export class HarvestRunner {
 
     await this.ensureLease()
     // Bounded read (AUT-489): reduceHarvest consumes durable types only.
-    const state = reduceHarvest(await this.deps.store.getRepoStateEvents(this.deps.repo))
+    const state = (await readRepositoryFacts(this.deps.store, this.deps.repo)).value.harvest
     const decision = decideHarvestControl(state, this.maxRecoveryAttempts)
     if (
       decision.kind !== 'exhaust-recovery' ||
@@ -1475,7 +1448,7 @@ export class HarvestRunner {
     while (true) {
       await this.ensureLease()
       // Bounded read (AUT-489): reduceHarvest consumes durable types only.
-      const state = reduceHarvest(await this.deps.store.getRepoStateEvents(this.deps.repo))
+      const state = (await readRepositoryFacts(this.deps.store, this.deps.repo)).value.harvest
       const decision = decideHarvestControl(state, this.maxRecoveryAttempts)
       if (decision.kind === 'proceed') return
       if (this.deps.preparedRun) throw new HarvestParkedSignal(run)
@@ -1520,7 +1493,7 @@ export class HarvestRunner {
 
   private async refreshRun(run: string): Promise<HarvestRunState> {
     // Bounded read (AUT-489): reduceHarvest consumes durable types only.
-    const state = reduceHarvest(await this.deps.store.getRepoStateEvents(this.deps.repo))
+    const state = (await readRepositoryFacts(this.deps.store, this.deps.repo)).value.harvest
     const found = state.runs.find((candidate) => candidate.run === run)
     if (!found) throw new Error(`unknown harvest run "${run}"`)
     return found
@@ -1638,9 +1611,20 @@ export class HarvestRunner {
             session,
           })
         : undefined
+    const ticketGrant =
+      parent?.AB_TICKET_URL && parent.AB_TICKET_TOKEN
+        ? await issueTicketGrant(
+            parent.AB_TICKET_URL,
+            parent.AB_TICKET_TOKEN,
+            this.deps.repo,
+            this.deps.instance,
+            'phase',
+          )
+        : undefined
     return {
       AB_STORE: 'local',
       ...this.deps.sessionEnv,
+      ...(ticketGrant ? { AB_TICKET_TOKEN: ticketGrant.token } : {}),
       ...(token ? { AB_TOKEN: token } : {}),
       AB_REPO: this.deps.repo,
       AB_HARVEST: run,