@defrex/autobuild 0.12.0 → 0.14.0

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

@@ -1,6 +1,9 @@
+import { readBuildFacts } from '../store/reduced-reads'
+import { samplePinnedAssets, preparePinnedAssets } from '../store/ticket-assets'
+import type { TicketRef } from '../ontology'
 import type { Config } from '../config/schema'
-import { reduceBuild } from '../kernel/reducer'
 import {
+  TicketOperationError,
   changeBlockers,
   createTicket,
   moveTicket,
@@ -9,7 +12,7 @@ import {
 } from '../ports/tickets/operations'
 import type { DependencyState, Ticket, TicketSource, TicketUpdate } from '../ports/types'
 import type { BuildStore } from '../store/types'
-import { defaultTriageState } from '../processes/dispatcher'
+import { ticketLifecycle } from '../ports/tickets/lifecycle'
 import { effectiveConfig } from './query'
 
 export interface OperatorTicketContext {
@@ -21,6 +24,7 @@ export interface OperatorTicketContext {
 }
 
 export interface OperatorTicketBackend {
+  contextFor?(repo: string): Promise<OperatorTicketContext>
   sourceFor(context: OperatorTicketContext): TicketSource | Promise<TicketSource>
   statesFor(context: OperatorTicketContext, source: TicketSource): string[] | Promise<string[]>
 }
@@ -63,10 +67,11 @@ export async function openOperatorTickets(opts: {
   store: BuildStore
   repo: string
   backend: OperatorTicketBackend
-}): Promise<{ config: Config; context: OperatorTicketContext; source: TicketSource }> {
-  const { config } = await effectiveConfig(opts.store, opts.repo)
-  const context = contextFor(config, opts.repo)
-  return { config, context, source: await opts.backend.sourceFor(context) }
+}): Promise<{ context: OperatorTicketContext; source: TicketSource }> {
+  const context = opts.backend.contextFor
+    ? await opts.backend.contextFor(opts.repo)
+    : contextFor((await effectiveConfig(opts.store, opts.repo)).config, opts.repo)
+  return { context, source: await opts.backend.sourceFor(context) }
 }
 
 export async function listOperatorTickets(opts: {
@@ -76,9 +81,9 @@ export async function listOperatorTickets(opts: {
   state?: string
   labels?: string[]
 }): Promise<OperatorTicketQueue> {
-  const { config, context, source } = await openOperatorTickets(opts)
-  const triageState = defaultTriageState(config)
-  const readyState = config.tickets.readyState
+  const { context, source } = await openOperatorTickets(opts)
+  const triageState = ticketLifecycle(context.tickets).triage
+  const readyState = context.tickets.readyState
   // The operator surface is a grooming queue. Unlike the CLI's ticket list,
   // labels narrow the default state instead of replacing its lifecycle gate.
   const criteria = {
@@ -103,14 +108,40 @@ async function matchingBuild(
   store: BuildStore,
   repo: string,
   id: string,
+  source: TicketSource,
+  configuredSource: string,
 ): Promise<OperatorTicketBuild | null> {
-  const matches = (await store.listBuilds()).filter(
-    (record) => record.repo === repo && record.ticket?.id === id,
+  // The service's database adapter implements the externally named hosted source.
+  const hosted =
+    source.name === 'hosted' || (configuredSource === 'hosted' && source.name === 'database')
+  const candidates = (await store.listBuilds()).filter(
+    (record) =>
+      record.repo === repo &&
+      (record.ticket?.source === source.name || (hosted && record.ticket?.source === 'hosted')),
   )
+  const matches = candidates.filter((record) => record.ticket!.id === id)
+  // The service database store always projects current ids, even when there is
+  // no matching build. Only a hosted client over an unprojected legacy store
+  // needs fallback lookups; failure must not undo a mutation.
+  if (matches.length === 0 && source.name === 'hosted') {
+    const identities = new Map<string, string>()
+    try {
+      for (const record of candidates) {
+        const raw = record.ticket!.id
+        if (!identities.has(raw)) {
+          const ticket = await source.get(raw)
+          identities.set(raw, ticket?.ref.source === source.name ? ticket.ref.id : raw)
+        }
+        if (identities.get(raw) === id) matches.push(record)
+      }
+    } catch {
+      // Build association is optional presentation; keep the successful ticket result.
+    }
+  }
   const projected = await Promise.all(
     matches.map(async (record) => ({
       record,
-      state: reduceBuild(await store.getEvents(record.slug)),
+      state: (await readBuildFacts(store, record.slug)).value.state,
     })),
   )
   projected.sort((a, b) => {
@@ -136,10 +167,20 @@ export async function getOperatorTicket(opts: {
   backend: OperatorTicketBackend
   id: string
 }): Promise<OperatorTicketDetail> {
-  const { source } = await openOperatorTickets(opts)
+  const { source, context } = await openOperatorTickets(opts)
   const ticket = await requireTicket(source, opts.id)
   const blockers = await source.dependencyStates(ticket.blockedBy ?? [])
-  return { ticket, blockers, build: await matchingBuild(opts.store, opts.repo, opts.id) }
+  return {
+    ticket,
+    blockers,
+    build: await matchingBuild(
+      opts.store,
+      opts.repo,
+      ticket.ref.id,
+      source,
+      context.tickets.source,
+    ),
+  }
 }
 
 export async function mutateOperatorTicket(opts: {
@@ -155,21 +196,90 @@ export async function mutateOperatorTicket(opts: {
         state?: string
         blockedBy?: string[]
       }
-    | { kind: 'update'; id: string; patch: TicketUpdate }
-    | { kind: 'move'; id: string; state: string }
-    | { kind: 'block' | 'unblock'; id: string; blockerIds: string[] }
+    | { kind: 'update'; id: string; patch: TicketUpdate; expectedRevision?: string }
+    | { kind: 'move'; id: string; state: string; expectedRevision?: string }
+    | { kind: 'block' | 'unblock'; id: string; blockerIds: string[]; expectedRevision?: string }
 }): Promise<OperatorTicketDetail> {
-  const { source } = await openOperatorTickets(opts)
+  const { source, context } = await openOperatorTickets(opts)
   const operation = opts.operation
   if (operation.kind === 'update') await requireTicket(source, operation.id)
   const ticket =
     operation.kind === 'create'
       ? await createTicket(source, operation)
       : operation.kind === 'update'
-        ? (await updateTicket(source, operation.id, operation.patch))!
+        ? (await updateTicket(
+            source,
+            operation.id,
+            operation.patch,
+            true,
+            operation.expectedRevision,
+          ))!
         : operation.kind === 'move'
-          ? await moveTicket(source, operation.id, operation.state)
-          : await changeBlockers(source, operation.id, operation.blockerIds, operation.kind)
+          ? await moveTicket(source, operation.id, operation.state, operation.expectedRevision)
+          : await changeBlockers(
+              source,
+              operation.id,
+              operation.blockerIds,
+              operation.kind,
+              operation.expectedRevision,
+            )
   const blockers = await source.dependencyStates(ticket.blockedBy ?? [])
-  return { ticket, blockers, build: await matchingBuild(opts.store, opts.repo, ticket.ref.id) }
+  return {
+    ticket,
+    blockers,
+    build: await matchingBuild(
+      opts.store,
+      opts.repo,
+      ticket.ref.id,
+      source,
+      context.tickets.source,
+    ),
+  }
+}
+
+export async function prepareOperatorTicketAssets(opts: {
+  store: BuildStore
+  repo: string
+  backend?: OperatorTicketBackend
+  ref: TicketRef
+}) {
+  if (!opts.backend) {
+    if (opts.ref.source !== 'hosted') return samplePinnedAssets(opts.store, opts.repo, opts.ref.id)
+    throw new Error('ticket operator backend is not configured')
+  }
+  const { context, source } = await openOperatorTickets({ ...opts, backend: opts.backend })
+  if (context.tickets.source !== opts.ref.source)
+    throw new Error('build ticket source differs from configured source')
+  return preparePinnedAssets(source, opts.store, opts.repo, opts.ref.id)
+}
+
+export async function listOperatorTicketStates(opts: {
+  store: BuildStore
+  repo: string
+  backend: OperatorTicketBackend
+}) {
+  const { source } = await openOperatorTickets(opts)
+  if (!source.listStates)
+    throw new TicketOperationError('refusal', `state discovery is not supported by ${source.name}`)
+  return source.listStates()
+}
+
+export async function createOperatorTicketState(opts: {
+  store: BuildStore
+  repo: string
+  backend: OperatorTicketBackend
+  name: string
+  about?: string
+}) {
+  const { source } = await openOperatorTickets(opts)
+  if (!source.addState)
+    throw new TicketOperationError('refusal', `state creation is not supported by ${source.name}`)
+  try {
+    return await source.addState(opts.name, opts.about === undefined ? {} : { about: opts.about })
+  } catch (error) {
+    throw new TicketOperationError(
+      'refusal',
+      error instanceof Error ? error.message : String(error),
+    )
+  }
 }

package/packages/core/src/plugin-sdk/index.ts

@@ -152,6 +152,12 @@ export type {
 
 export { FakeTicketSource } from '../ports/tickets/fake'
 export { validateTicketUpdate } from '../ports/tickets/update'
+export {
+  TicketRevisionConflict,
+  TicketRevisionUnsupported,
+  ticketRevision,
+  checkTicketRevision,
+} from '../ports/tickets/revision'
 export { FakeWorkspaceProvider } from '../ports/workspace/fake'
 export { FakeForge } from '../ports/forge/fake'
 // ScriptContext + defaultTurnResult are the scripted fake's own API: the
@@ -223,3 +229,16 @@ export type {
   TicketAssetMeta,
   TicketAssetSummary,
 } from '../store/ticket-assets'
+
+export {
+  readReducerValue,
+  resolveReducerValue,
+  reducerValueRequestSchema,
+  reducerValueSchema,
+} from '../store/reducer-values'
+export type {
+  ReducerValue,
+  ReducerValueRequest,
+  ReducerValueStorage,
+  ValueCacheRow,
+} from '../store/reducer-values'

package/packages/core/src/plugins/runtimes.ts

@@ -40,7 +40,11 @@ export async function materializePluginRuntimes(
   const merged = Object.assign(Object.create(null) as RuntimeRegistry, builtins)
   const config = Object.freeze({})
   const env = Object.freeze(
-    Object.fromEntries(Object.entries(opts.env).filter(([key]) => key !== 'AB_TOKEN')),
+    Object.fromEntries(
+      Object.entries(opts.env).filter(
+        ([key]) => !['AB_TOKEN', 'AB_TICKET_TOKEN', 'AB_TICKET_URL'].includes(key),
+      ),
+    ),
   )
   const context: PluginFactoryContext = {
     config,

package/packages/core/src/ports/runner/session-env.ts

@@ -21,6 +21,8 @@ export function sessionEnv(
   for (const [key, value] of Object.entries(ambient)) {
     if (value !== undefined) env[key] = value
   }
+  delete env.AB_TICKET_TOKEN
+  delete env.AB_TICKET_URL
   delete env.AB_TOKEN
   Object.assign(env, scoped)
 

package/packages/core/src/ports/tickets/contract.ts

@@ -1,3 +1,4 @@
+import { updateTicket, moveTicket, changeBlockers } from './operations'
 import { describe, expect, test } from 'bun:test'
 import type {
   DependencyState,
@@ -116,6 +117,64 @@ export function describeTicketSourceContract(
   factory: TicketSourceContractFactory,
 ): void {
   describe(`TicketSource contract: ${name}`, () => {
+    test('revisions cover mutable content and guarded writes fail closed', async () => {
+      await withTicketSource(factory, async (harness) => {
+        const source = harness.source
+        const created = await createTracked(
+          harness,
+          { title: contractTicketTitle('revisions'), body: CONTRACT_TICKET_BODY },
+          { state: harness.states.ready },
+        )
+        const id = created.ref.id
+        expect(created.revision.trim()).not.toBe('')
+        expect((await source.get(id))?.revision).toBe(created.revision)
+        expect(
+          (await source.listReady({ state: harness.states.ready })).tickets.find(
+            (t) => t.ref.id === id,
+          )?.revision,
+        ).toBe(created.revision)
+        if (!source.mutateIfRevision) {
+          await expect(
+            updateTicket(source, id, { title: 'Never written' }, false, created.revision),
+          ).rejects.toThrow('does not support')
+          expect((await source.get(id))?.revision).toBe(created.revision)
+          return
+        }
+        let current = created
+        for (const patch of [
+          { title: contractTicketTitle('renamed') },
+          { body: 'Changed body' },
+          { labels: [harness.editableLabel] },
+        ]) {
+          await updateTicket(source, id, patch, false, current.revision)
+          const next = (await source.get(id))!
+          expect(next.revision).not.toBe(current.revision)
+          await expect(updateTicket(source, id, patch, false, current.revision)).rejects.toThrow(
+            'current revision',
+          )
+          expect(await source.get(id)).toEqual(next)
+          current = next
+        }
+        await moveTicket(source, id, harness.states.completed, current.revision)
+        const moved = (await source.get(id))!
+        expect(moved.revision).not.toBe(current.revision)
+        await expect(
+          moveTicket(source, id, harness.states.ready, current.revision),
+        ).rejects.toThrow('current revision')
+        const blocker = await createTracked(harness, {
+          title: contractTicketTitle('blocker'),
+          body: CONTRACT_TICKET_BODY,
+        })
+        await changeBlockers(source, id, [blocker.ref.id], 'block', moved.revision)
+        const blocked = (await source.get(id))!
+        expect(blocked.revision).not.toBe(moved.revision)
+        await expect(
+          changeBlockers(source, id, [blocker.ref.id], 'unblock', moved.revision),
+        ).rejects.toThrow('current revision')
+        await changeBlockers(source, id, [blocker.ref.id], 'unblock', blocked.revision)
+        expect((await source.get(id))?.revision).not.toBe(blocked.revision)
+      })
+    })
     test('completion projections agree across create, get, listing, and transitions', async () => {
       await withTicketSource(factory, async (harness) => {
         const created = await createTracked(
@@ -156,7 +215,13 @@ export function describeTicketSourceContract(
           state: harness.states.ready,
           labels: [],
         })
-        expect(await harness.source.get(created.ref.id)).toEqual(created)
+        const detail = await harness.source.get(created.ref.id)
+        expect(detail).not.toBeNull()
+        // Detail reads may expose structured history absent from write responses.
+        const { comments, ...record } = detail!
+        const { comments: createdComments, ...createdRecord } = created
+        expect(record).toEqual(createdRecord)
+        if (comments !== undefined) expect(comments).toEqual(createdComments ?? [])
       })
     })
 

package/packages/core/src/ports/tickets/create.ts

@@ -16,6 +16,8 @@ import type { TicketSource } from '../types'
 import { DEFAULT_TICKETS_DIR, FileTicketSource } from './file'
 import { LinearTicketSource } from './linear'
 import { HostedTicketSource } from './remote'
+import { ticketLifecycle } from './lifecycle'
+import { normalizeServiceURL } from '../../connection'
 
 function reason(error: unknown): string {
   return error instanceof Error ? error.message : String(error)
@@ -32,26 +34,41 @@ export async function createTicketSource(
   plugins: PluginRegistry = createPluginRegistry(),
 ): Promise<TicketSource> {
   if (config.source === 'hosted') {
-    const rawUrl = env.AB_STORE?.trim() || configuredStore(targetRepo)
+    const buildUrl = env.AB_STORE?.trim() || configuredStore(targetRepo)
+    const rawUrl = config.url ?? buildUrl
     if (!rawUrl) {
       throw new Error(
-        'AB_STORE is not set — required when [tickets].source = "hosted"; set it to the hosted service HTTP(S) URL',
+        'Hosted tickets require [tickets] url when builds are local; alternatively set [store] url or AB_STORE to a service',
       )
     }
     let serviceUrl: URL
     try {
-      serviceUrl = new URL(rawUrl)
+      serviceUrl = new URL(normalizeServiceURL(rawUrl, 'tickets.url'))
     } catch {
-      throw new Error('AB_STORE must be a valid HTTP(S) URL when [tickets].source = "hosted"')
-    }
-    if (serviceUrl.protocol !== 'http:' && serviceUrl.protocol !== 'https:') {
-      throw new Error('AB_STORE must be an HTTP(S) URL when [tickets].source = "hosted"')
+      throw new Error(
+        'Hosted tickets require [tickets] url when [store] url / AB_STORE selects local builds',
+      )
     }
-    const token = projectToken(
-      rawUrl,
-      (await resolveRepoOrigin(targetRepo, spawnExec)) ?? targetRepo,
-      env,
+    const ticketSession = env.AB_TICKET_TOKEN !== undefined || env.AB_TICKET_URL !== undefined
+    if (
+      ticketSession &&
+      (!env.AB_TICKET_TOKEN ||
+        !env.AB_TICKET_URL ||
+        normalizeServiceURL(env.AB_TICKET_URL) !== normalizeServiceURL(rawUrl))
     )
+      throw new Error('Ticket session credential does not match the selected ticket service')
+    const token = ticketSession
+      ? env.AB_TICKET_TOKEN
+      : projectToken(
+          rawUrl,
+          (await resolveRepoOrigin(targetRepo, spawnExec)) ?? targetRepo,
+          config.url &&
+            (!buildUrl ||
+              !/^https?:/.test(buildUrl) ||
+              normalizeServiceURL(config.url) !== normalizeServiceURL(buildUrl))
+            ? { ...env, AB_TOKEN: undefined }
+            : env,
+        )
     if (!token) {
       throw new Error(
         'No project credential; run ab connect (or set AB_TOKEN) — a project credential is required when [tickets].source = "hosted"',
@@ -60,13 +77,32 @@ export async function createTicketSource(
     if (config.teamKey === undefined) {
       throw new Error('[tickets].source = "hosted" requires teamKey')
     }
-    return new HostedTicketSource({
+    const source = new HostedTicketSource({
       url: serviceUrl.toString(),
       token,
       teamKey: config.teamKey,
       ...(config.claimedState !== undefined ? { claimedState: config.claimedState } : {}),
       ...(config.createState !== undefined ? { createState: config.createState } : {}),
     })
+    // Delegated sessions may read policy, but never redefine project authority.
+    if (!ticketSession && !env.AB_HARVEST && !env.AB_PHASE) {
+      const lifecycle = ticketLifecycle(config)
+      await source.synchronizePolicy({
+        version: 1,
+        tickets: {
+          source: 'hosted',
+          teamKey: config.teamKey,
+          readyState: lifecycle.ready,
+          triageState: lifecycle.triage,
+          claimedState: lifecycle.doing,
+          doneState: lifecycle.done,
+          createState: lifecycle.create,
+          proposalState: lifecycle.proposal,
+          ...(config.readyLabels !== undefined ? { readyLabels: config.readyLabels } : {}),
+        },
+      })
+    }
+    return source
   }
 
   if (config.source === 'linear') {

package/packages/core/src/ports/tickets/fake.ts

@@ -1,3 +1,5 @@
+import { fileRequestedIds } from './requested-id'
+import { ticketRevision, checkTicketRevision } from './revision'
 /**
  * In-memory TicketSource for seam tests (SPEC §3.2, §13). Mirrors the policy
  * shape of the real adapters: initiation (listReady/get/claim/create),
@@ -12,11 +14,13 @@ import type {
   TicketListing,
   TicketSource,
   TicketUpdate,
+  TicketMutation,
 } from '../types'
 import { validateTicketUpdate } from './update'
 
 function cloneTicket(ticket: Ticket, doneState: string): Ticket {
   return {
+    revision: ticketRevision(ticket),
     ref: { ...ticket.ref },
     ...(ticket.creationKey !== undefined ? { creationKey: ticket.creationKey } : {}),
     title: ticket.title,
@@ -29,6 +33,7 @@ function cloneTicket(ticket: Ticket, doneState: string): Ticket {
 }
 
 export class FakeTicketSource implements TicketSource {
+  readonly requestedIds = fileRequestedIds
   readonly name = 'fake'
 
   /** Journal of every projection sent outward (§13), in call order. */
@@ -111,6 +116,7 @@ export class FakeTicketSource implements TicketSource {
     const ticket = this.tickets.get(id)
     if (!ticket || ticket.state === this.doneState || this.claimed.has(id)) return false
     this.claimed.add(id)
+    ticket.state = 'Doing'
     return true
   }
 
@@ -131,8 +137,10 @@ export class FakeTicketSource implements TicketSource {
       const adopted = this.idempotency.get(opts.idempotencyKey)
       if (adopted !== undefined) return cloneTicket(this.require(adopted, 'create'), this.doneState)
     }
-    const id = `fake-${this.nextId++}`
+    const id = opts.requestedId ?? `fake-${this.nextId++}`
+    if (this.tickets.has(id)) throw new Error(`requested ticket id already occupied: ${id}`)
     const ticket: Ticket = {
+      revision: 'pending',
       ref: { source: this.name, id, title: draft.title },
       ...(opts.idempotencyKey !== undefined ? { creationKey: opts.idempotencyKey } : {}),
       title: draft.title,
@@ -153,6 +161,27 @@ export class FakeTicketSource implements TicketSource {
     return cloneTicket(ticket, this.doneState)
   }
 
+  async mutateIfRevision(id: string, expected: string, mutation: TicketMutation): Promise<void> {
+    const ticket = this.require(id, 'revision-checked write')
+    checkTicketRevision(cloneTicket(ticket, this.doneState), expected)
+    if (mutation.kind === 'update') await this.update(id, mutation.patch)
+    else if (mutation.kind === 'transition') await this.transition(id, mutation.state)
+    else {
+      for (const blocker of mutation.ids) {
+        this.require(blocker, 'blocker')
+        if (mutation.operation === 'block' && blocker === id)
+          throw new Error(`ticket "${id}" cannot block itself`)
+      }
+      // No await between validation and in-memory batch application.
+      const blockers = new Set(ticket.blockedBy ?? [])
+      for (const blocker of mutation.ids) {
+        if (mutation.operation === 'block') blockers.add(blocker)
+        else blockers.delete(blocker)
+      }
+      ticket.blockedBy = [...blockers]
+    }
+  }
+
   async update(id: string, patch: TicketUpdate): Promise<void> {
     const validated = validateTicketUpdate(patch)
     const ticket = this.require(id, 'update')