mandrel 2.67.0 → 2.68.0

package/.agents/scripts/lib/supervised-suite.js

@@ -0,0 +1,247 @@
+/**
+ * A full suite supervised as a process group. The suite may write
+ * `$MANDREL_SUITE_READY_FILE` when its tests start; the kill timer then
+ * re-arms a fresh `timeoutMs`, so a pre-test wait (bounded by `timeoutMs`
+ * too) never spends the test budget. Close parses the timing line back.
+ */
+import { spawn } from 'node:child_process';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import {
+  groupSpawnOptions,
+  killProcessGroup,
+  superviseGroup,
+  TIMEOUT_EXIT_CODE,
+} from './process-group.js';
+
+/** @typedef {{ lockWaitMs: number, hostWaitMs: number|null, testRunMs: number }} SuiteTimings */
+
+export const SUITE_READY_FILE_ENV = 'MANDREL_SUITE_READY_FILE';
+
+const DEFAULT_READY_POLL_MS = 250;
+
+const NO_HOST_WAIT = 'n/a';
+
+/** @param {{ dir?: string }} [opts] */
+export function suiteReadyHandshake({ dir = os.tmpdir() } = {}) {
+  const name = `mandrel-suite-ready-${process.pid}-${crypto.randomBytes(6).toString('hex')}`;
+  const file = path.join(dir, name);
+  return { file, env: { [SUITE_READY_FILE_ENV]: file } };
+}
+
+/** @param {SuiteTimings} timings */
+export function formatSuiteTimings({ lockWaitMs, hostWaitMs, testRunMs }) {
+  const host = hostWaitMs === null ? NO_HOST_WAIT : Math.round(hostWaitMs);
+  return `⏲ suite timings: lockWaitMs=${Math.round(lockWaitMs)} hostWaitMs=${host} testRunMs=${Math.round(testRunMs)}`;
+}
+
+/**
+ * @param {string} line
+ * @returns {SuiteTimings|null}
+ */
+export function parseSuiteTimings(line) {
+  const match =
+    /suite timings: lockWaitMs=(\d+) hostWaitMs=(\d+|n\/a) testRunMs=(\d+)/u.exec(
+      String(line ?? ''),
+    );
+  if (!match) return null;
+  return {
+    lockWaitMs: Number(match[1]),
+    hostWaitMs: match[2] === NO_HOST_WAIT ? null : Number(match[2]),
+    testRunMs: Number(match[3]),
+  };
+}
+
+function fileExists(fsImpl, file) {
+  try {
+    return fsImpl.existsSync(file);
+  } catch {
+    return false;
+  }
+}
+
+function removeQuietly(fsImpl, file) {
+  try {
+    fsImpl.rmSync(file, { force: true });
+  } catch {
+    // A leftover marker is harmless.
+  }
+}
+
+class SuiteClock {
+  constructor({ kill, timeoutMs, readyTimeoutMs, readyFile, fsImpl, nowFn }) {
+    Object.assign(this, { kill, timeoutMs, readyFile, fsImpl, nowFn });
+    this.timedOut = false;
+    this.startedAt = nowFn();
+    this.readyAt = null;
+    this.endedAt = null;
+    this.timer = null;
+    this.poller = null;
+    this.arm(readyTimeoutMs ?? timeoutMs);
+  }
+
+  arm(boundMs) {
+    clearTimeout(this.timer);
+    if (!(Number.isFinite(boundMs) && boundMs > 0)) return;
+    this.timer = setTimeout(() => {
+      this.timedOut = true;
+      this.kill();
+    }, boundMs);
+  }
+
+  watch(pollMs) {
+    this.poller = setInterval(() => this.checkReady(), pollMs);
+    this.poller.unref?.();
+  }
+
+  checkReady() {
+    if (this.readyAt !== null || this.timedOut) return;
+    if (!fileExists(this.fsImpl, this.readyFile)) return;
+    this.readyAt = this.nowFn();
+    clearInterval(this.poller);
+    this.arm(this.timeoutMs);
+  }
+
+  stop() {
+    this.endedAt ??= this.nowFn();
+    this.checkReady();
+    clearInterval(this.poller);
+    clearTimeout(this.timer);
+    removeQuietly(this.fsImpl, this.readyFile);
+  }
+
+  timings() {
+    const end = this.endedAt ?? this.nowFn();
+    const testStart = this.readyAt ?? this.startedAt;
+    return {
+      hostWaitMs: this.readyAt === null ? null : this.readyAt - this.startedAt,
+      testRunMs: Math.max(0, end - testStart),
+    };
+  }
+}
+
+/**
+ * `hostWaitMs` is spawn → ready (null without a signal); `testRunMs` ends at
+ * exit. `readyTimeoutMs` (pre-ready bound) is a test seam over `timeoutMs`.
+ *
+ * @param {{ pid?: number, kill?: Function }} child
+ * @param {{ readyFile: string, timeoutMs?: number, readyTimeoutMs?: number, readyPollMs?: number, abortSignal?: AbortSignal, signalOnParentSignal?: string, fsImpl?: object, nowFn?: () => number }} opts
+ */
+export function superviseSuite(child, opts) {
+  const { readyPollMs = DEFAULT_READY_POLL_MS, fsImpl = fs } = opts;
+  const group = superviseGroup(child, {
+    abortSignal: opts.abortSignal,
+    signalOnParentSignal: opts.signalOnParentSignal,
+  });
+  const clock = new SuiteClock({
+    ...opts,
+    fsImpl,
+    nowFn: opts.nowFn ?? Date.now,
+    kill: () => killProcessGroup(child, 'SIGKILL'),
+  });
+  clock.watch(readyPollMs);
+  return {
+    get timedOut() {
+      return clock.timedOut;
+    },
+    get timings() {
+      return clock.timings();
+    },
+    release() {
+      clock.stop();
+      group.release();
+    },
+  };
+}
+
+/**
+ * A bare suite gets SIGKILL on a parent signal; a gate with its own cleanup
+ * (a capture holding the lock) SIGTERM. A full-suite gate also gets the
+ * handshake and emits its timing line on release.
+ *
+ * @param {{ fullSuiteLock?: boolean, timeoutMs?: number, signal?: AbortSignal, env?: Record<string, string> }} opts
+ * @param {{ lockWaitMs?: number }} [lock]
+ */
+export function gateSupervision(opts, lock = {}) {
+  const base = {
+    timeoutMs: opts.timeoutMs,
+    abortSignal: opts.signal,
+    signalOnParentSignal: opts.fullSuiteLock ? 'SIGKILL' : 'SIGTERM',
+  };
+  if (!opts.fullSuiteLock) {
+    return { env: opts.env, supervise: (child) => superviseGroup(child, base) };
+  }
+  const handshake = suiteReadyHandshake();
+  return {
+    env: { ...opts.env, ...handshake.env },
+    supervise: (child, output) =>
+      reportOnRelease(
+        superviseSuite(child, { ...base, readyFile: handshake.file }),
+        (timings) =>
+          output.emit(
+            output.prefix +
+              formatSuiteTimings({
+                lockWaitMs: lock.lockWaitMs ?? 0,
+                ...timings,
+              }),
+          ),
+      ),
+  };
+}
+
+/**
+ * @param {ReturnType<typeof superviseSuite>} supervisor
+ * @param {(timings: object) => void} report
+ */
+function reportOnRelease(supervisor, report) {
+  return {
+    get timedOut() {
+      return supervisor.timedOut;
+    },
+    release() {
+      supervisor.release();
+      report(supervisor.timings);
+    },
+  };
+}
+
+/**
+ * Resolves the exit code, or `124` when the supervisor killed the suite.
+ *
+ * @param {{ cmd: string, args: string[], cwd: string, env?: Record<string, string>, timeoutMs?: number, readyTimeoutMs?: number, readyPollMs?: number, lockWaitMs?: number, spawnImpl?: typeof spawn, onTimings?: (timings: SuiteTimings) => void, onTimeout?: () => void }} opts
+ * @returns {Promise<number>}
+ */
+export function runSupervisedSuite(opts) {
+  const { cmd, args, cwd, env = {}, spawnImpl = spawn } = opts;
+  const handshake = suiteReadyHandshake();
+  return new Promise((resolve) => {
+    const child = spawnImpl(cmd, args, {
+      cwd,
+      env: { ...process.env, ...env, ...handshake.env },
+      stdio: 'inherit',
+      shell: process.platform === 'win32',
+      ...groupSpawnOptions(),
+    });
+    const supervisor = superviseSuite(child, {
+      ...opts,
+      readyFile: handshake.file,
+    });
+    let settled = false;
+    const settle = (code) => {
+      if (settled) return;
+      settled = true;
+      supervisor.release();
+      opts.onTimings?.({
+        lockWaitMs: opts.lockWaitMs ?? 0,
+        ...supervisor.timings,
+      });
+      if (supervisor.timedOut) opts.onTimeout?.();
+      resolve(supervisor.timedOut ? TIMEOUT_EXIT_CODE : code);
+    };
+    child.on('error', () => settle(1));
+    child.on('exit', (code) => settle(code ?? 1));
+  });
+}

