mandrel 1.58.0 → 1.60.0

package/.agents/scripts/epic-plan-healthcheck.js

@@ -5,7 +5,7 @@
 /**
  * epic-plan-healthcheck.js — Post-Plan Readiness Check
  *
- * Runs at the end of /epic-plan (Phase 10) to validate the backlog and
+ * Runs at the end of /plan (Phase 10) to validate the backlog and
  * optionally prime the execution environment before handing off to
  * /epic-deliver.
  *
@@ -27,7 +27,7 @@
  *   node epic-plan-healthcheck.js --epic <EPIC_ID> \
  *     [--paranoid] [--prime-install] [--dry-run]
  *
- * @see .agents/workflows/epic-plan.md Phase 10
+ * @see .agents/workflows/helpers/plan-epic.md Phase 10
  */
 
 import { spawnSync } from 'node:child_process';
@@ -131,7 +131,7 @@ function checkGitRemote(baseBranch, cwd) {
 
 /**
  * Detect whether a Story body carries an inline `## Acceptance` section with
- * at least one checklist item. Epic #3078 — under 3-tier hierarchy, Stories
+ * at least one checklist item. Epic #3078 — under 2-tier hierarchy, Stories
  * carry acceptance inline, so the hierarchy check uses this signal as the
  * mark of a complete, executable Story.
  *
@@ -152,7 +152,7 @@ function hasInlineAcceptance(body) {
 }
 
 /**
- * Validate Epic ticket hierarchy. 3-tier is the only supported hierarchy
+ * Validate Epic ticket hierarchy. 2-tier is the only supported hierarchy
  * after Task #3154 deleted `planning.hierarchy`: every Story must carry an
  * inline `## Acceptance` checklist; there is no Task layer to graph.
  *
@@ -181,13 +181,9 @@ async function checkTickets(provider, epicId) {
     return { ok: false, detail: `Epic #${epicId} has no child tickets.` };
   }
 
-  const features = tickets.filter((t) =>
-    t.labels.includes(TYPE_LABELS.FEATURE),
-  );
   const stories = tickets.filter((t) => t.labels.includes(TYPE_LABELS.STORY));
 
   const errors = [];
-  if (features.length === 0) errors.push('no type::feature tickets');
   if (stories.length === 0) errors.push('no type::story tickets');
 
   const missingAcceptance = stories.filter(
@@ -214,7 +210,7 @@ async function checkTickets(provider, epicId) {
 
   return {
     ok: true,
-    detail: `${features.length} features, ${stories.length} stories (3-tier, inline acceptance) — hierarchy valid${advisory}.`,
+    detail: `${stories.length} stories (2-tier, inline acceptance) — hierarchy valid${advisory}.`,
   };
 }
 
@@ -313,7 +309,7 @@ export async function runPlanHealthcheck(opts = {}) {
     await timed('git-remote', async () => checkGitRemote(baseBranch, cwd)),
   );
 
-  // Paranoid lane: ticket-hierarchy revalidation (3-tier only).
+  // Paranoid lane: ticket-hierarchy revalidation (2-tier only).
   if (paranoid) {
     const provider = opts.injectedProvider || createProvider(config);
     progress('CHECK', 'Validating ticket hierarchy...');

package/.agents/scripts/epic-plan-spec-validate.js

@@ -3,7 +3,7 @@
 /**
  * epic-plan-spec-validate.js — Phase 7.5 Tech Spec post-authoring gate CLI.
  *
- * `/epic-plan` Phase 7 authors the Tech Spec; Phase 8.3 (Holistic
+ * `/plan` Phase 7 authors the Tech Spec; Phase 8.3 (Holistic
  * Consolidation) reconciles the draft ticket array against the Tech Spec's
  * `## Delivery Slicing` section, which the decompose-author skill uses as the
  * capability-boundary anchor. When that section is absent the consolidation

package/.agents/scripts/epic-reconcile.js

@@ -195,11 +195,11 @@ export async function fetchGhState(provider, epicId) {
 }
 
 /**
- * Walk the spec depth-first and yield one `{ slug, entity, title,
- * parentSlug, dependsOn }` record per logical entity (epic → feature →
- * story → task), mirroring the diff engine's `flattenSpec`. Local to the
- * CLI so the reseed pass (below) can map spec slugs onto live GH issues
- * without importing the diff engine's private walker. Pure.
+ * Walk the spec and yield one `{ slug, entity, title, parentSlug,
+ * dependsOn }` record per logical entity (epic → story), mirroring the
+ * diff engine's `flattenSpec`. Local to the CLI so the reseed pass
+ * (below) can map spec slugs onto live GH issues without importing the
+ * diff engine's private walker. Pure.
  *
  * @param {object} spec
  * @returns {Array<{slug: string, entity: string, title: string, parentSlug: string|null, dependsOn: string[]}>}
@@ -216,32 +216,14 @@ export function flattenSpecForReseed(spec) {
       dependsOn: [],
     });
   }
-  for (const feature of spec.features ?? []) {
+  for (const story of spec.stories ?? []) {
     out.push({
-      slug: feature.slug,
-      entity: 'feature',
-      title: String(feature.title ?? ''),
+      slug: story.slug,
+      entity: 'story',
+      title: String(story.title ?? ''),
       parentSlug: 'epic',
-      dependsOn: [],
+      dependsOn: story.dependsOn ?? [],
     });
-    for (const story of feature.stories ?? []) {
-      out.push({
-        slug: story.slug,
-        entity: 'story',
-        title: String(story.title ?? ''),
-        parentSlug: feature.slug,
-        dependsOn: story.dependsOn ?? [],
-      });
-      for (const task of story.tasks ?? []) {
-        out.push({
-          slug: task.slug,
-          entity: 'task',
-          title: String(task.title ?? ''),
-          parentSlug: story.slug,
-          dependsOn: [],
-        });
-      }
-    }
   }
   return out;
 }
@@ -255,7 +237,7 @@ export function flattenSpecForReseed(spec) {
  * file is absent (a fresh checkout, a reaped temp dir, the exact
  * situation `--resume` exists to recover from), `loadState` returns an
  * empty mapping, the diff engine sees every spec slug as unmapped, and
- * `apply` recreates the entire Feature/Story tree on top of the existing
+ * `apply` recreates the entire Story set on top of the existing
  * one — duplicating every child. This is precisely the failure `--resume`
  * is meant to prevent.
  *

package/.agents/scripts/evidence-gate.js

@@ -3,7 +3,7 @@
 /**
  * evidence-gate.js — evidence-aware wrapper around a single shell gate.
  *
- * Tech Spec #819 §"Evidence record (Story 7)" — `/epic-deliver` Phase 3
+ * Tech Spec #819 §"Evidence record (Story 7)" — `/deliver` Phase 3
  * (close-validation) runs `npm run lint` and `npm test` against the Epic
  * branch before opening the PR.
  * If the same gate has already passed against the current `git rev-parse
@@ -47,9 +47,9 @@
 import { spawnSync } from 'node:child_process';
 import { parseArgs } from 'node:util';
 import { runAsCli } from './lib/cli-utils.js';
-import { PROJECT_ROOT } from './lib/config-resolver.js';
 import { gitSpawn } from './lib/git-utils.js';
 import { Logger } from './lib/Logger.js';
+import { PROJECT_ROOT } from './lib/project-root.js';
 import {
   hashCommandConfig,
   recordPass,

package/.agents/scripts/generate-workflows-doc.js

@@ -91,7 +91,7 @@ export function renderWorkflowsDoc(catalog) {
     'Every command file lives at `.agents/workflows/<name>.md` and is projected',
     'into a flat `.claude/commands/` tree by `npm run sync:commands` (the',
     'UserPromptSubmit hook keeps it current) so it shows up as a bare `/<name>`',
-    'slash command (e.g. `/epic-deliver`). The projection writes only',
+    'slash command (e.g. `/deliver`). The projection writes only',
     '`.claude/commands/<name>.md` — there is no plugin manifest and no',
     'marketplace listing. The commands load in every Claude Code environment.',
     '',

package/.agents/scripts/git-rebase-and-resolve.js

@@ -40,9 +40,9 @@
 
 import { parseArgs } from 'node:util';
 import { runAsCli } from './lib/cli-utils.js';
-import { PROJECT_ROOT } from './lib/config-resolver.js';
 import { gitSpawn } from './lib/git-utils.js';
 import { Logger } from './lib/Logger.js';
+import { PROJECT_ROOT } from './lib/project-root.js';
 
 function currentBranch(cwd) {
   const res = gitSpawn(cwd, 'rev-parse', '--abbrev-ref', 'HEAD');

package/.agents/scripts/hierarchy-gate.js

@@ -3,7 +3,7 @@
 /**
  * .agents/scripts/hierarchy-gate.js — Hierarchy Completeness Gate
  *
- * Walks the Epic's full sub-issue graph (Features → Stories) and verifies
+ * Walks the Epic's full sub-issue graph (Stories) and verifies
  * every descendant is closed. Where the wave gate asks "did the sprint
  * complete what it committed to?" (manifest view), this gate asks "is
  * anything still open under this Epic?" (live GitHub graph view).
@@ -16,14 +16,13 @@
  *     top-level Stories outside the Epic's sub-issue graph.
  *
  * Per ticket type the rule is:
- *   - Features  — must be closed.
  *   - Stories   — must be closed.
  *   - Auxiliary (context::prd, context::tech-spec) — ignored.
  *     These are closed by the operator after the Epic PR merges, so
  *     requiring them closed here would block every Epic.
  *
- * **3-tier hierarchy (Epic #3078).** Mandrel ships only Epic / Feature /
- * Story tickets. `getSubTickets(<storyId>)` returns `[]`; the walk
+ * **2-tier hierarchy (Story #4041).** Mandrel ships only Epic / Story
+ * tickets. `getSubTickets(<storyId>)` returns `[]`; the walk
  * terminates at the Story. Acceptance criteria live inline on the
  * Story body.
  *
@@ -42,11 +41,17 @@ import { resolveConfig } from './lib/config-resolver.js';
 import { Logger } from './lib/Logger.js';
 import { CONTEXT_LABELS, TYPE_LABELS } from './lib/label-constants.js';
 import { createProvider } from './lib/provider-factory.js';
+import { concurrentMap } from './lib/util/concurrent-map.js';
+
+/**
+ * Bounded fan-out for per-level `getSubTickets` calls. Matches the
+ * wave-record-io.js precedent (Story #3024).
+ */
+const SUB_TICKET_FETCH_CONCURRENCY = 4;
 
 function classify(ticket) {
   const labels = ticket.labels ?? [];
   if (labels.includes(TYPE_LABELS.STORY)) return 'story';
-  if (labels.includes(TYPE_LABELS.FEATURE)) return 'feature';
   if (
     labels.includes(CONTEXT_LABELS.PRD) ||
     labels.includes(CONTEXT_LABELS.TECH_SPEC)
@@ -70,22 +75,35 @@ function ticketIsComplete(ticket) {
  */
 async function collectDescendants(provider, epicId) {
   const visited = new Set([epicId]);
-  const queue = [epicId];
   const out = [];
-  while (queue.length > 0) {
-    const parentId = queue.shift();
-    let children;
-    try {
-      children = await provider.getSubTickets(parentId);
-    } catch (err) {
-      throw new Error(`getSubTickets(#${parentId}) failed: ${err.message}`);
-    }
-    for (const child of children) {
-      if (visited.has(child.id)) continue;
-      visited.add(child.id);
-      out.push(child);
-      queue.push(child.id);
+  // Level-order BFS: each round fetches the whole frontier's children with a
+  // bounded-parallel map instead of one awaited round-trip per node. Stories
+  // are leaves (no sub-issues by contract), so they are never expanded
+  // — that skip alone removes the largest class of wasted GraphQL calls.
+  let frontier = [epicId];
+  while (frontier.length > 0) {
+    const levels = await concurrentMap(
+      frontier,
+      async (parentId) => {
+        try {
+          return await provider.getSubTickets(parentId);
+        } catch (err) {
+          throw new Error(`getSubTickets(#${parentId}) failed: ${err.message}`);
+        }
+      },
+      { concurrency: SUB_TICKET_FETCH_CONCURRENCY },
+    );
+    const next = [];
+    for (const children of levels) {
+      for (const child of children) {
+        if (visited.has(child.id)) continue;
+        visited.add(child.id);
+        out.push(child);
+        const labels = child.labels ?? [];
+        if (!labels.includes(TYPE_LABELS.STORY)) next.push(child.id);
+      }
     }
+    frontier = next;
   }
   return out;
 }
@@ -106,7 +124,7 @@ export async function runHierarchyGate({ epicId, injectedProvider } = {}) {
     process.exit(2);
   }
 
-  const failures = { feature: [], story: [], other: [] };
+  const failures = { story: [], other: [] };
   let auxiliaryDeferred = 0;
   for (const ticket of descendants) {
     const kind = classify(ticket);
@@ -124,15 +142,13 @@ export async function runHierarchyGate({ epicId, injectedProvider } = {}) {
     }
   }
 
-  const totalOpen =
-    failures.feature.length + failures.story.length + failures.other.length;
+  const totalOpen = failures.story.length + failures.other.length;
 
   if (totalOpen > 0) {
     Logger.error(
       `[hierarchy-gate] ❌ Hierarchy-completeness gate FAILED for Epic #${epicId}: ${totalOpen} descendant(s) incomplete.`,
     );
     const sections = [
-      ['feature', 'Features'],
       ['story', 'Stories'],
       ['other', 'Untyped descendants'],
     ];
@@ -143,7 +159,7 @@ export async function runHierarchyGate({ epicId, injectedProvider } = {}) {
         Logger.error(`    - #${item.id} (${item.reason}) — ${item.title}`);
       }
     }
-    Logger.error('\nClose the open descendants and re-run `/epic-deliver`.');
+    Logger.error('\nClose the open descendants and re-run `/deliver`.');
     process.exit(1);
   }
 

package/.agents/scripts/lib/ITicketingProvider.js

@@ -154,7 +154,7 @@ export class ITicketingProvider {
   /**
    * Create a child ticket within an Epic's structural hierarchy.
    *
-   * @param {number} parentId - GitHub Issue number of the immediate structural parent (e.g. Epic, Feature, or Story).
+   * @param {number} parentId - GitHub Issue number of the immediate structural parent (e.g. Epic or Story).
    * @param {{
    *   epicId: number,
    *   title: string,

package/.agents/scripts/lib/audit-suite/selector.js

@@ -60,7 +60,7 @@ export function matchesAnyFilePattern(patterns, files) {
  *   callers MUST pass the requested Epic's own branch ref (e.g.
  *   `refs/heads/epic/<id>`) so the change set is pinned to that Epic's branch
  *   rather than whatever HEAD the shared checkout happens to sit on. Under two
- *   concurrent `/epic-deliver` runs sharing one checkout, diffing against
+ *   concurrent `/deliver` runs sharing one checkout, diffing against
  *   `HEAD` silently resolves the *other* Epic's change set (Story #3362). When
  *   `headRef` cannot be resolved in the repo, the selector returns a
  *   `degraded: true` envelope (or hard-fails in gate-mode) instead of diffing

package/.agents/scripts/lib/audit-to-stories/seed-epic-from-findings.js

@@ -1,7 +1,7 @@
 /**
  * lib/audit-to-stories/seed-epic-from-findings.js
  *
- * Build the `--idea`-shaped seed markdown that `/epic-plan` Phase 1
+ * Build the `--idea`-shaped seed markdown that `/plan` Phase 1
  * consumes when the operator picks the Single-Epic grouping mode.
  *
  * The seed renders the canonical one-pager sections so the idea-refinement
@@ -10,7 +10,7 @@
  *   - Recommended Direction (rollup of recommendations by dimension)
  *   - Key Assumptions (carries the source-report links forward)
  *   - MVP Scope (the proposed Stories, one bullet per group)
- *   - Key Files (explicit file paths so /epic-plan Phase 7 decompose
+ *   - Key Files (explicit file paths so /plan Phase 7 decompose
  *     has concrete anchors)
  *   - Not Doing (out-of-scope items by convention)
  *

package/.agents/scripts/lib/baseline-snapshot.js

@@ -28,8 +28,8 @@ import { calculateAll, scanDirectory } from './maintainability-utils.js';
  * baseline-snapshot.js — per-Epic baseline lifecycle helpers.
  *
  * Story #1396 (Epic #1386). The Epic-snapshot scheme freezes the maintainability
- * and crap baselines at /epic-plan time and reconciles them back to `main`
- * at /epic-deliver time. Two helpers, both pure-ish (deterministic given the
+ * and crap baselines at /plan time and reconciles them back to `main`
+ * at /deliver time. Two helpers, both pure-ish (deterministic given the
  * working tree + injected I/O):
  *
  *   - forkMainToEpic({ epicId, cwd }) — copies the tracked main baselines
@@ -37,20 +37,20 @@ import { calculateAll, scanDirectory } from './maintainability-utils.js';
  *     source content produces the same destination bytes (no fs churn). When
  *     the source baseline is missing, emits a warn through the injected
  *     logger and returns `{ written: false, reason: 'source-missing' }` for
- *     that file — callers (e.g. /epic-plan Phase 7) treat the absence as
+ *     that file — callers (e.g. /plan Phase 7) treat the absence as
  *     non-fatal and stay in `--full-scope` mode.
  *
  *   - regenerateMainFromTree({ cwd }) — re-scores maintainability + crap
  *     against the current working tree and writes the result to the tracked
  *     main baseline paths. Returns `{ didChange, paths }` where `didChange`
  *     is true iff any baseline file's content differs from what's already on
- *     disk. Callers in /epic-deliver use `didChange === false` to skip the
+ *     disk. Callers in /deliver use `didChange === false` to skip the
  *     `baseline-refresh: epic-<id>` commit.
  *
  * Lifecycle note (Story #1467): per-epic ratchet snapshots are ephemeral
  * scratch state under the `temp/epic-<id>/baselines/` namespace, NOT committed
  * artifacts. They inherit the existing per-epic temp-tree cleanup contract —
- * `/epic-deliver` reaps the parent `temp/epic-<id>/` directory on merge, so
+ * `/deliver` reaps the parent `temp/epic-<id>/` directory on merge, so
  * no manual prune is required. Earlier versions of this module wrote under
  * `baselines/epic/<id>/`, which committed them to git and accumulated obsolete
  * snapshots forever.
@@ -103,7 +103,7 @@ export function epicSnapshotPathFor({ epicId, kind, cwd = process.cwd() }) {
  *   - Source baseline missing → returned per-file `{ written: false,
  *     reason: 'source-missing' }`. Logger warn fires once per missing file.
  *     Caller stays in `--full-scope` mode.
- *   - Source unreadable / not parseable → throws. Re-running /epic-plan
+ *   - Source unreadable / not parseable → throws. Re-running /plan
  *     with `--force` after fixing the source recovers.
  *
  * @param {{
@@ -428,7 +428,7 @@ export function commitSnapshotsToEpicBranch({
  * via `delivery.quality.gates.crap.coveragePath`. When coverage is missing and
  * `requireCoverage` is true, the crap regeneration is skipped (didChange stays
  * false for that file) and a warn is emitted — the operator is expected to run
- * `npm run test:coverage` before /epic-deliver if a refresh is anticipated.
+ * `npm run test:coverage` before /deliver if a refresh is anticipated.
  *
  * @param {{
  *   cwd?: string,

package/.agents/scripts/lib/baselines/kinds/coverage.js

@@ -7,19 +7,22 @@
  * `*` key and each component. Per-row denominators land later when the
  * components resolver and per-component weighting (Story #1902, #1919)
  * arrive; the rollup signature is stable so callers don't churn.
+ *
+ * Higher percentages are better. New paths land in the `additions` bucket
+ * (Story #2012 — partial coverage on a new file must never flip to a
+ * regression); removed paths inherit a perfect head row so any lower base
+ * registers as an improvement. Scaffold (sortRows / rollup / compare /
+ * applyEpsilon / mergeRows) is generated by `makeBaselineKind`
+ * (Story #3983).
  */
 
-import { componentMatches } from '../component-matcher.js';
 import { canonicalise } from '../path-canon.js';
-import { mergeRowsByScope } from '../scope.js';
+import { makeBaselineKind } from './kind-factory.js';
 
 export const name = 'coverage';
 export const keyField = 'path';
-const KERNEL_VERSION = '1.0.0';
 
-export function kernelVersion() {
-  return KERNEL_VERSION;
-}
+const COV_AXES = ['lines', 'branches', 'functions'];
 
 export function projectRow(row) {
   return {
@@ -35,160 +38,41 @@ function roundPct(v) {
   return Number(v.toFixed(2));
 }
 
-export function sortRows(rows) {
-  return [...rows].sort((a, b) => a.path.localeCompare(b.path));
+function meanOf(rows, axis) {
+  let sum = 0;
+  for (const r of rows) sum += r[axis] ?? 0;
+  return Number((sum / rows.length).toFixed(2));
 }
 
 function aggregate(rows) {
   if (!rows || rows.length === 0) {
     return { lines: 0, branches: 0, functions: 0 };
   }
-  let l = 0;
-  let b = 0;
-  let f = 0;
-  for (const row of rows) {
-    l += row.lines ?? 0;
-    b += row.branches ?? 0;
-    f += row.functions ?? 0;
-  }
   return {
-    lines: Number((l / rows.length).toFixed(2)),
-    branches: Number((b / rows.length).toFixed(2)),
-    functions: Number((f / rows.length).toFixed(2)),
+    lines: meanOf(rows, 'lines'),
+    branches: meanOf(rows, 'branches'),
+    functions: meanOf(rows, 'functions'),
   };
 }
 
-export function rollup(rows, components = []) {
-  const out = { '*': aggregate(rows) };
-  for (const c of components ?? []) {
-    const matched = (rows ?? []).filter((r) => componentMatches(c, r.path));
-    out[c.name] = aggregate(matched);
-  }
-  return out;
-}
-
-/**
- * Pure compare(head, base) for the coverage kind. Diffs rows by `path`.
- * Higher percentages are better — a row regresses if any axis (lines,
- * branches, functions) drops vs base; improves if any axis rises with no
- * axis dropping; unchanged otherwise. New paths (head has a row that
- * base lacks) land in the `additions` bucket; absolute-floor enforcement
- * is the unified `check-baselines` gate's job and runs independently.
- * Removed paths inherit a head of 100% so any lower base registers as
- * an improvement.
- *
- * Story #2012 — sibling fix to maintainability.compare. The prior
- * behaviour treated new paths as base=100% on every axis, so any partial
- * coverage on a new file flipped to a regression.
- *
- * No I/O. No process exit. No friction emission.
- */
-const COV_AXES = ['lines', 'branches', 'functions'];
-
-export function compare(head, base) {
-  const headRows = Array.isArray(head?.rows) ? head.rows : [];
-  const baseRows = Array.isArray(base?.rows) ? base.rows : [];
-  const baseByKey = new Map();
-  for (const r of baseRows) baseByKey.set(r.path, r);
-  const seen = new Set();
-  const regressions = [];
-  const improvements = [];
-  const unchanged = [];
-  const additions = [];
-  for (const h of headRows) {
-    seen.add(h.path);
-    const b = baseByKey.get(h.path);
-    if (!b) {
-      additions.push({ key: h.path, head: h, base: null });
-      continue;
-    }
-    classifyCoverage(regressions, improvements, unchanged, h.path, h, b);
-  }
-  for (const b of baseRows) {
-    if (seen.has(b.path)) continue;
-    const h = perfectCoverageRow(b.path);
-    classifyCoverage(regressions, improvements, unchanged, b.path, h, b);
-  }
-  return { regressions, improvements, unchanged, additions };
-}
-
 function perfectCoverageRow(path) {
   return { path, lines: 100, branches: 100, functions: 100 };
 }
 
-function classifyCoverage(
-  regressions,
-  improvements,
-  unchanged,
-  key,
-  head,
-  base,
-) {
-  let down = false;
-  let up = false;
-  for (const axis of COV_AXES) {
-    const delta = (head[axis] ?? 0) - (base[axis] ?? 0);
-    if (delta < 0) down = true;
-    else if (delta > 0) up = true;
-  }
-  if (down) regressions.push({ key, head, base });
-  else if (up) improvements.push({ key, head, base });
-  else unchanged.push({ key, head, base });
-}
-
-/**
- * Pure stabilizer for s-stability-epsilon (Story #1964). Folds sub-epsilon
- * row deltas back to the prior bytes so env variance (e.g. ±0.05% jitter
- * on a coverage axis) does not rewrite the on-disk baseline.
- *
- * For coverage, the comparison metric is the maximum |delta| across the
- * three axes (lines, branches, functions). When the prior row exists and
- * every axis delta is within `epsilon`, the prior row is returned
- * verbatim; otherwise the regenerated row wins. Missing-prior rows always
- * fall through to the regenerated row.
- *
- * No I/O. No mutation of inputs.
- *
- * @param {Array<{path: string, lines: number, branches: number, functions: number}>} prior
- * @param {Array<{path: string, lines: number, branches: number, functions: number}>} regenerated
- * @param {number} epsilon non-negative absolute tolerance (percentage points)
- * @returns {Array<object>}
- */
-export function applyEpsilon(prior, regenerated, epsilon) {
-  const priorRows = Array.isArray(prior) ? prior : [];
-  const regenRows = Array.isArray(regenerated) ? regenerated : [];
-  const eps = Number.isFinite(epsilon) && epsilon >= 0 ? epsilon : 0;
-  const priorByKey = new Map();
-  for (const r of priorRows) priorByKey.set(r.path, r);
-  return regenRows.map((row) => {
-    const p = priorByKey.get(row.path);
-    if (!p) return row;
-    let maxAxisDelta = 0;
-    for (const axis of COV_AXES) {
-      const d = Math.abs((row[axis] ?? 0) - (p[axis] ?? 0));
-      if (d > maxAxisDelta) maxAxisDelta = d;
-    }
-    return maxAxisDelta <= eps ? p : row;
-  });
-}
-
-/**
- * Pure scope-aware merge for s-diff-scoped-writes (Story #1974). Coverage
- * rows match by `path`. In diff mode, rows whose `path` is OUTSIDE
- * `scope.files` are preserved from `prior` verbatim; in-scope rows come
- * from `regenerated`. In full mode (or no scope), regenerated wins
- * everywhere. Pure; downstream `sortRows` re-sorts before write.
- *
- * @param {Array<{path: string, lines: number, branches: number, functions: number}>} prior
- * @param {Array<{path: string, lines: number, branches: number, functions: number}>} regenerated
- * @param {{mode: 'full'|'diff', files: Set<string>}|null|undefined} scope
- * @returns {Array<object>}
- */
-export function mergeRows(prior, regenerated, scope) {
-  return mergeRowsByScope({
-    prior,
-    regenerated,
-    scope,
-    scopeKey: (row) => row.path,
-  });
-}
+export const {
+  kernelVersion,
+  sortRows,
+  rollup,
+  compare,
+  applyEpsilon,
+  mergeRows,
+} = makeBaselineKind({
+  keyField,
+  kernelVersion: '1.0.0',
+  axes: COV_AXES,
+  betterWhen: 'higher',
+  aggregate,
+  missingBasePolicy: 'addition',
+  removedRowPolicy: { kind: 'perfect-head' },
+  perfectRow: perfectCoverageRow,
+});