mandrel 2.60.0 → 2.62.0

package/.agents/scripts/lib/config/quality.js

@@ -1,58 +1,22 @@
 /**
- * `delivery.quality` accessor (Epic #1720 Story #1737 — uniform gate shape).
- *
- * The quality block under `delivery.quality.*` is now organised as a
- * `gates.<tier>` object where every tier (lint, coverage, crap,
- * maintainability, mutation, lighthouse, bundle-size) shares the same
- * four-field base:
- *
- *   - `enabled`      — when `false`, the checker exits 0 with a skip line.
- *   - `baselinePath` — repo-root-relative path to the gate's baseline file.
- *   - `tolerance`    — `{ kind: 'absolute' | 'percent', value: number }`.
- *   - `floors`       — workspace-keyed `{ "*": { ... } }` floor object.
- *
- * Story #1737 changes (vs the Story #1739 mechanical relocation):
- *
- *   - `gateScoping` is the single source of truth for diff scope / ref.
- *     The duplicate `defaultScope` / `diffRef` keys on crap and
- *     maintainability are gone — resolvers carry the scope through from
- *     the lifted block.
- *   - Scalar `tolerance` values became `{ kind, value }` objects.
- *   - `coveragePath` moved from `gates.crap` to `gates.coverage`. CRAP
- *     reads from the coverage gate instead of carrying its own.
- *   - Flat `qualityFloors.*` shape is gone — every gate carries its own
- *     workspace-keyed `floors` object.
- *
- * The resolver returns a flattened bag with the legacy field names
- * (`crap.tolerance` as a number, `crap.targetDirs`, `maintainability.targetDirs`,
- * `crap.coveragePath`, etc.) so existing call sites stay untouched.
- * The translation from gate shape → legacy bag happens here, in one
- * place.
+ * `delivery.quality` resolver. Every `gates.<tier>` shares `enabled`,
+ * `baselinePath`, `tolerance` (`{ kind, value }`) and workspace-keyed
+ * `floors`; the resolver flattens them into the legacy bag callers read
+ * (scalar `tolerance`, `crap.coveragePath` cross-read from the coverage gate).
  */
 
 import { Logger } from '../Logger.js';
 import { resolveListValue } from './shared.js';
 
-const DEFAULT_GATE_SCOPING = Object.freeze({ scope: 'diff', diffRef: 'main' });
+const GATE_SCOPING = Object.freeze({ scope: 'diff', diffRef: 'main' });
+
+/** Commit-subject substring acknowledging a deliberate baseline refresh. */
+const BASELINE_REFRESH_TAG = 'baseline-refresh:';
 
-/**
- * Default object-shape tolerance for each gate. Values match the historical
- * scalar defaults so a consumer that omits `tolerance` keeps the prior
- * gate behaviour.
- */
 const DEFAULT_CRAP_TOLERANCE = Object.freeze({ kind: 'absolute', value: 0.05 });
 const DEFAULT_MI_TOLERANCE = Object.freeze({ kind: 'absolute', value: 0.5 });
 
-/**
- * Default floors per gate. Workspace-keyed so a single-workspace consumer
- * reads `floors["*"]` and a monorepo consumer can override per-workspace.
- *
- * Story #2125: these defaults are now injected by `resolveQuality` into
- * the resolved `gates.<kind>.floors` block when the consumer omits the
- * `'*'` workspace key, so `.agentrc.json` can carry `floors: {}` (or
- * omit the gate entirely) and still get framework-default enforcement
- * from the unified `check-baselines.js` dispatcher.
- */
+/** Injected when a declared gate omits a workspace key (usually `'*'`). */
 const DEFAULT_COVERAGE_FLOORS = Object.freeze({
   '*': Object.freeze({ lines: 90, branches: 85, functions: 90 }),
 });
