mandrel 2.41.0 → 2.43.0

package/.agents/scripts/lib/orchestration/planning/memory-pool-advisory.js

@@ -19,12 +19,28 @@
  * only the attended `/memory-consolidate` pass, reading content, can tell the
  * difference. This module counts and stats; it never judges an entry.
  *
+ * **Growth, never size (Story #5182).** The second arm used to be an absolute
+ * ceiling of a hundred entries. A consolidation pass prefers `correct` over
+ * `dead` by design, so a pool that crosses a fixed ceiling stays over it
+ * forever: the nudge then fired on every plan however fresh the stamp, and a
+ * permanent recommendation is one the operator learns to ignore. The arm now
+ * measures **entries written since the last pass** — the one quantity a pass
+ * actually resets, because Step 6 records the post-rewrite entry count in the
+ * stamp as the next run's growth baseline.
+ *
+ * A stamp carrying a date but no usable `entryCount` (every stamp written
+ * before that Story) leaves growth **unmeasured**. That is not
+ * "never consolidated" — an operator did review the pool — so the growth arm
+ * simply stays silent and only the age arm can speak, until the next pass
+ * writes a baseline.
+ *
  * Detection is filesystem-only — no child processes, no `gh` probes, no
  * network. Every failure path fails soft to "no pool, no recommendation": the
  * advisory can degrade the nudge, never a plan.
  *
  * Test seams: `cwd`, `env`, `fsImpl` (node:fs-compatible `statSync` /
- * `readdirSync` / `readFileSync`), `now`, and the two thresholds.
+ * `readdirSync` / `readFileSync`), `now`, and the two thresholds
+ * (`staleAfterDays`, `growthDelta`).
  *
  * `buildMemoryPoolAdvisory` is the **only** export: the helpers below have no
  * caller outside this module, and exporting one solely for a test would add a
@@ -40,8 +56,8 @@ import * as path from 'node:path';
 /** Recommend a consolidation pass once the stamp is this old. */
 const STALE_AFTER_DAYS = 30;
 
-/** Recommend a consolidation pass once the pool holds more entries than this. */
-const ENTRY_COUNT_CEILING = 100;
+/** Recommend a pass once this many entries were written since the last one. */
+const GROWTH_DELTA = 25;
 
 /** Stamp file written by `/memory-consolidate` after its operator gate. */
 const STAMP_FILENAME = '.consolidation-stamp.json';
@@ -94,21 +110,47 @@ function resolveMemoryPoolDir({ cwd, env = process.env, homedir } = {}) {
 }
 
 /**
- * Read the consolidation stamp, returning its ISO timestamp or `null`.
- * A missing, unreadable, unparseable, or malformed stamp is indistinguishable
+ * The growth baseline a stamp records: its entry count, or `null` when it
+ * records none. `null` is *unmeasured*, never zero — a zero baseline would
+ * score every entry in the pool as newly written.
+ *
+ * @param {unknown} count
+ * @returns {number|null}
+ */
+function readBaseline(count) {
+  return Number.isInteger(count) && count >= 0 ? count : null;
+}
+
+/**
+ * Read the consolidation stamp.
+ *
+ * `at` is the ISO timestamp of the last pass, or `null` when there was none:
+ * a missing, unreadable, unparseable or date-less stamp is indistinguishable
  * from "never consolidated" — all four mean the same thing to the advisory.
+ * A stamp whose date is unusable carries no baseline either, so `baseline`
+ * follows it to `null` rather than describing a pass that cannot be dated.
+ *
+ * `baseline` is the entry count that pass left behind — the growth arm's
+ * reference point. It is `null` on a stamp that predates Story #5182 (date
+ * only) and on a malformed count, which reads as *unmeasured growth*, never
+ * as zero growth: a `0` baseline would score the whole pool as new.
  *
- * @returns {string|null}
+ * @returns {{ at: string|null, baseline: number|null }}
  */
 function readStamp({ poolDir, fsImpl }) {
+  const unstamped = { at: null, baseline: null };
   try {
     const raw = fsImpl.readFileSync(path.join(poolDir, STAMP_FILENAME), 'utf8');
     const parsed = JSON.parse(raw);
-    const value = parsed?.lastConsolidatedAt;
-    if (typeof value !== 'string' || value.length === 0) return null;
-    return Number.isNaN(Date.parse(value)) ? null : value;
+    const at = parsed.lastConsolidatedAt;
+    // `Date.parse` rejects the empty string as NaN, so this one test covers
+    // both an absent date and an unusable one.
+    if (typeof at !== 'string' || Number.isNaN(Date.parse(at))) {
+      return unstamped;
+    }
+    return { at, baseline: readBaseline(parsed.entryCount) };
   } catch {
-    return null;
+    return unstamped;
   }
 }
 
