mandrel 2.54.0 → 2.55.0

package/.agents/scripts/lib/orchestration/resolve-stories.js

@@ -40,6 +40,13 @@ import { resolveStoryDispatchMode } from './complexity-gate.js';
 /** Labels/state that mean a blocker no longer gates its dependents. */
 const DONE_LABEL = 'agent::done';
 
+/**
+ * The lifecycle-label prefix a deliverable Story carries. Any `agent::*` label
+ * will do — the resolver is not a state machine and does not care WHICH state a
+ * Story is in, only that it has been through the step that assigns one.
+ */
+const AGENT_LABEL_PREFIX = 'agent::';
+
 /**
  * Module-private: `toStoryRecord` and `isSatisfiedBlocker` are its only
  * callers. The ancestor exported it with no external consumer, which is how
@@ -64,9 +71,12 @@ function normalizeIssueLabels(issue) {
  *
  * @param {object} issue
  * @param {number} [requestedId] The id the operator asked for, for error text.
+ * @param {{ allowUnlabelled?: boolean }} [options] `allowUnlabelled` waives the
+ *   `agent::*` guard below — the deliberate escape hatch for delivering a Story
+ *   whose state label is absent for a reason the operator knows about.
  * @returns {{ id, title, body, url, labels, state, assignees }}
  */
