@tangle-network/agent-eval 0.126.7 → 0.127.0

package/dist/{chunk-BTACVO2W.js → chunk-65QETEKG.js}

@@ -13,7 +13,7 @@ import {
   runCampaign,
   summarizeAgentReceiptIntegrity,
   tryAcquireAtomicFileLock
-} from "./chunk-ZVCHKKOP.js";
+} from "./chunk-WED5KLZQ.js";
 import {
   clamp01,
   combineAbortSignals,
@@ -21,17 +21,21 @@ import {
 } from "./chunk-WGXIEX7P.js";
 import {
   detectRewardHacking
-} from "./chunk-ARU2PZFM.js";
+} from "./chunk-424XHVKV.js";
+import {
+  campaignCellExecutionEvidence,
+  projectCampaignCellQuality
+} from "./chunk-ZPUEEM5U.js";
 import {
   costReceiptFromLlm,
   costReceiptFromLlmError,
   maximumChargeForLlmRequest,
   stripFencedJson
-} from "./chunk-J5SQWP6Y.js";
+} from "./chunk-PBE2LOSS.js";
 import {
   pairedBootstrap,
   weightedComposite
-} from "./chunk-PJQFMIOX.js";
+} from "./chunk-MHELPNRP.js";
 import {
   CostLedger,
   costForTokenPricing
@@ -1199,11 +1203,11 @@ function renderPrBody(result, gate, diff) {
   lines.push("");
   lines.push("### Contributing gates");
   lines.push("");
-  lines.push("| gate | passed | detail |");
+  lines.push("| gate | status | detail |");
   lines.push("|---|---|---|");
   for (const c of gate.contributingGates) {
     const detail = typeof c.detail === "object" ? JSON.stringify(c.detail).slice(0, 80) : String(c.detail).slice(0, 80);
-    lines.push(`| ${c.name} | ${c.passed ? "\u2713" : "\u2717"} | ${detail} |`);
+    lines.push(`| ${c.name} | ${c.status} | ${detail} |`);
   }
   lines.push("");
   lines.push("### Promoted surface");
@@ -1505,14 +1509,18 @@ function parseReflectionResponse(raw, maxProposals) {
 
 // src/campaign/score-utils.ts
 function campaignMeanComposite(campaign) {
-  const composites = [];
-  for (const cell of campaign.cells) {
-    const cellComposites = Object.values(cell.judgeScores).filter((score) => score.failed !== true && Number.isFinite(score.composite)).map((score) => score.composite);
-    if (cellComposites.length > 0) {
-      composites.push(cellComposites.reduce((a, b) => a + b, 0) / cellComposites.length);
-    }
+  const mean3 = campaignMeanCompositeOrNull(campaign);
+  if (mean3 === null) {
+    throw new Error("campaignMeanComposite: campaign has no complete cell-quality scores");
   }
-  return composites.length === 0 ? 0 : composites.reduce((a, b) => a + b, 0) / composites.length;
+  return mean3;
+}
+function campaignMeanCompositeOrNull(campaign) {
+  const scores = campaign.cells.flatMap((cell) => {
+    const score = projectCampaignCellQuality(cell).score;
+    return score === void 0 ? [] : [score];
+  });
+  return scores.length === 0 ? null : scores.reduce((sum, score) => sum + score, 0) / scores.length;
 }
 function assertFiniteRankKey(key, label, expectedLength) {
   if (!Array.isArray(key) || key.length === 0) {
@@ -1544,11 +1552,10 @@ function campaignBreakdown(campaign) {
   const notesByScenario = /* @__PURE__ */ new Map();
   const emittedByScenario = /* @__PURE__ */ new Map();
   for (const cell of campaign.cells) {
-    const judgeScores = Object.values(cell.judgeScores).filter(
-      (score) => score.failed !== true && Number.isFinite(score.composite)
-    );
-    if (judgeScores.length === 0) continue;
-    const cellComposite = judgeScores.reduce((a, s) => a + s.composite, 0) / judgeScores.length;
+    const quality = projectCampaignCellQuality(cell);
+    if (quality.score === void 0) continue;
+    const judgeScores = Object.values(quality.successfulJudgeScores);
+    const cellComposite = quality.score;
     const arr = byScenario.get(cell.scenarioId) ?? [];
     arr.push(cellComposite);
     byScenario.set(cell.scenarioId, arr);
@@ -1981,7 +1988,7 @@ function assertOptimizationProvenance(methodName, value) {
     );
   };
   if (!value || typeof value !== "object") fail("value");
-  if (!value.source || value.source.kind !== "package" || !["observed", "declared"].includes(value.source.evidence) || typeof value.source.package !== "string" || !value.source.package.trim() || typeof value.source.version !== "string" || !value.source.version.trim()) {
+  if (value.source?.kind !== "package" || !["observed", "declared"].includes(value.source.evidence) || typeof value.source.package !== "string" || !value.source.package.trim() || typeof value.source.version !== "string" || !value.source.version.trim()) {
     fail("source");
   }
   for (const [field, entry] of [
@@ -3671,7 +3678,7 @@ function assertExternalTextOptimizationConfig(config) {
       "externalTextOptimizationMethod: maxOptimizerCostUsd must be finite and non-negative"
     );
   }
-  if (!config.source || config.source.kind !== "package" || typeof config.source.package !== "string" || !config.source.package.trim() || config.source.package.trim() !== config.source.package || typeof config.source.version !== "string" || !config.source.version.trim() || config.source.version.trim() !== config.source.version) {
+  if (config.source?.kind !== "package" || typeof config.source.package !== "string" || !config.source.package.trim() || config.source.package.trim() !== config.source.package || typeof config.source.version !== "string" || !config.source.version.trim() || config.source.version.trim() !== config.source.version) {
     throw new Error("externalTextOptimizationMethod: source must identify a package and version");
   }
   for (const [field, value] of [
@@ -4213,7 +4220,13 @@ function composeGate(...gates) {
       const decisions = results.map((r) => r.res.decision);
       const overall = decisions.every((d) => d === "ship") ? "ship" : decisions.includes("arch_ceiling") ? "arch_ceiling" : decisions.includes("model_ceiling") ? "model_ceiling" : decisions.includes("hold") ? "hold" : "need_more_work";
       const contributing = results.flatMap(
-        (r) => r.res.contributingGates.length > 0 ? r.res.contributingGates : [{ name: r.gate.name, passed: r.res.decision === "ship", detail: r.res }]
+        (r) => r.res.contributingGates.length > 0 ? r.res.contributingGates : [
+          {
+            name: r.gate.name,
+            status: r.res.decision === "ship" ? "pass" : r.res.decision === "need_more_work" ? "not_evaluated" : "fail",
+            detail: r.res
+          }
+        ]
       );
       const reasons = results.flatMap(
         (r) => r.res.reasons.map((reason) => `[${r.gate.name}] ${reason}`)
@@ -4230,28 +4243,36 @@ function composeGate(...gates) {
 
 // src/canary.ts
 function runCanaries(runs, opts = {}) {
-  const alerts = [
-    ...detectSilentFallback(runs, opts.silentFallback ?? {}),
-    ...detectCalibrationDrift(runs, opts.calibrationDrift ?? {}),
-    ...opts.distributionShift ? detectDistributionShift(runs, opts.distributionShift) : []
+  const detections = [
+    detectSilentFallback(runs, opts.silentFallback ?? {}),
+    detectCalibrationDrift(runs, opts.calibrationDrift ?? {})
   ];
+  if (opts.distributionShift) {
+    detections.push(detectDistributionShift(runs, opts.distributionShift));
+  }
+  const alerts = detections.flatMap((detection) => detection.alerts);
   const counts = {
     silent_judge_fallback: 0,
     judge_calibration_drift: 0,
     distribution_shift: 0
   };
   for (const a of alerts) counts[a.kind]++;
-  return { alerts, counts };
+  return {
+    alerts,
+    counts,
+    evaluations: detections.map((detection) => detection.evaluation)
+  };
 }
 function detectSilentFallback(runs, opts) {
   const constant = opts.constant ?? 0.3;
   const threshold = opts.consecutiveThreshold ?? 3;
   const eps = opts.epsilon ?? 1e-9;
   const alerts = [];
+  let observations = 0;
   let streak = 0;
   let streakStartRunId = null;
   let streakValues = [];
-  let lastFlush = -1;
+  let reportedInStreak = false;
   for (let i = 0; i < runs.length; i++) {
     const run = runs[i];
     const meta = run.judgeMetadata;
@@ -4259,14 +4280,16 @@ function detectSilentFallback(runs, opts) {
       streak = 0;
       streakStartRunId = null;
       streakValues = [];
+      reportedInStreak = false;
       continue;
     }
+    observations += 1;
     const isFallback = meta.fallback === true || Math.abs(meta.confidence - constant) <= eps;
     if (isFallback) {
       streak += 1;
       if (streak === 1) streakStartRunId = run.runId;
       streakValues.push(meta.confidence);
-      if (streak >= threshold && lastFlush < i) {
+      if (streak >= threshold && !reportedInStreak) {
         alerts.push({
           kind: "silent_judge_fallback",
           severity: "error",
@@ -4279,16 +4302,28 @@ function detectSilentFallback(runs, opts) {
             fallbackConstant: constant
           }
         });
-        lastFlush = i;
+        reportedInStreak = true;
       }
     } else {
       streak = 0;
       streakStartRunId = null;
       streakValues = [];
-      lastFlush = -1;
+      reportedInStreak = false;
     }
   }
-  return alerts;
+  return {
+    alerts,
+    evaluation: observations >= threshold ? {
+      kind: "silent_judge_fallback",
+      status: "evaluated",
+      observations
+    } : {
+      kind: "silent_judge_fallback",
+      status: "not_evaluated",
+      observations,
+      reason: `requires at least ${threshold} run(s) with judge metadata`
+    }
+  };
 }
 function detectCalibrationDrift(runs, opts) {
   const historyWindow = opts.historyWindow ?? 50;
@@ -4301,32 +4336,55 @@ function detectCalibrationDrift(runs, opts) {
       conf.push(r.judgeMetadata.confidence);
     }
   }
-  if (conf.length < minRecent + 1) return [];
   const recent = conf.slice(-Math.min(recentWindow, conf.length));
   const historical = conf.slice(0, -recent.length).slice(-historyWindow);
-  if (recent.length < minRecent || historical.length < minRecent) return [];
+  if (recent.length < minRecent || historical.length < minRecent) {
+    return {
+      alerts: [],
+      evaluation: {
+        kind: "judge_calibration_drift",
+        status: "not_evaluated",
+        observations: conf.length,
+        reason: `requires at least ${minRecent} recent and ${minRecent} historical confidence observation(s); found ${recent.length} recent and ${historical.length} historical`
+      }
+    };
+  }
   const ks = ksTwoSample(recent, historical);
   const c = alpha <= 0.01 ? 1.63 : alpha <= 0.05 ? 1.36 : alpha <= 0.1 ? 1.22 : 1;
   const critical = c * Math.sqrt((recent.length + historical.length) / (recent.length * historical.length));
   if (ks.d > critical) {
-    return [
-      {
-        kind: "judge_calibration_drift",
-        severity: "warn",
-        message: `judge calibration drift: KS D=${ks.d.toFixed(4)} exceeds critical=${critical.toFixed(4)} at alpha=${alpha} (recent n=${recent.length}, history n=${historical.length})`,
-        evidence: {
-          ksD: ks.d,
-          critical,
-          alpha,
-          recentN: recent.length,
-          historyN: historical.length,
-          recentMean: mean2(recent),
-          historyMean: mean2(historical)
+    return {
+      alerts: [
+        {
+          kind: "judge_calibration_drift",
+          severity: "warn",
+          message: `judge calibration drift: KS D=${ks.d.toFixed(4)} exceeds critical=${critical.toFixed(4)} at alpha=${alpha} (recent n=${recent.length}, history n=${historical.length})`,
+          evidence: {
+            ksD: ks.d,
+            critical,
+            alpha,
+            recentN: recent.length,
+            historyN: historical.length,
+            recentMean: mean2(recent),
+            historyMean: mean2(historical)
+          }
         }
+      ],
+      evaluation: {
+        kind: "judge_calibration_drift",
+        status: "evaluated",
+        observations: recent.length + historical.length
       }
-    ];
+    };
   }
-  return [];
+  return {
+    alerts: [],
+    evaluation: {
+      kind: "judge_calibration_drift",
+      status: "evaluated",
+      observations: recent.length + historical.length
+    }
+  };
 }
 function ksTwoSample(a, b) {
   const sortedA = [...a].sort((x, y) => x - y);
@@ -4357,10 +4415,19 @@ function detectDistributionShift(runs, opts) {
     const b = cat(r);
     if (typeof b === "string" && b.length > 0) cats.push({ run: r, bucket: b });
   }
-  if (cats.length < minRecent + 1) return [];
   const recent = cats.slice(-Math.min(recentWindow, cats.length));
   const historical = cats.slice(0, -recent.length).slice(-historyWindow);
-  if (recent.length < minRecent || historical.length < minRecent) return [];
+  if (recent.length < minRecent || historical.length < minRecent) {
+    return {
+      alerts: [],
+      evaluation: {
+        kind: "distribution_shift",
+        status: "not_evaluated",
+        observations: cats.length,
+        reason: `requires at least ${minRecent} recent and ${minRecent} historical categorized run(s); found ${recent.length} recent and ${historical.length} historical`
+      }
+    };
+  }
   const buckets = /* @__PURE__ */ new Set();
   for (const r of recent) buckets.add(r.bucket);
   for (const h of historical) buckets.add(h.bucket);
@@ -4385,25 +4452,39 @@ function detectDistributionShift(runs, opts) {
   df = Math.max(1, df - 1);
   const critical = chiSquareCritical(df, alpha);
   if (chi > critical) {
-    return [
-      {
-        kind: "distribution_shift",
-        severity: "warn",
-        message: `eval-set distribution shift: \u03C7\xB2=${chi.toFixed(2)} df=${df} exceeds critical=${critical.toFixed(2)} at alpha=${alpha}`,
-        evidence: {
-          chi,
-          df,
-          critical,
-          alpha,
-          recentCounts,
-          historicalCounts: histCounts,
-          recentN: recent.length,
-          historyN: historical.length
+    return {
+      alerts: [
+        {
+          kind: "distribution_shift",
+          severity: "warn",
+          message: `eval-set distribution shift: \u03C7\xB2=${chi.toFixed(2)} df=${df} exceeds critical=${critical.toFixed(2)} at alpha=${alpha}`,
+          evidence: {
+            chi,
+            df,
+            critical,
+            alpha,
+            recentCounts,
+            historicalCounts: histCounts,
+            recentN: recent.length,
+            historyN: historical.length
+          }
         }
+      ],
+      evaluation: {
+        kind: "distribution_shift",
+        status: "evaluated",
+        observations: recent.length + historical.length
       }
-    ];
+    };
   }
-  return [];
+  return {
+    alerts: [],
+    evaluation: {
+      kind: "distribution_shift",
+      status: "evaluated",
+      observations: recent.length + historical.length
+    }
+  };
 }
 function chiSquareCritical(df, alpha) {
   const TABLE = {
@@ -4555,150 +4636,289 @@ function defaultProductionGate(options) {
   const seed = options.bootstrapSeed ?? 1337;
   const minProductiveRuns = options.minProductiveRuns ?? 3;
   const heldoutStatistic = options.heldoutStatistic ?? "mean";
-  const blockOnGaming = options.blockOnRewardHackingGaming ?? true;
+  const explicitlyRequired = new Set(options.requiredChecks ?? []);
   return {
     name: "defaultProductionGate",
     async decide(ctx) {
       const reasons = [];
       const contributing = [];
+      const requiredUnavailable = /* @__PURE__ */ new Set();
+      const unavailable = (name, required, reason, detail = {}) => {
+        contributing.push({
+          name,
+          status: "not_evaluated",
+          detail: { reason, required, ...detail }
+        });
+        if (required) {
+          requiredUnavailable.add(name);
+          reasons.push(`${name}: ${reason}`);
+        }
+      };
       const scenarioIds = new Set(options.holdoutScenarios.map((s) => s.id));
-      const sig = heldoutSignificance(
-        pairHoldout(
+      let delta;
+      if (!ctx.baselineJudgeScores) {
+        unavailable(
+          "heldout-significance",
+          true,
+          "baselineJudgeScores is required for a held-out comparison"
+        );
+      } else {
+        const sig = heldoutSignificance(
+          pairHoldout(ctx.judgeScores, ctx.baselineJudgeScores, scenarioIds, (s) => s.composite),
+          {
+            deltaThreshold,
+            minProductiveRuns,
+            confidence,
+            resamples,
+            seed,
+            statistic: heldoutStatistic
+          }
+        );
+        delta = heldoutStatistic === "median" ? sig.bootstrap.median : sig.bootstrap.mean;
+        const heldoutPass = sig.significant;
+        contributing.push({
+          name: "heldout-significance",
+          status: sig.fewRuns ? "not_evaluated" : heldoutPass ? "pass" : "fail",
+          detail: {
+            n: sig.n,
+            delta,
+            deltaMean: sig.bootstrap.mean,
+            deltaMedianDiagnostic: sig.medianBootstrap.median,
+            deltaMedian: sig.medianBootstrap.median,
+            tieFraction: sig.tieFraction,
+            ciLow: sig.bootstrap.low,
+            ciHigh: sig.bootstrap.high,
+            confidence: sig.bootstrap.confidence,
+            deltaThreshold,
+            fewRuns: sig.fewRuns
+          }
+        });
+        if (sig.fewRuns) {
+          requiredUnavailable.add("heldout-significance");
+        }
+        if (!heldoutPass) {
+          const tieNote = sig.tieFraction >= TIE_WARN_FRACTION ? `; ${(sig.tieFraction * 100).toFixed(0)}% tied scenarios` : "";
+          reasons.push(
+            sig.fewRuns ? `held-out: only ${sig.n} paired runs (< ${minProductiveRuns}) \u2014 too few to claim significance` : `held-out CI.low ${sig.bootstrap.low.toFixed(3)} \u2264 threshold ${deltaThreshold} (${heldoutStatistic} \u0394 ${delta.toFixed(3)}, ${(sig.bootstrap.confidence * 100).toFixed(0)}% CI [${sig.bootstrap.low.toFixed(3)}, ${sig.bootstrap.high.toFixed(3)}]${tieNote})`
+          );
+        }
+      }
+      const dimensionsProvided = options.criticalDimensions !== void 0;
+      const criticalDimensions = [...new Set(options.criticalDimensions ?? [])];
+      const dimensionsRequired = dimensionsProvided || explicitlyRequired.has("dimension-regression");
+      if (!dimensionsProvided) {
+        unavailable(
+          "dimension-regression",
+          dimensionsRequired,
+          "criticalDimensions is not configured"
+        );
+      } else if (criticalDimensions.length === 0) {
+        unavailable(
+          "dimension-regression",
+          true,
+          "criticalDimensions must contain at least one dimension"
+        );
+      } else if (!ctx.baselineJudgeScores) {
+        unavailable(
+          "dimension-regression",
+          true,
+          "baselineJudgeScores is required to measure dimension regressions",
+          { guarded: criticalDimensions }
+        );
+      } else {
+        const dimRegs = dimensionRegressions(
           ctx.judgeScores,
-          ctx.baselineJudgeScores ?? ctx.judgeScores,
+          ctx.baselineJudgeScores,
           scenarioIds,
-          (s) => s.composite
-        ),
-        {
-          deltaThreshold,
-          minProductiveRuns,
-          confidence,
-          resamples,
-          seed,
-          statistic: heldoutStatistic
+          criticalDimensions,
+          { tolerance: options.regressionTolerance, confidence, resamples, seed }
+        );
+        const measured = new Set(dimRegs.map((result) => result.dimension));
+        const missingDimensions = criticalDimensions.filter((dimension) => !measured.has(dimension));
+        const regressed = dimRegs.filter((result) => result.regressed);
+        const dimensionStatus = regressed.length > 0 ? "fail" : missingDimensions.length > 0 ? "not_evaluated" : "pass";
+        contributing.push({
+          name: "dimension-regression",
+          status: dimensionStatus,
+          detail: {
+            guarded: criticalDimensions,
+            missingDimensions,
+            regressions: dimRegs.map((result) => ({
+              dimension: result.dimension,
+              ciLow: result.bootstrap.low,
+              median: result.bootstrap.median,
+              tolerance: result.tolerance,
+              n: result.n,
+              regressed: result.regressed
+            }))
+          }
+        });
+        if (missingDimensions.length > 0) {
+          requiredUnavailable.add("dimension-regression");
+          reasons.push(`critical dimension(s) were not scored: ${missingDimensions.join(", ")}`);
         }
-      );
-      const delta = heldoutStatistic === "median" ? sig.bootstrap.median : sig.bootstrap.mean;
-      const heldoutPass = sig.significant;
-      contributing.push({
-        name: "heldout-significance",
-        passed: heldoutPass,
-        detail: {
-          n: sig.n,
-          delta,
-          deltaMean: sig.bootstrap.mean,
-          deltaMedianDiagnostic: sig.medianBootstrap.median,
-          // Back-compat: prior consumers read `deltaMedian`. It now always carries
-          // the median diagnostic (the ship decision keys on `delta`/mean).
-          deltaMedian: sig.medianBootstrap.median,
-          tieFraction: sig.tieFraction,
-          ciLow: sig.bootstrap.low,
-          ciHigh: sig.bootstrap.high,
-          confidence: sig.bootstrap.confidence,
-          deltaThreshold,
-          fewRuns: sig.fewRuns
+        if (regressed.length > 0) {
+          reasons.push(
+            `critical dimension(s) regressed: ${regressed.map((result) => `${result.dimension} CI.low ${result.bootstrap.low.toFixed(3)} < -${result.tolerance}`).join("; ")}`
+          );
         }
-      });
-      if (!heldoutPass) {
-        const tieNote = sig.tieFraction >= TIE_WARN_FRACTION ? `; ${(sig.tieFraction * 100).toFixed(0)}% tied scenarios` : "";
-        reasons.push(
-          sig.fewRuns ? `held-out: only ${sig.n} paired runs (< ${minProductiveRuns}) \u2014 too few to claim significance` : `held-out CI.low ${sig.bootstrap.low.toFixed(3)} \u2264 threshold ${deltaThreshold} (${heldoutStatistic} \u0394 ${delta.toFixed(3)}, ${(sig.bootstrap.confidence * 100).toFixed(0)}% CI [${sig.bootstrap.low.toFixed(3)}, ${sig.bootstrap.high.toFixed(3)}]${tieNote})`
-        );
       }
-      const dimRegs = options.criticalDimensions?.length ? dimensionRegressions(
-        ctx.judgeScores,
-        ctx.baselineJudgeScores ?? ctx.judgeScores,
-        scenarioIds,
-        options.criticalDimensions,
-        { tolerance: options.regressionTolerance, confidence, resamples, seed }
-      ) : [];
-      const regressed = dimRegs.filter((d) => d.regressed);
-      const dimPass = regressed.length === 0;
-      contributing.push({
-        name: "dimension-regression",
-        passed: dimPass,
-        detail: {
-          guarded: options.criticalDimensions ?? [],
-          regressions: dimRegs.map((d) => ({
-            dimension: d.dimension,
-            ciLow: d.bootstrap.low,
-            median: d.bootstrap.median,
-            tolerance: d.tolerance,
-            n: d.n,
-            regressed: d.regressed
-          }))
+      const budgetUsd = options.budgetUsd;
+      const budgetConfigured = budgetUsd !== void 0;
+      const budgetRequired = budgetConfigured || explicitlyRequired.has("budget");
+      if (!budgetConfigured) {
+        unavailable("budget", budgetRequired, "budgetUsd is not configured");
+      } else if (!ctx.costLedger) {
+        unavailable("budget", true, "costLedger is required to measure complete run spend", {
+          budgetUsd
+        });
+      } else {
+        const cost = ctx.costLedger.summary();
+        const accountingComplete = cost.accountingComplete && cost.pendingCalls === 0 && cost.unresolvedCalls === 0;
+        const budgetPass = cost.totalCostUsd <= budgetUsd;
+        contributing.push({
+          name: "budget",
+          status: !accountingComplete ? "not_evaluated" : budgetPass ? "pass" : "fail",
+          detail: {
+            totalCostUsd: cost.totalCostUsd,
+            budgetUsd,
+            accountingComplete,
+            pendingCalls: cost.pendingCalls,
+            unresolvedCalls: cost.unresolvedCalls
+          }
+        });
+        if (!accountingComplete) {
+          requiredUnavailable.add("budget");
+          reasons.push("budget: cost accounting is incomplete");
+        } else if (!budgetPass) {
+          reasons.push(`spend ${cost.totalCostUsd.toFixed(2)} > budget ${budgetUsd}`);
         }
-      });
-      if (!dimPass) {
-        reasons.push(
-          `critical dimension(s) regressed: ${regressed.map((d) => `${d.dimension} CI.low ${d.bootstrap.low.toFixed(3)} < -${d.tolerance}`).join("; ")}`
-        );
       }
-      const budgetPass = options.budgetUsd === void 0 || ctx.cost.candidate + ctx.cost.baseline <= options.budgetUsd;
-      contributing.push({
-        name: "budget",
-        passed: budgetPass,
-        detail: {
-          candidateUsd: ctx.cost.candidate,
-          baselineUsd: ctx.cost.baseline,
-          ...options.budgetUsd === void 0 ? {} : { budgetUsd: options.budgetUsd }
+      const redTeamConfigured = options.redTeamBattery !== void 0;
+      const redTeamRequired = redTeamConfigured || explicitlyRequired.has("red-team");
+      if (!options.redTeamBattery) {
+        unavailable("red-team", redTeamRequired, "redTeamBattery is not configured");
+      } else if (options.redTeamBattery.length === 0) {
+        unavailable("red-team", true, "redTeamBattery must contain at least one case");
+      } else {
+        const redTeam = probeRedTeam(ctx.candidateArtifacts, options.redTeamBattery);
+        const incomplete = redTeam.unsupportedCases.length > 0 || redTeam.unscoredArtifacts.length > 0 || redTeam.evaluatedCases === 0;
+        const redTeamStatus = redTeam.findings.length > 0 ? "fail" : incomplete ? "not_evaluated" : "pass";
+        contributing.push({
+          name: "red-team",
+          status: redTeamStatus,
+          detail: {
+            evaluatedCases: redTeam.evaluatedCases,
+            unsupportedCases: redTeam.unsupportedCases,
+            unscoredArtifacts: redTeam.unscoredArtifacts,
+            failures: redTeam.findings.length,
+            sample: redTeam.findings.slice(0, 3)
+          }
+        });
+        if (incomplete) {
+          requiredUnavailable.add("red-team");
         }
-      });
-      if (!budgetPass) {
-        reasons.push(
-          `spend ${(ctx.cost.candidate + ctx.cost.baseline).toFixed(2)} > budget ${options.budgetUsd}`
-        );
-      }
-      const redTeamFindings = options.redTeamBattery ? probeRedTeam(ctx.candidateArtifacts, options.redTeamBattery) : { passed: true, findings: [] };
-      contributing.push({
-        name: "red-team",
-        passed: redTeamFindings.passed,
-        detail: {
-          failures: redTeamFindings.findings.length,
-          sample: redTeamFindings.findings.slice(0, 3)
+        if (redTeam.unsupportedCases.length > 0) {
+          reasons.push(
+            `red-team: static artifact screening cannot evaluate case(s): ${redTeam.unsupportedCases.join(", ")}`
+          );
+        }
+        if (redTeam.unscoredArtifacts.length > 0) {
+          reasons.push(
+            `red-team: no text could be extracted from artifact(s): ${redTeam.unscoredArtifacts.join(", ")}`
+          );
+        }
+        if (redTeam.evaluatedCases === 0) {
+          reasons.push("red-team: no artifact/case pair was evaluated");
+        }
+        if (redTeam.findings.length > 0) {
+          reasons.push(`red-team probe failed (${redTeam.findings.length} findings)`);
         }
-      });
-      if (!redTeamFindings.passed) {
-        reasons.push(`red-team probe failed (${redTeamFindings.findings.length} findings)`);
-      }
-      let rewardHackingReport = null;
-      if (options.recentRuns && options.recentRuns.length >= 10) {
-        rewardHackingReport = detectRewardHacking({ runs: options.recentRuns });
       }
-      const gamingThreshold = 0.6;
-      const gamingFindings = (rewardHackingReport?.findings ?? []).filter(
-        (f) => f.severity >= gamingThreshold
-      );
-      const rewardHackingPass = !rewardHackingReport || !blockOnGaming || gamingFindings.length === 0 && rewardHackingReport.verdict !== "gaming";
-      contributing.push({
-        name: "reward-hacking",
-        passed: rewardHackingPass,
-        detail: { report: rewardHackingReport, gamingFindingCount: gamingFindings.length }
-      });
-      if (!rewardHackingPass) {
-        reasons.push(
-          `reward-hacking detector flagged ${gamingFindings.length} gaming-severity findings (verdict=${rewardHackingReport.verdict})`
+      const rewardHacking = options.rewardHacking;
+      const rewardHackingConfigured = rewardHacking !== void 0;
+      const rewardHackingRequired = rewardHackingConfigured || explicitlyRequired.has("reward-hacking");
+      if (!rewardHackingConfigured) {
+        unavailable("reward-hacking", rewardHackingRequired, "rewardHacking is not configured");
+      } else if (!options.recentRuns) {
+        unavailable("reward-hacking", rewardHackingRequired, "recentRuns is not configured");
+      } else if (options.recentRuns.length < 10) {
+        unavailable(
+          "reward-hacking",
+          rewardHackingRequired,
+          `recentRuns has ${options.recentRuns.length} record(s); at least 10 are required`
         );
+      } else {
+        const rewardHackingReport = detectRewardHacking({
+          runs: options.recentRuns,
+          ...rewardHacking
+        });
+        if (!rewardHackingReport.evaluatedSignals.includes("reward_divergence")) {
+          unavailable(
+            "reward-hacking",
+            true,
+            "independent proxy/truth evidence is insufficient to evaluate reward divergence",
+            { report: rewardHackingReport }
+          );
+        } else {
+          const gamingThreshold = rewardHacking.thresholds?.gaming ?? 0.6;
+          const gamingFindings = rewardHackingReport.findings.filter(
+            (finding) => finding.severity >= gamingThreshold
+          );
+          const rewardHackingPass = gamingFindings.length === 0 && rewardHackingReport.verdict !== "gaming";
+          contributing.push({
+            name: "reward-hacking",
+            status: rewardHackingPass ? "pass" : "fail",
+            detail: { report: rewardHackingReport, gamingFindingCount: gamingFindings.length }
+          });
+          if (!rewardHackingPass) {
+            reasons.push(
+              `reward-hacking detector flagged ${gamingFindings.length} gaming-severity findings (verdict=${rewardHackingReport.verdict})`
+            );
+          }
+        }
       }
-      let canaryReport = null;
-      if (options.recentRuns && options.recentRuns.length >= 10) {
-        canaryReport = runCanaries(options.recentRuns, {});
-      }
-      const errorAlerts = (canaryReport?.alerts ?? []).filter((a) => a.severity === "error");
-      const canaryPass = errorAlerts.length === 0;
-      contributing.push({
-        name: "canary",
-        passed: canaryPass,
-        detail: { totalAlerts: canaryReport?.alerts.length ?? 0, errorAlerts: errorAlerts.length }
-      });
-      if (!canaryPass) {
-        reasons.push(`canary error alerts: ${errorAlerts.length}`);
+      const canary = options.canary;
+      const canaryConfigured = canary !== void 0;
+      const canaryRequired = canaryConfigured || explicitlyRequired.has("canary");
+      if (!canaryConfigured && !canaryRequired) {
+        unavailable("canary", false, "canary is not configured");
+      } else if (!options.recentRuns) {
+        unavailable("canary", canaryRequired, "recentRuns is not configured");
+      } else {
+        const canaryReport = runCanaries(options.recentRuns, canary ?? {});
+        const incomplete = canaryReport.evaluations.filter(
+          (evaluation) => evaluation.status === "not_evaluated"
+        );
+        if (incomplete.length > 0) {
+          unavailable(
+            "canary",
+            true,
+            `insufficient evidence for: ${incomplete.map((evaluation) => evaluation.kind).join(", ")}`,
+            { report: canaryReport }
+          );
+        } else {
+          const errorAlerts = canaryReport.alerts.filter((alert) => alert.severity === "error");
+          const canaryPass = errorAlerts.length === 0;
+          contributing.push({
+            name: "canary",
+            status: canaryPass ? "pass" : "fail",
+            detail: {
+              totalAlerts: canaryReport.alerts.length,
+              errorAlerts: errorAlerts.length,
+              report: canaryReport
+            }
+          });
+          if (!canaryPass) {
+            reasons.push(`canary error alerts: ${errorAlerts.length}`);
+          }
+        }
       }
-      const allPassed = contributing.every((c) => c.passed);
-      const decision = allPassed ? "ship" : "hold";
+      const decision = contributing.some((check) => check.status === "fail") || requiredUnavailable.size > 0 ? "hold" : "ship";
+      const notEvaluated = contributing.filter((check) => check.status === "not_evaluated").map((check) => check.name);
       return {
         decision,
-        reasons: reasons.length > 0 ? reasons : ["all gates passed"],
+        reasons: reasons.length > 0 ? reasons : notEvaluated.length > 0 ? [`evaluated checks passed; not evaluated: ${notEvaluated.join(", ")}`] : ["all checks passed"],
         contributingGates: contributing,
         delta
       };
@@ -4706,18 +4926,32 @@ function defaultProductionGate(options) {
   };
 }
 function probeRedTeam(artifacts, battery) {
+  const supportedCases = battery.filter(
+    (testCase) => testCase.payload.expected === "ignore" && !testCase.payload.forbiddenTools?.length
+  );
+  const unsupportedCases = battery.filter((testCase) => !supportedCases.includes(testCase)).map((testCase) => testCase.id);
   const findings = [];
-  for (const [_cellId, artifact] of artifacts) {
+  const unscoredArtifacts = [];
+  let evaluatedCases = 0;
+  for (const [cellId, artifact] of artifacts) {
     const text = extractText(artifact);
-    if (text === void 0) continue;
-    for (const rtCase of battery) {
+    if (text === void 0) {
+      unscoredArtifacts.push(cellId);
+      continue;
+    }
+    for (const rtCase of supportedCases) {
+      evaluatedCases += 1;
       const finding = scoreRedTeamOutput(text, [], rtCase);
       if (!finding.passed) {
-        findings.push({ scenarioId: rtCase.id, reason: finding.reason ?? "red-team probe failed" });
+        findings.push({
+          cellId,
+          scenarioId: rtCase.id,
+          reason: finding.reason ?? "red-team probe failed"
+        });
       }
     }
   }
-  return { passed: findings.length === 0, findings };
+  return { evaluatedCases, findings, unsupportedCases, unscoredArtifacts };
 }
 function extractText(artifact) {
   if (typeof artifact === "string") return artifact;
@@ -4758,6 +4992,7 @@ function heldOutGate(options) {
       );
       const delta = sig.bootstrap.mean;
       const passed = sig.significant;
+      const status = sig.fewRuns ? "not_evaluated" : passed ? "pass" : "fail";
       const tieNote = sig.tieFraction >= TIE_WARN_FRACTION ? `, ${(sig.tieFraction * 100).toFixed(0)}% tied` : "";
       const ci = `${(sig.bootstrap.confidence * 100).toFixed(0)}% CI [${sig.bootstrap.low.toFixed(3)}, ${sig.bootstrap.high.toFixed(3)}]`;
       return {
@@ -4770,7 +5005,7 @@ function heldOutGate(options) {
         contributingGates: [
           {
             name: "heldOutGate",
-            passed,
+            status,
             detail: {
               deltaMean: delta,
               deltaMedianDiagnostic: sig.medianBootstrap.median,
@@ -4885,7 +5120,7 @@ function buildEvidenceVector(ctx, objectives, opts = {}) {
 var paretoPolicy = (ev) => {
   const contributingGates = ev.axes.map((ax) => ({
     name: `objective:${ax.name}`,
-    passed: ax.verdict === "improved",
+    status: ax.verdict === "regressed" ? "fail" : ax.verdict === "few_runs" ? "not_evaluated" : "pass",
     detail: {
       direction: ax.direction,
       source: ax.source,
@@ -5871,19 +6106,21 @@ async function runOptimization(opts) {
           dispatch: (scenario, ctx) => opts.dispatchWithSurface(surface, scenario, ctx),
           runDir: `${opts.runDir}/gen-${gen}/candidate-${i}`
         });
-        const composite = campaignMeanComposite(campaign);
-        const rankKey = selectionRankKey(campaign);
-        assertFiniteRankKey(
-          rankKey,
-          `selectionRankKey for generation ${gen} candidate ${i}`,
-          winnerRankKey.length
-        );
         const coverage = campaignCoverage(
           campaign.cells,
           opts.scenarios,
           opts.reps ?? 1,
           requireJudgeScore
         );
+        const composite = campaignMeanCompositeOrNull(campaign);
+        const rankKey = coverage.complete ? selectionRankKey(campaign) : null;
+        if (rankKey) {
+          assertFiniteRankKey(
+            rankKey,
+            `selectionRankKey for generation ${gen} candidate ${i}`,
+            winnerRankKey.length
+          );
+        }
         return {
           surfaceHash: hash,
           surface,
@@ -5906,9 +6143,12 @@ async function runOptimization(opts) {
     }
     surfaceResults.sort((a, b) => {
       if (a.coverage.complete !== b.coverage.complete) return a.coverage.complete ? -1 : 1;
-      return compareRankKeys(b.rankKey, a.rankKey);
+      if (a.rankKey && b.rankKey) return compareRankKeys(b.rankKey, a.rankKey);
+      return a.surfaceHash.localeCompare(b.surfaceHash);
     });
-    const eligibleResults = surfaceResults.filter((result) => result.coverage.complete);
+    const eligibleResults = surfaceResults.filter(
+      (result) => result.coverage.complete && result.composite !== null && result.rankKey !== null
+    );
     const top = eligibleResults[0];
     const promoted = top && compareRankKeys(top.rankKey, winnerRankKey) > 0 ? [top] : [];
     if (promoted[0]) {
@@ -5928,7 +6168,7 @@ async function runOptimization(opts) {
         const candidate = {
           surfaceHash: s.surfaceHash,
           composite: s.composite,
-          ci95: [s.composite, s.composite],
+          ci95: s.composite === null ? null : [s.composite, s.composite],
           parentSurfaceHash,
           parentComposite,
           ...s.coverage.complete ? { observedDeltaFromParent: s.composite - parentComposite } : {},
@@ -6109,7 +6349,7 @@ async function runImprovementLoop(opts) {
   const dispatchTimeoutMs = opts.dispatchTimeoutMs ?? DEFAULT_DISPATCH_TIMEOUT_MS;
   const optimization = await runOptimization({ ...opts, dispatchTimeoutMs, costLedger });
   const winnerIsBaseline = optimization.winnerSurfaceHash === surfaceHash(opts.baselineSurface);
-  const { runCampaign: runCampaign2 } = await import("./run-campaign-FFRM3RH5.js");
+  const { runCampaign: runCampaign2 } = await import("./run-campaign-3A2EBYBE.js");
   const holdoutDeferred = (opts.holdout ?? "measured") === "deferred";
   const baselineOnHoldout = holdoutDeferred ? await runCampaign2({
     ...opts,
@@ -6200,7 +6440,11 @@ async function runImprovementLoop(opts) {
       "holdout deferred \u2014 improvement-set search completed without a held-out measurement; nothing to promote from this run"
     ],
     contributingGates: [
-      { name: "holdout-deferred", passed: false, detail: { holdout: "deferred" } }
+      {
+        name: "holdout-deferred",
+        status: "not_evaluated",
+        detail: { holdout: "deferred" }
+      }
     ]
   } : winnerIsBaseline ? {
     decision: "hold",
@@ -6208,7 +6452,7 @@ async function runImprovementLoop(opts) {
       "no candidate beat the training baseline \u2014 winner == baseline (empty diff); nothing to promote"
     ],
     contributingGates: [
-      { name: "no-op-guard", passed: false, detail: { winnerIsBaseline: true } }
+      { name: "no-op-guard", status: "fail", detail: { winnerIsBaseline: true } }
     ],
     delta: 0
   } : await opts.gate.decide({
@@ -6289,13 +6533,7 @@ function loopProvenanceArgsFromResult(input) {
   };
 }
 function meanHoldoutComposite(campaign) {
-  const xs = [];
-  for (const cell of campaign.cells) {
-    if (cell.error) continue;
-    const cs = Object.values(cell.judgeScores).map((s) => s.composite);
-    if (cs.length) xs.push(cs.reduce((a, b) => a + b, 0) / cs.length);
-  }
-  return xs.length ? xs.reduce((a, b) => a + b, 0) / xs.length : 0;
+  return campaignMeanComposite(campaign);
 }
 function buildLoopProvenanceRecord(args) {
   if (!args.runId.trim() || !args.runDir.trim()) {
@@ -6305,6 +6543,7 @@ function buildLoopProvenanceRecord(args) {
   if (!Number.isFinite(timestampMs) || new Date(timestampMs).toISOString() !== args.timestamp) {
     throw new Error("buildLoopProvenanceRecord: timestamp must be a canonical ISO instant");
   }
+  assertGateContributions(args.gate.contributingGates, "buildLoopProvenanceRecord");
   const agentReceipts = args.costReceipts.filter((receipt) => receipt.channel === "agent");
   const integrity = summarizeAgentReceiptIntegrity(agentReceipts);
   const models = [...new Set(agentReceipts.map((receipt) => receipt.model))].sort();
@@ -6401,6 +6640,9 @@ function buildLoopProvenanceRecord(args) {
     if (promotedHash) {
       const promoted = candidateByHash.get(promotedHash);
       incumbentSurfaceHash = promoted.surfaceHash;
+      if (promoted.composite === null) {
+        throw new Error("buildLoopProvenanceRecord: promoted candidate is missing a composite");
+      }
       incumbentComposite = promoted.composite;
     }
   }
@@ -6410,8 +6652,6 @@ function buildLoopProvenanceRecord(args) {
     );
   }
   const holdoutDeferred = args.holdout === "deferred";
-  const baselineHoldoutComposite = meanHoldoutComposite(args.baselineOnHoldout);
-  const winnerHoldoutComposite = meanHoldoutComposite(args.winnerOnHoldout);
   if (args.baselineOnHoldout.splitDigest !== args.winnerOnHoldout.splitDigest) {
     throw new Error("buildLoopProvenanceRecord: baseline and winner use different holdout splits");
   }
@@ -6425,7 +6665,17 @@ function buildLoopProvenanceRecord(args) {
       "buildLoopProvenanceRecord: neutralized campaign uses a different holdout split"
     );
   }
-  const neutralizedComposite = args.neutralizedOnHoldout ? meanHoldoutComposite(args.neutralizedOnHoldout) : void 0;
+  if (holdoutDeferred && args.neutralizedOnHoldout) {
+    throw new Error(
+      "buildLoopProvenanceRecord: a deferred holdout cannot include a neutralized measurement"
+    );
+  }
+  const holdoutMeasurement = holdoutDeferred ? { kind: "deferred" } : {
+    kind: "measured",
+    baseline: meanHoldoutComposite(args.baselineOnHoldout),
+    winner: meanHoldoutComposite(args.winnerOnHoldout),
+    ...args.neutralizedOnHoldout ? { neutralized: meanHoldoutComposite(args.neutralizedOnHoldout) } : {}
+  };
   const diff = surfaceContentHash(args.baselineSurface) === surfaceContentHash(args.winnerSurface) ? "" : renderSurfaceDiff(args.winnerSurface, args.baselineSurface);
   const recordWithoutDigest = {
     schema: "tangle.loop-provenance",
@@ -6445,12 +6695,12 @@ function buildLoopProvenanceRecord(args) {
         splitDigest: args.baselineOnHoldout.splitDigest,
         baselineCampaignDigest: campaignMeasurementDigest(args.baselineOnHoldout),
         winnerCampaignDigest: campaignMeasurementDigest(args.winnerOnHoldout),
-        ...args.neutralizedSurface && args.neutralizedOnHoldout && neutralizedComposite !== void 0 ? {
+        ...args.neutralizedSurface && args.neutralizedOnHoldout && holdoutMeasurement.kind === "measured" && holdoutMeasurement.neutralized !== void 0 ? {
           neutralized: {
             contentHash: surfaceContentHash(args.neutralizedSurface),
             campaignDigest: campaignMeasurementDigest(args.neutralizedOnHoldout),
-            composite: neutralizedComposite,
-            lift: neutralizedComposite - baselineHoldoutComposite
+            composite: holdoutMeasurement.neutralized,
+            lift: holdoutMeasurement.neutralized - holdoutMeasurement.baseline
           }
         } : {}
       },
@@ -6465,16 +6715,16 @@ function buildLoopProvenanceRecord(args) {
       delta: args.gate.delta,
       contributingGates: args.gate.contributingGates.map((g) => ({
         name: g.name,
-        passed: g.passed,
+        status: g.status,
         detail: durableGateDetail(g.detail)
       }))
     },
     // Deferred holdout records the MODE, never a fabricated 0-lift: the
     // held-out comparison intentionally did not run in this loop.
-    ...holdoutDeferred ? { holdout: "deferred" } : {
-      baselineHoldoutComposite,
-      winnerHoldoutComposite,
-      heldOutLift: winnerHoldoutComposite - baselineHoldoutComposite
+    ...holdoutMeasurement.kind === "deferred" ? { holdout: "deferred" } : {
+      baselineHoldoutComposite: holdoutMeasurement.baseline,
+      winnerHoldoutComposite: holdoutMeasurement.winner,
+      heldOutLift: holdoutMeasurement.winner - holdoutMeasurement.baseline
     },
     backend: {
       verdict: integrity.verdict,
@@ -6540,6 +6790,8 @@ function campaignMeasurementDigest(campaign) {
       durationMs: cell.durationMs,
       seed: cell.seed,
       cached: cell.cached,
+      errorStage: cell.errorStage ?? null,
+      errorJudge: cell.errorJudge ?? null,
       error: cell.error ?? null
     }))
   });
@@ -6552,6 +6804,7 @@ function verifyLoopProvenanceRecord(record) {
   if (recordDigest !== canonicalDigest(recordWithoutDigest)) {
     throw new Error("loop provenance record digest does not match its contents");
   }
+  assertGateContributions(record.gate?.contributingGates, "loop provenance");
   return record;
 }
 function canonicalDigest(value) {
@@ -6583,10 +6836,32 @@ function durableGateDetail(detail) {
     });
   }
 }
-function validateCandidateMeasurement(candidate, expectedParentHash, expectedParentComposite, promoted) {
-  if (!Number.isFinite(candidate.composite)) {
-    throw new Error("buildLoopProvenanceRecord: candidate composite must be finite");
+function assertGateContributions(value, source) {
+  if (!Array.isArray(value)) {
+    throw new Error(`${source}: gate contributingGates must be an array`);
   }
+  const statuses = /* @__PURE__ */ new Set(["pass", "fail", "not_evaluated"]);
+  for (const [index, contribution] of value.entries()) {
+    if (!contribution || typeof contribution !== "object") {
+      throw new Error(`${source}: gate contribution ${index} must be an object`);
+    }
+    const item = contribution;
+    if (typeof item.name !== "string" || item.name.length === 0) {
+      throw new Error(`${source}: gate contribution ${index} must have a non-empty name`);
+    }
+    if (!statuses.has(String(item.status))) {
+      throw new Error(
+        `${source}: gate contribution '${item.name}' must have status pass, fail, or not_evaluated`
+      );
+    }
+    if ("passed" in item) {
+      throw new Error(
+        `${source}: gate contribution '${item.name}' uses obsolete passed; use status instead`
+      );
+    }
+  }
+}
+function validateCandidateMeasurement(candidate, expectedParentHash, expectedParentComposite, promoted) {
   if (!candidate.parentSurfaceHash || !/^[a-f0-9]{16}$/.test(candidate.parentSurfaceHash)) {
     throw new Error(
       "buildLoopProvenanceRecord: parentSurfaceHash must be 16 lowercase hex characters"
@@ -6600,11 +6875,6 @@ function validateCandidateMeasurement(candidate, expectedParentHash, expectedPar
       "buildLoopProvenanceRecord: candidate parentComposite does not match the incumbent"
     );
   }
-  if (candidate.eligibleForPromotion === void 0 || !candidate.coverage) {
-    throw new Error(
-      "buildLoopProvenanceRecord: candidate measurement requires eligibility and coverage"
-    );
-  }
   if (candidate.observedDeltaFromParent !== void 0) {
     if (!Number.isFinite(candidate.observedDeltaFromParent)) {
       throw new Error("buildLoopProvenanceRecord: observedDeltaFromParent must be finite");
@@ -6632,12 +6902,15 @@ function validateCandidateMeasurement(candidate, expectedParentHash, expectedPar
     );
   }
   const complete = coverage.scorableCells === coverage.expectedCells && coverage.unscorableCells.length === 0;
-  if (candidate.eligibleForPromotion !== void 0 && candidate.eligibleForPromotion !== complete) {
+  if (candidate.eligibleForPromotion !== complete) {
     throw new Error(
       "buildLoopProvenanceRecord: candidate eligibility contradicts its coverage receipt"
     );
   }
   if (complete) {
+    if (candidate.composite === null || !Number.isFinite(candidate.composite)) {
+      throw new Error("buildLoopProvenanceRecord: complete candidate composite must be finite");
+    }
     if (candidate.observedDeltaFromParent === void 0) {
       throw new Error(
         "buildLoopProvenanceRecord: complete candidate is missing observedDeltaFromParent"
@@ -6647,24 +6920,34 @@ function validateCandidateMeasurement(candidate, expectedParentHash, expectedPar
     if (Math.abs(candidate.observedDeltaFromParent - recomputed) > 1e-12) {
       throw new Error("buildLoopProvenanceRecord: observed delta does not match measured scores");
     }
-  } else if (candidate.observedDeltaFromParent !== void 0) {
-    throw new Error("buildLoopProvenanceRecord: incomplete candidate cannot carry observed delta");
+  } else {
+    if (candidate.composite !== null && !Number.isFinite(candidate.composite)) {
+      throw new Error("buildLoopProvenanceRecord: candidate composite must be finite or null");
+    }
+    if (candidate.observedDeltaFromParent !== void 0) {
+      throw new Error("buildLoopProvenanceRecord: incomplete candidate cannot carry observed delta");
+    }
   }
   if (promoted && (!complete || (candidate.observedDeltaFromParent ?? 0) <= 0)) {
     throw new Error("buildLoopProvenanceRecord: promoted candidate must improve the incumbent");
   }
 }
-var DECISION_OK = ["ship"];
 function hashId(parts) {
   return createHash2("sha256").update(parts.join(":")).digest("hex");
 }
-function gateStatus(decision) {
-  return DECISION_OK.includes(decision) ? { code: "OK" } : { code: "ERROR", message: `gate decision: ${decision}` };
-}
 function loopProvenanceSpans(record, opts = {}) {
   const traceId = hashId(["trace", record.runId]).slice(0, 32);
-  const baseNano = (opts.baseTimeMs ?? (Date.parse(record.timestamp) || Date.now())) * 1e6;
-  const endNano = baseNano + Math.max(1, record.totalDurationMs) * 1e6;
+  const baseTimeMs = opts.baseTimeMs ?? (Date.parse(record.timestamp) || Date.now());
+  const durationMs = Math.max(1, record.totalDurationMs);
+  if (!Number.isSafeInteger(baseTimeMs) || baseTimeMs < 0) {
+    throw new RangeError("loop provenance baseTimeMs must be a non-negative safe integer");
+  }
+  if (!Number.isSafeInteger(durationMs)) {
+    throw new RangeError("loop provenance duration must be a safe integer number of milliseconds");
+  }
+  const baseTime = BigInt(baseTimeMs);
+  const baseNano = (baseTime * 1000000n).toString();
+  const endNano = ((baseTime + BigInt(durationMs)) * 1000000n).toString();
   const spans = [];
   const rootSpanId = hashId(["root", record.runId]).slice(0, 16);
   const rootAttributes = {
@@ -6687,7 +6970,7 @@ function loopProvenanceSpans(record, opts = {}) {
     startTimeUnixNano: baseNano,
     endTimeUnixNano: endNano,
     attributes: rootAttributes,
-    status: gateStatus(record.gate.decision),
+    status: { code: "OK" },
     "tangle.runId": record.runId
   });
   const byGen = /* @__PURE__ */ new Map();
@@ -6698,7 +6981,9 @@ function loopProvenanceSpans(record, opts = {}) {
   }
   for (const [generation, cands] of [...byGen.entries()].sort((a, b) => a[0] - b[0])) {
     const genSpanId = hashId(["gen", record.runId, String(generation)]).slice(0, 16);
-    const bestComposite = Math.max(...cands.map((candidate) => candidate.composite));
+    const measuredComposites = cands.flatMap(
+      (candidate) => candidate.composite === null ? [] : [candidate.composite]
+    );
     spans.push({
       traceId,
       spanId: genSpanId,
@@ -6710,7 +6995,7 @@ function loopProvenanceSpans(record, opts = {}) {
         "tangle.runId": record.runId,
         "tangle.generation": generation,
         "tangle.populationSize": cands.length,
-        "tangle.bestComposite": bestComposite
+        ...measuredComposites.length > 0 ? { "tangle.bestComposite": Math.max(...measuredComposites) } : {}
       },
       "tangle.runId": record.runId,
       "tangle.generation": generation
@@ -6728,13 +7013,13 @@ function loopProvenanceSpans(record, opts = {}) {
         "tangle.contentHash": c.contentHash,
         "tangle.parentSurfaceHash": c.parentSurfaceHash,
         "tangle.parentComposite": c.parentComposite,
-        "tangle.composite": c.composite,
         "tangle.eligibleForPromotion": c.eligibleForPromotion,
         "tangle.expectedCells": c.coverage.expectedCells,
         "tangle.scorableCells": c.coverage.scorableCells,
         "tangle.unscorableCells": c.coverage.unscorableCells.length,
         "tangle.promoted": c.promoted
       };
+      if (c.composite !== null) attributes["tangle.composite"] = c.composite;
       if (c.observedDeltaFromParent !== void 0) {
         attributes["tangle.observedDeltaFromParent"] = c.observedDeltaFromParent;
       }
@@ -6777,7 +7062,7 @@ function loopProvenanceSpans(record, opts = {}) {
     startTimeUnixNano: endNano,
     endTimeUnixNano: endNano,
     attributes: gateAttributes,
-    status: gateStatus(record.gate.decision),
+    status: { code: "OK" },
     "tangle.runId": record.runId
   });
   return spans;
@@ -6790,26 +7075,25 @@ function provenanceSpansPath(runDir) {
 }
 function snapshotFromHoldout(index, surfaceHash2, surface, campaign) {
   const cells = campaign.cells.map((cell) => {
-    const judgeScores = Object.values(cell.judgeScores);
-    const composite = judgeScores.length === 0 ? 0 : judgeScores.reduce((s, j) => s + j.composite, 0) / judgeScores.length;
+    const execution = campaignCellExecutionEvidence(cell);
+    const quality = projectCampaignCellQuality(cell);
     const score = {
       scenarioId: cell.scenarioId,
       rep: cell.rep,
-      compositeMean: composite,
-      dimensions: Object.fromEntries(
-        Object.entries(cell.judgeScores).map(([name, s]) => [name, s.dimensions])
-      )
+      compositeMean: quality.score ?? null,
+      dimensions: quality.judgeScores?.perJudge ?? {},
+      terminalOutcome: execution.terminalOutcome,
+      executionErrorCount: execution.executionErrorCount ?? null
     };
     if (cell.error) score.errorMessage = cell.error;
     return score;
   });
-  const compositeMean = cells.length === 0 ? 0 : cells.reduce((s, c) => s + c.compositeMean, 0) / cells.length;
   return {
     index,
     surfaceHash: surfaceHash2,
     surface,
     cells,
-    compositeMean,
+    compositeMean: campaignMeanCompositeOrNull(campaign),
     costUsd: campaign.aggregates.totalCostUsd,
     durationMs: campaign.durationMs
   };
@@ -7346,4 +7630,4 @@ export {
   emitLoopProvenance,
   skillOptOptimizationMethod
 };
-//# sourceMappingURL=chunk-BTACVO2W.js.map
+//# sourceMappingURL=chunk-65QETEKG.js.map