@defrex/autobuild 0.11.0 → 0.13.0

package/packages/core/src/kernel/pr-summary.ts

@@ -0,0 +1,89 @@
+import { defineReducer } from './incremental'
+import type { AbEvent } from '../events/catalog'
+
+/** Latest completed occurrence only: never replay an obsolete publication backlog. */
+export const summaryBoundaryReducer = defineReducer<
+  {
+    occurrence?: number
+    boundary?: number
+    sessions: Record<string, true>
+  },
+  AbEvent,
+  { occurrence: number; boundary: number } | undefined
+>({
+  version: 1,
+  initial: () => ({ sessions: {} }),
+  fold(acc, events) {
+    for (const event of events) {
+      if (
+        [
+          'plan.started',
+          'plan-review.started',
+          'implement.started',
+          'code-review.started',
+          'verify.started',
+          'reconcile.started',
+          'finalize.started',
+          'finalize.step-started',
+        ].includes(event.type)
+      ) {
+        acc.occurrence = event.seq
+        delete acc.boundary
+      }
+      if (event.type === 'session.started') acc.sessions[event.payload.session] = true
+      if (event.type === 'session.ended') delete acc.sessions[event.payload.session]
+      if (
+        acc.occurrence !== undefined &&
+        (event.type === 'session.ended' ||
+          [
+            'plan.completed',
+            'plan-review.verdict',
+            'implement.completed',
+            'code-review.verdict',
+            'verify.completed',
+            'reconcile.completed',
+            'finalize.completed',
+            'finalize.step-completed',
+            'phase.failed',
+            'escalation.raised',
+            'publication.requested',
+          ].includes(event.type))
+      )
+        acc.boundary = event.seq
+    }
+  },
+  finish: (acc) =>
+    acc.occurrence !== undefined &&
+    acc.boundary !== undefined &&
+    Object.keys(acc.sessions).length === 0
+      ? { occurrence: acc.occurrence, boundary: acc.boundary }
+      : undefined,
+})
+
+export function summaryBoundary(events: readonly AbEvent[]) {
+  return summaryBoundaryReducer.reduce(events)
+}
+
+type SummaryRequest = Extract<AbEvent, { type: 'pr-summary.requested' }>
+export const summaryRequestsReducer = defineReducer<
+  {
+    requests: SummaryRequest[]
+    settled: number[]
+  },
+  AbEvent,
+  SummaryRequest[]
+>({
+  version: 1,
+  initial: () => ({ requests: [], settled: [] }),
+  fold(acc, events) {
+    for (const event of events) {
+      if (event.type === 'pr-summary.requested') acc.requests.push(event)
+      if (event.type === 'pr-summary.settled') acc.settled.push(event.payload.request)
+    }
+  },
+  finish: (acc) => acc.requests.filter((event) => !acc.settled.includes(event.seq)),
+})
+
+export function pendingSummaryRequests(events: readonly AbEvent[]) {
+  return summaryRequestsReducer.reduce(events)
+}

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

