mandrel 2.55.0 → 2.57.0

package/.agents/scripts/lib/baselines/crap-updater-cli.js

@@ -0,0 +1,223 @@
+/**
+ * lib/baselines/crap-updater-cli.js — the `update-crap-baseline` CLI's own
+ * logic: flag parsing, option defaulting, and the bespoke scorer it hands
+ * `refreshBaseline`.
+ *
+ * Story #5316: all three lived inside `update-crap-baseline.js#main`, which no
+ * test imports. `parseCliArgs` scored CRAP 56, the inlined scorer 72, and
+ * `main` itself 90 — three of the ten methods Story #5311's honest re-anchor
+ * made visible, every one at 0% coverage. They sit here for the same reason
+ * `diff-scope-cli.js` does: a CLI shell is unreachable from a test, and the
+ * import from the CLI is what keeps these off the `dead-exports:production`
+ * ratchet.
+ *
+ * **Why this is NOT the `refresh-service.js` default scorer.** The service
+ * already resolves a `buildDefaultCrapScorer`, and Story #4293 made
+ * `update-maintainability-baseline.js` drop its bespoke scorer in favour of
+ * exactly that. This one cannot follow: it carries `checkResolutionFloor`, a
+ * fail-closed refusal that throws before anything is written when too few
+ * methods resolved a coverage entry — the guard that stops a broken join being
+ * persisted as a sparse baseline (Story #4775). Moving that into the shared
+ * default would change behaviour for `refresh-commit.js` and close-validation,
+ * which resolve the same default. So the scorer stays bespoke, and is tested
+ * here instead.
+ */
+
+import path from 'node:path';
+import { checkResolutionFloor, scanAndScore } from '../crap-utils.js';
+import { Logger } from '../Logger.js';
+import { parseDiffScopeFlag } from './diff-scope-cli.js';
+
+/** Coverage artifact read when neither the flag nor config names one. */
+const DEFAULT_COVERAGE_PATH = 'coverage/coverage-final.json';
+
+/** Resolution-rate floor applied when config does not set one. */
+const DEFAULT_MIN_RESOLUTION_RATE = 0.75;
+
+/**
+ * Parse the updater's argv.
+ *
+ * `--full-scope` and `--diff-scope <ref>` are read here but deliberately NOT
+ * reconciled — {@link resolveCrapUpdaterOptions} owns the refusal, so a caller
+ * cannot get a half-validated shape by calling only this.
+ *
+ * @param {string[]} [argv]
+ * @returns {{baselinePath: string|undefined, coveragePath: string|undefined,
+ *   fullScope: boolean, diffScopeRef: string|null}}
+ */
+export function parseCrapUpdaterArgs(argv = []) {
+  const out = {
+    baselinePath: undefined,
+    coveragePath: undefined,
+    fullScope: false,
+    diffScopeRef: parseDiffScopeFlag(argv),
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    if (argv[i] === '--baseline' && argv[i + 1]) {
+      out.baselinePath = argv[i + 1];
+      i += 1;
+    } else if (argv[i] === '--coverage' && argv[i + 1]) {
+      out.coveragePath = argv[i + 1];
+      i += 1;
+    } else if (argv[i] === '--full-scope') {
+      out.fullScope = true;
+    }
+  }
+  return out;
+}
+
+/**
+ * Fold parsed args over the project's quality config into the one shape the
+ * CLI and the scorer both read.
+ *
+ * Every flag wins over config, and config over the built-in default — the
+ * precedence that used to be a chain of `??` inside `main`, which is most of
+ * why `main` was cyclomatic 9.
+ *
+ * Throws on `--full-scope` together with `--diff-scope`: the two describe
+ * incompatible scopes and silently preferring one would write a baseline the
+ * operator did not ask for.
+ *
+ * @param {{baselinePath?: string, coveragePath?: string, fullScope?: boolean,
+ *   diffScopeRef?: string|null}} args From {@link parseCrapUpdaterArgs}.
+ * @param {{crap?: object, baselines?: object}} sources Resolved config slices:
+ *   `crap` is the quality block, `baselines` the baselines block.
+ * @param {string} [cwd] Root the baseline path is resolved against.
+ * @returns {{targetDirs: string[], ignoreGlobs: string[],
+ *   requireCoverage: boolean, minMethodResolutionRate: number,
+ *   coveragePath: string, baselinePath: string, absBaselinePath: string,
+ *   fullScope: boolean, diffScopeRef: string|null}}
+ */
+export function resolveCrapUpdaterOptions(
+  args = {},
+  { crap = {}, baselines = {} } = {},
+  cwd = process.cwd(),
+) {
+  if (args.fullScope && args.diffScopeRef != null) {
+    throw new Error(
+      '[CRAP] --full-scope is incompatible with --diff-scope; pick one',
+    );
+  }
+  const baselinePath = args.baselinePath ?? baselines?.crap?.path;
+  const coveragePath =
+    args.coveragePath ?? crap.coveragePath ?? DEFAULT_COVERAGE_PATH;
+  return {
+    targetDirs: Array.isArray(crap.targetDirs) ? crap.targetDirs : [],
+    ignoreGlobs: Array.isArray(crap.ignoreGlobs) ? crap.ignoreGlobs : [],
+    requireCoverage: crap.requireCoverage !== false,
+    minMethodResolutionRate:
+      crap.minMethodResolutionRate ?? DEFAULT_MIN_RESOLUTION_RATE,
+    coveragePath,
+    baselinePath,
+    absBaselinePath: path.isAbsolute(baselinePath)
+      ? baselinePath
+      : path.resolve(cwd, baselinePath),
+    fullScope: Boolean(args.fullScope),
+    diffScopeRef: args.diffScopeRef ?? null,
+  };
+}
+
+/**
+ * Report a scan's drop counters. Each earns a line only when it moved, so a
+ * clean scan stays quiet.
+ *
+ * `unscorableFiles` (Story #5311) is the one that must never be silent: a file
+ * the scan could not read, transpile or parse contributes no rows, so without
+ * a line of its own the run reads as a clean scan of a tree with fewer methods
+ * than it has.
+ *
+ * @param {{skippedFilesNoCoverage?: number, skippedMethodsNoCoverage?: number,
+ *   unscorableFiles?: number, resolution?: object}} summary
+ * @param {{info: Function}} [logger]
+ */
+function reportScanSummary(summary, logger = Logger) {
+  const counters = [
+    [
+      summary.skippedFilesNoCoverage,
+      'file(s) skipped without coverage entries.',
+    ],
+    [
+      summary.skippedMethodsNoCoverage,
+      'method(s) skipped — per-method coverage unresolved.',
+    ],
+    [
+      summary.unscorableFiles,
+      'file(s) unscorable (read/transpile/parse failure) — no rows contributed.',
+    ],
+  ];
+  for (const [count, what] of counters) {
+    if (count > 0) logger.info(`[CRAP] ${count} ${what}`);
+  }
+  const r = summary.resolution;
+  if (r) {
+    logger.info(
+      `[CRAP] Method resolution: ${r.resolvedMethods}/${r.joinableMethods} ` +
+        `(${(r.rate * 100).toFixed(1)}%) in files with coverage.`,
+    );
+  }
+}
+
+/**
+ * Build the scorer `refreshBaseline` invokes.
+ *
+ * Fails closed twice, and both refusals are the point of keeping this bespoke:
+ *
+ *   - **No coverage artifact under `requireCoverage`** — every file would be
+ *     skipped, so the scan is abandoned with an operator-facing warning rather
+ *     than returning a confidently empty row set.
+ *   - **Resolution rate below the floor** — `checkResolutionFloor` throws
+ *     BEFORE the service writes anything. A baseline built from a broken join
+ *     is not sparse, it is wrong.
+ *
+ * `loadCoverage` and the logger are named seams so a test drives the whole
+ * scorer without a coverage artifact on disk (`rules/test-seams.md`).
+ *
+ * @param {ReturnType<typeof resolveCrapUpdaterOptions>} options
+ * @param {{loadCoverage: Function, scan?: Function, logger?: object}} deps
+ * @returns {(files: string[], opts: object) => Promise<object[]>}
+ */
+export function buildCrapUpdaterScorer(
+  options,
+  { loadCoverage, scan = scanAndScore, logger = Logger } = {},
+) {
+  return async (files, opts) => {
+    const effectiveCwd = opts?.cwd ?? process.cwd();
+    const coverageAbs = path.isAbsolute(options.coveragePath)
+      ? options.coveragePath
+      : path.resolve(effectiveCwd, options.coveragePath);
+    const coverage = loadCoverage(coverageAbs);
+    if (!coverage && options.requireCoverage) {
+      logger.warn(
+        `[CRAP] ⚠ No coverage artifact at ${options.coveragePath}. All files will be skipped under requireCoverage=true.`,
+      );
+      logger.warn(
+        "[CRAP] ⚠ Run 'npm run test:coverage' before 'npm run crap:update'.",
+      );
+      return [];
+    }
+
+    const summary = await scan({
+      targetDirs: options.targetDirs,
+      coverage,
+      requireCoverage: options.requireCoverage,
+      cwd: effectiveCwd,
+      ignoreGlobs: options.ignoreGlobs,
+      scopeFiles: opts?.fullScope ? null : (files ?? null),
+    });
+
+    logger.info(`[CRAP] Scanned ${summary.scannedFiles} file(s).`);
+    reportScanSummary(summary, logger);
+
+    // Fail closed BEFORE the service persists anything — a thin baseline is
+    // never written and then apologised for.
+    const refusal = checkResolutionFloor(
+      summary.resolution,
+      options.minMethodResolutionRate,
+    );
+    if (refusal) throw new Error(refusal);
+
+    return (summary.rows ?? []).filter(
+      (r) => typeof r?.crap === 'number' && Number.isFinite(r.crap),
+    );
+  };
+}

