@defrex/autobuild 0.8.0 → 0.10.0

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

@@ -38,10 +38,22 @@
 import type { AbEvent } from '../../events/catalog'
 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'
@@ -104,6 +116,12 @@ export interface PipelineStep {
   /** Absent ⇒ the step has never run in the current spec scope ⇒ no time is
    * shown (AC 6). The renderer composes the elapsed segment from this. */
   timing?: StepTiming
+  /** Display-only, like `qualifier`, and never consulted for routing: the
+   * parked merge step's no-consent explanation — why nothing will happen
+   * without operator action, and which control unblocks it. Attached when the
+   * build is current at merge with effective auto-merge off; the terminal
+   * row/detail and the web row/detail render the same words. */
+  reason?: string
 }
 
 export type DashboardSelection =
@@ -155,6 +173,11 @@ export interface DashboardBuild {
   pr?: { url: string; state: PrLifecycle }
   /** Chronological session history projected from the retained raw log. */
   sessions?: DashboardSession[]
+  /** Which `autobuild.toml` the dispatcher pinned this build's pipeline from,
+   * and the effective-config revision it was deposited under (SPEC §16.1).
+   * Present once an effective-config artifact exists. */
+  pipelineSource?: PipelineSourceMeta
+  effectiveConfigRev?: number
 }
 
 export type DashboardView =
@@ -329,6 +352,18 @@ export function autoMergeDisplay(state: BuildState): AutoMergeDisplay {
   return 'cancelling'
 }
 
+/** The shared no-consent wording for a build parked on an open PR. One string
+ * so the terminal row/detail and the web row/detail say the same words, and
+ * so it names the per-build control that unblocks the parked build. */
+export function autoMergeConsentReason(slug: string): string {
+  return (
+    `no auto-merge consent has been requested — request it with m on the build row or ` +
+    '`ab auto-merge ' +
+    slug +
+    ' on`'
+  )
+}
+
 /**
  * One step, built through one helper so the precedence rule cannot be applied
  * inconsistently: **`current > done > provisional > pending`**. In particular,
@@ -342,6 +377,7 @@ interface StepExtra {
   qualifier?: 'failed' | 'skipped' | 'waiting'
   count?: number
   timing?: StepTiming
+  reason?: string
 }
 
 function step(label: string, done: boolean, current: boolean, extra: StepExtra = {}): PipelineStep {
@@ -357,102 +393,10 @@ function step(label: string, done: boolean, current: boolean, extra: StepExtra =
     ...(extra.qualifier !== undefined ? { qualifier: extra.qualifier } : {}),
     ...(extra.count !== undefined ? { count: extra.count } : {}),
     ...(extra.timing !== undefined ? { timing: extra.timing } : {}),
+    ...(extra.reason !== undefined ? { reason: extra.reason } : {}),
   }
 }
 
-/** 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
@@ -463,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
@@ -490,6 +434,14 @@ function timingFor(
 
 /**
  * `record` + `state` → one dashboard row, or `null` only for terminal builds.
+ *
+ * `config` is the dispatcher's live snapshot; `pinnedConfig` (SPEC §16.1) is
+ * the build's own pipeline — its deposited effective-config artifact's
+ * build-owned sections composed over `config`'s deployment-owned ones. A
+ * build's verify/finalize universe and next-action are decided from the
+ * pinned pipeline: the live snapshot describes the base branch, which a
+ * pinned build may never execute (the AUT-366 class). Absent artifact ⇒ the
+ * live config, the pre-pin behavior.
  */
 export function projectBuild(
   record: BuildRecord,
@@ -497,7 +449,42 @@ export function projectBuild(
   config: Config,
   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 =
@@ -510,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
@@ -555,7 +536,7 @@ export function projectBuild(
       dispatch,
       blockers: [],
       autoMerge: autoMergeDisplay(state),
-      sessions: projectSessions(events, streams),
+      sessions: projectSessions(dashboard.sessionEvents, streams),
     }
   }
 
@@ -576,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),
     }
   }
 
