@defrex/autobuild 0.9.0 → 0.10.0

package/packages/core/src/cli/dashboard/frame-parse.ts

@@ -0,0 +1,223 @@
+import { graphemes } from './cells'
+
+/**
+ * Deterministic parsing of a rendered dashboard frame.
+ *
+ * The dashboard deliberately emits a tiny terminal vocabulary: SGR reset,
+ * bold/dim and six named foreground colours, plus OSC 8 hyperlinks. This
+ * parser accepts exactly that vocabulary and nothing else. Unknown control
+ * traffic is an error rather than evidence that merely looks plausible after
+ * bytes were dropped. Every rendition of a frame — the PNG evidence, the
+ * website's HTML — derives from these same exact cells.
+ */
+
+const ESC = '\x1b'
+const BEL = '\x07'
+
+export type Foreground = 'foreground' | 'red' | 'green' | 'yellow' | 'blue' | 'cyan'
+
+export interface FrameStyle {
+  foreground: Foreground
+  bold: boolean
+  dim: boolean
+  href?: string
+}
+
+export interface FrameRun {
+  /** Zero-based terminal cell column the run starts at. */
+  column: number
+  /** Terminal cells the run occupies. */
+  cells: number
+  text: string
+  style: FrameStyle
+}
+
+export interface ParsedFrameLine {
+  /** The line with every escape removed. */
+  text: string
+  /** Terminal cells the whole line occupies. */
+  cells: number
+  runs: FrameRun[]
+}
+
+function cloneStyle(style: FrameStyle): FrameStyle {
+  return {
+    foreground: style.foreground,
+    bold: style.bold,
+    dim: style.dim,
+    ...(style.href !== undefined ? { href: style.href } : {}),
+  }
+}
+
+function sameStyle(left: FrameStyle, right: FrameStyle): boolean {
+  return (
+    left.foreground === right.foreground &&
+    left.bold === right.bold &&
+    left.dim === right.dim &&
+    left.href === right.href
+  )
+}
+
+function applySgr(style: FrameStyle, raw: string, line: number): void {
+  const codes = raw === '' ? [0] : raw.split(';').map((part) => Number(part))
+  if (codes.some((code) => !Number.isInteger(code))) {
+    throw new Error(`dashboard frame line ${line}: malformed SGR sequence ESC[${raw}m`)
+  }
+  for (const code of codes) {
+    switch (code) {
+      case 0:
+        style.foreground = 'foreground'
+        style.bold = false
+        style.dim = false
+        break
+      case 1:
+        style.bold = true
+        break
+      case 2:
+        style.dim = true
+        break
+      case 22:
+        style.bold = false
+        style.dim = false
+        break
+      case 31:
+        style.foreground = 'red'
+        break
+      case 32:
+        style.foreground = 'green'
+        break
+      case 33:
+        style.foreground = 'yellow'
+        break
+      case 34:
+        style.foreground = 'blue'
+        break
+      case 36:
+        style.foreground = 'cyan'
+        break
+      case 39:
+        style.foreground = 'foreground'
+        break
+      default:
+        throw new Error(`dashboard frame line ${line}: unsupported SGR code ${code} in ESC[${raw}m`)
+    }
+  }
+}
+
+/** Parse one rendered line into styled runs pinned to their terminal cells.
+ * `lineNumber` is one-based and only names the line in errors. */
+export function parseFrameLine(value: string, lineNumber: number): ParsedFrameLine {
+  const style: FrameStyle = {
+    foreground: 'foreground',
+    bold: false,
+    dim: false,
+  }
+  const runs: FrameRun[] = []
+  let text = ''
+  let cells = 0
+
+  const append = (cluster: string, width: number): void => {
+    const previous = runs.at(-1)
+    // ASCII runs may coalesce. Unicode clusters stay independently pinned to
+    // their terminal cell columns so font fallback/advance cannot shift the
+    // run that follows a wide glyph.
+    if (
+      previous !== undefined &&
+      previous.column + previous.cells === cells &&
+      /^[\x20-\x7e]*$/.test(previous.text) &&
+      /^[\x20-\x7e]$/.test(cluster) &&
+      sameStyle(previous.style, style)
+    ) {
+      previous.text += cluster
+      previous.cells += width
+    } else {
+      runs.push({ column: cells, cells: width, text: cluster, style: cloneStyle(style) })
+    }
+    text += cluster
+    cells += width
+  }
+
+  for (let index = 0; index < value.length; ) {
+    if (value[index] === ESC) {
+      const family = value[index + 1]
+      if (family === '[') {
+        const rest = value.slice(index + 2)
+        const match = /^([0-9;]*)m/.exec(rest)
+        if (match === null) {
+          throw new Error(
+            `dashboard frame line ${lineNumber}: unsupported or unterminated CSI sequence`,
+          )
+        }
+        applySgr(style, match[1]!, lineNumber)
+        index += 2 + match[0].length
+        continue
+      }
+      if (family === ']') {
+        const end = value.indexOf(BEL, index + 2)
+        if (end === -1) {
+          throw new Error(`dashboard frame line ${lineNumber}: unterminated OSC sequence`)
+        }
+        const payload = value.slice(index + 2, end)
+        const match = /^8;;(.*)$/.exec(payload)
+        if (match === null) {
+          throw new Error(
+            `dashboard frame line ${lineNumber}: unsupported OSC sequence ${JSON.stringify(payload)}`,
+          )
+        }
+        const href = match[1]!
+        style.href = href === '' ? undefined : href
+        index = end + 1
+        continue
+      }
+      throw new Error(
+        `dashboard frame line ${lineNumber}: unsupported escape family ${JSON.stringify(family ?? '')}`,
+      )
+    }
+
+    const nextEscape = value.indexOf(ESC, index)
+    const stop = nextEscape === -1 ? value.length : nextEscape
+    const plain = value.slice(index, stop)
+    for (const character of plain) {
+      const code = character.codePointAt(0)!
+      if (code < 0x20 || code === 0x7f || (code >= 0x80 && code <= 0x9f)) {
+        throw new Error(
+          `dashboard frame line ${lineNumber}: unsupported control U+${code
+            .toString(16)
+            .toUpperCase()
+            .padStart(4, '0')}`,
+        )
+      }
+    }
+    for (const cluster of graphemes(plain)) append(cluster.text, cluster.width)
+    index = stop
+  }
+
+  if (style.href !== undefined) {
+    throw new Error(`dashboard frame line ${lineNumber}: OSC 8 hyperlink was not closed`)
+  }
+  if (style.foreground !== 'foreground' || style.bold || style.dim) {
+    throw new Error(
+      `dashboard frame line ${lineNumber}: SGR style was not reset before end of line`,
+    )
+  }
+  return { text, cells, runs }
+}
+
+/** Parse a whole frame, holding every line to the declared terminal width. */
+export function parseFrame(lines: readonly string[], columns: number): ParsedFrameLine[] {
+  if (!Number.isInteger(columns) || columns <= 0) {
+    throw new Error(`dashboard frame columns must be a positive integer, got ${columns}`)
+  }
+  if (lines.length === 0) {
+    throw new Error('dashboard frame is empty')
+  }
+  const parsed = lines.map((line, index) => parseFrameLine(line, index + 1))
+  for (const [index, line] of parsed.entries()) {
+    if (line.cells > columns) {
+      throw new Error(
+        `dashboard frame line ${index + 1} is ${line.cells} cells wide, exceeding declared terminal width ${columns}`,
+      )
+    }
+  }
+  return parsed
+}

