@defrex/autobuild 0.8.0 → 0.10.0

package/packages/core/src/kernel/generators/build-log.ts

@@ -0,0 +1,259 @@
+/** Seeded generated build logs for the incremental reducer property tests. */
+import { DISPATCHER, KERNEL, humanActor, type Actor } from '../../events/envelope'
+import {
+  validateEventWrite,
+  allowedActorKinds,
+  type AbEvent,
+  type EventWrite,
+} from '../../events/catalog'
+import type { EventType } from '../../events/payloads'
+import { steppingClock } from '../../testing/fixed'
+import { pick, seededRandom } from '../incremental-contract'
+
+function actorFor(type: EventType): Actor {
+  switch (allowedActorKinds[type][0]) {
+    case 'kernel':
+      return KERNEL
+    case 'dispatcher':
+      return DISPATCHER
+    case 'human':
+      return humanActor('aron')
+    case 'agent':
+      return { kind: 'agent', role: 'test-role', session: 's_test' }
+    default:
+      return { kind: 'ingester', source: 'test' }
+  }
+}
+
+const w = (type: EventType, payload: Record<string, unknown>): EventWrite =>
+  validateEventWrite({ actor: actorFor(type), type, payload } as EventWrite)
+
+const SHA = 'a'.repeat(40)
+const ART = (kind: string, rev: number) => ({ kind, rev })
+
+/** Plausible payload templates drawn from the catalog; ids and rounds come
+ * from small pools so correlations (escalations, sessions, rounds) happen. */
+function randomWrite(rand: () => number): EventWrite {
+  const round = 1 + Math.floor(rand() * 3)
+  const attempt = 1 + Math.floor(rand() * 3)
+  const id = pick(rand, ['e_1', 'e_2', 'e_3'])
+  const session = pick(rand, ['s_a', 's_b'])
+  const step = pick(rand, ['types', 'unit'])
+  const templates: Array<() => EventWrite> = [
+    () => w('runner.attached', { instance: 'runner-1', host: 'local' }),
+    () => w('spec.imported', { artifact: ART('spec', 0), ticket: { source: 'linear', id: 'E-1' } }),
+    () => w('spec.revised', { artifact: ART('spec', round), escalation: 1 }),
+    () => w('plan.started', { round }),
+    () => w('plan.completed', { round, artifact: ART('plan', round) }),
+    () => w('plan-review.started', { round }),
+    () =>
+      w('plan-review.verdict', {
+        round,
+        verdict: pick(rand, ['approve', 'revise'] as const),
+        findings: [],
+        artifact: ART('plan-review', round),
+      }),
+    () => w('implement.started', { round }),
+    () =>
+      w('implement.completed', {
+        round,
+        commits: { base: 'b', head: `h${round}` },
+        artifact: ART('implement-notes', round),
+      }),
+    () => w('code-review.started', { round }),
+    () =>
+      w('code-review.verdict', {
+        round,
+        verdict: pick(rand, ['approve', 'revise'] as const),
+        findings: [],
+        artifact: ART('code-review', round),
+      }),
+    () => w('verify.started', { step, attempt }),
+    () => w('verify.completed', { step, attempt, pass: rand() < 0.5 }),
+    () => w('finalize.started', {}),
+    () =>
+      w('finalize.completed', {
+        pr: { number: 7, url: 'https://github.com/o/r/pull/7', headSha: 'h' },
+      }),
+    () => w('finalize.step-completed', { step: 'notes', ok: rand() < 0.5 }),
+    () => w('pr.conflicted', { baseSha: 'm' }),
+    () => w('reconcile.started', { attempt, baseSha: 'm' }),
+    () =>
+      w('reconcile.completed', { mergeCommit: 'mc', artifact: ART('reconcile-notes', attempt) }),
+    () => w('pr.merged', { sha: 's' }),
+    () => w('build.completed', { outcome: 'merged' }),
+    () => w('build.pause-requested', {}),
+    () => w('build.resume-requested', {}),
+    () => w('build.paused', {}),
+    () => w('build.resumed', {}),
+    () => w('build.abort-requested', {}),
+    () => w('build.aborted', {}),
+    () => w('build.auto-merge-requested', {}),
+    () => w('build.auto-merge-cancelled', {}),
+    () => w('pr.auto-merge-enabled', { commandSeq: 1 }),
+    () =>
+      w('escalation.raised', {
+        id,
+        phase: pick(rand, ['plan', 'implement', 'plan-review'] as const),
+        source: 'agent',
+        question: 'q',
+      }),
+    () =>
+      w('escalation.answered', {
+        id,
+        answer: 'a',
+        resolution: pick(rand, ['guidance', 'abort', 'retry'] as const),
+      }),
+    () =>
+      w('session.started', {
+        session,
+        role: 'plan',
+        runner: 'claude',
+        phase: 'plan',
+        round,
+      }),
+    () =>
+      w('session.ended', {
+        session,
+        transcript: ART('transcript', 0),
+        usage: { inputTokens: 1, outputTokens: 1, turns: 1 },
+      }),
+    () =>
+      w('observation.recorded', { id: `o_${round}`, kind: 'refactor', summary: 's', files: [] }),
+    () => w('phase.failed', { phase: 'plan', round, attempt, error: 'x', willRetry: true }),
+    () => w('dispatch.failed', { stage: 'workspace', attempt, error: 'offline' }),
+    () => w('execution.started', { provider: 'p', workspaceRef: 'w', instance: 'i' }),
+    () => w('execution.ended', { instance: 'i', workspaceRef: 'w', outcome: 'completed' }),
+    () =>
+      w('infrastructure.failed', {
+        provider: 'p',
+        workspaceRef: 'w',
+        instance: 'i',
+        operation: 'wait',
+        cause: 'timeout',
+        attempt,
+        retryable: true,
+        cleanupPending: false,
+        error: 'x',
+      }),
+    () =>
+      w('infrastructure.cleanup-attempted', {
+        provider: 'p',
+        workspaceRef: 'w',
+        operation: 'stop',
+        attempt,
+        outcome: 'confirmed',
+      }),
+    () => w('runner.setup-failed', { command: 'bun install', attempt, exitStatus: 1, output: 'x' }),
+    () => w('build.discard-requested', {}),
+    () =>
+      w('escalation.raised', {
+        id,
+        phase: 'plan',
+        source: 'policy',
+        policyCause: 'infrastructure-failure-limit',
+        question: 'q',
+      }),
+    () =>
+      w('workspace.provision-started', { provider: 'worktree', branch: 'ab/x', generation: round }),
+    () =>
+      w('workspace.provisioned', {
+        provider: 'worktree',
+        ref: `/ws/${round}`,
+        branch: 'ab/x',
+        base: { source: 'remote', sha: `base${round}` },
+        ...(rand() < 0.5 ? { remote: true } : {}),
+      }),
+    () => w('workspace.released', rand() < 0.5 ? {} : { ref: '/ws/1', reason: 'completion' }),
+    () =>
+      w('publication.requested', {
+        operation: 'implement',
+        branch: 'ab/x',
+        sha: SHA,
+        round,
+        base: SHA,
+        artifact: ART('implement-notes', round),
+      }),
+    () =>
+      w('publication.requested', {
+        operation: 'reconcile',
+        branch: 'ab/x',
+        sha: SHA,
+        artifact: ART('reconcile-notes', round),
+      }),
+    () =>
+      w('publication.lost', {
+        request: round,
+        operation: 'implement',
+        branch: 'ab/x',
+        sha: SHA,
+        reason: 'released',
+      }),
+    () =>
+      w('pr-attachment.designated', {
+        artifact: ART('screenshot', round),
+        filename: `shot${round}.png`,
+        mediaType: 'image/png',
+      }),
+    () =>
+      w('pr-attachment.hosted', {
+        designationSeq: 1 + Math.floor(rand() * 20),
+        asset: {
+          provider: 'github-release',
+          repository: 'o/r',
+          releaseId: round,
+          assetId: attempt,
+          url: 'https://example.com/a.png',
+        },
+      }),
+    () => w('pr-attachment.reclaimed', { hostedSeq: 1 + Math.floor(rand() * 20) }),
+    () => w('build.auto-merge-default-observed', { defaultSeq: round }),
+    () =>
+      w('observation.recorded', {
+        id: `o_d${round}`,
+        kind: 'followup',
+        summary: 'deferred',
+        files: [],
+        refs: [`auto-merge-gate:pr:7:${round}`],
+      }),
+    () =>
+      w('spec.revised', {
+        artifact: ART('spec', round),
+        escalation: 1,
+        assets: [
+          {
+            kind: 'design',
+            name: 'a',
+            revision: round,
+            layout: 'file',
+            size: 1,
+            fileCount: 1,
+            dirCount: 0,
+          },
+        ],
+      }),
+  ]
+  return pick(rand, templates)()
+}
+
+export function randomBuildLog(seed: number, length: number): AbEvent[] {
+  const rand = seededRandom(seed)
+  const clock = steppingClock()
+  const created = w('build.created', {
+    ticket: { source: 'linear', id: 'E-1', title: 't' },
+    repo: 'o/r',
+    baseBranch: 'main',
+  })
+  const writes = [created, ...Array.from({ length }, () => randomWrite(rand))]
+  return writes.map(
+    (write, index) =>
+      ({
+        build: 'gen',
+        seq: index + 1,
+        ts: clock().toISOString(),
+        actor: write.actor,
+        type: write.type,
+        payload: write.payload,
+      }) as AbEvent,
+  )
+}