@@ -1,3 +1,6 @@
+import { executionNoProgressReducer } from '../processes/execution-no-progress'
+import { summaryBoundaryReducer, summaryRequestsReducer } from './pr-summary'
+import { dispatchFailureBudgetReducer } from '../processes/dispatch-failure-budget'
 import { ticketSourceHealthReducer } from './ticket-source-health'
 /**
  * Every incremental reducer, with its published version and the whole-array
@@ -58,6 +61,9 @@ export interface RegisteredReducer {
 /** Parameterized reducers are registered with representative arguments; the
  * accumulator shape does not depend on them. */
 export const REDUCERS: Record<string, RegisteredReducer> = {
+  executionNoProgress: { reducer: executionNoProgressReducer, covers: [] },
+  summaryBoundary: { reducer: summaryBoundaryReducer, covers: ['summaryBoundary'] },
+  summaryRequests: { reducer: summaryRequestsReducer, covers: ['pendingSummaryRequests'] },
   ticketSourceHealth: { reducer: ticketSourceHealthReducer, covers: ['reduceTicketSourceHealth'] },
   build: { reducer: buildReducer, covers: ['reduceBuild'] },
   harvest: { reducer: harvestReducer, covers: ['reduceHarvest'] },
@@ -97,6 +103,10 @@ export const REDUCERS: Record<string, RegisteredReducer> = {
     covers: ['openHarvestExecutions'],
   },
   openTick: { reducer: openTickReducer('run-a'), covers: ['hasOpenTick'] },
+  dispatchFailureBudget: {
+    reducer: dispatchFailureBudgetReducer(false),
+    covers: ['dispatchFailureBudget'],
+  },
   infrastructureFailureReset: {
     reducer: infrastructureFailureResetReducer,
     covers: ['infrastructureFailureResetSeq'],

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

@@ -113,6 +113,8 @@ export interface VerifyResult {
   attempt: number
   outcome: VerifyOutcome
   report?: ArtifactRef
+  /** Optional classification on kernel policy skips; historical skips omit it. */
+  skipCause?: 'post-reconcile-policy'
   /** Present exactly when `outcome === "skipped"`. */
   reason?: string
   /** seq of the `verify.completed` event — what `cycleSince` is compared to. */
@@ -457,6 +459,11 @@ function foldBuild(acc: BuildAcc, events: readonly AbEvent[]): void {
         break
       case 'workspace.provisioned':
       case 'workspace.released':
+      case 'pr-summary.requested':
+      case 'pr-summary.attempted':
+      case 'pr-summary.result':
+      case 'pr-summary.settled':
+      case 'finalize.step-started':
       case 'publication.requested':
       // Inert loss fact (AUT-328): the dispatcher released a workspace with a
       // pending publication. Recovery runs through the existing
@@ -689,6 +696,7 @@ function foldBuild(acc: BuildAcc, events: readonly AbEvent[]): void {
           outcome: result.outcome,
           report: result.report,
           ...(result.reason !== undefined ? { reason: result.reason } : {}),
+          ...(result.skipCause !== undefined ? { skipCause: result.skipCause } : {}),
           seq: event.seq,
         })
         if (verify.currentStep === result.step) {

package/packages/core/src/ontology.ts

@@ -108,6 +108,8 @@ export const policyEscalationCauseSchema = z.enum([
   'review-round-limit',
   'verify-failure-limit',
   'reconcile-no-progress',
+  'dispatch-failure-limit',
+  'execution-no-progress',
   'setup-failure-limit',
   'infrastructure-failure-limit',
   'phase-attempt-limit',

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

@@ -92,6 +92,18 @@ export const OPERATOR_TOOL_ANNOTATIONS = {
     idempotentHint: false,
     approval: 'default',
   },
+  'tickets.states': {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    approval: 'never',
+  },
+  'tickets.state.create': {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    approval: 'default',
+  },
   'tickets.list': {
     readOnlyHint: true,
     destructiveHint: false,

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

@@ -92,6 +92,9 @@ export type {
   OperatorTicketQueue,
 } from './tickets'
 export {
+  prepareOperatorTicketAssets,
+  listOperatorTicketStates,
+  createOperatorTicketState,
   getOperatorTicket,
   listOperatorTickets,
   mutateOperatorTicket,
@@ -125,3 +128,12 @@ 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'
+
+export {
+  effectiveConfig,
+  selectEffectiveConfig,
+  findEffectiveConfigRef,
+  decodeEffectiveConfig,
+} from './query'
+
+export { ticketStateCreateRequestSchema } from './protocol'

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

@@ -38,7 +38,7 @@ export type BuildListScope = 'active' | 'queued' | 'all'
 
 export class OperatorQueryError extends Error {
   constructor(
-    readonly code: 'not-found' | 'effective-config-unavailable',
+    readonly code: 'not-found' | 'effective-config-unavailable' | 'external-ticket-source',
     message: string,
   ) {
     super(message)
@@ -121,48 +121,70 @@ export async function effectiveConfig(
   status: ReturnType<typeof reduceDispatchStatus>
 }> {
   const repositoryEvents = journal ?? (await readRepoEventsIfRecorded(store, repo))
+  const status = selectEffectiveConfig(repositoryEvents, repo)
+  const ref = status.effectiveConfig!
+  const artifact = await store.getRepoArtifact(repo, ref.kind, ref.rev)
+  if (artifact === null) {
+    throw new OperatorQueryError(
+      'effective-config-unavailable',
+      `effective config ${ref.kind}@${ref.rev} is not retrievable`,
+    )
+  }
+  return {
+    config: decodeEffectiveConfig(artifact.content, `${ref.kind}@${ref.rev}`),
+    repositoryEvents,
+    status,
+  }
+}
+
+function latestDispatchConfigStatus(repositoryEvents: RepositoryEvent[]) {
   let latestRun: string | undefined
   for (const event of repositoryEvents) {
     if (event.type === 'dispatcher.run-started') latestRun = event.payload.run
   }
-  if (latestRun === undefined) {
+  return latestRun === undefined ? undefined : reduceDispatchStatus(repositoryEvents, latestRun)
+}
+
+/** Absence is distinct from a selected reference whose bytes cannot be read. */
+export function findEffectiveConfigRef(repositoryEvents: RepositoryEvent[]) {
+  return latestDispatchConfigStatus(repositoryEvents)?.effectiveConfig
+}
+
+export function selectEffectiveConfig(repositoryEvents: RepositoryEvent[], repo: string) {
+  const status = latestDispatchConfigStatus(repositoryEvents)
+  if (status === undefined) {
     throw new OperatorQueryError(
       'effective-config-unavailable',
       `effective config unavailable for repository "${repo}": no dispatcher run is recorded`,
     )
   }
-  const status = reduceDispatchStatus(repositoryEvents, latestRun)
-  const ref = status.effectiveConfig
-  if (ref === undefined) {
+  if (status.effectiveConfig === undefined) {
     throw new OperatorQueryError(
       'effective-config-unavailable',
       `effective config unavailable for repository "${repo}"`,
     )
   }
-  const artifact = await store.getRepoArtifact(repo, ref.kind, ref.rev)
-  if (artifact === null) {
-    throw new OperatorQueryError(
-      'effective-config-unavailable',
-      `effective config ${ref.kind}@${ref.rev} is not retrievable`,
-    )
-  }
+  return status
+}
+
+export function decodeEffectiveConfig(content: Uint8Array, label: string): Config {
   let raw: unknown
   try {
-    raw = JSON.parse(new TextDecoder().decode(artifact.content))
+    raw = JSON.parse(new TextDecoder().decode(content))
   } catch {
     throw new OperatorQueryError(
       'effective-config-unavailable',
-      `effective config ${ref.kind}@${ref.rev} is not valid JSON`,
+      `effective config ${label} is not valid JSON`,
     )
   }
   const parsed = configSchema.safeParse(raw)
   if (!parsed.success) {
     throw new OperatorQueryError(
       'effective-config-unavailable',
-      `effective config ${ref.kind}@${ref.rev} is invalid: ${parsed.error.message}`,
+      `effective config ${label} is invalid: ${parsed.error.message}`,
     )
   }
-  return { config: parsed.data, repositoryEvents, status }
+  return parsed.data
 }
 
 export interface OperatorBuildView {

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/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,33 +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.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)]
     },
   }