@defrex/autobuild 0.8.0 → 0.10.0

package/packages/core/src/events/sessions.ts

@@ -24,24 +24,62 @@ const positiveInt = z.number().int().positive()
 
 const empty = z.strictObject({})
 
-/** The trigger that started a turn: a human message or a wake event. */
-const turnTriggerSchema = z.discriminatedUnion('kind', [
-  z.strictObject({ kind: z.literal('message'), messageSeq: positiveInt }),
-  z.strictObject({
+/** The trigger that started a turn: a human message or a wake event. A wake
+ * trigger names exactly one source — a build (the build-log attention scan)
+ * or the repository journal — enforced by the schema's `.check()` below even
+ * though the static type (one object with optional fields) cannot express it:
+ * a two-member union or a nested discriminated union is not a valid
+ * discriminated-union option on zod 4 (both constructions throw at first
+ * parse), so the wake variant stays a single object and call sites branch on
+ * `journal === true`. */
+const turnWakeTriggerSchema = z
+  .strictObject({
     kind: z.literal('wake'),
-    build: z.string().min(1),
+    build: z.string().min(1).optional(),
+    journal: z.literal(true).optional(),
     seq: positiveInt,
     type: z.string().min(1),
-  }),
+  })
+  .check((ctx) => {
+    const hasBuild = ctx.value.build !== undefined
+    const hasJournal = ctx.value.journal === true
+    if (hasBuild === hasJournal) {
+      ctx.issues.push({
+        code: 'custom',
+        input: ctx.value,
+        message: 'a wake trigger names exactly one of build or journal',
+      })
+    }
+  })
+
+const turnTriggerSchema = z.discriminatedUnion('kind', [
+  z.strictObject({ kind: z.literal('message'), messageSeq: positiveInt }),
+  turnWakeTriggerSchema,
 ])
 
-/** Matches the transcript usage shape (harvest.session.ended, §15.3). */
+/** Matches the transcript usage shape (harvest.session.ended, §15.3). The
+ * turn runner records the AI SDK's totalUsage token counts plus the step
+ * count. Old `turn.completed` events without `steps` still reduce. */
 const usageSchema = z.strictObject({
   inputTokens: z.number().int().nonnegative(),
   outputTokens: z.number().int().nonnegative(),
+  steps: z.number().int().nonnegative(),
   turns: z.number().int().nonnegative().optional(),
 })
 
+/** The typed model-failure vocabulary (AUT-342): provider availability,
+ * exhaustion, credentials, and configuration are distinguished so a failed
+ * turn's class is visible in the session's reduced state and nothing is ever
+ * retried unboundedly. `internal` covers non-model failures — the dispatcher
+ * tick's crash reaper among them. */
+const turnFailureKindSchema = z.enum([
+  'provider-unavailable',
+  'exhausted',
+  'credentials',
+  'configuration',
+  'internal',
+])
+
 export const sessionEventPayloadSchemas = {
   /** The fact of creation; the session record carries the same title. */
   'session.created': z.strictObject({ title: z.string().min(1).optional() }),
@@ -52,11 +90,27 @@ export const sessionEventPayloadSchemas = {
   'session.wake-set': z.strictObject({
     globs: z.array(z.string().min(1)).max(100),
   }),
-  /** The (later) turn runner's start of one turn on its stream. */
+  /** The (later turn runner's) start of one turn on its stream. A wake
+   * turn additionally carries the delivered input — the attention event
+   * record and, for a build wake, the build's reduced state, frozen at wake
+   * time — so a later invocation reconstructs the identical user message
+   * from durable state alone (live build state keeps moving; the frozen
+   * snapshot does not). A journal wake delivers the event record only. */
   'turn.started': z.strictObject({
     turn: z.string().min(1),
     stream: z.string().min(1),
     trigger: turnTriggerSchema,
+    wake: z
+      .strictObject({
+        event: z.strictObject({
+          seq: positiveInt,
+          ts: z.string().min(1),
+          type: z.string().min(1),
+          payload: z.record(z.string(), z.unknown()),
+        }),
+        buildState: z.record(z.string(), z.unknown()).optional(),
+      })
+      .optional(),
   }),
   /** A turn was suspended for budget or for an approval. */
   'turn.suspended': z.strictObject({
@@ -80,8 +134,13 @@ export const sessionEventPayloadSchemas = {
   }),
   /** One turn finished. */
   'turn.completed': z.strictObject({ turn: z.string().min(1), usage: usageSchema }),
-  /** One turn failed. */
-  'turn.failed': z.strictObject({ turn: z.string().min(1), error: z.string().min(1) }),
+  /** One turn failed: `kind` is the typed failure class, `error` the
+   * human-readable message surfaced in the session's reduced state. */
+  'turn.failed': z.strictObject({
+    turn: z.string().min(1),
+    kind: turnFailureKindSchema,
+    error: z.string().min(1),
+  }),
   /** Terminal. The session is read-only afterwards. */
   'session.archived': empty,
 } as const

package/packages/core/src/events/workspace-remote.ts

@@ -0,0 +1,12 @@
+import type { EventPayload } from './payloads'
+
+/** Whether the workspace this payload records publishes remotely, per the
+ * marker recorded at provision. Journals written before the marker existed
+ * fall back to the legacy provider-name reading — the only name comparison
+ * among the remote/local decisions (removed in AUT-505). */
+export function isRemoteWorkspace(
+  payload: Pick<EventPayload<'workspace.provisioned'>, 'provider' | 'remote'>,
+): boolean {
+  if (payload.remote !== undefined) return payload.remote
+  return payload.provider === 'vercel-sandbox'
+}

package/packages/core/src/integration/harness.ts

@@ -59,6 +59,13 @@ import { InProcessBuildExecution } from '../ports/workspace/in-process-build-exe
 import { BuildRunner, LeaseHeldError, SetupFailureError } from '../processes/build-runner'
 import { diagnosticArtifact } from '../processes/build-execution-state'
 import { Dispatcher, type LaunchRunnerResult } from '../processes/dispatcher'
+import {
+  getHarvestStatus,
+  getOperatorDashboard,
+  getRepositoryStatus,
+  listOperatorBuilds,
+} from '../operator/query'
+import { RepoViewStore } from '../processes/repo-view'
 import { MemoryBuildStore } from '../store/memory'
 import type { BuildStore } from '../store/types'
 import { steppingClock } from '../testing/fixed'
@@ -279,6 +286,106 @@ export interface E2eHarness {
   cleanup(): Promise<void>
 }
 
+/** The store with every reducer snapshot deleted: reads miss, writes no-op. */
+export function withoutSnapshots<T extends BuildStore>(store: T): T {
+  return new Proxy(store, {
+    get(target, key) {
+      if (key === 'getReducerSnapshot') return async () => null
+      if (key === 'putReducerSnapshot') return async () => false
+      const value = Reflect.get(target, key, target)
+      return typeof value === 'function' ? value.bind(target) : value
+    },
+  })
+}
+
+/** A build's facts with the publication view (closures) reduced to its answers. */
+async function plainFacts(view: RepoViewStore, slug: string) {
+  const { publication, ...rest } = await view.buildFacts(slug)
+  return {
+    ...rest,
+    publication: {
+      pending: publication.pending(),
+      abandoned: publication.abandonedPending(),
+      latest: publication.latestUncompletedRequest(),
+    },
+  }
+}
+
+/** JSON with sorted keys, so two structurally equal values compare equal. */
+function canonical(value: unknown): string {
+  return JSON.stringify(value, (_key, item) =>
+    item !== null && typeof item === 'object' && !Array.isArray(item)
+      ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a.localeCompare(b)))
+      : item,
+  )
+}
+
+async function repositoryReading(store: BuildStore, repo: string) {
+  const view = new RepoViewStore(store, { repo })
+  await view.refresh()
+  const slugs = (await view.listBuilds()).map((record) => record.slug).sort()
+  const builds: Record<string, unknown> = {}
+  for (const slug of slugs) {
+    builds[slug] = { facts: await plainFacts(view, slug), state: await view.buildState(slug) }
+  }
+  return {
+    journal: view.recordedJournal(),
+    digests: [...(await view.getRepoBuildDigests(repo)).entries()].sort(([a], [b]) =>
+      a.localeCompare(b),
+    ),
+    builds,
+    view,
+  }
+}
+
+/** Reducer snapshots are a cache the log regenerates (SPEC §7): whatever a
+ * scenario's dispatcher left behind, a cold view restored from it must read
+ * exactly what a cold view over a store with every snapshot deleted reads — and
+ * so must one restored from snapshots written at the final cursor. Run for
+ * every scenario at cleanup. */
+export async function assertSnapshotEquivalence(store: BuildStore, repo: string): Promise<void> {
+  const replayed = await repositoryReading(withoutSnapshots(store), repo)
+  for (const round of ['as left by the scenario', 'written at the final cursor']) {
+    const restored = await repositoryReading(store, repo)
+    const { view: restoredView, ...got } = restored
+    const { view: _replayedView, ...want } = replayed
+    if (canonical(got) !== canonical(want)) {
+      throw new Error(`snapshot-restored reading differs from full replay (${round})`)
+    }
+    await restoredView.persistSnapshots({ force: true })
+  }
+  // The operator routes derive from the same view: each response with
+  // snapshots present equals the response with every snapshot deleted.
+  const at = new Date('2026-01-01T00:00:00.000Z')
+  const routes = async (target: BuildStore) => {
+    const attempt = async (read: () => Promise<unknown>): Promise<unknown> => {
+      try {
+        return await read()
+      } catch (error) {
+        return { error: error instanceof Error ? error.message : String(error) }
+      }
+    }
+    return {
+      dashboard: await attempt(() =>
+        getOperatorDashboard({ store: target, repo, clock: () => at }),
+      ),
+      status: await attempt(() => getRepositoryStatus(target, repo)),
+      harvest: await attempt(() => getHarvestStatus(target, repo)),
+      lists: await Promise.all(
+        (['active', 'queued', 'all'] as const).map((scope) =>
+          attempt(() => listOperatorBuilds({ store: target, repo, scope, now: at })),
+        ),
+      ),
+    }
+  }
+  const replayedRoutes = canonical(await routes(withoutSnapshots(store)))
+  for (const round of ['as left', 'warmed by a first poll']) {
+    if (canonical(await routes(store)) !== replayedRoutes) {
+      throw new Error(`snapshot-backed operator routes differ from full replay (${round})`)
+    }
+  }
+}
+
 export async function makeHarness(opts: {
   handlers: SkillHandlers
   tickets?: Ticket[]
@@ -336,7 +443,11 @@ export async function makeHarness(opts: {
   const clock = steppingClock()
   const ids = sequentialIds()
   const uuids = sequentialUuids()
-  const store = new MemoryBuildStore({ clock })
+  // `AB_E2E_SNAPSHOTS=off` runs every scenario with every snapshot deleted, the
+  // other arm of the "snapshots change no observable output" proof.
+  const snapshotsOff = process.env.AB_E2E_SNAPSHOTS === 'off'
+  const memory = new MemoryBuildStore({ clock })
+  const store = snapshotsOff ? withoutSnapshots(memory) : memory
   const adapted = await opts.storeAdapter?.(store)
   const activeStore = adapted?.store ?? store
   const config = parseConfig(configToml, 'e2e autobuild.toml')
@@ -347,7 +458,8 @@ export async function makeHarness(opts: {
     gatePresence: opts.gatePresence ?? 'present',
     ...(opts.pluginForge?.prAttachments === true ? { prAttachments: true } : {}),
   })
-  let selectedForge: Forge = opts.localGitForge === true ? new LocalGitForge() : forge
+  let selectedForge: Forge =
+    opts.localGitForge === true ? new LocalGitForge({ repoRoot: origin }) : forge
   let plugins: PluginRegistry | undefined
   if (opts.pluginForge !== undefined) {
     plugins = createPluginRegistry()
@@ -611,6 +723,7 @@ export async function makeHarness(opts: {
     },
     events: (slug) => store.getEvents(slug),
     cleanup: async () => {
+      if (!snapshotsOff) await assertSnapshotEquivalence(store, origin)
       await activeStore.close()
       if (activeStore !== store) await store.close()
       await adapted?.cleanup?.()