@defrex/autobuild 0.8.0 → 0.9.0

package/packages/core/src/cli/build-control.ts

@@ -7,11 +7,18 @@
  * normal runner and dispatcher consume them.
  */
 import type { AbEvent } from '../events/catalog'
+import type { PinnedAsset } from '../events/payloads'
 import { humanActor, KERNEL, type Via } from '../events/envelope'
-import { reduceBuild, type BuildState, type OpenEscalation } from '../kernel/reducer'
+import {
+  reduceBuild,
+  discardInFlight,
+  type BuildState,
+  type OpenEscalation,
+} from '../kernel/reducer'
 import type { ArtifactRef, BuildOutcome, BuildStatus, TicketRef } from '../ontology'
 import type { Exec } from '../ports/workspace/git-worktree'
 import { specConformance } from '../spec-standard'
+import { samplePinnedAssets } from '../store/ticket-assets'
 import type { BuildStore } from '../store/types'
 import { withSessionlessStore, type StoreOpener } from './store-opening'
 
@@ -107,6 +114,7 @@ export type BuildControlErrorCode =
   | 'missing-authorization'
   | 'no-longer-active'
   | 'abort-pending'
+  | 'discard-pending'
   | 'review-round-ceiling-unavailable'
   | 'incompatible-answer-options'
 
@@ -226,6 +234,78 @@ function hasPendingAbort(state: BuildState): boolean {
   return state.pendingCommands.some((command) => command.command === 'abort')
 }
 
