mandrel 2.36.0 → 2.37.0

package/.agents/scripts/quality-preview.js

@@ -292,7 +292,9 @@ export function computeExitCode(merged, miExit, crapExit) {
  *
  * The last header used to hardcode `c=8`, which quietly lied to any consumer
  * that had tuned `codingGuardrails.cyclomaticFlag`. It now names the value the
- * count was actually taken against, read off the merge result.
+ * count was actually taken against, read off the merge result — through the
+ * same `normalizeFlag` the merge itself uses, rather than the second, hand-
+ * inlined copy of that coercion this function used to carry.
  *
  * Pure — accepts pre-computed merge rows and returns a multi-line string. The
  * table renders even on a clean diff so operators see the "no drift" signal.
@@ -300,33 +302,40 @@ export function computeExitCode(merged, miExit, crapExit) {
  * @param {{ rows: Array<{ file: string, miDrop: number, worstCrapDelta: number, newOverCeilingMethods: number }>, totals: { miRegressions: number, crapViolations: number }, cyclomaticFlag?: number }} merged
  * @returns {string}
  */
+/**
+ * The table's body: one row per regressed file, or the single placeholder
+ * line that keeps the "no drift" signal visible on a clean diff.
+ *
+ * Split out of `renderTable` so that function keeps a flat shape — the
+ * empty-vs-populated branch and the row loop together carried it above the
+ * per-method CRAP contract the pre-push preview enforces.
+ *
+ * @param {Array<{ file: string, miDrop: number, worstCrapDelta: number, newOverCeilingMethods: number }>} rows
+ * @returns {string[]}
+ */
+function tableBodyLines(rows) {
+  if (rows.length === 0) return ['| _(no per-file regressions)_ | — | — | — |'];
+  return rows.map(
+    (row) =>
+      `| ${row.file} | -${row.miDrop.toFixed(2)} | +${row.worstCrapDelta.toFixed(2)} | ${row.newOverCeilingMethods} |`,
+  );
+}
+
 export function renderTable(merged) {
-  const flag = Number.isFinite(Number(merged?.cyclomaticFlag))
-    ? Number(merged.cyclomaticFlag)
-    : DEFAULT_CYCLOMATIC_FLAG;
+  const flag = normalizeFlag(merged?.cyclomaticFlag);
   const header = [
     'file',
     'MI delta',
     'worst CRAP delta',
     `new-method count over c=${flag}`,
   ];
-  const lines = [];
-  lines.push(`| ${header.join(' | ')} |`);
-  lines.push(`| ${header.map(() => '---').join(' | ')} |`);
-  if (merged.rows.length === 0) {
-    lines.push('| _(no per-file regressions)_ | — | — | — |');
-  } else {
-    for (const row of merged.rows) {
-      lines.push(
-        `| ${row.file} | -${row.miDrop.toFixed(2)} | +${row.worstCrapDelta.toFixed(2)} | ${row.newOverCeilingMethods} |`,
-      );
-    }
-  }
-  lines.push('');
-  lines.push(
+  return [
+    `| ${header.join(' | ')} |`,
+    `| ${header.map(() => '---').join(' | ')} |`,
+    ...tableBodyLines(merged.rows),
+    '',
     `Totals: MI regressions=${merged.totals.miRegressions} · CRAP violations=${merged.totals.crapViolations}`,
-  );
-  return lines.join('\n');
+  ].join('\n');
 }
 
 /**
@@ -354,6 +363,96 @@ function resolveCyclomaticFlag({ cwd, stderr }) {
   }
 }
 
+/**
+ * Invoke one preview runner, degrading a thrown failure into the same
+ * `{ exitCode: 1, envelope: null }` shape a real gate failure produces.
+ *
+ * Both runners degraded identically before, in two hand-copied `catch`
+ * arms; folding them into one helper removes the copy and keeps `runCli` a
+ * pipeline rather than a pair of inlined error handlers. The emitted message
+ * is byte-identical to the arm it replaces — `label` supplies the `MI` /
+ * `CRAP` prefix.
+ *
+ * @param {(args: object) => Promise<{exitCode: number, envelope: object|null}>} runner
+ * @param {{cwd: string, staged: boolean, changedSinceRef: string|null}} args
+ * @param {'MI'|'CRAP'} label
+ * @param {{ write: (s: string) => void }} stderr
+ * @returns {Promise<{exitCode: number, envelope: object|null}>}
+ */
+function runGateSafely(runner, args, label, stderr) {
+  return runner(args).catch((err) => {
+    stderr.write(
+      `[quality:preview] ${label} runner failed: ${err?.message ?? err}\n`,
+    );
+    return { exitCode: 1, envelope: null };
+  });
+}
+
+/**
+ * Write the run's report — the `--json` envelope, or the human-readable
+ * table plus any gate diagnostics and the non-zero-exit summary.
+ *
+ * Split out of `runCli` (Story #5109): the rendering half carried five of
+ * that function's decision points, which put it over the per-method CRAP
+ * contract the pre-push preview enforces. Output bytes are unchanged in both
+ * modes. The exit code stays with the caller — this function only reports.
+ *
+ * @param {{
+ *   json: boolean,
+ *   staged: boolean,
+ *   ref: string|null,
+ *   miResult: {exitCode: number, envelope: object|null},
+ *   crapResult: {exitCode: number, envelope: object|null},
+ *   merged: ReturnType<typeof mergeEnvelopes>,
+ *   stdout: { write: (s: string) => void },
+ *   stderr: { write: (s: string) => void },
+ * }} args
+ * @returns {void}
+ */
+function emitReport({
+  json,
+  staged,
+  ref,
+  miResult,
+  crapResult,
+  merged,
+  stdout,
+  stderr,
+}) {
+  const miExit = miResult.exitCode;
+  const crapExit = crapResult.exitCode;
+  if (json) {
+    stdout.write(
+      `${JSON.stringify(
+        {
+          ref: staged ? null : ref,
+          staged,
+          mi: { exit: miExit, envelope: miResult.envelope },
+          crap: { exit: crapExit, envelope: crapResult.envelope },
+          merged,
+        },
+        null,
+        2,
+      )}\n`,
+    );
+    return;
+  }
+  stdout.write('\n--- quality:preview ---\n');
+  stdout.write(
+    staged
+      ? 'scope=staged (git diff --cached)\n\n'
+      : `scope=diff ref=${ref}\n\n`,
+  );
+  stdout.write(`${renderTable(merged)}\n`);
+  const diagnostics = renderDiagnostics([miResult, crapResult]);
+  if (diagnostics) stdout.write(`\n${diagnostics}\n`);
+  if (miExit !== 0 || crapExit !== 0) {
+    stderr.write(
+      `\n[quality:preview] gate exits: mi=${miExit} crap=${crapExit}\n`,
+    );
+  }
+}
+
 /**
  * Top-level CLI entry: invoke both per-kind preview runners, merge, render,
  * and exit with the right code. Exposed as `runCli` so tests can drive the
@@ -381,62 +480,55 @@ export async function runCli({
   const staged = parseStagedFlag(argv);
   const ref = staged ? null : (parseChangedSinceArg(argv) ?? 'HEAD');
 
-  const [miResult, crapResult] = await Promise.all([
-    runMi({ cwd, staged, changedSinceRef: ref }).catch((err) => {
-      stderr.write(
-        `[quality:preview] MI runner failed: ${err?.message ?? err}\n`,
-      );
-      return { exitCode: 1, envelope: null };
-    }),
-    runCrap({ cwd, staged, changedSinceRef: ref }).catch((err) => {
-      stderr.write(
-        `[quality:preview] CRAP runner failed: ${err?.message ?? err}\n`,
-      );
-      return { exitCode: 1, envelope: null };
-    }),
-  ]);
-  const miExit = miResult.exitCode;
-  const crapExit = crapResult.exitCode;
-  const miEnvelope = miResult.envelope;
-  const crapEnvelope = crapResult.envelope;
+  // Story #5109 — the two gates run **one after the other**, not under a
+  // `Promise.all`. Each scores its batch with its own `runOnPool` budget
+  // sized to `os.availableParallelism()`, so overlapping them oversubscribed
+  // the host by 2x and stacked two escomplex heaps: a 58-file preview peaked
+  // at 1.0-1.2 GB RSS for 3.9 s of CPU. Serialising them bounds the preview
+  // to one `availableParallelism` of workers and one heap at a time. The two
+  // runners share no state and neither reads the other's envelope, so the
+  // emitted envelopes — and therefore the merged table and the exit code —
+  // are identical either way; only the peak cost differs.
+  //
+  // Each runner gets its own options literal rather than one shared object,
+  // so serialising them cannot introduce a coupling the concurrent form
+  // did not have.
+  const miResult = await runGateSafely(
+    runMi,
+    { cwd, staged, changedSinceRef: ref },
+    'MI',
+    stderr,
+  );
+  const crapResult = await runGateSafely(
+    runCrap,
+    { cwd, staged, changedSinceRef: ref },
+    'CRAP',
+    stderr,
+  );
+
   // Story #4923 — the over-ceiling column counts against the *resolved*
   // `codingGuardrails.cyclomaticFlag`, not the literal that used to be written
   // into `mergeEnvelopes` and the column header.
   const cyclomaticFlag = resolveCyclomaticFlag({ cwd, stderr });
-  const merged = mergeEnvelopes(miEnvelope, crapEnvelope, { cyclomaticFlag });
+  const merged = mergeEnvelopes(miResult.envelope, crapResult.envelope, {
+    cyclomaticFlag,
+  });
 
-  if (json) {
-    stdout.write(
-      `${JSON.stringify(
-        {
-          ref: staged ? null : ref,
-          staged,
-          mi: { exit: miExit, envelope: miEnvelope },
-          crap: { exit: crapExit, envelope: crapEnvelope },
-          merged,
-        },
-        null,
-        2,
-      )}\n`,
-    );
-  } else {
-    stdout.write('\n--- quality:preview ---\n');
-    stdout.write(
-      staged
-        ? 'scope=staged (git diff --cached)\n\n'
-        : `scope=diff ref=${ref}\n\n`,
-    );
-    stdout.write(`${renderTable(merged)}\n`);
-    const diagnostics = renderDiagnostics([miResult, crapResult]);
-    if (diagnostics) stdout.write(`\n${diagnostics}\n`);
-    if (miExit !== 0 || crapExit !== 0) {
-      stderr.write(
-        `\n[quality:preview] gate exits: mi=${miExit} crap=${crapExit}\n`,
-      );
-    }
-  }
+  emitReport({
+    json,
+    staged,
+    ref,
+    miResult,
+    crapResult,
+    merged,
+    stdout,
+    stderr,
+  });
 
-  return { exitCode: computeExitCode(merged, miExit, crapExit), merged };
+  return {
+    exitCode: computeExitCode(merged, miResult.exitCode, crapResult.exitCode),
+    merged,
+  };
 }
 
 // cli-opt-out: Windows-aware main-guard with leading-slash drive-letter normalisation; mirrors quality-watch.js so the diagnostic surface stays consistent across the gate suite.

package/.agents/scripts/run-test-profile.js

@@ -69,11 +69,14 @@ export function runTestProfile({
   const { outDir, topN, testArgv } = parseProfileArgv(argv);
   fsLike.mkdirSync(outDir, { recursive: true });
 
-  const nodeArgs = [
-    ...buildNodeTestArgs({ extraArgs: testArgv }),
-    '--test-reporter',
-    'tap',
-  ];
+  // The reporter is a *builder option*, not a suffix. Appended after the
+  // file targets it was two more positionals to Node, the default reporter
+  // ran, and every profile parsed `Timed entries parsed: 0` off a full
+  // suite run. `buildNodeTestArgs` places it in flag position.
+  const nodeArgs = buildNodeTestArgs({
+    extraArgs: testArgv,
+    reporter: 'tap',
+  });
 
   const started = Date.now();
   const result = spawnChild(process.execPath, nodeArgs, {

package/.agents/scripts/run-tests.js

@@ -16,16 +16,18 @@
  * to opt back in for the rare case where a contract test deliberately
  * exercises a sandbox endpoint.
  *
- * Windows arg-length safety: the `quick` / `integration` tiers enumerate
- * explicit test-file targets (they exclude specific slow suites, so a single
- * glob will not do). With ~700+ targets the joined command line crosses the
- * Windows `CreateProcess` ~32 767-char `lpCommandLine` ceiling, and
- * `spawnSync` throws `ENAMETOOLONG` before a single test runs. To stay safe
- * on every platform the runner partitions the targets into chunks whose
- * joined length stays well under that ceiling (`MAX_TARGET_CHARS`) and spawns
- * one `node --test` process per chunk, aggregating the exit codes. The
- * `full` tier (a single recursive `tests` glob) yields exactly one chunk, so
- * its behaviour is unchanged.
+ * Windows arg-length safety: every tier enumerates explicit test-file
+ * targets. `quick` / `integration` always did (they exclude specific slow
+ * suites, so a single glob will not do), and `full` joined them in Story
+ * #5111 — `node --test` has no negative pattern, so "everything except
+ * `tests/e2e/**`" is only sayable as a file set. With ~700+ targets the
+ * joined command line crosses the Windows `CreateProcess` ~32 767-char
+ * `lpCommandLine` ceiling, and `spawnSync` throws `ENAMETOOLONG` before a
+ * single test runs. To stay safe on every platform the runner partitions the
+ * targets into chunks whose joined length stays well under that ceiling
+ * (`MAX_TARGET_CHARS`) and spawns one `node --test` process per chunk,
+ * aggregating the exit codes. On POSIX the far larger
+ * `POSIX_MAX_TARGET_CHARS` budget collapses every tier back into one spawn.
  */
 
 import { spawnSync } from 'node:child_process';
@@ -126,18 +128,38 @@ export function chunkTestTargets(targets, maxChars = MAX_TARGET_CHARS) {
 }
 
 /**
+ * Build the argv for one `node --test` invocation.
+ *
+ * **Flag position is load-bearing.** Node stops treating tokens as options
+ * at the first positional, so every runner flag — the fixed
+ * `TEST_RUNNER_FLAGS`, the optional `--test-reporter`, and any caller
+ * `extraArgs` — has to sit *before* the test-file targets. Appending
+ * `--test-reporter tap` after the targets (what `run-test-profile.js` used
+ * to do) made Node read the two tokens as two more file patterns: the
+ * default reporter ran, no TAP was emitted, and the profiler parsed zero
+ * timed entries out of a full suite run. `reporter` is therefore an option
+ * of this builder rather than something a caller concatenates on the end.
+ *
  * @param {object} [opts]
- * @param {string[]} [opts.extraArgs]
+ * @param {string[]} [opts.extraArgs] Extra runner arguments (flag position).
  * @param {'full' | 'quick' | 'integration'} [opts.tier]
  * @param {string} [opts.repoRoot]
+ * @param {string} [opts.reporter] `--test-reporter` value, e.g. `'tap'`.
+ * @returns {string[]}
  */
 export function buildNodeTestArgs({
   extraArgs = [],
   tier = 'full',
   repoRoot = ROOT,
+  reporter,
 } = {}) {
-  const targets = listTestFilesForTier(tier, repoRoot);
-  return [...TEST_RUNNER_FLAGS, ...targets, ...extraArgs];
+  return [
+    ...(reporter
+      ? [...TEST_RUNNER_FLAGS, '--test-reporter', reporter]
+      : TEST_RUNNER_FLAGS),
+    ...extraArgs,
+    ...listTestFilesForTier(tier, repoRoot),
+  ];
 }
 
 export function runTestSuite({
@@ -169,7 +191,13 @@ export function runTestSuite({
   for (const chunk of chunks) {
     const testRun = spawn(
       process.execPath,
-      [...TEST_RUNNER_FLAGS, ...chunk, ...rest],
+      // `rest` carries the documented `node --test` pass-throughs
+      // (`--test-name-pattern`, `--test-only`) — `parseTierArgv` has already
+      // rejected anything else. They precede the targets for the same reason
+      // `buildNodeTestArgs` orders them that way: Node stops parsing options
+      // at the first positional, so a flag after a target is silently read as
+      // another file pattern.
+      [...TEST_RUNNER_FLAGS, ...rest, ...chunk],
       { cwd, stdio: 'inherit', env },
     );
     if (testRun.error) {
@@ -199,7 +227,44 @@ export function runTestSuite({
   return status;
 }
 
+/**
+ * `--help` contract for the runner — the pre-rendered shape
+ * `lib/cli-usage.js` accepts alongside a spec object, matching how
+ * `check-baselines.js` declares its own.
+ *
+ * Handed to `runAsCli`, which prints it and returns **before** `main` runs.
+ * That ordering is the whole point: with no `usage` the flag fell through to
+ * `runTestSuite`, which ran the tier preflight, spawned the full ~10 000-test
+ * suite, and swept `temp/` — 25+ seconds and a mutated working tree in
+ * answer to a question about flags.
+ *
+ * Exported so the unit test can assert the documented surface without
+ * spawning the CLI.
+ */
+export const USAGE = `Usage: node .agents/scripts/run-tests.js [--tier <full|quick|integration|e2e>] [runner args...]
+
+Run the test suite: tier preflight, \`node --test\` over the tier's targets,
+then reserved-temp cleanup — which runs even when the suite fails.
+
+Flags:
+  --tier <full|quick|integration|e2e>
+                        Tier to run. Default: full — every test file except
+                        \`tests/e2e/**\`, which only \`--tier e2e\` runs.
+  --test-name-pattern <re>, --test-only
+                        The documented \`node --test\` pass-throughs, forwarded
+                        verbatim in flag position, ahead of the file targets.
+                        Any other \`--flag\` is rejected rather than forwarded:
+                        \`node --test\` reads an unrecognized flag as another
+                        file pattern, so forwarding one ran nothing and
+                        still exited 0.
+  --help                Show this message.
+
+Exits with the first non-zero \`node --test\` chunk status, or 2 when the tier
+preflight refuses to start the suite.
+`;
+
 runAsCli(import.meta.url, async () => runTestSuite(), {
   source: 'run-tests',
   propagateExitCode: true,
+  usage: USAGE,
 });

package/.agents/scripts/single-story-close.js

@@ -237,8 +237,6 @@ runAsCli(import.meta.url, main, {
         // the point of this flag is that arming stays on the one code path.
         'Land despite a Story-scope code-review CRITICAL blocker you have reviewed and judged wrong. The reason is mandatory (≥12 chars) and is recorded on the Story, on the PR, and as a `review-block-overridden` friction signal; the terminal envelope reports `gates.codeReview: "overridden"`. Use this instead of merging the PR by hand with the GitHub CLI — a hand-merge bypasses the gate with no record at all.',
       ],
-      ['--no-evidence', 'Do not reuse or write gate evidence stamps.'],
-      ['--dry-run', 'Report the plan; mutate nothing.'],
     ],
     notes: [
       'Exit codes:\n  0  landed\n  1  blocked or failed\n  3  pending (resumable — run the envelope’s nextCommand)',

package/.agents/scripts/single-story-init.js

@@ -73,6 +73,7 @@ import {
 } from './lib/orchestration/ticketing.js';
 import { createProvider } from './lib/provider-factory.js';
 import { buildProtectionCtx } from './lib/single-story-sweep/protection-ctx.js';
+import { resolveSweepLockPath } from './lib/single-story-sweep/sweep-lock.js';
 // `sweepMergedStoryBranches` is imported dynamically below — its transitive
 // graph reaches `picomatch` (via `git-cleanup.js`). Loading it statically
 // would crash module resolution before `assertDepsInstalled()` can emit a
@@ -292,6 +293,9 @@ export function decideStoryBranchSeed({ localHas, remoteHas }) {
  *     in `sweep.protected` for the operator).
  *   - Cross-session lock: a single lockfile under `tempRoot` prevents
  *     two concurrent `/single-story-deliver` invocations from racing.
+ *     Story #5112 made that lockfile shared with `boot-sweep.js` — the
+ *     other entry point into the same merged-branch reap — by routing
+ *     both through `resolveSweepLockPath`.
  *
  * Exported for testing.
  */
@@ -307,7 +311,7 @@ export async function reapMergedStoryBranches({
     injectedSweep ??
     (await import('./lib/single-story-sweep.js')).sweepMergedStoryBranches;
   const tempRoot = config?.project?.paths?.tempRoot ?? 'temp';
-  const lockPath = path.resolve(cwd, tempRoot, 'single-story-sweep.lock');
+  const lockPath = resolveSweepLockPath({ cwd, tempRoot });
   const lockTimeoutMs =
     config.delivery?.worktreeIsolation?.sweepLockMs ?? 60_000;
   try {

package/docs/CHANGELOG.md

@@ -15,6 +15,38 @@ All notable changes to this project will be documented in this file.
 -->
 <!-- markdownlint-disable-file MD004 MD012 MD037 -->
 
+## [2.37.0](https://github.com/dsj1984/mandrel/compare/mandrel-v2.36.0...mandrel-v2.37.0) (2026-09-03)
+
+
+### ⚠ BREAKING CHANGES
+
+* `single-story-close.js` now exits non-zero on `--dry-run` or `--no-evidence` instead of silently ignoring them. Neither flag ever had an effect; a caller passing one was getting a full real close.
+
+### Added
+
+* cut the test suite's child-process budget: seed the e2e consumer once and move tests/e2e to its own tier, replace CLI cold-start spawns with in-process calls, and settle the isolation trade-off ([#5111](https://github.com/dsj1984/mandrel/issues/5111)) ([#5122](https://github.com/dsj1984/mandrel/issues/5122)) ([a4fbd56](https://github.com/dsj1984/mandrel/commit/a4fbd5628b8bc11c918e0ff658fe62baf078a17f))
+* detect high-severity advisories on main between PRs, and bound the TypeScript devDependency range ([#5104](https://github.com/dsj1984/mandrel/issues/5104)) ([#5107](https://github.com/dsj1984/mandrel/issues/5107)) ([af8f1b8](https://github.com/dsj1984/mandrel/commit/af8f1b8ee28300391a3a43cca1d43ece5851ce83))
+
+
+### Fixed
+
+* close five concurrency holes: sweep-lock steal and heartbeat, one lock for the merged-branch reap, atomic pending-cleanup manifest, idempotent createIssue retry, additive lease claim ([#5112](https://github.com/dsj1984/mandrel/issues/5112)) ([#5119](https://github.com/dsj1984/mandrel/issues/5119)) ([8651514](https://github.com/dsj1984/mandrel/commit/86515147381cf653c1e41c01f6405f5333826253))
+* **deps:** bump fast-uri to 3.1.7 for four high-severity advisories ([#5103](https://github.com/dsj1984/mandrel/issues/5103)) ([06c37b1](https://github.com/dsj1984/mandrel/commit/06c37b11952fb8079027c0beceef831bed677485))
+* **drain-pending-cleanup:** honour --no-escalate and guard advertised --no-* flags (refs [#5101](https://github.com/dsj1984/mandrel/issues/5101)) ([#5106](https://github.com/dsj1984/mandrel/issues/5106)) ([52ef3cb](https://github.com/dsj1984/mandrel/commit/52ef3cb0c546714900474c0613d78b23bc40a068))
+* restore the suite profiler, make run-tests --help print usage, and stop three tests burning worker slots on real backoff and a live-repo scan ([#5110](https://github.com/dsj1984/mandrel/issues/5110)) ([#5115](https://github.com/dsj1984/mandrel/issues/5115)) ([dbe0742](https://github.com/dsj1984/mandrel/commit/dbe07420a7d8d3c99016968d9c15e45da64d0de2))
+* single-story-close advertises --dry-run and --no-evidence but never wired either: retire both and reject them loudly ([#5100](https://github.com/dsj1984/mandrel/issues/5100)) ([#5102](https://github.com/dsj1984/mandrel/issues/5102)) ([2f4dd52](https://github.com/dsj1984/mandrel/commit/2f4dd52c682bcc3697f67124d6dc574e209ab204))
+
+
+### Performance
+
+* stop the baseline gates doing pointless heavy work: lazy TypeScript, small-batch in-process scoring, precompiled globs, diff-scoped cyclomatic, precompiled .agentrc validator ([#5109](https://github.com/dsj1984/mandrel/issues/5109)) ([#5117](https://github.com/dsj1984/mandrel/issues/5117)) ([6b04d5e](https://github.com/dsj1984/mandrel/commit/6b04d5e7c014b4bc052afbef8fd88d85c7a6b00f))
+
+
+### Changed
+
+* collapse the tripled semver comparator and the copy-pasted migration-step scaffold in the published lib/ payload ([#5113](https://github.com/dsj1984/mandrel/issues/5113)) ([#5116](https://github.com/dsj1984/mandrel/issues/5116)) ([ae2b6d6](https://github.com/dsj1984/mandrel/commit/ae2b6d6c40b26ea6d2f94b07698867863011a659))
+* extract one JavaScript comment stripper, bring two cyclomatic-20 CLI mains under the ceiling, and delete the orchestration payload’s dead code ([#5114](https://github.com/dsj1984/mandrel/issues/5114)) ([#5118](https://github.com/dsj1984/mandrel/issues/5118)) ([747d9a5](https://github.com/dsj1984/mandrel/commit/747d9a5bce66a6230fe6f46d132b3e8aacbc5a09))
+
 ## [2.36.0](https://github.com/dsj1984/mandrel/compare/mandrel-v2.35.0...mandrel-v2.36.0) (2026-08-29)