mandrel 2.16.0 → 2.18.0

package/.agents/scripts/lib/baselines/drift-detector.js

@@ -0,0 +1,351 @@
+// .agents/scripts/lib/baselines/drift-detector.js
+/**
+ * drift-detector.js — full-scope baseline drift detection (Story #4776).
+ *
+ * Every enforcement site for the maintainability and CRAP baselines is
+ * **diff-scoped**: close-validation, the pre-push hook and CI all compare
+ * the files a branch touched against their committed rows. That is the
+ * right per-PR trade — full-scope scoring on every push would be far too
+ * expensive — but it has a structural blind spot. A file that is never
+ * modified after its baseline row is written is never re-scored, so a
+ * regression introduced *indirectly* (a dependency getting more complex, a
+ * test deletion moving coverage underneath it) is invisible for as long as
+ * nobody happens to touch that file.
+ *
+ * This module closes that hole with the check that is too expensive to run
+ * per-PR and cheap enough to run on a schedule: re-score every target
+ * directory in full, and report every row whose current score has moved
+ * away from its baseline by more than the gate's tolerance — **in either
+ * direction**. Drift, not regression: a row that silently improved is
+ * equally strong evidence that the committed baseline no longer describes
+ * the tree, and leaving it stale means the ratchet is anchored to a number
+ * that no longer exists.
+ *
+ * Re-scoring routes through `refresh-service.resolveDefaultScorer` — the
+ * same scorer that writes the baseline — so the detector cannot report two
+ * implementations disagreeing with each other as drift in the tree.
+ *
+ * Pure-ish: the scorer and the baseline loader are both injectable, and the
+ * module never writes anything, exits, or emits friction.
+ *
+ * The public surface is deliberately the three symbols the CLI actually
+ * uses — `DRIFT_KINDS`, `detectBaselineDrift`, `formatDriftReport`. Every
+ * internal helper below stays module-local and is exercised through them
+ * (`detectBaselineDrift` forwards its `loadBaselineRows` / `scoreFullScope`
+ * seams straight down). Exporting the helpers so tests could reach them
+ * directly would ship five entry points nothing in production reaches —
+ * exactly the orphaning this Story exists to stop.
+ */
+
+import { getQuality } from '../config/quality.js';
+import { resolveConfig } from '../config-resolver.js';
+import { getKindModule } from './kernel.js';
+import { load as loadBaseline } from './reader.js';
+import { resolveDefaultScorer } from './refresh-service.js';
+
+/** The kinds whose rows carry a per-file/per-method score worth re-scoring. */
+export const DRIFT_KINDS = Object.freeze(['maintainability', 'crap']);
+
+/**
+ * Per-kind identity, metric axis, and refresh remedy. `identity` must match
+ * the granularity the kind's baseline rows are keyed at, or unchanged rows
+ * masquerade as added/removed pairs.
+ */
+const KIND_SPECS = Object.freeze({
+  maintainability: Object.freeze({
+    metric: 'mi',
+    identity: (row) => row.path,
+    label: (row) => row.path,
+    refreshCommand: 'npm run maintainability:update -- --full-scope',
+    defaultTolerance: 0.5,
+  }),
+  crap: Object.freeze({
+    metric: 'crap',
+    identity: (row) => `${row.path}::${row.method}@${row.startLine}`,
+    label: (row) => `${row.path}::${row.method} (line ${row.startLine})`,
+    refreshCommand: 'npm run crap:update -- --full-scope',
+    defaultTolerance: 0.001,
+  }),
+});
+
+/**
+ * Resolve the absolute drift tolerance for a kind: an explicit override
+ * wins, then the gate's configured `tolerance.value`, then the per-kind
+ * default.
+ *
+ * @param {string} kind
+ * @param {object|undefined} gate resolved `delivery.quality.gates.<kind>`
+ * @param {number|null|undefined} override
+ * @returns {number}
+ */
+function resolveTolerance(kind, gate, override) {
+  if (typeof override === 'number' && Number.isFinite(override)) {
+    return Math.abs(override);
+  }
+  const configured = gate?.tolerance;
+  if (configured?.kind === 'absolute') {
+    const value = Number(configured.value);
+    if (Number.isFinite(value)) return Math.abs(value);
+  }
+  return KIND_SPECS[kind].defaultTolerance;
+}
+
+/**
+ * Normalise a scorer's raw rows into the kind's canonical on-disk row
+ * shape, so scored rows and baseline rows are directly comparable. The
+ * per-kind `projectRow` is the same projection the writer applies, which is
+ * what makes the two sides comparable at all (it also reconciles the CRAP
+ * scorer's `file` key with the envelope's `path`).
+ *
+ * @param {string} kind
+ * @param {Array<object>} rows
+ * @returns {Array<object>}
+ */
+function projectScoredRows(kind, rows) {
+  const mod = getKindModule(kind);
+  const out = [];
+  for (const row of rows ?? []) {
+    try {
+      out.push(mod.projectRow(row));
+    } catch {
+      // A row the writer itself would refuse is not evidence of drift.
+    }
+  }
+  return out;
+}
+
+/**
+ * Diff two row sets by the kind's identity, classifying each key as
+ * drifted / added / removed. Pure.
+ *
+ * @param {{ kind: string, baselineRows: Array<object>, currentRows: Array<object>, tolerance: number }} opts
+ * @returns {{ drifted: Array<object>, added: Array<object>, removed: Array<object> }}
+ */
+function diffRows({ kind, baselineRows, currentRows, tolerance }) {
+  const spec = KIND_SPECS[kind];
+  const baseByKey = new Map();
+  for (const row of baselineRows ?? []) baseByKey.set(spec.identity(row), row);
+
+  const drifted = [];
+  const added = [];
+  const seen = new Set();
+
+  for (const row of currentRows ?? []) {
+    const key = spec.identity(row);
+    seen.add(key);
+    const base = baseByKey.get(key);
+    if (!base) {
+      added.push({ key, label: spec.label(row), current: row[spec.metric] });
+      continue;
+    }
+    const before = Number(base[spec.metric] ?? 0);
+    const after = Number(row[spec.metric] ?? 0);
+    const delta = after - before;
+    if (Math.abs(delta) <= tolerance) continue;
+    drifted.push({
+      key,
+      label: spec.label(row),
+      baseline: before,
+      current: after,
+      delta,
+    });
+  }
+
+  const removed = [];
+  for (const [key, row] of baseByKey) {
+    if (seen.has(key)) continue;
+    removed.push({ key, label: spec.label(row), baseline: row[spec.metric] });
+  }
+
+  return { drifted, added, removed };
+}
+
+/**
+ * Re-score one kind full-scope and diff the result against its committed
+ * baseline.
+ *
+ * Returns `{ ok: true, skipped: '<reason>' }` when the kind cannot be
+ * checked (gate disabled, no baseline on disk, no scorer registered, the
+ * scorer produced nothing) — an unscorable kind is not drift, and a
+ * scheduled job must not go red because coverage happened to be absent.
+ *
+ * @param {{
+ *   kind: string,
+ *   cwd?: string,
+ *   quality?: object,
+ *   tolerance?: number|null,
+ *   loadBaselineRows?: (kind: string, cwd: string) => Array<object>|null,
+ *   scoreFullScope?: (kind: string, cwd: string) => Promise<Array<object>|null>|Array<object>|null,
+ * }} opts
+ * @returns {Promise<object>}
+ */
+async function detectKindDrift({
+  kind,
+  cwd = process.cwd(),
+  quality,
+  tolerance = null,
+  loadBaselineRows = defaultLoadBaselineRows,
+  scoreFullScope = defaultScoreFullScope,
+}) {
+  if (!Object.hasOwn(KIND_SPECS, kind)) {
+    throw new Error(
+      `[drift] unknown kind "${kind}"; expected one of ${DRIFT_KINDS.join(', ')}`,
+    );
+  }
+  const gate = quality?.[kind];
+  const spec = KIND_SPECS[kind];
+  const base = { kind, refreshCommand: spec.refreshCommand };
+  if (gate?.enabled === false) {
+    return { ...base, ok: true, skipped: 'gate-disabled' };
+  }
+
+  const baselineRows = loadBaselineRows(kind, cwd);
+  if (!Array.isArray(baselineRows) || baselineRows.length === 0) {
+    return { ...base, ok: true, skipped: 'no-baseline' };
+  }
+
+  const raw = await scoreFullScope(kind, cwd);
+  if (raw === null || raw === undefined) {
+    return { ...base, ok: true, skipped: 'no-scorer' };
+  }
+  const currentRows = projectScoredRows(kind, raw);
+  if (currentRows.length === 0) {
+    return { ...base, ok: true, skipped: 'no-scored-rows' };
+  }
+
+  const resolvedTolerance = resolveTolerance(kind, gate, tolerance);
+  const { drifted, added, removed } = diffRows({
+    kind,
+    baselineRows,
+    currentRows,
+    tolerance: resolvedTolerance,
+  });
+
+  return {
+    ...base,
+    ok: drifted.length === 0,
+    tolerance: resolvedTolerance,
+    scanned: currentRows.length,
+    baselineRows: baselineRows.length,
+    drifted,
+    added,
+    removed,
+  };
+}
+
+/**
+ * Run the drift check across several kinds.
+ *
+ * @param {{ kinds?: string[], cwd?: string, tolerance?: number|null, quality?: object }} opts
+ * @returns {Promise<{ ok: boolean, results: Array<object> }>}
+ */
+export async function detectBaselineDrift({
+  kinds = DRIFT_KINDS,
+  cwd = process.cwd(),
+  tolerance = null,
+  quality,
+  ...seams
+} = {}) {
+  let resolvedQuality = quality;
+  if (!resolvedQuality) {
+    try {
+      resolvedQuality = getQuality(resolveConfig({ cwd })) ?? {};
+    } catch {
+      resolvedQuality = {};
+    }
+  }
+  const results = [];
+  for (const kind of kinds) {
+    results.push(
+      await detectKindDrift({
+        kind,
+        cwd,
+        tolerance,
+        quality: resolvedQuality,
+        ...seams,
+      }),
+    );
+  }
+  return { ok: results.every((r) => r.ok), results };
+}
+
+/**
+ * Default baseline loader — reads and schema-validates the committed
+ * envelope. Returns `null` when it cannot be read, which the caller maps to
+ * the `no-baseline` skip.
+ */
+function defaultLoadBaselineRows(kind, cwd) {
+  try {
+    return loadBaseline(kind, { cwd }).rows;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Default full-scope scorer — the same scorer `refreshBaseline` uses, run
+ * with `fullScope: true` so it walks every configured target directory
+ * rather than a diff-derived file list.
+ */
+async function defaultScoreFullScope(kind, cwd) {
+  const scorer = resolveDefaultScorer(kind, { cwd });
+  if (typeof scorer !== 'function') return null;
+  return await scorer(null, { fullScope: true, cwd });
+}
+
+/**
+ * Render one kind's result as an operator-facing block: a per-row
+ * before/after table plus the refresh remedy. Returns a string always —
+ * a clean kind reports one line so a scheduled job's log shows it ran.
+ *
+ * @param {object} result
+ * @returns {string}
+ */
+function formatKindDrift(result) {
+  if (result.skipped) {
+    return `[drift] ⏭ ${result.kind}: skipped (${result.skipped})`;
+  }
+  if (result.ok) {
+    return `[drift] ✓ ${result.kind}: ${result.scanned} row(s) re-scored full-scope, no drift beyond ±${result.tolerance}`;
+  }
+  const width = Math.max(
+    12,
+    ...result.drifted.map((d) => String(d.label).length),
+  );
+  const lines = [
+    `[drift] ✖ ${result.kind}: ${result.drifted.length} row(s) drifted beyond ±${result.tolerance} (${result.scanned} re-scored, ${result.baselineRows} in baseline)`,
+    `  ${'ROW'.padEnd(width)}  ${'BASELINE'.padStart(10)}  ${'CURRENT'.padStart(10)}  ${'DELTA'.padStart(10)}`,
+  ];
+  for (const d of result.drifted) {
+    lines.push(
+      `  ${String(d.label).padEnd(width)}  ${d.baseline.toFixed(2).padStart(10)}  ${d.current
+        .toFixed(2)
+        .padStart(
+          10,
+        )}  ${(d.delta > 0 ? `+${d.delta.toFixed(2)}` : d.delta.toFixed(2)).padStart(10)}`,
+    );
+  }
+  if (result.added.length > 0 || result.removed.length > 0) {
+    lines.push(
+      `  (${result.added.length} row(s) absent from baseline, ${result.removed.length} baseline row(s) absent from the tree)`,
+    );
+  }
+  lines.push(
+    `  Remedy: run \`${result.refreshCommand}\` and commit the refreshed baseline with a \`baseline-refresh:\` tagged subject (non-empty body).`,
+  );
+  return lines.join('\n');
+}
+
+/**
+ * Render the whole run.
+ *
+ * @param {{ ok: boolean, results: Array<object> }} run
+ * @returns {string}
+ */
+export function formatDriftReport(run) {
+  const body = run.results.map(formatKindDrift).join('\n');
+  const tail = run.ok
+    ? '[drift] ✅ No baseline drift detected.'
+    : '[drift] ❌ Baseline drift detected — the committed baselines no longer describe the tree.';
+  return `${body}\n${tail}`;
+}

package/.agents/scripts/lib/baselines/envelope.js

@@ -133,6 +133,7 @@ function resolveGeneratedAt(explicit) {
  *   rows: Array<object>,
  *   kernelVersion: string,
  *   generatedAt?: string,
+ *   extras?: Record<string, unknown>,
  * }} params
  * @returns {{
  *   $schema: string,
@@ -148,6 +149,7 @@ export function buildEnvelope({
   rows,
   kernelVersion,
   generatedAt,
+  extras,
 } = {}) {
   if (typeof kind !== 'string' || !KNOWN_KINDS.includes(kind)) {
     throw new TypeError(
@@ -176,10 +178,15 @@ export function buildEnvelope({
     throw new TypeError('envelope.buildEnvelope: rows must be an array');
   }
 
+  // Per-kind envelope-level stamps (Story #4775). A kind whose SCORING
+  // SEMANTICS can change independently of its kernel version contributes them
+  // here; `assertEnvelope` still validates the result against the kind's
+  // schema, so an unrecognised extra fails closed rather than being persisted.
   return {
     $schema: schemaRefFor(kind),
     kernelVersion,
     generatedAt: resolveGeneratedAt(generatedAt),
+    ...(extras && typeof extras === 'object' ? extras : {}),
     rollup,
     rows,
   };

package/.agents/scripts/lib/baselines/kernel.js

@@ -50,7 +50,9 @@ import {
 } from './kinds/coverage.js';
 import {
   applyEpsilon as crapApplyEpsilon,
+  assertBaselineCompatible as crapAssertBaselineCompatible,
   compare as crapCompare,
+  envelopeExtras as crapEnvelopeExtras,
   kernelVersion as crapKernelVersion,
   keyField as crapKeyField,
   mergeRows as crapMergeRows,
@@ -139,6 +141,12 @@ function bindKindModule(members) {
     compare: members.compare,
     applyEpsilon: members.applyEpsilon,
     mergeRows: members.mergeRows,
+    // Optional per-kind hooks (Story #4775). `envelopeExtras` contributes
+    // envelope-level stamps the shared writer would not otherwise know about;
+    // `assertBaselineCompatible` lets a kind refuse a loaded baseline whose
+    // scoring semantics predate the running scorer.
+    envelopeExtras: members.envelopeExtras,
+    assertBaselineCompatible: members.assertBaselineCompatible,
   });
 }
 
@@ -179,6 +187,8 @@ const KIND_MODULES = Object.freeze({
     compare: crapCompare,
     applyEpsilon: crapApplyEpsilon,
     mergeRows: crapMergeRows,
+    envelopeExtras: crapEnvelopeExtras,
+    assertBaselineCompatible: crapAssertBaselineCompatible,
   }),
   maintainability: bindKindModule({
     name: maintainabilityName,
@@ -270,6 +280,27 @@ export function currentKernelVersion(kind) {
   return getKindModule(kind).kernelVersion();
 }
 
+/**
+ * Ask a kind whether a loaded baseline is compatible with the running
+ * scorer's SEMANTICS — a dimension `kernelVersion` cannot express, because a
+ * kind's scoring can change while the upstream package it stamps does not
+ * (Story #4775). Kinds without the hook always answer "compatible".
+ *
+ * @param {string} kind
+ * @param {object|null} baseline
+ * @returns {string|null} Operator-facing message, or null when compatible.
+ */
+export function checkBaselineSemantics(kind, baseline) {
+  let mod;
+  try {
+    mod = getKindModule(kind);
+  } catch {
+    return null;
+  }
+  if (typeof mod.assertBaselineCompatible !== 'function') return null;
+  return mod.assertBaselineCompatible(baseline);
+}
+
 /**
  * Compare a baseline's stamped version against the currently running
  * kernel for the same kind. Returns `{ match, current }` so callers can

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

@@ -75,6 +75,41 @@ export function kernelVersion() {
   return '0.0.0';
 }
 
+/**
+ * Scoring-semantics stamp (Story #4775, fix part 5).
+ *
+ * `kernelVersion()` above tracks the `typhonjs-escomplex` package and
+ * `escomplexVersion` tracks the same dependency — so a change in how THIS
+ * repo joins escomplex methods to istanbul coverage moves neither. Rows
+ * scored by the pre-#4775 join (exact transpiled-line equality, methods
+ * dropped when unresolved) are not comparable to rows scored by the join
+ * that replaced it (original-source coordinates, containment matching,
+ * honest `requireCoverage: false`): the same method can carry a different
+ * `crap`, a different `startLine`, or exist in one baseline and not the
+ * other. Comparing across that boundary produces phantom regressions and,
+ * worse, phantom passes.
+ *
+ * The stamp makes the boundary explicit and fails closed. Bump it whenever
+ * the coverage join, the line coordinate system, or the unresolved-method
+ * policy changes.
+ *
+ * Deliberately module-local: `envelopeExtras()` is the single production door
+ * to this value, so exporting the bare constant would add a second entry
+ * point that nothing in production reaches. Callers and tests that need the
+ * string read it off `envelopeExtras().scoringSemantics`.
+ */
+const SCORING_SEMANTICS = 'coverage-join-v2';
+
+/**
+ * Envelope-level stamps this kind contributes beyond the shared envelope
+ * keys. Consumed by `writer.write` via the kind-module protocol.
+ *
+ * @returns {{scoringSemantics: string}}
+ */
+export function envelopeExtras() {
+  return { scoringSemantics: SCORING_SEMANTICS };
+}
+
 export function projectRow(row) {
   return {
     path: canonicalise(row.path ?? row.file),
@@ -372,6 +407,23 @@ export const CRAP_COMPAT_AXES = [
         : null,
   },
   kernelDriftAxis('CRAP'),
+  {
+    name: 'scoring-semantics-drift',
+    severity: 'fatal',
+    check: ({ baseline }) => {
+      if (!baseline) return null;
+      const stamped = baseline.scoringSemantics ?? null;
+      if (stamped === SCORING_SEMANTICS) return null;
+      return (
+        `[CRAP] scoring semantics changed: baseline=${stamped ?? '<unstamped>'} ` +
+        `running=${SCORING_SEMANTICS}. Rows scored by the previous per-method ` +
+        'coverage join are not comparable to rows scored by the current one, ' +
+        'so this baseline cannot be compared — it must be re-derived. Run ' +
+        "'npm run test:coverage' then 'npm run crap:update -- --full-scope' " +
+        "and commit the result with a 'baseline-refresh:' subject."
+      );
+    },
+  },
   {
     name: 'ts-transpiler-drift',
     severity: 'warn',
@@ -401,6 +453,30 @@ export function evaluateBaselineCompatibility(ctx) {
   return reduceCompatAxes(CRAP_COMPAT_AXES, ctx);
 }
 
+/**
+ * Kind-module hook (Story #4775): the subset of the compat table that a
+ * *loaded* v2 envelope can be judged against on its own, with no running
+ * dependency versions to compare. The unified `check-baselines` gate calls it
+ * straight after `reader.load` and turns a message into a fail-closed
+ * schema-class error, so a baseline written by the previous scoring semantics
+ * can never be silently compared against new-semantics scores.
+ *
+ * The version-drift axes stay out: the v2 envelope does not carry
+ * `escomplexVersion` / `tsTranspilerVersion`, and running those checks against
+ * an absent field would compare `undefined` to `undefined` and pass
+ * vacuously — worse than not running them.
+ *
+ * @param {object|null} baseline A loaded v2 baseline envelope.
+ * @returns {string|null} Operator-facing message, or null when compatible.
+ */
+export function assertBaselineCompatible(baseline) {
+  if (!baseline) return null;
+  const axis = CRAP_COMPAT_AXES.find(
+    (a) => a.name === 'scoring-semantics-drift',
+  );
+  return axis ? axis.check({ baseline }) : null;
+}
+
 /**
  * Pure helper: resolve the CRAP baseline either from the working tree
  * (via `getCrapBaseline`) or, when `epicRef` is supplied, from

package/.agents/scripts/lib/baselines/reader.js

@@ -18,7 +18,8 @@
 //      hand-edited while inside a story worktree — so downstream
 //      consumers see canonical repo-relative paths.
 //   5. Returns the envelope's headline fields plus rows/rollup as a
-//      narrow contract: `{ rollup, rows, kernelVersion, generatedAt }`.
+//      narrow contract: `{ rollup, rows, kernelVersion, generatedAt,
+//      scoringSemantics }`.
 //
 // Reader-only: the writer side lives in a sibling module (Story #1891).
 // No I/O happens here beyond reading the JSON file itself.
@@ -215,6 +216,11 @@ function readAndShape(kind, absolutePath) {
     rows,
     kernelVersion: parsed.kernelVersion,
     generatedAt: parsed.generatedAt,
+    // Story #4775 — carry the per-kind scoring-semantics stamp through the
+    // narrowing. The gate's compat check reads it off the LOADED envelope, so
+    // dropping it here would make every baseline look unstamped and fail the
+    // whole repo closed on a stamp that is actually present on disk.
+    scoringSemantics: parsed.scoringSemantics,
   };
 }
 
@@ -303,6 +309,11 @@ export function loadFile(absolutePath, opts = {}) {
     rows,
     kernelVersion: parsed.kernelVersion,
     generatedAt: parsed.generatedAt,
+    // Story #4775 — carry the per-kind scoring-semantics stamp through the
+    // narrowing. The gate's compat check reads it off the LOADED envelope, so
+    // dropping it here would make every baseline look unstamped and fail the
+    // whole repo closed on a stamp that is actually present on disk.
+    scoringSemantics: parsed.scoringSemantics,
   };
 }
 

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

@@ -355,11 +355,17 @@ const KIND_SCORER_BUILDERS = Object.freeze({
  * rather than crashing the refresh. The production crap/maintainability paths
  * never rely on this fallback — they inject an explicit, configured scorer.
  *
+ * Exported since Story #4776 so the full-scope drift detector
+ * (`check-baseline-drift.js`) re-scores through the *same* scorer that
+ * writes the baseline. A drift check scoring by a second, parallel
+ * implementation would report the two implementations' disagreement as
+ * drift, which is exactly the false signal it exists to rule out.
+ *
  * @param {string} kind
  * @param {{ cwd: string }} opts
  * @returns {((files: string[], opts: object) => Promise<object[]> | object[]) | undefined}
  */
-function resolveDefaultScorer(kind, { cwd } = {}) {
+export function resolveDefaultScorer(kind, { cwd } = {}) {
   const builder = KIND_SCORER_BUILDERS[kind];
   if (typeof builder !== 'function') return undefined;
   const effectiveCwd = cwd ?? process.cwd();

package/.agents/scripts/lib/baselines/writer.js

@@ -184,6 +184,8 @@ export function write({
     rollup,
     kernelVersion: kernelVersion ?? currentKernelVersion(kind),
     generatedAt,
+    extras:
+      typeof mod.envelopeExtras === 'function' ? mod.envelopeExtras() : null,
   });
   assertEnvelope(envelope);
   return envelope;
@@ -258,10 +260,18 @@ export function writeFile(absPath, envelope, opts = {}) {
   // Canonical key order on the top-level envelope keeps diffs stable
   // across runs and platforms. Per-kind row keys retain their natural
   // declaration order; the row sort is done by `sortRows()`.
+  //
+  // Story #4775: the projection is deliberately explicit, so any per-kind
+  // envelope stamp (`scoringSemantics`) must be carried through by name or it
+  // is silently dropped on the way to disk — the stamp would then be present
+  // in memory, validated, and absent from the file it exists to protect.
   const canonical = {
     $schema: envelope.$schema,
     kernelVersion: envelope.kernelVersion,
     generatedAt: envelope.generatedAt,
+    ...(envelope.scoringSemantics === undefined
+      ? {}
+      : { scoringSemantics: envelope.scoringSemantics }),
     rollup: envelope.rollup,
     rows: envelope.rows,
   };