@tangle-network/agent-eval 0.126.7 → 0.128.0

package/dist/{chunk-K6IAZZ6L.js → chunk-NACAGYSY.js}

@@ -1,25 +1,25 @@
-import {
-  summarizeBackendIntegrity
-} from "./chunk-ZVCHKKOP.js";
 import {
   paretoChart
-} from "./chunk-DPZAEKA6.js";
+} from "./chunk-VLOATJQ2.js";
+import {
+  pairRunRecords
+} from "./chunk-DPUHNQLN.js";
 import {
-  cohensD,
   continuousAgreement,
   pairedBootstrap,
+  pairedCohensDz,
   pairedMde,
   pairedTTest,
   pearsonR,
-  requiredSampleSize,
+  requiredPairedSampleSize,
   spearmanR
-} from "./chunk-PJQFMIOX.js";
+} from "./chunk-MHELPNRP.js";
 import {
   llmSpans
 } from "./chunk-ZET2UAYW.js";
 import {
-  resolveRunCostProvenance
-} from "./chunk-IILEIWGW.js";
+  validateRunRecord
+} from "./chunk-2JX3CFMB.js";
 
 // src/contamination-guard.ts
 function checkCanaries(output, scenarios) {
@@ -124,14 +124,15 @@ function excerpt(source, needle) {
 
 // src/contract/analyze-runs.ts
 function summarizeExecution(opts) {
+  const runs = opts.runs.map(validateRunRecord);
   const bins = opts.histogramBins ?? 12;
   return {
-    execution: computeExecutionInsight(opts.runs, bins),
-    costProvenance: summarizeCostProvenance(opts.runs)
+    execution: computeExecutionInsight(runs, bins),
+    costProvenance: summarizeCostProvenance(runs)
   };
 }
 async function analyzeRuns(opts) {
-  const runs = opts.runs;
+  const runs = opts.runs.map(validateRunRecord);
   const bins = opts.histogramBins ?? 12;
   const threshold = opts.decisionThreshold ?? 0.02;
   const split = resolveSplit(runs, opts.split ?? "auto");
@@ -146,15 +147,15 @@ async function analyzeRuns(opts) {
     runs,
     histogramBins: bins
   });
-  const knownCostRuns = runs.filter((run) => resolveRunCostProvenance(run).kind !== "uncaptured");
-  const costs = knownCostRuns.map((r) => r.costUsd).filter(Number.isFinite);
+  const knownCostRuns = runs.filter((run) => run.costProvenance.kind !== "uncaptured");
+  const costs = knownCostRuns.map((r) => r.costUsd).filter(isFiniteNumber);
   const costDist = distributionOf(costs, bins);
   const pareto = paretoChart(knownCostRuns, { split });
   const degraded = {};
   if (provenance.uncaptured.n > 0) {
     degraded.cost = diagnoseCostCoverage(runs, provenance);
   } else if (costs.length === 0 || costs.every((c) => c === 0)) {
-    degraded.cost = runs.length > 0 && runs.every((run) => run.costProvenance !== void 0) ? `all ${runs.length} explicitly observed or estimated USD values are $0` : diagnoseZeroCost(runs);
+    degraded.cost = `all ${runs.length} explicitly observed or estimated USD values are $0`;
   }
   if (pareto.points.length < 2) {
     degraded.pareto = pareto.points.length === 0 ? "no candidates \u2014 Pareto unavailable" : "single candidate \u2014 Pareto is a single point, not a frontier";
@@ -169,7 +170,7 @@ async function analyzeRuns(opts) {
   const interRater = opts.raterScores ? computeInterRater(opts.raterScores) : void 0;
   const lift = computeLift(runs, opts.baselineCandidateId, opts.candidateCandidateId, split);
   const failureClusters = opts.analyst ? await computeFailureClusters(runs, opts.analyst, split) : void 0;
-  const failureModes = computeFailureModes(runs);
+  const failureClasses = computeFailureClasses(runs, split);
   const contamination = opts.canaryScenarios ? computeContamination(runs, opts.canaryScenarios) : void 0;
   const outcomeCorrelation = opts.outcomeSignal ? computeOutcomeCorrelation(runs, opts.outcomeSignal, split) : void 0;
   const release = buildReleaseScorecard(composite, lift, contamination);
@@ -180,7 +181,7 @@ async function analyzeRuns(opts) {
     interRater,
     lift,
     failureClusters,
-    failureModes,
+    failureClasses,
     contamination,
     outcomeCorrelation,
     priorPeriodComparison,
@@ -199,7 +200,7 @@ async function analyzeRuns(opts) {
     contamination,
     outcomeCorrelation,
     release,
-    ...failureModes ? { failureModes } : {},
+    ...failureClasses ? { failureClasses } : {},
     ...priorPeriodComparison ? { priorPeriodComparison } : {},
     recommendations
   };
@@ -213,16 +214,34 @@ function computeExecutionInsight(runs, bins) {
     (row) => row.costUsd !== void 0 ? [row.costUsd] : []
   );
   const modelCounts = /* @__PURE__ */ new Map();
-  let failureRuns = 0;
-  let reportedErrorEvents = 0;
+  let executionErrorRuns = 0;
+  let executionErrorEvents = 0;
   let errorReportingRuns = 0;
+  let errorSpanEvents = 0;
+  let errorSpanReportingRuns = 0;
+  const terminalOutcomes = {
+    succeeded: 0,
+    failed: 0,
+    cancelled: 0,
+    incomplete: 0,
+    unknown: 0
+  };
+  const errorsByTerminalOutcome = {
+    succeeded: { withErrors: 0, withoutErrors: 0, unreported: 0 },
+    failed: { withErrors: 0, withoutErrors: 0, unreported: 0 },
+    cancelled: { withErrors: 0, withoutErrors: 0, unreported: 0 },
+    incomplete: { withErrors: 0, withoutErrors: 0, unreported: 0 },
+    unknown: { withErrors: 0, withoutErrors: 0, unreported: 0 }
+  };
   let modelCallRuns = 0;
   let modelCallEvents = 0;
   let modelCallReportingRuns = 0;
   for (const run of runs) {
     modelCounts.set(run.model, (modelCounts.get(run.model) ?? 0) + 1);
-    const modelCalls = run.outcome.raw.llm_span_count;
-    if (Number.isFinite(modelCalls)) {
+    const terminalOutcome = run.terminalOutcome;
+    terminalOutcomes[terminalOutcome] += 1;
+    const modelCalls = nonNegativeCountRaw(run, "llm_span_count");
+    if (modelCalls !== void 0) {
       modelCallEvents += modelCalls;
       modelCallReportingRuns += 1;
     }
@@ -230,13 +249,19 @@ function computeExecutionInsight(runs, bins) {
     if ((modelCalls ?? 0) > 0 || usage.input > 0 || usage.output > 0 || (usage.cached ?? 0) > 0 || (usage.cacheWrite ?? 0) > 0) {
       modelCallRuns += 1;
     }
-    const errorEvents = run.outcome.raw.error_span_count;
-    if (Number.isFinite(errorEvents)) {
-      reportedErrorEvents += errorEvents;
+    const errorEvents = reportedExecutionErrorEvents(run);
+    if (errorEvents !== void 0) {
+      executionErrorEvents += errorEvents;
       errorReportingRuns += 1;
-    }
-    if (run.failureClass !== void 0 && run.failureClass !== "success" || run.failureMode !== void 0 || (errorEvents ?? 0) > 0) {
-      failureRuns += 1;
+      if (errorEvents > 0) {
+        executionErrorRuns += 1;
+        errorsByTerminalOutcome[terminalOutcome].withErrors += 1;
+      } else errorsByTerminalOutcome[terminalOutcome].withoutErrors += 1;
+    } else errorsByTerminalOutcome[terminalOutcome].unreported += 1;
+    const reportedErrorSpans = nonNegativeCountRaw(run, "error_span_count");
+    if (reportedErrorSpans !== void 0) {
+      errorSpanEvents += reportedErrorSpans;
+      errorSpanReportingRuns += 1;
     }
   }
   return {
@@ -267,14 +292,28 @@ function computeExecutionInsight(runs, bins) {
       events: modelCallEvents,
       reportingRuns: modelCallReportingRuns
     },
-    failures: {
-      runs: failureRuns,
-      fraction: runs.length > 0 ? failureRuns / runs.length : 0,
-      reportedErrorEvents,
-      reportingRuns: errorReportingRuns
-    }
+    executionErrors: {
+      runs: executionErrorRuns,
+      fraction: errorReportingRuns > 0 ? executionErrorRuns / errorReportingRuns : null,
+      events: executionErrorEvents,
+      reportingRuns: errorReportingRuns,
+      errorSpanEvents,
+      errorSpanReportingRuns,
+      byTerminalOutcome: errorsByTerminalOutcome
+    },
+    terminalOutcomes
   };
 }
+function reportedExecutionErrorEvents(run) {
+  const canonical = nonNegativeCountRaw(run, "execution_error_count");
+  if (canonical !== void 0) return canonical;
+  const toolErrors = nonNegativeCountRaw(run, "tool_errors");
+  return toolErrors;
+}
+function nonNegativeCountRaw(run, key) {
+  const value = finiteRaw(run, key);
+  return value !== void 0 && Number.isInteger(value) && value >= 0 ? value : void 0;
+}
 function summarizeTokenUsage(usages, bins) {
   const reasoning = usages.flatMap(
     (usage) => usage.reasoning !== void 0 ? [usage.reasoning] : []
@@ -332,7 +371,7 @@ function summarizeCostProvenance(runs) {
     knownFraction: 0
   };
   for (const run of runs) {
-    const cost = resolveRunCostProvenance(run);
+    const cost = run.costProvenance;
     if (cost.kind === "uncaptured") {
       summary.uncaptured.n += 1;
     } else {
@@ -347,36 +386,25 @@ function summarizeCostProvenance(runs) {
 function diagnoseCostCoverage(runs, provenance) {
   const uncaptured = provenance.uncaptured.n;
   const known = provenance.observed.n + provenance.estimated.n;
-  const explicitUncaptured = runs.some((run) => run.costProvenance?.kind === "uncaptured");
-  if (uncaptured === runs.length && !explicitUncaptured) return diagnoseZeroCost(runs);
   if (uncaptured === runs.length) {
     return `USD cost uncaptured for all ${runs.length} runs \u2014 no observed or estimated USD values; token and wall-time metrics remain available.`;
   }
   return `USD cost uncaptured for ${uncaptured}/${runs.length} runs; excluded those rows from cost statistics (${known}/${runs.length} retained: ${provenance.observed.n} observed, ${provenance.estimated.n} estimated).`;
 }
-function diagnoseZeroCost(runs) {
-  const integrity = summarizeBackendIntegrity(runs);
-  const { totalRecords, stubRecords, uncostedRecords } = integrity;
-  if (totalRecords > 0 && stubRecords === totalRecords) {
-    return `no costUsd values recorded \u2014 all ${totalRecords} records are stub-mode (zero token usage). The backend never reported real LLM activity, so cost cannot be computed; verify the backend actually ran before trusting this corpus.`;
-  }
-  if (uncostedRecords > 0) {
-    return `no costUsd values recorded \u2014 ${uncostedRecords}/${totalRecords} records have token usage but $0 cost (unpriced model). Check isModelPriced(model) for the run's model id and add it to FAMILY_PRICING.`;
-  }
-  if (stubRecords > 0) {
-    return `no costUsd values recorded \u2014 ${stubRecords}/${totalRecords} records are stub-mode (zero token usage); the remainder reported neither tokens nor cost. Cost axis carries no signal.`;
-  }
-  return "no costUsd values recorded \u2014 cost axis carries no signal";
-}
-function computeFailureModes(runs) {
+function computeFailureClasses(runs, split) {
   const counts = /* @__PURE__ */ new Map();
   for (const r of runs) {
-    const key = r.failureClass ?? r.failureMode;
-    if (key) counts.set(key, (counts.get(key) ?? 0) + 1);
+    if (!isTaskFailure(r, split)) continue;
+    const key = r.failureClass !== void 0 && r.failureClass !== "success" ? r.failureClass : "unknown";
+    counts.set(key, (counts.get(key) ?? 0) + 1);
   }
   if (counts.size === 0) return void 0;
   const n = runs.length;
-  return [...counts.entries()].map(([mode, count]) => ({ mode, count, share: n > 0 ? count / n : 0 })).sort((a, b) => b.count - a.count || a.mode.localeCompare(b.mode));
+  return [...counts.entries()].map(([failureClass, count]) => ({
+    failureClass,
+    count,
+    share: n > 0 ? count / n : 0
+  })).sort((a, b) => b.count - a.count || a.failureClass.localeCompare(b.failureClass));
 }
 function computePriorPeriodComparison(current, baseline, split, windowLabel) {
   if (current.length === 0 || baseline.length === 0) return void 0;
@@ -434,7 +462,10 @@ function computePriorPeriodComparison(current, baseline, split, windowLabel) {
   };
 }
 function knownCostValues(runs) {
-  return runs.filter((run) => resolveRunCostProvenance(run).kind !== "uncaptured").map((run) => run.costUsd).filter(Number.isFinite);
+  return runs.filter((run) => run.costProvenance.kind !== "uncaptured").map((run) => run.costUsd).filter(isFiniteNumber);
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
 }
 function collectPerDimension(runs) {
   const out = {};
@@ -465,15 +496,15 @@ function welchCompare(baseline, current) {
   const pooledStddev = Math.sqrt(
     ((baselineN - 1) * baselineVar + (currentN - 1) * currentVar) / Math.max(1, baselineN + currentN - 2)
   );
-  const cohensD2 = pooledStddev > 0 ? delta / pooledStddev : 0;
-  const significant = pValue < 0.05 && Math.abs(cohensD2) >= 0.2;
+  const cohensD = pooledStddev > 0 ? delta / pooledStddev : 0;
+  const significant = pValue < 0.05 && Math.abs(cohensD) >= 0.2;
   return {
     current: currentMean,
     baseline: baselineMean,
     delta,
     ci95,
     pValue,
-    cohensD: cohensD2,
+    cohensD,
     baselineN,
     currentN,
     significant
@@ -504,21 +535,19 @@ function resolveSplit(runs, pref) {
   return hasHoldout ? "holdout" : "search";
 }
 function compositeOf(run, split) {
-  const primary = split === "holdout" ? run.outcome.holdoutScore : run.outcome.searchScore;
-  if (Number.isFinite(primary)) return primary;
-  const alt = split === "holdout" ? run.outcome.searchScore : run.outcome.holdoutScore;
-  return Number.isFinite(alt) ? alt : Number.NaN;
+  const score = split === "holdout" ? run.outcome.holdoutScore : run.outcome.searchScore;
+  return Number.isFinite(score) ? score : Number.NaN;
 }
 function distributionOf(values, bins, withIds) {
   if (values.length === 0) {
     return {
       n: 0,
-      mean: 0,
-      p50: 0,
-      p95: 0,
-      stddev: 0,
-      min: 0,
-      max: 0,
+      mean: null,
+      p50: null,
+      p95: null,
+      stddev: null,
+      min: null,
+      max: null,
       histogram: []
     };
   }
@@ -677,41 +706,28 @@ function computeLift(runs, baselineId, candidateId, split) {
     const ids = [...new Set(runs.map((r) => r.candidateId))];
     if (ids.length !== 2) return void 0;
     const [idA, idB] = ids;
-    const meanA = mean(runs.filter((r) => r.candidateId === idA).map((r) => compositeOf(r, split)));
-    const meanB = mean(runs.filter((r) => r.candidateId === idB).map((r) => compositeOf(r, split)));
+    const scoresA = finiteCompositeScores(
+      runs.filter((run) => run.candidateId === idA),
+      split
+    );
+    const scoresB = finiteCompositeScores(
+      runs.filter((run) => run.candidateId === idB),
+      split
+    );
+    if (scoresA.length === 0 || scoresB.length === 0) return void 0;
+    const meanA = mean(scoresA);
+    const meanB = mean(scoresB);
     bId = meanA <= meanB ? idA : idB;
     cId = meanA <= meanB ? idB : idA;
   }
   const baseline = runs.filter((r) => r.candidateId === bId);
   const candidate = runs.filter((r) => r.candidateId === cId);
   if (baseline.length === 0 || candidate.length === 0) return void 0;
-  const baselineByKey = new Map(baseline.map((r) => [pairingKey(r), r]));
-  const pairedBaseline = [];
-  const pairedCandidate = [];
-  let usedKeyPairing = false;
-  for (const cand of candidate) {
-    const b = baselineByKey.get(pairingKey(cand));
-    if (b) {
-      const bC = compositeOf(b, split);
-      const cC = compositeOf(cand, split);
-      if (Number.isFinite(bC) && Number.isFinite(cC)) {
-        pairedBaseline.push(bC);
-        pairedCandidate.push(cC);
-        usedKeyPairing = true;
-      }
-    }
-  }
-  if (!usedKeyPairing) {
-    const n = Math.min(baseline.length, candidate.length);
-    for (let i = 0; i < n; i++) {
-      const bC = compositeOf(baseline[i], split);
-      const cC = compositeOf(candidate[i], split);
-      if (Number.isFinite(bC) && Number.isFinite(cC)) {
-        pairedBaseline.push(bC);
-        pairedCandidate.push(cC);
-      }
-    }
-  }
+  const scoredBaseline = baseline.filter((run) => Number.isFinite(compositeOf(run, split)));
+  const scoredCandidate = candidate.filter((run) => Number.isFinite(compositeOf(run, split)));
+  const pairing = pairRunRecords(scoredBaseline, scoredCandidate);
+  const pairedBaseline = pairing.pairs.map((pair) => compositeOf(pair.baseline, split));
+  const pairedCandidate = pairing.pairs.map((pair) => compositeOf(pair.treatment, split));
   if (pairedBaseline.length === 0) return void 0;
   const baselineMean = mean(pairedBaseline);
   const candidateMean = mean(pairedCandidate);
@@ -722,10 +738,10 @@ function computeLift(runs, baselineId, candidateId, split) {
     statistic: "mean"
   });
   const tTest = pairedTTest(pairedBaseline, pairedCandidate);
-  const d = cohensD(pairedBaseline, pairedCandidate);
+  const d = pairedCohensDz(pairedBaseline, pairedCandidate);
   const mde = pairedMde({ nPaired: pairedBaseline.length, power: 0.8, alpha: 0.05 });
-  const requiredN = requiredSampleSize({
-    effect: Math.max(Math.abs(delta), 1e-6),
+  const requiredN = d === null || d === 0 ? null : requiredPairedSampleSize({
+    effect: Math.abs(d),
     power: 0.8,
     alpha: 0.05
   });
@@ -736,19 +752,18 @@ function computeLift(runs, baselineId, candidateId, split) {
     ci95: [bootstrap.low, bootstrap.high],
     pValue: tTest.p,
     n: pairedBaseline.length,
+    unpairedBaseline: pairing.unpairedBaseline.length,
+    unpairedCandidate: pairing.unpairedTreatment.length,
     cohensD: d,
     mde,
     requiredN
   };
 }
-function pairingKey(r) {
-  return `${r.experimentId}::${r.seed}`;
-}
 function mean(arr) {
   return arr.length === 0 ? 0 : arr.reduce((s, v) => s + v, 0) / arr.length;
 }
 async function computeFailureClusters(runs, analyst, split) {
-  const failed = runs.filter((r) => compositeOf(r, split) < 0.5 || r.failureMode !== void 0);
+  const failed = runs.filter((run) => isTaskFailure(run, split));
   if (failed.length === 0) return { clusters: [], totalFailures: 0 };
   const clusters = /* @__PURE__ */ new Map();
   for (const run of failed) {
@@ -775,6 +790,14 @@ async function computeFailureClusters(runs, analyst, split) {
   clusterList.sort((a, b) => b.share - a.share);
   return { clusters: clusterList, totalFailures: failed.length };
 }
+function finiteCompositeScores(runs, split) {
+  return runs.map((run) => compositeOf(run, split)).filter(Number.isFinite);
+}
+function isTaskFailure(run, split) {
+  if (run.failureClass !== void 0 && run.failureClass !== "success") return true;
+  const score = compositeOf(run, split);
+  return Number.isFinite(score) && score < 0.5;
+}
 function computeContamination(runs, canaries) {
   let leaks = 0;
   const details = [];
@@ -832,24 +855,30 @@ function computeOutcomeCorrelation(runs, outcome, split) {
 }
 function buildReleaseScorecard(composite, lift, contamination) {
   const axes = [];
-  const liftPass = lift === void 0 || lift.ci95[0] > 0 ? "pass" : lift.delta > 0 ? "warn" : "fail";
+  const liftPass = lift === void 0 ? "not_evaluated" : lift.ci95[0] > 0 ? "pass" : lift.delta > 0 ? "warn" : "fail";
   axes.push({
     name: "quality-lift",
     status: liftPass,
     detail: lift ? `delta=${lift.delta.toFixed(3)}, CI95=[${lift.ci95[0].toFixed(3)}, ${lift.ci95[1].toFixed(3)}], n=${lift.n}` : "no baseline/candidate pair available"
   });
-  const contamPass = contamination === void 0 || contamination.leaks === 0 ? "pass" : "fail";
+  const contamPass = contamination === void 0 ? "not_evaluated" : contamination.leaks === 0 ? "pass" : "fail";
   axes.push({
     name: "contamination",
     status: contamPass,
     detail: contamination ? `${contamination.leaks} canary leak(s)` : "no canaries supplied"
   });
-  axes.push({
-    name: "composite-distribution",
-    status: composite.mean >= 0.5 ? "pass" : composite.mean >= 0.3 ? "warn" : "fail",
-    detail: `mean=${composite.mean.toFixed(3)}, p50=${composite.p50.toFixed(3)}, p95=${composite.p95.toFixed(3)} over n=${composite.n}`
-  });
-  const status = axes.some((a) => a.status === "fail") ? "fail" : axes.some((a) => a.status === "warn") ? "warn" : "pass";
+  axes.push(
+    composite.n === 0 ? {
+      name: "composite-distribution",
+      status: "not_evaluated",
+      detail: "no task-quality scores available"
+    } : {
+      name: "composite-distribution",
+      status: composite.mean !== null && composite.mean >= 0.5 ? "pass" : composite.mean !== null && composite.mean >= 0.3 ? "warn" : "fail",
+      detail: composite.mean === null || composite.p50 === null || composite.p95 === null ? "task-quality distribution is internally incomplete" : `mean=${composite.mean.toFixed(3)}, p50=${composite.p50.toFixed(3)}, p95=${composite.p95.toFixed(3)} over n=${composite.n}`
+    }
+  );
+  const status = axes.some((a) => a.status === "fail") ? "fail" : axes.some((a) => a.status === "warn" || a.status === "not_evaluated") ? "warn" : "pass";
   return {
     status,
     axes,
@@ -884,7 +913,7 @@ function buildRecommendations(ctx) {
       });
     }
   }
-  if (ctx.composite.n > 0) {
+  if (ctx.composite.n > 0 && ctx.composite.mean !== null && ctx.composite.p50 !== null && ctx.composite.p95 !== null) {
     if (ctx.composite.mean < 0.3) {
       const tail = ctx.composite.tailRuns ?? [];
       const names = tail.slice(0, 5).map((t) => `${t.runId}=${t.score.toFixed(3)}`).join(", ");
@@ -907,15 +936,15 @@ function buildRecommendations(ctx) {
       });
     }
   }
-  if (ctx.failureModes && ctx.failureModes.length > 0) {
-    const top = ctx.failureModes[0];
+  if (ctx.failureClasses && ctx.failureClasses.length > 0) {
+    const top = ctx.failureClasses[0];
     if (top.count >= 3 && top.share >= 0.15) {
       out.push({
         priority: top.share >= 0.25 ? "high" : "medium",
         kind: "investigate",
-        title: `'${top.mode}' is the dominant failure mode \u2014 ${top.count} runs (${(top.share * 100).toFixed(0)}% of the corpus)`,
-        detail: `The mean composite can look acceptable while one named failure dominates the lower tail. ${top.count} of ${ctx.composite.n} runs failed with '${top.mode}'${ctx.failureModes.length > 1 ? ` (next: '${ctx.failureModes[1].mode}' \xD7${ctx.failureModes[1].count})` : ""}. Fix this cause first.`,
-        evidencePath: "failureModes"
+        title: `'${top.failureClass}' is the dominant failure class \u2014 ${top.count} runs (${(top.share * 100).toFixed(0)}% of the corpus)`,
+        detail: `The mean composite can look acceptable while one failure class dominates the lower tail. ${top.count} of ${ctx.composite.n} runs failed with '${top.failureClass}'${ctx.failureClasses.length > 1 ? ` (next: '${ctx.failureClasses[1].failureClass}' \xD7${ctx.failureClasses[1].count})` : ""}. Fix this cause first.`,
+        evidencePath: "failureClasses"
       });
     }
   }
@@ -929,6 +958,8 @@ function buildRecommendations(ctx) {
     });
   }
   if (ctx.lift) {
+    const pairedEffect = ctx.lift.cohensD === null ? "undefined (zero delta variance)" : ctx.lift.cohensD.toFixed(2);
+    const requiredRuns = ctx.lift.requiredN === null ? "not estimable" : `~${ctx.lift.requiredN} paired runs`;
     const decisive = ctx.lift.ci95[0] > ctx.threshold;
     const inconclusive = ctx.lift.ci95[0] <= ctx.threshold && ctx.lift.ci95[1] > ctx.threshold;
     if (decisive) {
@@ -936,14 +967,14 @@ function buildRecommendations(ctx) {
         priority: "critical",
         kind: "ship",
         title: `Ship \u2014 lift ${ctx.lift.delta.toFixed(3)} (95% CI ${ctx.lift.ci95[0].toFixed(3)}..${ctx.lift.ci95[1].toFixed(3)})`,
-        detail: `Holdout lift exceeds threshold ${ctx.threshold} with 95% bootstrap confidence (n=${ctx.lift.n}, p=${ctx.lift.pValue.toFixed(4)}, d=${ctx.lift.cohensD.toFixed(2)}).`,
+        detail: `Holdout lift exceeds threshold ${ctx.threshold} with 95% bootstrap confidence (n=${ctx.lift.n}, p=${ctx.lift.pValue.toFixed(4)}, paired d=${pairedEffect}).`,
         evidencePath: "lift"
       });
     } else if (inconclusive) {
       out.push({
         priority: "high",
         kind: "expand-corpus",
-        title: `Inconclusive \u2014 need ~${ctx.lift.requiredN} paired runs (have ${ctx.lift.n}) at current effect size`,
+        title: `Inconclusive \u2014 required sample is ${requiredRuns} (have ${ctx.lift.n}) at current effect size`,
         detail: `CI straddles threshold. Current MDE at 80% power is ${ctx.lift.mde.toFixed(3)}; observed delta is ${ctx.lift.delta.toFixed(3)}.`,
         evidencePath: "lift"
       });
@@ -1006,4 +1037,4 @@ export {
   summarizeExecution,
   analyzeRuns
 };
-//# sourceMappingURL=chunk-K6IAZZ6L.js.map
+//# sourceMappingURL=chunk-NACAGYSY.js.map