@@ -640,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
@@ -663,7 +641,7 @@ export function projectBuild(
   const verifySkipped = (s: string): boolean =>
     cycle.some((r) => r.step === s && r.outcome === 'skipped')
   const verifySatisfied = (s: string): boolean => verifyPassed(s) || verifySkipped(s)
-  const verifyDrained = !cycleFailed && config.verify.steps.every(verifySatisfied)
+  const verifyDrained = !cycleFailed && pipeline.verify.steps.every(verifySatisfied)
 
   // A loop is settled only if its standing approval survived the last restart
   // AND no later producer round reopened it. `approved` alone is a full-log
@@ -685,35 +663,31 @@ 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
   // spec restart never resets while the engine re-runs finalize from scratch.
   const finalizeDone = state.finalizeCompletedSeq > restartSince
-  const postStepsDrained = config.finalize.steps.every((s) =>
+  const postStepsDrained = pipeline.finalize.steps.every((s) =>
     finalizeSteps.some((f) => f.step === s),
   )
 
@@ -746,7 +720,7 @@ export function projectBuild(
     }),
   ]
 
-  for (const s of config.verify.steps) {
+  for (const s of pipeline.verify.steps) {
     const phase = verifyPhase(s)
     const current = at(phase)
     const stepResults = cycle.filter((r) => r.step === s)
@@ -787,7 +761,7 @@ export function projectBuild(
       timing: timingFor(intervals, 'finalize', restartSince, frozenNow),
     }),
   )