+function discardPending(slug: string): BuildControlError {
+  return new BuildControlError(
+    'discard-pending',
+    `build "${slug}" has an outstanding discard request; auto-merge consent was not recorded. ` +
+      'The discard settles only when the build terminalizes — nothing was appended. ' +
+      'If the discard raced with runner attachment and you still want the change, ' +
+      'merge the PR manually.',
+  )
+}
+
+/** Record or withdraw per-build auto-merge consent — the write path for
+ * `auto-merge-on`, `auto-merge-off`, and `toggle-auto-merge`.
+ *
+ * Ruling (AUT-445): recording consent on a build with an outstanding discard
+ * request is rejected — the fan-out's discard exclusion
+ * (`autoMergeDefaultEligible`'s discard clause, AUT-418) applied to explicit
+ * consent. Both controls call the same `discardInFlight` predicate from
+ * kernel/reducer.ts, so they cannot diverge silently. Withdrawing consent (OFF)
+ * is deliberately still allowed: `checkPr` honors revocation before anything
+ * else, so an OFF strictly shrinks the merge set, and it is the only way to
+ * withdraw consent recorded before the discard (a fan-out or claim-time seed) —
+ * refusing it would leave that discard-contradicting consent driving the merge
+ * anyway. The fan-out is direction-blind because it is a queue cleaner that
+ * withdraws nothing that survives the settlement; this guard is directional on
+ * purpose, and the divergence is stated here rather than left accidental.
+ *
+ * The guard runs inside a compare-and-append loop (the `appendIfCurrent` idiom
+ * the fan-out's dispatcher loop and `bulkControlRepository` already use), so a
+ * discard request that lands between the guard's read and this append cannot
+ * slip past it: the CAS misses, the loop re-reduces the log, and the guard
+ * fires on the fresh state. The toggle's direction is re-resolved from the
+ * re-read state each attempt. `activeState` runs before the guard on every
+ * attempt: a queued build (where the discard normally sits) still reports the
+ * existing `inactive` error. */
+async function appendConsentCommand(
+  store: BuildStore,
+  slug: string,
+  user: string,
+  action: 'auto-merge-on' | 'auto-merge-off' | 'toggle-auto-merge',
+  via?: Via,
+): Promise<BuildControlResult> {
+  while (true) {
+    const state = reduceBuild(await store.getEvents(slug))
+    activeState(slug, state)
+    const command =
+      action === 'toggle-auto-merge'
+        ? state.autoMerge.requested
+          ? 'auto-merge-off'
+          : 'auto-merge-on'
+        : action
+    if (command === 'auto-merge-on' && discardInFlight(state)) throw discardPending(slug)
+    const actor = humanActor(user, via)
+    // Written out rather than selected into a variable so `appendIfCurrent`'s
+    // `T extends EventType` infers a concrete payload type in each branch.
+    const appended =
+      command === 'auto-merge-on'
+        ? await store.appendIfCurrent(slug, state.lastSeq, {
+            actor,
+            type: 'build.auto-merge-requested',
+            payload: {},
+          })
+        : await store.appendIfCurrent(slug, state.lastSeq, {
+            actor,
+            type: 'build.auto-merge-cancelled',
+            payload: {},
+          })
+    if (appended !== null) return { kind: 'command', slug, command, event: appended }
+    // The stream advanced under us (a racing discard, a fan-out write, a
+    // runner acknowledgement): loop to re-read and re-check before writing.
+  }
+}
+
 function abortPending(slug: string): BuildControlError {
   return new BuildControlError(
     'abort-pending',
@@ -254,6 +334,9 @@ export type ReviseDecision =
   | {
       kind: 'complete'
       artifact: ArtifactRef
+      /** The assets sampled with the authorization; absent for a supplied body
+       * and for authorizations recorded before assets were pinned. */
+      assets?: PinnedAsset[]
       open: OpenEscalation[]
       escalationSeq: number
     }
@@ -289,7 +372,13 @@ export function decideRevise(
       }
     }
     const escalationSeq = Math.max(...[...open, ...pending].map((item) => item.seq))
-    return { kind: 'complete', artifact: authorized.artifact, open, escalationSeq }
+    return {
+      kind: 'complete',
+      artifact: authorized.artifact,
+      ...(authorized.assets !== undefined ? { assets: authorized.assets } : {}),
+      open,
+      escalationSeq,
+    }
   }
   if (open.length === 0) {
     const paused =
@@ -425,9 +514,14 @@ export async function controlBuild(opts: ControlBuildOpts): Promise<BuildControl
   switch (opts.action.kind) {
     case 'pause':
     case 'resume':
+      return appendCommand(opts.store, opts.slug, user, opts.action.kind, opts.via)
+
     case 'auto-merge-on':
     case 'auto-merge-off':
-      return appendCommand(opts.store, opts.slug, user, opts.action.kind, opts.via)
+    case 'toggle-auto-merge':
+      // Consent has its own guarded, compare-and-append write path; the
+      // outer `activeState` above only short-circuits the common inactive case.
+      return appendConsentCommand(opts.store, opts.slug, user, opts.action.kind, opts.via)
 
     case 'dashboard-pause': {
       const pendingPause = state.pendingCommands.some((command) => command.command === 'pause')
@@ -464,15 +558,6 @@ export async function controlBuild(opts: ControlBuildOpts): Promise<BuildControl
       return appendCommand(opts.store, opts.slug, user, 'resume', opts.via)
     }
 
-    case 'toggle-auto-merge':
-      return appendCommand(
-        opts.store,
-        opts.slug,
-        user,
-        state.autoMerge.requested ? 'auto-merge-off' : 'auto-merge-on',
-        opts.via,
-      )
-
     case 'answer': {
       const captured =
         opts.action.escalationIds === undefined ? undefined : new Set(opts.action.escalationIds)
@@ -510,11 +595,16 @@ export async function controlBuild(opts: ControlBuildOpts): Promise<BuildControl
         if (initial.kind === 'refuse') throwRefusal(initial)
 
         let artifact: ArtifactRef
+        // From-ticket revisions re-pin the ticket's assets; a supplied body
+        // leaves the pinned set alone (`undefined`). Sampled once, with the
+        // body, and persisted on the answers so a retry reuses it.
+        let assets: PinnedAsset[] | undefined
         let authorizedEarlier = initial.kind === 'complete'
         if (initial.kind === 'complete') {
           // Completion rule: recorded authorization wins before the caller's
           // lazy body source is opened, regardless of remaining blockers.
           artifact = initial.artifact
+          assets = initial.assets
         } else {
           let body: string
           const source = opts.action.resolve.body
@@ -534,6 +624,7 @@ export async function controlBuild(opts: ControlBuildOpts): Promise<BuildControl
               )
             }
             body = await opts.readTicketBody(record.ticket)
+            assets = await samplePinnedAssets(opts.store, record.repo, record.ticket.id)
           }
           const conformance = specConformance(body)
           if (!conformance.conforms) {
@@ -564,6 +655,7 @@ export async function controlBuild(opts: ControlBuildOpts): Promise<BuildControl
         if (decision.kind === 'refuse') throwRefusal(decision)
         if (decision.kind === 'complete') {
           artifact = decision.artifact
+          assets = decision.assets
           authorizedEarlier = true
         }
         const answer = guidance === '' ? SPEC_REVISION_ANSWER : guidance
@@ -580,13 +672,18 @@ export async function controlBuild(opts: ControlBuildOpts): Promise<BuildControl
               answer,
               resolution: 'revise-spec',
               artifact,
+              ...(assets !== undefined ? { assets } : {}),
             },
           })
         }
         await opts.store.append(opts.slug, {
           actor: KERNEL,
           type: 'spec.revised',
-          payload: { artifact, escalation: decision.escalationSeq },
+          payload: {
+            artifact,
+            escalation: decision.escalationSeq,
+            ...(assets !== undefined ? { assets } : {}),
+          },
         })
         if (alsoPaused) {
           await opts.store.append(opts.slug, {

package/packages/core/src/cli/context.ts

@@ -44,6 +44,7 @@ import {
 } from '../ports/workspace/phase-scratch'
 import type { Exec } from '../ports/workspace/git-worktree'
 import type { BuildStore } from '../store/types'
+import { writeAssetTo } from './ticket-assets'
 import type { CliEnv } from './env'
 
 export interface ContextDeps {
@@ -81,6 +82,16 @@ export interface ContextManifest {
   notesPath?: string
   /** relPath (under .ab/) → source artifact ref, or 'derived'. */
   materialized: Record<string, MaterializedEntry>
+  /** The ticket assets this build froze (SPEC §6.3), each written to `path`
+   * (relative to the workspace). Omitted when the build pinned none. */
+  assets?: {
+    kind: string
+    name: string
+    revision: number
+    layout: 'file' | 'tree'
+    size: number
+    path: string
+  }[]
   /** From the latest `implement.completed` (§8.3 code-review/verify inputs). */
   commitRange?: CommitRange
   /** Reconcile: `{baseSha}` freshly recorded by this attempt's phase start (§15.7). */
@@ -276,6 +287,41 @@ export async function buildContext(deps: ContextDeps): Promise<ContextManifest>
     }
   }
 
+  if (inputs.assets === true && state.pinnedAssets.length > 0) {
+    // The pin, not the ticket's current state: the revisions `build.created`
+    // (or the latest re-pinning `spec.revised`) recorded, fetched by explicit
+    // revision so a later attach/replace/remove cannot change what a phase sees.
+    const root = locate('assets')
+    manifest.assets = []
+    for (const pinned of state.pinnedAssets) {
+      const asset = await store.getPinnedTicketAsset(
+        build,
+        pinned.kind,
+        pinned.name,
+        pinned.revision,
+      )
+      if (asset === null) {
+        throw new Error(
+          `pinned ticket asset ${pinned.kind}/${pinned.name} revision ${pinned.revision} is missing from the store`,
+        )
+      }
+      const relPath = `${root}/${pinned.kind}/${pinned.name}`
+      const target = join(abDir, relPath)
+      // A file asset lands inside its directory as `<filename>`; a tree asset
+      // keeps its relative tree, empty directories included.
+      await mkdir(target, { recursive: true })
+      await writeAssetTo(asset, target)
+      manifest.assets.push({
+        kind: pinned.kind,
+        name: pinned.name,
+        revision: pinned.revision,
+        layout: pinned.layout,
+        size: pinned.size,
+        path: `.ab/${relPath}`,
+      })
+    }
+  }
+
   if (inputs.spec === true) {
     // §6.3 immutability: the spec a phase sees is the rev the spec.* events
     // anchor (spec.imported/authored/revised → state.specRev), never the

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

@@ -38,6 +38,7 @@
 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'
@@ -104,6 +105,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 +162,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 +341,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 +366,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,6 +382,7 @@ 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 } : {}),
   }
 }
 
@@ -490,6 +516,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 +531,9 @@ export function projectBuild(
   config: Config,
   events: AbEvent[],
   streams?: readonly StreamRecord[],
+  pinnedConfig?: Config,
 ): DashboardBuild | null {
+  const pipeline = pinnedConfig ?? config
   const status = effectiveStatus(state)
   if (!isVisible(status)) return null
   const abortProgress =
@@ -663,7 +699,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
@@ -713,7 +749,7 @@ export function projectBuild(
   // 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 +782,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 +823,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 +875,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,7 +902,7 @@ export function projectBuild(
               : `exit status ${state.setupFailure.exitStatus}`
           }): ${state.setupFailure.output || '(no output)'}`
 
-  const decision = decideNext(events, config)
+  const decision = decideNext(events, pipeline)
   const mergeWaitReason =
     decision.kind === 'wait' && decision.reason === 'awaiting-pr'
       ? currentAutoMergeDeferral(events, state)
@@ -875,7 +922,7 @@ 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 } }
       : {}),
@@ -1084,7 +1131,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 {
+  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 {
@@ -109,6 +120,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 +211,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,
         )
@@ -169,7 +228,7 @@ export class DashboardBuildPollCache {
         kind: 'live',
         events,
         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,
           ),
         },
       ]