package/.agents/scripts/lib/bdd-scenario-budget.js

@@ -36,7 +36,9 @@ const BDD_SCENARIOS_BYTE_BUDGET = 24_000;
 /**
  * Truncate a scenario index to a byte budget, deterministically (scan
  * order — file walk order, then in-file order — never re-sorted), and
- * report what was dropped rather than truncating silently.
+ * report what was dropped rather than truncating silently: `truncated` is
+ * `null` when everything fit, else a note naming how many scenarios were
+ * cut (Story #5312).
  *
  * @param {Array<object>} scenarios Full scan output (order preserved).
  * @param {{ byteBudget?: number }} [opts]
@@ -44,7 +46,7 @@ const BDD_SCENARIOS_BYTE_BUDGET = 24_000;
  *   scenarios: Array<object>,
  *   totalScenarios: number,
  *   includedScenarios: number,
- *   truncated: boolean,
+ *   truncated: null | { droppedScenarios: number, note: string },
  * }}
  */
 export function capBddScenarios(scenarios, opts = {}) {
@@ -63,6 +65,22 @@ export function capBddScenarios(scenarios, opts = {}) {
     scenarios: list.slice(0, cut),
     totalScenarios: list.length,
     includedScenarios: cut,
-    truncated: cut < list.length,
+    truncated: describeTruncation(list, cut, byteBudget),
+  };
+}
+
+/**
+ * The `truncated` note: `null` when everything fit, else what was cut.
+ *
+ * @param {Array<object>} list
+ * @param {number} cut
+ * @param {number} byteBudget
+ * @returns {null | { droppedScenarios: number, note: string }}
+ */
+function describeTruncation(list, cut, byteBudget) {
+  if (cut === list.length) return null;
+  return {
+    droppedScenarios: list.length - cut,
+    note: `bddScenarios cut to ${cut} of ${list.length} scenarios to fit the ${byteBudget}-byte envelope budget`,
   };
 }