package/packages/core/src/kernel/generators/repository-journals.ts

@@ -0,0 +1,206 @@
+/** Seeded generated repository journals for the incremental reducer property tests. */
+import { DISPATCHER, KERNEL, humanActor } from '../../events/envelope'
+import type { RepositoryEvent } from '../../events/repository'
+import { pick, seededRandom } from '../incremental-contract'
+
+type Spec = { type: string; payload: Record<string, unknown>; actor?: RepositoryEvent['actor'] }
+
+function toJournal(specs: Spec[], shuffleTs = false): RepositoryEvent[] {
+  return specs.map(
+    (spec, index) =>
+      ({
+        repo: 'acme/repo',
+        seq: index + 1,
+        ts: new Date(
+          Date.UTC(2026, 0, 1, 0, 0, shuffleTs ? (index * 7) % 13 : index),
+        ).toISOString(),
+        actor: spec.actor ?? KERNEL,
+        type: spec.type,
+        payload: spec.payload,
+      }) as RepositoryEvent,
+  )
+}
+
+/** Valid harvest lifecycles only (the reducer throws on dangling references):
+ * runs start one at a time with fresh observations; pause/resume facts and
+ * failures interleave while a run is open. */
+export function randomHarvestJournal(seed: number, length: number): RepositoryEvent[] {
+  const rand = seededRandom(seed)
+  const specs: Spec[] = []
+  let runNo = 0
+  let open: { run: string; obs: Array<{ build: string; seq: number }> } | undefined
+  let parked = false
+  for (let i = 0; i < length; i++) {
+    const r = rand()
+    if (open === undefined) {
+      runNo += 1
+      const obs = [{ build: `b${runNo}`, seq: 1 }]
+      open = { run: `h_${runNo}`, obs }
+      parked = false
+      specs.push({
+        type: 'harvest.started',
+        payload: { run: open.run, observations: obs, scan: { kind: 'harvest-scan', rev: runNo } },
+      })
+      continue
+    }
+    if (r < 0.15) {
+      specs.push({ type: 'harvest.pause-requested', payload: {}, actor: humanActor('aron') })
+    } else if (r < 0.25) {
+      specs.push({ type: 'harvest.resume-requested', payload: {}, actor: humanActor('aron') })
+    } else if (r < 0.35) {
+      specs.push({ type: 'harvest.paused', payload: {} })
+    } else if (r < 0.5) {
+      specs.push({ type: 'harvest.resumed', payload: {} })
+      parked = false
+    } else if (r < 0.7 && !parked) {
+      const willRetry = rand() < 0.5
+      specs.push({
+        type: 'harvest.failed',
+        payload: { run: open.run, step: 'file', attempt: 1, error: 'boom', willRetry },
+      })
+      if (!willRetry) parked = true
+    } else if (r < 0.8 && !parked) {
+      specs.push({
+        type: 'harvest.completed',
+        payload: {
+          run: open.run,
+          dispositions: [
+            { occurrence: open.obs[0], action: 'suppressed', proposalKey: `k${runNo}` },
+          ],
+          report: { kind: 'harvest-report', rev: runNo },
+        },
+      })
+      open = undefined
+    } else if (r < 0.9 && !parked) {
+      specs.push({
+        type: 'harvest.escalated',
+        payload: { run: open.run, source: 'agent', reason: 'judgment', observations: open.obs },
+      })
+      open = undefined
+    } else if (r < 0.95) {
+      const execution = `x${i % 3}`
+      specs.push(
+        rand() < 0.6
+          ? {
+              type: 'harvest.execution.started',
+              payload: { execution, provider: 'vercel', environmentId: 'env', sessionId: 's' },
+              actor: DISPATCHER,
+            }
+          : {
+              type: 'harvest.execution.released',
+              payload: { execution, environmentId: 'env', snapshots: { outcome: 'confirmed' } },
+              actor: DISPATCHER,
+            },
+      )
+    } else {
+      specs.push({
+        type: 'dispatcher.intake-set',
+        payload: { enabled: rand() < 0.5 },
+        actor: DISPATCHER,
+      })
+    }
+  }
+  return toJournal(specs)
+}
+
+export function randomSettingsJournal(seed: number, length: number): RepositoryEvent[] {
+  const rand = seededRandom(seed)
+  const specs: Spec[] = Array.from({ length }, () => ({
+    type: pick(rand, [
+      'dispatcher.intake-set',
+      'dispatcher.pause-set',
+      'dispatcher.auto-merge-default-set',
+      'harvest.paused',
+    ]),
+    payload: { enabled: rand() < 0.5 },
+    actor: humanActor('aron'),
+  }))
+  return toJournal(specs)
+}
+
+const counters = {
+  claimed: 0,
+  launched: 0,
+  merged: 0,
+  closed: 0,
+  conflicted: 0,
+  reconciled: 0,
+  harvestStarted: 0,
+  harvestCompleted: 0,
+  harvestEscalated: 0,
+  harvestFailed: 0,
+}
+
+export function randomStatusJournal(seed: number, length: number): RepositoryEvent[] {
+  const rand = seededRandom(seed)
+  const specs: Spec[] = []
+  for (let i = 0; i < length; i++) {
+    const run = pick(rand, ['run-a', 'run-b'])
+    const templates: Array<() => Spec> = [
+      () => ({
+        type: 'dispatcher.run-started',
+        payload: {
+          run,
+          pid: 100,
+          effectiveConfig: { kind: 'dispatcher-effective-config', rev: i },
+          roleWarnings: ['w'],
+        },
+      }),
+      () => ({
+        type: 'dispatcher.tick-completed',
+        payload: {
+          run,
+          queued: i,
+          counters: { ...counters, creationWithheld: 1 },
+          janitorDiagnostics: ['j'],
+          ticketDiagnostics: [],
+          dependencyDiagnostics: [],
+        },
+      }),
+      () => ({ type: 'dispatcher.tick-failed', payload: { run, error: 'e' } }),
+      () => ({ type: 'dispatcher.tick-started', payload: { run } }),
+      () => ({ type: 'dispatcher.config-rejected', payload: { run, error: 'bad' } }),
+      () => ({
+        type: 'dispatcher.operator-reported',
+        payload: { run, level: pick(rand, ['info', 'warning']), message: 'm' },
+      }),
+      () => ({ type: 'dispatcher.upgrade-available', payload: { run, version: '1.0.0' } }),
+      () => ({
+        type: 'dispatcher.run-stopped',
+        payload: { run, outcome: pick(rand, ['normal', 'abnormal']) },
+      }),
+    ]
+    specs.push({ ...pick(rand, templates)(), actor: DISPATCHER })
+  }
+  return toJournal(specs)
+}
+
+export function randomSandboxJournal(seed: number, length: number): RepositoryEvent[] {
+  const rand = seededRandom(seed)
+  const specs: Spec[] = []
+  for (let i = 0; i < length; i++) {
+    const base = { operator: 'op', environmentId: pick(rand, ['env_1', 'env_2']) }
+    const templates: Array<() => Spec> = [
+      () => ({
+        type: 'orchestrator.sandbox.provisioned',
+        payload: {
+          ...base,
+          provider: 'vercel',
+          workspacePath: '/w',
+          ...(rand() < 0.5 ? { sessionId: 's' } : {}),
+        },
+      }),
+      () => ({ type: 'orchestrator.sandbox.resumed', payload: { ...base, provider: 'vercel' } }),
+      () => ({ type: 'orchestrator.sandbox.activity', payload: base }),
+      () => ({ type: 'orchestrator.sandbox.stopped', payload: { ...base, reason: 'idle' } }),
+      () => ({ type: 'orchestrator.sandbox.reset', payload: base }),
+      () => ({
+        type: 'orchestrator.sandbox.released',
+        payload: { ...base, snapshots: { outcome: 'confirmed' } },
+      }),
+    ]
+    specs.push({ ...pick(rand, templates)(), actor: DISPATCHER })
+  }
+  // Non-monotonic timestamps exercise the `lastEvidenceTs <= ts` guards.
+  return toJournal(specs, true)
+}

