mandrel 1.69.0 → 1.71.0

package/.agents/scripts/generate-config-docs.js

@@ -141,6 +141,92 @@ function resolveNode(schema, node) {
   return { node, refName: null };
 }
 
+/**
+ * Render the "Type" cell for an `array`-typed node by inspecting its `items`
+ * schema. Mirrors the original inline ladder exactly: a `$ref` item renders
+ * `array<RefName>`, an enum item renders `array<enum>`, a typed item renders
+ * `array<type>`, and anything else collapses to a bare `array`.
+ *
+ * @param {object} flat Flattened array node.
+ * @returns {string}
+ */
+function renderArrayType(flat) {
+  const items = flat.items;
+  if (items && typeof items === 'object') {
+    if (items.$ref) {
+      const refName = items.$ref.startsWith('#/$defs/')
+        ? items.$ref.slice('#/$defs/'.length)
+        : items.$ref;
+      return `\`array<${refName}>\``;
+    }
+    if (Array.isArray(items.enum)) {
+      return `\`array<enum>\``;
+    }
+    if (typeof items.type === 'string') {
+      return `\`array<${items.type}>\``;
+    }
+  }
+  return '`array`';
+}
+
+/**
+ * Render the "Type" cell for an `object`-typed node — `object<map>` when it
+ * carries an `additionalProperties` schema (the map form), `object`
+ * otherwise.
+ *
+ * @param {object} flat Flattened object node.
+ * @returns {string}
+ */
+function renderObjectType(flat) {
+  if (
+    flat.additionalProperties &&
+    typeof flat.additionalProperties === 'object'
+  ) {
+    return '`object<map>`';
+  }
+  return '`object`';
+}
+
+/**
+ * Ordered dispatch table for the "Type" cell. Each rule pairs a `when(flat)`
+ * predicate with a `render(flat)` producer; {@link renderType} walks the
+ * table once and returns the first match, so a new schema shape becomes a new
+ * row here rather than another nested branch.
+ *
+ * Order is load-bearing — `oneOf` and `enum` are matched before the plain
+ * `type` rules, exactly as the original ladder short-circuited.
+ *
+ * @type {Array<{ when: (flat: object) => boolean, render: (flat: object) => string }>}
+ */
+const TYPE_RULES = [
+  // The only oneOf in the schema is `listOrExtenderOfStrings`.
+  {
+    when: (flat) => Array.isArray(flat.oneOf),
+    render: () => '`string[]` or `{ append?, prepend? }`',
+  },
+  {
+    when: (flat) => Array.isArray(flat.enum),
+    render: (flat) =>
+      flat.enum.map((v) => `\`${JSON.stringify(v)}\``).join(' \\| '),
+  },
+  {
+    when: (flat) => Array.isArray(flat.type),
+    render: (flat) => flat.type.map((t) => `\`${t}\``).join(' \\| '),
+  },
+  {
+    when: (flat) => flat.type === 'array',
+    render: renderArrayType,
+  },
+  {
+    when: (flat) => flat.type === 'object',
+    render: renderObjectType,
+  },
+  {
+    when: (flat) => typeof flat.type === 'string',
+    render: (flat) => `\`${flat.type}\``,
+  },
+];
+
 /**
  * Render the "Type" cell for a schema node. The agentrc schema uses a few
  * recurring shapes — string, integer, number, boolean, array, object,
@@ -155,51 +241,8 @@ function resolveNode(schema, node) {
 function renderType(schema, node) {
   if (!node || typeof node !== 'object') return '?';
   const flat = flattenAllOf(schema, node);
-
-  if (Array.isArray(flat.oneOf)) {
-    // The only oneOf in the schema is `listOrExtenderOfStrings`.
-    return '`string[]` or `{ append?, prepend? }`';
-  }
-
-  if (Array.isArray(flat.enum)) {
-    return flat.enum.map((v) => `\`${JSON.stringify(v)}\``).join(' \\| ');
-  }
-
-  const type = flat.type;
-  if (Array.isArray(type)) {
-    return type.map((t) => `\`${t}\``).join(' \\| ');
-  }
-  if (typeof type === 'string') {
-    if (type === 'array') {
-      const items = flat.items;
-      if (items && typeof items === 'object') {
-        if (items.$ref) {
-          const refName = items.$ref.startsWith('#/$defs/')
-            ? items.$ref.slice('#/$defs/'.length)
-            : items.$ref;
-          return `\`array<${refName}>\``;
-        }
-        if (Array.isArray(items.enum)) {
-          return `\`array<enum>\``;
-        }
-        if (typeof items.type === 'string') {
-          return `\`array<${items.type}>\``;
-        }
-      }
-      return '`array`';
-    }
-    if (type === 'object') {
-      if (
-        flat.additionalProperties &&
-        typeof flat.additionalProperties === 'object'
-      ) {
-        return '`object<map>`';
-      }
-      return '`object`';
-    }
-    return `\`${type}\``;
-  }
-  return '?';
+  const rule = TYPE_RULES.find((r) => r.when(flat));
+  return rule ? rule.render(flat) : '?';
 }
 
 /**
@@ -233,6 +276,94 @@ function escapeCell(text) {
   return String(text).replace(/\r?\n/g, ' ').replace(/\|/g, '\\|');
 }
 
+/**
+ * Emit the rows for a nested-object property: a header row carrying the
+ * parent's description followed by the recursively-flattened child rows.
+ * Returns `null` when `flat` is not a properties-bearing object, so the
+ * caller can fall through to the next row shape.
+ *
+ * @param {object} schema
+ * @param {{flat: object, keyPath: string, pathParts: string[], propName: string, isRequired: boolean, description: string}} ctx
+ * @returns {Array<object> | null}
+ */
+function nestedObjectRows(schema, ctx) {
+  const { flat, keyPath, pathParts, propName, isRequired, description } = ctx;
+  if (flat.type !== 'object' || !flat.properties) return null;
+  const childRequired = new Set(
+    Array.isArray(flat.required) ? flat.required : [],
+  );
+  return [
+    {
+      key: keyPath,
+      required: isRequired ? 'Yes' : 'No',
+      type: '`object`',
+      def: renderDefault(flat.default),
+      description: description || 'Nested configuration block.',
+    },
+    ...flattenObject(schema, flat, [...pathParts, propName], childRequired),
+  ];
+}
+
+/**
+ * Emit the single `[]`-suffixed row for an array-of-objects property,
+ * describing the item shape in the Description cell. Returns `null` when the
+ * property is not an array whose items are a properties-bearing object.
+ *
+ * @param {object} schema
+ * @param {{flat: object, keyPath: string, isRequired: boolean, description: string}} ctx
+ * @returns {Array<object> | null}
+ */
+function arrayOfObjectsRows(schema, ctx) {
+  const { flat, keyPath, isRequired, description } = ctx;
+  if (flat.type !== 'array' || !flat.items) return null;
+  const { node: itemNode, refName } = resolveNode(schema, flat.items);
+  if (!itemNode || itemNode.type !== 'object' || !itemNode.properties) {
+    return null;
+  }
+  const itemKeys = Object.keys(itemNode.properties).join(', ');
+  const suffix = refName ? ` (\`${refName}\`)` : '';
+  const desc =
+    (description ? `${description} ` : '') +
+    `Each item${suffix} has: ${itemKeys}.`;
+  return [
+    {
+      key: `${keyPath}[]`,
+      required: isRequired ? 'Yes' : 'No',
+      type: renderType(schema, flat),
+      def: renderDefault(flat.default),
+      description: desc,
+    },
+  ];
+}
+
+/**
+ * Emit the leaf (scalar / non-recursed) row for a property. Always matches —
+ * it is the fallthrough shape when neither the nested-object nor the
+ * array-of-objects builder applied.
+ *
+ * @param {object} schema
+ * @param {{flat: object, keyPath: string, isRequired: boolean, description: string}} ctx
+ * @returns {Array<object>}
+ */
+function leafRow(schema, ctx) {
+  const { flat, keyPath, isRequired, description } = ctx;
+  return [
+    {
+      key: keyPath,
+      required: isRequired ? 'Yes' : 'No',
+      type: renderType(schema, flat),
+      def: renderDefault(flat.default),
+      description: description || '—',
+    },
+  ];
+}
+
+// Ordered row-shape builders for one property. The loop in flattenObject
+// returns the first builder that yields rows (non-null), matching the
+// original if/continue ladder: nested-object first, array-of-objects next,
+// scalar leaf as the always-matching fallthrough.
+const ROW_BUILDERS = [nestedObjectRows, arrayOfObjectsRows, leafRow];
+
 /**
  * Flatten one object-typed schema node into table rows. Recurses into
  * nested `object` properties (resolving `$ref`s along the way) so dot-paths
@@ -260,57 +391,21 @@ function flattenObject(schema, node, pathParts, required) {
   for (const [propName, rawChild] of Object.entries(properties)) {
     const { node: child } = resolveNode(schema, rawChild);
     const flat = flattenAllOf(schema, child);
-    const keyPath = [...pathParts, propName].join('.');
-    const isRequired = required.has(propName) || localRequired.has(propName);
-    const description = flat.description || rawChild.description || '';
-
-    // Nested object: recurse to surface dot-pathed children.
-    if (flat.type === 'object' && flat.properties) {
-      // Emit a header row for the parent object so its description is
-      // visible, then recurse.
-      rows.push({
-        key: keyPath,
-        required: isRequired ? 'Yes' : 'No',
-        type: '`object`',
-        def: renderDefault(flat.default),
-        description: description || 'Nested configuration block.',
-      });
-      const childRequired = new Set(
-        Array.isArray(flat.required) ? flat.required : [],
-      );
-      rows.push(
-        ...flattenObject(schema, flat, [...pathParts, propName], childRequired),
-      );
-      continue;
-    }
-
-    // Array-of-objects: emit one row and describe the item shape.
-    if (flat.type === 'array' && flat.items) {
-      const { node: itemNode, refName } = resolveNode(schema, flat.items);
-      if (itemNode && itemNode.type === 'object' && itemNode.properties) {
-        const itemKeys = Object.keys(itemNode.properties).join(', ');
-        const suffix = refName ? ` (\`${refName}\`)` : '';
-        const desc =
-          (description ? `${description} ` : '') +
-          `Each item${suffix} has: ${itemKeys}.`;
-        rows.push({
-          key: `${keyPath}[]`,
-          required: isRequired ? 'Yes' : 'No',
-          type: renderType(schema, flat),
-          def: renderDefault(flat.default),
-          description: desc,
-        });
-        continue;
+    const ctx = {
+      flat,
+      keyPath: [...pathParts, propName].join('.'),
+      pathParts,
+      propName,
+      isRequired: required.has(propName) || localRequired.has(propName),
+      description: flat.description || rawChild.description || '',
+    };
+    for (const build of ROW_BUILDERS) {
+      const built = build(schema, ctx);
+      if (built !== null) {
+        rows.push(...built);
+        break;
       }
     }
-
-    rows.push({
-      key: keyPath,
-      required: isRequired ? 'Yes' : 'No',
-      type: renderType(schema, flat),
-      def: renderDefault(flat.default),
-      description: description || '—',
-    });
   }
 
   return rows;

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

@@ -17,8 +17,6 @@
 
 import { groupRows, resolveComponents } from '../baselines/components.js';
 
-const SEVERITIES = Object.freeze(['critical', 'high', 'medium', 'low']);
-
 /**
  * Pure: count findings into a {critical,high,medium,low} histogram. Findings
  * with severities outside that set are ignored, keeping the rendered summary
@@ -37,8 +35,6 @@ export function aggregateSummary(findings) {
   return summary;
 }
 
-export const KNOWN_SEVERITIES = SEVERITIES;
-
 /**
  * Resolve the per-component rollup map for an envelope. When the envelope
  * already carries a `rollup` block (every writer-produced baseline does), we

package/.agents/scripts/lib/audit-to-stories/audit-lenses.js

@@ -0,0 +1,99 @@
+/**
+ * lib/audit-to-stories/audit-lenses.js — SSOT for the canonical audit lens
+ * taxonomy.
+ *
+ * The `/audit-<lens>` workflows each emit a report named
+ * `audit-<lens>-results.md`. The `audit::<lens>` GitHub label set is keyed off
+ * exactly these lens names — never off a finding's fine-grained `dimension`
+ * text. `build-story-body.js` derives a group's `audit::<lens>` labels from
+ * each finding's `sourceReport` basename via {@link lensFromSourceReport}, and
+ * `audit-labels-bootstrap.js` creates one `audit::<lens>` label per entry in
+ * {@link AUDIT_LENSES}. Centralising the list here keeps the label producer
+ * (bootstrap) and the label deriver (story-body) from drifting apart.
+ *
+ * Pure: no I/O.
+ *
+ * @see Story #4195 — junk `audit::<dimension>` label derivation.
+ */
+
+/**
+ * The canonical lens names, one per `/audit-<lens>` workflow under
+ * `.agents/workflows/` (excluding the `audit-to-stories` and `audit-fan-out`
+ * meta-workflows, which produce no `audit-<lens>-results.md` of their own).
+ * Adding a new `audit-*` workflow MUST add its lens name here.
+ *
+ * @type {ReadonlyArray<string>}
+ */
+export const AUDIT_LENSES = Object.freeze([
+  'architecture',
+  'clean-code',
+  'dependencies',
+  'devops',
+  'documentation',
+  'lighthouse',
+  'navigability',
+  'performance',
+  'privacy',
+  'quality',
+  'security',
+  'seo',
+  'sre',
+  'ux-ui',
+]);
+
+/** O(1) membership set for {@link isCanonicalLens}. */
+const LENS_SET = new Set(AUDIT_LENSES);
+
+/**
+ * @param {string} lens
+ * @returns {boolean} true when `lens` is one of the canonical {@link AUDIT_LENSES}.
+ */
+export function isCanonicalLens(lens) {
+  return LENS_SET.has(lens);
+}
+
+/**
+ * Derive the canonical lens name from an `audit-<lens>-results.md` source
+ * report path. The derivation is basename-only (the directory — typically
+ * `temp/audits/` — is irrelevant) and matches the exact
+ * `audit-<lens>-results.md` shape the audit workflows emit. Backslash and
+ * forward-slash separators are both handled so a Windows-authored path
+ * resolves identically.
+ *
+ * Returns `null` when the path does not match the expected shape or the
+ * extracted lens is not one of the canonical {@link AUDIT_LENSES} — callers
+ * drop a `null` so a stray report name can never mint a junk `audit::*` label.
+ *
+ * @param {unknown} sourceReport — e.g. `temp/audits/audit-clean-code-results.md`.
+ * @returns {string|null} the canonical lens (`clean-code`) or `null`.
+ */
+export function lensFromSourceReport(sourceReport) {
+  if (typeof sourceReport !== 'string' || sourceReport.length === 0) {
+    return null;
+  }
+  const normalised = sourceReport.replace(/\\/g, '/');
+  const base = normalised.slice(normalised.lastIndexOf('/') + 1);
+  const match = base.match(/^audit-(.+)-results\.md$/);
+  if (!match) return null;
+  const lens = match[1];
+  return isCanonicalLens(lens) ? lens : null;
+}
+
+/**
+ * Derive the deduped, sorted set of canonical `audit::<lens>` labels for a
+ * collection of findings, keyed off each finding's `sourceReport` basename.
+ * Findings whose `sourceReport` does not resolve to a canonical lens
+ * contribute no label (never a junk one). Multi-lens groups (findings from
+ * more than one report) yield one label per distinct lens.
+ *
+ * @param {Array<{ sourceReport?: unknown }>} findings
+ * @returns {string[]} sorted `audit::<lens>` labels.
+ */
+export function auditLabelsForFindings(findings) {
+  const lenses = new Set();
+  for (const finding of findings ?? []) {
+    const lens = lensFromSourceReport(finding?.sourceReport);
+    if (lens) lenses.add(lens);
+  }
+  return [...lenses].sort().map((lens) => `audit::${lens}`);
+}