package/.agents/scripts/lib/wave-runner/cross-run-overlap.js

@@ -0,0 +1,120 @@
+/**
+ * Advisory report of probed Stories whose declared footprint shares a
+ * concrete path with a Story another session has in flight. Never feeds
+ * selection, ordering or the exit code.
+ *
+ * @module lib/wave-runner/cross-run-overlap
+ */
+
+import { TYPE_LABELS } from '../label-constants.js';
+import { storyFootprintPaths } from '../orchestration/resolve-stories.js';
+import { currentOwner } from '../orchestration/ticket-lease.js';
+import { detectCollision } from './footprint.js';
+import { classifyStory, storyIdOf } from './ready-set.js';
+
+/**
+ * One labelled list query. Never rejects, so a failed read reports
+ * "unavailable" instead of an empty list.
+ *
+ * @param {object} provider
+ * @returns {Promise<{ tickets?: object[], error?: string }>}
+ */
+async function listOpenStories(provider) {
+  if (typeof provider?.listTicketsByLabel !== 'function') {
+    return { error: 'the provider cannot list issues by label' };
+  }
+  try {
+    const tickets = await provider.listTicketsByLabel({
+      state: 'open',
+      labels: TYPE_LABELS.STORY,
+    });
+    return { tickets: Array.isArray(tickets) ? tickets : [] };
+  } catch (err) {
+    return { error: String(err?.message ?? err) };
+  }
+}
+
+/**
+ * @param {object[]} tickets
+ * @param {Set<number>} inSetIds
+ * @returns {Array<{id: number, files: string[], holder: string|null}>}
+ */
+function outsideInFlight(tickets, inSetIds) {
+  const outside = [];
+  for (const ticket of tickets) {
+    const id = storyIdOf(ticket);
+    if (id === null || inSetIds.has(id)) continue;
+    if (classifyStory(ticket) !== 'executing') continue;
+    outside.push({
+      id,
+      files: storyFootprintPaths(ticket.body, id),
+      holder: currentOwner(ticket.assignees),
+    });
+  }
+  return outside;
+}
+
+/**
+ * The reservation guard's `concreteOnly` rule, so advisory and guard never
+ * disagree: a glob or the UNKNOWN sentinel reports nothing.
+ *
+ * @param {Array<{id: number}>} probed
+ * @param {Array<{id: number, holder: string|null}>} outside
+ * @returns {object[]}
+ */
+function findCrossRunOverlaps(probed, outside) {
+  const overlaps = [];
+  for (const rec of probed) {
+    for (const other of outside) {
+      const hit = detectCollision(rec, other, { concreteOnly: true });
+      if (!hit) continue;
+      overlaps.push({
+        id: rec.id,
+        otherId: other.id,
+        holder: other.holder,
+        paths: hit.paths,
+      });
+    }
+  }
+  return overlaps;
+}
+
+/**
+ * @param {{ tickets?: object[], error?: string }} listing
+ * @param {object[]} nodes
+ * @param {Set<number>} inSetIds
+ * @returns {object}
+ */
+function buildReport(listing, nodes, inSetIds) {
+  if (listing.error) {
+    return {
+      crossRunOverlapProbe: 'unavailable',
+      crossRunOverlapProbeReason: `Could not list in-flight Stories outside this run: ${listing.error}`,
+    };
+  }
+  const candidates = nodes.filter((node) => {
+    const cls = classifyStory(node);
+    return cls === 'ready' || cls === 'executing';
+  });
+  return {
+    crossRunOverlaps: findCrossRunOverlaps(
+      candidates,
+      outsideInFlight(listing.tickets, inSetIds),
+    ),
+  };
+}
+
+/**
+ * Starts the read now so it overlaps the per-Story reads; probed-set Stories
+ * are excluded (their overlap is the ready-set guard's job).
+ *
+ * @param {object} provider
+ * @returns {{ report: (nodes: object[]) => Promise<object> }}
+ */
+export function startCrossRunProbe(provider) {
+  const listing = listOpenStories(provider);
+  return {
+    report: async (nodes) =>
+      buildReport(await listing, nodes, new Set(nodes.map((n) => n.id))),
+  };
+}

