@defrex/autobuild 0.8.0 → 0.10.0

package/packages/core/src/processes/build-runner.ts

@@ -48,8 +48,10 @@ import type { Config } from '../config/schema'
 import type { AbEvent, EventWrite } from '../events/catalog'
 import type { EventPayload } from '../events/payloads'
 import { KERNEL, agentActor, type Actor } from '../events/envelope'
+import { isRemoteWorkspace } from '../events/workspace-remote'
 import type { IdSource } from '../ids'
 import { decideNext, type Decision } from '../kernel/engine'
+import { defineReducer } from '../kernel/incremental'
 import { PHASE_SPECS } from '../kernel/phases'
 import { reduceBuild, type BuildState } from '../kernel/reducer'
 import { evaluateVerifyApplicability } from '../kernel/verify-applicability'
@@ -240,6 +242,12 @@ interface SessionSpec {
 /** Longest tail of check output preserved in a verify report (§8.2). */
 const REPORT_TAIL_CHARS = 10_000
 
+/** Per-section cap for the finalize preflight's dirty-worktree diff capture:
+ * each diff view (working tree, staged) is truncated at this many characters
+ * so a large dirty diff cannot bloat the failure record unboundedly — worst
+ * case ≈ porcelain + 2 × (cap + header). */
+const FINALIZE_DIFF_CAPTURE_CAP = 20_000
+
 /**
  * One session bracket's live stream (SPEC §9): the sink the build-runner
  * opened through the resolved target's streaming capability, the store id it
@@ -260,6 +268,14 @@ function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error)
 }
 
+/** Bound one captured diff section: unchanged within the cap, otherwise the
+ * first FINALIZE_DIFF_CAPTURE_CAP characters plus an explicit truncation
+ * marker, so truncation is visible in the record itself. */
+function capDiffOutput(output: string): string {
+  if (output.length <= FINALIZE_DIFF_CAPTURE_CAP) return output
+  return `${output.slice(0, FINALIZE_DIFF_CAPTURE_CAP)}\n... (truncated at ${FINALIZE_DIFF_CAPTURE_CAP} characters)`
+}
+
 function sessionBudgetError(seconds: number): string {
   return `phase session budget expired after ${seconds} seconds`
 }
@@ -299,22 +315,155 @@ function providerAttemptSummary(attempts: readonly ProviderAttempt[] | undefined
   )
 }
 
