mandrel 2.61.0 → 2.63.0

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

@@ -3,6 +3,10 @@
  * Non-fatal: a failure returns `{ enabled: false, reason }`. The arm runs from
  * the primary worktree so `--delete-branch`'s local `git checkout <base>`
  * cannot collide with a worktree holding the base.
+ *
+ * A merge-queue base is armed with a bare `--auto` instead: `gh` refuses
+ * `--delete-branch` under a queue, the queue rule picks the strategy, and the
+ * repo's `delete_branch_on_merge` owns the remote branch reap.
  */
 
 import { gh as defaultGh, describeGhFailure } from '../../../gh-exec.js';
@@ -11,6 +15,12 @@ import {
   decideAdvisoryGateBlock,
   deriveRedHeadRuns,
 } from '../../merge-poll.js';
+import {
+  armForMergeQueue,
+  disarmByDequeue,
+  MERGE_QUEUE_REFUSAL,
+  readMergeQueueState,
+} from '../../merge-queue.js';
 
 /**
  * The operator deliberately owns the merge, so close does not wait for it;
@@ -104,8 +114,9 @@ async function directMergeFallback({ exec, prNumber, armCwd, autoReason }) {
  *   gh?: ReturnType<typeof import('../../../gh-exec.js').createGh>,
  *   runner?: (args: string[], opts: object) => ({ status: number, stdout?: string, stderr?: string } | Promise<{ status: number, stdout?: string, stderr?: string }>),
  *   resolveArmCwd?: (cwd: string) => string,
- * }} opts
- * @returns {Promise<{ enabled: boolean, reason?: string, localCleanupDeferred?: boolean, directMerged?: boolean }>}
+ *   queueRequired?: boolean,
+ * }} opts `queueRequired`: the base requires a merge queue.
+ * @returns {Promise<{ enabled: boolean, reason?: string, localCleanupDeferred?: boolean, directMerged?: boolean, mergeQueue?: boolean }>}
  */
 export async function enableAutoMergeWith({
   cwd,
@@ -113,9 +124,19 @@ export async function enableAutoMergeWith({
   gh,
   runner,
   resolveArmCwd = resolveAutoMergeArmCwd,
+  queueRequired = false,
 }) {
   const exec = runner ?? makeDefaultGhAutoMergeRunner(gh ?? defaultGh);
   const armCwd = resolveArmCwd(cwd);
+  const arm = queueRequired ? armForMergeQueue : armNativeAutoMerge;
+  return arm({ exec, prNumber, armCwd });
+}
+
+/**
+ * `--auto --squash --delete-branch`, falling back to a direct squash-merge
+ * only when native auto-merge is unavailable.
+ */
+async function armNativeAutoMerge({ exec, prNumber, armCwd }) {
   try {
     const result = await exec(
       [
@@ -134,6 +155,10 @@ export async function enableAutoMergeWith({
       // The remote side stands; the land tail finishes the local ref reap.
       return { enabled: true, localCleanupDeferred: true, reason: detail };
     }
+    if (MERGE_QUEUE_REFUSAL.test(String(result.stderr ?? ''))) {
+      // The detection probe missed the queue; the refusal names it.
+      return armForMergeQueue({ exec, prNumber, armCwd });
+    }
     if (isAutoMergeUnavailable(result.stderr)) {
       return directMergeFallback({
         exec,
@@ -218,15 +243,32 @@ const NOT_ARMED = /not enabled|isn't enabled|is not set|no auto-?merge/i;
 
 /**
  * Lives here because `lifecycle-lint` confines `gh pr merge` to this module.
- * Never throws.
+ * An enqueued PR is dequeued instead. Never throws.
  *
  * @param {{ prNumber?: number|string, prRef?: string, gh?: object,
- *   progress?: (tag: string, msg: string) => void }} args `prRef` wins over
- *   `prNumber` when both are given.
+ *   progress?: (tag: string, msg: string) => void,
+ *   readMergeQueueStateFn?: typeof readMergeQueueState }} args `prRef` wins
+ *   over `prNumber` when both are given.
  * @returns {Promise<{ disarmed: boolean, alreadyUnarmed: boolean, detail: string }>}
  */
-export async function disarmAutoMerge({ prNumber, prRef, gh, progress }) {
+export async function disarmAutoMerge({
+  prNumber,
+  prRef,
+  gh,
+  progress,
+  readMergeQueueStateFn = readMergeQueueState,
+}) {
   const ref = String(prRef ?? prNumber);
+  const queue = await readMergeQueueStateFn({ prNumber, prRef, gh });
+  const outcome =
+    queue?.inQueue === true && queue.prNodeId
+      ? await disarmByDequeue({ prNodeId: queue.prNodeId, ref, gh, progress })
+      : await disableNativeAutoMerge({ ref, gh, progress });
+  warnIfStillArmed({ outcome, ref, progress });
+  return outcome;
+}
+
+async function disableNativeAutoMerge({ ref, gh, progress }) {
   try {
     await (gh ?? defaultGh).pr.merge(ref, ['--disable-auto']);
     progress?.(
@@ -235,9 +277,7 @@ export async function disarmAutoMerge({ prNumber, prRef, gh, progress }) {
     );
     return { disarmed: true, alreadyUnarmed: false, detail: 'disarmed' };
   } catch (err) {
-    const outcome = classifyDisarmFailure(describeGhFailure(err));
-    warnIfStillArmed({ outcome, ref, progress });
-    return outcome;
+    return classifyDisarmFailure(describeGhFailure(err));
   }
 }
 
@@ -307,6 +347,62 @@ async function evaluateAdvisoryGate({
   };
 }
 
+/**
+ * Report an arm that stood, naming how it will land.
+ *
+ * @returns {{ autoMergeEnabled: true, autoMergeReason: null, localCleanupDeferred: boolean, directMerged?: boolean, mergeQueue?: boolean }}
+ */
+function reportArmed({ result, prNumber, progress }) {
+  if (result.mergeQueue) {
+    progress(
+      'PR',
+      `✅ Auto-merge enabled on PR #${prNumber} (merge queue — the queue rule picks the strategy).`,
+    );
+    return {
+      autoMergeEnabled: true,
+      autoMergeReason: null,
+      localCleanupDeferred: false,
+      mergeQueue: true,
+    };
+  }
+  if (result.directMerged) {
+    progress(
+      'PR',
+      `✅ Native auto-merge unavailable on PR #${prNumber} — direct squash-merge landed it` +
+        (result.localCleanupDeferred
+          ? " (gh's LOCAL branch cleanup deferred to the land tail; the merge stands)."
+          : '.'),
+    );
+    return {
+      autoMergeEnabled: true,
+      autoMergeReason: null,
+      directMerged: true,
+      localCleanupDeferred: Boolean(result.localCleanupDeferred),
+    };
+  }
+  if (result.localCleanupDeferred) {
+    progress(
+      'PR',
+      `⚠️ Auto-merge armed on PR #${prNumber}, but gh's LOCAL branch cleanup failed ` +
+        `(${result.reason}) — deferring the local ref reap to the land tail; the merge stands.`,
+    );
+    return {
+      autoMergeEnabled: true,
+      autoMergeReason: null,
+      localCleanupDeferred: true,
+    };
+  }
+  progress(
+    'PR',
+    `✅ Auto-merge enabled on PR #${prNumber} (squash, delete-branch).`,
+  );
+  return {
+    autoMergeEnabled: true,
+    autoMergeReason: null,
+    localCleanupDeferred: false,
+  };
+}
+
 /**
  * Dispatch auto-merge enablement.
  *
@@ -319,7 +415,7 @@ async function evaluateAdvisoryGate({
  *   gh?: ReturnType<typeof import('../../../gh-exec.js').createGh>,
  *   progress: (tag: string, msg: string) => void,
  * }} args
- * @returns {Promise<{ autoMergeEnabled: boolean, autoMergeReason: string|null, localCleanupDeferred?: boolean, directMerged?: boolean }>}
+ * @returns {Promise<{ autoMergeEnabled: boolean, autoMergeReason: string|null, localCleanupDeferred?: boolean, directMerged?: boolean, mergeQueue?: boolean }>}
  *   `localCleanupDeferred`: the arm stands but the land tail owns the local
  *   ref reap. `directMerged`: landed by direct squash-merge instead.
  */
@@ -334,6 +430,7 @@ export async function runAutoMergePhase({
   gh,
   progress,
   readPrWaitProbeFn = readAdvisoryProbe,
+  readMergeQueueStateFn = readMergeQueueState,
 }) {
   if (noAutoMerge) {
     progress('PR', '⏭  Auto-merge disabled (--no-auto-merge).');
@@ -384,45 +481,14 @@ export async function runAutoMergePhase({
       },
     };
   }
-  const result = await enableAutoMergeWith({ cwd, prNumber, gh });
-  if (result.enabled) {
-    if (result.directMerged) {
-      progress(
-        'PR',
-        `✅ Native auto-merge unavailable on PR #${prNumber} — direct squash-merge landed it` +
-          (result.localCleanupDeferred
-            ? " (gh's LOCAL branch cleanup deferred to the land tail; the merge stands)."
-            : '.'),
-      );
-      return {
-        autoMergeEnabled: true,
-        autoMergeReason: null,
-        directMerged: true,
-        localCleanupDeferred: Boolean(result.localCleanupDeferred),
-      };
-    }
-    if (result.localCleanupDeferred) {
-      progress(
-        'PR',
-        `⚠️ Auto-merge armed on PR #${prNumber}, but gh's LOCAL branch cleanup failed ` +
-          `(${result.reason}) — deferring the local ref reap to the land tail; the merge stands.`,
-      );
-      return {
-        autoMergeEnabled: true,
-        autoMergeReason: null,
-        localCleanupDeferred: true,
-      };
-    }
-    progress(
-      'PR',
-      `✅ Auto-merge enabled on PR #${prNumber} (squash, delete-branch).`,
-    );
-    return {
-      autoMergeEnabled: true,
-      autoMergeReason: null,
-      localCleanupDeferred: false,
-    };
-  }
+  const queue = await readMergeQueueStateFn({ prNumber, gh });
+  const result = await enableAutoMergeWith({
+    cwd,
+    prNumber,
+    gh,
+    queueRequired: queue?.queueRequired === true,
+  });
+  if (result.enabled) return reportArmed({ result, prNumber, progress });
   progress(
     'PR',
     `⚠️ Auto-merge enablement failed (${result.reason}) — operator can merge manually.`,

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

@@ -49,6 +49,7 @@ import {
   readRunSummary,
   resolveAdvisoryGateVerdict,
 } from '../../merge-poll.js';
+import { readMergeQueueState } from '../../merge-queue.js';
 import { NEXT_COMMANDS } from '../../story-deliver-terminal.js';
 import {
   postStructuredComment,
@@ -117,6 +118,30 @@ function readString(value, absent = undefined) {
   return typeof value === 'string' && value ? value : absent;
 }
 
+/**
+ * `inMergeQueue` for a green open PR, the only state GitHub enqueues from;
+ * `undefined` otherwise, so the common poll pays no extra call. An enqueued
+ * PR has no auto-merge request and can read BLOCKED — neither is a disarm.
+ */
+async function readInMergeQueue({
+  view,
+  checksStatus,
+  gh,
+  ghTimeoutMs,
+  readMergeQueueStateFn,
+}) {
+  const prNodeId = readString(view?.id);
+  if (view?.state !== 'OPEN' || checksStatus !== 'success' || !prNodeId) {
+    return undefined;
+  }
+  const queue = await readMergeQueueStateFn({
+    prNodeId,
+    gh,
+    timeoutMs: ghTimeoutMs,
+  });
+  return typeof queue?.inQueue === 'boolean' ? queue.inQueue : undefined;
+}
+
 /**
  * One probe per poll iteration. A failed or timed-out read degrades to
  * `{ checksStatus: 'pending', error }` so a flaky read is never a verdict.
@@ -127,10 +152,12 @@ export async function readPrWaitProbe({
   prNumber,
   gh = defaultGh,
   ghTimeoutMs = MERGE_WAIT_GH_TIMEOUT_MS,
+  readMergeQueueStateFn = readMergeQueueState,
 }) {
   try {
     const view = await withGhTimeout(
       gh.pr.view(prNumber, [
+        'id',
         'state',
         'mergedAt',
         'createdAt',
@@ -142,13 +169,21 @@ export async function readPrWaitProbe({
       ghTimeoutMs,
       `gh pr view ${prNumber}`,
     );
+    const checksStatus = deriveChecksStatus(view?.statusCheckRollup);
     return {
       state: readString(view?.state, null),
       mergedAt: readString(view?.mergedAt, null),
       createdAt: readString(view?.createdAt, null),
       mergeStateStatus: readString(view?.mergeStateStatus),
       reviewDecision: readString(view?.reviewDecision),
-      checksStatus: deriveChecksStatus(view?.statusCheckRollup),
+      checksStatus,
+      inMergeQueue: await readInMergeQueue({
+        view,
+        checksStatus,
+        gh,
+        ghTimeoutMs,
+        readMergeQueueStateFn,
+      }),
       // Head-anchored, so superseded/pending runs don't read as red; `null`
       // when the rollup is empty (the consecutive-probe fallback owns that).
       requiredRunEvidence: deriveRequiredRunEvidence(view?.statusCheckRollup),
@@ -644,6 +679,18 @@ async function resolveAdvisoryUnlanded({
   };
 }
 
+/**
+ * An enqueued PR reads BLOCKED with every check green, which the classifier
+ * would call human-required — but the queue lands it unattended.
+ */
+function queuedExhaustionVerdict(probe, cumulativeMs) {
+  if (probe?.inMergeQueue !== true) return {};
+  return {
+    blockClassOverride: 'checks-pending-timeout',
+    reasonOverride: `PR is still in the merge queue after ${Math.round(cumulativeMs / 1000)} seconds — GitHub merges it when the queue's checks pass; a queued base may need a larger delivery.mergeWatch.maxBudgetSeconds`,
+  };
+}
+
 /** Classify, emit `merge.unlanded`, post friction, block — all best-effort. */
 async function blockOnUnlanded({
   storyId,
@@ -1126,6 +1173,7 @@ export async function runConfirmMergePhase({
             exhausted: true,
             elapsedSeconds: Math.round(cumulativeMs / 1000),
           },
+          ...queuedExhaustionVerdict(probe, cumulativeMs),
         };
       }
     }

package/.agents/scripts/merge-baseline.js

@@ -3,10 +3,12 @@
 /**
  * merge-baseline.js — git merge driver for `baselines/*.json`.
  *
- * A text merge of a baseline either conflicts on the always-different
- * `generatedAt` stamp or, worse, silently splices both sides' rows into a set
- * no scorer produced. This merges rows by identity and re-derives the rollup.
- * Files that are not a known row baseline go to `git merge-file` unchanged.
+ * A text merge of a baseline conflicts on rows adjacent in sort order or
+ * appended at the tail, and can splice both sides' rows into a set no scorer
+ * produced. This merges rows by identity instead. The committed shape carries
+ * no stamp or rollup, so disjoint non-adjacent refreshes also merge textually
+ * where this driver never runs (GitHub). Files that are not a known row
+ * baseline go to `git merge-file` unchanged.
  *
  *   node .agents/scripts/merge-baseline.js %O %A %B %P
  *
@@ -115,7 +117,7 @@ function delegateToGit(basePath, oursPath, theirsPath) {
 }
 
 /**
- * Envelope kinds (rollup re-derived) or plain row baselines (cyclomatic,
+ * Envelope kinds or plain row baselines (cyclomatic,
  * dead-exports*); anything else resolves `null` and goes back to git.
  *
  * @param {unknown} ours
@@ -269,8 +271,8 @@ function markConflicts({ kind, merged, oursPath, label }) {
 }
 
 /**
- * Names the regenerate command: the rollup was derived from unresolved rows,
- * so hand-resolving the markers leaves it describing a tree nobody scored.
+ * Names the regenerate command: hand-resolved rows describe a tree nobody
+ * scored.
  *
  * @param {{ kind: string, label: string, rowConflicts: Array<object>, envelopeConflicts: Array<object> }} args
  */
@@ -286,9 +288,9 @@ function reportConflicts({ kind, label, rowConflicts, envelopeConflicts }) {
     );
   }
   process.stderr.write(
-    `merge-baseline: ${label} is conflicted — the rollup in it was derived from ` +
-      `unresolved rows and must not be trusted. After resolving the markers, ` +
-      `regenerate it: ${baselineRegenerateRemedy(kind)}\n`,
+    `merge-baseline: ${label} is conflicted — hand-resolved rows describe a ` +
+      `tree nobody scored. After resolving the markers, regenerate it: ` +
+      `${baselineRegenerateRemedy(kind)}\n`,
   );
 }
 
@@ -302,7 +304,7 @@ runAsCli(import.meta.url, main, {
   usage: {
     invocation: 'node .agents/scripts/merge-baseline.js %O %A %B %P',
     summary:
-      'Git merge driver for baselines/*.json. Merges per-kind envelopes by ROW IDENTITY — disjoint refreshes merge clean, the rollup is recomputed from the merged rows, and generatedAt resolves to the later stamp instead of conflicting. A baselines file that is not a known per-kind envelope is handed back to git merge-file unchanged. Exit 0 clean, 1 conflicted.',
+      'Git merge driver for baselines/*.json. Merges per-kind envelopes by ROW IDENTITY — disjoint refreshes merge clean even where their rows are adjacent, and a row both sides changed differently conflicts. A baselines file that is not a known per-kind envelope is handed back to git merge-file unchanged. Exit 0 clean, 1 conflicted.',
     flags: [
       ['%O', 'Merge ancestor (git supplies this).'],
       ['%A', 'Our version — the driver writes its result here.'],

package/.agents/workflows/audit-baselines.md

@@ -114,7 +114,8 @@ Two envelope-level reads come **before** any finding:
    gate **High** (delivery reads that file every run), a dead glob **Low**.
 
 2. **Staleness.** Two clocks. `staleDays` is whole days since the baseline's
-   own `generatedAt`; `staleCommits` is commits touching the measured surface
+   own stamp where it carries one, else its last-commit date (row-set
+   baselines carry no stamp); `staleCommits` is commits touching the measured surface
    since the baseline was last committed, with `surfaceStale` its boolean. A
    `null` on either is never a fabricated zero — the stamp is unreadable, git
    cannot answer, or the rows are not file paths — and is itself the finding.

package/docs/CHANGELOG.md

@@ -15,6 +15,24 @@ All notable changes to this project will be documented in this file.
 -->
 <!-- markdownlint-disable-file MD004 MD012 MD037 -->
 
+## [2.63.0](https://github.com/dsj1984/mandrel/compare/mandrel-v2.62.0...mandrel-v2.63.0) (2026-09-18)
+
+
+### ⚠ BREAKING CHANGES
+
+* committed baselines/*.json row-set files no longer carry `generatedAt` or `rollup`, and the per-kind schemas reject both keys. Run `mandrel migrate` (step 2.63.0, run by `mandrel update`) to rewrite existing baselines. `MANDREL_BASELINE_GENERATED_AT` is retired.
+
+### Added
+
+* make committed row-set baselines merge clean without the custom merge driver ([#5400](https://github.com/dsj1984/mandrel/issues/5400)) ([#5401](https://github.com/dsj1984/mandrel/issues/5401)) ([8a2df0a](https://github.com/dsj1984/mandrel/commit/8a2df0aeb6c75c2c08ef70eeb970b88bef716bde))
+
+## [2.62.0](https://github.com/dsj1984/mandrel/compare/mandrel-v2.61.0...mandrel-v2.62.0) (2026-09-18)
+
+
+### Fixed
+
+* **close:** arm auto-merge on a merge-queue-protected base ([#5395](https://github.com/dsj1984/mandrel/issues/5395)) ([#5396](https://github.com/dsj1984/mandrel/issues/5396)) ([6d739ea](https://github.com/dsj1984/mandrel/commit/6d739eadb8ae00bedeb7279b1a765c3e0cc5791e))
+
 ## [2.61.0](https://github.com/dsj1984/mandrel/compare/mandrel-v2.60.0...mandrel-v2.61.0) (2026-09-18)
 
 

package/lib/cli/registry.js

@@ -814,7 +814,7 @@ export function runMergeDriver({ cwd, fsImpl = fs, runner = spawn } = {}) {
   if (command === '') {
     return {
       ok: false,
-      detail: `${BASELINE_MERGE_DRIVER_CONFIG_KEY} is unset — baselines/*.json will fall back to git's text merge, which conflicts on the generatedAt stamp and can splice rows neither branch scored`,
+      detail: `${BASELINE_MERGE_DRIVER_CONFIG_KEY} is unset — baselines/*.json will fall back to git's text merge, which conflicts on adjacent rows and can splice rows neither branch scored`,
       remedy: BASELINE_MERGE_DRIVER_REMEDY,
     };
   }

package/lib/migrations/index.js

@@ -15,6 +15,7 @@ import { retireLintBaselineCommand } from './steps/2.32.0-retire-lint-baseline-c
 import { retireDeliveryLimitKnobs } from './steps/2.57.0-retire-delivery-limit-knobs.js';
 import { retirePlanningLimitKnobs } from './steps/2.57.0-retire-planning-limit-knobs.js';
 import { retireAuditResultsAutoFile } from './steps/2.60.0-retire-audit-results-autofile.js';
+import { baselineMergeQueueShape } from './steps/2.63.0-baseline-merge-queue-shape.js';
 import { stripRemovedAgentrcKeys } from './steps/strip-removed-agentrc-keys.js';
 
 /**
@@ -38,6 +39,7 @@ export const migrations = [
   retireDeliveryLimitKnobs,
   retireAuditResultsAutoFile,
   stripRemovedAgentrcKeys,
+  baselineMergeQueueShape,
 ];
 
 export { compareVersions };

package/lib/migrations/steps/2.63.0-baseline-merge-queue-shape.js

@@ -0,0 +1,96 @@
+// lib/migrations/steps/2.63.0-baseline-merge-queue-shape.js
+/**
+ * Strip `generatedAt` and `rollup` from the committed row-set baselines. Both
+ * were rewritten on every refresh, so two branches refreshing disjoint rows
+ * always conflicted on GitHub, which never runs the custom merge driver.
+ * Readers now derive the rollup from `rows`. Files are identified by their
+ * `$schema` tail; any other baseline is left byte-identical.
+ */
+
+import nodeFs from 'node:fs';
+import path from 'node:path';
+
+const BASELINES_DIR = 'baselines';
+
+/** `$schema` tail → the keys the new shape no longer carries. */
+const RETIRED_KEYS_BY_SCHEMA = Object.freeze({
+  'coverage.schema.json': ['generatedAt', 'rollup'],
+  'crap.schema.json': ['generatedAt', 'rollup'],
+  'maintainability.schema.json': ['generatedAt', 'rollup'],
+  'duplication.schema.json': ['generatedAt', 'rollup'],
+  'mutation.schema.json': ['generatedAt', 'rollup'],
+  'bundle-size.schema.json': ['generatedAt', 'rollup'],
+  'cyclomatic.schema.json': ['generatedAt', 'rollup'],
+  'dead-exports.schema.json': ['generatedAt'],
+});
+
+/**
+ * @param {unknown} envelope
+ * @returns {string[]}
+ */
+function retiredKeysPresent(envelope) {
+  if (!envelope || typeof envelope !== 'object' || Array.isArray(envelope)) {
+    return [];
+  }
+  const schema = envelope.$schema;
+  if (typeof schema !== 'string') return [];
+  const keys = RETIRED_KEYS_BY_SCHEMA[schema.split('/').pop()] ?? [];
+  return keys.filter((key) => Object.hasOwn(envelope, key));
+}
+
+/**
+ * @param {{ projectRoot?: string }} ctx
+ * @param {typeof nodeFs} fsImpl
+ * @returns {Array<{ file: string, envelope: object, keys: string[] }>}
+ */
+function pendingBaselines(ctx, fsImpl) {
+  const dir = path.join(ctx?.projectRoot ?? process.cwd(), BASELINES_DIR);
+  let names;
+  try {
+    names = fsImpl.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of [...names].sort()) {
+    if (!String(name).endsWith('.json')) continue;
+    const file = path.join(dir, String(name));
+    let envelope;
+    try {
+      envelope = JSON.parse(fsImpl.readFileSync(file, 'utf8'));
+    } catch {
+      continue;
+    }
+    const keys = retiredKeysPresent(envelope);
+    if (keys.length > 0) out.push({ file, envelope, keys });
+  }
+  return out;
+}
+
+export const baselineMergeQueueShape = {
+  version: '2.63.0',
+  description:
+    'strip generatedAt and rollup from committed row-set baselines so ' +
+    'disjoint refreshes merge textually on GitHub, where the custom merge ' +
+    'driver never runs (Story #5400)',
+  /**
+   * @param {{ projectRoot?: string, fs?: typeof nodeFs }} [ctx]
+   * @param {typeof nodeFs} [fsImpl]
+   * @returns {boolean}
+   */
+  detect(ctx, fsImpl = ctx?.fs ?? nodeFs) {
+    return pendingBaselines(ctx, fsImpl).length > 0;
+  },
+  /**
+   * @param {{ projectRoot?: string, fs?: typeof nodeFs }} [ctx]
+   * @param {typeof nodeFs} [fsImpl]
+   * @returns {void}
+   */
+  apply(ctx, fsImpl = ctx?.fs ?? nodeFs) {
+    for (const { file, envelope, keys } of pendingBaselines(ctx, fsImpl)) {
+      const next = { ...envelope };
+      for (const key of keys) delete next[key];
+      fsImpl.writeFileSync(file, `${JSON.stringify(next, null, 2)}\n`);
+    }
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mandrel",
-  "version": "2.61.0",
+  "version": "2.63.0",
   "description": "Claude Code-first opinionated workflow framework: instructions, skills, rules, and SDLC workflows that govern AI coding assistants.",
   "files": [
     ".agents/",