package/.agents/scripts/lib/wave-runner/live-probe.js

@@ -19,6 +19,7 @@ import {
   currentOwner,
   normalizeOperatorHandle,
 } from '../orchestration/ticket-lease.js';
+import { startCrossRunProbe } from './cross-run-overlap.js';
 import { classifyStory, storyIdOf } from './ready-set.js';
 
 /**
@@ -143,7 +144,8 @@ export function createProbeContext({
  *   inFlight: number,
  *   blockedIds: number[],
  *   stalledDispatch: number[],
- *   foreignHeld: Array<{id: number, holder: string}>
+ *   foreignHeld: Array<{id: number, holder: string}>,
+ *   crossRunOverlaps?: object[]
  * }>}
  */
 export async function probeLiveState({
@@ -156,6 +158,7 @@ export async function probeLiveState({
   self,
   warn,
 }) {
+  const crossRun = startCrossRunProbe(provider);
   // The `agent::*` guard is an admission check; a just-dispatched Story is
   // legitimately unlabelled until init flips it, so a per-beat probe allows it.
   const stories = await fetchStories(provider, ids, { allowUnlabelled: true });
@@ -207,6 +210,7 @@ export async function probeLiveState({
       .filter((id) => !foreignHeld.has(id))
       .sort((a, b) => a - b),
     foreignHeld: [...foreignHeld].map(([id, holder]) => ({ id, holder })),
+    ...(await crossRun.report(nodes)),
   };
 }
 

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

@@ -18,7 +18,7 @@ import { CODING_GUARDRAILS } from './lib/config/quality.js';
 
 const USAGE = {
   invocation:
-    'node .agents/scripts/quality-preview.js [--staged | --changed-since <ref>] [--json]',
+    'node .agents/scripts/quality-preview.js [--staged | --changed-since <ref>] [--only mi|crap] [--json]',
   summary:
     'Preview the per-file maintainability and CRAP deltas for the change set, and exit non-zero on any threshold violation.',
   flags: [
@@ -30,6 +30,10 @@ const USAGE = {
       '--changed-since <ref>',
       'Score the diff against <ref> (default: HEAD). Last occurrence wins.',
     ],
+    [
+      '--only mi|crap',
+      'Run one half only — maintainability (`mi`) or CRAP (`crap`); the other half is reported as not run. Default: both, serially.',
+    ],
     ['--json', 'Emit both gate envelopes plus the merged table as JSON.'],
   ],
 };
@@ -73,6 +77,96 @@ export function parseStagedFlag(argv) {
   return argv.includes('--staged');
 }
 
+/** The halves `--only` can select. */
+const PREVIEW_HALVES = new Set(['mi', 'crap']);
+
+/**
+ * `--only <half>` (last occurrence wins); `null` runs both halves. A value
+ * outside {@link PREVIEW_HALVES} is returned as-is for the caller to refuse.
+ *
+ * @param {string[]} argv
+ * @returns {string | null}
+ */
+function parseOnlyArg(argv) {
+  const at = argv.lastIndexOf('--only');
+  return at === -1 ? null : (argv[at + 1] ?? '');
+}
+
+/**
+ * @param {string|null} only
+ * @returns {boolean}
+ */
+function isUnknownHalf(only) {
+  return only !== null && !PREVIEW_HALVES.has(only);
+}
+
+/**
+ * Run `half` unless `--only` selected the other one.
+ *
+ * @param {{ only: string|null, half: 'mi'|'crap', run: () => Promise<{exitCode: number, envelope: object|null}> }} opts
+ * @returns {Promise<{exitCode: number, envelope: object|null}>}
+ */
+function runHalf({ only, half, run }) {
+  return only === null || only === half ? run() : Promise.resolve(NOT_RUN);
+}
+
+/**
+ * The `--json` field naming the selected half; empty for the default run so
+ * its envelope stays byte-identical.
+ *
+ * @param {string|null} only
+ * @returns {{ only?: string }}
+ */
+function onlyField(only) {
+  return only ? { only } : {};
+}
+
+/**
+ * The report line naming the selected half; empty for the default run.
+ *
+ * @param {string|null} only
+ * @returns {string}
+ */
+function halfLine(only) {
+  return only ? `half=${only} only — the other half was not run\n` : '';
+}
+
+/**
+ * `--staged` wins; otherwise `--changed-since` (absent → `HEAD`).
+ *
+ * @param {string[]} argv
+ * @param {boolean} staged
+ * @returns {string|null}
+ */
+function resolveRef(argv, staged) {
+  return staged ? null : (parseChangedSinceArg(argv) ?? 'HEAD');
+}
+
+/** A half `--only` left out: clean, with no envelope to merge. */
+const NOT_RUN = Object.freeze({ exitCode: 0, envelope: null });
+
+/**
+ * Run the selected halves serially, not via Promise.all: each runner sizes its
+ * own pool to availableParallelism, so overlapping them oversubscribes 2x and
+ * stacks two escomplex heaps (>1 GB RSS).
+ *
+ * @param {{ only: string|null, args: object, runMi: Function, runCrap: Function, stderr: { write: (s: string) => void } }} opts
+ * @returns {Promise<{ miResult: {exitCode: number, envelope: object|null}, crapResult: {exitCode: number, envelope: object|null} }>}
+ */
+async function runHalves({ only, args, runMi, runCrap, stderr }) {
+  const miResult = await runHalf({
+    only,
+    half: 'mi',
+    run: () => runGateSafely(runMi, args, 'MI', stderr),
+  });
+  const crapResult = await runHalf({
+    only,
+    half: 'crap',
+    run: () => runGateSafely(runCrap, args, 'CRAP', stderr),
+  });
+  return { miResult, crapResult };
+}
+
 /**
  * @param {unknown} value
  * @returns {number}
@@ -325,6 +419,7 @@ function stagedScopeLine({ staged, ref, cwd }) {
  *
  * @param {{
  *   json: boolean,
+ *   only: string|null,
  *   staged: boolean,
  *   ref: string|null,
  *   cwd: string,
@@ -338,6 +433,7 @@ function stagedScopeLine({ staged, ref, cwd }) {
  */
 function emitReport({
   json,
+  only,
   staged,
   ref,
   cwd,
@@ -355,6 +451,7 @@ function emitReport({
         {
           ref: staged ? null : ref,
           staged,
+          ...onlyField(only),
           mi: { exit: miExit, envelope: miResult.envelope },
           crap: { exit: crapExit, envelope: crapResult.envelope },
           merged,
@@ -366,6 +463,7 @@ function emitReport({
     return;
   }
   stdout.write('\n--- quality:preview ---\n');
+  stdout.write(halfLine(only));
   stdout.write(stagedScopeLine({ staged, ref, cwd }));
   stdout.write(`${renderTable(merged)}\n`);
   writeAdvisories(merged.advisories, stdout);
@@ -399,23 +497,22 @@ export async function runCli({
 } = {}) {
   const json = parseJsonFlag(argv);
   const staged = parseStagedFlag(argv);
-  const ref = staged ? null : (parseChangedSinceArg(argv) ?? 'HEAD');
+  const ref = resolveRef(argv, staged);
+  const only = parseOnlyArg(argv);
+  if (isUnknownHalf(only)) {
+    stderr.write(
+      `[quality:preview] --only takes mi or crap (got "${only}").\n`,
+    );
+    return { exitCode: 2, merged: mergeEnvelopes(null, null) };
+  }
 
-  // Serial, not Promise.all: each runner sizes its own pool to
-  // availableParallelism, so overlapping them oversubscribes 2x and stacks
-  // two escomplex heaps (>1 GB RSS).
-  const miResult = await runGateSafely(
+  const { miResult, crapResult } = await runHalves({
+    only,
+    args: { cwd, staged, changedSinceRef: ref },
     runMi,
-    { cwd, staged, changedSinceRef: ref },
-    'MI',
-    stderr,
-  );
-  const crapResult = await runGateSafely(
     runCrap,
-    { cwd, staged, changedSinceRef: ref },
-    'CRAP',
     stderr,
-  );
+  });
 
   const merged = mergeEnvelopes(miResult.envelope, crapResult.envelope, {
     cyclomaticFlag: DEFAULT_CYCLOMATIC_FLAG,
@@ -423,6 +520,7 @@ export async function runCli({
 
   emitReport({
     json,
+    only,
     staged,
     ref,
     cwd,

package/.agents/scripts/stories-wave-tick.js

@@ -183,6 +183,15 @@ delivery.deliverRunner.footprintGuard: under "advisory" the collisions are
 detected and listed in "advisory" but never withhold, and dispatch follows the
 declared depends_on edges alone.
 
+crossRunOverlaps (probe mode only) is ADVISORY: each probed Story that is
+ready or in flight and shares a concrete path with an open Story in flight in
+ANOTHER session (outside --stories) — { id, otherId, holder, paths } — plus one
+stderr warning line per pair. It never withholds, reorders or delays dispatch
+and never changes the exit code; it uses the same concrete-path rule as
+inFlightReservation. When the outside query fails the envelope carries
+crossRunOverlapProbe: "unavailable" and crossRunOverlapProbeReason instead of
+the list, so "no overlap" is never inferred from a failed read.
+
 Exit codes:
   0 - Success, ready set emitted
   1 - Invalid input (missing/malformed DAG, invalid --concurrency/--in-flight/--done)
@@ -890,6 +899,7 @@ export function runStoriesWaveTick({
  * @param {NodeJS.ProcessEnv} [args.env]
  * @param {Function} [args.probe]   Test seam.
  * @param {Function} [args.context] Test seam.
+ * @param {Function} [args.warn]  Test seam.
  * @returns {Promise<{ envelope: object, exitCode: number, records: object[] }>}
  *   `records` are the probed nodes, kept off stdout.
  */
@@ -902,6 +912,7 @@ export async function runProbedStoriesWaveTick({
   env,
   probe = probeLiveState,
   context = createProbeContext,
+  warn = Logger.warn,
 } = {}) {
   const { value: override, error: concurrencyError } =
     parseConcurrencyOverride(concurrency);
@@ -956,6 +967,8 @@ export async function runProbedStoriesWaveTick({
     foreignHeld = [],
     inFlightRecords = [],
   } = probed;
+  const crossRun = crossRunFields(probed);
+  for (const line of crossRunWarnings(crossRun.crossRunOverlaps)) warn(line);
   const { envelope, exitCode } = buildReadySetEnvelope(nodes, {
     concurrencyCap,
     capPrecedence,
@@ -979,6 +992,7 @@ export async function runProbedStoriesWaveTick({
       stalledDispatch,
       foreignHeld,
       foreignHeldReason: foreignHeldReasonFor(foreignHeld),
+      ...crossRun,
     },
     records: nodes,
     // Blocked outranks a wedge (its blockers are moot while a human owes a
@@ -990,6 +1004,39 @@ export async function runProbedStoriesWaveTick({
   };
 }
 
+/**
+ * Exactly one advisory shape passes through; a failed read never becomes [].
+ *
+ * @param {object} probed
+ * @returns {object}
+ */
+function crossRunFields(probed) {
+  if (Array.isArray(probed.crossRunOverlaps)) {
+    return { crossRunOverlaps: probed.crossRunOverlaps };
+  }
+  if (probed.crossRunOverlapProbe === 'unavailable') {
+    return {
+      crossRunOverlapProbe: 'unavailable',
+      crossRunOverlapProbeReason: probed.crossRunOverlapProbeReason ?? null,
+    };
+  }
+  return {};
+}
+
+/**
+ * @param {object[]} [overlaps]
+ * @returns {string[]}
+ */
+function crossRunWarnings(overlaps = []) {
+  return overlaps.map(({ id, otherId, holder, paths }) => {
+    const who = holder ? `held by @${holder}` : 'holder unknown';
+    return (
+      `stories-wave-tick: #${id} overlaps #${otherId} (in flight in another session, ${who}) ` +
+      `on ${paths.join(', ')} — expect a rebase conflict at close. Advisory only; dispatch is unchanged.`
+    );
+  });
+}
+
 /**
  * @param {number[]} blockedIds
  * @returns {string|null}