-export function toStoryRecord(issue, requestedId) {
+export function toStoryRecord(issue, requestedId, { allowUnlabelled } = {}) {
   const id = Number(issue?.number ?? issue?.id ?? requestedId);
   if (!Number.isInteger(id) || id <= 0) {
     throw new Error(
@@ -88,6 +98,9 @@ export function toStoryRecord(issue, requestedId) {
         `v2 is Story-only — re-plan it as a v2 Story or finish it on a pre-v2 checkout.`,
     );
   }
+  // Last, so the two shape refusals above — not a Story at all, and a v1 body —
+  // keep naming their own remedy rather than being masked by a missing label.
+  assertDispatchable(id, labels, allowUnlabelled);
   return {
     id,
     title: String(issue?.title ?? ''),
@@ -106,6 +119,36 @@ export function toStoryRecord(issue, requestedId) {
   };
 }
 
+/**
+ * Refuse a Story that has never been through planning.
+ *
+ * The audit sweep files Stories deliberately WITHOUT an `agent::*` label: their
+ * bodies are audit prose — a symptom and a recommendation — not a scoped change
+ * with acceptance criteria a worker can verify against, and the sweep's runbook
+ * says so. But `/mandrel-deliver` takes ids, and nothing downstream re-checked the
+ * label, so naming a freshly-filed audit Story dispatched a worker at an
+ * unenriched body: the run then either invented its own acceptance criteria or
+ * blocked several minutes in, having taken the Story's lease and flipped it to
+ * `agent::executing` on the way.
+ *
+ * The label is the cheap, honest signal that the enrich step ran — no state
+ * machine is consulted, only that SOME `agent::*` label exists.
+ *
+ * @param {number} id
+ * @param {string[]} labels
+ * @param {boolean} [allowUnlabelled]
+ */
+function assertDispatchable(id, labels, allowUnlabelled) {
+  if (allowUnlabelled) return;
+  if (labels.some((l) => l.startsWith(AGENT_LABEL_PREFIX))) return;
+  throw new Error(
+    `[resolve-stories] Issue #${id} carries no "${AGENT_LABEL_PREFIX}*" label, so it has not been ` +
+      `through planning — an audit sweep files Stories without one on purpose (its runbook's ` +
+      `"Enrich before you deliver" step). Route it through /mandrel-plan first, which applies ` +
+      `agent::ready once the finding is a scoped slice. Pass --allow-unlabelled to deliver it as-is.`,
+  );
+}
+
 /**
  * A blocker stops gating once its issue is closed or carries `agent::done`.
  *

package/.agents/scripts/lib/orchestration/review-providers/native.js

@@ -372,11 +372,25 @@ export async function analyzeChangedFiles(
 /**
  * Pure: turn a lint summary into Finding(s). Lint errors collapse into a
  * single high-risk finding (the structured comment shows the count); lint
- * warnings collapse into a single suggestion. An `executionFailed` summary
- * produces **zero** findings (Story #4699): a runner that could not execute
- * is an operational degradation, not a code finding — the provider routes it
- * to friction telemetry instead so severity counts reflect code findings
- * only.
+ * warnings collapse into a single suggestion.
+ *
+ * **Findings come from the parsed counts, never from the execution flag**
+ * (Story #5282). `executionFailed` is the OR across the biome and markdownlint
+ * surfaces, so gating findings on it let *one* absent runner discard the
+ * *other* surface's real errors — and since the code surface's disk probe
+ * (#5193) degrades in every checkout without `node_modules/.bin/biome`, that
+ * was the default state of a consumer checkout: markdownlint errors reached
+ * neither the findings nor the severity tally while the outcome read clean
+ * apart from a degradation line.
+ *
+ * Story #4699's intent is preserved exactly, because it was never about the
+ * flag: a degradation is still not a `Finding` — it has no counts to report,
+ * so a surface that could not execute contributes `parsed: false` and zero
+ * counts and produces nothing here, while travelling on the degradation and
+ * friction-telemetry channels under its own name. A summary that explicitly
+ * reports `parsed: false` therefore yields no findings whatever its counts
+ * claim; a summary omitting `parsed` (an injected or pre-#4839 shape) is
+ * scored on its counts as before.
  *
  * @param {{ errors: number, warnings: number, parsed?: boolean, skipped?: boolean, mode?: string, executionFailed?: boolean, evidenceSkipped?: boolean }} lintSummary
  * @returns {Finding[]}
@@ -385,7 +399,7 @@ export function buildLintFindings(lintSummary) {
   if (lintSummary.mode === 'off') return [];
   if (lintSummary.evidenceSkipped) return [];
   if (lintSummary.skipped) return [];
-  if (lintSummary.executionFailed) return [];
+  if (lintSummary.parsed === false) return [];
   const findings = [];
   if (lintSummary.errors > 0) {
     findings.push({
@@ -428,6 +442,7 @@ async function runLintPhase({
       mode: 'off',
       executionFailed: false,
       degradations: [],
+      surfaces: [],
     };
   }
   logger?.info?.(
@@ -592,15 +607,19 @@ export function createNativeProvider(deps = {}) {
         // Story #4839 — telemetry alone left the review's own verdict unable to
         // distinguish "lint ran and found nothing" from "lint never ran", so
         // the same degradation is also recorded on the outcome channel. It is
-        // still never a `Finding`: the friction emission below is unchanged and
-        // severity counts remain code-findings-only.
+        // still never a `Finding`: the friction emission below is unchanged.
+        //
+        // Story #5282 — this branch is about the degraded surface only. A
+        // sibling surface that *did* run still contributes its parsed counts
+        // to `buildLintFindings` below, so a degradation here no longer
+        // suppresses the other surface's errors.
         recordedDegradations = buildLintDegradations(lintSummary);
         logger?.warn?.(
           `[native-review] Lint runner could not execute (${recordedDegradations
             .map((d) => `${d.surface}: ${d.reason}`)
             .join(
               '; ',
-            )}) — reported as a degraded gate on the review outcome and recorded as friction telemetry; no finding emitted. Verify with the canonical \`npm run lint\` before merging.`,
+            )}) — reported as a degraded gate on the review outcome and recorded as friction telemetry; the degradation itself is never a finding, and any surface that did run still reports its own errors. Verify with the canonical \`npm run lint\` before merging.`,
         );
         try {
           await emitToolDegradationFn({
@@ -622,8 +641,9 @@ export function createNativeProvider(deps = {}) {
 
       // Canonical ordering: critical (maintainability) first, then high
       // (lint errors), then medium (size/volume warnings), then suggestion
-      // (lint warnings). An execution failure contributes to none of these
-      // tiers — it travels on the degradation channel. The renderer
+      // (lint warnings). An execution failure contributes no counts of its
+      // own to these tiers — it travels on the degradation channel — but it
+      // no longer suppresses a sibling surface's. The renderer
       // re-bucketizes by severity tier, so this order only matters for
       // stability of fixture outputs.
       return [

package/.agents/scripts/lib/orchestration/review-providers/scoped-lint.js

@@ -289,36 +289,38 @@ export function parseLintOutput(result) {
  * one degradation record naming itself. Merging *summaries* rather than raw
  * output is what stops one runner's failure from becoming the other's verdict.
  *
+ * The OR is deliberately lossy — it answers "did any surface fail?", which is
+ * the only question the degradation channel asks. Story #5282 added the
+ * `surfaces[]` rows so a consumer can ask the *other* questions the OR cannot
+ * answer: which surface the merged counts came from, and — via each row's
+ * `parsed` and `executionFailed` — whether an absent biome or a biome run that
+ * simply reported nothing is behind a zero. Consumers that read the flat
+ * counts are unaffected; the rows are additive.
+ *
  * @param {Array<{ surface: string, summary: ReturnType<typeof parseLintOutput> }>} surfaces
  */
 function mergeSurfaceSummaries(surfaces) {
-  let errors = 0;
-  let warnings = 0;
-  let parsed = false;
-  let executionFailed = false;
-  const degradations = [];
-
-  for (const { surface, summary } of surfaces) {
-    errors += summary.errors;
-    warnings += summary.warnings;
-    if (summary.parsed) parsed = true;
-    if (summary.executionFailed) {
-      executionFailed = true;
-      degradations.push({
-        surface,
-        reason: summary.reason ?? DEGRADATION_REASONS.UNPARSEABLE_OUTPUT,
-      });
-    }
-  }
+  const rows = surfaces.map(({ surface, summary }) => ({
+    surface,
+    parsed: summary.parsed,
+    errors: summary.errors,
+    warnings: summary.warnings,
+    executionFailed: summary.executionFailed,
+    reason: summary.reason ?? DEGRADATION_REASONS.UNPARSEABLE_OUTPUT,
+  }));
+  const total = (field) => rows.reduce((sum, row) => sum + row[field], 0);
 
   return {
-    errors,
-    warnings,
-    parsed,
-    executionFailed,
+    errors: total('errors'),
+    warnings: total('warnings'),
+    parsed: rows.some((row) => row.parsed),
+    executionFailed: rows.some((row) => row.executionFailed),
     skipped: false,
     mode: 'changed-only',
-    degradations,
+    degradations: rows
+      .filter((row) => row.executionFailed)
+      .map(({ surface, reason }) => ({ surface, reason })),
+    surfaces: rows.map(({ reason, ...row }) => row),
   };
 }
 
@@ -329,7 +331,7 @@ function mergeSurfaceSummaries(surfaces) {
  * @param {string} cwd
  * @param {typeof spawnLintRunner} [runnerFn]
  * @param {{ existsFn?: (p: string) => boolean }} [deps]  Test seam for runner resolution.
- * @returns {{ errors: number, warnings: number, parsed: boolean, skipped: boolean, mode: 'changed-only'|'off', executionFailed: boolean, degradations: Array<{ surface: string, reason: string }> }}
+ * @returns {{ errors: number, warnings: number, parsed: boolean, skipped: boolean, mode: 'changed-only'|'off', executionFailed: boolean, degradations: Array<{ surface: string, reason: string }>, surfaces: Array<{ surface: string, parsed: boolean, errors: number, warnings: number, executionFailed: boolean }> }}
  */
 export function runScopedLint(
   changedFiles,
@@ -348,6 +350,7 @@ export function runScopedLint(
       mode: 'changed-only',
       executionFailed: false,
       degradations: [],
+      surfaces: [],
     };
   }
 

package/.agents/scripts/lib/orchestration/run-epilogue.js

@@ -7,8 +7,8 @@
  *   2. Rolls up friction follow-ups across every Story in the run and
  *      files/posts them on the primary Story.
  *   3. Checks sibling Spec/acceptance coherence across Story bodies.
- *   4. Reports the container Epics whose children all landed (Story #5139),
- *      delegating the derivation and the close to `epic-rollup.js`.
+ *   4. Reports what the per-Story land tails left the run's container Epics
+ *      in — closed, or still open (Story #5139; read-only since #5280).
  *
  * There is no inert planner-only path: `planRunEpilogue` enumerates steps
  * and `runPlanRunEpilogue` executes them. Single-Story runs skip the
@@ -21,7 +21,7 @@ import { selectAudits } from '../audit-suite/index.js';
 import { graduateRetroProposals } from '../feedback-loop/retro-proposals-graduator.js';
 import { gitSpawn } from '../git-utils.js';
 import { Logger } from '../Logger.js';
-import { rollUpEpicForStory } from './epic-rollup.js';
+import { isEpicTicket } from './epic-container.js';
 import { composeRoutedProposals } from './retro-proposals.js';
 import {
   assessRollupOutcome,
@@ -44,54 +44,51 @@ export const RUN_EPILOGUE_STEP_KINDS = Object.freeze([
 ]);
 
 /**
- * Close every container Epic whose children all landed in this run.
+ * Report which container Epics this run's Stories left closed, and which are
+ * still open.
  *
- * Delegates to `epic-rollup.js` (Story #5205) rather than deriving anything
- * itself. That module owns the child→parent scan, the body-checklist-union-
- * native-sub-issue child read, and the one-way closure rule, and it is also
- * invoked from the per-Story land tail — which is what closes a container
- * whose last open child was a single Story, a case this epilogue never
- * reaches because a one-Story run reports `applicable: false`.
+ * **It derives nothing and writes nothing.** It used to: it walked every Story
+ * and re-ran the full rollup, closing containers itself. That made sense while
+ * the rollup only fired on the edges someone had wired, and the epilogue was
+ * the backstop for the ones that were missed. Every child state change is now
+ * an edge — init, post-land, the supersede close — so by the time the last
+ * Story of a run has landed, its container has already been derived from a
+ * complete child set by that Story's own land tail. Re-deriving here would ask
+ * the same question a second time and answer it identically, at the cost of a
+ * full re-read per Story and a second writer on the same issue.
  *
- * The step survives for its report: this is the surface an operator reads to
- * see which containers a multi-Story run closed and which are still pending.
+ * What survives is the report, which is why the step exists at all: one place
+ * an operator reads to see what a multi-Story run did to its containers. A
+ * pending Epic here is a real signal — it means a land tail's rollup declined
+ * to close, and the tail's own outcome says why.
  *
- * Non-fatal throughout: the epilogue is a reporting tail, and a container
- * left open costs tidiness, not correctness.
+ * Non-fatal throughout: a container it cannot read is simply not reported.
  *
- * @param {{ stories: string[], provider: object, config?: object }} opts
+ * @param {{ stories: string[], provider: object }} opts
  * @returns {Promise<{ kind: string, closed: number[], pending: number[] }>}
  */
-async function executeEpicClose({ stories, provider, config }) {
+async function executeEpicClose({ stories, provider }) {
   const closed = new Set();
   const pending = new Set();
-  // Siblings share a container, so an Epic resolved by one Story's rollup is
-  // withheld from the next one's — otherwise the second Story would re-derive
-  // and re-close what the first already closed.
+  // Siblings share a container: resolve each distinct Epic once, however many
+  // of the run's Stories point at it.
   const seen = new Set();
 
-  // `rollUpEpicForStory` never throws and always returns the full envelope,
-  // so its three lists are read directly — a `?? []` guard here would be an
-  // unreachable branch asserting a contract the module already keeps.
   for (const raw of stories) {
     const storyId = Number(raw);
     if (!Number.isInteger(storyId) || storyId <= 0) continue;
-    const outcome = await rollUpEpicForStory({
-      storyId,
-      provider,
-      config,
-      skipEpicIds: seen,
-    });
-    for (const epic of outcome.epics) seen.add(epic.epicId);
-    for (const epicId of outcome.closed) closed.add(epicId);
-    for (const epicId of outcome.pending) pending.add(epicId);
+    const epic = await readContainerFor({ storyId, provider });
+    if (!epic) continue;
+    const epicId = Number(epic.id);
+    if (!Number.isInteger(epicId) || seen.has(epicId)) continue;
+    seen.add(epicId);
+    if (String(epic.state ?? '').toLowerCase() === 'closed') {
+      closed.add(epicId);
+    } else {
+      pending.add(epicId);
+    }
   }
 
-  // An Epic this run closed can also have been reported pending by an
-  // earlier Story's rollup, when a sibling had not landed yet. The close is
-  // the later, truer answer.
-  for (const epicId of closed) pending.delete(epicId);
-
   return {
     kind: 'epic-close',
     closed: [...closed],
@@ -99,6 +96,30 @@ async function executeEpicClose({ stories, provider, config }) {
   };
 }
 
+/**
+ * Read one Story's container Epic, or null.
+ *
+ * One request per Story via the declared parent port. Degrades to null on any
+ * failure and on a provider without the port — this is a report, and a
+ * container it could not read is better omitted than guessed at.
+ *
+ * @param {{ storyId: number, provider: object }} opts
+ * @returns {Promise<object|null>}
+ */
+async function readContainerFor({ storyId, provider }) {
+  if (typeof provider?.getParentIssue !== 'function') return null;
+  try {
+    const parent = await provider.getParentIssue(storyId);
+    return parent && isEpicTicket(parent) ? parent : null;
+  } catch (err) {
+    Logger.warn(
+      `[run-epilogue] could not read the container for Story #${storyId} ` +
+        `(${err?.message ?? err}); omitting it from the Epic report.`,
+    );
+    return null;
+  }
+}
+
 /**
  * @param {string|number|{ id?: string|number, slug?: string }} entry
  * @returns {string|null}
@@ -185,7 +206,7 @@ export function planRunEpilogue({ planRunId, stories } = {}) {
     },
     {
       kind: 'epic-close',
-      description: `Close any container Epic whose children all landed in run ${effectiveRunId}`,
+      description: `Report the container Epic state the land tails of run ${effectiveRunId} left behind`,
       stories: ids,
     },
   ];
@@ -892,7 +913,7 @@ export async function runPlanRunEpilogue({
         );
       } else if (step.kind === 'epic-close') {
         results.push(
-          await executeEpicClose({ stories: plan.stories, provider, config }),
+          await executeEpicClose({ stories: plan.stories, provider }),
         );
       }
     } catch (err) {

package/.agents/scripts/lib/orchestration/single-story-close/close-note.js

@@ -0,0 +1,81 @@
+/**
+ * close-note.js — the human-readable `note` on close's result record
+ * (Story #5266).
+ *
+ * ## Why this is its own module
+ *
+ * The note used to branch on `waitedForMerge` — whether close *waited* — and
+ * not on `merged`. A bounded wait that expired with the PR still open
+ * therefore wrote "Close-and-land: PR merge confirmed … the issue closed"
+ * into `story-close-result-<id>.log` **beside `merged: false`**, while the
+ * schema-validated terminal envelope correctly reported
+ * `status: pending, phase: confirm-merge`. That log is what close's summary
+ * line points the operator at, so the contradiction is what gets read first:
+ * a merge that never happened, reported as confirmed.
+ *
+ * The invariant this module exists to hold:
+ *
+ *   > **No note may assert a state the same object denies.**
+ *
+ * Every branch below is therefore derived from the result's OWN
+ * `merged` / `directMerged` / `autoMergeEnabled` / `landCompleted` fields —
+ * the ones the note ships next to — so no input can produce a note that
+ * contradicts them. Story #5279 added the fourth, because `merged: true`
+ * used to imply the flip, the issue close and the post-land tail: a direct
+ * squash-merge under `--no-wait-merge`, and a merge whose `agent::done` write
+ * failed, now reach it with none of the three, and reusing the confirmed
+ * wording for them would reintroduce the defect above one field over. The
+ * unmerged branches deliberately claim nothing about the Story's label state
+ * either: close's ending may be `pending` OR `blocked` with the same
+ * `merged: false`, and the terminal envelope is the authority on which. They
+ * also avoid the merge-completion vocabulary entirely — no `agent::done`, no
+ * "the merge confirms" — so that a reader skimming for those words cannot
+ * take a next-step instruction for a report of what happened.
+ */
+
+/**
+ * The one line the note is not allowed to get wrong.
+ *
+ * @param {{ merged?: boolean, directMerged?: boolean,
+ *   autoMergeEnabled?: boolean, landCompleted?: boolean }} result
+ *   `landCompleted` — did THIS run flip `agent::done`, close the issue and
+ *   run the post-land tail? Defaults to `merged`, the pre-#5279 equivalence.
+ * @returns {string}
+ */
+export function deriveCloseNote({
+  merged = false,
+  directMerged = false,
+  autoMergeEnabled = false,
+  landCompleted = merged,
+} = {}) {
+  if (merged) {
+    const how = directMerged
+      ? 'PR merge confirmed by a DIRECT squash-merge (native auto-merge was ' +
+        'unavailable on this repository).'
+      : 'PR merge confirmed.';
+    return landCompleted
+      ? `Close-and-land: ${how} Story flipped agent::closing → agent::done, ` +
+          'the issue closed (confirmStoryMerged), and the post-land tail ran.'
+      : `Close-and-land: ${how} This close did NOT finish the land: ` +
+          'agent::done was not flipped and the post-land tail did not run. ' +
+          'Finish it with single-story-confirm-merge.js, idempotent against an ' +
+          'already-merged PR. The terminal envelope is authoritative.';
+  }
+  if (autoMergeEnabled) {
+    return (
+      'PR open against baseBranch and NOT merged; auto-merge is armed. ' +
+      'GitHub will squash-merge it once the required checks pass — resume ' +
+      'with single-story-confirm-merge.js then, to finish the land and ' +
+      'release the lease this close is still holding. The terminal envelope ' +
+      '(status / phase / blocked) is authoritative for what happened here.'
+    );
+  }
+  return (
+    'PR open against baseBranch and NOT merged; auto-merge was not armed ' +
+    '(see autoMergeReason). The operator owns the land: merge via the GitHub ' +
+    'UI, then resume with single-story-confirm-merge.js to finish the land ' +
+    'and release the lease this close is still holding. The terminal ' +
+    'envelope (status / phase / blocked) is authoritative for what happened ' +
+    'here.'
+  );
+}

package/.agents/scripts/lib/orchestration/single-story-close/failed-terminal.js

@@ -50,8 +50,11 @@ const GATE_PHASES = Object.freeze([
 ]);
 
 /**
- * The names the split baselines gate registers under, mirrored from
- * `BASELINES_GATE_NAMES` in `lib/close-validation/gates.js` (Story #5172).
+ * The names the unified baselines gate can register under, mirrored from
+ * `BASELINES_GATE_NAMES` in `lib/close-validation/gates.js` (Story #5172) —
+ * all three, matching the projection the SUCCESS path applies in
+ * `runner.js#baselinesEnvelopeGates`, so the two endings of one run cannot
+ * key the same gate differently.
  *
  * Deliberately a local copy rather than an import: several close suites
  * replace that module wholesale via `t.mock.module`, and a named import here
@@ -61,48 +64,37 @@ const GATE_PHASES = Object.freeze([
  * against each other so the copy cannot drift.
  */
 const BASELINES_ENTRY_NAMES = Object.freeze([
+  'check-baselines',
   'check-baselines-independent',
   'check-baselines-coverage',
 ]);
 
 /**
- * Outcome for each split baselines entry on a run that died at `phase`.
+ * Project the baselines entries out of the per-gate outcomes THIS run
+ * observed (Story #5279).
  *
- * The two entries sit in ONE pipeline phase, so the phase walk alone cannot
- * separate them — `failedGate` (tagged onto the error by the close-validation
- * phase) is what names the entry that actually broke. Rules, in the module's
- * house style of never claiming a pass it cannot prove:
- *   - validation skipped, or the run died before reaching it → both `skipped`.
- *   - the run cleared validation entirely → both `passed`.
- *   - the run died IN validation on the coverage-independent entry → that one
- *     `failed`, the coverage one `skipped` (it runs behind `coverage-capture`,
- *     which the failure pre-empted).
- *   - died on the coverage-consuming entry → that one `failed`, and the
- *     independent one `passed`: it is in the parallel partition that must go
- *     green before any serial gate starts.
- *   - died in validation on some other gate → both `skipped`; which of them
- *     had run is not knowable from the phase alone.
+ * This used to RECONSTRUCT them: it inferred, from the phase the run died in
+ * plus the name of the failing gate, what the two split entries "must have"
+ * done — and it did so over a hardcoded pair, so every failed close reported
+ * both split names whether or not the run had ever registered them. A repo
+ * whose config resolves to the unsplit `check-baselines`, or to only one half
+ * of the pair, got envelope keys for gates that did not exist; a run that
+ * died at `init` got them too, reported as `skipped`, which reads as "the
+ * gate was turned off" rather than "there was no such gate".
  *
- * @param {string} phase
- * @param {{ skipValidation?: boolean, failedGate?: string|null }} args
+ * Reporting instead of reconstructing removes the whole class: an outcome
+ * appears only for a gate the run actually observed, and the runner tags
+ * exactly that set onto the error (`err.closeGates`).
+ *
+ * @param {Record<string, string>|null|undefined} observedGates
  * @returns {Record<string, 'passed'|'failed'|'skipped'>}
  */
-function baselinesGatesForFailedPhase(phase, { skipValidation, failedGate }) {
-  const [independent, coverage] = BASELINES_ENTRY_NAMES;
-  const both = (outcome) => ({ [independent]: outcome, [coverage]: outcome });
-  const failedAt = PHASE_ORDER.indexOf(phase);
-  const validationAt = PHASE_ORDER.indexOf('close-validation');
-  if (skipValidation || failedAt < 0 || failedAt < validationAt) {
-    return both('skipped');
-  }
-  if (failedAt > validationAt) return both('passed');
-  if (failedGate === independent) {
-    return { [independent]: 'failed', [coverage]: 'skipped' };
-  }
-  if (failedGate === coverage) {
-    return { [independent]: 'passed', [coverage]: 'failed' };
+function baselinesGatesObserved(observedGates) {
+  const out = {};
+  for (const [name, outcome] of Object.entries(observedGates ?? {})) {
+    if (BASELINES_ENTRY_NAMES.includes(name)) out[name] = outcome;
   }
-  return both('skipped');
+  return out;
 }
 
 /**
@@ -119,14 +111,17 @@ function baselinesGatesForFailedPhase(phase, { skipValidation, failedGate }) {
  * turned off via `--skip-validation` / `--skip-sync` is `skipped` too (it did
  * not pass — it never ran).
  *
- * Story #5172 — the reported set also carries the two split baselines
- * entries under their own names, so a failed close says WHICH half of the
- * baselines gate breached instead of a single generic verdict.
+ * Story #5172 — the reported set also carries the baselines entries under
+ * their own names, so a failed close says WHICH half of the baselines gate
+ * breached instead of a single generic verdict. Story #5279 — those names
+ * are REPORTED from `observedGates`, never reconstructed, so only a gate the
+ * run registered can appear.
  *
  * @param {string} phase The phase the run died in.
- * @param {{ skipValidation?: boolean, skipSync?: boolean, failedGate?: string|null }} args
- *   Parsed CLI args, plus the gate name tagged onto the error by the
- *   close-validation phase.
+ * @param {{ skipValidation?: boolean, skipSync?: boolean,
+ *   observedGates?: Record<string, string>|null }} args
+ *   Parsed CLI args, plus the per-gate outcomes the runner tagged onto the
+ *   error.
  * @returns {Record<string, 'passed'|'failed'|'skipped'>}
  */
 export function gatesForFailedPhase(phase, args = {}) {
@@ -139,13 +134,7 @@ export function gatesForFailedPhase(phase, args = {}) {
     else if (failedAt < 0 || at > failedAt) gates[gate] = 'skipped';
     else gates[gate] = skipped[gate] ? 'skipped' : 'passed';
   }
-  return {
-    ...gates,
-    ...baselinesGatesForFailedPhase(phase, {
-      skipValidation: args.skipValidation,
-      failedGate: args.failedGate ?? null,
-    }),
-  };
+  return { ...gates, ...baselinesGatesObserved(args.observedGates) };
 }
 
 /**
@@ -163,9 +152,9 @@ export function gatesForFailedPhase(phase, args = {}) {
  * holding the script had been reaped mid-run. On failure this returns null
  * and the caller rethrows the original.
  *
- * `err.closeGate` — tagged by the close-validation phase — names the gate that
- * died inside that phase, which is what lets the reported gates separate the
- * two split baselines entries (Story #5172).
+ * `err.closeGates` — tagged by the runner — carries the per-gate outcomes the
+ * run observed, which is what lets the reported gates name the baselines
+ * entries that actually ran (Story #5172 / #5279) instead of a hardcoded pair.
  *
  * @param {unknown} err
  * @param {{ storyId?: string|number, skipValidation?: boolean, skipSync?: boolean }} args
@@ -186,7 +175,7 @@ export function failedTerminalFor(err, args = {}) {
       phase,
       gates: gatesForFailedPhase(phase, {
         ...args,
-        failedGate: err?.closeGate ?? null,
+        observedGates: err?.closeGates ?? null,
       }),
       failure: { reason: String(err?.message ?? err) },
       nextCommand: NEXT_COMMANDS.recover(storyId),

package/.agents/scripts/lib/orchestration/single-story-close/phases/auto-merge.js

@@ -66,7 +66,7 @@ import { resolveAutoMergeArmCwd } from '../../auto-merge-cwd.js';
 import {
   advisoryCheckFailedBlocksArm,
   deriveRedHeadRuns,
-  formatAdvisoryGateReason,
+  resolveAdvisoryGateVerdict,
   selectBlockingRedRuns,
 } from '../../merge-poll.js';
 
@@ -430,10 +430,17 @@ async function evaluateAdvisoryGate({
     probe.redHeadRuns,
     advisoryAllowlist,
   );
+  // Story #5266 — the class travels with the reason. This pre-arm gate
+  // classifies on the text the ROLLUP carried (a legacy StatusContext's
+  // `description`); the merge wait, which owns the common case, additionally
+  // reads the check-run output. Either way a run whose failure cannot be read
+  // as "never finished" keeps the `advisory-gate-red` verdict.
+  const verdict = resolveAdvisoryGateVerdict({ blockingRuns });
   return {
     blocked: true,
     blockingRuns,
-    reason: formatAdvisoryGateReason(blockingRuns),
+    blockClass: verdict.blockClass,
+    reason: verdict.reason,
   };
 }
 
@@ -522,6 +529,7 @@ export async function runAutoMergePhase({
       autoMergeReason: 'advisory-gate-red',
       advisoryGate: {
         blockingRuns: advisory.blockingRuns,
+        blockClass: advisory.blockClass,
         reason: advisory.reason,
       },
     };