package/packages/core/src/cli/dashboard/model.ts

@@ -40,9 +40,20 @@ import type { RepositoryEvent } from '../../events/repository'
 import type { Config } from '../../config/schema'
 import type { PipelineSourceMeta } from '../../config/pipeline-source'
 import type { BuildState, PhaseContext, PrLifecycle } from '../../kernel/reducer'
-import { currentAutoMergeDeferral } from '../../kernel/auto-merge'
-import { decideNext } from '../../kernel/engine'
+import {
+  currentAutoMergeDeferralFrom,
+  currentDeferralObservationReducer,
+  type DeferralLedger,
+} from '../../kernel/auto-merge'
+import { decideNextFromFacts } from '../../kernel/engine'
 import { verifyPhase } from '../../ontology'
+import { indexLog, type LogIndex } from '../../kernel/log-index'
+import {
+  dashboardFactsReducer,
+  producedAfter,
+  type DashboardFacts,
+  type PhaseTiming,
+} from './facts'
 import type { BuildRecord, StreamRecord } from '../../store/types'
 import { reduceDispatchSettings } from '../../kernel/dispatch-settings'
 import { projectSessions, type DashboardSession } from './detail'
@@ -386,99 +397,6 @@ function step(label: string, done: boolean, current: boolean, extra: StepExtra =
   }
 }
 
