@defrex/autobuild 0.12.0 → 0.13.0

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

@@ -1,3 +1,4 @@
+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'
@@ -60,6 +61,7 @@ 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'] },

package/packages/core/src/ontology.ts

@@ -109,6 +109,7 @@ export const policyEscalationCauseSchema = z.enum([
   '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,
@@ -132,3 +135,5 @@ export {
   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/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,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)]
     },
   }

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

@@ -1,6 +1,9 @@
+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,10 +108,36 @@ 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,
@@ -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

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 ?? [])
       })
     })