mandrel 1.94.0 → 2.1.0

package/.agents/scripts/lib/orchestration/epic-runner/progress-reporter/transport.js

@@ -1,238 +0,0 @@
-/**
- * progress-reporter/transport.js — outbound I/O for the
- * `/deliver` progress narrative.
- *
- * Extracted from the parent `progress-reporter.js` so the
- * GitHub-comment posting surface (in `composition.js`) and the
- * progress-signal aggregation (in `signals.js`) can be reasoned about
- * independently of the webhook fan-out.
- *
- * Each `emit*` helper dispatches a curated event-shaped payload through
- * the caller-supplied `notify` function. The `notify` contract is owned
- * by `lib/notifications/*` and ultimately reaches the configured webhook
- * via gh-exec (the retry/backoff loop lives there, not here — this
- * module's role is the boundary). Failures from `notify` are swallowed
- * by design: a flaky webhook URL must never crash the runner mid-wave.
- *
- * The webhook events emitted from this module are:
- *
- *   - `epic-started`  — fired once at /deliver kickoff
- *   - `epic-progress` — fired at wave boundaries / blocker transitions
- *   - `epic-blocked`  — wave aggregated to blocked/failed outside halt path
- *   - `epic-unblocked` — operator flipped back to executing
- *
- * Each fire passes `skipComment: true` so the operator-facing GitHub
- * comments stay owned by `composition.js` (`upsertEpicRunProgress` and
- * `ProgressReporter.fire()`) — there is exactly one comment writer and
- * exactly one webhook writer per event.
- */
-
-/**
- * Webhook event name for the curated epic-progress rollup. Distinct from
- * the `epic-run-progress` structured-comment kind in `signals.js` — the
- * comment is the operator-facing per-poll snapshot on the Epic ticket,
- * the webhook event is the coarse-grained rollup that fires at wave
- * boundaries and after blocker transitions.
- */
-export const EPIC_PROGRESS_EVENT = 'epic-progress';
-
-/**
- * Fire a curated `epic-progress` webhook event. Event-driven only — called
- * per recorder beat and after blocker raise/clear transitions. Carries the
- * rollup payload `{ pct, done, total, phase, openBlockers }`, which Slack
- * consumers and downstream subscribers use to track epic progress without
- * subscribing to per-story chatter.
- *
- * The dispatch passes `skipComment: true` — the operator-facing GitHub
- * comment is owned by `ProgressReporter.fire()` and `upsertEpicRunProgress`,
- * not by this webhook fire.
- *
- * Failures are swallowed by design: the runner must keep moving even if
- * the webhook URL is misconfigured or the network is flaky.
- *
- * Story #4155 — the Epic `/deliver` runtime cut over to the continuous
- * ready-set scheduler, which has **no wave index**. The wave segment was
- * dropped from the message and the rollup payload entirely (rather than
- * rendered as `Wave undefined/undefined`); the sole live caller
- * (`wave-record-notifications.js`) never supplied wave coordinates.
- *
- * @param {{
- *   notify: Function|null,
- *   epicId: number,
- *   done: number,
- *   total: number,
- *   phase?: string,
- *   openBlockers?: Array<{ reason: string, storyId?: number }>,
- *   logger?: { warn?: Function },
- * }} args
- * @returns {Promise<{ payload: object } | null>}
- */
-export async function emitEpicProgress({
-  notify,
-  epicId,
-  done,
-  total,
-  phase,
-  openBlockers = [],
-  logger,
-}) {
-  if (typeof notify !== 'function') return null;
-  const epicIdNum = Number(epicId);
-  if (!Number.isInteger(epicIdNum) || epicIdNum <= 0) return null;
-  const totalN = Math.max(0, Number(total) || 0);
-  const doneN = Math.max(0, Math.min(totalN, Number(done) || 0));
-  const pct = totalN === 0 ? 0 : Math.round((doneN / totalN) * 100);
-  const blockerCount = Array.isArray(openBlockers) ? openBlockers.length : 0;
-  const blockerSuffix =
-    blockerCount > 0
-      ? ` · 🚧 ${blockerCount} blocker${blockerCount === 1 ? '' : 's'}`
-      : '';
-  const message = `Epic #${epicIdNum} progress · ${doneN}/${totalN} stories done (${pct}%)${blockerSuffix}`;
-
-  const payload = {
-    severity: blockerCount > 0 ? 'high' : 'medium',
-    message,
-    event: EPIC_PROGRESS_EVENT,
-    level: 'epic',
-    epicId: epicIdNum,
-  };
-  if (phase) payload.phase = phase;
-
-  try {
-    await notify(epicIdNum, payload, { skipComment: true });
-  } catch (err) {
-    logger?.warn?.(
-      `[emitEpicProgress] notify dispatch failed (swallowed): ${err?.message ?? err}`,
-    );
-    return null;
-  }
-  return {
-    payload: {
-      pct,
-      done: doneN,
-      total: totalN,
-      phase,
-      openBlockers: openBlockers ?? [],
-    },
-  };
-}
-
-/**
- * Fire a curated `epic-started` webhook event at /deliver kickoff.
- * The Slack consumer anchors the rest of the epic narrative to this fire.
- * Failures are swallowed.
- *
- * Story #4155 — the ready-set runtime has no wave count, so the wave
- * segment was dropped from the message (rather than rendered as
- * `undefined wave(s)`); the sole live caller never supplied one.
- */
-export async function emitEpicStarted({
-  notify,
-  epicId,
-  totalStories,
-  title,
-  logger,
-}) {
-  if (typeof notify !== 'function') return null;
-  const epicIdNum = Number(epicId);
-  if (!Number.isInteger(epicIdNum) || epicIdNum <= 0) return null;
-  const message = `Epic #${epicIdNum} started · ${totalStories} stor${totalStories === 1 ? 'y' : 'ies'}${title ? ` — ${title}` : ''}`;
-  try {
-    await notify(
-      epicIdNum,
-      {
-        severity: 'medium',
-        message,
-        event: 'epic-started',
-        level: 'epic',
-        epicId: epicIdNum,
-      },
-      { skipComment: true },
-    );
-  } catch (err) {
-    logger?.warn?.(
-      `[emitEpicStarted] notify dispatch failed (swallowed): ${err?.message ?? err}`,
-    );
-  }
-  return null;
-}
-
-/**
- * Fire a curated `epic-blocked` webhook event when a wave aggregates to
- * `blocked` or `failed` outside the `BlockerHandler.halt` code path (the
- * /deliver host-LLM loop has no handler instance — it calls this
- * helper directly from `epic-execute-record-wave.js`). The payload shape
- * matches the inline emit in `BlockerHandler.halt` so downstream consumers
- * see one canonical envelope regardless of which entry point fired.
- * Failures are swallowed.
- */
-export async function emitEpicBlocked({
-  notify,
-  epicId,
-  reason,
-  storyId,
-  logger,
-}) {
-  if (typeof notify !== 'function') return null;
-  const epicIdNum = Number(epicId);
-  if (!Number.isInteger(epicIdNum) || epicIdNum <= 0) return null;
-  const storyPart = storyId ? ` (story #${storyId})` : '';
-  const message = `🚨 Action Required: Epic #${epicIdNum}${storyPart} blocked: ${reason}`;
-  try {
-    await notify(
-      epicIdNum,
-      {
-        severity: 'high',
-        message,
-        event: 'epic-blocked',
-        level: 'epic',
-        epicId: epicIdNum,
-      },
-      { skipComment: true },
-    );
-  } catch (err) {
-    logger?.warn?.(
-      `[emitEpicBlocked] notify dispatch failed (swallowed): ${err?.message ?? err}`,
-    );
-  }
-  return null;
-}
-
-/**
- * Fire a curated `epic-unblocked` webhook event after the operator flips
- * the Epic label back to `agent::executing`. Paired with `epic-blocked` so
- * downstream consumers can track open-blocker lifecycle. Failures are
- * swallowed.
- */
-export async function emitEpicUnblocked({
-  notify,
-  epicId,
-  resolvedBlocker,
-  logger,
-}) {
-  if (typeof notify !== 'function') return null;
-  const epicIdNum = Number(epicId);
-  if (!Number.isInteger(epicIdNum) || epicIdNum <= 0) return null;
-  const reasonPart = resolvedBlocker?.reason
-    ? ` (${resolvedBlocker.reason})`
-    : '';
-  const message = `Epic #${epicIdNum} unblocked${reasonPart} · resuming.`;
-  try {
-    await notify(
-      epicIdNum,
-      {
-        severity: 'medium',
-        message,
-        event: 'epic-unblocked',
-        level: 'epic',
-        epicId: epicIdNum,
-      },
-      { skipComment: true },
-    );
-  } catch (err) {
-    logger?.warn?.(
-      `[emitEpicUnblocked] notify dispatch failed (swallowed): ${err?.message ?? err}`,
-    );
-  }
-  return null;
-}

