@defrex/autobuild 0.12.0 → 0.14.0

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

@@ -92,6 +92,9 @@ export type {
   OperatorTicketQueue,
 } from './tickets'
 export {
+  prepareOperatorTicketAssets,
+  listOperatorTicketStates,
+  createOperatorTicketState,
   getOperatorTicket,
   listOperatorTickets,
   mutateOperatorTicket,
@@ -132,3 +135,7 @@ export {
   findEffectiveConfigRef,
   decodeEffectiveConfig,
 } from './query'
+
+export { ticketStateCreateRequestSchema } from './protocol'
+
+export { readBuildFacts } from '../store/reduced-reads'

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

@@ -55,15 +55,27 @@ export const ticketCreateRequestSchema = z.strictObject({
   state: z.string().min(1).optional(),
   blockedBy: z.array(z.string().min(1)).optional(),
 })
+const expectedRevisionSchema = z
+  .string()
+  .refine((v) => v.trim().length > 0, 'expectedRevision must be nonblank')
+  .optional()
 export const ticketUpdateRequestSchema = z
   .strictObject({
+    expectedRevision: expectedRevisionSchema,
     title: z.string().optional(),
     body: z.string().optional(),
     labels: z.array(z.string()).optional(),
   })
-  .refine((value) => Object.keys(value).length > 0, 'update must name at least one field')
-export const ticketMoveRequestSchema = z.strictObject({ state: z.string().min(1) })
+  .refine(
+    (value) => value.title !== undefined || value.body !== undefined || value.labels !== undefined,
+    'update must name at least one field',
+  )
+export const ticketMoveRequestSchema = z.strictObject({
+  expectedRevision: expectedRevisionSchema,
+  state: z.string().min(1),
+})
 export const ticketBlockerRequestSchema = z.strictObject({
+  expectedRevision: expectedRevisionSchema,
   blockerIds: z.array(z.string().min(1)).min(1),
 })
 export type OperatorTicketCreateRequest = z.infer<typeof ticketCreateRequestSchema>
@@ -96,3 +108,8 @@ export const sessionApprovalRequestSchema = z.strictObject({
   decision: z.enum(['approve', 'deny']),
 })
 export type OperatorSessionApprovalRequest = z.infer<typeof sessionApprovalRequestSchema>
+
+export const ticketStateCreateRequestSchema = z.strictObject({
+  name: z.string(),
+  about: z.string().optional(),
+})

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

@@ -1,3 +1,9 @@
+import { readBuildDigests } from '../store/reduced-reads'
+import {
+  readBuildFacts,
+  readRepositoryFacts,
+  type RepositoryReadFacts,
+} from '../store/reduced-reads'
 import { readDispatcherLiveness } from '../cli/dispatcher-liveness'
 import { composeBuildConfig } from '../config/live'
 import type { PipelineSourceMeta } from '../config/pipeline-source'
@@ -9,26 +15,25 @@ import {
 } from '../processes/build-execution-state'
 import type { Artifact } from '../store/types'
 import {
-  detail,
+  detailFromFacts,
   statusFilter,
   summarizeFrom,
   type BuildDetail,
   type BuildSummary,
 } from '../cli/status'
-import { projectRepositoryStatus, type RepositoryStatus } from '../cli/repository-status'
+import { repositoryStatusFromFacts, type RepositoryStatus } from '../cli/repository-status'
 import { projectHarvestStatus, type HarvestStatusView } from '../cli/harvest'
 import {
   buildDashboardFromProjected,
   effectiveStatus,
-  projectBuild,
   projectBuildFromFacts,
   type DashboardBuild,
   type DashboardModel,
 } from '../cli/dashboard/model'
-import { reduceBuild, type BuildState } from '../kernel/reducer'
+import type { BuildState } from '../kernel/reducer'
 import { DISPATCHER_EFFECTIVE_CONFIG_ARTIFACT } from '../store/retention'
 import { reduceDispatchStatus } from '../kernel/dispatch-status'
-import { readRepoEventsIfRecorded, unclaimedObservationCount } from '../processes/harvest'
+import { unclaimedObservationCount } from '../processes/harvest'
 import type { RepoViewStore } from '../processes/repo-view'
 import { withOperatorView } from './read-view'
 import type { RepositoryEvent } from '../events/repository'
@@ -74,7 +79,7 @@ async function listFromView(
   // finished builds accumulate. The `--all` scope includes terminal statuses,
   // so it takes no digest read and skips nothing; its terminal builds are
   // restored from the reducer snapshots the dispatcher leaves at settlement.
-  const digests = opts.scope === 'all' ? undefined : await view.getRepoBuildDigests(opts.repo)
+  const digests = opts.scope === 'all' ? undefined : await readBuildDigests(view, opts.repo)
   const output: BuildSummary[] = []
   for (const record of records) {
     if (record.repo !== opts.repo) continue
@@ -114,14 +119,19 @@ export async function effectiveConfig(
   repo: string,
   /** The bounded journal, when the caller already holds it (a repository
    * view); otherwise it is read from the store. */
-  journal?: RepositoryEvent[],
+  journal?: RepositoryReadFacts,
 ): Promise<{
   config: Config
-  repositoryEvents: RepositoryEvent[]
+  repositoryEvents: RepositoryReadFacts
   status: ReturnType<typeof reduceDispatchStatus>
 }> {
-  const repositoryEvents = journal ?? (await readRepoEventsIfRecorded(store, repo))
-  const status = selectEffectiveConfig(repositoryEvents, repo)
+  const repositoryEvents = journal ?? (await readRepositoryFacts(store, repo)).value
+  const status = repositoryEvents.status
+  if (status?.effectiveConfig === undefined)
+    throw new OperatorQueryError(
+      'effective-config-unavailable',
+      `effective config unavailable for repository "${repo}"${repositoryEvents.config.run === undefined ? ': no dispatcher run is recorded' : ''}`,
+    )
   const ref = status.effectiveConfig!
   const artifact = await store.getRepoArtifact(repo, ref.kind, ref.rev)
   if (artifact === null) {
@@ -258,19 +268,19 @@ export async function getOperatorBuild(opts: {
   now: Date
 }): Promise<OperatorBuildView> {
   const record = await requireBuild(opts.store, opts.repo, opts.slug)
-  const events = await opts.store.getEvents(opts.slug)
-  const state = reduceBuild(events)
+  const facts = (await readBuildFacts(opts.store, opts.slug)).value
+  const state = facts.state
   const { config } = await effectiveConfig(opts.store, opts.repo)
   let dashboardRow: DashboardBuild | null = null
   if (!projectsNoDashboardRow(state)) {
     const pinned = await readPinnedConfig(opts.store, opts.slug, config)
-    const row = projectBuild(record, state, config, events, undefined, pinned.config)
+    const row = projectBuildFromFacts(record, state, facts, config, undefined, pinned.config)
     // Implied by the gate; kept as an explicit check (not an assertion) so the
     // code never lies if `effectiveStatus` and `projectBuild` ever drift.
     if (row !== null) dashboardRow = decorateWithPinnedMeta(row, pinned)
   }
   return {
-    detail: detail(record, events, opts.now),
+    detail: detailFromFacts(record, facts, opts.now),
     dashboardRow,
   }
 }
@@ -281,8 +291,12 @@ export async function getRepositoryStatus(
   now = new Date(),
 ): Promise<RepositoryStatus> {
   return withOperatorView(store, repo, 'journal', async (view) => {
-    const { dispatcher } = await readDispatcherLiveness(store, repo, now, view.recordedJournal())
-    return projectRepositoryStatus(repo, view.recordedJournal(), dispatcher)
+    const { dispatcher } = await readDispatcherLiveness(store, repo, now)
+    return repositoryStatusFromFacts(
+      repo,
+      (await readRepositoryFacts(view, repo)).value,
+      dispatcher,
+    )
   })
 }
 
@@ -291,7 +305,7 @@ export async function getHarvestStatus(
   repo: string,
 ): Promise<HarvestStatusView> {
   return withOperatorView(store, repo, 'journal', async (view) =>
-    projectHarvestStatus(repo, view.recordedJournal()),
+    projectHarvestStatus(repo, view.repositoryFacts()),
   )
 }
 
@@ -321,7 +335,7 @@ async function dashboardFromView(
   const { config, repositoryEvents, status } = await effectiveConfig(
     view,
     opts.repo,
-    view.recordedJournal(),
+    view.repositoryFacts(),
   )
   const records = await view.listBuilds()
   // One digest read covers every build of the repository (AUT-487): the
@@ -330,7 +344,7 @@ async function dashboardFromView(
   // builds accumulate. Row-rendering builds derive from the repository view's
   // reducer snapshots plus a delta read (AUT-650); every snapshot is a cache
   // the event log regenerates, so the response equals a full replay's.
-  const digests = await view.getRepoBuildDigests(opts.repo)
+  const digests = await readBuildDigests(view, opts.repo)
   const projected: DashboardBuild[] = []
   let activeCount = 0
   for (const record of records) {
@@ -372,7 +386,10 @@ async function dashboardFromView(
   // `effectiveConfig` already returned — no per-build history reads (AUT-487).
   // The pure core writes nothing — a snapshot performs no store writes and
   // never creates or locks the repository record.
-  const observationCount = unclaimedObservationCount({ digests, harvestEvents: repositoryEvents })
+  const observationCount = unclaimedObservationCount({
+    digests,
+    harvestEvents: repositoryEvents.harvest,
+  })
   const warningLines = [
     ...status.roleWarnings,
     ...(status.warningNotice !== undefined ? [status.warningNotice] : []),

package/packages/core/src/operator/read-view.ts

@@ -1,16 +1,15 @@
 /**
  * The operator read paths' repository view: every poll-driven route (dashboard,
  * repository and harvest status, build listings) derives its state from a
- * `RepoViewStore` cold-started from stored reducer snapshots and advanced with
- * delta reads, so a poll's event-row cost follows the events appended since the
- * last one, never the history, the open tabs, or the watchers.
+ * `RepoViewStore` backed by persisted reduced values. Each pass refreshes
+ * repository facts and metadata without hydrating raw history.
  *
  * Passes are single-flight per `(store, repo)` within one serving process: at
  * most one pass runs at a time, and requests arriving while it runs join the
  * one trailing pass (each needs state at least as new as its arrival, which the
  * running pass cannot promise). That trailing pass restores from the snapshot
- * the previous pass persisted, so N concurrent pollers cost one delta read per
- * pass, not N. The coordination is scheduling inside this process; every datum
+ * the previous pass persisted for builds, so N concurrent pollers cost one
+ * build delta read per pass, not N. The coordination is scheduling inside this process; every datum
  * still comes from durable state, and a second serving process simply reads the
  * same delta once itself (duplicate reads are bounded by the process count).
  */
@@ -58,14 +57,6 @@ async function pass(store: BuildStore, repo: string, waiters: Waiter[]): Promise
     return
   }
   await Promise.all(waiters.map((waiter) => waiter.run(view).then(waiter.resolve, waiter.reject)))
-  // Leave the advanced state behind for the next pass (this process's or
-  // another's). `held` also writes a settled build read for a listing. The
-  // cache never fails a read.
-  try {
-    await view.persistSnapshots({ force: true, held: true })
-  } catch {
-    // A cache: the next pass retries.
-  }
 }
 
 async function drain(store: BuildStore, repo: string, flight: Flight): Promise<void> {

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

@@ -1,3 +1,4 @@
+import { TicketRevisionConflict, TicketRevisionUnsupported } from '../ports/tickets/revision'
 /**
  * The agent tool registry — one typed table that is the single source of
  * truth for the agent-facing operator surface (AUT-338).
@@ -58,6 +59,9 @@ import { answerAction, controlPrechecks, requireRouteBuild, RouteRefusalError }
 import { SandboxOperationError } from '../ports/workspace/operator-sandbox'
 import type { OperatorSandboxService } from './sandbox'
 import {
+  prepareOperatorTicketAssets,
+  listOperatorTicketStates,
+  createOperatorTicketState,
   getOperatorTicket,
   listOperatorTickets,
   mutateOperatorTicket,
@@ -598,7 +602,13 @@ export const TOOLS: readonly ToolEntry[] = [
         user: attributed(ctx),
         ...(ctx.via !== undefined ? { via: ctx.via } : {}),
         action,
-        ...(readTicketBody !== undefined ? { readTicketBody } : {}),
+        ...(readTicketBody !== undefined
+          ? {
+              readTicketBody,
+              prepareTicketAssets: (ref, store, repo) =>
+                prepareOperatorTicketAssets({ ref, store, repo, backend: ctx.tickets }),
+            }
+          : {}),
       })
     },
   ),
@@ -691,6 +701,30 @@ export const TOOLS: readonly ToolEntry[] = [
           })
     },
   ),
+  defineTool(
+    'tickets.states',
+    'List all ticket states with ticket counts and optional purposes.',
+    z.strictObject({ repo: z.string().min(1) }),
+    'Array of {name,tickets,about?}.',
+    async (raw, ctx) => {
+      const input = raw as { repo: string }
+      return listOperatorTicketStates({
+        store: ctx.store,
+        repo: input.repo,
+        backend: ticketsOf(ctx),
+      })
+    },
+  ),
+  defineTool(
+    'tickets.state.create',
+    'Create a custom ticket state with an optional one-line purpose. Hosted duplicates are refused.',
+    z.strictObject({ repo: z.string().min(1), name: z.string(), about: z.string().optional() }),
+    '{state: {name,tickets,about?},created}.',
+    async (raw, ctx) => {
+      const input = raw as { repo: string; name: string; about?: string }
+      return createOperatorTicketState({ store: ctx.store, backend: ticketsOf(ctx), ...input })
+    },
+  ),
   defineTool(
     'tickets.list',
     'List the repository’s ticket grooming queue from the configured ticket source.',
@@ -709,9 +743,9 @@ export const TOOLS: readonly ToolEntry[] = [
   ),
   defineTool(
     'tickets.get',
-    'Show one ticket with its blockers and any related build.',
+    'Show one ticket with its hosted comments, blockers and any related build.',
     ticketDetailInput,
-    '{ticket, blockers, build}: the ticket, its dependency states, and the most relevant build for it (null when none).',
+    '{ticket, blockers, build}: the ticket (including hosted ticket.comments when available), its dependency states, and the most relevant build for it (null when none).',
     async (raw, ctx) => {
       const input = raw as z.infer<typeof ticketDetailInput>
       return getOperatorTicket({
@@ -752,12 +786,12 @@ export const TOOLS: readonly ToolEntry[] = [
     '{ticket, blockers, build}: the updated ticket.',
     async (raw, ctx) => {
       const input = raw as z.infer<typeof ticketsUpdateInput>
-      const { repo, id, ...patch } = input
+      const { repo, id, expectedRevision, ...patch } = input
       return mutateOperatorTicket({
         store: ctx.store,
         repo,
         backend: ticketsOf(ctx),
-        operation: { kind: 'update', id, patch },
+        operation: { kind: 'update', id, patch, expectedRevision },
       })
     },
   ),
@@ -772,7 +806,12 @@ export const TOOLS: readonly ToolEntry[] = [
         store: ctx.store,
         repo: input.repo,
         backend: ticketsOf(ctx),
-        operation: { kind: 'block', id: input.id, blockerIds: input.blockerIds },
+        operation: {
+          kind: 'block',
+          id: input.id,
+          blockerIds: input.blockerIds,
+          expectedRevision: input.expectedRevision,
+        },
       })
     },
   ),
@@ -787,7 +826,12 @@ export const TOOLS: readonly ToolEntry[] = [
         store: ctx.store,
         repo: input.repo,
         backend: ticketsOf(ctx),
-        operation: { kind: 'unblock', id: input.id, blockerIds: input.blockerIds },
+        operation: {
+          kind: 'unblock',
+          id: input.id,
+          blockerIds: input.blockerIds,
+          expectedRevision: input.expectedRevision,
+        },
       })
     },
   ),
@@ -802,7 +846,12 @@ export const TOOLS: readonly ToolEntry[] = [
         store: ctx.store,
         repo: input.repo,
         backend: ticketsOf(ctx),
-        operation: { kind: 'move', id: input.id, state: input.state },
+        operation: {
+          kind: 'move',
+          id: input.id,
+          state: input.state,
+          expectedRevision: input.expectedRevision,
+        },
       })
     },
   ),
@@ -964,6 +1013,10 @@ function mapDomainError(error: unknown): RegistryError {
       error: error.refusal.error,
     })
   }
+  if (error instanceof TicketRevisionConflict)
+    return new RegistryError('domain', error.message, { kind: 'conflict', error: error.message })
+  if (error instanceof TicketRevisionUnsupported)
+    return new RegistryError('domain', error.message, { kind: 'refusal', error: error.message })
   if (error instanceof TicketOperationError) {
     return new RegistryError('domain', error.message, {
       kind: error.code === 'not-found' ? 'not-found' : 'refusal',

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

@@ -1,16 +1,4 @@
-/**
- * The route-level glue the operator HTTP server applies around the shared
- * services, re-derived for the agent tool registry (operator/registry.ts).
- *
- * This module is registry-owned on purpose: the operator API routes were
- * declared out of scope for the registry ticket, so the parity between a
- * tool and its route is *proven* by the contract suite
- * (packages/hosted-store-service/src/registry.contract.test.ts) rather than
- * obtained by extraction. Every refusal text here is load-bearing — it must
- * stay byte-identical to the hosted package's `operator-server.ts` so the
- * suite's full-body comparisons hold.
- */
-import { reduceBuild } from '../kernel/reducer'
+import { readBuildFacts } from '../store/reduced-reads'
 import { effectiveStatus } from '../cli/dashboard/model'
 import { BuildControlError, type BuildControlAction } from '../cli/build-control'
 import type { BuildStore } from '../store/types'
@@ -80,7 +68,7 @@ export async function controlPrechecks(
 ): Promise<void> {
   await requireRouteBuild(store, repo, slug)
   if (action === 'pause' || action === 'cancel-pause') {
-    const state = reduceBuild(await store.getEvents(slug))
+    const state = (await readBuildFacts(store, slug)).value.state
     const display = effectiveStatus(state)
     if (action === 'pause' && display === 'pausing') {
       throw new BuildControlError(

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

@@ -13,7 +13,6 @@
 import { createHash } from 'node:crypto'
 import { humanActor } from '../events/envelope'
 import type { Via } from '../events/envelope'
-import type { RepositoryEvent } from '../events/repository'
 import type { Forge } from '../ports/types'
 import {
   SANDBOX_FORBIDDEN_ENV,
@@ -23,8 +22,7 @@ import {
   type SandboxWaitResult,
 } from '../ports/workspace/operator-sandbox'
 import type { WorkspaceProvider } from '../ports/types'
-import { readRepoEventsIfRecorded } from '../processes/harvest'
-import { sandboxStates } from '../processes/sandbox-state'
+import { readRepositoryFacts } from '../store/reduced-reads'
 import { systemClock, type BuildStore, type Clock } from '../store/types'
 
 /** Hard bound on one sandbox command wait, in seconds — shared with the
@@ -253,8 +251,11 @@ export async function createOperatorSandboxService(
   }
 
   /** The operator's journal state, or undefined when no environment exists. */
-  const operatorState = (identity: string, events: RepositoryEvent[]) =>
-    sandboxStates(events)
+  const operatorState = (
+    identity: string,
+    events: import('../store/reduced-reads').RepositoryReadFacts,
+  ) =>
+    events.sandboxes
       .filter((state) => state.operator === identity && state.state !== 'released')
       .at(-1)
 
@@ -327,7 +328,7 @@ export async function createOperatorSandboxService(
   ): Promise<T> => {
     const key = `${repo}\0${identity}`
     return serialize(key, async () => {
-      const events = await readRepoEventsIfRecorded(store, repo)
+      const events = (await readRepositoryFacts(store, repo)).value
       const state = operatorState(identity, events)
       const resolved = await ensureWithFacts(identity, state).catch((error: unknown) => {
         if (error instanceof SandboxOperationError) throw error
@@ -337,7 +338,7 @@ export async function createOperatorSandboxService(
           { cause: error },
         )
       })
-      const freshEvents = await readRepoEventsIfRecorded(store, repo)
+      const freshEvents = (await readRepositoryFacts(store, repo)).value
       const freshState = operatorState(identity, freshEvents)
       try {
         const result = await operation(resolved, freshState)
@@ -630,7 +631,7 @@ export async function createOperatorSandboxService(
       requireRepo(input.repo)
       const key = `${repo}\0${identity}`
       await serialize(key, async () => {
-        const events = await readRepoEventsIfRecorded(store, repo)
+        const events = (await readRepositoryFacts(store, repo)).value
         const state = operatorState(identity, events)
         const resolved = await capability.describe({ repo, operator: identity })
         await append(identity, 'orchestrator.sandbox.reset', {
@@ -662,7 +663,7 @@ export async function createOperatorSandboxService(
       requireRepo(input.repo)
       const key = `${repo}\0${identity}`
       await serialize(key, async () => {
-        const events = await readRepoEventsIfRecorded(store, repo)
+        const events = (await readRepositoryFacts(store, repo)).value
         const state = operatorState(identity, events)
         // No environment ever provisioned: a no-op, with no fact and no
         // provider traffic beyond the pure describe.

package/packages/core/src/operator/ticket-source-backend.ts

@@ -1,3 +1,4 @@
+import { ticketLifecycle } from '../ports/tickets/lifecycle'
 /**
  * A dispatcher ticket source as the registry's ticket backend (AUT-342):
  * the tick's turn runner takes an `OperatorToolRegistry`, and
@@ -14,34 +15,29 @@ import type { Config } from '../config/schema'
 import type { OperatorTicketBackend, OperatorTicketContext } from './tickets'
 import type { TicketSource } from '../ports/types'
 
-/** The dispatcher's resolved triage state (the same default
- * `processes/dispatcher.ts` applies); inlined rather than imported so this
- * operator-seam module does not pull the dispatcher's module graph. */
-function defaultTriageState(config: Config): string {
-  return (
-    config.tickets.triageState ??
-    (config.tickets.source === 'linear' || config.tickets.source === 'hosted'
-      ? 'Backlog'
-      : 'Triage')
-  )
-}
-
 export function ticketBackendFromSource(options: {
   source: TicketSource
   config: Config
 }): OperatorTicketBackend {
   return {
     sourceFor: (_context: OperatorTicketContext) => options.source,
-    statesFor: (_context: OperatorTicketContext, _source: TicketSource): string[] => {
+    statesFor: async (_context: OperatorTicketContext, source: TicketSource): Promise<string[]> => {
+      if (source.listStates) return (await source.listStates()).map((s) => s.name)
       const tickets = options.config.tickets
-      const states = [
-        tickets.triageState ?? defaultTriageState(options.config),
-        tickets.readyState,
-        tickets.createState,
-        tickets.claimedState,
-        tickets.doneState,
-        tickets.proposalState ?? defaultTriageState(options.config),
-      ].filter((state): state is string => typeof state === 'string' && state.trim().length > 0)
+      const lifecycle = ticketLifecycle(tickets)
+      const states =
+        tickets.source === 'hosted'
+          ? Object.values(lifecycle)
+          : [
+              lifecycle.triage,
+              tickets.readyState,
+              tickets.createState,
+              tickets.claimedState,
+              tickets.doneState,
+              lifecycle.proposal,
+            ].filter(
+              (state): state is string => typeof state === 'string' && state.trim().length > 0,
+            )
       return [...new Set(states)]
     },
   }