@@ -127,6 +169,83 @@ function countEntries({ poolDir, fsImpl }) {
   }
 }
 
+/**
+ * The advisory's field set, defaulted to the fail-soft "no usable pool"
+ * reading. Every return path spreads its own findings over this, so the
+ * envelope's shape is declared once — a new field cannot reach some callers
+ * and not others, which is the failure mode a per-branch object literal has.
+ *
+ * @param {object} fields
+ * @returns {{ present: boolean, entryCount: number, lastConsolidatedAt: string|null,
+ *            entriesSinceConsolidation: number|null, recommend: boolean,
+ *            reasons: string[] }}
+ */
+function envelope(fields) {
+  return {
+    present: false,
+    entryCount: 0,
+    lastConsolidatedAt: null,
+    entriesSinceConsolidation: null,
+    recommend: false,
+    reasons: [],
+    ...fields,
+  };
+}
+
+/**
+ * Collect the reasons a pool wants a consolidation pass. An empty array is
+ * the quiet verdict; the caller turns it into `recommend` and supplies the
+ * standing-down sentence, so every arm lives in one place.
+ *
+ * The two arms are independent and both are reported when both fire.
+ *
+ * @param {{ stamp: { at: string|null, baseline: number|null },
+ *           growth: number|null, now: Date|string|number,
+ *           staleAfterDays: number, growthDelta: number }} args
+ * @returns {string[]}
+ */
+function collectReasons({ stamp, growth, now, staleAfterDays, growthDelta }) {
+  const reasons = [];
+
+  if (stamp.at === null) {
+    reasons.push(
+      'no consolidation stamp — this pool has never been consolidated',
+    );
+  } else {
+    const ageDays =
+      (new Date(now).getTime() - Date.parse(stamp.at)) / MS_PER_DAY;
+    if (ageDays > staleAfterDays) {
+      reasons.push(
+        `last consolidated ${Math.floor(ageDays)} days ago (over the ${staleAfterDays}-day threshold)`,
+      );
+    }
+  }
+
+  // `growth === null` is unmeasured, not zero — a pre-#5182 stamp carries no
+  // baseline, and guessing one would re-invent the ceiling this arm replaced.
+  if (growth !== null && growth >= growthDelta) {
+    reasons.push(
+      `${growth} entries written since the last consolidation (at or over the ${growthDelta}-entry growth delta)`,
+    );
+  }
+
+  return reasons;
+}
+
+/**
+ * The sentence a quiet pool explains itself with — one per reason it is quiet,
+ * so "nothing to do" never reads the same as "nothing measurable".
+ *
+ * @param {{ growth: number|null, growthDelta: number }} args
+ * @returns {string}
+ */
+function quietReason({ growth, growthDelta }) {
+  if (growth === null) {
+    return 'memory pool is within the freshness threshold; growth is unmeasured until the next /memory-consolidate stamps an entry count';
+  }
+  return `memory pool is within both thresholds — ${growth} entries written since the last consolidation (under the ${growthDelta}-entry growth delta)`;
+}
+
 /**
  * Build the `memoryPoolAdvisory` envelope field.
  *
@@ -141,9 +260,10 @@ function countEntries({ poolDir, fsImpl }) {
  * @param {string} [opts.homedir]
  * @param {Date|string|number} [opts.now]
  * @param {number} [opts.staleAfterDays]
- * @param {number} [opts.entryCountCeiling]
+ * @param {number} [opts.growthDelta]
  * @returns {{ present: boolean, entryCount: number, lastConsolidatedAt: string|null,
- *            recommend: boolean, reasons: string[] }}
+ *            entriesSinceConsolidation: number|null, recommend: boolean,
+ *            reasons: string[] }}
  */
 export function buildMemoryPoolAdvisory({
   cwd = process.cwd(),
@@ -152,15 +272,9 @@ export function buildMemoryPoolAdvisory({
   homedir,
   now = new Date(),
   staleAfterDays = STALE_AFTER_DAYS,
-  entryCountCeiling = ENTRY_COUNT_CEILING,
+  growthDelta = GROWTH_DELTA,
 } = {}) {
-  const absent = (reason) => ({
-    present: false,
-    entryCount: 0,
-    lastConsolidatedAt: null,
-    recommend: false,
-    reasons: [reason],
-  });
+  const absent = (reason) => envelope({ reasons: [reason] });
 
   const poolDir = resolveMemoryPoolDir({ cwd, env, homedir });
   if (!poolDir) {
@@ -184,48 +298,38 @@ export function buildMemoryPoolAdvisory({
     return absent(`memory pool at ${poolDir} could not be listed`);
   }
 
-  const lastConsolidatedAt = readStamp({ poolDir, fsImpl });
-  const reasons = [];
+  const stamp = readStamp({ poolDir, fsImpl });
+  // Reported raw: a pruning pass can leave this negative, and saying the pool
+  // shrank by 7 is more use to the operator than clamping it to zero.
+  const growth = stamp.baseline === null ? null : entryCount - stamp.baseline;
+
+  const found = {
+    present: true,
+    entryCount,
+    lastConsolidatedAt: stamp.at,
+    entriesSinceConsolidation: growth,
+  };
 
   // An empty pool has nothing to consolidate, whatever the stamp says.
   if (entryCount === 0) {
-    return {
-      present: true,
-      entryCount: 0,
-      lastConsolidatedAt,
-      recommend: false,
+    return envelope({
+      ...found,
       reasons: ['memory pool is empty — nothing to consolidate'],
-    };
+    });
   }
 
-  if (lastConsolidatedAt === null) {
-    reasons.push(
-      'no consolidation stamp — this pool has never been consolidated',
-    );
-  } else {
-    const ageDays =
-      (new Date(now).getTime() - Date.parse(lastConsolidatedAt)) / MS_PER_DAY;
-    if (ageDays > staleAfterDays) {
-      reasons.push(
-        `last consolidated ${Math.floor(ageDays)} days ago (over the ${staleAfterDays}-day threshold)`,
-      );
-    }
-  }
-
-  if (entryCount > entryCountCeiling) {
-    reasons.push(
-      `${entryCount} entries (over the ${entryCountCeiling}-entry threshold)`,
-    );
-  }
+  const reasons = collectReasons({
+    stamp,
+    growth,
+    now,
+    staleAfterDays,
+    growthDelta,
+  });
 
-  return {
-    present: true,
-    entryCount,
-    lastConsolidatedAt,
+  return envelope({
+    ...found,
     recommend: reasons.length > 0,
     reasons:
-      reasons.length > 0
-        ? reasons
-        : ['memory pool is within both freshness thresholds'],
-  };
+      reasons.length > 0 ? reasons : [quietReason({ growth, growthDelta })],
+  });
 }

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

@@ -27,8 +27,12 @@ import {
 const PHASE_ORDER = Object.freeze([
   'init',
   'wrong-tree-guard',
-  'close-validation',
+  // Story #5172 — base-sync now precedes close-validation, so the tree the
+  // gates validate is the tree the push sends. The order here is not
+  // decoration: it is how a failed terminal decides which gates had already
+  // cleared, so it MUST track `runPrePushPhases`.
   'base-sync',
+  'close-validation',
   'push',
   'pull-request',
   'code-review',
@@ -45,6 +49,62 @@ const GATE_PHASES = Object.freeze([
   ['codeReview', 'code-review'],
 ]);
 
+/**
+ * The names the split baselines gate registers under, mirrored from
+ * `BASELINES_GATE_NAMES` in `lib/close-validation/gates.js` (Story #5172).
+ *
+ * Deliberately a local copy rather than an import: several close suites
+ * replace that module wholesale via `t.mock.module`, and a named import here
+ * would fail to link against a mock that does not re-export the constant —
+ * turning an unrelated test's mock into a load error on the CLI's own entry
+ * path. `tests/close-validation-gates-enum.test.js` pins the two lists
+ * against each other so the copy cannot drift.
+ */
+const BASELINES_ENTRY_NAMES = Object.freeze([
+  'check-baselines-independent',
+  'check-baselines-coverage',
+]);
+
+/**
+ * Outcome for each split baselines entry on a run that died at `phase`.
+ *
+ * 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.
+ *
+ * @param {string} phase
+ * @param {{ skipValidation?: boolean, failedGate?: string|null }} args
+ * @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' };
+  }
+  return both('skipped');
+}
+
 /**
  * Report every gate's outcome for a run that died at `phase`.
  *
@@ -59,8 +119,14 @@ const GATE_PHASES = Object.freeze([
  * 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.
+ *
  * @param {string} phase The phase the run died in.
- * @param {{ skipValidation?: boolean, skipSync?: boolean }} args Parsed CLI args.
+ * @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.
  * @returns {Record<string, 'passed'|'failed'|'skipped'>}
  */
 export function gatesForFailedPhase(phase, args = {}) {
@@ -73,7 +139,13 @@ export function gatesForFailedPhase(phase, args = {}) {
     else if (failedAt < 0 || at > failedAt) gates[gate] = 'skipped';
     else gates[gate] = skipped[gate] ? 'skipped' : 'passed';
   }
-  return gates;
+  return {
+    ...gates,
+    ...baselinesGatesForFailedPhase(phase, {
+      skipValidation: args.skipValidation,
+      failedGate: args.failedGate ?? null,
+    }),
+  };
 }
 
 /**
@@ -91,6 +163,10 @@ 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).
+ *
  * @param {unknown} err
  * @param {{ storyId?: string|number, skipValidation?: boolean, skipSync?: boolean }} args
  *   Parsed CLI args — the story id the envelope reports on, plus the skip
@@ -108,7 +184,10 @@ export function failedTerminalFor(err, args = {}) {
       storyId,
       status: 'failed',
       phase,
-      gates: gatesForFailedPhase(phase, args),
+      gates: gatesForFailedPhase(phase, {
+        ...args,
+        failedGate: err?.closeGate ?? null,
+      }),
       failure: { reason: String(err?.message ?? err) },
       nextCommand: NEXT_COMMANDS.recover(storyId),
       elapsedSeconds: 0,

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

@@ -79,6 +79,10 @@ import { createGateLogSink as defaultCreateGateLogSink } from '../gate-log.js';
  *   runScopedFormatAutofix?: typeof defaultRunScopedFormatAutofix,
  *   createGateLogSink?: typeof defaultCreateGateLogSink,
  * }} args
+ * @returns {Promise<{ gates: Record<string, 'passed'|'skipped'> }>} Per-gate
+ *   outcomes keyed by gate name — the terminal envelope reports the split
+ *   baselines entries from this (Story #5172). A failure throws instead, with
+ *   `err.closeGate` naming the gate that died.
  */
 export async function runCloseValidationPhase({
   cwd,
@@ -144,17 +148,18 @@ export async function runCloseValidationPhase({
   // Story #4736 — one sink for both `log` seams (gate construction and gate
   // execution), so nothing in the chain can route around the artifact.
   const gateLog = createGateLogSink({ storyId, config });
+  const gateList = buildDefaultGates({
+    config,
+    baseBranch,
+    cwd: worktreePath || cwd,
+    log: gateLog.log,
+  });
   let validation;
   try {
     validation = await runCloseValidation({
       cwd,
       worktreePath,
-      gates: buildDefaultGates({
-        config,
-        baseBranch,
-        cwd: worktreePath || cwd,
-        log: gateLog.log,
-      }),
+      gates: gateList,
       log: gateLog.log,
       storyId,
       // Story #4250 — standalone storyId-anchored evidence keyspace. No
@@ -182,10 +187,37 @@ export async function runCloseValidationPhase({
     // The evidence is the point on this path: replay the captured tail inline
     // rather than making the caller open a file to learn why close stopped.
     gateLog.replay();
-    throw new Error(
+    const err = new Error(
       `[single-story-close] Gate failed: ${gate.name} (exit ${status})${gateCwd ? ` in ${gateCwd}` : ''}.` +
         (gate.hint ? ` ${gate.hint}` : ''),
     );
+    // Story #5172 — the phase tracker tags `closePhase`; this tags WHICH gate
+    // inside the phase died, so the failed terminal can name the split
+    // baselines entry rather than reporting a generic validation failure.
+    err.closeGate = gate.name;
+    throw err;
   }
   progress('VALIDATE', `✅ All gates passed. ${gateLog.digest()}`);
+  return { gates: gateOutcomes(gateList, validation) };
+}
+
+/**
+ * Per-gate outcomes for a validation run that passed (Story #5172).
+ *
+ * Every registered gate passed unless the runner reported it skipped — an
+ * evidence short-circuit at unchanged HEAD, or a changed-file scope that
+ * matched nothing. `skipped` is the honest verdict for both: the gate did not
+ * run in THIS invocation, and the terminal schema's own contract is that a
+ * skipped gate is reported as skipped rather than quietly counted as a pass.
+ *
+ * @param {Array<{ name: string }>} gateList The gates this run registered.
+ * @param {{ skipped?: Array<{ gate: { name: string } }> }} validation
+ * @returns {Record<string, 'passed'|'skipped'>}
+ */
+function gateOutcomes(gateList, validation) {
+  const outcomes = {};
+  for (const gate of gateList) outcomes[gate.name] = 'passed';
+  for (const { gate } of validation.skipped ?? [])
+    outcomes[gate.name] = 'skipped';
+  return outcomes;
 }

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

@@ -1,6 +1,9 @@
 import nodeFs from 'node:fs';
 import path from 'node:path';
-import { buildDefaultGates } from '../../close-validation/gates.js';
+import {
+  BASELINES_GATE_NAMES,
+  buildDefaultGates,
+} from '../../close-validation/gates.js';
 import { runCloseValidation } from '../../close-validation/runner.js';
 import { getCiDelivery } from '../../config/ci.js';
 import { resolveConfig } from '../../config-resolver.js';
@@ -135,12 +138,57 @@ async function alreadyClosedResult(storyId, stateReason = null, config) {
   return { success: true, result, terminal };
 }
 
+/**
+ * Project the baselines entries out of close-validation's per-gate outcomes,
+ * keyed by the gate's own name (Story #5172).
+ *
+ * The envelope's `gates` map used to roll the whole gate chain up into a
+ * single `validation` verdict, which was fine while the baselines gate was
+ * one entry and stopped being fine when it became two: a reader of a failed
+ * close could not tell whether the cheap coverage-independent baselines had
+ * breached or the expensive coverage-consuming ones had. Only registered
+ * entries are reported — a consumer whose config registers just one of the
+ * pair gets just that one, never a phantom key for a gate that never existed.
+ *
+ * @param {Record<string, string>|null|undefined} validationGates
+ * @returns {Record<string, string>}
+ */
+function baselinesEnvelopeGates(validationGates) {
+  const registered = Object.values(BASELINES_GATE_NAMES);
+  const out = {};
+  for (const [name, outcome] of Object.entries(validationGates ?? {})) {
+    if (registered.includes(name)) out[name] = outcome;
+  }
+  return out;
+}
+
 function resolveWorktreePath({ cwd, config, storyId }) {
   const root = config.delivery?.worktreeIsolation?.root ?? '.worktrees';
   const candidate = path.resolve(cwd, root, `story-${storyId}`);
   return nodeFs.existsSync(candidate) ? candidate : null;
 }
 
+/**
+ * The pre-push phases, in the order the pipeline walks them: wrong-tree
+ * guard → base-sync → close-validation.
+ *
+ * Story #5172 put base-sync AHEAD of close-validation, for two reasons that
+ * are really one. The cheap one: a base-sync conflict is a hard block that
+ * costs nothing to detect, so paying for the full gate chain before
+ * discovering it burns the pipeline's most expensive minutes on a tree that
+ * was never going to be pushed. The load-bearing one: with the gates last,
+ * **the validated tree is the pushed tree**. Under the old order the merge
+ * commit base-sync writes landed AFTER validation, so every close pushed a
+ * tree no gate had ever seen.
+ *
+ * `--skip-sync` and `--skip-validation` stay independent — either, both or
+ * neither may be set, and each still elides exactly its own phase.
+ *
+ * @returns {Promise<{ validationGates: Record<string, string>|null }>}
+ *   The per-gate outcomes close-validation observed, or `null` when the phase
+ *   was skipped. Feeds the terminal envelope's `gates` map so the split
+ *   baselines entries are separable there.
+ */
 async function runPrePushPhases({
   cwd,
   worktreePath,
@@ -166,22 +214,6 @@ async function runPrePushPhases({
     progress,
     gitSpawn: injectedGitSpawn,
   });
-  if (!skipValidation) {
-    setPhase('close-validation');
-    await runCloseValidationPhase({
-      cwd,
-      worktreePath,
-      config,
-      baseBranch,
-      storyBranch,
-      storyId,
-      progress,
-      runCloseValidation,
-      buildDefaultGates,
-    });
-  } else {
-    progress('VALIDATE', '⏭ Skipped (--skip-validation).');
-  }
   if (!skipSync) {
     setPhase('base-sync');
     await runBaseSyncPhase({
@@ -198,6 +230,23 @@ async function runPrePushPhases({
   } else {
     progress('SYNC', '⏭ Skipped (--skip-sync).');
   }
+  if (skipValidation) {
+    progress('VALIDATE', '⏭ Skipped (--skip-validation).');
+    return { validationGates: null };
+  }
+  setPhase('close-validation');
+  const validation = await runCloseValidationPhase({
+    cwd,
+    worktreePath,
+    config,
+    baseBranch,
+    storyBranch,
+    storyId,
+    progress,
+    runCloseValidation,
+    buildDefaultGates,
+  });
+  return { validationGates: validation?.gates ?? null };
 }
 
 async function openAndReviewPr({
@@ -743,7 +792,7 @@ async function runClosePipeline({
     config,
     injectedReleaseLease,
   };
-  await releaseLeaseOnBlock(
+  const { validationGates } = await releaseLeaseOnBlock(
     () =>
       runPrePushPhases({
         ...options,
@@ -881,6 +930,9 @@ async function runClosePipeline({
     startedAtMs,
     gates: {
       validation: options.skipValidation ? 'skipped' : 'passed',
+      // Story #5172 — the split baselines entries, named individually so a
+      // reader can tell the two apart. Absent when validation was skipped.
+      ...baselinesEnvelopeGates(validationGates),
       baseSync: options.skipSync ? 'skipped' : 'passed',
       // An overridden blocker reports `overridden`, never
       // `passed`. The review DID fail; a human authorized shipping anyway, and