@@ -60,35 +24,18 @@ const DEFAULT_CRAP_FLOORS = Object.freeze({
   '*': Object.freeze({ max: 30, p95: 20, methodsAbove20: 50 }),
 });
 /**
- * Story #2193 — maintainability rollups expose the `min` / `p50` / `p95`
- * axes (see `.agents/schemas/baselines/maintainability.schema.json`). The
- * default floor therefore targets `min`, not the row-axis `maintainability`
- * name. The pre-#2193 default keyed on `maintainability` silently no-oped
- * inside `check-baselines.js#compareToFloor` because the rollup never
- * exposed that axis.
+ * Keyed on the rollup's `min` axis; a `maintainability` key silently
+ * no-ops because the rollup never exposes it.
  */
 const DEFAULT_MI_FLOORS = Object.freeze({
   '*': Object.freeze({ min: 70 }),
 });
 
 /**
- * Story #4981 / #5065 / #5173 — the two independent full-suite economies.
- *
- * `skipWhenUnchanged` decides *whether* to capture: no changed file under
- * `crap.targetDirs` versus `baseRef` means no capture at all. It is on by
- * default because it is gate-semantics-neutral — the gates score exactly what
- * they scored before, since nothing they score moved.
- *
- * `baselineJoin` lets the CRAP join resolve a method in an untouched file
- * from its committed baseline row instead of requiring fresh coverage for it.
- * That *loosens* the gate, so it stays off by default. Bundling the two under
- * one `enabled` switch is precisely what forced the earlier default flip to
- * be reverted (Story #5173).
- *
- * Neither switch shortens the capture run — a capture that does happen is the
- * ordinary full `npm run test:coverage` (Story #5065). `baseRef: null` means
- * "use the caller's own ref resolution" (the gate's `--ref` flag / `main`)
- * rather than a second, possibly-conflicting default.
+ * `skipWhenUnchanged` (on: gate-neutral) skips capture when nothing under
+ * `crap.targetDirs` changed vs `baseRef`. `baselineJoin` (off: it loosens the
+ * gate) resolves untouched files from committed baseline rows. The two must
+ * stay independent. `baseRef: null` defers to the caller's ref resolution.
  */
 const DEFAULT_INCREMENTAL_COVERAGE = Object.freeze({
   skipWhenUnchanged: true,
@@ -96,7 +43,6 @@ const DEFAULT_INCREMENTAL_COVERAGE = Object.freeze({
   baseRef: null,
 });
 
-/** Framework defaults for the CRAP gate (post-1737 uniform shape). */
 export const CRAP_GATE_DEFAULTS = Object.freeze({
   enabled: true,
   baselinePath: 'baselines/crap.json',
@@ -105,77 +51,37 @@ export const CRAP_GATE_DEFAULTS = Object.freeze({
   targetDirs: Object.freeze(['src']),
   newMethodCeiling: 30,
   requireCoverage: true,
-  friction: Object.freeze({ markerKey: 'crap-baseline-regression' }),
-  refreshTag: 'baseline-refresh:',
-  // Story #2165 — bounded timeout (ms) for `npm run crap:update` spawned by
-  // the baseline-attribution refresh path. Defaults to 60 s; mirrors
-  // `gates.coverage.timeoutMs` (Story #2142) for shape and SIGKILL → 124
-  // semantics.
-  refreshTimeoutMs: 60_000,
+  refreshTag: BASELINE_REFRESH_TAG,
   ignoreGlobs: Object.freeze([]),
-  // Story #4775 — fail-closed floor on the per-method coverage JOIN. The
-  // fraction of methods that must resolve a coverage entry, counted only over
-  // files that HAVE one, before `update-crap-baseline.js` will persist. A
-  // broken join is silent by construction (unresolved methods are simply
-  // absent from the baseline), so the updater refuses rather than writing a
-  // thin baseline and logging it as success. 0.75 sits far above a healthy
-  // run (a repo with fresh coverage resolves ~98%) and far below the 4–6%
-  // signature of a coordinate-system mismatch.
+  // Fail-closed floor on the coverage join (over files that have coverage):
+  // a broken join is silent, so the updater refuses to persist below it.
+  // Healthy runs resolve ~98%; a coordinate mismatch resolves 4–6%.
   minMethodResolutionRate: 0.75,
   incrementalCoverage: DEFAULT_INCREMENTAL_COVERAGE,
 });
 
-/** Framework defaults for the coverage gate. */
 export const COVERAGE_GATE_DEFAULTS = Object.freeze({
   enabled: true,
   baselinePath: 'baselines/coverage.json',
   tolerance: Object.freeze({ kind: 'absolute', value: 0 }),
   floors: DEFAULT_COVERAGE_FLOORS,
   coveragePath: 'coverage/coverage-final.json',
-  // Story #2136 — 10 minute wall clock on `npm run test:coverage`. Trips
-  // `runCapture` to return exit 124 (GNU `timeout` convention) so the
-  // close-validation caller can branch on hang-vs-failure.
+  // On expiry `runCapture` exits 124 so callers can tell a hang from a failure.
   timeoutMs: 600_000,
 });
 
-/** Framework defaults for the maintainability gate. */
 export const MAINTAINABILITY_GATE_DEFAULTS = Object.freeze({
   enabled: true,
   baselinePath: 'baselines/maintainability.json',
   tolerance: DEFAULT_MI_TOLERANCE,
   floors: DEFAULT_MI_FLOORS,
   targetDirs: Object.freeze([]),
-  // Story #4731 — the commit-subject substring that acknowledges a deliberate
-  // maintainability baseline refresh in the compared range. Mirrors the CRAP
-  // gate's `refreshTag`; the evaluate phase demotes head-vs-base regressions
-  // (floors still enforced) when a range commit carrying this tag touches the
-  // baseline file. Kept identical to the CRAP default so one refresh commit
-  // can acknowledge both gates.
-  refreshTag: 'baseline-refresh:',
-  // Story #2165 — bounded timeout (ms) for `npm run maintainability:update`
-  // spawned by the baseline-attribution refresh path. Defaults to 60 s.
-  refreshTimeoutMs: 60_000,
+  // Same tag as CRAP so one refresh commit acknowledges both gates.
+  refreshTag: BASELINE_REFRESH_TAG,
   ignoreGlobs: Object.freeze([]),
-  // Story #4775 — fail-closed floor on the per-method coverage JOIN. The
-  // fraction of methods that must resolve a coverage entry, counted only over
-  // files that HAVE one, before `update-crap-baseline.js` will persist. A
-  // broken join is silent by construction (unresolved methods are simply
-  // absent from the baseline), so the updater refuses rather than writing a
-  // thin baseline and logging it as success. 0.75 sits far above a healthy
-  // run (a repo with fresh coverage resolves ~98%) and far below the 4–6%
-  // signature of a coordinate-system mismatch.
   minMethodResolutionRate: 0.75,
 });
 
-/**
- * Story #2165 — framework defaults for the close-time `npx biome format
- * --write` autofix spawn. The SIGKILL → exit 124 mapping mirrors
- * `gates.coverage.timeoutMs` (Story #2142).
- */
-const FORMAT_AUTOFIX_DEFAULTS = Object.freeze({
-  timeoutMs: 60_000,
-});
-
 const CRAP_GATE_KEYS = new Set([
   'enabled',
   'baselinePath',
@@ -184,9 +90,6 @@ const CRAP_GATE_KEYS = new Set([
   'targetDirs',
   'newMethodCeiling',
   'requireCoverage',
-  'friction',
-  'refreshTag',
-  'refreshTimeoutMs',
   'ignoreGlobs',
   'minMethodResolutionRate',
   'incrementalCoverage',
@@ -198,7 +101,6 @@ const COVERAGE_GATE_KEYS = new Set([
   'tolerance',
   'floors',
   'coveragePath',
-  'timeoutMs',
 ]);
 
 const MI_GATE_KEYS = new Set([
@@ -207,18 +109,12 @@ const MI_GATE_KEYS = new Set([
   'tolerance',
   'floors',
   'targetDirs',
-  'refreshTag',
-  'refreshTimeoutMs',
   'ignoreGlobs',
 ]);
 
 /**
- * Pure helper: coerce the object-shape tolerance to its scalar `value`
- * for call sites that still expect a plain number. Returns the default
- * scalar when the tolerance object is malformed.
- *
  * @param {{ kind?: string, value?: number } | undefined} tolerance
- * @param {number} fallback scalar tolerance
+ * @param {number} fallback
  * @returns {number}
  */
 function toleranceScalar(tolerance, fallback) {
@@ -242,20 +138,7 @@ function warnUnknownKeys(userBlock, knownKeys, blockLabel) {
 }
 
 /**
- * Resolve the CRAP gate. Accepts both the new `gates.crap.*` shape and
- * the resolved `coverage` gate (for the `coveragePath` cross-read). The
- * lifted `gateScoping` carries the diff scope and ref.
- *
- * @param {object | undefined} userCrap raw `delivery.quality.gates.crap`
- * @param {{ scope: string, diffRef: string }} gateScoping resolved scoping
- * @param {{ coveragePath: string }} coverageGate resolved coverage gate
- * @returns {object} flattened legacy-bag view that existing callers read
- */
-/**
- * Clamp a user-supplied method-resolution floor into `[0, 1]`. A
- * non-numeric, non-finite, or out-of-range value falls back to the framework
- * default rather than silently disabling the guard (a floor of `NaN` would
- * compare false against every rate and never fire).
+ * Out-of-range or non-finite falls back: a `NaN` floor would never fire.
  *
  * @param {unknown} value
  * @param {number} fallback
@@ -268,26 +151,14 @@ function resolveResolutionRate(value, fallback) {
 }
 
 /**
- * Resolve `gates.crap.incrementalCoverage` (Story #4981, split by #5173).
- *
- * Precedence, lowest to highest: the framework defaults
- * (`skipWhenUnchanged: true`, `baselineJoin: false`), then the deprecated
- * `enabled` alias which sets **both** switches to its value, then either
- * explicit switch. A malformed or absent user block resolves to the defaults,
- * so a consumer that never sets the key inherits the saving without the
- * loosening.
- *
- * @param {{ skipWhenUnchanged?: boolean, baselineJoin?: boolean, enabled?: boolean, baseRef?: string } | undefined} user
+ * @param {{ skipWhenUnchanged?: boolean, baselineJoin?: boolean, baseRef?: string } | undefined} user
  * @param {{ skipWhenUnchanged: boolean, baselineJoin: boolean, baseRef: string | null }} defaults
  * @returns {{ skipWhenUnchanged: boolean, baselineJoin: boolean, baseRef: string | null }}
  */
 function resolveIncrementalCoverage(user, defaults) {
   if (user == null || typeof user !== 'object') return { ...defaults };
-  const alias = typeof user.enabled === 'boolean' ? user.enabled : null;
-  const pick = (explicit, fallback) => {
-    if (typeof explicit === 'boolean') return explicit;
-    return alias === null ? fallback : alias;
-  };
+  const pick = (explicit, fallback) =>
+    typeof explicit === 'boolean' ? explicit : fallback;
   return {
     skipWhenUnchanged: pick(user.skipWhenUnchanged, defaults.skipWhenUnchanged),
     baselineJoin: pick(user.baselineJoin, defaults.baselineJoin),
@@ -298,17 +169,19 @@ function resolveIncrementalCoverage(user, defaults) {
   };
 }
 
-export function resolveMaintainabilityCrap(
-  userCrap,
-  gateScoping,
-  coverageGate,
-) {
+/**
+ * @param {object | undefined} userCrap
+ * @param {{ coveragePath: string }} coverageGate
+ * @returns {object}
+ */
+export function resolveMaintainabilityCrap(userCrap, coverageGate) {
   const defaults = CRAP_GATE_DEFAULTS;
-  const scoping = {
-    defaultScope: gateScoping?.scope ?? DEFAULT_GATE_SCOPING.scope,
-    diffRef: gateScoping?.diffRef ?? DEFAULT_GATE_SCOPING.diffRef,
-  };
   const coverage = coverageGate ?? COVERAGE_GATE_DEFAULTS;
+  const fixed = {
+    refreshTag: defaults.refreshTag,
+    defaultScope: GATE_SCOPING.scope,
+    diffRef: GATE_SCOPING.diffRef,
+  };
   if (userCrap == null || typeof userCrap !== 'object') {
     return {
       enabled: defaults.enabled,
@@ -321,13 +194,9 @@ export function resolveMaintainabilityCrap(
       ),
       requireCoverage: defaults.requireCoverage,
       minMethodResolutionRate: defaults.minMethodResolutionRate,
-      friction: { ...defaults.friction },
-      refreshTag: defaults.refreshTag,
-      refreshTimeoutMs: defaults.refreshTimeoutMs,
       ignoreGlobs: [...defaults.ignoreGlobs],
       incrementalCoverage: { ...defaults.incrementalCoverage },
-      defaultScope: scoping.defaultScope,
-      diffRef: scoping.diffRef,
+      ...fixed,
     };
   }
 
@@ -347,12 +216,6 @@ export function resolveMaintainabilityCrap(
       userCrap.minMethodResolutionRate,
       defaults.minMethodResolutionRate,
     ),
-    friction: { ...defaults.friction, ...(userCrap.friction ?? {}) },
-    refreshTag: userCrap.refreshTag ?? defaults.refreshTag,
-    refreshTimeoutMs: resolvePositiveIntegerMs(
-      userCrap.refreshTimeoutMs,
-      defaults.refreshTimeoutMs,
-    ),
     ignoreGlobs: Array.isArray(userCrap.ignoreGlobs)
       ? userCrap.ignoreGlobs.slice()
       : [...defaults.ignoreGlobs],
@@ -360,48 +223,31 @@ export function resolveMaintainabilityCrap(
       userCrap.incrementalCoverage,
       defaults.incrementalCoverage,
     ),
-    defaultScope: scoping.defaultScope,
-    diffRef: scoping.diffRef,
+    ...fixed,
   };
 }
 
-/**
- * Resolve the maintainability gate. Returns the legacy-bag shape with
- * `targetDirs` + a scalar `tolerance` (when set) + scoping inherited
- * from `gateScoping`.
- */
-function resolveMaintainabilityQuality(userBlock, gateScoping) {
+function resolveMaintainabilityQuality(userBlock) {
   const defaults = MAINTAINABILITY_GATE_DEFAULTS;
-  const scoping = {
-    defaultScope: gateScoping?.scope ?? DEFAULT_GATE_SCOPING.scope,
-    diffRef: gateScoping?.diffRef ?? DEFAULT_GATE_SCOPING.diffRef,
+  const fixed = {
+    refreshTag: defaults.refreshTag,
+    defaultScope: GATE_SCOPING.scope,
+    diffRef: GATE_SCOPING.diffRef,
   };
   if (userBlock == null || typeof userBlock !== 'object') {
     return {
       targetDirs: [...defaults.targetDirs],
-      refreshTag: defaults.refreshTag,
-      refreshTimeoutMs: defaults.refreshTimeoutMs,
       ignoreGlobs: [...defaults.ignoreGlobs],
-      defaultScope: scoping.defaultScope,
-      diffRef: scoping.diffRef,
+      ...fixed,
     };
   }
   warnUnknownKeys(userBlock, MI_GATE_KEYS, 'quality.gates.maintainability');
   const out = {
     targetDirs: resolveListValue(defaults.targetDirs, userBlock.targetDirs),
-    refreshTag:
-      typeof userBlock.refreshTag === 'string' && userBlock.refreshTag.length
-        ? userBlock.refreshTag
-        : defaults.refreshTag,
-    refreshTimeoutMs: resolvePositiveIntegerMs(
-      userBlock.refreshTimeoutMs,
-      defaults.refreshTimeoutMs,
-    ),
     ignoreGlobs: Array.isArray(userBlock.ignoreGlobs)
       ? userBlock.ignoreGlobs.slice()
       : [...defaults.ignoreGlobs],
-    defaultScope: scoping.defaultScope,
-    diffRef: scoping.diffRef,
+    ...fixed,
   };
   if (userBlock.tolerance !== undefined) {
     out.tolerance = toleranceScalar(
@@ -412,46 +258,6 @@ function resolveMaintainabilityQuality(userBlock, gateScoping) {
   return out;
 }
 
-/**
- * Story #2165 — accept a user-supplied positive-integer ms budget, falling
- * back to `defaultMs` when the value is missing, non-integer, or non-positive.
- * Mirrors the inlined guard in `resolveCoverageGate`.
- *
- * @param {*} value
- * @param {number} defaultMs
- * @returns {number}
- */
-function resolvePositiveIntegerMs(value, defaultMs) {
-  if (typeof value === 'number' && Number.isInteger(value) && value > 0) {
-    return value;
-  }
-  return defaultMs;
-}
-
-/**
- * Story #2165 — resolve `delivery.quality.formatAutofix`. Owns the bounded
- * timeout for the close-time `npx biome format --write` spawn.
- *
- * @param {object | undefined} userBlock
- * @returns {{ timeoutMs: number }}
- */
-const FORMAT_AUTOFIX_KEYS = new Set(['timeoutMs']);
-
-function resolveFormatAutofix(userBlock) {
-  const defaults = FORMAT_AUTOFIX_DEFAULTS;
-  if (userBlock == null || typeof userBlock !== 'object') {
-    return { timeoutMs: defaults.timeoutMs };
-  }
-  warnUnknownKeys(userBlock, FORMAT_AUTOFIX_KEYS, 'quality.formatAutofix');
-  return {
-    timeoutMs: resolvePositiveIntegerMs(
-      userBlock.timeoutMs,
-      defaults.timeoutMs,
-    ),
-  };
-}
-
-/** Resolve the coverage gate. Owns `coveragePath` and `timeoutMs`. */
 function resolveCoverageGate(userBlock) {
   const defaults = COVERAGE_GATE_DEFAULTS;
   if (userBlock == null || typeof userBlock !== 'object') {
@@ -472,109 +278,39 @@ function resolveCoverageGate(userBlock) {
       userBlock.tolerance,
       toleranceScalar(defaults.tolerance, 0),
     ),
-    timeoutMs:
-      typeof userBlock.timeoutMs === 'number' &&
-      Number.isInteger(userBlock.timeoutMs) &&
-      userBlock.timeoutMs > 0
-        ? userBlock.timeoutMs
-        : defaults.timeoutMs,
+    timeoutMs: defaults.timeoutMs,
   };
 }
 
 /**
- * Framework defaults for `delivery.quality.codingGuardrails`.
- *
- * `miDropMustRefactor` was retired in Story #4531: schema-validated,
- * defaulted, and resolved, but never consumed — the gate it named
- * (`quality-preview.js`'s `computeExitCode`) short-circuits on `miExit`
- * (derived from the already-consumed `gates.maintainability.tolerance`)
- * before this value is ever read. `maintainability.tolerance` is the one
- * documented MI-drop control now; see `lib/migrations/index.js` for the
- * consumer-config migration that strips a leftover key on upgrade.
- *
- * `cyclomaticMustFix` was retired in Story #5313: the cyclomatic ratchet
- * (`check-cyclomatic.js`) keeps a fixed ceiling of 12
- * (`lib/cyclomatic-ceiling.js#CYCLOMATIC_CEILING`), and `cyclomaticFlag` is
- * the one advisory knob left — `quality-preview.js` reports over-flag
- * methods without failing on them.
+ * `cyclomaticFlag` is advisory only (`quality-preview.js`); the ratchet
+ * ceiling lives in `lib/cyclomatic-ceiling.js`.
  */
-export const CODING_GUARDRAILS_DEFAULTS = Object.freeze({
+export const CODING_GUARDRAILS = Object.freeze({
   cyclomaticFlag: 8,
   requireSiblingTest: false,
 });
 
-const CODING_GUARDRAILS_KEYS = new Set(Object.keys(CODING_GUARDRAILS_DEFAULTS));
-
-export function resolveCodingGuardrails(userBlock) {
-  const defaults = CODING_GUARDRAILS_DEFAULTS;
-  if (userBlock == null || typeof userBlock !== 'object') {
-    return { ...defaults };
-  }
-  warnUnknownKeys(
-    userBlock,
-    CODING_GUARDRAILS_KEYS,
-    'quality.codingGuardrails',
-  );
-  return {
-    cyclomaticFlag: userBlock.cyclomaticFlag ?? defaults.cyclomaticFlag,
-    requireSiblingTest:
-      typeof userBlock.requireSiblingTest === 'boolean'
-        ? userBlock.requireSiblingTest
-        : defaults.requireSiblingTest,
-  };
-}
-
-// autoRefresh.miDropCap was retired alongside codingGuardrails.
-// miDropMustRefactor in Story #4531 — same unconsumed-knob shape, same fix.
+/** Only `enabled` is an operator switch. */
 const AUTO_REFRESH_DEFAULTS = Object.freeze({
   enabled: true,
   crapJumpCap: 5,
   scope: 'diff',
 });
 
-const AUTO_REFRESH_KEYS = new Set(Object.keys(AUTO_REFRESH_DEFAULTS));
-
 function resolveAutoRefresh(userBlock) {
-  const defaults = AUTO_REFRESH_DEFAULTS;
-  if (userBlock == null || typeof userBlock !== 'object') {
-    return {
-      enabled: defaults.enabled,
-      crapJumpCap: defaults.crapJumpCap,
-      scope: defaults.scope,
-    };
-  }
-
-  warnUnknownKeys(userBlock, AUTO_REFRESH_KEYS, 'quality.autoRefresh');
-
   return {
+    ...AUTO_REFRESH_DEFAULTS,
     enabled:
-      typeof userBlock.enabled === 'boolean'
+      typeof userBlock?.enabled === 'boolean'
         ? userBlock.enabled
-        : defaults.enabled,
-    crapJumpCap:
-      typeof userBlock.crapJumpCap === 'number' &&
-      Number.isFinite(userBlock.crapJumpCap) &&
-      userBlock.crapJumpCap >= 0
-        ? userBlock.crapJumpCap
-        : defaults.crapJumpCap,
-    scope:
-      userBlock.scope === 'diff' || userBlock.scope === 'full'
-        ? userBlock.scope
-        : defaults.scope,
+        : AUTO_REFRESH_DEFAULTS.enabled,
   };
 }
 
-/**
- * Resolve the merged baselines block. Baselines now live alongside their
- * gates (`gates.<tier>.baselinePath`); this helper preserves the
- * historical flat `baselines.{lint, crap, maintainability}` shape so
- * existing readers (`getBaselines(config)` in `config-resolver.js`)
- * stay untouched. Each entry is synthesised from the resolved gate's
- * `baselinePath`.
- */
+/** Flat `baselines.{crap, maintainability}` view over each gate's `baselinePath`. */
 function resolveBaselinesFromGates(gates) {
   return {
-    lint: { path: gates?.lint?.baselinePath ?? 'baselines/lint.json' },
     crap: {
       path: gates?.crap?.baselinePath ?? CRAP_GATE_DEFAULTS.baselinePath,
     },
@@ -587,26 +323,12 @@ function resolveBaselinesFromGates(gates) {
 }
 
 /**
- * Merge the entire `delivery.quality` block with framework defaults.
- *
- * Returns the historical flattened bag (so the existing call sites that
- * read `q.crap.coveragePath`, `q.maintainability.targetDirs`, etc. keep
- * working) plus the new `gates` resolved object and `gateScoping`.
- *
- * @param {object|undefined} userQuality
- */
-/**
- * Story #2125: merge a consumer-supplied `floors` bag with the framework
- * default for that gate. Defaults supply any workspace key the consumer
- * didn't provide — most commonly the catch-all `'*'`. Consumer entries
- * always win over defaults at the workspace-key level.
+ * Consumer entries win per workspace key. Returns a fresh object so callers
+ * cannot mutate the frozen defaults.
  *
- * Returns a fresh plain object so downstream mutations can't poison the
- * frozen module-level defaults.
- *
- * @param {object | undefined | null} userFloors raw `gates.<kind>.floors`
- * @param {object} defaults frozen framework default (e.g. `DEFAULT_COVERAGE_FLOORS`)
- * @returns {object} merged workspace-keyed floors
+ * @param {object | undefined | null} userFloors
+ * @param {object} defaults
+ * @returns {object}
  */
 function mergeFloorsWithDefaults(userFloors, defaults) {
   const defaultsCopy = {};
@@ -631,21 +353,8 @@ const FLOOR_DEFAULTS_BY_KIND = Object.freeze({
 });
 
 /**
- * Build the resolved `gates` object that `resolveQuality` returns. For
- * each kind the consumer declared that has a framework-default floor
- * (coverage, crap, maintainability), the resolved block carries `floors`
- * merged with the kind's default — so `check-baselines.js` sees the
- * framework default at runtime even when `.agentrc.json` omits the
- * `floors` key.
- *
- * Kinds the consumer did NOT declare are passed through untouched —
- * `check-baselines.js` skips kinds whose gate block is absent, and this
- * function preserves that contract (synthesising a default block here
- * would silently enable gates the consumer never asked for).
- *
- * Other keys on a declared gate block (e.g. `enabled`, `targetDirs`,
- * `baselinePath`) are preserved as the consumer supplied them; this
- * function only injects the floors layer.
+ * Injects default floors into declared gates only; synthesising a block for
+ * an undeclared kind would silently enable a gate the consumer never asked for.
  */
 function resolveGatesWithFloors(gates) {
   const out = { ...gates };
@@ -661,118 +370,53 @@ function resolveGatesWithFloors(gates) {
   return out;
 }
 
+/**
+ * @param {object|undefined} userQuality
+ */
 export function resolveQuality(userQuality) {
   const block =
     userQuality && typeof userQuality === 'object' ? userQuality : {};
   const gates =
     block.gates && typeof block.gates === 'object' ? block.gates : {};
-  const gateScoping = {
-    scope: block.gateScoping?.scope ?? DEFAULT_GATE_SCOPING.scope,
-    diffRef: block.gateScoping?.diffRef ?? DEFAULT_GATE_SCOPING.diffRef,
-  };
   const coverage = resolveCoverageGate(gates.coverage);
   const resolvedGates = resolveGatesWithFloors(gates);
   return {
-    maintainability: resolveMaintainabilityQuality(
-      gates.maintainability,
-      gateScoping,
-    ),
-    crap: resolveMaintainabilityCrap(gates.crap, gateScoping, coverage),
+    maintainability: resolveMaintainabilityQuality(gates.maintainability),
+    crap: resolveMaintainabilityCrap(gates.crap, coverage),
     coverage,
     baselines: resolveBaselinesFromGates(gates),
-    codingGuardrails: resolveCodingGuardrails(block.codingGuardrails),
+    codingGuardrails: { ...CODING_GUARDRAILS },
     autoRefresh: resolveAutoRefresh(block.autoRefresh),
-    baselineEpsilon: resolveBaselineEpsilon(block.baselineEpsilon),
-    // Story #2165 — `delivery.quality.formatAutofix.timeoutMs` for the
-    // close-time `npx biome format --write` spawn.
-    formatAutofix: resolveFormatAutofix(block.formatAutofix),
-    gateScoping,
+    baselineEpsilon: { ...BASELINE_EPSILON },
     gates: resolvedGates,
   };
 }
 
 /**
- * Framework defaults for `delivery.quality.baselineEpsilon` (Story #1964 —
- * s-stability-epsilon). The writer folds sub-epsilon row deltas back to
- * the prior bytes so env variance never rewrites the on-disk baseline.
- *
- * Defaults match the AC: MI 0.5, CRAP 0.5, coverage 0.1, mutation 0.5,
- * lint 0 (counts are integer), lighthouse 1, bundle-size 1024 (bytes),
- * duplication 0.5 (percentage points, Story #3664).
+ * The writer folds sub-epsilon row deltas back to the prior bytes so env
+ * variance never rewrites a baseline. bundle-size is bytes.
  */
-export const BASELINE_EPSILON_DEFAULTS = Object.freeze({
+const BASELINE_EPSILON = Object.freeze({
   maintainability: 0.5,
   crap: 0.5,
   coverage: 0.1,
   mutation: 0.5,
-  lint: 0,
-  lighthouse: 1,
   'bundle-size': 1024,
   duplication: 0.5,
 });
 
-const BASELINE_EPSILON_KINDS = new Set(Object.keys(BASELINE_EPSILON_DEFAULTS));
-
 /**
- * Resolve the merged `delivery.quality.baselineEpsilon` block. Returns a
- * frozen per-kind map keyed by the same kind names used by the per-kind
- * modules. Unknown keys raise a warning. Negative or non-numeric overrides
- * throw an `EXIT_CONFIG`-style error so a misconfigured project halts at
- * startup rather than silently dropping the override.
- *
- * @param {object | undefined} userBlock
- * @returns {{ [kind: string]: number }}
- */
-function assertEpsilonValue(kind, v) {
-  if (typeof v !== 'number' || !Number.isFinite(v) || v < 0) {
-    const err = new Error(
-      `[config] quality.baselineEpsilon.${kind} must be a non-negative finite number (got ${JSON.stringify(v)})`,
-    );
-    err.code = 'EXIT_CONFIG';
-    err.exitCode = 3;
-    throw err;
-  }
-}
-
-export function resolveBaselineEpsilon(userBlock) {
-  if (userBlock == null || typeof userBlock !== 'object') {
-    return { ...BASELINE_EPSILON_DEFAULTS };
-  }
-  warnUnknownKeys(userBlock, BASELINE_EPSILON_KINDS, 'quality.baselineEpsilon');
-  const out = { ...BASELINE_EPSILON_DEFAULTS };
-  for (const kind of BASELINE_EPSILON_KINDS) {
-    if (!Object.hasOwn(userBlock, kind)) continue;
-    assertEpsilonValue(kind, userBlock[kind]);
-    out[kind] = userBlock[kind];
-  }
-  return out;
-}
-
-/**
- * Convenience accessor: resolve a single kind's epsilon from a config
- * (project override or framework default). Returns the framework default
- * when the user block is absent or omits the kind. Throws when the kind
- * is unknown.
- *
  * @param {string} kind
- * @param {object | null | undefined} config full resolved config OR
- *   a `{ delivery: { quality: ... } }` / `{ quality: ... }` shape.
  * @returns {number}
  */
-export function getBaselineEpsilon(kind, config) {
-  if (!BASELINE_EPSILON_KINDS.has(kind)) {
+export function getBaselineEpsilon(kind) {
+  if (!Object.hasOwn(BASELINE_EPSILON, kind)) {
     throw new Error(`[config] getBaselineEpsilon: unknown kind '${kind}'`);
   }
-  const userBlock = config?.delivery?.quality?.baselineEpsilon;
-  const resolved = resolveBaselineEpsilon(userBlock);
-  return resolved[kind];
+  return BASELINE_EPSILON[kind];
 }
 
 /**
- * Read the merged `delivery.quality` block. Accepts the full resolved
- * config — the canonical `delivery.quality` path is the single supported
- * shape.
- *
  * @param {object | null | undefined} config
  * @returns {ReturnType<typeof resolveQuality>}
  */