package/.agents/scripts/lib/orchestration/epic-runner/progress-signals/_bullet-format.js

@@ -1,32 +0,0 @@
-/**
- * Shared bullet-formatting helpers for progress-signal detectors.
- *
- * Both crap-drift and maintainability-drift produce component-level
- * regression bullets and need the same two pure utilities — hoisted here
- * so they are maintained in one place (Story #3631, refs #3631).
- */
-
-/**
- * Comparator that sorts the wildcard component `'*'` before all named
- * components, with named components in locale order.
- *
- * @param {string} a
- * @param {string} b
- * @returns {number}
- */
-export function componentOrder(a, b) {
-  if (a === '*') return -1;
-  if (b === '*') return 1;
-  return a.localeCompare(b);
-}
-
-/**
- * Formats a numeric gate value for display: integers render without a
- * decimal point; non-integers are fixed to two decimal places.
- *
- * @param {number} value
- * @returns {string}
- */
-export function formatNumber(value) {
-  return Number.isInteger(value) ? String(value) : value.toFixed(2);
-}

package/.agents/scripts/lib/orchestration/epic-runner/progress-signals/component-drift.js

@@ -1,203 +0,0 @@
-import nodeFs from 'node:fs';
-import path from 'node:path';
-import { resolveComponents } from '../../../baselines/components.js';
-import { componentOrder } from './_bullet-format.js';
-
-/**
- * Shared component-regression walk for the progress-signal drift detectors
- * (Story #3984). `crap-drift.js` and `maintainability-drift.js` previously
- * duplicated this baseline-rollup → per-component compare → bullet-list
- * shape verbatim; the only divergence was the breach comparator (CRAP is
- * "lower is better", maintainability is "higher is better") and the bullet
- * text. Both detectors now parameterize this walk.
- *
- * Pure — the caller loads the baseline via `lib/baselines/reader.js#load(...)`
- * and passes the resulting `{ rollup }` plus the gate config block.
- *
- * Only components whose rollup breaches the configured floor surface — a
- * breach in a component-scoped floor does NOT report against `*` unless
- * `*` itself breaches. This keeps the rollout narrowly targeted: when an
- * operator wires up a per-component floor for `api`, regressing `api`
- * names `api` — not `*`.
- *
- * @param {{
- *   rollup?: Record<string, Record<string, number>>,
- *   gateConfig?: { floors?: Record<string, Record<string, number>> } & object,
- * }} params
- * @param {{
- *   isBreach: (value: number, floor: number) => boolean,
- *   formatBullet: (name: string, axis: string, value: number, floor: number) => string,
- * }} spec
- * @returns {string[]}
- */
-export function walkComponentRegressions(params = {}, spec) {
-  const rollup = params.rollup ?? {};
-  const gateConfig = params.gateConfig ?? {};
-  const floors = gateConfig.floors ?? {};
-  const components = resolveComponents(gateConfig);
-  const names = new Set([
-    ...Object.keys(components),
-    ...Object.keys(floors),
-    ...Object.keys(rollup),
-  ]);
-  const bullets = [];
-  for (const name of [...names].sort(componentOrder)) {
-    const aggregate = rollup[name];
-    if (!aggregate || typeof aggregate !== 'object') continue;
-    const floor = floors[name] ?? floors['*'];
-    if (!floor || typeof floor !== 'object') continue;
-    for (const axis of Object.keys(floor).sort()) {
-      const target = floor[axis];
-      const value = aggregate[axis];
-      if (typeof target !== 'number' || !Number.isFinite(target)) continue;
-      if (typeof value !== 'number' || !Number.isFinite(value)) continue;
-      if (!spec.isBreach(value, target)) continue;
-      bullets.push(spec.formatBullet(name, axis, value, target));
-    }
-  }
-  return bullets;
-}
-
-/**
- * Shared wave-start snapshot persistence for the drift detectors. Both
- * detectors persist a `{ capturedAt, ...metadata, scores }` JSON document
- * under `<cwd>/<baselineDir>/<filename>` so a resumed epic run can re-read
- * the wave-start anchor rather than lose it, and both treat persistence as
- * best-effort (the in-memory baseline still works when a write fails).
- *
- * @param {{
- *   fs: { readFileSync?: Function, writeFileSync?: Function, mkdirSync?: Function },
- *   baselinePath: string,
- *   metadata?: Record<string, unknown>,
- * }} opts
- */
-function createSnapshotStore({ fs, baselinePath, metadata = {} }) {
-  return {
-    persist(scores) {
-      if (!fs.writeFileSync) return;
-      try {
-        fs.mkdirSync?.(path.dirname(baselinePath), { recursive: true });
-        fs.writeFileSync(
-          baselinePath,
-          JSON.stringify(
-            { capturedAt: new Date().toISOString(), ...metadata, scores },
-            null,
-            2,
-          ),
-        );
-      } catch {
-        // persistence is best-effort; the in-memory baseline still works
-      }
-    },
-
-    load() {
-      if (!fs.readFileSync) return null;
-      try {
-        const raw = fs.readFileSync(baselinePath, 'utf-8');
-        const parsed = JSON.parse(raw);
-        return parsed?.scores ?? null;
-      } catch {
-        return null;
-      }
-    },
-  };
-}
-
-/**
- * Shared per-file/per-method drift-detector skeleton for the progress-signal
- * detectors (Story #4076). `crap-drift.js` and `maintainability-drift.js`
- * previously duplicated the same `{ baselinePath, captureBaseline,
- * loadBaseline, detect }` shape — identical snapshot-store wiring, identical
- * "distinct from canonical baseline" framing, and identical
- * swallow-and-warn resilience. The only divergence is the per-axis scoring
- * (`scoreFile`), the snapshot value extracted from a score (`captureScore`),
- * and the per-detect comparison that emits bullets (`detect`). Both detectors
- * now supply those deltas to this factory, mirroring the "shared walker +
- * per-axis delta" pattern already established by `walkComponentRegressions`.
- *
- * The factory owns:
- *
- *   - `fs` / `cwd` / `files` resolution from `opts`.
- *   - The `<cwd>/<baselineDir>/<baselineFilename>` baseline path and the
- *     `createSnapshotStore` wiring (with caller-supplied `metadata`).
- *   - The in-memory `baseline` cache and the `captureBaseline` /
- *     `loadBaseline` lifecycle.
- *
- * The caller owns:
- *
- *   - `scoreFile(relPath, ctx)` — returns the per-file score (any shape) or
- *     `null` when the file can't be scored. `ctx` is whatever
- *     `beforeScore()` returned for this pass (e.g. a coverage map), or
- *     `undefined` when `beforeScore` is omitted.
- *   - `captureScore(score)` — maps a `scoreFile` result to the value
- *     persisted in the snapshot (e.g. extract `crap` from each method row).
- *   - `detect({ baseline, scoreFile })` — async; returns the bullet list.
- *     Receives the loaded baseline and a `scoreFile(relPath)` bound to this
- *     pass's score context so the per-axis compare stays free of plumbing.
- *   - `beforeScore()` (optional) — runs once per `captureBaseline` / `detect`
- *     pass and returns the score context threaded into `scoreFile`.
- *
- * @param {{
- *   cwd?: string,
- *   files?: string[],
- *   fs?: { readFileSync?: Function, writeFileSync?: Function, mkdirSync?: Function, existsSync?: Function },
- *   baselineDir?: string,
- *   baselineFilename: string,
- *   metadata?: Record<string, unknown>,
- *   beforeScore?: () => unknown,
- *   scoreFile: (relPath: string, ctx: unknown) => unknown,
- *   captureScore: (score: unknown) => unknown,
- *   detect: (args: { baseline: Record<string, unknown>, scoreFile: (relPath: string) => unknown }) => Promise<string[]>,
- * }} opts
- */
-export function createDriftDetector(opts = {}) {
-  const fs = opts.fs ?? nodeFs;
-  const cwd = opts.cwd ?? process.cwd();
-  const files = Array.isArray(opts.files) ? [...opts.files] : [];
-  const baselineDir = opts.baselineDir ?? '.agents/state';
-  const baselinePath = path.join(cwd, baselineDir, opts.baselineFilename);
-  const beforeScore = opts.beforeScore ?? (() => undefined);
-  const scoreFile = opts.scoreFile;
-  const captureScore = opts.captureScore;
-  const runDetect = opts.detect;
-  const store = createSnapshotStore({
-    fs,
-    baselinePath,
-    metadata: opts.metadata ?? {},
-  });
-
-  let baseline = null;
-
-  return {
-    get baselinePath() {
-      return baselinePath;
-    },
-
-    captureBaseline() {
-      const ctx = beforeScore();
-      const snapshot = {};
-      for (const f of files) {
-        const score = scoreFile(f, ctx);
-        if (score == null) continue;
-        snapshot[f] = captureScore(score);
-      }
-      baseline = snapshot;
-      store.persist(snapshot);
-      return snapshot;
-    },
-
-    loadBaseline() {
-      baseline = store.load();
-      return baseline;
-    },
-
-    async detect() {
-      if (!baseline) return [];
-      const ctx = beforeScore();
-      return runDetect({
-        baseline,
-        scoreFile: (relPath) => scoreFile(relPath, ctx),
-      });
-    },
-  };
-}