-  for (const s of config.finalize.steps) {
+  for (const s of pipeline.finalize.steps) {
     // Post-steps have no `.started` event, so they carry no timing.
     const done = finalizeSteps.find((f) => f.step === s)
     steps.push(
@@ -839,6 +813,17 @@ export function projectBuild(
       ? { accumulatedMs: Math.max(0, frozenNow - lastMs) }
       : { accumulatedMs: 0, runningSince: lastMs }
   steps.push(step('merge', false, mergeCurrent, { qualifier: 'waiting', timing: mergeTiming }))
+  const autoMerge = autoMergeDisplay(state)
+  // The parked no-consent reason: a merge-current build whose effective
+  // auto-merge state is off will never merge without operator action, and the
+  // step must say so (and name the control) wherever the pipeline renders.
+  // Display-only; the deferral `mergeWaitReason` stays in `blockers`.
+  if (mergeCurrent && autoMerge === 'off') {
+    steps[steps.length - 1] = {
+      ...steps[steps.length - 1]!,
+      reason: autoMergeConsentReason(record.slug),
+    }
+  }
 
   const setupError =
     state.infrastructureFailure !== undefined
@@ -855,10 +840,10 @@ export function projectBuild(
               : `exit status ${state.setupFailure.exitStatus}`
           }): ${state.setupFailure.output || '(no output)'}`
 
-  const decision = decideNext(events, config)
+  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 {
@@ -875,11 +860,11 @@ export function projectBuild(
     ...(state.reviewRoundCeilings.plan !== undefined || state.reviewRoundCeilings.code !== undefined
       ? { reviewRoundCeilings: { ...state.reviewRoundCeilings } }
       : {}),
-    autoMerge: autoMergeDisplay(state),
+    autoMerge,
     ...(state.pr !== undefined && state.prState !== undefined
       ? { pr: { url: state.pr.url, state: state.prState } }
       : {}),
-    sessions: projectSessions(events, streams),
+    sessions: projectSessions(dashboard.sessionEvents, streams),
   }
 }
 
@@ -1084,7 +1069,10 @@ interface RepositoryHarvestProjection {
   harvest?: DashboardHarvest
 }
 
-function projectRepositoryHarvest(events: RepositoryEvent[]): RepositoryHarvestProjection {
+/** The repository-journal half of a legacy dashboard frame (AUT-545): the
+ * harvest projection and the pause flag exactly as `buildDashboardFromProjected`
+ * derives them, exposed for tests that pin the bounded read's equivalence. */
+export function projectRepositoryHarvest(events: RepositoryEvent[]): RepositoryHarvestProjection {
   const state = reduceHarvest(events)
   const harvest = projectHarvestRun(events, state)
   return {

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

@@ -1,16 +1,27 @@
 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 type { BuildRecord, StreamRecord, StreamScope } from '../../store/types'
+import { buildReducer, type BuildAcc, type BuildState } from '../../kernel/reducer'
+import {
+  BUILD_EFFECTIVE_CONFIG_ARTIFACT,
+  parseBuildConfigMetadata,
+  parseEffectiveBuildConfig,
+} from '../../processes/build-execution-state'
+import type { Artifact, BuildRecord, StreamRecord, StreamScope } from '../../store/types'
 import { projectBuild, type DashboardBuild } from './model'
 
 /** The read-only BuildStore surface needed to construct dashboard build rows.
  * `listStreams` is optional: when present, build-scope records enrich each
- * row's session history with authoritative stream ids and statuses (SPEC §9). */
+ * row's session history with authoritative stream ids and statuses (SPEC §9).
+ * `getArtifact` is optional: when present, the effective-config artifact's
+ * metadata decorates each row with its pinned pipeline source and revision
+ * (SPEC §16.1). */
 export interface DashboardBuildReader {
   listBuilds(): Promise<BuildRecord[]>
   getEvents(slug: string, sinceSeq?: number): Promise<AbEvent[]>
   listStreams?(scope: StreamScope): Promise<StreamRecord[]>
+  getArtifact?(slug: string, kind: string): Promise<Artifact | null>
 }
 
 export interface DashboardPollSnapshot {
@@ -27,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
 }
@@ -109,6 +123,60 @@ export class DashboardBuildPollCache {
     return snapshot.revision === this.committedRevision
   }
 
+  /** Effective-config artifact facts for one build (SPEC §16.1), when the
+   * reader exposes the artifact primitive: the metadata projection plus the
+   * artifact's parsed content. A malformed artifact still yields its metadata
+   * (config absent); all failures are display-only. */
+  private async readEffectiveConfig(
+    slug: string,
+  ): Promise<
+    { revision?: number; pipelineSource?: PipelineSourceMeta; config?: Config } | undefined
+  > {
+    const getArtifact = this.reader.getArtifact
+    if (getArtifact === undefined) return undefined
+    try {
+      const artifact = await getArtifact.call(this.reader, slug, BUILD_EFFECTIVE_CONFIG_ARTIFACT)
+      if (artifact === null) return undefined
+      let config: Config | undefined
+      try {
+        config = parseEffectiveBuildConfig(artifact)
+      } catch {
+        config = undefined
+      }
+      return { ...parseBuildConfigMetadata(artifact), config }
+    } catch {
+      return undefined
+    }
+  }
+
+  /** Project one build row against its PINNED pipeline (SPEC §16.1) and
+   * attach the effective-config metadata. The row's verify/finalize steps and
+   * next-action must describe the pipeline the build actually runs — the
+   * artifact's build-owned sections — never the dispatcher's live base-branch
+   * snapshot, which a pinned build may never execute. Deployment-owned
+   * sections (roles/policy) still come from the live snapshot, so a reload
+   * that reaches the build is reflected. A build with no artifact yet (queued
+   * or pre-pin) projects from the live config, the pre-pin behavior. */
+  private async projectRow(
+    record: BuildRecord,
+    state: BuildState,
+    events: AbEvent[],
+    config: Config,
+  ): Promise<DashboardBuild | null> {
+    const [streams, artifact] = await Promise.all([
+      this.readStreams(record.slug),
+      this.readEffectiveConfig(record.slug),
+    ])
+    const pinnedConfig =
+      artifact?.config !== undefined ? composeBuildConfig(artifact.config, config) : undefined
+    const build = projectBuild(record, state, config, events, streams, pinnedConfig)
+    if (build !== null && artifact !== undefined) {
+      if (artifact.revision !== undefined) build.effectiveConfigRev = artifact.revision
+      if (artifact.pipelineSource !== undefined) build.pipelineSource = artifact.pipelineSource
+    }
+    return build
+  }
+
   refresh(
     config: Config = this.config,
     configRevision = this.configRevision,
@@ -146,13 +214,7 @@ export class DashboardBuildPollCache {
           configChanged
             ? {
                 ...current,
-                build: projectBuild(
-                  record,
-                  current.state,
-                  config,
-                  current.events,
-                  await this.readStreams(record.slug),
-                ),
+                build: await this.projectRow(record, current.state, current.events, config),
               }
             : current,
         )
@@ -160,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
@@ -168,8 +231,9 @@ export class DashboardBuildPollCache {
       next.set(record.slug, {
         kind: 'live',
         events,
+        acc,
         state,
-        build: projectBuild(record, state, config, events, await this.readStreams(record.slug)),
+        build: await this.projectRow(record, state, events, config),
       })
     }
 

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

@@ -250,7 +250,8 @@ function renderStep(step: PipelineStep, color: boolean, now: number): string {
     parts.push(`${formatDuration(elapsedMs)}${count}`)
   }
   const note = parts.length > 0 ? `(${parts.join(', ')})` : ''
-  const text = `${GLYPH[step.state]} ${step.label}${note}`
+  const reason = step.reason !== undefined ? ` — ${step.reason}` : ''
+  const text = `${GLYPH[step.state]} ${step.label}${note}${reason}`
   const painted = paint(text, STEP_COLOR[step.state], color)
   return step.state === 'current' ? paint(painted, 'bold', color) : painted
 }
@@ -307,6 +308,7 @@ function renderBuild(
   widths: Widths,
   selected: boolean,
   selecting: boolean,
+  defaultAutoMerge: boolean,
 ): string[] {
   const { color, width, now } = opts
 
@@ -329,10 +331,22 @@ function renderBuild(
   // right-justifies the status word so it is never truncated and always ends at
   // the frame's right edge (AC 3, AC 5).
   const rightTokens: string[] = []
-  if (build.autoMerge !== 'off') {
+  // The state is ALWAYS drawn — including `off` — so consent is never conveyed
+  // by the absence of a token alone. `off` turns red while the repository
+  // default reads ON: the default-on/build-off mismatch an operator must see
+  // without opening the detail view.
+  {
     const autoColor: ColorName =
-      build.autoMerge === 'enabled' ? 'green' : build.autoMerge === 'requested' ? 'cyan' : 'yellow'
-    rightTokens.push(paint('auto merge', autoColor, color))
+      build.autoMerge === 'enabled'
+        ? 'green'
+        : build.autoMerge === 'requested'
+          ? 'cyan'
+          : build.autoMerge === 'cancelling'
+            ? 'yellow'
+            : defaultAutoMerge
+              ? 'red'
+              : 'dim'
+    rightTokens.push(paint(`auto merge ${build.autoMerge}`, autoColor, color))
   }
   if (build.pr !== undefined) rightTokens.push(link(build.pr.url, `PR ${build.pr.state}`, color))
   // A repository hold changes no build lifecycle state. Keep QUEUED literal
@@ -578,7 +592,8 @@ function detailStep(step: PipelineStep, opts: RenderOpts): string {
     notes.push(formatDuration(elapsed))
   }
   const note = notes.length > 0 ? ` (${notes.join(', ')})` : ''
-  return paint(`${GLYPH[step.state]} ${step.label}${note}`, STEP_COLOR[step.state], color)
+  const reason = step.reason !== undefined ? ` — ${step.reason}` : ''
+  return paint(`${GLYPH[step.state]} ${step.label}${note}${reason}`, STEP_COLOR[step.state], color)
 }
 
 function sessionLines(session: DashboardSession, selected: boolean, opts: RenderOpts): string[] {
@@ -639,6 +654,19 @@ function detailBody(
   if (ceiling !== undefined) body.push(`  ${ceiling}`)
   if (build.pr !== undefined)
     body.push(`  PR ${build.pr.state}  ${link(build.pr.url, build.pr.url, color)}`)
+  if (build.pipelineSource !== undefined || build.effectiveConfigRev !== undefined) {
+    const commit =
+      build.pipelineSource?.commit !== undefined
+        ? build.pipelineSource.commit.slice(0, 7)
+        : 'unknown'
+    const source =
+      build.pipelineSource !== undefined
+        ? `autobuild.toml@${commit} (${build.pipelineSource.ref})`
+        : 'autobuild.toml@unknown (pre-pin)'
+    const rev =
+      build.effectiveConfigRev !== undefined ? `  config rev ${build.effectiveConfigRev}` : ''
+    body.push(`  pipeline ${source}${rev}`)
+  }
   if (build.abortProgress !== undefined) {
     body.push('', paint('Abort progress', 'bold', color))
     body.push(...wrappedText(build.abortProgress, width, '  '))
@@ -1449,6 +1477,7 @@ function renderDashboardContent(model: DashboardModel, opts: RenderOpts): string
             widths,
             sameSelection(selection, model.selection),
             selecting,
+            model.defaultAutoMerge,
           ),
         },
       ]