@defrex/autobuild 0.9.0 → 0.10.1

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

@@ -23,11 +23,9 @@
  */
 import type { Config } from '../config/schema'
 import type { AbEvent } from '../events/catalog'
-import { normalizeVerifyCompletion, type EventPayload } from '../events/payloads'
 import {
   isVerifyPhase,
   verifyPhase,
-  type ArtifactRef,
   type CorePhase,
   type EscalationSource,
   type EscalationTarget,
@@ -35,10 +33,9 @@ import {
   type Finding,
   type Phase,
   type PolicyEscalationCause,
-  type ReviewVerdictKind,
-  type VerifyOutcome,
 } from '../ontology'
-import { reduceBuild, type AnsweredEscalation } from './reducer'
+import { indexLog, type LogIndex, type LoopIndex } from './log-index'
+import { reduceBuild, type AnsweredEscalation, type BuildState } from './reducer'
 import { stalledChains, type FindingChain } from './stall'
 
 // ── The decision contract ────────────────────────────────────────────────────
@@ -110,153 +107,15 @@ export type Decision =
       refs?: string[]
     }
 
-// ── Raw-log index ────────────────────────────────────────────────────────────
-//
-// Every field here is a projection the reducer does not carry (or carries
-// without the seq the engine routes on). Loop and verify progress counts only
-// events with seq > restartSeq (§6.3 immutability: every reviewer approves
-// conformance to ONE spec revision — a drifting spec silently converts
-// approvals into approvals-of-something-else, so approvals of an old spec do
-// not carry across `spec.revised`).
-
-interface VerdictRecord {
-  seq: number
-  round: number
-  verdict: ReviewVerdictKind
-  findings: Finding[]
-  reason?: string
-}
-
-interface PlanCompletionRecord {
-  seq: number
-  artifact: ArtifactRef
-  verifySteps?: string[]
-}
-
-interface RoundRecord {
-  startedSeq?: number
-  completedSeq?: number
-  /** Plan only. Kept separately so approval snapshots this exact completion. */
-  planCompletion?: PlanCompletionRecord
-  verdict?: VerdictRecord
-}
-
-interface LoopIndex {
-  /**
-   * Max round in any of this loop's events over the FULL log. Round numbers
-   * continue monotonically across spec restarts (next round = max round ever
-   * seen + 1) so the log stays unambiguous: "plan round 1" must name exactly
-   * one producer run, not one per spec revision.
-   */
-  maxRoundEver: number
-  /** Max round with post-restart events; 0 when the loop is untouched. */
-  maxRound: number
-  /** Post-restart per-round event records (latest occurrence wins). */
-  rounds: Map<number, RoundRecord>
-  /** Latest post-restart revise verdict — the findings-feedback source. */
-  latestRevise?: VerdictRecord
-  /** seq of the latest post-restart approve verdict (verify cycle boundary). */
-  latestApproveSeq: number
-  /** Plan only: the completion present when the latest approve verdict landed.
-   * A later orphan or superseded completion cannot replace this snapshot. */
-  approvedPlan?: PlanCompletionRecord
-  /** Findings per round (index round-1), post-restart — stalledChains input.
-   * The reducer's reviewFindings spans restarts; this one must not. */
-  findingsByRound: Finding[][]
-}
-
-interface VerifyRecord {
-  seq: number
-  step: string
-  attempt: number
-  outcome: VerifyOutcome
-  report?: ArtifactRef
-  reason?: string
-}
-
-interface GuidanceDelivery {
-  escalation: string
-  /** seq of the matching `session.started` that made the carrier actionable. */
-  seq: number
-}
-
-interface ReconcileStartRecord {
-  seq: number
-  attempt: number
-  baseSha: string
-}
-
-interface ReconcileCompletionRecord extends ReconcileStartRecord {
-  completedSeq: number
-}
-
-interface ReconcileProgressRecord {
-  seq: number
-  conflictSeq: number
-  attempt: number
-  baseSha: string
-}
-
-interface LogIndex {
-  /** seq of the latest `spec.revised`, else 0 — the restart boundary (§6.3). */
-  restartSeq: number
-  plan: LoopIndex
-  code: LoopIndex
-  /** Post-restart `verify.completed` facts with seq, for the same sequence-based
-   * cycle boundary query exposed by the reducer (§15.6-A). */
-  verifyCompleted: VerifyRecord[]
-  /** Post-restart `verify.started` facts — a crashed step re-runs at the SAME
-   * attempt (§15.6-C), so the current cycle's attempt must be readable from
-   * its start events even before any completion lands. */
-  verifyStarted: { seq: number; attempt: number }[]
-  /**
-   * Max verify attempt in any `verify.started`/`verify.completed` over the
-   * FULL log. Attempt numbers continue monotonically across spec restarts and
-   * reconcile cycles — the same rationale as LoopIndex.maxRoundEver: the log
-   * stays unambiguous ("verify attempt 2" names exactly one cycle) and D5
-   * failure keys (verify:<step>, round = attempt) never collide across cycles.
-   * This high-water allocates attempt numbers; current-cycle membership is
-   * independently sequence-based.
-   */
-  maxVerifyAttemptEver: number
-  /** seq of the latest post-restart `reconcile.completed` — cycle boundary
-   * input: reconciliation changed code, verify re-runs in full (§15.7). */
-  lastReconcileCompletedSeq: number
-  /** seq of the latest post-restart `implement.completed` — a verify failure
-   * with an implement round after it was already routed (§15.6-A). */
-  lastImplementCompletedSeq: number
-  /** Post-restart `finalize.completed` seen (the reducer only projects pr). */
-  finalizeCompleted: boolean
-  /** Post-restart `finalize.step-completed` steps, ok true OR false —
-   * post-steps are failure-tolerant (§5), so any completion counts. */
-  finalizeStepsDone: Set<string>
-  /** Latest `pr.conflicted` (full log — the epilogue is restart-orthogonal);
-   * only its seq is needed for policy/dedupe. Its baseSha is detection-time
-   * evidence, not the reconcile merge target (§15.7). */
-  lastConflict?: { seq: number }
-  /** A `reconcile.started` after lastConflict without its completion — a
-   * crashed reconcile re-runs the SAME attempt from its start (§15.6-C). */
-  conflictReconcileStarted?: { attempt: number }
-  /** Most recent completed reconcile, paired with the latest same-occurrence
-   * start so crash retries use the base that actually completed. */
-  lastReconcileCompleted?: ReconcileCompletionRecord
-  /** Explicit authoritative observation for the current repeat conflict. */
-  lastConflictProgressCheck?: ReconcileProgressRecord
-  /** Distinct completed attempts observed still conflicted at the same base.
-   * A later attempt start supplies the observation for pre-event logs. */
-  reconcileNoProgressCount: number
-  /** Guidance carriers that reached a matching durable session launch.
-   * Plan, implement, and agent-verify starts may cite feedback (§15.3), but a
-   * citation alone remains recoverable across the pre-launch crash boundary.
-   * Only a later `session.started` for the same phase and round/attempt marks
-   * that answer delivered (§15.6-B). */
-  guidanceDeliveries: GuidanceDelivery[]
-}
-
 export function decideNext(events: AbEvent[], config: Config): Decision {
-  const state = reduceBuild(events)
-  const log = indexLog(events)
+  return decideNextFromFacts(reduceBuild(events), indexLog(events), config)
+}
 