package/packages/core/src/kernel/generators/session-log.ts

@@ -0,0 +1,72 @@
+/** Seeded generated session logs, with `session.archived` optionally mid-log. */
+import { agentActor, humanActor } from '../../events/envelope'
+import type { SessionEvent } from '../../events/sessions'
+import { pick, seededRandom } from '../incremental-contract'
+
+type Spec = { type: SessionEvent['type']; payload: Record<string, unknown>; human?: boolean }
+
+export function randomSessionLog(seed: number, length: number, archive: boolean): SessionEvent[] {
+  const rand = seededRandom(seed)
+  const specs: Spec[] = [{ type: 'session.created', payload: {}, human: true }]
+  for (let i = 0; i < length; i++) {
+    const turn = pick(rand, ['t1', 't2', 't3'])
+    const toolCallId = pick(rand, ['c1', 'c2'])
+    const templates: Spec[] = [
+      { type: 'message.posted', payload: { text: 'hi' }, human: true },
+      {
+        type: 'session.wake-set',
+        payload: { globs: [pick(rand, ['a*', 'b*', 'c*'])] },
+        human: true,
+      },
+      {
+        type: 'turn.started',
+        payload: {
+          turn,
+          stream: `st_${turn}`,
+          trigger: pick(rand, [
+            { kind: 'message', messageSeq: 1 },
+            {
+              kind: 'wake',
+              build: pick(rand, ['b1', 'b2']),
+              seq: 1 + Math.floor(rand() * 9),
+              type: 'x',
+            },
+            { kind: 'wake', journal: true, seq: 1 + Math.floor(rand() * 9), type: 'x' },
+          ]),
+        },
+      },
+      { type: 'turn.suspended', payload: { turn, cause: pick(rand, ['budget', 'approval']) } },
+      { type: 'turn.resumed', payload: { turn } },
+      {
+        type: 'approval.requested',
+        payload: { turn, toolCallId, toolName: 'tool', input: { a: 1 } },
+      },
+      {
+        type: 'approval.answered',
+        payload: { turn, toolCallId, decision: 'approve' },
+        human: true,
+      },
+      {
+        type: 'turn.completed',
+        payload: { turn, usage: { inputTokens: 1, outputTokens: 2, steps: 3 } },
+      },
+      { type: 'turn.failed', payload: { turn, kind: 'internal', error: 'boom' } },
+    ]
+    specs.push(pick(rand, templates))
+  }
+  if (archive) {
+    const at = 1 + Math.floor(rand() * specs.length)
+    specs.splice(at, 0, { type: 'session.archived', payload: {}, human: true })
+  }
+  return specs.map(
+    (spec, index) =>
+      ({
+        session: 's_1',
+        seq: index + 1,
+        ts: new Date(Date.UTC(2026, 0, 1, 0, 0, index)).toISOString(),
+        actor: spec.human ? humanActor('aron') : agentActor('orchestrator', 's_a'),
+        type: spec.type,
+        payload: spec.payload,
+      }) as unknown as SessionEvent,
+  )
+}

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

