driftproof 0.10.1 → 0.11.0

package/lib/diff.js

@@ -1,16 +1,18 @@
 // SPDX-License-Identifier: Apache-2.0
 'use strict';
 
-const { bandVerdict, round } = require('./stats');
+const { bandVerdict, round, WITHIN_NOISE } = require('./stats');
 const { EFFECT_FLOOR } = require('../config');
 const { revisionHeadline } = require('./revision');
 const { baselineReproduces, REFUSAL_REASONS, bandOf } = require('./reuse');
+const { caseRule, armOf, drawsLine, UNDERPOWERED_LINE } = require('./verdict');
 
 // Practical-significance gate applied ON TOP of band separation. bandVerdict()
 // stays a pure geometry test (kept that way so its unit checks are unambiguous);
 // this wrapper additionally requires |delta| >= EFFECT_FLOOR before a verdict is
-// claimed. A separated-but-trivial move (below the judge's quantization floor)
-// becomes "within noise (below effect floor)".
+// claimed. A separated but trivial move (below the judge's quantization floor)
+// gets the verdict value WITHIN_NOISE_FLOOR, which the table labels "below effect
+// floor".
 const WITHIN_NOISE_FLOOR = 'within noise (below effect floor)';
 function verdictWithFloor(before, after, delta) {
   const raw = bandVerdict(before.mean, before.stddev, after.mean, after.stddev);
@@ -19,17 +21,18 @@ function verdictWithFloor(before, after, delta) {
   }
   return raw;
 }
-function isWithinNoise(v) { return v === 'within noise' || v === WITHIN_NOISE_FLOOR; }
+function isWithinNoise(v) { return v === WITHIN_NOISE || v === WITHIN_NOISE_FLOOR; }
 
 // Build a drift report (markdown) between two receipts.
 //
-// CREDIBILITY CORE — the anti-false-positive rule: a per-case regression (or
-// improvement) is claimed ONLY when (1) the two confidence bands do NOT overlap
-// AND (2) the mean moved by at least EFFECT_FLOOR (practical-significance floor,
-// see config.js). When the bands overlap OR the move is below the floor, the
-// change is reported as "within noise" and is NOT counted as a regression. A tool
-// that cries wolf is worse than useless, so band separation PLUS a real-sized
-// delta — not either alone — is what triggers a verdict.
+// CREDIBILITY CORE, the anti-false-positive rule: a per-case regression (or
+// improvement) is claimed ONLY when (1) the two bands, each the mean plus or
+// minus one sample standard deviation, do NOT overlap AND (2) the mean moved by at
+// least EFFECT_FLOOR (practical-significance floor, see config.js). When the
+// bands overlap OR the move is below the floor, no separation is detected at the
+// sample size used, and the case is NOT counted as a regression. A tool that cries
+// wolf is worse than useless, so band separation PLUS a real-sized delta, not
+// either alone, is what triggers a verdict.
 
 // Map case-id → { mean, stddev } for a receipt's with_skill cases. Falls back to
 // score/0 for v0.1 receipts that have no per-case band.
