@sema-ai/core 1.275.1

package/dist/bench/metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["../../src/bench/metrics.ts"],"names":[],"mappings":"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"}

package/dist/bench/metrics.js

@@ -0,0 +1,618 @@
+/**
+ * design/89 §2 — VALUE-JUDGMENT METRICS (the cost-per-truly-correct measurement tool).
+ *
+ * Pure, deterministic measurement logic for the value-judgment benchmark (design/89, milestone-gap
+ * ❓-未判项: "supervisor / multi-agent vs solo 到底值不值?"). The service three-arm harness feeds REAL
+ * runs in; this module computes truly-correct / three-class outcomes / cost four-components / Pareto.
+ *
+ * IRON LAWS (design/89 §2, blood-bought red lines — DO NOT relax):
+ *   1. The numerator counts ONLY objective oracles (exec-gate exit-code, build, property-harness, and
+ *      actual-delivery). LLM-judge is NEVER counted into truly-correct (it is a runtime GATE, not a
+ *      measurement; §2.2). It burns cost (C1/C2) but never the numerator.
+ *   2. NEVER synthesize a single scalar. Cost is FOUR separate components (§2.3); C1 (token µUSD) and
+ *      C2 (human seconds) are apples + oranges (§2.1) and are NEVER added. The verdict is a 3-D Pareto
+ *      frontier over (C1, C2.sec, P). A µUSD/tc ratio may be reported ONLY as a per-axis diagnostic.
+ *   3. THREE outcome classes (§2.2.1): DELIVERED-CORRECT / DELIVERED-WRONG / CORRECTLY-WITHHELD. A
+ *      correctly-withheld task (human/gate stopped a would-be DELIVERED-WRONG) is the supervisor's
+ *      avoided-loss value — it is NOT a failure and NOT in the numerator.
+ *   4. Deterministic + testable: this file has zero model/network dependency. Synthetic-run fixtures
+ *      validate the measurement logic without a real model (see metrics.test.ts).
+ *
+ * This is a SHADOW-LAB experiment tool (not the core engine). Run via `npx tsx`.
+ */
+// ────────────────────────────────────────────────────────────────────────────────────────────────
+// IRON LAW #1 — truly-correct = AND of FOUR objective criteria (§2.2). LLM-judge never enters.
+// ────────────────────────────────────────────────────────────────────────────────────────────────
+/**
+ * §2.2 — `truly-correct(run)` = AND of the four objective criteria (any false ⇒ 0). The numerator of
+ * P. By construction this takes ONLY {@link OracleVerdicts} (objective oracles); there is no parameter
+ * by which an LLM-judge could enter — that is the type-level enforcement of iron law #1.
+ */
+export function trulyCorrect(o) {
+    return o.hiddenTestsGreen && o.buildPassed && o.invariantsOk && o.delivered;
+}
+/**
+ * §2.2.1 — classify a run into one of the outcome classes. The withheld bucket is SPLIT by the §2.1
+ * intercept-value counterfactual (design/89 §2.2.1 line 96 — a withhold is only avoided-loss if it
+ * stopped a would-be DELIVERED-WRONG):
+ *   - DELIVERED-CORRECT: not withheld AND truly-correct → the numerator.
+ *   - DELIVERED-WRONG: not withheld AND not truly-correct → the true negative (solo hard-committing a
+ *     buggy artifact, OR 触顶蒸发 with delivered=false). §2.2 criterion ④ folds "ran-but-didn't-
+ *     deliver" into DELIVERED-WRONG, not into a withheld bucket — withheld requires an EXPLICIT
+ *     human/gate decision, vaporized-on-overflow is a failure.
+ *   - CORRECTLY-WITHHELD: withheld AND the counterfactual proves the task WOULD have been DELIVERED-
+ *     WRONG (`withoutInterventionTrulyCorrect===false`). The supervisor's avoided-loss value — NOT in
+ *     the numerator, NOT a failure.
+ *   - INCORRECTLY-WITHHELD: withheld BUT the counterfactual shows the task would have been DELIVERED-
+ *     CORRECT (`withoutInterventionTrulyCorrect===true`). A value-DESTROYING over-cautious intervention
+ *     (a false-positive withhold). This is a COST/mistake, NEVER laundered into avoided-loss (the
+ *     focus-item-② failure mode the review caught).
+ *   - UNVERIFIED-WITHHELD: withheld but NO counterfactual was recorded → correctness unknown. Excluded
+ *     from the avoided-loss credit (NOT defaulted to CORRECTLY-WITHHELD) and flagged (design/89 §2.2.1
+ *     line 96: withheld MUST be counterfactual-verified).
+ */
+export function classifyOutcome(run) {
+    if (run.delivery.withheld) {
+        const cf = run.counterfactual;
+        if (!cf)
+            return "UNVERIFIED-WITHHELD";
+        // Avoided-loss iff, without the intervention, the task would NOT have been truly-correct.
+        return cf.withoutInterventionTrulyCorrect ? "INCORRECTLY-WITHHELD" : "CORRECTLY-WITHHELD";
+    }
+    return trulyCorrect(run.oracle) ? "DELIVERED-CORRECT" : "DELIVERED-WRONG";
+}
+/**
+ * §2.3 — derive C1 from `stats.costBreakdown` (design/80 D-E-core). C1 is the LLM-token-derived total:
+ * the sum of the four breakdown lines. Falls back to `costMicroUsd` (+ nested) when `costBreakdown`
+ * is absent (older runs), then 0. This is the ONLY composition done — and it is WITHIN C1 (all µUSD,
+ * same unit); it never reaches across to C2.
+ */
+export function deriveC1(stats) {
+    const b = stats.costBreakdown;
+    if (b) {
+        return (b.llmRootMicroUsd +
+            b.nestedSubagentMicroUsd +
+            b.memoryConsolidationMicroUsd +
+            b.compactionMicroUsd);
+    }
+    // Fallback for runs assembled before costBreakdown existed.
+    const root = stats.costMicroUsd ?? 0;
+    const nested = stats.nested?.costMicroUsd ?? 0;
+    return root + nested;
+}
+/** §2.4 — derive C2 (count, seconds) from `stats.humanReview` (design/91). Absent ⇒ no gate ⇒ (0,0). */
+export function deriveC2(stats) {
+    const h = stats.humanReview;
+    if (!h)
+        return { count: 0, sec: 0 };
+    return { count: h.count, sec: h.totalWaitMs / 1000 };
+}
+/** §2.3 — assemble all four cost components for a run. They stay separate by construction. */
+export function costComponents(run) {
+    const c2 = deriveC2(run.stats);
+    return {
+        c1ModelMicroUsd: deriveC1(run.stats),
+        c2HumanCount: c2.count,
+        c2HumanSec: c2.sec,
+        c3WallSec: run.wallTimeSec ?? 0,
+        c4InfraMicroUsd: run.infraMicroUsd ?? 0,
+    };
+}
+/**
+ * §2.4#2 — did a human intervention have intercept VALUE? Outcome-CLASS-aware (NOT truly-correct-binary
+ * -aware), so it correctly credits the supervisor's #1 value — an avoided-loss withhold — which a
+ * truly-correct XOR cannot see (design/89 §2.2.1: a withheld run's truly-correct is always false).
+ *
+ * Value exists when disabling the intervention would have WORSENED the outcome class:
+ *   - DELIVER-correcting intervention: WITH delivers correct, WITHOUT delivers wrong
+ *     (`withInterventionTrulyCorrect===true && withoutInterventionTrulyCorrect===false`).
+ *   - AVOIDED-LOSS withhold: the run was correctly withheld (CORRECTLY-WITHHELD) and WITHOUT the
+ *     intervention it would have been DELIVERED-WRONG (`withoutInterventionTrulyCorrect===false`).
+ *
+ * An INCORRECTLY-WITHHELD intervention (would-be correct, killed by an over-cautious human) has
+ * NEGATIVE value and returns `false` here — it is never counted as intercept value.
+ *
+ * Pass the run's outcome class so the predicate knows whether this was a withhold; the explicit
+ * `changedOutcome` override still wins when the harness sets it.
+ */
+export function interceptHadValue(cf, outcome) {
+    if (typeof cf.changedOutcome === "boolean")
+        return cf.changedOutcome;
+    if (outcome === "CORRECTLY-WITHHELD") {
+        // Avoided-loss: without the intervention the task would have been DELIVERED-WRONG.
+        return cf.withoutInterventionTrulyCorrect === false;
+    }
+    if (outcome === "INCORRECTLY-WITHHELD" || outcome === "UNVERIFIED-WITHHELD") {
+        // A mistaken or unverifiable withhold never has intercept value.
+        return false;
+    }
+    // Non-withheld: value iff the intervention flipped a would-be-wrong delivery to correct.
+    return cf.withInterventionTrulyCorrect === true && cf.withoutInterventionTrulyCorrect === false;
+}
+function mean(xs) {
+    return xs.length ? xs.reduce((a, b) => a + b, 0) / xs.length : 0;
+}
+/** Fold a cell's runs (all same arm) into the per-arm vector. */
+export function foldCell(runs) {
+    if (runs.length === 0)
+        throw new Error("foldCell: empty runs");
+    const arm = runs[0].arm;
+    for (const r of runs)
+        if (r.arm !== arm)
+            throw new Error(`foldCell: mixed arms (${arm} vs ${r.arm})`);
+    let deliveredCorrect = 0;
+    let deliveredWrong = 0;
+    let correctlyWithheld = 0;
+    let incorrectlyWithheld = 0;
+    let unverifiedWithheld = 0;
+    let interceptValueChanged = 0;
+    let interceptValueMeasured = 0;
+    const c1s = [];
+    const c2counts = [];
+    const c2secs = [];
+    const c3s = [];
+    const c4s = [];
+    for (const r of runs) {
+        const oc = classifyOutcome(r);
+        if (oc === "DELIVERED-CORRECT")
+            deliveredCorrect++;
+        else if (oc === "DELIVERED-WRONG")
+            deliveredWrong++;
+        else if (oc === "CORRECTLY-WITHHELD")
+            correctlyWithheld++;
+        else if (oc === "INCORRECTLY-WITHHELD")
+            incorrectlyWithheld++;
+        else
+            unverifiedWithheld++;
+        const c = costComponents(r);
+        c1s.push(c.c1ModelMicroUsd);
+        c2counts.push(c.c2HumanCount);
+        c2secs.push(c.c2HumanSec);
+        c3s.push(c.c3WallSec);
+        c4s.push(c.c4InfraMicroUsd);
+        if (r.counterfactual) {
+            interceptValueMeasured++;
+            if (interceptHadValue(r.counterfactual, oc))
+                interceptValueChanged++;
+        }
+    }
+    const delivered = deliveredCorrect + deliveredWrong;
+    const trulyCorrectRate = delivered > 0 ? deliveredCorrect / delivered : undefined;
+    const c1Mean = mean(c1s);
+    // codex MINOR / M10 — withhold precision/recall (would-be-wrong detector). UNVERIFIED withholds are
+    // excluded from precision (TP/FP unknown w/o counterfactual); deliveredWrong is the recall FN (a wrong
+    // delivery a withhold would have avoided). Both undefined when their denominator is 0.
+    const verifiedWithholds = correctlyWithheld + incorrectlyWithheld;
+    const wrongDeliveryOpportunities = correctlyWithheld + deliveredWrong;
+    const withholdPrecision = verifiedWithholds > 0 ? correctlyWithheld / verifiedWithholds : undefined;
+    const withholdRecall = wrongDeliveryOpportunities > 0 ? correctlyWithheld / wrongDeliveryOpportunities : undefined;
+    return {
+        arm,
+        n: runs.length,
+        deliveredCorrect,
+        deliveredWrong,
+        correctlyWithheld,
+        incorrectlyWithheld,
+        unverifiedWithheld,
+        trulyCorrectRate,
+        correctlyWithheldRate: correctlyWithheld / runs.length,
+        withholdPrecision,
+        withholdRecall,
+        c1ModelMicroUsdMean: c1Mean,
+        c2HumanCountMean: mean(c2counts),
+        c2HumanSecMean: mean(c2secs),
+        c3WallSecMean: mean(c3s),
+        c4InfraMicroUsdMean: mean(c4s),
+        interceptValueChanged,
+        interceptValueMeasured,
+        c1PerTrulyCorrectDiag: deliveredCorrect > 0 ? (c1Mean * runs.length) / deliveredCorrect : undefined,
+    };
+}
+/**
+ * §2.1 — does point `a` Pareto-DOMINATE point `b`? `a` dominates `b` iff `a` is no worse on ALL three
+ * axes (≤ C1, ≤ C2.sec, ≥ P) AND strictly better on at least one. Domination means b is provably
+ * inferior. NOT dominated ⇒ both are on the frontier (a real trade-off — exactly the §2.1 outcome we
+ * refuse to collapse into one scalar).
+ */
+export function dominates(a, b) {
+    const noWorse = a.c1ModelMicroUsd <= b.c1ModelMicroUsd &&
+        a.c2HumanSec <= b.c2HumanSec &&
+        a.trulyCorrectRate >= b.trulyCorrectRate;
+    if (!noWorse)
+        return false;
+    const strictlyBetter = a.c1ModelMicroUsd < b.c1ModelMicroUsd ||
+        a.c2HumanSec < b.c2HumanSec ||
+        a.trulyCorrectRate > b.trulyCorrectRate;
+    return strictlyBetter;
+}
+/**
+ * §2.1 — compute the 3-D Pareto frontier over the per-arm cells. Each arm contributes ONE point
+ * `(C1 mean, C2.sec mean, P)`. Arms with undefined P (all-withheld) are flagged and excluded from
+ * domination. The output is the frontier + dominated-by map — NEVER a single ranked scalar.
+ */
+export function paretoFrontier(cells) {
+    const points = [];
+    const excludedUndefinedP = [];
+    for (const c of cells) {
+        if (c.trulyCorrectRate === undefined) {
+            excludedUndefinedP.push({
+                arm: c.arm,
+                correctlyWithheldRate: c.correctlyWithheldRate,
+                correctlyWithheld: c.correctlyWithheld,
+                deliveredWrong: c.deliveredWrong,
+            });
+            continue;
+        }
+        points.push({
+            arm: c.arm,
+            c1ModelMicroUsd: c.c1ModelMicroUsdMean,
+            c2HumanSec: c.c2HumanSecMean,
+            trulyCorrectRate: c.trulyCorrectRate,
+        });
+    }
+    const frontier = [];
+    const dominated = [];
+    for (const p of points) {
+        const by = points.filter((q) => q.arm !== p.arm && dominates(q, p)).map((q) => q.arm);
+        if (by.length > 0)
+            dominated.push({ arm: p.arm, dominatedBy: by });
+        else
+            frontier.push(p.arm);
+    }
+    // §2.2.1 counterweight: an excluded avoided-loss arm + a wrong-shipping frontier arm ⇒ the frontier
+    // is NOT a winner declaration (else a wrong-shipping solo reads as sole winner).
+    const excludedAvoidedLossArms = excludedUndefinedP.filter((e) => e.correctlyWithheld > 0).map((e) => e.arm);
+    const cellByArm = new Map(cells.map((c) => [c.arm, c]));
+    const frontierArmsShippingWrong = frontier.filter((a) => (cellByArm.get(a)?.deliveredWrong ?? 0) > 0);
+    const result = { points, frontier, dominated, excludedUndefinedP };
+    if (excludedAvoidedLossArms.length > 0 && frontierArmsShippingWrong.length > 0) {
+        result.frontierNotAWinnerDeclaration = {
+            reason: "Frontier is NOT a winner declaration (design/89 §2.1/§2.2.1): an arm with counterfactual-" +
+                "verified avoided-loss (all delivery withheld → P undefined → excluded from the frontier) " +
+                "coexists with a frontier arm that ships DELIVERED-WRONG. The excluded arm avoided real " +
+                "negatives the frontier arm did not — do NOT read the frontier as 'X won'.",
+            excludedAvoidedLossArms,
+            frontierArmsShippingWrong,
+        };
+    }
+    return result;
+}
+// ────────────────────────────────────────────────────────────────────────────────────────────────
+// §2.1 — risk-transfer disclosure (solo's missing C2 ≠ cheaper). MUST be emitted in every report.
+// ────────────────────────────────────────────────────────────────────────────────────────────────
+/**
+ * §2.1 — the risk-transfer disclosure: solo having no C2 does NOT mean solo is cheaper — it transfers
+ * quality risk downstream (single-agent 3-runs-all-failed 0-commit = the cost of no human safety net;
+ * METR -19% / DORA more-code≠more-delivered / 31% PR zero-review). The report MUST emit this verbatim
+ * whenever a solo arm is present so a low solo C2 is never read as "solo cheaper". Returns the text +
+ * the supporting numbers from this run so it is not boilerplate but grounded.
+ */
+export function riskTransferDisclosure(cells) {
+    const solo = cells.find((c) => c.arm === "solo");
+    // S1b — the supervisor avoided-loss is whatever supervised arm is present (sup-per-step OR sup-vf); sum
+    // their CORRECTLY-WITHHELD so the disclosure's evidence is not blind to the verifier-first arm.
+    const supArms = cells.filter((c) => c.arm === "sup" || c.arm === "sup-vf");
+    const soloC2Sec = solo?.c2HumanSecMean ?? 0;
+    const soloDeliveredWrong = solo?.deliveredWrong ?? 0;
+    const supCorrectlyWithheld = supArms.reduce((a, c) => a + c.correctlyWithheld, 0);
+    const text = "RISK-TRANSFER DISCLOSURE (design/89 §2.1): solo has no C2 (human-review seconds) but that does " +
+        "NOT make solo cheaper — it transfers the quality risk DOWNSTREAM. A low/zero solo C2 must never " +
+        "be read as 'solo cheaper': solo's DELIVERED-WRONG count is the unmitigated cost of having no " +
+        "human safety net (single-agent experiment: 3 runs all failed, 0 commit; METR -19%; DORA more-" +
+        "code ≠ more-delivered). The supervisor's C2 BUYS the CORRECTLY-WITHHELD avoided-loss; compare " +
+        "C2 against avoided DELIVERED-WRONG, never against zero.";
+    return {
+        applies: !!solo,
+        text,
+        evidence: { soloC2Sec, soloDeliveredWrong, supCorrectlyWithheld },
+    };
+}
+// ────────────────────────────────────────────────────────────────────────────────────────────────
+// codex B2 — POWERED statistics: paired bootstrap / McNemar / Newcombe, pre-registered MDE + power.
+// "N≥15 is an assertion, not power; 'CI non-overlap' is the WRONG test for paired binary." (codex B2)
+// All deterministic: paired bootstrap uses a seeded LCG so the same inputs reproduce the same CI.
+// ────────────────────────────────────────────────────────────────────────────────────────────────
+/** A small deterministic PRNG (mulberry32) — bootstrap must be replayable (design/95 §3.2). */
+function mulberry32(seed) {
+    let a = seed >>> 0;
+    return function () {
+        a |= 0;
+        a = (a + 0x6d2b79f5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/**
+ * Two-sided tail of χ²(1df) = P(χ²₁ ≥ chi) = erfc(√(chi/2)) (for McNemar with continuity correction).
+ *
+ * 🔴 ADVERSARIAL-REVIEW FIX (B2 false-close): Abramowitz-Stegun 7.1.26 approximates erf(x), NOT
+ * erfc(x). The prior code computed `erf` and labelled/returned it as `erfc`, INVERTING every
+ * large-sample McNemar p-value (chi=10.83 → returned 0.999 instead of the correct 0.001; the
+ * strongest possible discordant signal b=26,c=0 read as p≈1 = "not significant"). Tests missed it
+ * because they all used discordant counts ≤25 (the exact-binomial path). A firm-n benchmark (N≥15,
+ * the design's own J1/J3 bar) routinely exceeds 25 discordant pairs → would draw INVERTED
+ * significance. Correct: erfc(x) = 1 − erf(x).
+ */
+function chiSqTwoSidedP1df(chi) {
+    const x = Math.sqrt(chi / 2);
+    const t = 1 / (1 + 0.3275911 * x);
+    const erf = 1 -
+        (((((1.061405429 * t - 1.453152027) * t) + 1.421413741) * t - 0.284496736) * t + 0.254829592) *
+            t *
+            Math.exp(-x * x);
+    return Math.max(0, Math.min(1, 1 - erf)); // erfc(x) = 1 − erf(x)
+}
+/** Exact two-sided binomial p for McNemar when discordant count is small (b+c ≤ 25). */
+function binomTwoSidedP(b, c) {
+    const n = b + c;
+    if (n === 0)
+        return 1;
+    const k = Math.min(b, c);
+    // P(X ≤ k) under Binom(n, 0.5), doubled (two-sided), capped at 1.
+    let cum = 0;
+    for (let i = 0; i <= k; i++)
+        cum += binomPmfHalf(n, i);
+    return Math.min(1, 2 * cum);
+}
+function binomPmfHalf(n, k) {
+    // C(n,k) * 0.5^n, computed in log space for stability.
+    let logC = 0;
+    for (let i = 1; i <= k; i++)
+        logC += Math.log(n - k + i) - Math.log(i);
+    return Math.exp(logC + n * Math.log(0.5));
+}
+/**
+ * codex B2 — compare two arms' delivered truly-correct as PAIRED binary. Pairs runs by the COMPOSITE
+ * `(taskId, seed)` key (codex MAJOR-A: a bare `seed` collides across tasks — the same repeat index
+ * recurs per task — so cross-task input would overwrite pairs and poison the McNemar sample);
+ * only rows where BOTH arms delivered (not withheld, both scored) form a pair — a
+ * withheld run has no delivered binary to pair (it is scored in the withhold/avoided-loss axis, not
+ * here). `mde` is the pre-registered minimum detectable effect (default 0.20 absolute = a 20pp swing).
+ */
+export function pairedBinaryCompare(scoredRuns, armA, armB, opts = {}) {
+    const mde = opts.mde ?? 0.2;
+    const aByKey = new Map();
+    const bByKey = new Map();
+    for (const r of scoredRuns) {
+        if (r.delivery.withheld)
+            continue; // no delivered binary for a withheld run
+        // codex MAJOR-A: pair by the COMPOSITE (taskId, seed) key — a bare `seed` collides across tasks (the
+        // same seed/repeat index recurs per task), so feeding cross-task runs would silently overwrite pairs
+        // and poison the McNemar sample. The composite is task-local, matching the paired-seed-WITHIN-task design.
+        const key = r.taskId + "" + String(r.seed ?? "");
+        if (r.arm === armA)
+            aByKey.set(key, r);
+        else if (r.arm === armB)
+            bByKey.set(key, r);
+    }
+    const pairs = [];
+    for (const [key, a] of aByKey) {
+        const b = bByKey.get(key);
+        if (!b)
+            continue;
+        pairs.push({ a: trulyCorrect(a.oracle), b: trulyCorrect(b.oracle) });
+    }
+    const nPairs = pairs.length;
+    let bAonly = 0; // A correct, B wrong
+    let cBonly = 0; // A wrong, B correct
+    let aCorrect = 0;
+    let bCorrect = 0;
+    for (const p of pairs) {
+        if (p.a)
+            aCorrect++;
+        if (p.b)
+            bCorrect++;
+        if (p.a && !p.b)
+            bAonly++;
+        if (!p.a && p.b)
+            cBonly++;
+    }
+    const pDiff = nPairs > 0 ? (aCorrect - bCorrect) / nPairs : 0;
+    // McNemar over discordant pairs.
+    let mcnemarP;
+    const disc = bAonly + cBonly;
+    if (disc === 0)
+        mcnemarP = 1;
+    else if (disc <= 25)
+        mcnemarP = binomTwoSidedP(bAonly, cBonly);
+    else {
+        const chi = Math.pow(Math.abs(bAonly - cBonly) - 1, 2) / disc; // continuity-corrected χ²(1df)
+        mcnemarP = chiSqTwoSidedP1df(chi);
+    }
+    // Deterministic paired-bootstrap PERCENTILE CI over the resampled paired difference (codex MAJOR-B:
+    // this is NOT Newcombe's analytic score interval — it is a percentile CI on the bootstrap distribution
+    // of (aCorrect-bCorrect)/n, seeded for determinism; adequate for the paired binary delta).
+    const rnd = mulberry32(opts.bootstrapSeed ?? 0xc0ffee);
+    const iters = opts.bootstrapIters ?? 2000;
+    const diffs = [];
+    if (nPairs > 0) {
+        for (let it = 0; it < iters; it++) {
+            let ac = 0;
+            let bc = 0;
+            for (let i = 0; i < nPairs; i++) {
+                const p = pairs[Math.floor(rnd() * nPairs)];
+                if (p.a)
+                    ac++;
+                if (p.b)
+                    bc++;
+            }
+            diffs.push((ac - bc) / nPairs);
+        }
+        diffs.sort((x, y) => x - y);
+    }
+    const ci95 = nPairs > 0
+        ? [diffs[Math.floor(0.025 * diffs.length)], diffs[Math.min(diffs.length - 1, Math.floor(0.975 * diffs.length))]]
+        : [0, 0];
+    const ciExcludesZero = ci95[0] > 0 || ci95[1] < 0;
+    const significant = ciExcludesZero && mcnemarP < 0.05;
+    // MDE at observed n: smallest detectable absolute diff at 80% power, 2-sided α=0.05. Variance uses
+    // the CONSERVATIVE worst-case 0.5 (= 2×0.25, the UNPAIRED two-proportion upper bound), NOT the true
+    // McNemar paired-difference variance (b+c−(b−c)²)/n which is typically smaller. This over-states n
+    // needed ⇒ declares "not-powered" more readily = the SAFE (anti-over-claim) direction. n ≈
+    // ((z_α/2 + z_β)^2 * 0.5) / mde^2 → invert for mde at observed nPairs.
+    const zSum = 1.96 + 0.84; // z_{.975} + z_{.80}
+    const mdeAt80Power = nPairs > 0 ? Math.min(1, (zSum * Math.sqrt(0.5 / nPairs))) : 1;
+    const nNeeded = Math.ceil((zSum * zSum * 0.5) / (mde * mde));
+    const power = nPairs >= nNeeded ? "powered" : "not-powered";
+    let verdict;
+    if (significant)
+        verdict = pDiff > 0 ? "A-better" : "B-better";
+    else if (power === "not-powered")
+        verdict = "not-powered";
+    else
+        verdict = "no-detectable-difference";
+    return { armA, armB, nPairs, bAonly, cBonly, pDiff, mcnemarP, ci95, significant, mdeAt80Power, power, verdict };
+}
+/**
+ * codex B3 — classify each arm against the SUP/TEAM-vs-baseline value question with a pre-registered
+ * exchange rate. `baselineArm` is the cost floor to compare extra C2 against (default "solo").
+ * `avoidedWrong` / `savedDecisions` per arm come from the cells / campaign report.
+ *
+ * 🔴 ADVERSARIAL-REVIEW DISCIPLINE (B1 partial false-close, design/95 §2.3): `cells` MUST be a
+ * HOMOGENEOUS cross-arm set — feed `report.comparisons[*].arms` (one `(suiteVersion,taskId,archetype,
+ * valueDimension)` comparison at a time), NEVER `report.cells` (the suite-wide ARM MEAN). The arm mean
+ * folds heterogeneous tasks → the value LABEL itself flips (Simpson): a cell that is "quality-tradeoff"
+ * (extra human seconds NOT bought back) gets averaged with a "worth-it" cell into a single misleading
+ * "worth-it", hiding the "helpful but too expensive" anti-thesis. The frontier folds too (§11 / B1).
+ * Regression: metrics.test §13b proves per-cell {worth-it, quality-tradeoff} ≠ arm-mean {worth-it}.
+ */
+export function paretoValueVerdict(cells, thresholds, perArmValue, baselineArm = "solo") {
+    const pareto = paretoFrontier(cells);
+    const dominatedArms = new Set(pareto.dominated.map((d) => d.arm));
+    const baseline = cells.find((c) => c.arm === baselineArm);
+    const baselineC2 = baseline?.c2HumanSecMean ?? 0;
+    const verdicts = cells.map((c) => {
+        const nonDominated = !dominatedArms.has(c.arm);
+        if (c.arm === baselineArm) {
+            return { arm: c.arm, nonDominated, label: nonDominated ? "worth-it" : "dominated" };
+        }
+        const extraC2 = Math.max(0, c.c2HumanSecMean - baselineC2);
+        const v = perArmValue[c.arm];
+        let clearsC2Threshold;
+        if (extraC2 > 0 && v) {
+            const budget = v.avoidedWrong * thresholds.secPerAvoidedWrong + v.savedDecisions * thresholds.secPerSavedDecision;
+            clearsC2Threshold = extraC2 <= budget;
+        }
+        else if (extraC2 === 0) {
+            clearsC2Threshold = true; // no extra human cost to justify
+        }
+        else {
+            clearsC2Threshold = false; // spent human seconds but bought no measured value
+        }
+        let label;
+        if (!nonDominated)
+            label = "dominated";
+        else if (clearsC2Threshold)
+            label = "worth-it";
+        else
+            label = "quality-tradeoff";
+        return { arm: c.arm, nonDominated, clearsC2Threshold, label };
+    });
+    return { pareto, verdicts };
+}
+/** True iff ALL ideal-blueprint constraints hold (codex M8 gate). */
+export function idealConstraintsSatisfied(c) {
+    return (c.generatedBeforeRun &&
+        c.fromVisibleBriefOnly &&
+        c.noOracleTestAccess &&
+        c.sameInfoBudget &&
+        c.solutionLeakReviewed);
+}
+/** The heterogeneity group key (codex B1). Missing coordinates collapse to "*" so legacy runs still
+ *  form one well-defined cell. */
+function groupKeyOf(r) {
+    return [r.suiteVersion ?? "*", r.taskId, r.archetype ?? "*", r.valueDimension ?? "*", r.arm].join("|");
+}
+/**
+ * Top-level (codex B1+B4): SCORE only `scored` runs (B4 — drop infra-failed/excluded with reasons),
+ * group by `(suiteVersion, taskId, archetype, valueDimension, arm)` (B1 — the per-cell decision surface,
+ * Simpson's-paradox guard), fold each group, AND provide a suite-level per-arm rollup for dashboards
+ * (explicitly NOT a decision surface). Deterministic; no model.
+ *
+ * `opts.implementedAxes` lets the harness declare which §7 axes it populated (codex MINOR11); default
+ * = only Pareto (the V1/V2/V3 structures are T1 net-new, not synthesized here).
+ */
+export function buildReport(runs, opts = {}) {
+    // B4 — split scored vs excluded.
+    const scored = [];
+    const excluded = [];
+    for (const r of runs) {
+        const status = r.runStatus ?? "scored";
+        if (status === "scored")
+            scored.push(r);
+        else
+            excluded.push({ taskId: r.taskId, arm: r.arm, seed: r.seed, reason: status });
+    }
+    // B1 — per-cell grouping (the decision surface).
+    const byGroup = new Map();
+    for (const r of scored) {
+        const key = groupKeyOf(r);
+        const list = byGroup.get(key) ?? [];
+        list.push(r);
+        byGroup.set(key, list);
+    }
+    const groupedCells = [...byGroup.entries()].map(([groupKey, rs]) => {
+        const s = rs[0];
+        return {
+            groupKey,
+            suiteVersion: s.suiteVersion,
+            taskId: s.taskId,
+            archetype: s.archetype,
+            valueDimension: s.valueDimension,
+            cell: foldCell(rs),
+        };
+    });
+    // B1 — the CROSS-ARM decision surface: group by everything EXCEPT arm, fold each arm within, run a
+    // per-comparison Pareto over a HOMOGENEOUS run set. This is what J2/J3/B3 must read (not the arm mean).
+    const byComparison = new Map();
+    for (const r of scored) {
+        const key = [r.suiteVersion ?? "*", r.taskId, r.archetype ?? "*", r.valueDimension ?? "*"].join("|");
+        const list = byComparison.get(key) ?? [];
+        list.push(r);
+        byComparison.set(key, list);
+    }
+    const comparisons = [...byComparison.entries()].map(([comparisonKey, rs]) => {
+        const s = rs[0];
+        const armBuckets = new Map();
+        for (const r of rs) {
+            const l = armBuckets.get(r.arm) ?? [];
+            l.push(r);
+            armBuckets.set(r.arm, l);
+        }
+        const arms = [...armBuckets.values()].map(foldCell);
+        return {
+            comparisonKey,
+            suiteVersion: s.suiteVersion,
+            taskId: s.taskId,
+            archetype: s.archetype,
+            valueDimension: s.valueDimension,
+            arms,
+            pareto: paretoFrontier(arms),
+        };
+    });
+    // B1 — suite-level rollup (dashboard only, NOT a decision surface). Per-arm over all scored runs.
+    const byArm = new Map();
+    for (const r of scored) {
+        const list = byArm.get(r.arm) ?? [];
+        list.push(r);
+        byArm.set(r.arm, list);
+    }
+    const cells = [...byArm.values()].map(foldCell);
+    return {
+        groupedCells,
+        comparisons,
+        cells,
+        pareto: paretoFrontier(cells),
+        riskTransfer: riskTransferDisclosure(cells),
+        directionalOnly: cells.filter((c) => c.n < 8).map((c) => c.arm),
+        excluded,
+        implementedAxes: {
+            pareto: opts.implementedAxes?.pareto ?? true,
+            v1: opts.implementedAxes?.v1 ?? false,
+            v2: opts.implementedAxes?.v2 ?? false,
+            v3: opts.implementedAxes?.v3 ?? false,
+        },
+    };
+}
+//# sourceMappingURL=metrics.js.map