@@ -15,6 +15,7 @@ import {
   type HarvestTrigger,
   type OccurrenceKey,
 } from '../harvest/schema'
+import { defineReducer, type IncrementalReducer } from './incremental'
 
 export interface HarvestStepOccurrence {
   step: HarvestStep
@@ -184,21 +185,35 @@ function requireRun(
   return state
 }
 
-/** Total for valid journals; malformed cross-event references throw loudly so
- * storage corruption cannot masquerade as an idle harvester. */
-export function reduceHarvest(events: readonly RepositoryEvent[]): HarvestState {
-  const runs = new Map<string, HarvestRunState>()
-  const order: HarvestRunState[] = []
-  const claimed = new Map<string, { occurrence: OccurrenceKey; run: string }>()
-  const ledger: HarvestLedgerEntry[] = []
-  const pending: Record<HarvestPendingCommand['command'], HarvestPendingCommand[]> = {
-    pause: [],
-    resume: [],
-  }
-  let paused = false
-  let pausedSeq: number | undefined
-  let pausedAt: string | undefined
-  let lastSeq = 0
+/** The carried accumulator for `reduceHarvest`: `runs` in start order, and
+ * `claimed` as `Map`-insertion-ordered entries keyed by occurrence id. The
+ * public `latest` aliases the last run and is rebuilt by `finish`. */
+export interface HarvestAcc {
+  runs: HarvestRunState[]
+  claimed: Array<{ key: string; occurrence: OccurrenceKey; run: string }>
+  ledger: HarvestLedgerEntry[]
+  pending: Record<HarvestPendingCommand['command'], HarvestPendingCommand[]>
+  paused: boolean
+  pausedSeq?: number
+  pausedAt?: string
+  lastSeq: number
+}
+
+/** Bump when `HarvestAcc`'s shape or fold semantics change. */
+export const HARVEST_REDUCER_VERSION = 1
+
+function foldHarvest(acc: HarvestAcc, events: readonly RepositoryEvent[]): void {
+  const order = acc.runs
+  const runs = new Map(order.map((run) => [run.run, run]))
+  const claimed = new Map(
+    acc.claimed.map((entry) => [entry.key, { occurrence: entry.occurrence, run: entry.run }]),
+  )
+  const ledger = acc.ledger
+  const pending = acc.pending
+  let paused = acc.paused
+  let pausedSeq = acc.pausedSeq
+  let pausedAt = acc.pausedAt
+  let lastSeq = acc.lastSeq
 
   for (const event of events) {
     lastSeq = Math.max(lastSeq, event.seq)
@@ -638,9 +653,17 @@ export function reduceHarvest(events: readonly RepositoryEvent[]): HarvestState
         break
     }
   }
+  acc.claimed = [...claimed].map(([key, { occurrence, run }]) => ({ key, occurrence, run }))
+  acc.paused = paused
+  acc.pausedSeq = pausedSeq
+  acc.pausedAt = pausedAt
+  acc.lastSeq = lastSeq
+}
 
+function finishHarvest(acc: HarvestAcc): HarvestState {
+  const { runs: order, paused, pausedSeq, pausedAt, pending } = acc
   const state: HarvestState = {
-    lastSeq,
+    lastSeq: acc.lastSeq,
     runs: order,
     paused,
     ...(pausedSeq !== undefined ? { pausedSeq } : {}),
@@ -648,14 +671,35 @@ export function reduceHarvest(events: readonly RepositoryEvent[]): HarvestState
     pendingCommands: [...pending.pause, ...pending.resume].sort(
       (left, right) => left.seq - right.seq,
     ),
-    claimed: [...claimed.values()].map(({ occurrence }) => occurrence),
-    ledger,
+    claimed: acc.claimed.map(({ occurrence }) => occurrence),
+    ledger: acc.ledger,
   }
   const latest = order.at(-1)
   if (latest !== undefined) state.latest = latest
   return state
 }
 
+export const harvestReducer: IncrementalReducer<HarvestAcc, RepositoryEvent, HarvestState> =
+  defineReducer({
+    version: HARVEST_REDUCER_VERSION,
+    initial: (): HarvestAcc => ({
+      runs: [],
+      claimed: [],
+      ledger: [],
+      pending: { pause: [], resume: [] },
+      paused: false,
+      lastSeq: 0,
+    }),
+    fold: foldHarvest,
+    finish: finishHarvest,
+  })
+
+/** Total for valid journals; malformed cross-event references throw loudly so
+ * storage corruption cannot masquerade as an idle harvester. */
+export function reduceHarvest(events: readonly RepositoryEvent[]): HarvestState {
+  return harvestReducer.reduce(events)
+}
+
 export function claimedOccurrenceKeys(state: HarvestState): Set<string> {
   return new Set(state.claimed.map(occurrenceKey))
 }