-/** One phase occurrence's wall-clock span, keyed by phase. `startSeq` is the
- * seq of the `*.started` event, so callers can scope by the same seq
- * boundaries (`restartSince`/`cycleSince`) the step STATES already use. */
-interface PhaseInterval {
-  start: number
-  end: number
-  startSeq: number
-}
-interface PhaseTiming {
-  closed: PhaseInterval[]
-  open?: { start: number; startSeq: number }
-}
-
-/**
- * Walk the raw event log into per-phase `[start, end]` intervals in epoch-ms
- * (`Date.parse(ev.ts)`), the durations the reducer collapses away. Each
- * `*.started` opens an interval for its phase key and its terminal event
- * (`.completed`/`.verdict`) closes it. A second `*.started` while one is still
- * open REPLACES the open start — a §15.6-C cross-sandbox re-run starts the
- * phase afresh, so the crashed attempt contributes nothing. Finalize post-steps
- * (`finalize.step-completed`) have no `.started` and so no interval.
- */
-function phaseIntervals(events: AbEvent[]): Map<string, PhaseTiming> {
-  const timings = new Map<string, PhaseTiming>()
-  const get = (key: string): PhaseTiming => {
-    let t = timings.get(key)
-    if (t === undefined) {
-      t = { closed: [] }
-      timings.set(key, t)
-    }
-    return t
-  }
-  for (const ev of events) {
-    const ms = Date.parse(ev.ts)
-    const open = (key: string): void => {
-      get(key).open = { start: ms, startSeq: ev.seq }
-    }
-    const close = (key: string): void => {
-      const t = get(key)
-      if (t.open === undefined) return
-      t.closed.push({ start: t.open.start, end: ms, startSeq: t.open.startSeq })
-      t.open = undefined
-    }
-    switch (ev.type) {
-      case 'plan.started':
-        open('plan')
-        break
-      case 'plan.completed':
-        close('plan')
-        break
-      case 'plan-review.started':
-        open('plan-review')
-        break
-      case 'plan-review.verdict':
-        close('plan-review')
-        break
-      case 'implement.started':
-        open('implement')
-        break
-      case 'implement.completed':
-        close('implement')
-        break
-      case 'code-review.started':
-        open('code-review')
-        break
-      case 'code-review.verdict':
-        close('code-review')
-        break
-      case 'verify.started':
-        open(verifyPhase(ev.payload.step))
-        break
-      case 'verify.completed':
-        close(verifyPhase(ev.payload.step))
-        break
-      case 'finalize.started':
-        open('finalize')
-        break
-      case 'finalize.completed':
-        close('finalize')
-        break
-      case 'reconcile.started':
-        open('reconcile')
-        break
-      case 'reconcile.completed':
-        close('reconcile')
-        break
-      default:
-        break
-    }
-  }
-  return timings
-}
-
 /**
  * Sum the in-scope occurrences of one phase into a `StepTiming`, or `undefined`
  * when the phase never ran in scope (the step shows no time, AC 6). Scope is
@@ -489,12 +407,12 @@ function phaseIntervals(events: AbEvent[]): Map<string, PhaseTiming> {
  * not advance (AC 10).
  */
 function timingFor(
-  intervals: Map<string, PhaseTiming>,
+  intervals: Record<string, PhaseTiming>,
   key: string,
   sinceSeq: number,
   frozenNow: number | undefined,
 ): StepTiming | undefined {
-  const t = intervals.get(key)
+  const t = intervals[key]
   if (t === undefined) return undefined
   let accumulatedMs = 0
   let inScope = false
@@ -532,8 +450,41 @@ export function projectBuild(
   events: AbEvent[],
   streams?: readonly StreamRecord[],
   pinnedConfig?: Config,
+): DashboardBuild | null {
+  return projectBuildFromFacts(
+    record,
+    state,
+    {
+      dashboard: dashboardFactsReducer.reduce(events),
+      log: indexLog(events),
+      deferral: currentDeferralObservationReducer.reduce(events),
+    },
+    config,
+    streams,
+    pinnedConfig,
+  )
+}
+
+/** The reduced facts a row renders from, beside the build state: what
+ * `projectBuild` derives from the event array, advanced incrementally. */
+export interface DashboardRowFacts {
+  dashboard: DashboardFacts
+  log: LogIndex
+  deferral: DeferralLedger
+}
+
+/** `projectBuild` over already-reduced facts — the one implementation of the
+ * row projection, so a snapshot-backed row and a replayed row cannot differ. */
+export function projectBuildFromFacts(
+  record: BuildRecord,
+  state: BuildState,
+  facts: DashboardRowFacts,
+  config: Config,
+  streams?: readonly StreamRecord[],
+  pinnedConfig?: Config,
 ): DashboardBuild | null {
   const pipeline = pinnedConfig ?? config
+  const dashboard = facts.dashboard
   const status = effectiveStatus(state)
   if (!isVisible(status)) return null
   const abortProgress =
@@ -546,35 +497,29 @@ export function projectBuild(
         : undefined
 
   if (status === 'queued') {
-    const created = events.findLast((event) => event.type === 'build.created')
-    const workspace = events.findLast((event) => event.type === 'workspace.provisioned')
-    const released = events.findLast((event) => event.type === 'workspace.released')
+    const created = dashboard.created
+    const workspace = dashboard.workspaceProvisioned
+    const released = dashboard.workspaceReleased
     const openWorkspace =
-      workspace !== undefined && (released === undefined || workspace.seq > released.seq)
-    const spec = events.findLast(
-      (event) => event.type === 'spec.imported' || event.type === 'spec.authored',
-    )
-    const commentPosted = events.findLast((event) => event.type === 'dispatch.comment-posted')
-    const latestFailure = events.findLast((event) => event.type === 'dispatch.failed')
+      workspace !== undefined && (released === undefined || workspace > released)
+    const spec = dashboard.specLanded
+    const commentPosted = dashboard.commentPosted
+    const latestFailure = dashboard.latestFailure
     const failureSuperseded =
       latestFailure !== undefined &&
-      ((latestFailure.payload.stage === 'create' &&
-        created !== undefined &&
-        created.seq > latestFailure.seq) ||
-        (latestFailure.payload.stage === 'workspace' &&
+      ((latestFailure.stage === 'create' && created !== undefined && created > latestFailure.seq) ||
+        (latestFailure.stage === 'workspace' &&
           workspace !== undefined &&
-          workspace.seq > latestFailure.seq) ||
-        (latestFailure.payload.stage === 'spec' &&
-          spec !== undefined &&
-          spec.seq > latestFailure.seq) ||
-        (latestFailure.payload.stage === 'comment' &&
+          workspace > latestFailure.seq) ||
+        (latestFailure.stage === 'spec' && spec !== undefined && spec > latestFailure.seq) ||
+        (latestFailure.stage === 'comment' &&
           commentPosted !== undefined &&
-          commentPosted.seq > latestFailure.seq))
+          commentPosted > latestFailure.seq))
     const dispatch =
       state.discardRequest !== undefined
         ? 'discard requested; cleanup and Ready handback pending'
         : latestFailure !== undefined && !failureSuperseded
-          ? `dispatch ${latestFailure.payload.stage} failed (attempt ${latestFailure.payload.attempt}): ${latestFailure.payload.error}`
+          ? `dispatch ${latestFailure.stage} failed (attempt ${latestFailure.attempt}): ${latestFailure.error}`
           : created === undefined
             ? 'dispatch initialization pending'
             : !openWorkspace
@@ -591,7 +536,7 @@ export function projectBuild(
       dispatch,
       blockers: [],
       autoMerge: autoMergeDisplay(state),
-      sessions: projectSessions(events, streams),
+      sessions: projectSessions(dashboard.sessionEvents, streams),
     }
   }
 
@@ -612,7 +557,7 @@ export function projectBuild(
       ...(state.pr !== undefined && state.prState !== undefined
         ? { pr: { url: state.pr.url, state: state.prState } }
         : {}),
-      sessions: projectSessions(events, streams),
+      sessions: projectSessions(dashboard.sessionEvents, streams),
     }
   }
 
@@ -676,11 +621,8 @@ export function projectBuild(
   // blocked build freezes at the latest durable event. Timers therefore do not
   // advance behind either gate (AC 10). Each step scopes by the SAME seq boundary its state uses, so
   // durations and states restart in lockstep (AC 12).
-  const intervals = phaseIntervals(events)
-  const pausedAt =
-    state.status === 'paused'
-      ? events.findLast((event) => event.type === 'build.paused')?.ts
-      : undefined
+  const intervals = dashboard.intervals
+  const pausedAt = state.status === 'paused' ? dashboard.pausedAt : undefined
   const frozenNow =
     state.status === 'running'
       ? undefined
@@ -721,29 +663,25 @@ export function projectBuild(
   // boundary. Starts and timing intervals are deliberately insufficient: a
   // crashed phase has run, but has produced no output. Matching the round also
   // drops a review verdict as soon as the next producer round starts.
-  const planProduced = events.some(
-    (ev) =>
-      ev.seq > restartSince &&
-      ev.type === 'plan.completed' &&
-      ev.payload.round === state.plan.round,
+  const planProduced = producedAfter(
+    dashboard.produced.planCompleted,
+    state.plan.round,
+    restartSince,
   )
-  const planReviewProduced = events.some(
-    (ev) =>
-      ev.seq > restartSince &&
-      ev.type === 'plan-review.verdict' &&
-      ev.payload.round === state.plan.round,
+  const planReviewProduced = producedAfter(
+    dashboard.produced.planReviewVerdict,
+    state.plan.round,
+    restartSince,
   )
-  const implementProduced = events.some(
-    (ev) =>
-      ev.seq > restartSince &&
-      ev.type === 'implement.completed' &&
-      ev.payload.round === state.implement.round,
+  const implementProduced = producedAfter(
+    dashboard.produced.implementCompleted,
+    state.implement.round,
+    restartSince,
   )
-  const codeReviewProduced = events.some(
-    (ev) =>
-      ev.seq > restartSince &&
-      ev.type === 'code-review.verdict' &&
-      ev.payload.round === state.implement.round,
+  const codeReviewProduced = producedAfter(
+    dashboard.produced.codeReviewVerdict,
+    state.implement.round,
+    restartSince,
   )
 
   // Finalize ran for the CURRENT spec — NOT `prState !== undefined`, which a
@@ -902,10 +840,10 @@ export function projectBuild(
               : `exit status ${state.setupFailure.exitStatus}`
           }): ${state.setupFailure.output || '(no output)'}`
 
-  const decision = decideNext(events, pipeline)
+  const decision = decideNextFromFacts(state, facts.log, pipeline)
   const mergeWaitReason =
     decision.kind === 'wait' && decision.reason === 'awaiting-pr'
-      ? currentAutoMergeDeferral(events, state)
+      ? currentAutoMergeDeferralFrom(facts.deferral, state)
       : undefined
 
   return {
@@ -926,7 +864,7 @@ export function projectBuild(
     ...(state.pr !== undefined && state.prState !== undefined
       ? { pr: { url: state.pr.url, state: state.prState } }
       : {}),
-    sessions: projectSessions(events, streams),
+    sessions: projectSessions(dashboard.sessionEvents, streams),
   }
 }
 

package/packages/core/src/cli/dashboard/poll.ts

@@ -2,7 +2,7 @@ import type { Config } from '../../config/schema'
 import { composeBuildConfig } from '../../config/live'
 import type { PipelineSourceMeta } from '../../config/pipeline-source'
 import type { AbEvent } from '../../events/catalog'
-import { reduceBuild, type BuildState } from '../../kernel/reducer'
+import { buildReducer, type BuildAcc, type BuildState } from '../../kernel/reducer'
 import {
   BUILD_EFFECTIVE_CONFIG_ARTIFACT,
   parseBuildConfigMetadata,
@@ -38,6 +38,9 @@ export interface DashboardPollSnapshot {
 interface LiveEntry {
   kind: 'live'
   events: AbEvent[]
+  /** The reducer accumulator `state` was derived from; the next delta is
+   * folded into a copy of it instead of re-reducing the whole log. */
+  acc: BuildAcc
   state: BuildState
   build: DashboardBuild | null
 }
@@ -219,7 +222,8 @@ export class DashboardBuildPollCache {
       }
 
       const events = current === undefined ? delta : [...current.events, ...delta]
-      const state = reduceBuild(events)
+      const acc = buildReducer.advance(current?.acc ?? buildReducer.initial(), delta)
+      const state = buildReducer.finish(acc)
       if (isTerminal(state)) {
         next.set(record.slug, { kind: 'terminal' })
         continue
@@ -227,6 +231,7 @@ export class DashboardBuildPollCache {
       next.set(record.slug, {
         kind: 'live',
         events,
+        acc,
         state,
         build: await this.projectRow(record, state, events, config),
       })

package/packages/core/src/cli/dispatch-process.ts

@@ -1,6 +1,6 @@
 import { distributionPath } from '../distribution'
 import { DISPATCHER } from '../events/envelope'
-import type { RepositoryEvent } from '../events/repository'
+import { hasOpenTick } from '../processes/tick-state'
 import type { BuildStore } from '../store/types'
 
 export const DISPATCH_CHILD_OPTIONS_ENV = 'AB_DISPATCH_CHILD_OPTIONS'
@@ -132,18 +132,6 @@ export interface DispatchChildSupervisorDeps {
   }) => DispatchSubprocess
 }
 
-function hasOpenTick(events: readonly RepositoryEvent[], run: string): boolean {
-  const boundary = events.findLast(
-    (event) =>
-      'run' in event.payload &&
-      event.payload.run === run &&
-      (event.type === 'dispatcher.tick-started' ||
-        event.type === 'dispatcher.tick-completed' ||
-        event.type === 'dispatcher.tick-failed'),
-  )
-  return boundary?.type === 'dispatcher.tick-started'
-}
-
 function defaultSpawn(input: {
   entrypoint: string
   cwd: string