+export interface PhaseFailureTally {
+  count: number
+  lastError?: string
+  lastWillRetry?: boolean
+  lastProviderAttempts?: readonly ProviderAttempt[]
+}
+
+export const PHASE_FAILURES_REDUCER_VERSION = 1
+
+/**
+ * phase.failed tally for one phase+round — D5's retry-guard input. A factory
+ * because phase and round are parameters of the projection.
+ *
+ * An answered escalation re-arms this budget only when its semantic class
+ * acknowledges phase-runner failures (§15.6-B). Runner-failure causes reset
+ * their matching round, the phase-level verify cause resets all rounds, and
+ * unrelated policy causes reset nothing. Cause-less historical and
+ * non-policy raises retain the legacy round-shaped behavior. Failures after
+ * an applicable answer count again, so a still-failing phase re-escalates on
+ * new evidence instead of deadlocking before its recovery session starts.
+ */
+export function phaseFailuresReducer(phase: Phase, round: number) {
+  return defineReducer<
+    {
+      /** id → the raise's reset semantics — answers are matched by id (§15.3). */
+      raised: Record<string, PhaseFailureResetEscalation>
+      count: number
+      lastError?: string
+      lastWillRetry?: boolean
+      lastProviderAttempts?: readonly ProviderAttempt[]
+    },
+    AbEvent,
+    PhaseFailureTally
+  >({
+    version: PHASE_FAILURES_REDUCER_VERSION,
+    initial: () => ({ raised: {}, count: 0 }),
+    fold(acc, events) {
+      for (const event of events) {
+        switch (event.type) {
+          case 'escalation.raised':
+            acc.raised[event.payload.id] = {
+              phase: event.payload.phase,
+              source: event.payload.source,
+              ...(event.payload.policyCause !== undefined
+                ? { policyCause: event.payload.policyCause }
+                : {}),
+              ...(event.payload.round !== undefined ? { round: event.payload.round } : {}),
+            }
+            break
+          case 'escalation.answered': {
+            const raise = acc.raised[event.payload.id]
+            if (raise !== undefined && resetsPhaseFailureBudget(raise, phase, round)) {
+              acc.count = 0
+              delete acc.lastError
+              delete acc.lastWillRetry
+              delete acc.lastProviderAttempts
+            }
+            break
+          }
+          case 'phase.failed':
+            if (event.payload.phase === phase && event.payload.round === round) {
+              acc.count += 1
+              acc.lastError = event.payload.error
+              acc.lastWillRetry = event.payload.willRetry
+              acc.lastProviderAttempts = event.payload.providerAttempts
+            }
+            break
+          default:
+            break
+        }
+      }
+    },
+    finish: (acc) => ({
+      count: acc.count,
+      ...(acc.lastError !== undefined ? { lastError: acc.lastError } : {}),
+      ...(acc.lastWillRetry !== undefined ? { lastWillRetry: acc.lastWillRetry } : {}),
+      ...(acc.lastProviderAttempts !== undefined
+        ? { lastProviderAttempts: acc.lastProviderAttempts }
+        : {}),
+    }),
+  })
+}
+
+export const SETUP_STREAK_REDUCER_VERSION = 1
+
+/** Consecutive durable setup failures since the latest successful attachment
+ * or explicit human answer. The accumulator keeps the boundary seq and the
+ * failure seqs, so it is exact for any array order. */
+export const setupStreakReducer = defineReducer<
+  { escalations: string[]; boundary: number; failures: number[] },
+  AbEvent,
+  number
+>({
+  version: SETUP_STREAK_REDUCER_VERSION,
+  initial: () => ({ escalations: [], boundary: 0, failures: [] }),
+  fold(acc, events) {
+    for (const event of events) {
+      if (event.type === 'runner.attached') acc.boundary = event.seq
+      else if (
+        event.type === 'escalation.raised' &&
+        event.payload.phase === 'setup' &&
+        event.payload.source === 'policy'
+      ) {
+        if (!acc.escalations.includes(event.payload.id)) acc.escalations.push(event.payload.id)
+      } else if (
+        event.type === 'escalation.answered' &&
+        acc.escalations.includes(event.payload.id)
+      ) {
+        acc.boundary = event.seq
+      } else if (event.type === 'runner.setup-failed') {
+        acc.failures.push(event.seq)
+      }
+    }
+  },
+  finish: (acc) => acc.failures.filter((seq) => seq > acc.boundary).length,
+})
+
+export const PUBLISHED_BRANCH_HEAD_REDUCER_VERSION = 1
+
+/** Latest event-checkpointed branch head that kernel plumbing published;
+ * undefined while the build has none. */
+export const publishedBranchHeadReducer = defineReducer<
+  { head?: string },
+  AbEvent,
+  string | undefined
+>({
+  version: PUBLISHED_BRANCH_HEAD_REDUCER_VERSION,
+  initial: () => ({}),
+  fold(acc, events) {
+    for (const event of events) {
+      if (event.type === 'implement.completed') {
+        acc.head = event.payload.commits.head
+      } else if (event.type === 'reconcile.completed') {
+        acc.head = event.payload.mergeCommit
+      } else if (
+        event.type === 'finalize.step-completed' &&
+        event.payload.ok &&
+        event.payload.headSha !== undefined
+      ) {
+        acc.head = event.payload.headSha
+      }
+    }
+  },
+  finish: (acc) => acc.head,
+})
+
 /** Latest event-checkpointed branch head that kernel plumbing published. */
 export function selectPublishedBranchHead(events: readonly AbEvent[]): string {
-  let head: string | undefined
-  for (const event of events) {
-    if (event.type === 'implement.completed') {
-      head = event.payload.commits.head
-    } else if (event.type === 'reconcile.completed') {
-      head = event.payload.mergeCommit
-    } else if (
-      event.type === 'finalize.step-completed' &&
-      event.payload.ok &&
-      event.payload.headSha !== undefined
-    ) {
-      head = event.payload.headSha
-    }
-  }
+  const head = publishedBranchHeadReducer.reduce(events)
   if (head === undefined) {
     throw new Error(
       'finalize publication requires a prior implement.completed, reconcile.completed, ' +
@@ -324,6 +473,37 @@ export function selectPublishedBranchHead(events: readonly AbEvent[]): string {
   return head
 }
 
+export const VERIFY_DIFF_BASE_REDUCER_VERSION = 1
+
+/**
+ * The durable tree against which a conditional verifier evaluates the
+ * branch's current HEAD, or undefined until a `workspace.provisioned` exists.
+ * The accumulator keeps the first provisioned base and the latest promoted
+ * reconcile base separately, so the result is exact for any array order (a
+ * promotion that precedes the provisioned fact in the array still wins).
+ */
+export const verifyDiffBaseReducer = defineReducer<
+  { provisioned?: string; promoted?: string; pendingReconcileBase?: string },
+  AbEvent,
+  string | undefined
+>({
+  version: VERIFY_DIFF_BASE_REDUCER_VERSION,
+  initial: () => ({}),
+  fold(acc, events) {
+    for (const event of events) {
+      if (event.type === 'workspace.provisioned') {
+        if (acc.provisioned === undefined) acc.provisioned = event.payload.base.sha
+      } else if (event.type === 'reconcile.started') {
+        acc.pendingReconcileBase = event.payload.baseSha
+      } else if (event.type === 'reconcile.completed') {
+        if (acc.pendingReconcileBase !== undefined) acc.promoted = acc.pendingReconcileBase
+        delete acc.pendingReconcileBase
+      }
+    }
+  },
+  finish: (acc) => (acc.provisioned === undefined ? undefined : (acc.promoted ?? acc.provisioned)),
+})
+
 /**
  * Select the durable tree against which a conditional verifier evaluates the
  * branch's current HEAD. The initial branch-cut SHA is authoritative until a
@@ -331,24 +511,13 @@ export function selectPublishedBranchHead(events: readonly AbEvent[]): string {
  * refreshed base SHA. A dangling start is intentionally ignored.
  */
 export function selectVerifyDiffBase(events: readonly AbEvent[]): string {
-  const provisioned = events.find((event) => event.type === 'workspace.provisioned')
-  if (provisioned === undefined || provisioned.type !== 'workspace.provisioned') {
+  const base = verifyDiffBaseReducer.reduce(events)
+  if (base === undefined) {
     throw new Error(
       'conditional verify requires a workspace.provisioned base SHA, but this build has none',
     )
   }
-
-  let baseSha = provisioned.payload.base.sha
-  let pendingReconcileBase: string | undefined
-  for (const event of events) {
-    if (event.type === 'reconcile.started') {
-      pendingReconcileBase = event.payload.baseSha
-    } else if (event.type === 'reconcile.completed') {
-      if (pendingReconcileBase !== undefined) baseSha = pendingReconcileBase
-      pendingReconcileBase = undefined
-    }
-  }
-  return baseSha
+  return base
 }
 
 /** Parse `git diff --name-only -z`; malformed output fails closed. */
@@ -468,22 +637,7 @@ export class BuildRunner {
    * or explicit human answer. The answer re-arms the budget but deliberately
    * does not erase the current diagnostic while recovery is still running. */
   private setupStreak(events: readonly AbEvent[]): number {
-    const setupEscalations = new Set<string>()
-    let boundary = 0
-    for (const event of events) {
-      if (event.type === 'runner.attached') boundary = event.seq
-      else if (
-        event.type === 'escalation.raised' &&
-        event.payload.phase === 'setup' &&
-        event.payload.source === 'policy'
-      ) {
-        setupEscalations.add(event.payload.id)
-      } else if (event.type === 'escalation.answered' && setupEscalations.has(event.payload.id)) {
-        boundary = event.seq
-      }
-    }
-    return events.filter((event) => event.type === 'runner.setup-failed' && event.seq > boundary)
-      .length
+    return setupStreakReducer.reduce(events)
   }
 
   private setupQuestion(failure: EventPayload<'runner.setup-failed'>): string {
@@ -1137,8 +1291,7 @@ export class BuildRunner {
           )
           if (scratchPaths.length > 0) throw phaseScratchRejection(scratchPaths)
           const remote = events.some(
-            (event) =>
-              event.type === 'workspace.provisioned' && event.payload.provider === 'vercel-sandbox',
+            (event) => event.type === 'workspace.provisioned' && isRemoteWorkspace(event.payload),
           )
           if (remote) {
             await this.deps.store.append(this.deps.slug, {
@@ -1490,13 +1643,50 @@ export class BuildRunner {
       )
     }
     if (result.stdout.length > 0) {
+      // The failure record must characterize the dirtiness on its own: the
+      // build workspace is disposable, and porcelain lists paths and status
+      // codes only — a mode-only flip (AUT-439) is indistinguishable from a
+      // content modification once the workspace is gone. Append both diff
+      // views so the record shows what actually changed.
       throw new Error(
         `workspace must be clean ${when}; commit intended files and remove ` +
-          `temporary files before finishing:\n${result.stdout.trimEnd()}`,
+          `temporary files before finishing:\n${result.stdout.trimEnd()}\n\n` +
+          (await this.collectWorktreeDiffSections()),
       )
     }
   }
 
+  /** Labeled working-tree and staged diff sections for a dirty finalize
+   * preflight record. Runs only on the dirty branch (a clean worktree or a
+   * failed status command never executes a diff), caps each section at
+   * FINALIZE_DIFF_CAPTURE_CAP characters, and is best-effort: a failing `git
+   * diff` command annotates its own section instead of masking the
+   * dirty-worktree failure it is annotating. */
+  private async collectWorktreeDiffSections(): Promise<string> {
+    const views = [
+      { args: ['git', 'diff'], header: '--- git diff (working tree) ---' },
+      { args: ['git', 'diff', '--cached'], header: '--- git diff --cached (staged) ---' },
+    ] as const
+    const sections: string[] = []
+    for (const { args, header } of views) {
+      const command = args.join(' ')
+      let body: string
+      try {
+        const result = await this.deps.exec([...args], { cwd: this.deps.workspacePath })
+        if (result.exitCode !== 0) {
+          const detail = result.stderr.trim() || result.stdout.trim() || '(no output)'
+          body = `(${command} failed: exit ${result.exitCode}: ${capDiffOutput(detail)})`
+        } else {
+          body = capDiffOutput(result.stdout) || '(no output)'
+        }
+      } catch (error) {
+        body = `(${command} failed: ${capDiffOutput(errorMessage(error))})`
+      }
+      sections.push(`${header}\n${body}`)
+    }
+    return sections.join('\n\n')
+  }
+
   private async resolveFinalizeHead(): Promise<string> {
     const args = ['git', 'rev-parse', 'HEAD']
     const result = await this.deps.exec(args, { cwd: this.deps.workspacePath })
@@ -2401,52 +2591,7 @@ export class BuildRunner {
     lastWillRetry?: boolean
     lastProviderAttempts?: readonly ProviderAttempt[]
   } {
-    /** id → the raise's reset semantics — answers are matched by id (§15.3). */
-    const raised = new Map<string, PhaseFailureResetEscalation>()
-    let count = 0
-    let lastError: string | undefined
-    let lastWillRetry: boolean | undefined
-    let lastProviderAttempts: readonly ProviderAttempt[] | undefined
-    for (const event of events) {
-      switch (event.type) {
-        case 'escalation.raised':
-          raised.set(event.payload.id, {
-            phase: event.payload.phase,
-            source: event.payload.source,
-            ...(event.payload.policyCause !== undefined
-              ? { policyCause: event.payload.policyCause }
-              : {}),
-            ...(event.payload.round !== undefined ? { round: event.payload.round } : {}),
-          })
-          break
-        case 'escalation.answered': {
-          const raise = raised.get(event.payload.id)
-          if (raise !== undefined && resetsPhaseFailureBudget(raise, phase, round)) {
-            count = 0
-            lastError = undefined
-            lastWillRetry = undefined
-            lastProviderAttempts = undefined
-          }
-          break
-        }
-        case 'phase.failed':
-          if (event.payload.phase === phase && event.payload.round === round) {
-            count += 1
-            lastError = event.payload.error
-            lastWillRetry = event.payload.willRetry
-            lastProviderAttempts = event.payload.providerAttempts
-          }
-          break
-        default:
-          break
-      }
-    }
-    return {
-      count,
-      ...(lastError !== undefined ? { lastError } : {}),
-      ...(lastWillRetry !== undefined ? { lastWillRetry } : {}),
-      ...(lastProviderAttempts !== undefined ? { lastProviderAttempts } : {}),
-    }
+    return phaseFailuresReducer(phase, round).reduce(events)
   }
 
   private async failPhase(

package/packages/core/src/processes/dispatcher-selectors.ts

@@ -0,0 +1,123 @@
+/**
+ * Pure event-log projections the dispatcher and janitor read, extracted from
+ * `dispatcher.ts` so each is an incremental reducer (see
+ * `kernel/incremental.ts`). The dispatcher's private helpers delegate here.
+ */
+import type { AbEvent } from '../events/catalog'
+import type { EventPayload } from '../events/payloads'
+import { defineReducer } from '../kernel/incremental'
+
+export type OpenBuildWorkspace = EventPayload<'workspace.provisioned'>
+
+export const OPEN_BUILD_WORKSPACE_REDUCER_VERSION = 1
+
+/** Latest `workspace.provisioned` not followed by a `workspace.released` —
+ * the reducer deliberately ignores workspace events (liveness is the
+ * dispatcher's concern), so the janitor scans the raw log. */
+export const openBuildWorkspaceReducer = defineReducer<
+  { open: OpenBuildWorkspace | null },
+  AbEvent,
+  OpenBuildWorkspace | null
+>({
+  version: OPEN_BUILD_WORKSPACE_REDUCER_VERSION,
+  initial: () => ({ open: null }),
+  fold(acc, events) {
+    for (const event of events) {
+      if (event.type === 'workspace.provisioned') acc.open = event.payload
+      else if (event.type === 'workspace.released') acc.open = null
+    }
+  },
+  finish: (acc) => (acc.open === null ? null : { ...acc.open }),
+})
+
+export function openBuildWorkspace(events: readonly AbEvent[]): OpenBuildWorkspace | null {
+  return openBuildWorkspaceReducer.reduce(events)
+}
+
+export const BASE_BRANCH_REDUCER_VERSION = 1
+
+/** The base branch recorded on the FIRST `build.created` in array order, or
+ * undefined for logs missing one (callers fall back to the repo config). */
+export const baseBranchReducer = defineReducer<
+  { baseBranch?: string },
+  AbEvent,
+  string | undefined
+>({
+  version: BASE_BRANCH_REDUCER_VERSION,
+  initial: () => ({}),
+  fold(acc, events) {
+    if (acc.baseBranch !== undefined) return
+    for (const event of events) {
+      if (event.type === 'build.created') {
+        acc.baseBranch = event.payload.baseBranch
+        return
+      }
+    }
+  },
+  finish: (acc) => acc.baseBranch,
+})
+
+export interface ProvisionMarker {
+  provider: string
+  branch: string
+  generation: number
+  ts: string
+  seq: number
+}
+
+export const PROVISION_MARKER_REDUCER_VERSION = 1
+
+/** The latest `workspace.provision-started` not yet followed by a
+ * provisioned/released fact — an open provisioning marker. */
+export const provisionMarkerReducer = defineReducer<
+  { marker: ProvisionMarker | null },
+  AbEvent,
+  ProvisionMarker | undefined
+>({
+  version: PROVISION_MARKER_REDUCER_VERSION,
+  initial: () => ({ marker: null }),
+  fold(acc, events) {
+    for (const event of events) {
+      if (event.type === 'workspace.provision-started') {
+        acc.marker = { ...event.payload, ts: event.ts, seq: event.seq }
+      } else if (
+        acc.marker !== null &&
+        (event.type === 'workspace.provisioned' || event.type === 'workspace.released')
+      ) {
+        acc.marker = null
+      }
+    }
+  },
+  finish: (acc) => (acc.marker === null ? undefined : { ...acc.marker }),
+})
+
+export const RECOVERY_CHECKPOINT_REDUCER_VERSION = 1
+
+/** The commit a recovered workspace is re-cut from: the latest settled
+ * publication head, else the first provisioned base. */
+export const recoveryCheckpointReducer = defineReducer<
+  { settled?: string; original?: string },
+  AbEvent,
+  string | undefined
+>({
+  version: RECOVERY_CHECKPOINT_REDUCER_VERSION,
+  initial: () => ({}),
+  fold(acc, events) {
+    for (const event of events) {
+      if (event.type === 'workspace.provisioned' && acc.original === undefined) {
+        acc.original = event.payload.base.sha
+      } else if (event.type === 'implement.completed') {
+        acc.settled = event.payload.commits.head
+      } else if (event.type === 'reconcile.completed') {
+        acc.settled = event.payload.mergeCommit
+      } else if (
+        event.type === 'finalize.step-completed' &&
+        event.payload.ok &&
+        event.payload.headSha !== undefined
+      ) {
+        acc.settled = event.payload.headSha
+      }
+    }
+  },
+  finish: (acc) => acc.settled ?? acc.original,
+})