package/.agents/scripts/lib/orchestration/epic-runner/progress-signals/crap-drift.js

@@ -1,227 +0,0 @@
-import nodeFs from 'node:fs';
-import path from 'node:path';
-import { loadCoverage as defaultLoadCoverage } from '../../../coverage-utils.js';
-import { calculateCrapForSource } from '../../../crap-engine.js';
-import { formatNumber } from './_bullet-format.js';
-import {
-  createDriftDetector,
-  walkComponentRegressions,
-} from './component-drift.js';
-
-const DEFAULT_THRESHOLD = 5.0;
-const DEFAULT_CEILING = 30;
-// Distinct from the canonical ratchet baseline at `baselines/crap.json`
-// (Epic #730 Story 5.5) — this is a per-wave drift SNAPSHOT, not the
-// committed score baseline. Filename intentionally differs so a repo-wide
-// grep for the canonical baseline no longer hits the snapshot.
-const BASELINE_FILENAME = 'wave-crap-snapshot.json';
-
-/**
- * Normalise a repo-relative path for coverage-key lookup. Pure; exported
- * for unit tests so the underlying branches don't have to be exercised
- * through the closure-bound `findCoverageEntry`.
- */
-export function normaliseCoveragePath(relPath) {
-  return String(relPath)
-    .replace(/\\/g, '/')
-    .replace(/^\.\/+/, '');
-}
-
-/**
- * True when a coverage map key matches a (normalised) relative path,
- * either by full equality or by suffix-with-slash. Pure.
- */
-export function coverageKeyMatches(key, suffix) {
-  const norm = String(key).replace(/\\/g, '/');
-  return norm === suffix || norm.endsWith(`/${suffix}`);
-}
-
-/**
- * Detect per-component CRAP regressions from a baseline rollup against the
- * gate's configured floors. Pure — the caller loads the baseline via
- * `lib/baselines/reader.js#load('crap')` and passes the resulting
- * `{ rollup }` plus the gate config block.
- *
- * Bullet shape (Task #1919, Epic #1786):
- *
- *   🧨 crap: <component> <axis> <value> > floor <floor>
- *
- * CRAP is a "lower is better" gate — every axis breach reports when
- * `value > floor`. Component-scoped breaches do NOT trigger a `*` bullet
- * unless `*` itself breaches. The walk itself is the shared
- * `component-drift.js` helper (Story #3984).
- *
- * @param {{
- *   rollup?: Record<string, Record<string, number>>,
- *   gateConfig?: { floors?: Record<string, Record<string, number>> } & object,
- * }} params
- * @returns {string[]}
- */
-export function detectComponentRegressions(params = {}) {
-  return walkComponentRegressions(params, {
-    isBreach: (value, cap) => value > cap,
-    formatBullet: (name, axis, value, cap) =>
-      `🧨 crap: ${name} ${axis} ${formatNumber(value)} > floor ${formatNumber(cap)}`,
-  });
-}
-
-/**
- * Detects per-method CRAP drift versus a wave-start baseline.
- *
- * Mirrors the `maintainability-drift.js` contract but at per-method
- * granularity: baseline snapshots are `{ "<file>::<method>@<startLine>": crap }`
- * rather than a single score per file. A method surfaces as a Notable bullet
- * when either condition holds:
- *
- *   - **Crossed the ceiling** — current CRAP ≥ `ceiling` and baseline was
- *     either absent or below `ceiling`. Captures newly introduced hotspots
- *     and methods that tipped over the budget.
- *   - **Rose by ≥ threshold** — baseline present and `current - baseline ≥
- *     threshold`. Captures silent regressions that stay under the ceiling
- *     but are trending badly.
- *
- * Bullet shape:
- *
- *   🧨 CRAP drift: <file>::<method> <score> (ceiling <N>)
- *
- * Persistence: baseline is written to `<cwd>/<baselineDir>/wave-crap-snapshot.json`
- * so a resumed epic run can reuse the wave-start anchor rather than lose it.
- *
- * Resilience: read / scoring errors for an individual file are swallowed (and
- * optionally logged) so a single unscorable file cannot take the progress
- * reporter down.
- *
- * @param {{
- *   cwd?: string,
- *   files?: string[],
- *   fs?: { readFileSync: Function, writeFileSync?: Function, mkdirSync?: Function, existsSync?: Function },
- *   calculate?: (source: string, coverageForFile: object|null) => Array<{ method: string, startLine: number, crap: number|null }>,
- *   loadCoverage?: (coveragePath: string) => object|null,
- *   coveragePath?: string | null,
- *   threshold?: number,
- *   ceiling?: number,
- *   baselineDir?: string,
- *   logger?: { warn?: Function },
- * }} [opts]
- */
-export function createCrapDriftDetector(opts = {}) {
-  const fs = opts.fs ?? nodeFs;
-  const cwd = opts.cwd ?? process.cwd();
-  const files = Array.isArray(opts.files) ? [...opts.files] : [];
-  const calculate = opts.calculate ?? calculateCrapForSource;
-  const loadCoverage = opts.loadCoverage ?? defaultLoadCoverage;
-  const coveragePath = opts.coveragePath ?? null;
-  const threshold = Number.isFinite(opts.threshold)
-    ? opts.threshold
-    : DEFAULT_THRESHOLD;
-  const ceiling = Number.isFinite(opts.ceiling)
-    ? opts.ceiling
-    : DEFAULT_CEILING;
-  const logger = opts.logger ?? null;
-
-  function methodKey(method, startLine) {
-    return `${method}@${startLine}`;
-  }
-
-  // Hoisted helpers — exported via `_internal` for unit coverage on each
-  // branch. Keeping them outside the closure keeps the orchestration
-  // method's complexity low.
-  // (see normaliseCoveragePath / coverageKeyMatches at module top.)
-  function findCoverageEntry(coverageMap, relPath) {
-    if (!coverageMap || typeof coverageMap !== 'object') return null;
-    const suffix = normaliseCoveragePath(relPath);
-    if (!suffix) return null;
-    for (const key of Object.keys(coverageMap)) {
-      if (coverageKeyMatches(key, suffix)) {
-        return coverageMap[key] ?? null;
-      }
-    }
-    return null;
-  }
-
-  function scoreFile(relPath, coverageMap) {
-    try {
-      const abs = path.join(cwd, relPath);
-      const src = fs.readFileSync(abs, 'utf-8');
-      const entry = findCoverageEntry(coverageMap, relPath);
-      const rows = calculate(src, entry) ?? [];
-      const methods = {};
-      for (const row of rows) {
-        if (!row || typeof row.method !== 'string') continue;
-        if (typeof row.startLine !== 'number') continue;
-        if (typeof row.crap !== 'number' || !Number.isFinite(row.crap))
-          continue;
-        methods[methodKey(row.method, row.startLine)] = {
-          method: row.method,
-          startLine: row.startLine,
-          crap: row.crap,
-        };
-      }
-      return methods;
-    } catch (err) {
-      logger?.warn?.(
-        `[crap-drift] scoring failed for ${relPath}: ${err?.message ?? err}`,
-      );
-      return null;
-    }
-  }
-
-  function readCoverageMap() {
-    if (!coveragePath) return null;
-    try {
-      return loadCoverage(coveragePath);
-    } catch (err) {
-      logger?.warn?.(
-        `[crap-drift] coverage load failed (${coveragePath}): ${err?.message ?? err}`,
-      );
-      return null;
-    }
-  }
-
-  return createDriftDetector({
-    fs,
-    cwd,
-    files: opts.files,
-    baselineDir: opts.baselineDir,
-    baselineFilename: BASELINE_FILENAME,
-    metadata: { ceiling, threshold },
-    beforeScore: readCoverageMap,
-    scoreFile,
-    captureScore: (methods) => {
-      const persisted = {};
-      for (const [key, row] of Object.entries(methods)) {
-        persisted[key] = row.crap;
-      }
-      return persisted;
-    },
-    async detect({ baseline, scoreFile: score }) {
-      const bullets = [];
-      // Union of files watched and files present in baseline, so methods that
-      // appeared since the snapshot (new files) are still checked, and methods
-      // that disappeared from baseline-only files don't get us stuck iterating
-      // anything spurious.
-      const fileSet = new Set([...files, ...Object.keys(baseline)]);
-      for (const relPath of fileSet) {
-        const currentMethods = score(relPath);
-        if (!currentMethods) continue;
-        const fileBaseline = baseline[relPath] ?? {};
-        for (const [key, row] of Object.entries(currentMethods)) {
-          const prev = fileBaseline[key];
-          const crossed =
-            row.crap >= ceiling &&
-            (prev === undefined || prev === null || prev < ceiling);
-          const rose =
-            typeof prev === 'number' &&
-            Number.isFinite(prev) &&
-            row.crap - prev >= threshold;
-          if (crossed || rose) {
-            bullets.push(
-              `🧨 CRAP drift: ${relPath}::${row.method} ${row.crap.toFixed(2)} (ceiling ${ceiling})`,
-            );
-          }
-        }
-      }
-      return bullets;
-    },
-  });
-}