mandrel 1.93.0 → 2.0.0

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

@@ -1,210 +0,0 @@
-/**
- * progress-reporter/signals.js — parsing and aggregation helpers for the
- * `story-run-progress` and `phase-timings` structured comments.
- *
- * Extracted from the parent `progress-reporter.js` so the aggregator
- * surface (phase percentile rollups, story-run-progress parsing) is
- * testable independently of the comment composition (`composition.js`)
- * and webhook transport (`transport.js`). Pure functions only — no
- * provider calls, no I/O — which makes this the natural home for the
- * shared state lookup tables (`PHASE_TO_STATE`, `PHASE_ORDER`,
- * `STATE_EMOJI`) and the structured-comment kind constants.
- */
-
-import { parseFencedJsonComment } from '../../structured-comment-parser.js';
-
-/**
- * Structured-comment kind for the rolled-up Epic-level progress
- * comment. Persisted via `composition.upsertEpicRunProgress` and read
- * back by tests + reconcilers.
- */
-export const EPIC_RUN_PROGRESS_TYPE = 'epic-run-progress';
-
-/**
- * Structured-comment kind for the per-Story phase-timings summary
- * posted by `story-close.js`. Read back by the ProgressReporter so the
- * Epic-level snapshot can aggregate median/p95 across waves.
- */
-export const PHASE_TIMINGS_TYPE = 'phase-timings';
-
-/**
- * Structured-comment kind for the per-Story run-progress snapshot that
- * `/deliver` upserts on every Task transition. Read by
- * ProgressReporter so the Epic-level table reflects sub-agent state in
- * near-real time instead of label-derived classifications.
- */
-export const STORY_RUN_PROGRESS_TYPE = 'story-run-progress';
-
-/**
- * Phase → high-level state classification. Lookup table flattens the
- * previous switch so cyclomatic complexity stays at 1 (one branch in the
- * `??` fallback) rather than 6 — keeps the CRAP score floor-bound under
- * coverage variance.
- */
-export const PHASE_TO_STATE = {
-  done: 'done',
-  blocked: 'blocked',
-  implementing: 'in-flight',
-  closing: 'in-flight',
-  init: 'queued',
-};
-
-/**
- * Fixed ordering for the rendered phase-timings table. Matches the enum
- * in lib/util/phase-timer.js so rows line up with how operators think
- * about the story lifecycle rather than re-sorting by alphabet or
- * frequency.
- */
-export const PHASE_ORDER = [
-  'worktree-create',
-  'bootstrap',
-  'install',
-  'implement',
-  'lint',
-  'test',
-  'close',
-  'api-sync',
-];
-
-/**
- * Emoji prefix per high-level state. Consumed by the rolled-up Epic table
- * (`composition.upsertEpicRunProgress`) so operators see a consistent icon
- * per state across the progress surface.
- */
-export const STATE_EMOJI = {
-  done: '✅',
-  blocked: '🚧',
-  'in-flight': '🔧',
-  queued: '⏳',
-  unknown: '❓',
-};
-
-/**
- * Map a `story-run-progress` phase to the high-level state label used
- * by the rendered tables. Returns `'unknown'` for any phase value that
- * isn't in the lookup table so an unexpected phase surfaces as an
- * unreadable row rather than a crash.
- */
-export function phaseToState(phase) {
-  return PHASE_TO_STATE[phase] ?? 'unknown';
-}
-
-/**
- * Parse a `story-run-progress` structured comment posted by `/deliver`.
- * Returns `null` for any malformed body — the caller falls back to the
- * ticket-label state derivation in that case.
- *
- * Expected payload shape (JSON inside a fenced json codeblock):
- *   {
- *     storyId: number,
- *     branch?: string,
- *     phase: 'init'|'implementing'|'closing'|'blocked'|'done',
- *     title?: string,
- *     updatedAt?: string,
- *   }
- */
-export function parseStoryRunProgressComment(comment) {
-  const payload = parseFencedJsonComment(comment);
-  if (!payload || typeof payload !== 'object') return null;
-  const phase = typeof payload.phase === 'string' ? payload.phase : undefined;
-  return {
-    storyId: Number(payload.storyId),
-    title: typeof payload.title === 'string' ? payload.title : '',
-    phase,
-    state: phaseToState(phase),
-  };
-}
-
-/**
- * Extract the `{ phases, ... }` payload from a `phase-timings` structured
- * comment. Comment body is the fenced-JSON format produced by
- * `renderPhaseTimingsCommentBody` in story-close. Returns `null`
- * for any parse failure — the caller treats that as "no summary
- * available" without erroring out progress rendering.
- */
-export function parsePhaseTimingsComment(comment) {
-  const payload = parseFencedJsonComment(comment);
-  if (!payload || typeof payload !== 'object') return null;
-  if (!Array.isArray(payload.phases)) return null;
-  return {
-    storyId: Number(payload.storyId),
-    totalMs: Number(payload.totalMs) || 0,
-    phases: payload.phases
-      .filter(
-        (p) =>
-          p &&
-          typeof p.name === 'string' &&
-          Number.isFinite(Number(p.elapsedMs)),
-      )
-      .map((p) => ({ name: p.name, elapsedMs: Number(p.elapsedMs) })),
-  };
-}
-
-/**
- * Aggregate a list of `phase-timings` summaries into per-phase median,
- * p95, and sample count. Returns phases ordered by the canonical
- * `PHASE_ORDER` so the rendered table always has the same row sequence —
- * operators should never have to hunt for the `install` row.
- */
-export function aggregatePhaseTimings(summaries) {
-  const buckets = new Map();
-  for (const s of summaries) {
-    if (!s || !Array.isArray(s.phases)) continue;
-    for (const p of s.phases) {
-      if (!buckets.has(p.name)) buckets.set(p.name, []);
-      buckets.get(p.name).push(p.elapsedMs);
-    }
-  }
-  const rows = [];
-  for (const name of PHASE_ORDER) {
-    const samples = buckets.get(name);
-    if (!samples || samples.length === 0) continue;
-    rows.push({
-      name,
-      median: percentile(samples, 0.5),
-      p95: percentile(samples, 0.95),
-      n: samples.length,
-    });
-  }
-  // Include any unexpected phase names at the tail so a future enum
-  // addition surfaces in the table instead of being silently dropped.
-  for (const [name, samples] of buckets.entries()) {
-    if (PHASE_ORDER.includes(name)) continue;
-    rows.push({
-      name,
-      median: percentile(samples, 0.5),
-      p95: percentile(samples, 0.95),
-      n: samples.length,
-    });
-  }
-  return rows;
-}
-
-function percentile(samples, q) {
-  const sorted = [...samples].sort((a, b) => a - b);
-  if (sorted.length === 0) return 0;
-  // Nearest-rank method — clamped so q=1 picks the last element.
-  const idx = Math.min(
-    sorted.length - 1,
-    Math.max(0, Math.ceil(q * sorted.length) - 1),
-  );
-  return sorted[idx];
-}
-
-/**
- * Render the aggregated phase-timings table. Returns `null` when there
- * are no summaries to render so the caller can elide the section
- * entirely rather than emitting an empty stub.
- */
-export function renderPhaseTimingsSection(summaries) {
-  if (!Array.isArray(summaries) || summaries.length === 0) return null;
-  const rows = aggregatePhaseTimings(summaries);
-  if (rows.length === 0) return null;
-  const header = `### Phase timings (last ${summaries.length} completed stor${summaries.length === 1 ? 'y' : 'ies'})`;
-  const table = [
-    '| Phase | median ms | p95 ms | n |',
-    '| --- | --- | --- | --- |',
-    ...rows.map((r) => `| ${r.name} | ${r.median} | ${r.p95} | ${r.n} |`),
-  ].join('\n');
-  return `${header}\n\n${table}`;
-}

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),
-      });
-    },
-  };
-}