@@ -124,14 +127,21 @@ function judgeDiffers(a, b, ids, aB, bB) {
 // It deliberately does NOT run a separate band test on the aggregate mean: the
 // aggregate band is suite dispersion, and a separate test there would either cry
 // wolf (if too tight) or mask real per-case drift (if too wide).
+//
+// THE WORDING (spec 031 A-031-20). A band is a descriptive spread, the mean plus or
+// minus one sample standard deviation. A separation is stated as detected under
+// the rule, never as proof that the skill moved; no separation is stated as none
+// detected at this sample size, never as evidence that nothing changed. The
+// leading word is the label; the verdict values it summarises are unchanged.
 function headlineVerdict(perCase) {
   const reg = perCase.filter((r) => r.verdict === 'regression').length;
   const imp = perCase.filter((r) => r.verdict === 'improvement').length;
   const s = (n) => (n === 1 ? '' : 's');
-  if (reg && imp) return `MIXED — ${reg} case regression${s(reg)} and ${imp} improvement${s(imp)} on non-overlapping bands.`;
-  if (reg) return `DRIFT — ${reg} case${s(reg)} regressed (bands do not overlap); the skill is measurably weaker on ${reg} case${s(reg)}.`;
-  if (imp) return `IMPROVED — ${imp} case${s(imp)} improved (bands do not overlap); none regressed.`;
-  return 'WITHIN NOISE — no case moved beyond its confidence band; the skill holds up.';
+  const rule = 'bands do not overlap and the move clears the effect floor';
+  if (reg && imp) return `MIXED: separation detected under the rule on ${reg} case${s(reg)} downward and ${imp} case${s(imp)} upward (${rule}).`;
+  if (reg) return `DRIFT: separation detected under the rule on ${reg} case${s(reg)}, downward (${rule}); none upward.`;
+  if (imp) return `IMPROVED: separation detected under the rule on ${imp} case${s(imp)}, upward (${rule}); none downward.`;
+  return 'NO SEPARATION DETECTED: no case separated under the rule at this sample size (band = mean \u00b1 1 sd); this is not evidence that nothing changed.';
 }
 
 // A revision pair is a pair in which the SKILL TEXT is the only thing that
@@ -189,6 +199,15 @@ function buildDriftReport(a, b, { labelA = 'A', labelB = 'B', mode = 'release' }
   // untested input does: no delta is asserted, and the reason travels with it.
   const measured = belowTested.length === 0 && !refusal && incompleteSides.length === 0 && !judgeProblem;
 
+  // THE UNDERPOWERED STATE RIDES BESIDE THE VERDICT VALUE (spec 035 R-6). The value
+  // is unchanged, because Reports 006 to 008 and spec 009's gate compare against it
+  // and a published record quotes the lines it produced. `power` says, for a case
+  // the rule did not separate, whether the two with_skill arms' own spreads and
+  // draws could have resolved a shift of the effect floor, by the rule lib/verdict.js
+  // applies to a single receipt.
+  const rawWith = (r) => new Map(r.results.cases.filter((c) => c.mode === 'with_skill').map((c) => [c.id, c]));
+  const aRaw = rawWith(a);
+  const bRaw = rawWith(b);
   const perCase = ids.map((id) => {
     const before = aB[id] || null;
     const after = bB[id] || null;
@@ -196,10 +215,16 @@ function buildDriftReport(a, b, { labelA = 'A', labelB = 'B', mode = 'release' }
     const verdict = refusal ? 'refused'
       : !measured ? 'not measured'
       : (before && after) ? verdictWithFloor(before, after, delta) : 'n/a';
-    return { id, before, after, delta, verdict };
+    let power = null;
+    if (measured && before && after && (verdict === WITHIN_NOISE || verdict === WITHIN_NOISE_FLOOR)) {
+      const ra = armOf(aRaw.get(id)); const rb = armOf(bRaw.get(id));
+      const rule = ra && rb ? caseRule(ra, rb) : null;
+      if (rule && rule.state === 'underpowered') power = { state: 'underpowered', drawsNeeded: rule.drawsNeeded, reason: rule.reason, ...(rule.spread !== undefined ? { spread: rule.spread } : {}) };
+    }
+    return { id, before, after, delta, verdict, power };
   });
   // Sort worst-first: regressions, then by delta.
-  const order = { regression: 0, 'within noise': 1, [WITHIN_NOISE_FLOOR]: 1, improvement: 2, 'n/a': 3, 'not measured': 3, refused: 3 };
+  const order = { regression: 0, [WITHIN_NOISE]: 1, [WITHIN_NOISE_FLOOR]: 1, improvement: 2, 'n/a': 3, 'not measured': 3, refused: 3 };
   perCase.sort((x, y) => (order[x.verdict] - order[y.verdict]) || ((x.delta || 0) - (y.delta || 0)));
 
   const aAgg = aggWithBand(a);
@@ -310,10 +335,33 @@ function buildDriftReport(a, b, { labelA = 'A', labelB = 'B', mode = 'release' }
   // carries a source. A legend explains markers on the page; if `bandStr` emits
   // none, the legend is describing something the reader cannot see. Asked of
   // `bandStr` itself rather than recomputed, so the two cannot disagree.
-  const anyLabelRendered = [...Object.values(aB), ...Object.values(bB)]
-    .some((x) => x && /\([a-z]+\)\s*$/.test(bandStr(x)));
-  if (anyLabelRendered) {
-    warnings.push('band provenance: `(generation)` is an ACROSS-DRAW spread — receipt spec v0.5, n generation draws per arm. `(legacy)` is a JUDGE-SAMPLE spread over a single generation, which is what v0.4 and earlier recorded. They are different statistics. The comparison is the only one the older receipt admits, and it is not like for like.');
+  //
+  // THE LEGEND DESCRIBES ONLY THE SOURCES ON THE PAGE, AND THE PAIR IS CALLED
+  // NOT LIKE FOR LIKE ONLY WHEN IT IS NOT (spec 031 AC-6). This used to print one
+  // sentence whenever any label rendered, naming both sources and saying the
+  // comparison was the only one an older receipt admits and was not like for
+  // like. Every v0.4 and v0.5 band carries a label, so two v0.5 receipts with
+  // `generation` bands on both sides were told they were not like for like, and
+  // shown a `(legacy)` source neither carried. The sources are read per receipt,
+  // from the markers each side renders; the difference is stated only when the
+  // two sides' sets differ, naming which side carries which.
+  const renderedSources = (bands) => [...new Set(Object.values(bands)
+    .map((x) => (x && (/\(([a-z]+)\)\s*$/.exec(bandStr(x)) || [])[1]) || null).filter(Boolean))].sort();
+  const sourcesA = renderedSources(aB);
+  const sourcesB = renderedSources(bB);
+  const sourcesOnPage = [...new Set([...sourcesA, ...sourcesB])].sort();
+  const sourcesDiffer = sourcesA.join() !== sourcesB.join();
+  if (sourcesOnPage.length) {
+    const LEGEND = {
+      generation: '`(generation)` is an ACROSS-DRAW spread: the standard deviation of the case\'s score across n generation draws per arm.',
+      legacy: '`(legacy)` is a JUDGE-SAMPLE spread over a single generation: the standard deviation across the judge\'s samples of that one text.',
+    };
+    const legend = sourcesOnPage.map((s) => LEGEND[s] || `\`(${s})\` is a band source this differ does not describe.`);
+    if (sourcesDiffer) {
+      const side = (label, s) => `${label} carries ${s.length ? s.map((x) => `\`(${x})\``).join(' and ') : 'no labelled'} bands`;
+      legend.push(`The two receipts' bands come from different sources: ${side(labelA, sourcesA)}, ${side(labelB, sourcesB)}. They are different statistics, so a per-case comparison across them is not like for like.`);
+    }
+    warnings.push(`band provenance: ${legend.join(' ')}`);
   }
   if (warnings.length) {
     L.push('> **⚠ Caveats**');
@@ -350,8 +398,27 @@ function buildDriftReport(a, b, { labelA = 'A', labelB = 'B', mode = 'release' }
   } else {
     L.push(`**${revision ? revisionHeadline(perCase) : headlineVerdict(perCase)}**`);
     L.push('');
-    L.push(`with_skill mean moved ${fmt(headlineDelta)} (${bandStr(aAgg)} → ${bandStr(bAgg)}; band = suite dispersion). Per-case band-overlap verdicts: ${regressions.length} regression(s), ${perCase.filter((r) => r.verdict === 'improvement').length} improvement(s), ${nWithin} within noise${nFloor ? ` (${nFloor} of them band-separated but below the ${EFFECT_FLOOR} effect floor)` : ''}.`);
+    // ONE LABEL PER CASE, THE TABLE'S (F-5 of
+    // specs/031-artefact-claims/evidence/approval-20260915T032341Z.md). A case whose
+    // bands do not overlap but whose move is below the floor is labelled below
+    // effect floor in the per-case table. This line counted it among the cases with
+    // no separation detected and then called the same cases band-separated; it now
+    // counts the two apart, as the table labels them. Neither is a separation under
+    // the rule, which is what the headline above says.
+    L.push(`with_skill mean moved ${fmt(headlineDelta)} (${bandStr(aAgg)} → ${bandStr(bAgg)}; band = suite dispersion). Per-case band-overlap verdicts: ${regressions.length} regression(s), ${perCase.filter((r) => r.verdict === 'improvement').length} improvement(s), ${nWithin - nFloor} with no separation detected${nFloor ? `, ${nFloor} below the ${EFFECT_FLOOR} effect floor` : ''}.`);
     L.push('');
+    const underpowered = perCase.filter((r) => r.power);
+    if (underpowered.length) {
+      // One count, one sentence, one draws line: the worst case's (spec 035 AC-5).
+      const spread = underpowered.find((r) => r.power.reason === 'spread');
+      const most = underpowered.filter((r) => r.power.reason === 'draws').sort((x, y) => y.power.drawsNeeded - x.power.drawsNeeded)[0];
+      const worst = spread ? { value: null, reason: 'spread', case: spread.id, spread: spread.power.spread }
+        : most ? { value: most.power.drawsNeeded, reason: 'draws', case: most.id }
+          : { value: 2, reason: 'single_draw', case: underpowered[0].id };
+      const powerLine = `Underpowered: ${underpowered.length} of the cases with no separation under the rule. ${UNDERPOWERED_LINE}. ${drawsLine(worst)}`;
+      L.push(powerLine);
+      L.push('');
+    }
   }
 
   L.push(`## Per-case with_skill (band overlap → verdict)`);
@@ -359,8 +426,9 @@ function buildDriftReport(a, b, { labelA = 'A', labelB = 'B', mode = 'release' }
   L.push(`| case | ${labelA} (mean ± sd) | ${labelB} (mean ± sd) | Δ | verdict |`);
   L.push(`|---|---|---|---|---|`);
   for (const r of perCase) {
-    const flag = r.verdict === 'regression' ? '🔻 regression' : r.verdict === 'improvement' ? '🔼 improvement' : r.verdict === WITHIN_NOISE_FLOOR ? 'within noise (below floor)' : r.verdict === 'within noise' ? 'within noise' : r.verdict === 'not measured' ? 'not measured' : 'n/a';
-    L.push(`| \`${r.id}\` | ${r.before ? bandStr(r.before) : 'n/a'} | ${r.after ? bandStr(r.after) : 'n/a'} | ${fmt(r.delta)} | ${flag} |`);
+    const flag = r.verdict === 'regression' ? '🔻 regression' : r.verdict === 'improvement' ? '🔼 improvement' : r.verdict === WITHIN_NOISE_FLOOR ? 'below effect floor' : r.verdict === WITHIN_NOISE ? 'no separation detected' : r.verdict === 'not measured' ? 'not measured' : 'n/a';
+    const label = r.power ? `${flag}; ${UNDERPOWERED_LINE}` : flag;
+    L.push(`| \`${r.id}\` | ${r.before ? bandStr(r.before) : 'n/a'} | ${r.after ? bandStr(r.after) : 'n/a'} | ${fmt(r.delta)} | ${label} |`);
   }
   L.push('');
 

package/lib/judge.js

@@ -78,8 +78,15 @@ function promptTemplateHash() {
 const TRUNCATION_STOP_REASONS = new Set(['max_tokens', 'length']);
 function isTruncated(stopReason) { return TRUNCATION_STOP_REASONS.has(String(stopReason || '')); }
 
+// Only a JSON number is a score (spec 032 AC-1). Number() turned null, false,
+// "" and [] into 0 and true into 1, and each of those became a measured sample:
+// a judge that said nothing scored the worst possible grade, and two receipts
+// over the same generations read as a regression. Every non-number becomes NaN
+// here and is refused by the isFinite line below, which stays the one line every
+// non-number reaches (spec 026's clamp mutation is planted on it).
 function scoreOf(parsed) {
-  const x = Number(parsed && parsed.score);
+  const raw = parsed ? parsed.score : undefined;
+  const x = typeof raw === 'number' ? raw : NaN;
   if (!Number.isFinite(x)) return null;
   if (x < 0 || x > 1) return null;
   return x;
@@ -128,10 +135,11 @@ async function gradeOnce({ task, response, rubric, model, timeoutMs, temperature
   }
   const score = scoreOf(parsed);
   if (score === null) {
-    const x = parsed && parsed.score;
-    const reason = x === undefined || x === null ? 'judge output carries no numeric score'
-      : !Number.isFinite(Number(x)) ? `judge output carries no numeric score (score ${JSON.stringify(x)})`
-        : `judge score ${x} outside [0, 1]`;
+    const x = parsed ? parsed.score : undefined;
+    const reason = x === undefined ? 'judge output carries no numeric score'
+      : typeof x !== 'number' ? `judge output carries no numeric score (score ${JSON.stringify(x)})`
+        : !Number.isFinite(x) ? `judge output carries no numeric score (score ${String(x)})`
+          : `judge score ${x} outside [0, 1]`;
     return { ...base, unmeasured: true, reason };
   }
   return { ...base, score, reason: String(parsed.reason || '').slice(0, 300) };
@@ -143,7 +151,7 @@ async function gradeOnce({ task, response, rubric, model, timeoutMs, temperature
 // samples: a partial sample set must never become a band, and a draw one of
 // whose judge samples carried no score is unmeasured as a whole (spec 026
 // AC-3). The remaining samples are not taken.
-// `mean` ± `stddev` is the per-case confidence band (raw spread of the N scores)
+// `mean` ± `stddev` is the per-case band, a descriptive spread (one sample sd of the N scores)
 // used by the borderline-outcome rule and per-case drift band-overlap logic.
 // NO DEFAULT TIMEOUT HERE (spec 017 AC-2). This defaulted to 120000, which
 // outranked the per-surface policy exactly as lib/run.js's literal did — so the

package/lib/receipt.js

@@ -25,7 +25,11 @@ const SCHEMA_FILES = {
   // the validator (it requires the receipt to say what answered it), so the
   // number has to keep resolving to the schema it meant.
   '0.5': 'receipt.v0.5.schema.json',
-  '0.6': 'receipt.schema.json',
+  // v0.6 moved the same way when v0.7 took the current pointer (spec 035): v0.7 adds a
+  // verdict token a reader derives (UNDERPOWERED), and a v0.6 receipt restamped 0.7
+  // is refused by the const, so the number keeps resolving to the schema it meant.
+  '0.6': 'receipt.v0.6.schema.json',
+  '0.7': 'receipt.schema.json',
 };
 
 // THE BAND RULE, stated on every receipt (results.aggregates.band_rule, spec
@@ -114,7 +118,7 @@ function comparisonOf(aggWith, aggBase) {
     baseline_score: aggBase.mean_score,
     delta: noCases ? null : round(aggWith.mean_score - aggBase.mean_score),
     // Combined uncertainty of the delta: quadrature sum of the two aggregate
-    // bands. Diff uses this for the headline "within noise" vs real-move rule.
+    // bands. A figure beside the delta; the per-case band rule decides the headline.
     delta_uncertainty: noCases ? null : combineUncertainty(aggWith.stddev, aggBase.stddev),
   };
   if (noCases) cmp.delta_uncertainty_unavailable = 'no_cases';

package/lib/revision.js

@@ -21,29 +21,38 @@ const { EFFECT_FLOOR } = require('../config');
 
 // ── the cell headline ────────────────────────────────────────────────────────
 // A summary of the per-case band-overlap verdicts, worded about the REVISION.
-// The release-drift headline says "the skill is measurably weaker", which is a
-// sentence about a skill under a moving model. Here the model is the control.
+// The release-drift headline is a sentence about a skill under a moving model.
+// Here the model is the control. Worded under spec 031 A-031-20: a separation is
+// detected under the rule, never proof; none detected is not evidence of sameness.
 function revisionHeadline(perCase) {
   const reg = perCase.filter((r) => r.verdict === 'regression').length;
   const imp = perCase.filter((r) => r.verdict === 'improvement').length;
   const s = (n) => (n === 1 ? '' : 's');
   if (reg && imp) {
-    return `MIXED — the revision improved ${imp} case${s(imp)} and regressed ${reg} on non-overlapping bands.`;
+    return `MIXED: separation detected under the rule on ${imp} case${s(imp)} upward and ${reg} downward under the current upstream text (bands do not overlap).`;
   }
   if (reg) {
-    return `REVISION REGRESSED — ${reg} case${s(reg)} scored lower under the current upstream text (bands do not overlap).`;
+    return `REVISION REGRESSED: separation detected under the rule on ${reg} case${s(reg)}, lower under the current upstream text (bands do not overlap).`;
   }
   if (imp) {
-    return `REVISION IMPROVED — ${imp} case${s(imp)} scored higher under the current upstream text (bands do not overlap); none regressed.`;
+    return `REVISION IMPROVED: separation detected under the rule on ${imp} case${s(imp)}, higher under the current upstream text (bands do not overlap); none lower.`;
   }
-  return 'WITHIN NOISE — the revision moved no case beyond its confidence band; the pinned text and the current text measure the same.';
+  return 'NO SEPARATION DETECTED: no case separated under the rule at this sample size (band = mean \u00b1 1 sd); this is not evidence that the pinned text and the current text behave alike.';
 }
 
-// Classification word for a cell, from its headline. Kept separate so a caller
-// can branch on the class without parsing prose.
+// Classification value for a cell. Kept separate so a caller can branch on the
+// class without parsing prose. It used to be the headline's first word, cut at
+// its dash; the headline's wording is now a display matter (spec 031 A-031-20),
+// so the values are stated here and are unchanged: scripts/prepare-report-006.js
+// and spec 009's gate read them. CLASS_NOT_SEPARATED is the value, not a label.
+const CLASS_NOT_SEPARATED = 'WITHIN NOISE';
 function revisionClass(perCase) {
-  const h = revisionHeadline(perCase);
-  return h.split(' —')[0];
+  const reg = perCase.filter((r) => r.verdict === 'regression').length;
+  const imp = perCase.filter((r) => r.verdict === 'improvement').length;
+  if (reg && imp) return 'MIXED';
+  if (reg) return 'REVISION REGRESSED';
+  if (imp) return 'REVISION IMPROVED';
+  return CLASS_NOT_SEPARATED;
 }
 
 // ── the fairness sentence ────────────────────────────────────────────────────
@@ -54,7 +63,7 @@ function revisionClass(perCase) {
 // one-directional courtesy — the symmetry is a property of the code, and the
 // gate asserts it.
 //
-// A cell within noise gets NO sentence. #005's figure stands unamended, because
+// A cell with no separation detected gets NO sentence. #005's figure stands unamended, because
 // nothing was measured that would amend it, and manufacturing a hedge for a null
 // result is how a report launders noise into a finding.
 function fairnessSentence({ slug, classification, report005Delta, measuredDelta }) {

package/lib/stats.js

@@ -1,8 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 'use strict';
 
-// Small statistics helpers for sampled judging and confidence bands. Kept
-// dependency-free and deterministic.
+// Small statistics helpers for sampled scores and their bands. A band is a
+// descriptive spread, the mean plus or minus one sample standard deviation; it
+// carries no coverage probability. Kept dependency-free and deterministic.
 
 function round(n, dp = 6) { const f = Math.pow(10, dp); return Math.round(n * f) / f; }
 
@@ -60,16 +61,24 @@ function aggregateBands(cases) {
   return { mean: mean(means), stddev: means.length < 2 ? null : stddev(means) };
 }
 
-// Do two confidence bands (mean ± half-width) fail to overlap, and in which
-// direction? Returns 'regression' (b below a), 'improvement' (b above a), or
-// 'within noise' (bands touch/overlap). This is the anti-false-positive rule:
-// a change is only claimed when the bands are fully separated.
+// THE NOT-SEPARATED VERDICT VALUE, which is a value and not a label (spec 031
+// A-031-20). Callers compare against it, and every display label is mapped from
+// it where it is rendered: lib/diff.js prints "no separation detected". The value
+// itself is unchanged pending the verdict-rule spec.
+const WITHIN_NOISE = 'within noise';
+
+// Do two bands (mean ± half-width, the half-width one sample standard deviation)
+// fail to overlap, and in which direction? Returns 'regression' (b below a),
+// 'improvement' (b above a), or WITHIN_NOISE (the bands touch or overlap). This
+// is the anti-false-positive rule: a separation is detected only when the bands
+// are fully apart, and overlap is the absence of a detected separation at the
+// sample size used, not evidence that nothing changed.
 //   regression   : meanB + hwB < meanA - hwA
 //   improvement  : meanB - hwB > meanA + hwA
 function bandVerdict(meanA, hwA, meanB, hwB) {
   if (meanB + hwB < meanA - hwA) return 'regression';
   if (meanB - hwB > meanA + hwA) return 'improvement';
-  return 'within noise';
+  return WITHIN_NOISE;
 }
 
 // The variance ratio: how much larger the GENERATION-level spread is than the
@@ -87,4 +96,4 @@ function varianceRatio(generationSd, judgeSdMean) {
   return round(g / j);
 }
 
-module.exports = { mean, stddev, stderr, combineUncertainty, aggregateBands, bandVerdict, round, varianceRatio };
+module.exports = { mean, stddev, stderr, combineUncertainty, aggregateBands, bandVerdict, round, varianceRatio, WITHIN_NOISE };

package/lib/value.js

@@ -25,8 +25,8 @@ const { EFFECT_FLOOR } = require('../config');
 //
 // RATIO FRAMINGS ARE FLOOR-GATED. A ratio like "dollars per 0.01 lift" is
 // only meaningful when the benefit it prices is a real move. When the lift did not clear
-// the effect floor (or its bands overlap), the ratio renders "n/a (within noise)"
-// — never a number, however tempting the arithmetic. Dividing noise by a cost
+// the effect floor (or its bands overlap), the ratio renders "n/a (no separation
+// detected)", never a number, however tempting the arithmetic. Dividing noise by a cost
 // produces a precise-looking figure with no evidence under it.
 //
 // PRICING IS FROZEN AT RUN TIME. Registry prices change (vendors cut prices; we
@@ -47,14 +47,14 @@ const COST_BASIS = {
 const LATENCY_DISCLOSURE =
   'observed on subscription CLI surface, indicative';
 
-const NOISE_CELL = 'n/a (within noise)';
+const NOISE_CELL = 'n/a (no separation detected)';
 
 // A floor-clearing NEGATIVE lift: the skill measurably hurt, so there is no
 // benefit to put a price on.
 const REGRESSED_CELL = 'n/a (skill regressed)';
 
 // A cell with at least one separated, floor-clearing DRIVER whose AGGREGATE lift
-// does not clear the floor. It is not "within noise" — the QA re-derivation found
+// does not clear the floor. It is not the no-separation cell: the QA re-derivation found
 // six such cells rendering the noise string while the Verdict basis on the same
 // page named their drivers (QA V-4, 2026-08-19). The aggregate stays the
 // denominator (spec 002 AC-4, DECISIONS #9), so no price is quoted, but the cell
@@ -461,7 +461,7 @@ function costPerLiftPoint({ lift, separated, incrementalCostPer1kCalls }) {
     // Two different absences, two different strings. `separated` means at least
     // one case cleared the floor with non-overlapping bands; when that holds and
     // only the aggregate falls short, the evidence exists and is listed under
-    // Verdict basis — saying "within noise" there contradicts the same page.
+    // Verdict basis, and the no-separation cell there would contradict the same page.
     return separated ? DRIVER_ONLY_CELL : NOISE_CELL;
   }
   const cost = Number(incrementalCostPer1kCalls);