@defrex/autobuild 0.8.0 → 0.9.0

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

@@ -37,15 +37,23 @@
  * execution lease before launch; the child renews that same-holder lease.
  */
 import type { Config } from '../config/schema'
+import type { LanguageModel } from 'ai'
+import { runOrchestratorTickStep } from './orchestrator-tick'
 import { DISPATCHER, agentActor, humanActor } from '../events/envelope'
+import { isRemoteWorkspace } from '../events/workspace-remote'
 import type { AbEvent, EventWrite } from '../events/catalog'
-import type { EventPayload } from '../events/payloads'
+import type { EventPayload, PinnedAsset } from '../events/payloads'
 import type { IdSource } from '../ids'
 import {
   autoMergeApplicationType,
   pendingAutoMerge,
   recordAutoMergeDeferralObservation,
 } from '../kernel/auto-merge'
+import {
+  autoMergeDefaultTarget,
+  latestAutoMergeDefault,
+  type AutoMergeDefaultFact,
+} from '../kernel/auto-merge-default'
 import { reduceDispatchSettings } from '../kernel/dispatch-settings'
 import { decideNext } from '../kernel/engine'
 import {
@@ -56,7 +64,8 @@ import {
 } from '../kernel/harvest'
 import { pendingPrAttachmentReclaims } from '../kernel/pr-attachments'
 import { reduceBuild, type BuildState } from '../kernel/reducer'
-import type { ArtifactRef } from '../ontology'
+import { createOperatorSandboxService, type OperatorSandboxService } from '../operator/sandbox'
+import type { ArtifactRef, TicketRef } from '../ontology'
 import { BUILD_EXECUTION_LEASE_TTL_MS } from '../ports/workspace/build-execution'
 import type {
   DependencyState,
@@ -67,12 +76,14 @@ import type {
 } from '../ports/types'
 import type { Exec } from '../ports/workspace/git-worktree'
 import type { ArtifactMeta, BuildRecord, BuildStore, Clock } from '../store/types'
+import { samplePinnedAssets } from '../store/ticket-assets'
 import { resolveRepoOrigin } from '../cli/repo-state'
 import { specConformance } from '../spec-standard'
 export { specConformance, type SpecConformance } from '../spec-standard'
 import { recordInfrastructureFailure as appendInfrastructureFailure } from './infrastructure-failure-budget'
 import { lastExecutionOutcome, openExecution, settleExecution } from './execution-settlement'
 import { openHarvestExecutions } from './harvest-execution-state'
+import { readRepoEventsIfRecorded } from './harvest'
 import type { RepositoryEvent } from '../events/repository'
 import { sandboxStates } from './sandbox-state'
 import { abandonedPublicationPending, publicationPending } from './publication-state'
@@ -349,6 +360,11 @@ export interface TickReport {
   sandboxIdleStops: number
   /** Contained idle-settlement failures this tick; retried next tick. */
   sandboxSettleFailures: number
+  /** Contained sandbox-backend construction failures this tick (AUT-584):
+   * deterministic and config-shaped, so it re-reports every tick until the
+   * config is repaired. The affected tick runs with sandbox tools filtered
+   * exactly as when no backend exists. */
+  orchestratorSandboxFailures: number
 }
 
 export function emptyTickReport(): TickReport {
@@ -385,6 +401,7 @@ export function emptyTickReport(): TickReport {
     harvestFailed: 0,
     sandboxIdleStops: 0,
     sandboxSettleFailures: 0,
+    orchestratorSandboxFailures: 0,
   }
 }
 
@@ -534,6 +551,11 @@ export interface DispatcherDeps {
    * supplies cancellation and treats every absence/failure/invalid result as a
    * local deterministic fallback, so naming can never prevent build creation. */
   nameSlug?: (spec: string, signal: AbortSignal) => Promise<string | null>
+  /** The orchestrator turn runner's language model, injected for tests. When
+   * absent the configured gateway model is resolved in process (AUT-342);
+   * the step itself only ever constructs in origin mode with the orchestrator
+   * enabled, so a local dispatcher never resolves a model. */
+  orchestratorModel?: LanguageModel
   /** Settle pending publication for `slug` after durable proof that the
    * guest execution ended. Supplied by the DispatchLoop; the settlement stage
    * invokes it only on a recorded completion. */
@@ -672,11 +694,23 @@ export class Dispatcher {
     /** Builds already launched this tick — a janitor/startup re-attach must
      * not be doubled by the sweep, nor a fresh dispatch by anything. */
     const launched = new Set<string>()
-    // Sampled once, before any stage that could attach a runner: a pause that
-    // lands mid-tick takes effect on the next tick, matching intake (which the
-    // CLI likewise samples before calling `tick`). Neither control pretends to
-    // a serialization the store does not offer.
-    const paused = await this.repositoryPaused()
+    // One journal read for both repository-wide controls: a pause that lands
+    // mid-tick takes effect on the next tick, matching intake (which the CLI
+    // likewise samples before calling `tick`); the auto-merge default fact is
+    // the durable driver of this tick's fan-out below. Neither control
+    // pretends to a serialization the store does not offer.
+    const repoEvents = await readRepoEventsIfRecorded(this.deps.store, this.deps.repo)
+    const paused = reduceDispatchSettings(repoEvents).paused
+    const autoMergeDefault = latestAutoMergeDefault(repoEvents)
+    // The claim-time seed cites the newest fact whose enabled state matches
+    // the launch sample, not blindly the newest fact: the CLI samples
+    // `defaultAutoMerge` from its own earlier read, so an interleaved toggle
+    // can make this tick's read newer-and-opposite. Citing the matching fact
+    // keeps the newer opposite fact strictly ahead of the seed's provenance,
+    // so the fan-out reconciles the build on the next tick instead of the
+    // stale sample out-voting the durable default forever (f_b851c0e8).
+    const autoMergeSeedFact =
+      opts.defaultAutoMerge === true ? latestAutoMergeDefault(repoEvents, true) : undefined
     // Stage 0 — SETTLEMENT: observe foreign executions from durable facts plus
     // provider liveness and settle their completion, lease, and publication.
     // Runs before the janitor so its executionLeaseLive checks see freshly
@@ -691,6 +725,13 @@ export class Dispatcher {
     if (this.outOfBudget(opts)) return report
     await this.settleOrchestratorSandboxes(report, opts)
     if (this.outOfBudget(opts)) return report
+    // The default fan-out runs before the janitor so one tick both records the
+    // consent and lets the janitor act on it (the janitor reduces a fresh read
+    // inside `checkPr`). Independent of intake and `acceptNewWork` — the
+    // durable fact drives it, so a second dispatcher polling the same
+    // repository converges the same state.
+    await this.applyAutoMergeDefault(autoMergeDefault)
+    if (this.outOfBudget(opts)) return report
     await this.janitor(report, launched, opts)
     if (this.outOfBudget(opts)) return report
     await this.recoverDispatches(report, launched, paused, opts)
@@ -700,7 +741,7 @@ export class Dispatcher {
     await this.leaseSweep(report, launched, paused, opts)
     if (this.outOfBudget(opts)) return report
     if (opts.acceptNewWork !== false) {
-      await this.dispatch(report, launched, autoMergeUser, paused, opts)
+      await this.dispatch(report, launched, autoMergeUser, paused, opts, autoMergeSeedFact)
     }
     // Fire-and-forget by contract: long synthesize/review sessions must not
     // stop janitor, lease sweep, ticket dispatch, or signal handling on later
@@ -708,6 +749,60 @@ export class Dispatcher {
     // launch. Pending control commands still launch the runner so the kernel
     // can settle them under the repository lease.
     await this.triggerHarvest()
+    // The orchestrator step (AUT-342) — LAST, after every build stage, so it
+    // can only consume slack: resumes, crash reaping, and wake turns run
+    // against min(configured, remaining tick budget) with a 30 s floor, and
+    // a busy repository simply defers its sessions to later ticks (durable
+    // state makes that safe). Two independent gates keep it inert where it
+    // does not belong: the step is constructed ONLY in origin mode (a local
+    // `ab dispatch` never constructs it — enabled = true in a local
+    // repository's autobuild.toml lists no sessions, builds no registry, and
+    // calls no model), and in origin mode only when the effective config
+    // enables the orchestrator.
+    if (this.deps.repoOrigin !== undefined && this.deps.config.orchestrator.enabled) {
+      if (!this.outOfBudget(opts)) {
+        const remainingSeconds =
+          opts.deadlineAt === undefined
+            ? undefined
+            : Math.max(0, Math.floor((opts.deadlineAt - this.deps.clock().getTime()) / 1000))
+        // The origin-mode tick's sandbox backend (AUT-584), built from the
+        // dispatcher's own deps — the same wired provider and forge the
+        // settlement stage already consumes. Construction is cheap and
+        // network-free (one idempotent ensureRepo), and building per tick
+        // picks up hot config reloads the way the rest of the tick does.
+        // A construction failure is contained: the step runs with sandbox
+        // tools filtered exactly as today, and the standing counter names
+        // the condition (the same discipline as sandboxSettleFailures).
+        let sandbox: OperatorSandboxService | undefined
+        try {
+          sandbox = await createOperatorSandboxService({
+            store: this.deps.store,
+            repo: this.deps.repo,
+            provider: this.deps.workspaces,
+            sandbox: this.deps.config.orchestrator.sandbox,
+            baseBranch: this.deps.config.baseBranch,
+            forge: this.deps.forge,
+            clock: this.deps.clock,
+          })
+        } catch {
+          report.orchestratorSandboxFailures += 1
+          sandbox = undefined
+        }
+        await runOrchestratorTickStep({
+          store: this.deps.store,
+          repo: this.deps.repo,
+          config: this.deps.config,
+          clock: this.deps.clock,
+          ids: this.deps.ids,
+          tickets: this.deps.tickets,
+          ...(sandbox !== undefined ? { sandbox } : {}),
+          ...(this.deps.orchestratorModel !== undefined
+            ? { model: this.deps.orchestratorModel }
+            : {}),
+          ...(remainingSeconds !== undefined ? { remainingBudgetSeconds: remainingSeconds } : {}),
+        })
+      }
+    }
     return report
   }
 
@@ -745,13 +840,51 @@ export class Dispatcher {
     }
   }
 
-  private async repositoryEvents() {
-    if ((await this.deps.store.getRepo(this.deps.repo)) === null) return []
-    return this.deps.store.getRepoEvents(this.deps.repo)
-  }
-
-  private async repositoryPaused(): Promise<boolean> {
-    return reduceDispatchSettings(await this.repositoryEvents()).paused
+  /** Apply the newest durable `dispatcher.auto-merge-default-set` fact to every
+   * current non-terminal build of this repository: on — request consent; off —
+   * cancel it. Attribution is the toggling human's own actor, exactly as if
+   * they had pressed `m` on each row; each command carries the fact's seq so
+   * the fan-out is idempotent (a settled build fails `autoMergeDefaultTarget`)
+   * and a per-build override stands until the default is toggled again. A fact
+   * whose value already matches the build's state writes a provenance-only
+   * `build.auto-merge-default-observed` marker instead of a duplicate command,
+   * so the matching fact is recorded as answered (f_28b3fba1).
+   *
+   * Per build, a compare-and-set loop (the `requestOne` shape from
+   * `bulk-control.ts`): the read/reduce/evaluate lives inside the loop, so a
+   * competing write loses at most one attempt and the next re-reads fresh
+   * state. No TickReport counter: the evidence is the build events, and the
+   * report shape stays compatible. */
+  private async applyAutoMergeDefault(fact: AutoMergeDefaultFact | undefined): Promise<void> {
+    if (fact === undefined) return
+    const { store } = this.deps
+    for (const record of (await store.listBuilds())
+      .filter((candidate) => candidate.repo === this.deps.repo)
+      .sort((a, b) => a.slug.localeCompare(b.slug))) {
+      while (true) {
+        const events = await store.getEvents(record.slug)
+        const state = reduceBuild(events)
+        const target = autoMergeDefaultTarget(state, fact)
+        if (target === undefined) break
+        if (target === 'observed') {
+          const observed = await store.appendIfCurrent(record.slug, state.lastSeq, {
+            actor: DISPATCHER,
+            type: 'build.auto-merge-default-observed',
+            payload: { defaultSeq: fact.seq },
+          })
+          if (observed !== null) break
+          continue
+        }
+        const type =
+          target === 'request' ? 'build.auto-merge-requested' : 'build.auto-merge-cancelled'
+        const appended = await store.appendIfCurrent(record.slug, state.lastSeq, {
+          actor: fact.actor,
+          type,
+          payload: { defaultSeq: fact.seq },
+        })
+        if (appended !== null) break
+      }
+    }
   }
 
   private async triggerHarvest(): Promise<void> {
@@ -762,7 +895,8 @@ export class Dispatcher {
       start()
       return
     }
-    const state = reduceHarvest(await this.deps.store.getRepoEvents(this.deps.repo))
+    // Bounded read (AUT-489): the harvest reducer consumes durable types only.
+    const state = reduceHarvest(await this.deps.store.getRepoStateEvents(this.deps.repo))
     if (decideHarvestControl(state, this.maxHarvestRecoveryAttempts).kind !== 'park') {
       start()
     }
@@ -837,9 +971,12 @@ export class Dispatcher {
     const active = this.deps.activeHarvestExecutions?.() ?? new Set<string>()
     let events: RepositoryEvent[]
     try {
-      events = await this.repositoryEvents()
+      events = await readRepoEventsIfRecorded(this.deps.store, this.deps.repo)
     } catch {
-      // A repository with no journal yet has nothing to settle.
+      // The read itself failed (a transient store error — a missing record
+      // answers `[]` inside the helper, so it never reaches this arm):
+      // skipping this settlement stage for this tick while the rest of the
+      // tick proceeds, and the next tick retries what remains.
       return
     }
     for (const execution of openHarvestExecutions(events)) {
@@ -933,9 +1070,12 @@ export class Dispatcher {
     const providerName = this.deps.workspaces.name
     let events: RepositoryEvent[]
     try {
-      events = await this.repositoryEvents()
+      events = await readRepoEventsIfRecorded(this.deps.store, this.deps.repo)
     } catch {
-      // A repository with no journal yet has nothing to settle.
+      // The read itself failed (a transient store error — a missing record
+      // answers `[]` inside the helper, so it never reaches this arm):
+      // skipping this settlement stage for this tick while the rest of the
+      // tick proceeds, and the next tick retries what remains.
       return
     }
     const idleMs = config.orchestrator.sandbox.idleMinutes * 60_000
@@ -1065,6 +1205,8 @@ export class Dispatcher {
       body: string
       authoredSession?: string
       autoMergeUser?: string
+      autoMergeDefaultSeq?: number
+      assets?: PinnedAsset[]
     },
   ): Promise<'kicked' | 'in-flight' | 'foreign-live'> {
     const slug = record.slug
@@ -1134,6 +1276,8 @@ export class Dispatcher {
             body: string
             authoredSession?: string
             autoMergeUser?: string
+            autoMergeDefaultSeq?: number
+            assets?: PinnedAsset[]
           }
         | undefined
       tail: 'dispatch' | 'launch'
@@ -1192,6 +1336,7 @@ export class Dispatcher {
           ref: handle.ref,
           path: handle.path,
           ...(handle.localPath !== undefined ? { localPath: handle.localPath } : {}),
+          remote: workspaces.publication !== undefined,
           branch: handle.branch,
           base: handle.base,
         },
@@ -1379,7 +1524,7 @@ export class Dispatcher {
 
   private forgeWorkspacePath(events: AbEvent[]): string {
     const open = openWorkspace(events)
-    if (open?.provider === 'vercel-sandbox') return this.deps.repo
+    if (open !== null && isRemoteWorkspace(open)) return this.deps.repo
     // Local forges run git with cwd = workspacePath: it must be the physical
     // checkout, never the store identity (an origin URL since the identity
     // change; a path only for origin-less fixtures).
@@ -1407,13 +1552,12 @@ export class Dispatcher {
     // provisioned facts (not the open one, which is null when the build never
     // provisioned or already released — only the former must skip the
     // local-branch git step; a released local workspace may still have left a
-    // branch in the checkout). Remote workspaces (vercel-sandbox) never create
-    // a local branch in the main checkout, and origin mode has no checkout at
-    // all: the local-branch git step is skipped, and the saga's later steps
-    // tolerate its absence.
+    // branch in the checkout). Remote workspaces never create a local branch
+    // in the main checkout, and origin mode has no checkout at all: the
+    // local-branch git step is skipped, and the saga's later steps tolerate
+    // its absence.
     const hadLocalWorkspace = events.some(
-      (event) =>
-        event.type === 'workspace.provisioned' && event.payload.provider !== 'vercel-sandbox',
+      (event) => event.type === 'workspace.provisioned' && !isRemoteWorkspace(event.payload),
     )
     const has = (type: AbEvent['type']): boolean => events.some((event) => event.type === type)
     const append = async <T extends EventWrite['type']>(write: EventWrite<T>): Promise<void> => {
@@ -2046,7 +2190,15 @@ export class Dispatcher {
   private async baseSha(baseBranch: string): Promise<string> {
     const remoteBranchSha = this.deps.forge.remoteBranchSha
     if (remoteBranchSha !== undefined) {
-      return await remoteBranchSha.call(this.deps.forge, baseBranch)
+      try {
+        return await remoteBranchSha.call(this.deps.forge, baseBranch)
+      } catch {
+        // A forge that advertises the capability but cannot resolve this branch
+        // (a checkout-mode adapter, an unseeded test fake, or a transient
+        // remote failure) falls through to the physical checkout's git read.
+        // In origin mode there is no checkout, so the git read's failure is the
+        // actionable error and the tick still fails closed.
+      }
     }
     const args = [
       'git',
@@ -2068,6 +2220,29 @@ export class Dispatcher {
 
   // ── b. Interrupted dispatch recovery ───────────────────────────────────────
 
+  /** The claim-time `build.created` payload. Assets are omitted when the ticket
+   * had none, so a no-asset build's log is exactly what it was before. */
+  private buildCreatedPayload(
+    ticket: TicketRef,
+    repo: string,
+    seed:
+      | { autoMergeUser?: string; autoMergeDefaultSeq?: number; assets?: PinnedAsset[] }
+      | undefined,
+  ): EventPayload<'build.created'> {
+    const { config } = this.deps
+    return {
+      ticket,
+      repo,
+      baseBranch: config.baseBranch,
+      ...(seed?.autoMergeUser !== undefined ? { autoMergeRequestedBy: seed.autoMergeUser } : {}),
+      ...(seed?.autoMergeDefaultSeq !== undefined
+        ? { autoMergeDefaultSeq: seed.autoMergeDefaultSeq }
+        : {}),
+      ...(config.pr !== undefined ? { pr: config.pr } : {}),
+      ...(seed?.assets !== undefined && seed.assets.length > 0 ? { assets: seed.assets } : {}),
+    }
+  }
+
   /** Every boundary before runner attachment is derived from durable facts.
    * Missing facts are the todo list; successful provider calls are followed
    * immediately by their facts, so an ordinary later tick can continue. */
@@ -2091,6 +2266,8 @@ export class Dispatcher {
       body: string
       authoredSession?: string
       autoMergeUser?: string
+      autoMergeDefaultSeq?: number
+      assets?: PinnedAsset[]
     },
   ): Promise<DispatchOutcome> {
     const { store, config } = this.deps
@@ -2103,18 +2280,16 @@ export class Dispatcher {
             'build record lacks the immutable ticket facts needed to reconstruct build.created',
           )
         }
+        // Legacy path: a record an older dispatcher left with an empty stream.
+        // New claims write `build.created` atomically with the record, so this
+        // can only sample the ticket's current assets (SPEC §6.3).
+        const assets =
+          seed?.assets ??
+          (await samplePinnedAssets(store, record.repo, record.ticket.id).catch(() => []))
         await store.appendIfCurrent(record.slug, 0, {
           actor: DISPATCHER,
           type: 'build.created',
-          payload: {
-            ticket: record.ticket,
-            repo: record.repo,
-            baseBranch: config.baseBranch,
-            ...(seed?.autoMergeUser !== undefined
-              ? { autoMergeRequestedBy: seed.autoMergeUser }
-              : {}),
-            ...(config.pr !== undefined ? { pr: config.pr } : {}),
-          },
+          payload: this.buildCreatedPayload(record.ticket, record.repo, { ...seed, assets }),
         })
         events = await store.getEvents(record.slug)
         if (!events.some((event) => event.type === 'build.created')) {
@@ -2124,6 +2299,10 @@ export class Dispatcher {
 
       const created = events.find((event) => event.type === 'build.created')
       const autoMergeUser = seed?.autoMergeUser ?? created?.payload.autoMergeRequestedBy
+      // The claim's sampled default fact, for the request's fan-out provenance:
+      // the seed's own value first (this dispatch created the build), else the
+      // durable `build.created` fact a recovery pass resumes from.
+      const autoMergeDefaultSeq = seed?.autoMergeDefaultSeq ?? created?.payload.autoMergeDefaultSeq
       if (
         autoMergeUser !== undefined &&
         !events.some((event) => event.type === 'build.auto-merge-requested')
@@ -2131,7 +2310,9 @@ export class Dispatcher {
         await store.append(record.slug, {
           actor: humanActor(autoMergeUser),
           type: 'build.auto-merge-requested',
-          payload: {},
+          payload: {
+            ...(autoMergeDefaultSeq !== undefined ? { defaultSeq: autoMergeDefaultSeq } : {}),
+          },
         })
         events = await store.getEvents(record.slug)
       }
@@ -2172,6 +2353,7 @@ export class Dispatcher {
             ref: handle.ref,
             path: handle.path,
             ...(handle.localPath !== undefined ? { localPath: handle.localPath } : {}),
+            remote: this.deps.workspaces.publication !== undefined,
             branch: handle.branch,
             base: handle.base,
           },
@@ -2218,6 +2400,8 @@ export class Dispatcher {
       body: string
       authoredSession?: string
       autoMergeUser?: string
+      autoMergeDefaultSeq?: number
+      assets?: PinnedAsset[]
     },
     report?: TickReport,
     launched?: Set<string>,
@@ -2578,6 +2762,7 @@ export class Dispatcher {
     autoMergeUser: string | undefined,
     paused: boolean,
     opts: TickOpts = {},
+    autoMergeSeedFact: AutoMergeDefaultFact | undefined = undefined,
   ): Promise<void> {
     const { store, tickets, config } = this.deps
     // Blocked and paused builds still occupy a slot: their workspaces and
@@ -2599,9 +2784,9 @@ export class Dispatcher {
     // standing queue-depth report and must stay honest exactly when the
     // dispatcher is saturated. Sources that keep a claimed ticket in the
     // ready state are deduped against the active builds embodying them.
-    const journalBeforeReady = await this.repositoryEvents()
+    const journalBeforeReady = await readRepoEventsIfRecorded(this.deps.store, this.deps.repo)
     const listing = await tickets.listReady(readyCriteria(config))
-    const journalAfterReady = await this.repositoryEvents()
+    const journalAfterReady = await readRepoEventsIfRecorded(this.deps.store, this.deps.repo)
     const creationHolds = new Map(
       harvestCreationsDuringReadyScan(journalBeforeReady, journalAfterReady).map((creation) => [
         creation.creationKey.toLowerCase(),
@@ -2691,6 +2876,10 @@ export class Dispatcher {
         continue
       }
 
+      // Freeze the ticket's assets at the claim (SPEC §6.3): sampled before the
+      // spec-authoring interval so edits made during it are never pinned.
+      const assets = await samplePinnedAssets(store, this.deps.repo, ticket.ref.id)
+
       // Quality gate (§6.3): import a conforming ticket body as the spec;
       // author one for thin-but-groomed tickets; otherwise bounce.
       let body = ticket.body
@@ -2717,12 +2906,29 @@ export class Dispatcher {
       const slug = await this.uniqueSlug(baseSlug)
       const branch = `ab/${slug}`
       const repoOrigin = await this.resolveRepoOriginOnce()
+      const createdSeed = {
+        ...(autoMergeUser !== undefined ? { autoMergeUser } : {}),
+        // Claim-time provenance: the newest durable default fact that agrees
+        // with the launch sample, recorded on `build.created` so the fan-out's
+        // seq comparison sees the claim as already answering that fact — and
+        // so a newer opposite fact (an interleaved toggle) stays strictly
+        // ahead of it and reconciles this build on the next tick (f_b851c0e8).
+        ...(autoMergeSeedFact !== undefined ? { autoMergeDefaultSeq: autoMergeSeedFact.seq } : {}),
+        assets,
+      }
+      // `build.created` rides with the record so the pinned assets and the
+      // record exist together or not at all.
       const record = await store.createBuild({
         slug,
         repo: this.deps.repo,
         ticket: ticket.ref,
         branch,
         ...(repoOrigin !== undefined ? { repoOrigin } : {}),
+        created: {
+          actor: DISPATCHER,
+          type: 'build.created',
+          payload: this.buildCreatedPayload(ticket.ref, this.deps.repo, createdSeed),
+        },
       })
       report.queued -= 1
       capacity -= 1
@@ -2730,7 +2936,7 @@ export class Dispatcher {
         ticket,
         body,
         ...(authoredSession !== undefined ? { authoredSession } : {}),
-        ...(autoMergeUser !== undefined ? { autoMergeUser } : {}),
+        ...createdSeed,
       })
       // Accepted dispatches: durable boundaries recorded. A deferred outcome
       // means the remote provisioning continuation owns the rest.

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

@@ -61,8 +61,13 @@ export async function runHarvestChild(
     // Full build-child composition parity, in the same order: plugins load
     // first or materializePluginRuntimes silently no-ops and leaves any
     // plugin-provided runtime unrouted in the guest.
+    // Guest tolerance (AUT-517): a harvest runner launch is always
+    // environment-supervised — the process is structurally a guest and never
+    // constructs a workspace provider — so a configured provider plugin the
+    // guest cannot resolve is skipped with a notice instead of failing.
     const plugins = await loadPlugins(config.plugins, workspacePath, {
       packageRoot: input.repo,
+      ...(input.supervision.kind === 'environment' ? { guest: true } : {}),
     })
     const { runtimes: builtins } = createProductionRuntimes()
     const runtimes = await materializePluginRuntimes(builtins, plugins, {