package/.agents/scripts/lib/audit-to-stories/build-story-body.js

@@ -6,8 +6,10 @@
  * criteria #8: Title (caller), Summary, Acceptance Criteria, Agent
  * Prompts, Context block, fingerprint footer.
  *
- * Pure: returns { title, body, labels }. Labels include every
- * `audit::<dimension>` represented in the merge plus the standard
+ * Pure: returns { title, body, labels }. Labels carry one canonical
+ * `audit::<lens>` per distinct source report represented in the merge
+ * (derived from each finding's `sourceReport` basename, NEVER from the
+ * fine-grained `dimension` text — see Story #4195), plus the standard
  * `type::story`, `agent::ready`, and (when any finding is Critical)
  * `risk::high`.
  *
@@ -19,6 +21,7 @@
  */
 
 import { serialize } from '../story-body/story-body.js';
+import { auditLabelsForFindings } from './audit-lenses.js';
 import { renderFingerprintFooter } from './finding-adapter.js';
 
 const STATIC_LABELS = Object.freeze(['type::story', 'agent::ready']);
@@ -71,9 +74,14 @@ function contextLinksFromGroup(group) {
 }
 
 function labelsForGroup(group) {
-  const auditLabels = uniq(
-    (group.dimensions ?? []).map((d) => `audit::${d.replace(/\s+/g, '-')}`),
-  );
+  // Derive `audit::<lens>` from each finding's `sourceReport` basename
+  // (`audit-<lens>-results.md` → `audit::<lens>`), NOT from the finding's
+  // fine-grained `dimension` text. The dimension is free-form prose
+  // ("stale-description", "dry", "efficiency (cpu)") and minting
+  // `audit::<dimension>` from it produced non-existent labels; only the 14
+  // canonical lens labels are valid. Multi-lens groups carry one label per
+  // distinct source report. See Story #4195.
+  const auditLabels = auditLabelsForFindings(group.findings ?? []);
   const labels = [...STATIC_LABELS, ...auditLabels];
   const hasCritical = (group.findings ?? []).some(
     (f) => f.severity === 'critical',

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

@@ -20,6 +20,7 @@ import {
   resolveEscomplexVersion,
   resolveTsTranspilerVersion,
   scanAndScore,
+  scanAndScoreCombined,
 } from './crap-utils.js';
 import { ensureEpicBranchRef as defaultEnsureEpicBranchRef } from './git-branch-lifecycle.js';
 import { calculateAll, scanDirectory } from './maintainability-utils.js';
@@ -562,6 +563,126 @@ function crapDirsMatchMi({
   );
 }
 
+/**
+ * Config-only sibling of `crapDirsMatchMi` (Story #4192): decide — before any
+ * tree scan — whether the MI and CRAP passes target the same dirs with the
+ * same ignore globs. When true, `regenerateMainFromTree` collapses the two
+ * escomplex passes into a single combined `analyzeOnce` scan; when false it
+ * falls back to the independent two-pass path. Pure array compare, no scan
+ * list required.
+ */
+function crapConfigMatchesMi({
+  crapTargetDirs,
+  crapIgnoreGlobs,
+  miTargetDirs,
+  miIgnoreGlobs,
+}) {
+  return (
+    crapTargetDirs.length === miTargetDirs.length &&
+    crapTargetDirs.every((d, i) => d === miTargetDirs[i]) &&
+    crapIgnoreGlobs.length === miIgnoreGlobs.length &&
+    crapIgnoreGlobs.every((g, i) => g === miIgnoreGlobs[i])
+  );
+}
+
+/**
+ * Run the combined MI + CRAP single-pass scan once and project it into the
+ * `{ calculateAllFn, scanDirectoryFn, scanAndScoreFn, loadCoverageFn }`
+ * injection seams that `regenerateMaintainability` / `regenerateCrap` already
+ * consume. Returns `null` when the combined path is NOT eligible (either
+ * baseline unconfigured, dirs/globs differ, or coverage is required but
+ * missing) — the caller then falls back to the two independent passes.
+ *
+ * Eligibility deliberately requires coverage to be present under
+ * `requireCoverage`: when coverage is missing, the two-pass path takes a
+ * dedicated `no-coverage` short-circuit for CRAP (no scan at all), and
+ * reproducing that precise envelope is cleaner by deferring to the existing
+ * `regenerateCrap` branch than by routing through the combined scanner.
+ *
+ * Story #4192 — collapses the duplicate escomplex AST parse on the full-tree
+ * baseline path (2 parses/file → 1 parse/file). Byte-for-byte equivalent to
+ * the two-pass path: the combined scan returns the same MI score map and the
+ * same CRAP rows the separate passes would, and the downstream projection +
+ * writer logic is shared verbatim.
+ *
+ * @returns {Promise<null | {
+ *   calculateAllFn: () => Promise<Record<string, number>>,
+ *   scanDirectoryFn: (dir: string, list: string[]) => string[],
+ *   scanAndScoreFn: () => Promise<{ rows: Array<object> }>,
+ *   loadCoverageFn: () => object,
+ * }>}
+ */
+async function buildCombinedScanSeams({
+  cwd,
+  baselines,
+  quality,
+  loadCoverageFn,
+  scanAndScoreCombinedFn,
+}) {
+  const miPath = baselines?.maintainability?.path;
+  const crapPath = baselines?.crap?.path;
+  if (
+    typeof miPath !== 'string' ||
+    miPath.length === 0 ||
+    typeof crapPath !== 'string' ||
+    crapPath.length === 0
+  ) {
+    return null; // both baselines must be configured to combine
+  }
+
+  const miTargetDirs = quality?.maintainability?.targetDirs ?? [];
+  const miIgnoreGlobs = quality?.maintainability?.ignoreGlobs ?? [];
+  const crapCfg = quality?.crap ?? {};
+  const crapTargetDirs = Array.isArray(crapCfg.targetDirs)
+    ? crapCfg.targetDirs
+    : [];
+  const crapIgnoreGlobs = Array.isArray(crapCfg.ignoreGlobs)
+    ? crapCfg.ignoreGlobs
+    : [];
+
+  if (
+    !crapConfigMatchesMi({
+      crapTargetDirs,
+      crapIgnoreGlobs,
+      miTargetDirs,
+      miIgnoreGlobs,
+    })
+  ) {
+    return null; // dirs/globs differ → two-pass fallback
+  }
+
+  const requireCoverage = crapCfg.requireCoverage !== false;
+  const coveragePath = crapCfg.coveragePath ?? 'coverage/coverage-final.json';
+  const coverageAbs = path.isAbsolute(coveragePath)
+    ? coveragePath
+    : path.resolve(cwd, coveragePath);
+  const coverage = loadCoverageFn(coverageAbs);
+
+  if (!coverage && requireCoverage) {
+    return null; // no coverage → let the two-pass CRAP short-circuit run
+  }
+
+  const { miScores, crap } = await scanAndScoreCombinedFn({
+    targetDirs: miTargetDirs,
+    coverage,
+    requireCoverage,
+    cwd,
+    ignoreGlobs: miIgnoreGlobs,
+  });
+
+  return {
+    // MI consumes the precomputed score map directly; the scanDirectory seam
+    // is short-circuited to a no-op list (the combined scan already walked
+    // the tree), so regenerateMaintainability's projection runs unchanged.
+    calculateAllFn: async () => miScores,
+    scanDirectoryFn: (_dir, list = []) => list,
+    // CRAP consumes the precomputed scan result; coverage is already loaded
+    // so its loadCoverage seam returns the same object without re-reading.
+    scanAndScoreFn: async () => crap,
+    loadCoverageFn: () => coverage,
+  };
+}
+
 /**
  * Regenerate the CRAP baseline from a fresh tree scan + coverage map.
  * Returns `null` when no CRAP baseline path is configured. Story #4075 —
@@ -675,6 +796,7 @@ export async function regenerateMainFromTree({
   scanDirectoryFn = scanDirectory,
   calculateAllFn = calculateAll,
   scanAndScoreFn = scanAndScore,
+  scanAndScoreCombinedFn = scanAndScoreCombined,
   loadCoverageFn = loadCoverage,
   resolveEscomplexVersionFn = resolveEscomplexVersion,
   resolveTsTranspilerVersionFn = resolveTsTranspilerVersion,
@@ -689,12 +811,49 @@ export async function regenerateMainFromTree({
   const files = [];
   let didChange = false;
 
+  // Story #4192 — when MI and CRAP target the same dirs/globs (and coverage
+  // is present), collapse the two escomplex passes into a single combined
+  // `analyzeOnce` scan. The combined scan is projected into the same scan
+  // seams the two passes consume, so the MI/CRAP envelope projection + writer
+  // logic below runs byte-for-byte identically either way. When the combined
+  // path is not eligible, `combined` is `null` and the original two
+  // independent passes run.
+  //
+  // The combined path is an internal optimization of the *production-default*
+  // scan seams. A caller that injects its own `calculateAllFn` or
+  // `scanAndScoreFn` is explicitly opting into the two independent passes
+  // (the DI contract: "use my seam"), so the combined path defers to those
+  // injected seams rather than silently bypassing them. In production neither
+  // seam is overridden, so the optimization is always taken.
+  const usingDefaultScanSeams =
+    calculateAllFn === calculateAll && scanAndScoreFn === scanAndScore;
+  const combined = usingDefaultScanSeams
+    ? await buildCombinedScanSeams({
+        cwd,
+        baselines,
+        quality,
+        loadCoverageFn,
+        scanAndScoreCombinedFn,
+      })
+    : null;
+
+  const miCalculateAllFn = combined ? combined.calculateAllFn : calculateAllFn;
+  const miScanDirectoryFn = combined
+    ? combined.scanDirectoryFn
+    : scanDirectoryFn;
+  const crapScanAndScoreFn = combined
+    ? combined.scanAndScoreFn
+    : scanAndScoreFn;
+  const crapLoadCoverageFn = combined
+    ? combined.loadCoverageFn
+    : loadCoverageFn;
+
   const miScan = await regenerateMaintainability({
     cwd,
     baselines,
     quality,
-    scanDirectoryFn,
-    calculateAllFn,
+    scanDirectoryFn: miScanDirectoryFn,
+    calculateAllFn: miCalculateAllFn,
     writeFn,
     writeFileFn,
     loadPriorFn,
@@ -711,8 +870,8 @@ export async function regenerateMainFromTree({
     quality,
     logger,
     miScan,
-    scanAndScoreFn,
-    loadCoverageFn,
+    scanAndScoreFn: crapScanAndScoreFn,
+    loadCoverageFn: crapLoadCoverageFn,
     resolveEscomplexVersionFn,
     resolveTsTranspilerVersionFn,
     writeFn,

package/.agents/scripts/lib/baselines/refresh-service.js

@@ -739,7 +739,3 @@ function validateOptions({ kind, scopeFiles, fullScope, writePath }) {
     );
   }
 }
-
-// Exposed for the lint/test invariant (Task #2208) so the guard can list
-// every kind the service is contracted to dispatch without re-deriving it.
-export const REFRESH_SERVICE_SUPPORTED_KINDS = SUPPORTED_KINDS;

package/.agents/scripts/lib/bootstrap/ci-workflow-template.js

@@ -180,7 +180,7 @@ export const CI_WORKFLOW_RELATIVE_PATH = '.github/workflows/ci.yml';
  * `unchanged`. When the file is absent the action is `created`. When the
  * file exists with operator-authored differences the helper preserves it
  * and returns `custom-workflow-skip` along with the rendered body so the
- * bootstrap caller (or `/agents-update`) can offer a side-by-side diff.
+ * bootstrap caller (or `/mandrel-update`) can offer a side-by-side diff.
  *
  * Network-free; safe to invoke under tests with a tmp `projectRoot`.
  *