+/** `decideNext` over already-reduced facts: a caller holding the build state
+ * and log index (a reducer snapshot advanced to the log tail) decides without
+ * the event array. `decideNext(events, config)` is exactly this over
+ * `reduceBuild(events)` and `indexLog(events)`. */
+export function decideNextFromFacts(state: BuildState, log: LogIndex, config: Config): Decision {
   // ── 1. Terminal (§15.5: terminal wins, latest wins) ────────────────────────
   if (state.status === 'aborted') return { kind: 'wait', reason: 'aborted' }
   if (state.status === 'done') return { kind: 'wait', reason: 'done' }
@@ -757,291 +616,3 @@ function guidanceDestination(
   if (isVerifyPhase(phase)) return source === 'agent' ? phase : 'code'
   return 'other'
 }
-
-// ── Raw-log indexing ─────────────────────────────────────────────────────────
-
-type ReviewVerdictPayload = EventPayload<'plan-review.verdict'>
-
-function emptyLoop(): LoopIndex {
-  return {
-    maxRoundEver: 0,
-    maxRound: 0,
-    rounds: new Map(),
-    latestApproveSeq: 0,
-    findingsByRound: [],
-  }
-}
-
-function indexLog(events: AbEvent[]): LogIndex {
-  // Pass 1: the restart boundary — seq of the latest spec.revised (§6.3).
-  let restartSeq = 0
-  for (const event of events) {
-    if (event.type === 'spec.revised') restartSeq = event.seq
-  }
-
-  const plan = emptyLoop()
-  const code = emptyLoop()
-  const verifyCompleted: VerifyRecord[] = []
-  const verifyStarted: { seq: number; attempt: number }[] = []
-  let maxVerifyAttemptEver = 0
-  const finalizeStepsDone = new Set<string>()
-  const guidanceDeliveries: GuidanceDelivery[] = []
-  const pendingGuidanceStarts = new Map<string, { escalation: string; seq: number }>()
-  let lastReconcileCompletedSeq = 0
-  let lastImplementCompletedSeq = 0
-  let finalizeCompleted = false
-  let lastConflict: { seq: number } | undefined
-  let conflictReconcileStarted: { attempt: number } | undefined
-  const conflictSeqs = new Set<number>()
-  const reconcileStarts: ReconcileStartRecord[] = []
-  const reconcileCompletions: ReconcileCompletionRecord[] = []
-  const reconcileProgressChecks: ReconcileProgressRecord[] = []
-  let activeReconcileStart: ReconcileStartRecord | undefined
-
-  /** Track a loop round: maxRoundEver over the full log; the per-round record
-   * only for post-restart events (returns undefined pre-restart). */
-  const roundRecord = (loop: LoopIndex, r: number, post: boolean): RoundRecord | undefined => {
-    if (r > loop.maxRoundEver) loop.maxRoundEver = r
-    if (!post) return undefined
-    if (r > loop.maxRound) loop.maxRound = r
-    let record = loop.rounds.get(r)
-    if (record === undefined) {
-      record = {}
-      loop.rounds.set(r, record)
-    }
-    return record
-  }
-
-  const noteGuidanceStart = (key: string, feedback: Feedback | undefined, seq: number): void => {
-    // A newer start is the authoritative carrier for this exact occurrence.
-    // In particular, a guidance-free retry must not let its later session
-    // consume an older citation that never launched.
-    if (feedback !== undefined && 'guidance' in feedback) {
-      pendingGuidanceStarts.set(key, { escalation: feedback.guidance.escalation, seq })
-    } else {
-      pendingGuidanceStarts.delete(key)
-    }
-  }
-
-  const noteVerdict = (
-    loop: LoopIndex,
-    payload: ReviewVerdictPayload,
-    seq: number,
-    post: boolean,
-  ): void => {
-    const record = roundRecord(loop, payload.round, post)
-    if (record === undefined) return
-    const verdict: VerdictRecord = {
-      seq,
-      round: payload.round,
-      verdict: payload.verdict,
-      findings: payload.findings,
-      reason: payload.reason,
-    }
-    record.verdict = verdict
-    if (payload.verdict === 'revise') loop.latestRevise = verdict
-    if (payload.verdict === 'approve') {
-      loop.latestApproveSeq = seq
-      // Snapshot at verdict time. A plan.completed appended later — even for
-      // this round — was never reviewed and therefore has no authority.
-      if (loop === plan) loop.approvedPlan = record.planCompletion
-    }
-    // Findings per round, reducer-style padding (rounds without verdicts stay
-    // empty — including every pre-restart round, which is the point).
-    while (loop.findingsByRound.length < payload.round) loop.findingsByRound.push([])
-    loop.findingsByRound[payload.round - 1] = payload.findings
-  }
-
-  for (const event of events) {
-    const post = event.seq > restartSeq
-    switch (event.type) {
-      case 'plan.started': {
-        noteGuidanceStart(`plan@${event.payload.round}`, event.payload.feedback, event.seq)
-        const record = roundRecord(plan, event.payload.round, post)
-        if (record !== undefined) record.startedSeq = event.seq
-        break
-      }
-      case 'plan.completed': {
-        const record = roundRecord(plan, event.payload.round, post)
-        if (record !== undefined) {
-          record.completedSeq = event.seq
-          record.planCompletion = {
-            seq: event.seq,
-            artifact: event.payload.artifact,
-            ...(event.payload.verifySteps !== undefined
-              ? { verifySteps: [...event.payload.verifySteps] }
-              : {}),
-          }
-        }
-        break
-      }
-      case 'plan-review.started':
-        roundRecord(plan, event.payload.round, post)
-        break
-      case 'plan-review.verdict':
-        noteVerdict(plan, event.payload, event.seq, post)
-        break
-
-      case 'implement.started': {
-        noteGuidanceStart(`implement@${event.payload.round}`, event.payload.feedback, event.seq)
-        const record = roundRecord(code, event.payload.round, post)
-        if (record !== undefined) record.startedSeq = event.seq
-        break
-      }
-      case 'implement.completed': {
-        const record = roundRecord(code, event.payload.round, post)
-        if (record !== undefined) record.completedSeq = event.seq
-        if (post) lastImplementCompletedSeq = event.seq
-        break
-      }
-      case 'code-review.started':
-        roundRecord(code, event.payload.round, post)
-        break
-      case 'code-review.verdict':
-        noteVerdict(code, event.payload, event.seq, post)
-        break
-
-      case 'verify.started': {
-        noteGuidanceStart(
-          `${verifyPhase(event.payload.step)}@${event.payload.attempt}`,
-          event.payload.feedback,
-          event.seq,
-        )
-        maxVerifyAttemptEver = Math.max(maxVerifyAttemptEver, event.payload.attempt)
-        if (post) verifyStarted.push({ seq: event.seq, attempt: event.payload.attempt })
-        break
-      }
-      case 'session.started': {
-        if (event.payload.round === undefined) break
-        const key = `${event.payload.phase}@${event.payload.round}`
-        const carrier = pendingGuidanceStarts.get(key)
-        if (carrier !== undefined && carrier.seq < event.seq) {
-          guidanceDeliveries.push({ escalation: carrier.escalation, seq: event.seq })
-          pendingGuidanceStarts.delete(key)
-        }
-        break
-      }
-      case 'verify.completed': {
-        const result = normalizeVerifyCompletion(event.payload)
-        maxVerifyAttemptEver = Math.max(maxVerifyAttemptEver, result.attempt)
-        if (post) {
-          verifyCompleted.push({
-            seq: event.seq,
-            step: result.step,
-            attempt: result.attempt,
-            outcome: result.outcome,
-            ...(result.report !== undefined ? { report: result.report } : {}),
-            ...(result.reason !== undefined ? { reason: result.reason } : {}),
-          })
-        }
-        break
-      }
-
-      case 'finalize.completed':
-        if (post) finalizeCompleted = true
-        break
-      case 'finalize.step-completed':
-        if (post) finalizeStepsDone.add(event.payload.step)
-        break
-
-      case 'pr.conflicted':
-        lastConflict = { seq: event.seq }
-        conflictSeqs.add(event.seq)
-        conflictReconcileStarted = undefined
-        break
-      case 'reconcile.progress-checked':
-        reconcileProgressChecks.push({ seq: event.seq, ...event.payload })
-        break
-      case 'reconcile.started': {
-        const start = { seq: event.seq, ...event.payload }
-        reconcileStarts.push(start)
-        activeReconcileStart = start
-        if (lastConflict !== undefined && event.seq > lastConflict.seq) {
-          conflictReconcileStarted = { attempt: event.payload.attempt }
-        }
-        break
-      }
-      case 'reconcile.completed':
-        if (post) lastReconcileCompletedSeq = event.seq
-        if (activeReconcileStart !== undefined) {
-          reconcileCompletions.push({
-            ...activeReconcileStart,
-            completedSeq: event.seq,
-          })
-          activeReconcileStart = undefined
-        }
-        conflictReconcileStarted = undefined
-        break
-
-      default:
-        break
-    }
-  }
-
-  // One completed occurrence per monotonic attempt. A later duplicate
-  // completion is safer to pair with its own latest start than with an older
-  // aggregate high-water, and malformed unmatched completions classify nothing.
-  const completedByAttempt = new Map<number, ReconcileCompletionRecord>()
-  for (const completion of reconcileCompletions) {
-    completedByAttempt.set(completion.attempt, completion)
-  }
-  const completed = [...completedByAttempt.values()].sort(
-    (left, right) => left.completedSeq - right.completedSeq,
-  )
-
-  let reconcileNoProgressCount = 0
-  for (const completion of completed) {
-    const nextStart = reconcileStarts.find(
-      (start) => start.seq > completion.completedSeq && start.attempt > completion.attempt,
-    )
-    const observationLimit = nextStart?.seq ?? Number.POSITIVE_INFINITY
-    // Explicit checks win over the historical fallback. Use the latest one
-    // that could have routed this next occurrence; duplicate conflict facts do
-    // not count one completed reconcile more than once.
-    const explicit = reconcileProgressChecks
-      .filter(
-        (check) =>
-          check.attempt === completion.attempt &&
-          check.seq > completion.completedSeq &&
-          check.seq < observationLimit &&
-          check.conflictSeq > completion.completedSeq &&
-          check.seq > check.conflictSeq &&
-          conflictSeqs.has(check.conflictSeq),
-      )
-      .at(-1)
-    const observedBase = explicit?.baseSha ?? nextStart?.baseSha
-    if (observedBase === completion.baseSha) reconcileNoProgressCount += 1
-  }
-
-  const lastReconcileCompleted = completed.at(-1)
-  const lastConflictProgressCheck =
-    lastConflict === undefined || lastReconcileCompleted === undefined
-      ? undefined
-      : reconcileProgressChecks
-          .filter(
-            (check) =>
-              check.conflictSeq === lastConflict.seq &&
-              check.attempt === lastReconcileCompleted.attempt &&
-              check.seq > lastConflict.seq,
-          )
-          .at(-1)
-
-  return {
-    restartSeq,
-    plan,
-    code,
-    verifyCompleted,
-    verifyStarted,
-    maxVerifyAttemptEver,
-    lastReconcileCompletedSeq,
-    lastImplementCompletedSeq,
-    finalizeCompleted,
-    finalizeStepsDone,
-    lastConflict,
-    conflictReconcileStarted,
-    lastReconcileCompleted,
-    lastConflictProgressCheck,
-    reconcileNoProgressCount,
-    guidanceDeliveries,
-  }
-}