package/.agents/scripts/lib/bootstrap/quality-bootstrap.js

@@ -86,7 +86,6 @@ export const PRE_COMMIT_MARKER =
 const QUALITY_CONFIG_DEFAULTS = Object.freeze({
   codingGuardrails: Object.freeze({
     cyclomaticFlag: 8,
-    cyclomaticMustFix: 12,
     requireSiblingTest: false,
   }),
   autoRefresh: Object.freeze({

package/.agents/scripts/lib/close-validation/gates.js

@@ -14,6 +14,7 @@ import { getQuality } from '../config/quality.js';
 import { filterFilesUnderTargets } from '../coverage-capture.js';
 import { hasNpmScript, readPackageScripts } from '../npm-scripts.js';
 import { KNOWN_KINDS } from '../orchestration/check-baselines/phases/parse-args.js';
+import { predictsTestEvidenceCredit } from '../test-run-credit.js';
 import {
   buildFormatHint,
   FORMAT_CHECK_FALLBACK,
@@ -415,6 +416,35 @@ function predictsIncrementalCaptureSkip({
   }
 }
 
+/**
+ * Is the `test` gate already credited for this build? Only consulted when
+ * coverage-capture is the active runner; a consumer without one gets the
+ * plain `test` gate regardless (Story #5313).
+ *
+ * @param {{ coverageCaptureActive: boolean } & Parameters<typeof predictsTestEvidenceCredit>[0]} opts
+ * @returns {boolean}
+ */
+function resolveTestCredited({ coverageCaptureActive, ...probe }) {
+  return coverageCaptureActive && predictsTestEvidenceCredit(probe);
+}
+
+/**
+ * Will the `coverage-capture` gate be the one that runs the suite for this
+ * build — so the plain `test` gate is dropped? It is not when it is inactive,
+ * when its incremental skip is pre-decided (Story #5278), or when a green
+ * bare `npm test` already deposited the test credit (Story #5313).
+ *
+ * @param {{ coverageCaptureActive: boolean, captureSkipPredicted: boolean, testCredited: boolean }} opts
+ * @returns {boolean}
+ */
+function coverageCaptureRunsSuite({
+  coverageCaptureActive,
+  captureSkipPredicted,
+  testCredited,
+}) {
+  return coverageCaptureActive && !captureSkipPredicted && !testCredited;
+}
+
 /**
  * The `coverage-capture` gate's argv.
  *
@@ -510,10 +540,25 @@ export function buildDefaultGates({
   presentBaselines,
   log,
   getChangedFilesImpl,
+  storyId,
+  evidenceCwd,
+  gitSpawnImpl,
+  shouldSkipImpl,
 } = {}) {
   const scripts = packageScripts ?? readPackageScripts(cwd);
   const coverageCaptureActive =
     isCrapGateEnabled(config) && hasNpmScript(scripts, 'test:coverage');
+  // Story #5313 — a credited bare `npm test` registers the plain `test` gate
+  // beside the capture so the credit is reported, never re-spent.
+  const testCredited = resolveTestCredited({
+    coverageCaptureActive,
+    storyId,
+    cwd,
+    evidenceCwd,
+    gitSpawnImpl,
+    shouldSkipImpl,
+    log,
+  });
   // Story #5278 — a registered coverage-capture gate that is going to take
   // its own incremental skip is not the test runner for this close, so the
   // plain `test` gate comes back beside it and the capture gate registers as
@@ -563,7 +608,13 @@ export function buildDefaultGates({
     // scoped pair does not shift the close-orchestrator log line, the
     // evidence keyspace, or the parallel-partition membership below.
     { name: 'lint', cmd: lint.cmd, args: lint.args },
-    ...buildTestGateEntry(coverageCaptureActive && !captureSkipPredicted),
+    ...buildTestGateEntry(
+      coverageCaptureRunsSuite({
+        coverageCaptureActive,
+        captureSkipPredicted,
+        testCredited,
+      }),
+    ),
     {
       // Gate name kept generic ("format") so the close-orchestrator log line
       // doesn't shift when a repo swaps biome for Prettier / dprint via

package/.agents/scripts/lib/config/acceptance-eval.js

@@ -1,34 +1,23 @@
 /**
- * Acceptance self-eval accessor (Story #3819).
+ * Acceptance self-eval accessor (Story #3819, Story #5313).
  *
  * Resolves `.agentrc.json → delivery.acceptanceEval` into the canonical
  * shape the per-Story acceptance self-eval loop consumes. The loop scores
  * the caller-injected change set against each inline `acceptance[]` item,
- * redrafts the unmet items, and re-evaluates — capped at `maxRounds` rounds,
- * then escalates to `agent::blocked` when criteria remain unmet.
- *
- * ## The undisableable cap
- *
- * `maxRounds` is operator-tunable, but the cap itself can never be turned
- * off. Two invariants enforce the open-loop token-burn guard:
- *
- *   1. A configured value is clamped into
- *      `[1, ACCEPTANCE_EVAL_MAX_ROUNDS_CEILING]`. `maxRounds: 0` (which
- *      would disable the loop) clamps up to 1; a pathological
- *      `maxRounds: 9999` clamps down to the ceiling.
- *   2. Non-integer / non-finite / missing values fall back to the
- *      documented default. The AJV schema already rejects `maxRounds < 1`
- *      and non-integers before they reach this accessor, but the resolver
- *      stays defensive so unit-test fixtures and degraded configs never
- *      produce an unbounded or zero-round loop.
- *
- * There is intentionally no `enabled` flag — the loop is a hard cutover
- * (always on) per `rules/git-conventions.md` (no parallel old-shape path,
- * no toggle between "loop" and "no loop").
+ * redrafts the unmet items, and re-evaluates — capped at `maxRounds`
+ * redraft rounds, then escalates to `agent::blocked` when criteria remain
+ * unmet.
+ *
+ * Story #5313 dropped the hard ceiling (`ACCEPTANCE_EVAL_MAX_ROUNDS_CEILING`)
+ * and the floor-of-one clamp: `maxRounds` is any non-negative integer, and
+ * `0` means the verdict is scored **once** with no redraft round. The
+ * scoring pass itself is always on — there is intentionally no `enabled`
+ * flag (hard cutover per `rules/git-conventions.md`); only the redraft
+ * budget is tunable.
  */
 
 /**
- * Default redraft-round ceiling applied when `.agentrc.json` omits
+ * Default redraft-round budget applied when `.agentrc.json` omits
  * `delivery.acceptanceEval.maxRounds`. Frozen so downstream callers cannot
  * mutate the resolver's defaults across processes.
  *
@@ -41,55 +30,34 @@ export const ACCEPTANCE_EVAL_DEFAULTS = Object.freeze({
 });
 
 /**
- * Hard, undisableable ceiling on the number of redraft rounds. No
- * configuration can exceed this value — it is the open-loop token-burn
- * guard. A configured `maxRounds` larger than the ceiling is clamped down
- * to it.
- *
- * @type {number}
- */
-export const ACCEPTANCE_EVAL_MAX_ROUNDS_CEILING = 5;
-
-/**
- * Clamp a candidate round count into the inviolable `[1, ceiling]` range.
- * Non-integer / non-finite inputs fall back to the documented default.
+ * Normalize a candidate round count: a non-negative integer is taken as-is
+ * (including `0`); anything else — negative, non-integer, non-finite,
+ * missing — falls back to the documented default.
  *
  * @param {unknown} value
  * @param {number} fallback
  * @returns {number}
  */
-function clampRounds(value, fallback) {
-  const candidate =
-    typeof value === 'number' && Number.isInteger(value) ? value : fallback;
-  if (candidate < 1) return 1;
-  if (candidate > ACCEPTANCE_EVAL_MAX_ROUNDS_CEILING) {
-    return ACCEPTANCE_EVAL_MAX_ROUNDS_CEILING;
-  }
-  return candidate;
+function normalizeRounds(value, fallback) {
+  return typeof value === 'number' && Number.isInteger(value) && value >= 0
+    ? value
+    : fallback;
 }
 
 /**
  * Read the merged acceptance-eval block. Returns the canonical shape:
  *
- *   {
- *     maxRounds: number,  // clamped into [1, ceiling]
- *     ceiling: number     // the undisableable hard cap on rounds
- *   }
- *
- * `maxRounds` is always a positive integer no greater than `ceiling`,
- * regardless of what the resolved config carried.
+ *   { maxRounds: number }  // non-negative integer; 0 = scored once
  *
  * @param {object | null | undefined} config
- * @returns {{ maxRounds: number, ceiling: number }}
+ * @returns {{ maxRounds: number }}
  */
 export function getAcceptanceEval(config) {
   const user = config?.delivery?.acceptanceEval ?? {};
-  const maxRounds = clampRounds(
-    user.maxRounds,
-    ACCEPTANCE_EVAL_DEFAULTS.maxRounds,
-  );
   return {
-    maxRounds,
-    ceiling: ACCEPTANCE_EVAL_MAX_ROUNDS_CEILING,
+    maxRounds: normalizeRounds(
+      user.maxRounds,
+      ACCEPTANCE_EVAL_DEFAULTS.maxRounds,
+    ),
   };
 }

package/.agents/scripts/lib/config/delivery-routing.js

@@ -1,10 +1,14 @@
 /**
  * `delivery.routing` accessor + framework defaults — Epic #4478 (M7-B), the
- * role-scoped-boot-context flip and the maker-checker sampling floor.
+ * role-scoped-boot-context flip and the ceremony profile.
  *
  * Stage 6 dropped `delivery.routing.singleDelivery` (the v1 epic
- * single-vs-fan-out kill-switch). v2 has one Story delivery path; routing
- * here is only about spawn boot context and critic sampling.
+ * single-vs-fan-out kill-switch). Story #5313 dropped
+ * `delivery.routing.freshCriticSampleRate` (the maker-checker sampling
+ * floor): the standard profile now routes purely off the derived change
+ * level — high or underivable → fresh critic, low → inline self-eval. v2 has
+ * one Story delivery path; routing here is only about spawn boot context and
+ * the ceremony profile.
  *
  * `delivery.routing.roleScopedAgents` is the **kill-switch for the role-scoped
  * boot contexts** (Epic #4478, M7-B). It defaults to `true`: a converted spawn
@@ -17,22 +21,11 @@
  * `.claude/agents/`. Flipping it off never drops a gate: the fallback is the
  * full-closure agent that ran before M7-B.
  *
- * `delivery.routing.freshCriticSampleRate` is the **maker-checker sampling
- * floor** (Epic #4478, M7-B, Part 2). Ceremony routing sends the acceptance
- * clusters of a change set that touches no sensitive path down the
- * contract-identical *inline* critic path, but a fraction of them are still
- * forced through a *fresh-context* critic so a low derived level never degrades
- * to zero independent checking. The rate is clamped into `[0, 1]`; `0` disables
- * the floor (pure level routing), `1` forces every cluster fresh. The default is
- * `0.2`. See `resolveCeremonyForRisk` in
- * `lib/orchestration/ceremony-routing.js`.
- *
  * Framework-defaults pattern mirrors `lib/config/ci.js#getCiDelivery`.
  */
 
 export const DELIVERY_ROUTING_DEFAULTS = Object.freeze({
   roleScopedAgents: true,
-  freshCriticSampleRate: 0.2,
   /** @type {'minimal'|'standard'|'strict'} */
   ceremonyProfile: 'standard',
   /**
@@ -43,23 +36,6 @@ export const DELIVERY_ROUTING_DEFAULTS = Object.freeze({
   closeAndLand: true,
 });
 
-/**
- * Clamp a candidate sample rate into `[0, 1]`. Non-finite / non-number inputs
- * fall back to the framework default so a degraded config never yields a
- * NaN-driven or out-of-range floor.
- *
- * @param {unknown} value
- * @returns {number}
- */
-function clampSampleRate(value) {
-  if (typeof value !== 'number' || !Number.isFinite(value)) {
-    return DELIVERY_ROUTING_DEFAULTS.freshCriticSampleRate;
-  }
-  if (value < 0) return 0;
-  if (value > 1) return 1;
-  return value;
-}
-
 /**
  * Normalize ceremony profile; unknown values → `standard`.
  *
@@ -82,7 +58,6 @@ function normalizeCeremonyProfile(value) {
  * @param {object | null | undefined} config
  * @returns {{
  *   roleScopedAgents: boolean,
- *   freshCriticSampleRate: number,
  *   ceremonyProfile: 'minimal'|'standard'|'strict',
  *   closeAndLand: boolean,
  * }}
@@ -94,7 +69,6 @@ export function getDeliveryRouting(config) {
       typeof routing.roleScopedAgents === 'boolean'
         ? routing.roleScopedAgents
         : DELIVERY_ROUTING_DEFAULTS.roleScopedAgents,
-    freshCriticSampleRate: clampSampleRate(routing.freshCriticSampleRate),
     ceremonyProfile: normalizeCeremonyProfile(routing.ceremonyProfile),
     closeAndLand:
       typeof routing.closeAndLand === 'boolean'

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

@@ -112,20 +112,6 @@ const KEY_MEANINGS = Object.freeze({
     'Allowlist of events that fire a webhook notification.',
 
   // planning.*
-  'planning.riskHeuristics':
-    'Phrases that flag a Story as high-risk for HITL escalation.',
-  'planning.failOnSharedEditors':
-    'Whether shared-editor conflict findings are promoted to hard errors.',
-  'planning.requireExplicitCrossStoryDeps':
-    'Whether implicit cross-Story dependencies are promoted to hard errors.',
-  'planning.failOnRegistryConflicts':
-    'Whether cross-cutting registry conflict findings are promoted to hard errors.',
-  'planning.failOnLargeFanOut':
-    'Whether large fan-out findings are promoted to hard errors.',
-  'planning.largeFanOutThreshold':
-    'Story count above which a plan is flagged as a large fan-out.',
-  'planning.crossCuttingRegistries':
-    'Glob patterns naming cross-cutting registry files the planner conflict-checks.',
   'planning.navigation.routeGlobs':
     'Glob patterns marking paths that add a user-facing route (plan-time reachability gate).',
   'planning.navigation.navRegistry':
@@ -168,14 +154,10 @@ const KEY_MEANINGS = Object.freeze({
     'Ordered provider chain the code-review phase consults.',
   'delivery.codeReview.maxFixAttempts':
     'Maximum auto-fix attempts the code-review phase makes.',
-  'delivery.codeReview.maxFixScopeFiles':
-    'Maximum files an auto-fix may touch in one attempt.',
   'delivery.codeReview.autoFixSeverity':
     'Severity threshold for on-branch code-review remediation (medium fixes 🔴/🟠/🟡, high fixes 🔴/🟠 only; default medium).',
   'delivery.routing.roleScopedAgents':
     'Whether delivery spawns boot on role-scoped .claude/agents/<role>.md contexts.',
-  'delivery.routing.freshCriticSampleRate':
-    'Fraction of low-risk acceptance clusters forced through a fresh-context critic (maker-checker floor).',
   'delivery.routing.ceremonyProfile':
     'Acceptance-ceremony depth: minimal (always inline), standard (derived-level routed), or strict (always fresh).',
   'delivery.routing.closeAndLand':
@@ -231,7 +213,6 @@ const PREFIX_MEANINGS = Object.freeze([
     'Tolerance epsilon applied when comparing a quality baseline.',
   ],
   ['delivery.quality', 'Delivery-time quality configuration.'],
-  ['delivery.signals', 'Threshold for a delivery friction/telemetry signal.'],
   ['delivery.mergeWatch', 'Merge-wait poll cadence and wall-clock budget.'],
   [
     'delivery.feedbackLoop',