@defrex/autobuild 0.8.0 → 0.10.0

package/packages/core/src/kernel/reducer.ts

@@ -9,7 +9,7 @@
  */
 import type { Actor } from '../events/envelope'
 import type { AbEvent } from '../events/catalog'
-import { normalizeVerifyCompletion, type EventPayload } from '../events/payloads'
+import { normalizeVerifyCompletion, type EventPayload, type PinnedAsset } from '../events/payloads'
 import type {
   ArtifactRef,
   BuildOutcome,
@@ -24,6 +24,7 @@ import type {
   VerifyOutcome,
 } from '../ontology'
 import { verifyPhase } from '../ontology'
+import { defineReducer, type IncrementalReducer } from './incremental'
 
 /** An `escalation.raised` without a matching `escalation.answered` — the
  * definition of `blocked` (§15.5). Matched by id, so answers may arrive in
@@ -52,6 +53,8 @@ export interface AnsweredEscalation extends OpenEscalation {
   resolution: EscalationResolution
   /** Exact replacement spec revision authorized by a `revise-spec` answer. */
   artifact?: ArtifactRef
+  /** Ticket assets sampled with a revise-from-ticket authorization. */
+  assets?: PinnedAsset[]
   /** Absolute review budget accepted with a review-round-limit answer. */
   reviewRoundCeiling?: number
   /** seq of the `escalation.answered` event. */
@@ -130,6 +133,11 @@ export interface AutoMergeProjection {
   /** Latest human command. False with no commandSeq means the default: off. */
   requested: boolean
   commandSeq?: number
+  /** The repository seq of the `dispatcher.auto-merge-default-set` fact the
+   * latest answering command (claim-time seed or fan-out) sampled, when one
+   * did. A per-build command with no `defaultSeq` preserves the previous
+   * value, so the default fan-out can tell an override from staleness. */
+  defaultSeq?: number
   /** Latest recorded external application. It may acknowledge an older
    * command; such a stale fact never changes `requested`/`commandSeq`. */
   applied?: { enabled: boolean; commandSeq: number }
@@ -194,6 +202,9 @@ export interface BuildState {
   lastEvent?: AbEvent
   /** 0 for an empty log; `runner.attached {resumedFromSeq}` cites this. */
   lastSeq: number
+  /** Ticket assets the build froze: set by `build.created`, replaced by a
+   * `spec.revised` that carries `assets` (§6.3). Empty for historical logs. */
+  pinnedAssets: PinnedAsset[]
   /** Latest spec artifact rev — `spec.imported`/`spec.authored` set it,
    * `spec.revised` bumps it (§6.3: rev N+1 restarts the build from plan). */
   specRev?: number
@@ -279,48 +290,143 @@ export interface BuildState {
   failures: Record<string, number>
 }
 
-export function reduceBuild(events: AbEvent[]): BuildState {
-  let attached = false
-  let pausedFlag = false
-  let terminal: 'done' | 'aborted' | undefined
-  let outcome: BuildOutcome | undefined
-  let round = 0
-  let currentPhase: PhaseContext | undefined
-  let lastCompletedPhase: PhaseContext | undefined
-  const openEscalations = new Map<string, OpenEscalation>()
-  const answeredEscalations: AnsweredEscalation[] = []
-  const reviewRoundCeilings: BuildState['reviewRoundCeilings'] = {}
-  let pr: BuildState['pr']
-  let prState: PrLifecycle | undefined
-  const autoMerge: AutoMergeProjection = { requested: false }
-  let specRev: number | undefined
-  let restartSince = 0
-  let finalizeCompletedSeq = 0
-  const finalizeSteps: BuildState['finalizeSteps'] = []
-  const plan: BuildState['plan'] = { round: 0, approved: false }
-  const implement: BuildState['implement'] = { round: 0 }
-  let codeReviewApproved = false
-  let codeReviewApproval: BuildState['codeReviewApproval']
-  const planReviewFindings: Finding[][] = []
-  const codeReviewFindings: Finding[][] = []
-  const verify: BuildState['verify'] = { maxAttemptSeen: 0, results: [], cycleSince: 0 }
-  let reconcileAttempts = 0
-  const observations: ObservationRecord[] = []
-  const setupFailures: BuildState['setupFailures'] = []
-  let setupFailure: BuildState['setupFailure']
-  const dispatchFailures: BuildState['dispatchFailures'] = []
-  const executions: BuildState['executions'] = []
-  const infrastructureFailures: BuildState['infrastructureFailures'] = []
-  let infrastructureFailure: BuildState['infrastructureFailure']
-  const cleanupAttempts: BuildState['cleanupAttempts'] = []
-  let discardRequest: BuildState['discardRequest']
-  const pending: Record<PendingCommand['command'], PendingCommand[]> = {
-    pause: [],
-    resume: [],
-    abort: [],
+/** Whether the build carries an outstanding `discardRequest`. Present exactly
+ * while the build is non-terminal and its discard is unsettled; the reducer
+ * settles it only by terminal completion. This is the single predicate shared
+ * by the auto-merge default fan-out (`autoMergeDefaultEligible`, AUT-418) and
+ * the per-build consent guard (`controlBuild`'s `discard-pending` refusal), so
+ * the two controls' discard exclusions cannot diverge silently. */
+export function discardInFlight(state: Pick<BuildState, 'discardRequest'>): boolean {
+  return state.discardRequest !== undefined
+}
+
+/** The reducer's carried accumulator: everything `reduceBuild` folds, before
+ * the final status derivation. Plain JSON-shaped data (the escalation and
+ * session maps are insertion-ordered entry arrays) so it survives a round
+ * trip through `JSON.stringify` — the foundation for incremental advancement
+ * and cached state. */
+export interface BuildAcc {
+  attached: boolean
+  pausedFlag: boolean
+  terminal?: 'done' | 'aborted'
+  outcome?: BuildOutcome
+  round: number
+  currentPhase?: PhaseContext
+  lastCompletedPhase?: PhaseContext
+  openEscalations: OpenEscalation[]
+  answeredEscalations: AnsweredEscalation[]
+  reviewRoundCeilings: BuildState['reviewRoundCeilings']
+  pr: BuildState['pr']
+  prState?: PrLifecycle
+  autoMerge: AutoMergeProjection
+  specRev?: number
+  restartSince: number
+  pinnedAssets: PinnedAsset[]
+  finalizeCompletedSeq: number
+  finalizeSteps: BuildState['finalizeSteps']
+  plan: BuildState['plan']
+  implement: BuildState['implement']
+  codeReviewApproved: boolean
+  codeReviewApproval: BuildState['codeReviewApproval']
+  planReviewFindings: Finding[][]
+  codeReviewFindings: Finding[][]
+  verify: BuildState['verify']
+  reconcileAttempts: number
+  observations: ObservationRecord[]
+  setupFailures: BuildState['setupFailures']
+  setupFailure: BuildState['setupFailure']
+  dispatchFailures: BuildState['dispatchFailures']
+  executions: BuildState['executions']
+  infrastructureFailures: BuildState['infrastructureFailures']
+  infrastructureFailure: BuildState['infrastructureFailure']
+  cleanupAttempts: BuildState['cleanupAttempts']
+  discardRequest: BuildState['discardRequest']
+  pending: Record<PendingCommand['command'], PendingCommand[]>
+  openSessions: OpenSession[]
+  failures: Record<string, number>
+  lastEvent?: AbEvent
+}
+
+/** Bump when `BuildAcc`'s shape or the fold's semantics change. */
+export const BUILD_REDUCER_VERSION = 1
+
+function initialBuildAcc(): BuildAcc {
+  return {
+    attached: false,
+    pausedFlag: false,
+    round: 0,
+    openEscalations: [],
+    answeredEscalations: [],
+    reviewRoundCeilings: {},
+    pr: undefined,
+    autoMerge: { requested: false },
+    restartSince: 0,
+    pinnedAssets: [],
+    finalizeCompletedSeq: 0,
+    finalizeSteps: [],
+    plan: { round: 0, approved: false },
+    implement: { round: 0 },
+    codeReviewApproved: false,
+    codeReviewApproval: undefined,
+    planReviewFindings: [],
+    codeReviewFindings: [],
+    verify: { maxAttemptSeen: 0, results: [], cycleSince: 0 },
+    reconcileAttempts: 0,
+    observations: [],
+    setupFailures: [],
+    setupFailure: undefined,
+    dispatchFailures: [],
+    executions: [],
+    infrastructureFailures: [],
+    infrastructureFailure: undefined,
+    cleanupAttempts: [],
+    discardRequest: undefined,
+    pending: { pause: [], resume: [], abort: [] },
+    openSessions: [],
+    failures: {},
   }
-  const openSessions = new Map<string, OpenSession>()
-  const failures: Record<string, number> = {}
+}
+
+/** Fold `events` into `acc` in place. */
+function foldBuild(acc: BuildAcc, events: readonly AbEvent[]): void {
+  let attached = acc.attached
+  let pausedFlag = acc.pausedFlag
+  let terminal = acc.terminal
+  let outcome = acc.outcome
+  let round = acc.round
+  let currentPhase = acc.currentPhase
+  let lastCompletedPhase = acc.lastCompletedPhase
+  const openEscalations = new Map(acc.openEscalations.map((e) => [e.id, e]))
+  const answeredEscalations = acc.answeredEscalations
+  const reviewRoundCeilings = acc.reviewRoundCeilings
+  let pr = acc.pr
+  let prState = acc.prState
+  const autoMerge = acc.autoMerge
+  let specRev = acc.specRev
+  let restartSince = acc.restartSince
+  let pinnedAssets = acc.pinnedAssets
+  let finalizeCompletedSeq = acc.finalizeCompletedSeq
+  const finalizeSteps = acc.finalizeSteps
+  const plan = acc.plan
+  const implement = acc.implement
+  let codeReviewApproved = acc.codeReviewApproved
+  let codeReviewApproval = acc.codeReviewApproval
+  const planReviewFindings = acc.planReviewFindings
+  const codeReviewFindings = acc.codeReviewFindings
+  const verify = acc.verify
+  let reconcileAttempts = acc.reconcileAttempts
+  const observations = acc.observations
+  const setupFailures = acc.setupFailures
+  let setupFailure = acc.setupFailure
+  const dispatchFailures = acc.dispatchFailures
+  const executions = acc.executions
+  const infrastructureFailures = acc.infrastructureFailures
+  let infrastructureFailure = acc.infrastructureFailure
+  const cleanupAttempts = acc.cleanupAttempts
+  let discardRequest = acc.discardRequest
+  const pending = acc.pending
+  const openSessions = new Map(acc.openSessions.map((s) => [s.session, s]))
+  const failures = acc.failures
 
   const start = (ctx: PhaseContext): void => {
     currentPhase = ctx
@@ -341,12 +447,14 @@ export function reduceBuild(events: AbEvent[]): BuildState {
     per[r - 1] = findings
   }
 
-  let lastEvent: AbEvent | undefined
+  let lastEvent = acc.lastEvent
   for (const event of events) {
     switch (event.type) {
       // Facts the projection does not need (workspace liveness is the
       // dispatcher's concern; finalize post-steps are failure-tolerant §5).
       case 'build.created':
+        pinnedAssets = event.payload.assets ?? []
+        break
       case 'workspace.provisioned':
       case 'workspace.released':
       case 'publication.requested':
@@ -443,10 +551,23 @@ export function reduceBuild(events: AbEvent[]): BuildState {
       case 'build.auto-merge-requested':
         autoMerge.requested = true
         autoMerge.commandSeq = event.seq
+        // A fan-out (or seeded) command carries the default fact it answers; a
+        // bare per-build command must preserve the previous provenance.
+        if (event.payload.defaultSeq !== undefined) autoMerge.defaultSeq = event.payload.defaultSeq
         break
       case 'build.auto-merge-cancelled':
         autoMerge.requested = false
         autoMerge.commandSeq = event.seq
+        if (event.payload.defaultSeq !== undefined) autoMerge.defaultSeq = event.payload.defaultSeq
+        break
+      case 'build.auto-merge-default-observed':
+        // A no-op fan-out still advances the build's provenance. Without it, a
+        // matching default fact would stay strictly ahead of a bare per-build
+        // command and be re-applied on the next tick, reverting the operator's
+        // explicit choice (f_28b3fba1).
+        if (event.payload.defaultSeq > (autoMerge.defaultSeq ?? 0)) {
+          autoMerge.defaultSeq = event.payload.defaultSeq
+        }
         break
       case 'build.paused':
         pausedFlag = true
@@ -467,6 +588,7 @@ export function reduceBuild(events: AbEvent[]): BuildState {
         break
       case 'spec.revised':
         specRev = event.payload.artifact.rev
+        if (event.payload.assets !== undefined) pinnedAssets = event.payload.assets
         // §6.3: rev N+1 restarts the build from plan. The restart boundary
         // invalidates every approval and result at or before it, so it is also
         // a verify cycle boundary. Finalize post-steps remain in full-log
@@ -661,6 +783,7 @@ export function reduceBuild(events: AbEvent[]): BuildState {
             answer: event.payload.answer,
             resolution: event.payload.resolution,
             ...(event.payload.artifact !== undefined ? { artifact: event.payload.artifact } : {}),
+            ...(event.payload.assets !== undefined ? { assets: event.payload.assets } : {}),
             ...(event.payload.reviewRoundCeiling !== undefined
               ? { reviewRoundCeiling: event.payload.reviewRoundCeiling }
               : {}),
@@ -699,54 +822,112 @@ export function reduceBuild(events: AbEvent[]): BuildState {
     lastEvent = event
   }
 
+  acc.attached = attached
+  acc.pausedFlag = pausedFlag
+  acc.terminal = terminal
+  acc.outcome = outcome
+  acc.round = round
+  acc.currentPhase = currentPhase
+  acc.lastCompletedPhase = lastCompletedPhase
+  acc.openEscalations = [...openEscalations.values()]
+  acc.pr = pr
+  acc.prState = prState
+  acc.specRev = specRev
+  acc.restartSince = restartSince
+  acc.pinnedAssets = pinnedAssets
+  acc.finalizeCompletedSeq = finalizeCompletedSeq
+  acc.codeReviewApproved = codeReviewApproved
+  acc.codeReviewApproval = codeReviewApproval
+  acc.reconcileAttempts = reconcileAttempts
+  acc.setupFailure = setupFailure
+  acc.infrastructureFailure = infrastructureFailure
+  acc.discardRequest = discardRequest
+  acc.openSessions = [...openSessions.values()]
+  acc.lastEvent = lastEvent
+}
+
+function finishBuild(acc: BuildAcc): BuildState {
+  const {
+    terminal,
+    pausedFlag,
+    attached,
+    currentPhase,
+    lastCompletedPhase,
+    lastEvent,
+    discardRequest,
+    pending,
+  } = acc
+
   // §15.5 precedence: aborted/done (terminal, latest wins) > paused >
   // blocked > running > queued. See BuildState.status for the paused+blocked
   // overlap rule.
   const status: BuildStatus =
     terminal ??
-    (pausedFlag ? 'paused' : openEscalations.size > 0 ? 'blocked' : attached ? 'running' : 'queued')
+    (pausedFlag
+      ? 'paused'
+      : acc.openEscalations.length > 0
+        ? 'blocked'
+        : attached
+          ? 'running'
+          : 'queued')
 
   const active = currentPhase ?? lastCompletedPhase
 
   return {
     status,
-    outcome,
+    outcome: acc.outcome,
     phase: active?.phase,
-    round,
+    round: acc.round,
     currentPhase,
     lastCompletedPhase,
-    openEscalations: [...openEscalations.values()],
-    answeredEscalations,
-    reviewRoundCeilings,
-    pr,
-    prState,
-    autoMerge,
-    finalizeCompletedSeq,
-    finalizeSteps,
+    openEscalations: [...acc.openEscalations],
+    answeredEscalations: acc.answeredEscalations,
+    reviewRoundCeilings: acc.reviewRoundCeilings,
+    pr: acc.pr,
+    prState: acc.prState,
+    autoMerge: acc.autoMerge,
+    finalizeCompletedSeq: acc.finalizeCompletedSeq,
+    finalizeSteps: acc.finalizeSteps,
     lastEvent,
     lastSeq: lastEvent?.seq ?? 0,
-    specRev,
-    restartSince,
-    plan,
-    implement,
-    codeReviewApproved,
-    codeReviewApproval,
-    reviewFindings: { planReview: planReviewFindings, codeReview: codeReviewFindings },
-    verify,
-    reconcileAttempts,
-    observations,
-    setupFailures,
-    setupFailure,
-    dispatchFailures,
-    executions,
-    infrastructureFailures,
-    infrastructureFailure,
-    cleanupAttempts,
+    pinnedAssets: acc.pinnedAssets,
+    specRev: acc.specRev,
+    restartSince: acc.restartSince,
+    plan: acc.plan,
+    implement: acc.implement,
+    codeReviewApproved: acc.codeReviewApproved,
+    codeReviewApproval: acc.codeReviewApproval,
+    reviewFindings: { planReview: acc.planReviewFindings, codeReview: acc.codeReviewFindings },
+    verify: acc.verify,
+    reconcileAttempts: acc.reconcileAttempts,
+    observations: acc.observations,
+    setupFailures: acc.setupFailures,
+    setupFailure: acc.setupFailure,
+    dispatchFailures: acc.dispatchFailures,
+    executions: acc.executions,
+    infrastructureFailures: acc.infrastructureFailures,
+    infrastructureFailure: acc.infrastructureFailure,
+    cleanupAttempts: acc.cleanupAttempts,
     ...(terminal === undefined && discardRequest !== undefined ? { discardRequest } : {}),
     pendingCommands: [...pending.pause, ...pending.resume, ...pending.abort].sort(
       (a, b) => a.seq - b.seq,
     ),
-    sessions: { open: [...openSessions.values()] },
-    failures,
+    sessions: { open: [...acc.openSessions] },
+    failures: acc.failures,
   }
 }
+
+/** The incremental form of `reduceBuild`: advance a carried accumulator with
+ * only the events newer than it, then derive the state. */
+export const buildReducer: IncrementalReducer<BuildAcc, AbEvent, BuildState> = defineReducer({
+  version: BUILD_REDUCER_VERSION,
+  initial: initialBuildAcc,
+  fold: foldBuild,
+  finish: finishBuild,
+})
+
+export function reduceBuild(events: AbEvent[]): BuildState {
+  const acc = initialBuildAcc()
+  foldBuild(acc, events)
+  return finishBuild(acc)
+}

package/packages/core/src/operator/annotations.ts

@@ -182,6 +182,12 @@ export const OPERATOR_TOOL_ANNOTATIONS = {
     idempotentHint: false,
     approval: 'default',
   },
+  'sandbox.publish': {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    approval: 'default',
+  },
 } as const satisfies Record<string, ToolAnnotationsTableEntry>
 
 export type OperatorToolName = keyof typeof OPERATOR_TOOL_ANNOTATIONS

package/packages/core/src/operator/control.ts

@@ -29,19 +29,27 @@ export async function setRepositorySetting(opts: {
   enabled: boolean
   /** Delegated-write attribution marker threaded onto the event's actor. */
   via?: Via
+  /** Dispatcher invocation that performed the write. Present on the
+   * dashboard/launch-flag write paths so the two are distinguishable in the
+   * journal; optional so the operator API (which has no run) is unchanged. */
+  run?: string
 }): Promise<{ enabled: boolean; event: RepositoryEventEnvelope }> {
   await opts.store.ensureRepo(opts.repo)
+  const payload = {
+    enabled: opts.enabled,
+    ...(opts.run !== undefined ? { run: opts.run } : {}),
+  }
   const event =
     opts.setting === 'intake'
       ? await opts.store.appendRepo(opts.repo, {
           actor: humanActor(opts.user, opts.via),
           type: 'dispatcher.intake-set',
-          payload: { enabled: opts.enabled },
+          payload,
         })
       : await opts.store.appendRepo(opts.repo, {
           actor: humanActor(opts.user, opts.via),
           type: 'dispatcher.auto-merge-default-set',
-          payload: { enabled: opts.enabled },
+          payload,
         })
   return { enabled: opts.enabled, event }
 }
@@ -52,9 +60,12 @@ export async function toggleRepositorySetting(opts: {
   user: string
   setting: RepositorySetting
   via?: Via
+  /** Dispatcher invocation that performed the write (see setRepositorySetting). */
+  run?: string
 }): Promise<{ enabled: boolean; event: RepositoryEventEnvelope }> {
   await opts.store.ensureRepo(opts.repo)
-  const settings = reduceDispatchSettings(await opts.store.getRepoEvents(opts.repo))
+  // Bounded read (AUT-489): the settings reducer consumes durable types only.
+  const settings = reduceDispatchSettings(await opts.store.getRepoStateEvents(opts.repo))
   const enabled = opts.setting === 'intake' ? !settings.intake : !settings.defaultAutoMerge
   return setRepositorySetting({ ...opts, enabled })
 }
@@ -66,7 +77,8 @@ export async function toggleHarvestGate(opts: {
   via?: Via
 }): Promise<{ command: 'pause' | 'resume'; event: RepositoryEventEnvelope }> {
   await opts.store.ensureRepo(opts.repo)
-  const state = reduceHarvest(await opts.store.getRepoEvents(opts.repo))
+  // Bounded read (AUT-489): the harvest reducer consumes durable types only.
+  const state = reduceHarvest(await opts.store.getRepoStateEvents(opts.repo))
   const pending = state.pendingCommands.at(-1)
   const requestedPaused = pending === undefined ? state.paused : pending.command === 'pause'
   const command = requestedPaused ? 'resume' : 'pause'
@@ -87,7 +99,9 @@ export async function controlHarvestRun(opts: {
   via?: Via
 }): Promise<{ action: HarvestRunAction; event: RepositoryEventEnvelope }> {
   await opts.store.ensureRepo(opts.repo)
-  const events = await opts.store.getRepoEvents(opts.repo)
+  // Bounded read (AUT-489): the harvest reducer and the dashboard harvest
+  // projection consume durable types only.
+  const events = await opts.store.getRepoStateEvents(opts.repo)
   const state = reduceHarvest(events)
   const projected = projectHarvest(events)
   if (projected === undefined || projected.run !== opts.run) {

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

@@ -1,7 +1,7 @@
-export { OperatorApiClient, OperatorApiError } from './client'
-export type { DownloadedArtifact, OperatorApiClientOptions } from './client'
-export { createOperatorServer } from './server'
-export type { OperatorServerOptions } from './server'
+// Core's operator surface: the tool registry behind `ab mcp`, the CLI-facing
+// control/query/tickets/requests primitives, and the operator wire protocol.
+// The operator HTTP server and client ship in
+// `@defrex/autobuild-hosted-store-service` (see its `operator-api` subpath).
 export {
   answerRequestSchema,
   buildControlRequestSchema,
@@ -9,6 +9,10 @@ export {
   bulkControlRequestSchema,
   harvestControlRequestSchema,
   operatorErrorSchema,
+  sessionApprovalRequestSchema,
+  sessionCreateRequestSchema,
+  sessionMessageRequestSchema,
+  sessionWakeRequestSchema,
   settingRequestSchema,
   ticketBlockerRequestSchema,
   ticketCreateRequestSchema,
@@ -19,6 +23,10 @@ export type {
   OperatorAnswerRequest,
   OperatorBuildControlRequest,
   OperatorErrorBody,
+  OperatorSessionApprovalRequest,
+  OperatorSessionCreateRequest,
+  OperatorSessionMessageRequest,
+  OperatorSessionWakeRequest,
   OperatorTicketBlockerRequest,
   OperatorTicketCreateRequest,
   OperatorTicketMoveRequest,
@@ -29,8 +37,32 @@ export type {
   OperatorBuildView,
   OperatorDashboardSnapshot,
 } from './query'
-export { OperatorControlError } from './control'
-export { OperatorQueryError } from './query'
+export {
+  controlHarvestRun,
+  OperatorControlError,
+  setRepositorySetting,
+  toggleHarvestGate,
+  toggleRepositorySetting,
+} from './control'
+export {
+  getHarvestStatus,
+  getOperatorBuild,
+  getOperatorDashboard,
+  getRepositoryStatus,
+  listOperatorBuilds,
+  OperatorQueryError,
+  OrchestratorConfigError,
+  orchestratorConfig,
+} from './query'
+export {
+  orchestratorWakeGlobs,
+  ORCHESTRATOR_ROUTE_LIMIT_SECONDS,
+  type OrchestratorConfig,
+} from '../config/schema'
+export type { OrchestratorTurnRunner } from '../orchestrator/turn-runner'
+export { createOrchestratorTurnRunner } from '../orchestrator/turn-runner'
+export { randomIds } from '../ids'
+export type { Config } from '../config/schema'
 export {
   OPERATOR_NOTES_ARTIFACT,
   TOOLS,
@@ -59,4 +91,37 @@ export type {
   OperatorTicketDetail,
   OperatorTicketQueue,
 } from './tickets'
+export {
+  getOperatorTicket,
+  listOperatorTickets,
+  mutateOperatorTicket,
+} from './tickets'
+export type { OperatorSandboxService } from './sandbox'
 export * from './presentation'
+
+/**
+ * Hosted operator-server composition. The moved server (in
+ * `@defrex/autobuild-hosted-store-service`) builds its routes from these core
+ * primitives; they are re-exported here so the hosted package needs no core
+ * internals. Deliberately not a general public API — do not grow it for
+ * core-internal convenience.
+ */
+export {
+  BuildControlError,
+  controlBuild,
+  type BuildControlAction,
+  type BuildControlResult,
+} from '../cli/build-control'
+export {
+  BulkWalkError,
+  bulkControlRepository,
+  type BulkControlSummary,
+} from '../cli/bulk-control'
+export { effectiveStatus } from '../cli/dashboard/model'
+export { reduceBuild } from '../kernel/reducer'
+export { TicketOperationError } from '../ports/tickets/operations'
+export { humanActor, type Via } from '../events/envelope'
+export type { HarvestStatusView } from '../cli/harvest'
+export type { RepositoryStatus } from '../cli/repository-status'
+export type { BuildSummary } from '../cli/status'
+export type { SessionRecord } from '../store/types'