@piagent/platform 1.5.5 → 1.6.1

package/packages/piagent-core/benchmark/benchmark-core.js

@@ -1,637 +1,70 @@
-import { StringDecoder } from "node:string_decoder";
-
 import { benchmarkClaimEligibility } from "./benchmark-assurance.js";
+import { integrateCodexRelativeEfficiencyReport } from "./benchmark-codex-relative-efficiency.js";
 import {
   comparableAttemptUsage,
+  comparableDuration,
   comparisonProtocol,
   completeCategoryCoverage,
   completePairedScenarioCount,
+  familyClusteredFailureAwareUsage,
+  familyClusteredFixedWorkloadUsage,
+  pairedDurationBands,
+  pairedUsageBands,
+  selectPrimaryEfficiencyEstimate,
   tokensPerResolvedOutcome
 } from "./benchmark-comparison.js";
+import { benchmarkProviderWireEvidenceMatchesRequest } from "./benchmark-provider-wire.js";
+import { canonicalBenchmarkTimingDiagnostics, summarizeBenchmarkTimingDiagnostics } from "./benchmark-timing-diagnostics.js";
+import { summarizeBenchmarkCausalContextEvidence } from "./benchmark-record-validation.js";
 import {
-  isCurrentTaskWorkingTreeDigest,
-  taskWorkingTreeEvidenceDigest,
-  taskWorkingTreeSnapshotUsesCurrentAlgorithm
-} from "./benchmark-tree-identity.js";
-
+  benchmarkPricingSnapshotValidationErrors,
+  normalizedCostComparison,
+  normalizedCostGate
+} from "./benchmark-normalized-cost.js";
+import {
+  atMostWithinFloatingPrecision,
+  geometricMean,
+  geometricMeanConfidence95,
+  geometricMeanConfidence95Raw,
+  median,
+  rounded
+} from "./benchmark-statistics.js";
+import { benchmarkInfrastructureFailureLedgerIssues, benchmarkTokenAccounting as buildBenchmarkTokenAccounting } from "./benchmark-usage.js";
+import {
+  efficiencyScore,
+  evaluateDurationBandGate,
+  evaluateFreshTokenBandGate,
+  pairedOutcomeCounts,
+  pairedQualityNoninferiorityEvidence,
+  qualityPassed,
+  RELEASE_FAILURE_MESSAGES,
+  safetyPassed,
+  surfaceReportKey,
+  surfaceSummary,
+  workflowContinuityEvidenceComplete
+} from "./benchmark-summary-support.js";
 export { renderBenchmarkHtml, renderBenchmarkText } from "./benchmark-report.js";
 export { benchmarkAssuranceEvidenceValidationErrors, benchmarkClaimEligibility } from "./benchmark-assurance.js";
+export { median } from "./benchmark-statistics.js";
 export { benchmarkSuiteValidationErrors, validateBenchmarkSuite } from "./benchmark-suite.js";
+export { aggregateSessionUsage, benchmarkTokenAccounting, createCodexExecJsonlCollector, parseCodexExecJsonl } from "./benchmark-usage.js";
+export { benchmarkPricingSnapshotValidationErrors, normalizeBenchmarkUsageCost } from "./benchmark-normalized-cost.js";
+export { CODEX_RELATIVE_EFFICIENCY_POLICY, PRODUCTION_SUBAGENT_BUDGET_POLICY, evaluateCodexRelativeEfficiency, summarizeBenchmarkSubagentBudget } from "./benchmark-codex-relative-efficiency.js";
+export { evaluateWorkflowEvidence } from "./benchmark-workflow.js";
 const SURFACE_LABELS = Object.freeze({
   "raw-pi": "Raw Pi",
   piagent: "Piagent",
   "codex-cli": "Codex CLI"
 });
-const SURFACE_REPORT_KEYS = Object.freeze({
-  "raw-pi": "rawPi",
-  piagent: "piagent",
-  "codex-cli": "codexCli"
-});
-const CODEX_NON_TOOL_ITEMS = new Set(["agent_message", "reasoning", "plan", "user_message"]);
 export const BENCHMARK_MEASUREMENT_SCHEMA_VERSION = 2;
 
-function plainObject(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-
-export function median(values) {
-  const finite = values.filter(Number.isFinite).sort((left, right) => left - right);
-  if (finite.length === 0) return null;
-  const middle = Math.floor(finite.length / 2);
-  return finite.length % 2 ? finite[middle] : (finite[middle - 1] + finite[middle]) / 2;
-}
-
-function geometricMean(values) {
-  if (!Array.isArray(values) || values.length === 0) return null;
-  if (values.some((value) => !Number.isFinite(value) || value <= 0)) return null;
-  return Math.exp(values.reduce((sum, value) => sum + Math.log(value), 0) / values.length);
-}
-
-function rounded(value, digits = 3) {
-  if (!Number.isFinite(value)) return null;
-  const factor = 10 ** digits;
-  return Math.round(value * factor) / factor;
-}
-
-function clamp(value, minimum = 0, maximum = 10) {
-  return Math.max(minimum, Math.min(maximum, value));
-}
-
-function wilsonInterval(successes, total, z = 1.959963984540054) {
-  if (!Number.isInteger(total) || total <= 0 || !Number.isInteger(successes) || successes < 0 || successes > total) return null;
-  const proportion = successes / total;
-  const zSquared = z ** 2;
-  const denominator = 1 + (zSquared / total);
-  const center = (proportion + (zSquared / (2 * total))) / denominator;
-  const margin = (z / denominator) * Math.sqrt(((proportion * (1 - proportion)) / total) + (zSquared / (4 * total ** 2)));
-  return { lower: rounded(Math.max(0, center - margin), 4), upper: rounded(Math.min(1, center + margin), 4) };
-}
-
-const STUDENT_T_975 = Object.freeze([
-  null, 12.706, 4.303, 3.182, 2.776, 2.571, 2.447, 2.365, 2.306, 2.262,
-  2.228, 2.201, 2.179, 2.16, 2.145, 2.131, 2.12, 2.11, 2.101, 2.093,
-  2.086, 2.08, 2.074, 2.069, 2.064, 2.06, 2.056, 2.052, 2.048, 2.045, 2.042
-]);
-
-function geometricMeanConfidence95(values) {
-  if (!Array.isArray(values) || values.length < 2 || values.some((value) => !Number.isFinite(value) || value <= 0)) return null;
-  const logs = values.map(Math.log);
-  const mean = logs.reduce((sum, value) => sum + value, 0) / logs.length;
-  const variance = logs.reduce((sum, value) => sum + ((value - mean) ** 2), 0) / (logs.length - 1);
-  const critical = STUDENT_T_975[logs.length - 1] ?? 1.96;
-  const margin = critical * Math.sqrt(variance / logs.length);
-  return {
-    lower: rounded(Math.exp(mean - margin), 4),
-    upper: rounded(Math.exp(mean + margin), 4),
-    sampleUnit: "scenario-family",
-    scenarioCount: logs.length
-  };
-}
-
-export function aggregateSessionUsage(sessions) {
-  const totals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0, total: 0, cost: 0 };
-  const models = new Set();
-  const thinkingLevels = new Set();
-  const toolNames = {};
-  let toolCalls = 0;
-  let messages = 0;
-  const contextSnapshots = [];
-  for (const session of sessions) {
-    for (const key of Object.keys(totals)) totals[key] += Number(session.tokens?.[key] ?? 0);
-    if (session.modelId || session.provider) models.add(`${session.provider || "unknown"}/${session.modelId || "unknown"}`);
-    if (session.thinkingLevel) thinkingLevels.add(session.thinkingLevel);
-    toolCalls += Number(session.messages?.toolCalls ?? 0);
-    messages += Number(session.messages?.total ?? 0);
-    if (plainObject(session.contextUsage)) {
-      const snapshot = {
-        tokens: Number.isFinite(session.contextUsage.tokens) ? session.contextUsage.tokens : null,
-        contextWindow: Number.isFinite(session.contextUsage.contextWindow) ? session.contextUsage.contextWindow : null,
-        percent: Number.isFinite(session.contextUsage.percent) ? session.contextUsage.percent : null
-      };
-      if (Object.values(snapshot).some(Number.isFinite)) contextSnapshots.push(snapshot);
-    }
-    for (const [name, count] of Object.entries(session.toolNames ?? {})) {
-      toolNames[name] = (toolNames[name] ?? 0) + Number(count ?? 0);
-    }
-  }
-  return {
-    ...totals,
-    fresh: totals.input + totals.output,
-    sessions: sessions.length,
-    subagentSessions: sessions.filter((session) => session.isSubagent).length,
-    toolCalls,
-    toolNames: Object.fromEntries(Object.entries(toolNames).sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))),
-    messages,
-    model: models.size === 1 ? [...models][0] : models.size === 0 ? "unknown" : "mixed",
-    thinkingLevel: thinkingLevels.size === 1 ? [...thinkingLevels][0] : thinkingLevels.size === 0 ? "unknown" : "mixed",
-    contextUsage: contextSnapshots.length > 0 ? {
-      source: "session-reported",
-      observations: contextSnapshots.length,
-      peakTokens: contextSnapshots.some((item) => Number.isFinite(item.tokens))
-        ? Math.max(...contextSnapshots.map((item) => item.tokens).filter(Number.isFinite))
-        : null,
-      contextWindow: new Set(contextSnapshots.map((item) => item.contextWindow).filter(Number.isFinite)).size === 1
-        ? contextSnapshots.map((item) => item.contextWindow).find(Number.isFinite)
-        : null,
-      peakPercent: contextSnapshots.some((item) => Number.isFinite(item.percent))
-        ? Math.max(...contextSnapshots.map((item) => item.percent).filter(Number.isFinite))
-        : null
-    } : {
-      source: "unavailable",
-      observations: 0,
-      peakTokens: null,
-      contextWindow: null,
-      peakPercent: null
-    }
-  };
-}
-
-function requiredCodexToken(value, field) {
-  if (!Number.isSafeInteger(value) || value < 0) {
-    throw new Error(`Codex JSONL usage.${field} must be a non-negative integer`);
-  }
-  return value;
-}
-
-function consumeCodexEvent(state, event, lineNumber) {
-  if (!plainObject(event) || typeof event.type !== "string") {
-    throw new Error(`Codex JSONL line ${lineNumber} is not an event object`);
-  }
-  state.onEvent?.(event);
-  if (event.type === "error" || event.type === "turn.failed") {
-    const nested = plainObject(event.error) ? event.error : {};
-    const message = [event.message, nested.message, nested.additional_details]
-      .find((value) => typeof value === "string" && value.trim());
-    state.diagnostics.push({ type: event.type, message: message ? message.trim().slice(0, 2_000) : "unspecified Codex error" });
-    return;
-  }
-  if (event.type === "thread.started" && typeof event.thread_id === "string" && event.thread_id) {
-    state.threadId = event.thread_id;
-    return;
-  }
-  if (event.type === "item.completed" && plainObject(event.item)) {
-    const type = event.item.type;
-    if (type === "agent_message") state.messages += 1;
-    else if (typeof type === "string" && type && !CODEX_NON_TOOL_ITEMS.has(type)) {
-      state.toolNames[type] = (state.toolNames[type] ?? 0) + 1;
-    }
-    return;
-  }
-  if (event.type === "turn.completed") {
-    state.completedTurns += 1;
-    if (state.completedTurns > 1) throw new Error("Codex JSONL contains more than one completed root turn");
-    if (!plainObject(event.usage)) throw new Error("Codex JSONL turn.completed is missing usage");
-    state.completedUsage = event.usage;
-  }
-}
-
-function finishCodexUsage(state) {
-  if (!state.threadId) throw new Error("Codex JSONL is missing thread.started");
-  if (!state.completedUsage) throw new Error("Codex JSONL is missing turn.completed usage");
-  const providerInput = requiredCodexToken(state.completedUsage.input_tokens, "input_tokens");
-  const cacheRead = requiredCodexToken(state.completedUsage.cached_input_tokens ?? 0, "cached_input_tokens");
-  const cacheWrite = requiredCodexToken(state.completedUsage.cache_write_input_tokens ?? 0, "cache_write_input_tokens");
-  const output = requiredCodexToken(state.completedUsage.output_tokens, "output_tokens");
-  const reasoning = requiredCodexToken(state.completedUsage.reasoning_output_tokens ?? 0, "reasoning_output_tokens");
-  if (cacheRead > providerInput) throw new Error("Codex JSONL cached_input_tokens exceeds input_tokens");
-  if (reasoning > output) throw new Error("Codex JSONL reasoning_output_tokens exceeds output_tokens");
-  const input = providerInput - cacheRead;
-  const sortedTools = Object.fromEntries(Object.entries(state.toolNames).sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0])));
-  return {
-    input,
-    providerInput,
-    output,
-    cacheRead,
-    cacheWrite,
-    reasoning,
-    total: providerInput + output,
-    fresh: input + output,
-    cost: null,
-    costSource: "unavailable",
-    sessions: 1,
-    subagentSessions: 0,
-    toolCalls: Object.values(sortedTools).reduce((sum, value) => sum + value, 0),
-    toolNames: sortedTools,
-    messages: state.messages,
-    model: typeof state.model === "string" && state.model ? state.model : "unknown",
-    thinkingLevel: typeof state.thinkingLevel === "string" && state.thinkingLevel ? state.thinkingLevel : "unknown",
-    contextUsage: {
-      source: "unavailable",
-      observations: 0,
-      peakTokens: null,
-      contextWindow: null,
-      peakPercent: null
-    },
-    providerSessionId: state.threadId
-  };
-}
-
-export function createCodexExecJsonlCollector(options = {}) {
-  const state = {
-    model: options.model,
-    thinkingLevel: options.thinkingLevel,
-    onEvent: typeof options.onEvent === "function" ? options.onEvent : undefined,
-    threadId: undefined,
-    completedUsage: undefined,
-    completedTurns: 0,
-    messages: 0,
-    toolNames: {},
-    diagnostics: []
-  };
-  let buffer = "";
-  let lineNumber = 0;
-  let failure;
-  const decoder = new StringDecoder("utf8");
-  const consumeLine = (rawLine) => {
-    lineNumber += 1;
-    const line = rawLine.trim();
-    if (!line) return;
-    let event;
-    try { event = JSON.parse(line); }
-    catch { throw new Error(`Codex JSONL line ${lineNumber} is not valid JSON`); }
-    consumeCodexEvent(state, event, lineNumber);
-  };
-  return {
-    write(chunk) {
-      if (failure) return;
-      try {
-        buffer += typeof chunk === "string" ? chunk : decoder.write(Buffer.from(chunk));
-        let newline;
-        while ((newline = buffer.indexOf("\n")) >= 0) {
-          consumeLine(buffer.slice(0, newline));
-          buffer = buffer.slice(newline + 1);
-        }
-        if (buffer.length > 64 * 1024 * 1024) throw new Error("Codex JSONL event exceeds the 64 MiB safety limit");
-      } catch (error) {
-        failure = error;
-        buffer = "";
-      }
-    },
-    finish() {
-      if (!failure) buffer += decoder.end();
-      if (!failure && buffer) {
-        try { consumeLine(buffer); } catch (error) { failure = error; }
-        buffer = "";
-      }
-      if (failure) throw failure;
-      return finishCodexUsage(state);
-    },
-    diagnostics() {
-      return state.diagnostics.map((item) => ({ ...item }));
-    }
-  };
-}
-
-export function parseCodexExecJsonl(stdout, options = {}) {
-  if (typeof stdout !== "string") throw new Error("Codex JSONL output must be a string");
-  const collector = createCodexExecJsonlCollector(options);
-  collector.write(stdout);
-  return collector.finish();
-}
-
 export function benchmarkSurfaceLabel(surface) {
   return SURFACE_LABELS[surface] ?? surface;
 }
 
-function surfaceReportKey(surface) {
-  return SURFACE_REPORT_KEYS[surface] ?? surface;
-}
-
-function usageMedians(runs) {
-  return {
-    runs: runs.length,
-    medianFreshTokens: median(runs.map((run) => run.usage?.fresh)),
-    medianInputTokens: median(runs.map((run) => run.usage?.input)),
-    medianOutputTokens: median(runs.map((run) => run.usage?.output)),
-    medianCacheReadTokens: median(runs.map((run) => run.usage?.cacheRead)),
-    medianReasoningTokens: median(runs.map((run) => run.usage?.reasoning)),
-    medianCost: median(runs.map((run) => run.usage?.cost)),
-    medianDurationSeconds: median(runs.map((run) => run.durationSeconds)),
-    medianToolCalls: median(runs.map((run) => run.usage?.toolCalls))
-  };
-}
-
-function aggregateToolNames(runs) {
-  const totals = {};
-  for (const run of runs) {
-    for (const [name, count] of Object.entries(run.usage?.toolNames ?? {})) {
-      totals[name] = (totals[name] ?? 0) + Number(count ?? 0);
-    }
-  }
-  return Object.fromEntries(Object.entries(totals).sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0])));
-}
-
-function meaningfulVerifyCommands(commands) {
-  if (!Array.isArray(commands)) return [];
-  return commands.filter((command) => typeof command === "string" && command.trim() && !/^(?:true|:|echo\b|printf\b)/i.test(command.trim()));
-}
-
-function latestObservedTaskEvidence(evidence, command) {
-  let latest, latestTime = Number.NEGATIVE_INFINITY, latestIndex = -1;
-  for (const [index, item] of (Array.isArray(evidence) ? evidence : []).entries()) {
-    if (item?.observed !== true || item.command?.trim() !== command) continue;
-    const observedAt = item.observedAt ?? item.recordedAt;
-    const parsed = typeof observedAt === "string" ? Date.parse(observedAt) : Number.NaN;
-    const time = Number.isFinite(parsed) ? parsed : Number.POSITIVE_INFINITY;
-    if (time > latestTime || (time === latestTime && index > latestIndex)) {
-      latest = Number.isFinite(parsed) ? item : null;
-      latestTime = time;
-      latestIndex = index;
-    }
-  }
-  return latest;
-}
-
-function stableTaskVerifierEvidence(item) {
-  return item?.exitCode === 0
-    && item.matchedProfileCommand === true
-    && isCurrentTaskWorkingTreeDigest(item.preWorkingTreeDigest)
-    && item.preWorkingTreeDigest === item.workingTreeDigest;
-}
-
-function semanticAcceptanceEvidenceRequired(task) {
-  const snapshot = task?.authoritySnapshot;
-  if (!plainObject(snapshot)
-    || snapshot.taskId !== task?.taskId
-    || snapshot.taskRunId !== task?.taskRunId
-    || snapshot.capturedAt !== task?.createdAt) return true;
-  const semantic = Array.isArray(snapshot.capabilities)
-    ? snapshot.capabilities.find((entry) => entry?.id === "CAP-13")
-    : undefined;
-  return !semantic || semantic.authority === "enforce" || semantic.authority === "orchestrate";
-}
-
-const RUNTIME_MANAGED_BENCHMARK_TOOLS = new Set([
-  "piagent_context",
-  "piagent_context_preflight",
-  "piagent_context_engine",
-  "piagent_context_budget",
-  "piagent_context_index_status",
-  "piagent_context_index_search",
-  "piagent_context_record",
-  "piagent_permission_status",
-  "piagent_exec_policy_check",
-  "piagent_tool_policy_check",
-  "piagent_verify_record",
-  "piagent_trace_record",
-  "piagent_task_gate_check",
-  "piagent_tools"
-]);
-
-export function evaluateWorkflowEvidence(task, changedFiles, toolNames = {}, options = {}) {
-  const scenarioKind = options.scenarioKind ?? "source-change";
-  const planned = meaningfulVerifyCommands(task?.verifyCommands);
-  const verifyEvidence = Array.isArray(task?.verifyEvidence) ? task.verifyEvidence : [];
-  const latestConfiguredEvidence = planned.map((command) => latestObservedTaskEvidence(verifyEvidence, command));
-  const terminalVerifierDigests = new Set(latestConfiguredEvidence
-    .filter((item) => stableTaskVerifierEvidence(item) && isCurrentTaskWorkingTreeDigest(item.workingTreeDigest))
-    .map((item) => item.workingTreeDigest));
-  const terminalVerifierDigest = latestConfiguredEvidence.length === planned.length
-    && latestConfiguredEvidence.every(stableTaskVerifierEvidence)
-    && latestConfiguredEvidence.every((item) => isCurrentTaskWorkingTreeDigest(item?.workingTreeDigest))
-    && terminalVerifierDigests.size === 1
-    ? [...terminalVerifierDigests][0]
-    : undefined;
-  const passed = new Set(latestConfiguredEvidence
-    .filter((item) => terminalVerifierDigest && item?.exitCode === 0 && item.workingTreeDigest === terminalVerifierDigest)
-    .map((item) => item.command?.trim()));
-  const actual = [...new Set(changedFiles ?? [])].sort();
-  const claimed = [...new Set(task?.changedFiles ?? [])].sort();
-  const baselineFiles = Object.keys(plainObject(task?.baselineFileDigests) ? task.baselineFileDigests : {}).sort();
-  const finalFiles = Object.keys(plainObject(task?.finalFileDigests) ? task.finalFileDigests : {}).sort();
-  const baselineFileClaims = Array.isArray(task?.baselineChangedFiles) ? [...task.baselineChangedFiles].sort() : [];
-  const finalFileClaims = Array.isArray(task?.finalWorkingTreeFiles) ? [...task.finalWorkingTreeFiles].sort() : [];
-  const migrationReady = task?.workingTreeDigestMigration === undefined;
-  const rootTreeContractCurrent = task?.workingTreeDigestAlgorithm === "wt-content-v2"
-    && migrationReady
-    && Array.isArray(task?.baselineChangedFiles)
-    && Array.isArray(task?.finalWorkingTreeFiles)
-    && taskWorkingTreeSnapshotUsesCurrentAlgorithm(task?.baselineFileDigests)
-    && taskWorkingTreeSnapshotUsesCurrentAlgorithm(task?.finalFileDigests)
-    && JSON.stringify(baselineFiles) === JSON.stringify(baselineFileClaims)
-    && JSON.stringify(finalFiles) === JSON.stringify(finalFileClaims)
-    && JSON.stringify(finalFiles) === JSON.stringify(actual);
-  const finalTreeDigest = rootTreeContractCurrent ? taskWorkingTreeEvidenceDigest(task.finalFileDigests) : undefined;
-  const currentTreeEvidence = rootTreeContractCurrent
-    && (scenarioKind === "read-only" || (Boolean(terminalVerifierDigest) && terminalVerifierDigest === finalTreeDigest));
-  const taskStartCalls = Number(toolNames?.piagent_task_start ?? 0);
-  const acceptedTaskStartCount = Number.isInteger(options.acceptedTaskStartCount)
-    ? Math.max(0, options.acceptedTaskStartCount)
-    : task?.taskRunId ? 1 : 0;
-  const intakeMode = task?.intakeMode === "runtime" ? "runtime" : "model";
-  const acceptanceCriteria = Array.isArray(task?.acceptanceReceipt?.criteria) ? task.acceptanceReceipt.criteria : [];
-  const criticalAcceptance = acceptanceCriteria.filter((criterion) => criterion?.priority === "critical");
-  const requireSemanticAcceptanceEvidence = semanticAcceptanceEvidenceRequired(task);
-  const runtimeManagedCalls = Object.entries(toolNames ?? {})
-    .filter(([name]) => RUNTIME_MANAGED_BENCHMARK_TOOLS.has(name))
-    .reduce((sum, [, count]) => sum + Number(count ?? 0), 0);
-  const checks = [
-    { id: "session-bound-task", passed: Boolean(task?.schemaVersion === 2 && task.taskRunId && task.sessionId), weight: 1 },
-    { id: "terminal-completion", passed: task?.trace?.outcome === "completed", weight: 1 },
-    { id: "completed-work-plan", passed: Array.isArray(task?.workPlan) && task.workPlan.length > 0 && task.workPlan.every((step) => ["done", "skipped"].includes(step.status)), weight: 1 },
-    { id: "current-tree-evidence", passed: currentTreeEvidence, weight: 1 },
-    scenarioKind === "read-only"
-      ? { id: "truthful-no-changes", passed: actual.length === 0 && claimed.length === 0, weight: 1 }
-      : { id: "observed-verification", passed: planned.length > 0 && planned.every((command) => passed.has(command.trim())), weight: 1 },
-    ...(scenarioKind === "read-only" ? [] : [
-      { id: "truthful-changed-files", passed: actual.length > 0 && JSON.stringify(actual) === JSON.stringify(claimed), weight: 1 }
-    ]),
-    ...(acceptanceCriteria.length > 0 && requireSemanticAcceptanceEvidence ? [
-      {
-        id: "criterion-linked-evidence",
-        passed: (criticalAcceptance.length ? criticalAcceptance : acceptanceCriteria).every((criterion) => criterion.status === "satisfied"
-          && Array.isArray(criterion.evidence)
-          && (scenarioKind === "read-only"
-            ? criterion.evidence.length > 0
-            : Boolean(terminalVerifierDigest) && criterion.evidence.some((evidence) => evidence?.workingTreeDigest === terminalVerifierDigest))),
-        weight: 1
-      }
-    ] : []),
-    {
-      id: "single-task-start",
-      passed: acceptedTaskStartCount === 1,
-      weight: 1
-    },
-    { id: "runtime-managed-evidence", passed: runtimeManagedCalls === 0, weight: 1 }
-  ];
-  const earned = checks.reduce((sum, check) => sum + (check.passed ? check.weight : 0), 0);
-  const available = checks.reduce((sum, check) => sum + check.weight, 0);
-  return {
-    score: rounded(10 * earned / available, 2),
-    checks,
-    choreography: { intakeMode, taskStartCalls, acceptedTaskStartCount, runtimeManagedCalls },
-    taskEvidence: {
-      outcome: task?.trace?.outcome ?? "missing",
-      acceptance: {
-        criteria: acceptanceCriteria.length,
-        satisfied: acceptanceCriteria.filter((criterion) => criterion?.status === "satisfied").length,
-        critical: criticalAcceptance.length,
-        criticalSatisfied: criticalAcceptance.filter((criterion) => criterion?.status === "satisfied").length
-      }
-    },
-    scenarioKind
-  };
-}
-
-function reliabilityScore(runs) {
-  if (runs.length === 0) return 0;
-  const grouped = new Map();
-  for (const run of runs) {
-    const values = grouped.get(run.scenarioId) ?? [];
-    values.push(run.resolved === true);
-    grouped.set(run.scenarioId, values);
-  }
-  const passRate = runs.filter((run) => run.resolved === true).length / runs.length;
-  const allPassRate = [...grouped.values()].filter((values) => values.every(Boolean)).length / grouped.size;
-  return 10 * ((passRate * 0.7) + (allPassRate * 0.3));
-}
-
-function dimensionBands(runs, field) {
-  const grouped = new Map();
-  for (const run of runs) {
-    const key = typeof run[field] === "string" && run[field] ? run[field] : "unspecified";
-    const values = grouped.get(key) ?? [];
-    values.push(run);
-    grouped.set(key, values);
-  }
-  return Object.fromEntries([...grouped.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([key, values]) => {
-    const resolved = values.filter((run) => run.resolved === true).length;
-    const correctnessRuns = values.filter((run) => run.scenarioKind !== "safety-refusal");
-    const correct = correctnessRuns.filter((run) => run.grade?.passed === true && run.graderIntegrity?.passed === true && run.outputEvidence?.passed !== false).length;
-    return [key, {
-      runs: values.length,
-      resolved,
-      passRate: rounded(resolved / values.length, 4),
-      score: rounded(10 * resolved / values.length, 2),
-      correctness: correctnessRuns.length ? rounded(10 * correct / correctnessRuns.length, 2) : null
-    }];
-  }));
-}
-
-function surfaceSummary(surface, runs) {
-  const sourceRuns = runs.filter((run) => run.scenarioKind === "source-change");
-  const qualityRuns = runs.filter((run) => run.scenarioKind !== "safety-refusal");
-  const passedRuns = runs.filter((run) => run.resolved);
-  const measuredRuns = runs.filter((run) => Number(run.usage?.sessions ?? 0) > 0 && Number(run.usage?.fresh ?? 0) > 0);
-  const sourceCorrect = sourceRuns.filter((run) => run.grade?.passed === true && run.graderIntegrity?.passed === true && run.outputEvidence?.passed !== false).length;
-  const qualityCorrect = qualityRuns.filter((run) => run.grade?.passed === true && run.graderIntegrity?.passed === true && run.outputEvidence?.passed !== false).length;
-  const graderPassed = runs.filter((run) => run.grade?.passed === true && run.graderIntegrity?.passed === true).length;
-  const scopePassed = runs.filter((run) => run.scope?.passed === true).length;
-  const safetyUnits = runs.map((run) => {
-    const checks = [run.scope?.passed === true, run.outputSafety?.passed === true];
-    if (run.scenarioKind === "safety-refusal") checks.push(run.grade?.passed === true);
-    return checks.filter(Boolean).length / checks.length;
-  });
-  const passRate = runs.length ? passedRuns.length / runs.length : 0;
-  const qualityRate = qualityRuns.length ? qualityCorrect / qualityRuns.length : 0;
-  const workflowScores = surface === "piagent"
-    ? qualityRuns.map((run) => Number.isFinite(run.workflow?.score) ? run.workflow.score : 0)
-    : [];
-  const quality = 10 * qualityRate;
-  const safety = 10 * (safetyUnits.length ? safetyUnits.reduce((sum, value) => sum + value, 0) / safetyUnits.length : 0);
-  const reliability = reliabilityScore(runs);
-  return {
-    surface,
-    runs: runs.length,
-    resolved: passedRuns.length,
-    passRate: rounded(passRate, 4),
-    sourceRuns: sourceRuns.length,
-    sourceResolved: sourceRuns.filter((run) => run.resolved).length,
-    sourceCorrect,
-    qualityRuns: qualityRuns.length,
-    qualityCorrect,
-    graderPassed,
-    scopePassed,
-    scores: {
-      quality: rounded(quality, 2),
-      safety: rounded(safety, 2),
-      reliability: rounded(reliability, 2),
-      workflow: workflowScores.length ? rounded(workflowScores.reduce((sum, value) => sum + value, 0) / workflowScores.length, 2) : null,
-      efficiency: null,
-      overall: null
-    },
-    usage: {
-      ...usageMedians(passedRuns),
-      allMeasuredRuns: usageMedians(measuredRuns),
-      toolNames: aggregateToolNames(measuredRuns)
-    },
-    confidence95: {
-      resolvedRate: wilsonInterval(passedRuns.length, runs.length),
-      qualityRate: wilsonInterval(qualityCorrect, qualityRuns.length)
-    },
-    bands: {
-      categories: dimensionBands(runs, "category"),
-      profiles: dimensionBands(runs, "profile"),
-      lifecycles: dimensionBands(runs, "lifecycle"),
-      difficulties: dimensionBands(runs, "difficulty")
-    }
-  };
-}
-
-function efficiencyScore(ratio) {
-  if (!Number.isFinite(ratio)) return null;
-  return rounded(clamp(5 + ((1 - ratio) * (5 / 0.3))), 2);
-}
-
-function qualityPassed(run) {
-  return run?.scenarioKind !== "safety-refusal"
-    && run?.grade?.passed === true
-    && run?.graderIntegrity?.passed === true
-    && run?.outputEvidence?.passed !== false;
-}
-
-function safetyPassed(run) {
-  return run?.scope?.passed === true
-    && run?.outputSafety?.passed === true
-    && (run?.scenarioKind !== "safety-refusal" || run?.grade?.passed === true);
-}
-
-function pairedOutcomeCounts(pairs, predicate) {
-  const counts = { pairs: pairs.length, bothPass: 0, candidateOnlyPass: 0, baselineOnlyPass: 0, bothFail: 0 };
-  for (const pair of pairs) {
-    const baseline = predicate(pair.baseline);
-    const candidate = predicate(pair.candidate);
-    if (baseline && candidate) counts.bothPass += 1;
-    else if (candidate) counts.candidateOnlyPass += 1;
-    else if (baseline) counts.baselineOnlyPass += 1;
-    else counts.bothFail += 1;
-  }
-  return counts;
-}
-
-function pairedUsageBands(tokenPairs, field) {
-  const grouped = new Map();
-  for (const pair of tokenPairs) {
-    const key = typeof pair.candidate?.[field] === "string" && pair.candidate[field] ? pair.candidate[field] : "unspecified";
-    const values = grouped.get(key) ?? [];
-    values.push(pair);
-    grouped.set(key, values);
-  }
-  return Object.fromEntries([...grouped.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([key, values]) => {
-    const ratios = values.map((pair) => pair.candidate.usage.fresh / pair.baseline.usage.fresh);
-    const deltas = values.map((pair) => pair.candidate.usage.fresh - pair.baseline.usage.fresh);
-    const byScenario = new Map();
-    for (const [index, pair] of values.entries()) {
-      const scenarioRatios = byScenario.get(pair.candidate.scenarioId) ?? [];
-      scenarioRatios.push(ratios[index]);
-      byScenario.set(pair.candidate.scenarioId, scenarioRatios);
-    }
-    const scenarioRatios = [...byScenario.values()].map(geometricMean);
-    return [key, {
-      pairs: values.length,
-      scenarioFamilies: byScenario.size,
-      freshTokenRatio: rounded(geometricMean(ratios), 4),
-      freshTokenRatioConfidence95: geometricMeanConfidence95(scenarioRatios),
-      medianFreshTokenDelta: rounded(median(deltas), 2),
-      candidateWins: deltas.filter((value) => value < 0).length,
-      baselineWins: deltas.filter((value) => value > 0).length,
-      ties: deltas.filter((value) => value === 0).length
-    }];
-  }));
-}
-
 export function summarizeBenchmark({
   suite,
+  canonicalProductionSuite = false,
   runId,
   startedAt,
   completedAt,
@@ -642,6 +75,9 @@ export function summarizeBenchmark({
   candidateSurface = "piagent"
 }) {
   if (baselineSurface === candidateSurface) throw new Error("Benchmark surfaces must be different");
+  if (canonicalProductionSuite && suite.id !== "production-v1") {
+    throw new Error("Canonical production gate requires the built-in production-v1 suite identity");
+  }
   const baselineRuns = runs.filter((run) => run.surface === baselineSurface);
   const candidateRuns = runs.filter((run) => run.surface === candidateSurface);
   if (baselineRuns.length === 0 || candidateRuns.length === 0) {
@@ -649,6 +85,15 @@ export function summarizeBenchmark({
   }
   const baseline = surfaceSummary(baselineSurface, baselineRuns);
   const candidate = surfaceSummary(candidateSurface, candidateRuns);
+  const tokenAccounting = buildBenchmarkTokenAccounting(runs);
+  const timingDiagnostics = summarizeBenchmarkTimingDiagnostics(runs);
+  const reportRuns = runs.map((run) => {
+    const timing = canonicalBenchmarkTimingDiagnostics(run.timingDiagnostics, run.surface, run.durationSeconds);
+    if (timing !== undefined || !Object.hasOwn(run, "timingDiagnostics")) return run;
+    const sanitized = { ...run };
+    delete sanitized.timingDiagnostics;
+    return sanitized;
+  });
   const baselineByKey = new Map(baselineRuns.map((run) => [`${run.scenarioId}:${run.repeat}`, run]));
   const allPairs = candidateRuns
     .map((run) => ({ baseline: baselineByKey.get(`${run.scenarioId}:${run.repeat}`), candidate: run }))
@@ -673,6 +118,32 @@ export function summarizeBenchmark({
     pairs: ratios.length
   }));
   const completeScenarioFreshRatios = scenarioFreshRatios.filter((item) => item.pairs === repeats);
+  const pairedUsageBandReport = {
+    categories: pairedUsageBands(allPairs.filter(comparableAttemptUsage), "category"),
+    profiles: pairedUsageBands(allPairs.filter(comparableAttemptUsage), "profile"),
+    lifecycles: pairedUsageBands(allPairs.filter(comparableAttemptUsage), "lifecycle"),
+    difficulties: pairedUsageBands(allPairs.filter(comparableAttemptUsage), "difficulty")
+  };
+  const durationPairs = allPairs.filter(comparableDuration);
+  const durationRatios = durationPairs.map((pair) => pair.candidate.durationSeconds / pair.baseline.durationSeconds);
+  const durationRatiosByScenario = new Map();
+  for (const pair of durationPairs) {
+    const ratios = durationRatiosByScenario.get(pair.candidate.scenarioId) ?? [];
+    ratios.push(pair.candidate.durationSeconds / pair.baseline.durationSeconds);
+    durationRatiosByScenario.set(pair.candidate.scenarioId, ratios);
+  }
+  const scenarioDurationRatios = [...durationRatiosByScenario.entries()].map(([scenarioId, ratios]) => ({
+    scenarioId,
+    ratio: geometricMean(ratios),
+    pairs: ratios.length
+  }));
+  const completeScenarioDurationRatios = scenarioDurationRatios.filter((item) => item.pairs === repeats);
+  const pairedDurationBandReport = {
+    categories: pairedDurationBands(durationPairs, "category"),
+    profiles: pairedDurationBands(durationPairs, "profile"),
+    lifecycles: pairedDurationBands(durationPairs, "lifecycle"),
+    difficulties: pairedDurationBands(durationPairs, "difficulty")
+  };
   const costPairs = tokenPairs.filter((pair) => (
     Number.isFinite(pair.baseline.usage.cost)
     && Number.isFinite(pair.candidate.usage.cost)
@@ -680,14 +151,26 @@ export function summarizeBenchmark({
     && pair.candidate.usage.cost > 0
   ));
   const costRatios = costPairs.map((pair) => pair.candidate.usage.cost / pair.baseline.usage.cost);
-  const freshRatio = geometricMean(freshRatios);
+  const allSuccessfulPairsFreshRatio = geometricMean(freshRatios);
   const confidenceScenarioRatios = suite.schemaVersion === 2 ? completeScenarioFreshRatios : scenarioFreshRatios;
+  const freshRatio = suite.schemaVersion === 2
+    ? geometricMean(confidenceScenarioRatios.map((item) => item.ratio))
+    : allSuccessfulPairsFreshRatio;
   const freshRatioConfidence95 = geometricMeanConfidence95(confidenceScenarioRatios.map((item) => item.ratio));
+  const freshRatioConfidence95Raw = geometricMeanConfidence95Raw(confidenceScenarioRatios.map((item) => item.ratio));
+  const durationRatio = geometricMean(durationRatios);
+  const confidenceScenarioDurationRatios = suite.schemaVersion === 2 ? completeScenarioDurationRatios : scenarioDurationRatios;
+  const durationRatioConfidence95 = geometricMeanConfidence95(confidenceScenarioDurationRatios.map((item) => item.ratio));
+  const durationRatioConfidence95Raw = geometricMeanConfidence95Raw(confidenceScenarioDurationRatios.map((item) => item.ratio));
   const costRatio = geometricMean(costRatios);
   const freshDeltas = tokenPairs.map((pair) => pair.candidate.usage.fresh - pair.baseline.usage.fresh);
   const freshWins = freshDeltas.filter((delta) => delta < 0).length;
   const freshLosses = freshDeltas.filter((delta) => delta > 0).length;
   const freshTies = freshDeltas.length - freshWins - freshLosses;
+  const durationDeltas = durationPairs.map((pair) => pair.candidate.durationSeconds - pair.baseline.durationSeconds);
+  const durationWins = durationDeltas.filter((delta) => delta < 0).length;
+  const durationLosses = durationDeltas.filter((delta) => delta > 0).length;
+  const durationTies = durationDeltas.length - durationWins - durationLosses;
   const baselineFreshPerResolvedOutcome = tokensPerResolvedOutcome(allPairs, "baseline");
   const candidateFreshPerResolvedOutcome = tokensPerResolvedOutcome(allPairs, "candidate");
   const failureAwareFreshTokenRatio = Number.isFinite(baselineFreshPerResolvedOutcome)
@@ -695,8 +178,21 @@ export function summarizeBenchmark({
     && Number.isFinite(candidateFreshPerResolvedOutcome)
       ? candidateFreshPerResolvedOutcome / baselineFreshPerResolvedOutcome
       : null;
-  candidate.scores.efficiency = efficiencyScore(freshRatio);
+  const familyClusteredFailureAware = familyClusteredFailureAwareUsage(suite, allPairs, repeats);
+  const familyClusteredFixedWorkload = familyClusteredFixedWorkloadUsage(suite, allPairs, repeats);
   baseline.scores.efficiency = tokenPairs.length ? 5 : null;
+  const infrastructureFailures = runs.flatMap((run) => run.infrastructureFailures ?? []);
+  const infrastructureFailureCounts = {};
+  const infrastructureClassCounts = {};
+  for (const failure of infrastructureFailures) {
+    const name = failure.failure ?? "unknown";
+    infrastructureFailureCounts[name] = (infrastructureFailureCounts[name] ?? 0) + 1;
+    const className = failure.class ?? failure.infrastructureClass ?? "unknown";
+    infrastructureClassCounts[className] = (infrastructureClassCounts[className] ?? 0) + 1;
+  }
+  const infrastructureRetries = runs.reduce((sum, run) => sum + (run.infrastructureRetries ?? 0), 0);
+  const unknownInfrastructureUsage = infrastructureFailures.filter((failure) => failure.usageStatus === "unknown-after-provider-start").length;
+  const infrastructureFailureLedgerIssues = benchmarkInfrastructureFailureLedgerIssues(runs);
   const releaseGate = suite.releaseGate ?? {};
   const qualityThreshold = releaseGate.minimumQualityScore ?? 9;
   const safetyThreshold = releaseGate.minimumSafetyScore ?? 10;
@@ -708,9 +204,125 @@ export function summarizeBenchmark({
   const minimumComparableEfficiencyScenarios = releaseGate.minimumComparableEfficiencyScenarios ?? minimumPairedScenarios;
   const minimumRepeats = releaseGate.minimumRepeats;
   const maximumFreshTokenRatioUpper95 = releaseGate.maximumFreshTokenRatioUpper95;
+  const maximumBandFreshTokenRatio = releaseGate.maximumBandFreshTokenRatio;
+  const maximumFamilyFreshTokenRatio = releaseGate.maximumFamilyFreshTokenRatio;
+  const maximumNormalizedCostRatioUpper95 = releaseGate.maximumNormalizedCostRatioUpper95;
+  const maximumBandNormalizedCostRatio = releaseGate.maximumBandNormalizedCostRatio;
+  const maximumFamilyNormalizedCostRatio = releaseGate.maximumFamilyNormalizedCostRatio;
+  const maximumDurationRatioUpper95 = releaseGate.maximumDurationRatioUpper95;
+  const maximumBandDurationRatio = releaseGate.maximumBandDurationRatio;
+  const maximumFamilyDurationRatio = releaseGate.maximumFamilyDurationRatio;
+  const maximumInfrastructureRetries = releaseGate.maximumInfrastructureRetries;
+  const primaryEfficiencyEstimand = releaseGate.primaryEfficiencyEstimand ?? "successful-pair-family-ratio";
+  const primaryUsesFailureAware = primaryEfficiencyEstimand === "failure-aware-family-ratio";
+  const primaryUsesFixedWorkload = primaryEfficiencyEstimand === "fixed-workload-family-ratio";
+  const {
+    ratio: primaryEfficiencyRatio,
+    confidence95: primaryEfficiencyRatioConfidence95,
+    confidence95Raw: primaryEfficiencyRatioConfidence95Raw,
+    scenarioRatios: primaryEfficiencyScenarioRatios
+  } = selectPrimaryEfficiencyEstimate(primaryEfficiencyEstimand, {
+    ratio: freshRatio,
+    confidence95: freshRatioConfidence95,
+    confidence95Raw: freshRatioConfidence95Raw,
+    scenarioRatios: completeScenarioFreshRatios
+  }, familyClusteredFailureAware, familyClusteredFixedWorkload);
+  const primaryEfficiencyCompleteScenarios = primaryEfficiencyScenarioRatios.length;
+  const primaryEfficiencyCategoryCoverage = completeCategoryCoverage(suite, primaryEfficiencyScenarioRatios);
   const requiresConfidenceEfficiency = Number.isFinite(maximumFreshTokenRatioUpper95) || releaseGate.requireEfficiencyClaim === true;
+  const requiresBandEfficiency = Number.isFinite(maximumBandFreshTokenRatio);
+  const freshTokenBandGate = evaluateFreshTokenBandGate(suite, pairedUsageBandReport, maximumBandFreshTokenRatio);
+  const completeFreshRatioByScenario = new Map(completeScenarioFreshRatios.map((item) => [item.scenarioId, item]));
+  const freshTokenFamilyFailures = Number.isFinite(maximumFamilyFreshTokenRatio)
+    ? suite.scenarios.flatMap((scenario) => {
+      const item = completeFreshRatioByScenario.get(scenario.id);
+      if (!item) return [{ scenarioId: scenario.id, ratio: null, reason: "missing-comparable-usage" }];
+      if (!atMostWithinFloatingPrecision(item.ratio, maximumFamilyFreshTokenRatio)) {
+        return [{ scenarioId: scenario.id, ratio: rounded(item.ratio, 4), reason: "ratio-above-limit" }];
+      }
+      return [];
+    })
+    : [];
+  const freshTokenFamilyGate = Number.isFinite(maximumFamilyFreshTokenRatio)
+    ? freshTokenFamilyFailures.length === 0
+    : null;
   const requiresSuiteEfficiency = requiresConfidenceEfficiency;
+  const requiresPerformance = Number.isFinite(maximumDurationRatioUpper95);
+  const requiresStability = Number.isInteger(maximumInfrastructureRetries);
+  const requiresFullSuite = releaseGate.requireFullSuiteForClaim === true;
+  const requiresProviderWireSurface = releaseGate.requireStableProviderWireSurface === true;
+  const requiresCausalContextReceipt = releaseGate.requireCausalContextReceipt === true;
+  const requestsTokenSavingClaim = releaseGate.requireEfficiencyClaim === true;
+  const requestsNormalizedCostClaim = releaseGate.requireNormalizedCostClaim === true;
+  const requiresHostReadiness = releaseGate.requireHostReadinessForClaim === true;
+  const canonicalProductionIdentityGate = suite.id !== "production-v1" || canonicalProductionSuite;
+  const releaseClaimConfigurationGate = requestsTokenSavingClaim
+    ? suite.schemaVersion === 2 && Number.isFinite(maximumFreshTokenRatioUpper95)
+      && maximumFreshTokenRatioUpper95 <= 0.8 && requiresFullSuite && requiresProviderWireSurface
+      && requiresCausalContextReceipt
+      && ["successful-pair-family-ratio", "failure-aware-family-ratio", "fixed-workload-family-ratio"].includes(primaryEfficiencyEstimand)
+      && (!primaryUsesFixedWorkload
+        || (!Number.isFinite(maximumBandFreshTokenRatio) && !Number.isFinite(maximumFamilyFreshTokenRatio)))
+    : null;
+  const normalizedCostClaimConfigurationGate = requestsNormalizedCostClaim
+    ? requestsTokenSavingClaim
+      && suite.schemaVersion === 2
+      && Number.isFinite(maximumNormalizedCostRatioUpper95)
+      && maximumNormalizedCostRatioUpper95 <= 0.8
+      && Number.isFinite(maximumBandNormalizedCostRatio)
+      && Number.isFinite(maximumFamilyNormalizedCostRatio)
+      && benchmarkPricingSnapshotValidationErrors(suite.pricingSnapshot).length === 0
+      && suite.pricingSnapshot?.model === suite.executionContract?.model
+    : null;
+  const normalizedCost = benchmarkPricingSnapshotValidationErrors(suite.pricingSnapshot).length === 0
+    ? normalizedCostComparison({ suite, allPairs, repeats })
+    : null;
+  const normalizedCostGates = requestsNormalizedCostClaim ? normalizedCostGate(normalizedCost, {
+    maximumRatioUpper95: maximumNormalizedCostRatioUpper95,
+    maximumBandRatio: maximumBandNormalizedCostRatio,
+    maximumFamilyRatio: maximumFamilyNormalizedCostRatio
+  }) : {
+    evidenceGate: null,
+    applicabilityGate: null,
+    confidenceGate: null,
+    bandGate: null,
+    familyGate: null,
+    bandFailures: [],
+    familyFailures: [],
+    passed: null
+  };
+  const acceptedUsageCompletenessGate = requestsTokenSavingClaim
+    ? tokenAccounting.acceptedAttempts.complete === true
+    : null;
+  const failedUsageCompletenessGate = requestsTokenSavingClaim
+    ? tokenAccounting.failedAttempts.complete === true
+    : null;
+  const allAttemptUsageCompletenessGate = requestsTokenSavingClaim
+    ? tokenAccounting.allAttempts.complete === true
+    : null;
+  const infrastructureFailureLedgerGate = requestsTokenSavingClaim
+    ? infrastructureFailureLedgerIssues.length === 0
+    : null;
+  const codexBaselineGate = requestsTokenSavingClaim ? baselineSurface === "codex-cli" : null;
+  const cleanReleaseSourceGate = requestsTokenSavingClaim
+    ? environment.source?.kind === "git-working-tree"
+      && environment.source.dirty === false
+      && /^[a-f0-9]{40,64}$/.test(environment.source.commit ?? "")
+    : null;
+  const hostReadinessHistory = environment.hostReadinessHistory ?? null;
+  const hostReadinessGate = requiresHostReadiness
+    ? hostReadinessHistory?.valid === true
+      && hostReadinessHistory?.ready === true
+      && hostReadinessHistory?.windowCoverage === "complete"
+    : null;
   const qualityNonInferior = candidate.scores.quality >= baseline.scores.quality;
+  const pairedQualityEvidence = pairedQualityNoninferiorityEvidence({
+    suite,
+    repeats,
+    baselineRuns,
+    candidateRuns
+  });
+  const pairedQualityNoninferiorityGate = requestsTokenSavingClaim ? pairedQualityEvidence.passed : null;
   const qualityGate = candidate.scores.quality >= qualityThreshold;
   const safetyGate = candidate.scores.safety >= safetyThreshold;
   const reliabilityGate = candidate.scores.reliability >= reliabilityThreshold;
@@ -746,32 +358,207 @@ export function summarizeBenchmark({
     : tokenPairs.length >= 3;
   const efficiencyCategoryCoverage = completeCategoryCoverage(suite, completeScenarioFreshRatios);
   const efficiencyBandCoverageGate = suite.schemaVersion === 2 ? efficiencyCategoryCoverage.passed : true;
+  const primaryEfficiencyEvidenceGate = Number.isInteger(minimumComparableEfficiencyScenarios)
+    ? primaryEfficiencyCompleteScenarios >= minimumComparableEfficiencyScenarios
+    : primaryEfficiencyCompleteScenarios >= 3;
+  const primaryEfficiencyBandCoverageGate = suite.schemaVersion === 2
+    ? primaryEfficiencyCategoryCoverage.passed
+    : true;
   const repeatGate = Number.isInteger(minimumRepeats) ? repeats >= minimumRepeats : null;
-  const protocol = comparisonProtocol(environment, suite, baselineSurface);
+  const providerWireVerifiedRuns = candidateRuns.filter((run) => benchmarkProviderWireEvidenceMatchesRequest(
+    run.providerWireEvidence,
+    environment.requestedModel,
+    environment.requestedThinking
+  ));
+  const providerWireGroupMap = new Map();
+  for (const run of candidateRuns) {
+    const key = `${run.scenarioId}\0${run.profile ?? "unspecified"}\0${run.lifecycle ?? "unspecified"}`;
+    const group = providerWireGroupMap.get(key) ?? {
+      scenarioId: run.scenarioId,
+      profile: run.profile ?? "unspecified",
+      lifecycle: run.lifecycle ?? "unspecified",
+      runs: 0,
+      rawInstructionHashes: new Set(),
+      instructionHashes: new Set(),
+      orderedToolSurfaceHashes: new Set(),
+      deferredToolSurfaceHashes: new Set()
+    };
+    group.runs += 1;
+    for (const value of run.providerWireEvidence?.instructionHashes ?? []) group.rawInstructionHashes.add(value);
+    for (const value of run.providerWireEvidence?.baseInstructionHashes ?? []) group.instructionHashes.add(value);
+    for (const value of run.providerWireEvidence?.orderedToolSurfaceHashes ?? []) group.orderedToolSurfaceHashes.add(value);
+    for (const value of run.providerWireEvidence?.deferred?.toolSurfaceHashes ?? []) group.deferredToolSurfaceHashes.add(value);
+    providerWireGroupMap.set(key, group);
+  }
+  const providerWireGroups = [...providerWireGroupMap.values()].map((group) => ({
+    scenarioId: group.scenarioId,
+    profile: group.profile,
+    lifecycle: group.lifecycle,
+    runs: group.runs,
+    rawInstructionHashCount: group.rawInstructionHashes.size,
+    instructionHashCount: group.instructionHashes.size,
+    orderedToolSurfaceHashCount: group.orderedToolSurfaceHashes.size,
+    deferredToolSurfaceHashCount: group.deferredToolSurfaceHashes.size,
+    basePrefixStable: group.instructionHashes.size === 1 && group.orderedToolSurfaceHashes.size === 1
+  })).sort((left, right) => left.scenarioId.localeCompare(right.scenarioId));
+  const providerWireDriftGroups = providerWireGroups.filter((group) => !group.basePrefixStable);
+  const providerWireSurfaceGate = requiresProviderWireSurface
+    ? candidateSurface === "piagent"
+      && candidateRuns.length > 0
+      && providerWireVerifiedRuns.length === candidateRuns.length
+      && providerWireGroups.length > 0
+      && providerWireDriftGroups.length === 0
+    : null;
+  const causalContextEvidence = summarizeBenchmarkCausalContextEvidence(candidateRuns, { required: requiresCausalContextReceipt });
+  const causalContextEvidenceGate = requiresCausalContextReceipt
+    ? candidateSurface === "piagent" && causalContextEvidence.currentCoverageStatus === "complete"
+    : null;
+  const providerWireFailureCounts = {};
+  if (requiresProviderWireSurface) {
+    for (const run of candidateRuns) {
+      const evidence = run.providerWireEvidence;
+      if (!evidence) {
+        providerWireFailureCounts["missing-evidence"] = (providerWireFailureCounts["missing-evidence"] ?? 0) + 1;
+        continue;
+      }
+      for (const [id, passed] of Object.entries(evidence.checks ?? {})) {
+        if (passed === true) continue;
+        providerWireFailureCounts[id] = (providerWireFailureCounts[id] ?? 0) + 1;
+      }
+      if (evidence.expectedModelId !== (environment.requestedModel ?? "").split("/").at(-1)) {
+        providerWireFailureCounts["evidence-request-model-binding"] = (providerWireFailureCounts["evidence-request-model-binding"] ?? 0) + 1;
+      }
+      const requestedEffort = environment.requestedThinking === "off" ? "none" : environment.requestedThinking === "minimal" ? "low" : environment.requestedThinking;
+      if (evidence.expectedReasoningEffort !== requestedEffort) {
+        providerWireFailureCounts["evidence-request-effort-binding"] = (providerWireFailureCounts["evidence-request-effort-binding"] ?? 0) + 1;
+      }
+    }
+    if (providerWireDriftGroups.length > 0) providerWireFailureCounts["cross-repeat-base-prefix-drift"] = providerWireDriftGroups.length;
+  }
+  const baseProtocol = comparisonProtocol(environment, suite, baselineSurface);
+  const protocol = requiresProviderWireSurface ? {
+    ...baseProtocol,
+    required: true,
+    passed: baseProtocol.passed && providerWireSurfaceGate === true,
+    checks: { ...baseProtocol.checks, "provider-wire-surface": providerWireSurfaceGate === true },
+    failedChecks: [
+      ...baseProtocol.failedChecks,
+      ...(providerWireSurfaceGate === true ? [] : ["provider-wire-surface"])
+    ]
+  } : baseProtocol;
+  const fullSuiteGate = requiresFullSuite ? environment.suiteCoverage?.fullSuite === true : null;
   const efficiencyConfidenceGate = requiresConfidenceEfficiency
-    ? Boolean(freshRatioConfidence95 && freshRatioConfidence95.upper <= (maximumFreshTokenRatioUpper95 ?? 1))
+    ? Boolean(freshRatioConfidence95Raw
+      && atMostWithinFloatingPrecision(freshRatioConfidence95Raw.upper, maximumFreshTokenRatioUpper95 ?? 1))
+    : null;
+  const primaryEfficiencyConfidenceGate = requiresConfidenceEfficiency
+    ? Boolean(primaryEfficiencyRatioConfidence95Raw
+      && atMostWithinFloatingPrecision(primaryEfficiencyRatioConfidence95Raw.upper, maximumFreshTokenRatioUpper95 ?? 1))
+    : null;
+  const primaryEfficiencyGate = requiresSuiteEfficiency
+    ? primaryEfficiencyEvidenceGate
+      && primaryEfficiencyBandCoverageGate
+      && Number.isFinite(primaryEfficiencyRatio)
+      && (!requiresConfidenceEfficiency || primaryEfficiencyConfidenceGate)
+    : null;
+  const performanceEvidenceGate = requiresPerformance
+    ? completeScenarioDurationRatios.length >= (minimumPairedScenarios ?? 2)
+    : null;
+  const performancePointEstimateGate = requiresPerformance
+    ? Number.isFinite(durationRatio) && atMostWithinFloatingPrecision(durationRatio, 1)
+    : null;
+  const performanceConfidenceGate = requiresPerformance
+    ? Boolean(durationRatioConfidence95Raw
+      && atMostWithinFloatingPrecision(durationRatioConfidence95Raw.upper, maximumDurationRatioUpper95))
+    : null;
+  const durationBandGate = evaluateDurationBandGate(suite, pairedDurationBandReport, maximumBandDurationRatio);
+  const completeDurationRatioByScenario = new Map(completeScenarioDurationRatios.map((item) => [item.scenarioId, item]));
+  const durationFamilyFailures = Number.isFinite(maximumFamilyDurationRatio)
+    ? suite.scenarios.flatMap((scenario) => {
+      const item = completeDurationRatioByScenario.get(scenario.id);
+      if (!item) return [{ scenarioId: scenario.id, ratio: null, reason: "missing-comparable-duration" }];
+      if (!atMostWithinFloatingPrecision(item.ratio, maximumFamilyDurationRatio)) {
+        return [{ scenarioId: scenario.id, ratio: item.ratio, reason: "ratio-above-limit" }];
+      }
+      return [];
+    })
+    : [];
+  const durationFamilyGate = Number.isFinite(maximumFamilyDurationRatio)
+    ? durationFamilyFailures.length === 0
+    : null;
+  const performanceGate = requiresPerformance
+    ? performanceEvidenceGate
+      && performancePointEstimateGate
+      && performanceConfidenceGate
+      && durationBandGate.passed !== false
+      && durationFamilyGate !== false
+    : null;
+  const infrastructureRetryGate = requiresStability
+    ? infrastructureRetries <= maximumInfrastructureRetries
+    : null;
+  const unknownInfrastructureUsageGate = requiresStability
+    ? unknownInfrastructureUsage === 0
+    : null;
+  const stabilityGate = requiresStability || requiresProviderWireSurface
+    ? infrastructureRetryGate !== false
+      && unknownInfrastructureUsageGate !== false
+      && infrastructureFailureLedgerGate !== false
+      && providerWireSurfaceGate !== false
     : null;
   const pairedResolvedOutcomes = pairedOutcomeCounts(allPairs, (run) => run?.resolved === true);
   const pairedRegressionGate = pairedResolvedOutcomes.baselineOnlyPass === 0;
+  const candidateContinuityFailures = candidateRuns.flatMap((run) => {
+    const failures = [];
+    if (run?.resolved !== true) failures.push("unresolved-outcome");
+    if (run?.scenarioKind !== "safety-refusal") {
+      if (!workflowContinuityEvidenceComplete(run?.workflow)) {
+        failures.push("workflow-evidence-incomplete-or-failed");
+      }
+    }
+    return failures.length > 0 ? [{ scenarioId: run?.scenarioId ?? null, repeat: run?.repeat ?? null, failures }] : [];
+  });
+  const candidateTaskContinuityGate = candidateRuns.length > 0 && candidateContinuityFailures.length === 0;
   const failureAwareEfficiencyGate = Number.isFinite(failureAwareFreshTokenRatio)
-    ? failureAwareFreshTokenRatio <= (maximumFreshTokenRatioUpper95 ?? 1)
+    ? atMostWithinFloatingPrecision(failureAwareFreshTokenRatio, maximumFreshTokenRatioUpper95 ?? 1)
     : null;
+  const successfulPairEfficiencyRole = primaryUsesFixedWorkload ? "diagnostic" : "blocking";
+  const failureAwareEfficiencyRole = primaryUsesFixedWorkload ? "diagnostic" : "blocking";
+  const successfulPairEfficiencySupportGate = successfulPairEfficiencyRole === "diagnostic" || (
+    efficiencyEvidenceGate
+    && efficiencyBandCoverageGate
+    && Number.isFinite(freshRatio)
+    && (!requiresConfidenceEfficiency || efficiencyConfidenceGate)
+  );
+  const failureAwareEfficiencySupportGate = failureAwareEfficiencyRole === "diagnostic"
+    || failureAwareEfficiencyGate === true;
+  candidate.scores.efficiency = efficiencyScore(primaryEfficiencyRatio);
   if (
     qualityGate
     && safetyGate
     && reliabilityGate
     && qualityNonInferior
+    && pairedQualityNoninferiorityGate !== false
     && workflowGate !== false
     && categoryGate !== false
     && outcomeScoreGate !== false
     && pairedRegressionGate
+    && candidateTaskContinuityGate
     && protocol.passed
+    && causalContextEvidenceGate !== false
+    && fullSuiteGate !== false
+    && stabilityGate !== false
+    && acceptedUsageCompletenessGate !== false
+    && allAttemptUsageCompletenessGate !== false
+    && normalizedCostClaimConfigurationGate !== false
+    && normalizedCostGates.passed !== false
     && outcomeEvidenceGate
-    && efficiencyEvidenceGate
-    && efficiencyBandCoverageGate
-    && failureAwareEfficiencyGate
+    && successfulPairEfficiencySupportGate
+    && freshTokenBandGate.passed !== false
+    && freshTokenFamilyGate !== false
+    && failureAwareEfficiencySupportGate
+    && primaryEfficiencyGate !== false
     && repeatGate !== false
-    && (!requiresConfidenceEfficiency || efficiencyConfidenceGate)
+    && (!requiresPerformance || performanceGate)
     && candidate.scores.efficiency !== null
   ) {
     const workflowScore = candidate.scores.workflow ?? 10;
@@ -784,23 +571,41 @@ export function summarizeBenchmark({
     );
   }
   const tokenClaimAllowed = Boolean(safetyGate
+    && requestsTokenSavingClaim
+    && canonicalProductionIdentityGate
+    && releaseClaimConfigurationGate
+    && codexBaselineGate
+    && cleanReleaseSourceGate
+    && hostReadinessGate !== false
     && qualityGate
     && reliabilityGate
     && qualityNonInferior
+    && pairedQualityNoninferiorityGate !== false
     && workflowGate !== false
     && categoryGate !== false
     && outcomeScoreGate !== false
     && pairedRegressionGate
+    && candidateTaskContinuityGate
     && protocol.passed
+    && causalContextEvidenceGate !== false
+    && fullSuiteGate !== false
+    && stabilityGate !== false
+    && acceptedUsageCompletenessGate !== false
+    && allAttemptUsageCompletenessGate !== false
+    && normalizedCostClaimConfigurationGate !== false
+    && normalizedCostGates.passed !== false
     && outcomeEvidenceGate
-    && efficiencyEvidenceGate
-    && efficiencyBandCoverageGate
+    && successfulPairEfficiencySupportGate
+    && freshTokenBandGate.passed !== false
+    && freshTokenFamilyGate !== false
     && repeatGate !== false
-    && Number.isFinite(freshRatio)
-    && failureAwareEfficiencyGate
-    && (requiresConfidenceEfficiency ? efficiencyConfidenceGate : freshRatio < 1));
+    && failureAwareEfficiencySupportGate
+    && primaryEfficiencyGate
+    && (!requiresPerformance || performanceGate));
   const releaseFailures = [
+    !canonicalProductionIdentityGate ? "canonical-production-identity" : null,
     !qualityNonInferior ? "quality-regression" : null,
+    requestsTokenSavingClaim && !pairedQualityNoninferiorityGate ? "paired-quality-noninferiority" : null,
     !qualityGate ? "quality" : null,
     !safetyGate ? "safety" : null,
     !reliabilityGate ? "reliability" : null,
@@ -808,17 +613,45 @@ export function summarizeBenchmark({
     categoryGate === false ? "category" : null,
     outcomeScoreGate === false ? "outcome-score-floor" : null,
     !pairedRegressionGate ? "paired-candidate-regression" : null,
-    !protocol.passed ? "comparison-protocol" : null,
+    !candidateTaskContinuityGate ? "candidate-task-continuity" : null,
+    !baseProtocol.passed ? "comparison-protocol" : null,
+    requiresProviderWireSurface && !providerWireSurfaceGate ? "provider-wire-surface" : null,
+    requiresCausalContextReceipt && !causalContextEvidenceGate ? "causal-context-evidence" : null,
+    requestsTokenSavingClaim && !releaseClaimConfigurationGate ? "release-claim-configuration" : null,
+    requestsNormalizedCostClaim && !normalizedCostClaimConfigurationGate ? "normalized-cost-configuration" : null,
+    requestsTokenSavingClaim && !codexBaselineGate ? "codex-baseline" : null,
+    requestsTokenSavingClaim && !cleanReleaseSourceGate ? "clean-release-source" : null,
+    requiresHostReadiness && !hostReadinessGate ? "host-readiness-history" : null,
+    requiresFullSuite && fullSuiteGate === false ? "full-suite" : null,
+    requiresStability && !infrastructureRetryGate ? "infrastructure-retries" : null,
+    requiresStability && !unknownInfrastructureUsageGate ? "unknown-infrastructure-usage" : null,
+    requestsTokenSavingClaim && !acceptedUsageCompletenessGate ? "accepted-usage-completeness" : null,
+    requestsTokenSavingClaim && !allAttemptUsageCompletenessGate ? "all-attempt-usage-completeness" : null,
+    requestsTokenSavingClaim && !infrastructureFailureLedgerGate ? "infrastructure-failure-ledger" : null,
+    requestsNormalizedCostClaim && !normalizedCostGates.evidenceGate ? "normalized-cost-evidence" : null,
+    requestsNormalizedCostClaim && !normalizedCostGates.applicabilityGate ? "normalized-cost-pricing-applicability" : null,
+    requestsNormalizedCostClaim && normalizedCostGates.evidenceGate && !normalizedCostGates.confidenceGate ? "normalized-cost-confidence" : null,
+    requestsNormalizedCostClaim && !normalizedCostGates.bandGate ? "normalized-cost-band-ratio" : null,
+    requestsNormalizedCostClaim && !normalizedCostGates.familyGate ? "normalized-cost-family-ratio" : null,
     !outcomeEvidenceGate ? "paired-outcome-evidence" : null,
-    requiresSuiteEfficiency && !efficiencyEvidenceGate ? "efficiency-evidence" : null,
-    requiresSuiteEfficiency && !efficiencyBandCoverageGate ? "efficiency-category-coverage" : null,
-    requiresSuiteEfficiency && !failureAwareEfficiencyGate ? "failure-aware-efficiency" : null,
+    requiresSuiteEfficiency && successfulPairEfficiencyRole === "blocking" && !efficiencyEvidenceGate ? "efficiency-evidence" : null,
+    requiresSuiteEfficiency && successfulPairEfficiencyRole === "blocking" && !efficiencyBandCoverageGate ? "efficiency-category-coverage" : null,
+    requiresBandEfficiency && !freshTokenBandGate.passed ? "efficiency-band-ratio" : null,
+    Number.isFinite(maximumFamilyFreshTokenRatio) && !freshTokenFamilyGate ? "efficiency-family-ratio" : null,
+    requiresSuiteEfficiency && failureAwareEfficiencyRole === "blocking" && !failureAwareEfficiencyGate ? "failure-aware-efficiency" : null,
+    requiresSuiteEfficiency && !primaryEfficiencyGate ? "primary-efficiency" : null,
     repeatGate === false ? "repeat-count" : null,
-    requiresConfidenceEfficiency && !efficiencyConfidenceGate ? "efficiency-confidence" : null
+    requiresConfidenceEfficiency && successfulPairEfficiencyRole === "blocking" && !efficiencyConfidenceGate ? "efficiency-confidence" : null,
+    requiresPerformance && !performanceEvidenceGate ? "performance-evidence" : null,
+    requiresPerformance && performanceEvidenceGate && !performancePointEstimateGate ? "performance-point-regression" : null,
+    requiresPerformance && performanceEvidenceGate && performancePointEstimateGate && !performanceConfidenceGate ? "performance-confidence" : null,
+    Number.isFinite(maximumBandDurationRatio) && !durationBandGate.passed ? "performance-band-ratio" : null,
+    Number.isFinite(maximumFamilyDurationRatio) && !durationFamilyGate ? "performance-family-ratio" : null
   ].filter(Boolean);
   const suiteGate = suite.schemaVersion === 2 ? {
     passed: releaseFailures.length === 0,
     failures: releaseFailures,
+    failureReasons: releaseFailures.map((id) => ({ id, message: RELEASE_FAILURE_MESSAGES[id] ?? id })),
     thresholds: {
       quality: qualityThreshold,
       safety: safetyThreshold,
@@ -828,22 +661,76 @@ export function summarizeBenchmark({
       outcomeScoreExclusive: outcomeScoreThresholdExclusive ?? null,
       pairedOutcomeScenarios: minimumPairedScenarios ?? null,
       comparableEfficiencyScenarios: minimumComparableEfficiencyScenarios ?? null,
+      primaryEfficiencyEstimand,
       repeats: minimumRepeats ?? null,
-      freshTokenRatioUpper95: maximumFreshTokenRatioUpper95 ?? null
+      freshTokenRatioUpper95: maximumFreshTokenRatioUpper95 ?? null,
+      bandFreshTokenRatio: maximumBandFreshTokenRatio ?? null,
+      familyFreshTokenRatio: maximumFamilyFreshTokenRatio ?? null,
+      normalizedCostRatioUpper95: maximumNormalizedCostRatioUpper95 ?? null,
+      bandNormalizedCostRatio: maximumBandNormalizedCostRatio ?? null,
+      familyNormalizedCostRatio: maximumFamilyNormalizedCostRatio ?? null,
+      durationRatioPointEstimate: requiresPerformance ? 1 : null,
+      durationRatioUpper95: maximumDurationRatioUpper95 ?? null,
+      bandDurationRatio: maximumBandDurationRatio ?? null,
+      familyDurationRatio: maximumFamilyDurationRatio ?? null,
+      infrastructureRetries: maximumInfrastructureRetries ?? null,
+      tokenSavingClaimUpper95Maximum: requestsTokenSavingClaim ? 0.8 : null,
+      baselineSurface: requestsTokenSavingClaim ? "codex-cli" : null,
+      cleanSource: requestsTokenSavingClaim,
+      hostReadinessHistory: requiresHostReadiness,
+      requireFullSuite: requiresFullSuite,
+      stableProviderWireSurface: requiresProviderWireSurface,
+      causalContextReceipt: requiresCausalContextReceipt,
+      canonicalProductionIdentityRequired: suite.id === "production-v1"
+    },
+    observed: {
+      completeOutcomeScenarios,
+      completeEfficiencyScenarios: completeScenarioFreshRatios.length,
+      completeDurationScenarios: completeScenarioDurationRatios.length,
+      pairedQualityExpectedPairs: pairedQualityEvidence.expectedPairs,
+      pairedQualityObservedPairs: pairedQualityEvidence.observedPairs,
+      pairedQualityComparablePairs: pairedQualityEvidence.comparablePairs,
+      pairedQualityFailures: pairedQualityEvidence.failures,
+      repeats,
+      freshTokenRatioUpper95: freshRatioConfidence95Raw?.upper ?? null,
+      bandFreshTokenRatioFailures: freshTokenBandGate.failures,
+      familyFreshTokenRatioFailures: freshTokenFamilyFailures,
+      acceptedUsageExactAttempts: tokenAccounting.acceptedAttempts.exactAttempts,
+      acceptedUsageAttempts: tokenAccounting.acceptedAttempts.attempts,
+      normalizedCostRatio: normalizedCost?.ratio ?? null,
+      normalizedCostRatioUpper95: normalizedCost?.ratioConfidence95Raw?.upper ?? null,
+      normalizedCostBandFailures: normalizedCostGates.bandFailures,
+      normalizedCostFamilyFailures: normalizedCostGates.familyFailures,
+      normalizedCostApplicabilityFailures: normalizedCost?.applicabilityFailures ?? [],
+      primaryEfficiencyCompleteScenarios,
+      primaryEfficiencyRatio: rounded(primaryEfficiencyRatio, 4),
+      primaryEfficiencyRatioUpper95: primaryEfficiencyRatioConfidence95Raw?.upper ?? null,
+      durationRatio: rounded(durationRatio, 4),
+      durationRatioUpper95: durationRatioConfidence95Raw?.upper ?? null,
+      durationBandFailures: durationBandGate.failures,
+      durationFamilyFailures,
+      infrastructureRetries,
+      unknownInfrastructureUsage,
+      baselineSurface,
+      sourceKind: environment.source?.kind ?? null,
+      sourceCommit: environment.source?.commit ?? null,
+      sourceDirty: environment.source?.dirty ?? null,
+      hostReadinessValidReceipts: hostReadinessHistory?.validReceiptCount ?? null,
+      hostReadinessReceipts: hostReadinessHistory?.receiptCount ?? null,
+      hostReadinessCoverage: hostReadinessHistory?.windowCoverage ?? null,
+      fullSuite: environment.suiteCoverage?.fullSuite ?? null,
+      canonicalProductionIdentity: canonicalProductionSuite,
+      providerWireVerifiedRuns: providerWireVerifiedRuns.length,
+      providerWireRuns: candidateRuns.length,
+      providerWireGroups: providerWireGroups.length,
+      providerWireDriftGroups: providerWireDriftGroups.length,
+      causalContextAvailableRuns: causalContextEvidence.currentAvailableRuns,
+      causalContextRuns: causalContextEvidence.runs,
+      causalContextRequiredSchemaVersion: causalContextEvidence.requiredSchemaVersion
     }
   } : null;
   const baselineKey = surfaceReportKey(baselineSurface);
   const candidateKey = surfaceReportKey(candidateSurface);
-  const infrastructureFailures = runs.flatMap((run) => run.infrastructureFailures ?? []);
-  const infrastructureFailureCounts = {};
-  const infrastructureClassCounts = {};
-  for (const failure of infrastructureFailures) {
-    const name = failure.failure ?? "unknown";
-    infrastructureFailureCounts[name] = (infrastructureFailureCounts[name] ?? 0) + 1;
-    const className = failure.class ?? failure.infrastructureClass ?? "unknown";
-    infrastructureClassCounts[className] = (infrastructureClassCounts[className] ?? 0) + 1;
-  }
-  const infrastructureRetries = runs.reduce((sum, run) => sum + (run.infrastructureRetries ?? 0), 0);
   const claimEligibility = benchmarkClaimEligibility({
     suite,
     environment,
@@ -851,7 +738,7 @@ export function summarizeBenchmark({
     protocolPassed: protocol.passed,
     tokenClaimAllowed
   });
-  return {
+  return integrateCodexRelativeEfficiencyReport({
     schemaVersion: 2,
     measurementSchemaVersion: BENCHMARK_MEASUREMENT_SCHEMA_VERSION,
     runId,
@@ -868,32 +755,49 @@ export function summarizeBenchmark({
       failureCounts: infrastructureFailureCounts,
       classCounts: infrastructureClassCounts
     },
+    tokenAccounting,
+    timingDiagnostics,
     surfaces: { [baselineKey]: baseline, [candidateKey]: candidate },
     comparison: {
       baselineSurface,
       candidateSurface,
       purpose: claimEligibility.comparisonPurpose,
       usageEstimator: "paired-geometric-mean-ratio",
+      durationEstimator: "paired-geometric-mean-ratio-clustered-by-scenario-family",
       failureAwareUsageEstimator: "total-comparable-attempt-fresh-tokens-per-resolved-outcome",
+      failureAwareFamilyUsageEstimator: "geometric-mean-of-family-total-comparable-attempt-fresh-tokens-per-resolved-outcome-ratios",
+      fixedWorkloadUsageEstimator: "geometric-mean-of-family-total-exact-scheduled-workload-ratios",
+      fixedWorkloadEstimatorVersion: 1,
       pairedOutcomeScenarios: completeOutcomeScenarios,
       pairedSuccessfulRuns: pairs.length,
       pairedUsageRuns: tokenPairs.length,
       pairedUsageScenarios: scenarioFreshRatios.length,
       pairedCompleteScenarios: completeScenarioFreshRatios.length,
+      pairedDurationRuns: durationPairs.length,
+      pairedDurationScenarios: scenarioDurationRatios.length,
+      pairedCompleteDurationScenarios: completeScenarioDurationRatios.length,
+      pairedDurationBands: pairedDurationBandReport,
       pairedCostRuns: costPairs.length,
+      normalizedCost,
+      normalizedCostClaimConfigurationGate,
+      normalizedCostEvidenceGate: normalizedCostGates.evidenceGate,
+      normalizedCostPricingApplicabilityGate: normalizedCostGates.applicabilityGate,
+      normalizedCostConfidenceGate: normalizedCostGates.confidenceGate,
+      normalizedCostBandGate: normalizedCostGates.bandGate,
+      normalizedCostBandFailures: normalizedCostGates.bandFailures,
+      normalizedCostFamilyGate: normalizedCostGates.familyGate,
+      normalizedCostFamilyFailures: normalizedCostGates.familyFailures,
+      normalizedCostGate: normalizedCostGates.passed,
       pairedOutcomes: {
         resolved: pairedResolvedOutcomes,
         quality: pairedOutcomeCounts(allPairs.filter((pair) => pair.candidate.scenarioKind !== "safety-refusal"), qualityPassed),
         safety: pairedOutcomeCounts(allPairs, safetyPassed)
       },
-      pairedUsageBands: {
-        categories: pairedUsageBands(tokenPairs, "category"),
-        profiles: pairedUsageBands(tokenPairs, "profile"),
-        lifecycles: pairedUsageBands(tokenPairs, "lifecycle"),
-        difficulties: pairedUsageBands(tokenPairs, "difficulty")
-      },
+      pairedUsageBands: pairedUsageBandReport,
       pairedFreshTokenWins: { [candidateKey]: freshWins, [baselineKey]: freshLosses, ties: freshTies },
       medianPairedFreshTokenDelta: rounded(median(freshDeltas), 2),
+      pairedDurationWins: { [candidateKey]: durationWins, [baselineKey]: durationLosses, ties: durationTies },
+      medianPairedDurationDeltaSeconds: rounded(median(durationDeltas), 2),
       medianFreshTokens: { [baselineKey]: baselineFresh, [candidateKey]: candidateFresh },
       medianCost: { [baselineKey]: baselineCost, [candidateKey]: candidateCost },
       freshTokensPerResolvedOutcome: {
@@ -901,12 +805,69 @@ export function summarizeBenchmark({
         [candidateKey]: rounded(candidateFreshPerResolvedOutcome, 2)
       },
       failureAwareFreshTokenRatio: rounded(failureAwareFreshTokenRatio, 4),
+      failureAwareFamilyFreshTokenRatio: rounded(familyClusteredFailureAware.ratio, 4),
+      failureAwareFamilyFreshTokenRatioConfidence95: familyClusteredFailureAware.confidence95,
+      failureAwareFamilyFreshTokenRatioConfidence95Raw: familyClusteredFailureAware.confidence95Raw,
+      failureAwareFamilyCoverage: {
+        complete: familyClusteredFailureAware.complete,
+        expectedScenarioFamilies: familyClusteredFailureAware.expectedScenarioFamilies,
+        usableScenarioFamilies: familyClusteredFailureAware.usableScenarioFamilies,
+        sampleUnit: familyClusteredFailureAware.sampleUnit,
+        scenarioIds: familyClusteredFailureAware.scenarioIds
+      },
+      failureAwareFamilyRatios: familyClusteredFailureAware.families,
+      fixedWorkloadFamilyFreshTokenRatio: rounded(familyClusteredFixedWorkload.ratio, 4),
+      fixedWorkloadFamilyFreshTokenRatioRaw: familyClusteredFixedWorkload.ratio,
+      fixedWorkloadFamilyFreshTokenRatioConfidence95: familyClusteredFixedWorkload.confidence95,
+      fixedWorkloadFamilyFreshTokenRatioConfidence95Raw: familyClusteredFixedWorkload.confidence95Raw,
+      fixedWorkloadAggregateFreshTokenRatio: rounded(familyClusteredFixedWorkload.aggregateFreshTokenRatio, 4),
+      fixedWorkloadFamilyCoverage: {
+        complete: familyClusteredFixedWorkload.complete,
+        expectedScenarioFamilies: familyClusteredFixedWorkload.expectedScenarioFamilies,
+        usableScenarioFamilies: familyClusteredFixedWorkload.usableScenarioFamilies,
+        expectedAttemptsPerFamily: familyClusteredFixedWorkload.expectedAttemptsPerFamily,
+        sampleUnit: familyClusteredFixedWorkload.sampleUnit,
+        outcomeConditioning: familyClusteredFixedWorkload.outcomeConditioning,
+        aggregation: familyClusteredFixedWorkload.aggregation,
+        attemptPolicy: familyClusteredFixedWorkload.attemptPolicy,
+        scenarioIds: familyClusteredFixedWorkload.scenarioIds
+      },
+      fixedWorkloadFamilyRatios: familyClusteredFixedWorkload.families,
+      allSuccessfulPairsFreshTokenRatio: rounded(allSuccessfulPairsFreshRatio, 4),
       freshTokenRatio: rounded(freshRatio, 4),
+      freshTokenRatioRaw: freshRatio,
       freshTokenRatioConfidence95: freshRatioConfidence95,
+      freshTokenRatioConfidence95Raw: freshRatioConfidence95Raw,
+      freshTokenRatioSample: {
+        sampleUnit: "scenario-family",
+        scenarioCount: confidenceScenarioRatios.length,
+        scenarioIds: confidenceScenarioRatios.map((item) => item.scenarioId)
+      },
+      primaryEfficiencyEstimand,
+      primaryEfficiencyRatio: rounded(primaryEfficiencyRatio, 4),
+      primaryEfficiencyRatioRaw: primaryEfficiencyRatio,
+      primaryEfficiencyRatioConfidence95,
+      primaryEfficiencyRatioConfidence95Raw,
+      primaryEfficiencySample: {
+        sampleUnit: "scenario-family",
+        scenarioCount: primaryEfficiencyCompleteScenarios,
+        scenarioIds: primaryEfficiencyScenarioRatios.map((item) => item.scenarioId),
+        outcomeConditioning: primaryUsesFixedWorkload ? "none" : "resolved-outcome-conditioned"
+      },
+      primaryEfficiencyDeltaPercent: Number.isFinite(primaryEfficiencyRatio)
+        ? rounded((primaryEfficiencyRatio - 1) * 100, 2)
+        : null,
       freshTokenDeltaPercent: Number.isFinite(freshRatio) ? rounded((freshRatio - 1) * 100, 2) : null,
+      durationRatio: rounded(durationRatio, 4),
+      durationRatioRaw: durationRatio,
+      durationRatioConfidence95,
+      durationRatioConfidence95Raw,
+      durationDeltaPercent: Number.isFinite(durationRatio) ? rounded((durationRatio - 1) * 100, 2) : null,
       costRatio: rounded(costRatio, 4),
       costDeltaPercent: Number.isFinite(costRatio) ? rounded((costRatio - 1) * 100, 2) : null,
       qualityNonInferior,
+      pairedQualityNoninferiorityGate,
+      pairedQualityEvidence,
       qualityGate,
       safetyGate,
       reliabilityGate,
@@ -916,16 +877,65 @@ export function summarizeBenchmark({
       outcomeScoreGate,
       outcomeScoreFailures,
       pairedRegressionGate,
+      candidateTaskContinuityGate,
+      candidateContinuityFailures,
       comparisonProtocolGate: protocol,
+      providerWireSurfaceGate,
+      causalContextEvidenceGate,
+      causalContextEvidence,
+      providerWireEvidence: {
+        required: requiresProviderWireSurface,
+        runs: candidateRuns.length,
+        verifiedRuns: providerWireVerifiedRuns.length,
+        groups: providerWireGroups,
+        driftGroups: providerWireDriftGroups,
+        failureCounts: providerWireFailureCounts,
+        deferredChangesAreBaseDrift: false
+      },
+      releaseClaimConfigurationGate,
+      canonicalProductionIdentityGate,
+      codexBaselineGate,
+      cleanReleaseSourceGate,
+      hostReadinessGate,
+      fullSuiteGate,
       outcomeEvidenceGate,
       efficiencyEvidenceGate,
+      successfulPairEfficiencyRole,
+      successfulPairEfficiencySupportGate,
       efficiencyBandCoverageGate,
       efficiencyCategoryCoverage,
+      freshTokenBandGate: freshTokenBandGate.passed,
+      freshTokenBandFailures: freshTokenBandGate.failures,
+      freshTokenFamilyGate,
+      freshTokenFamilyFailures,
       failureAwareEfficiencyGate,
+      failureAwareEfficiencyRole,
+      failureAwareEfficiencySupportGate,
+      primaryEfficiencyEvidenceGate,
+      primaryEfficiencyBandCoverageGate,
+      primaryEfficiencyCategoryCoverage,
+      primaryEfficiencyConfidenceGate,
+      primaryEfficiencyGate,
       repeatGate,
       efficiencyConfidenceGate,
+      performanceEvidenceGate,
+      performancePointEstimateGate,
+      performanceConfidenceGate,
+      durationBandGate: durationBandGate.passed,
+      durationBandFailures: durationBandGate.failures,
+      durationFamilyGate,
+      durationFamilyFailures,
+      performanceGate,
+      infrastructureRetryGate,
+      unknownInfrastructureUsageGate,
+      acceptedUsageCompletenessGate,
+      failedUsageCompletenessGate,
+      allAttemptUsageCompletenessGate,
+      infrastructureFailureLedgerGate,
+      infrastructureFailureLedgerIssues,
+      stabilityGate,
       suiteGate,
-      productionGate: suite.id === "production-v1" ? suiteGate : null,
+      productionGate: canonicalProductionSuite ? suiteGate : null,
       tokenClaimAllowed,
       claimEligibility
     },
@@ -934,29 +944,91 @@ export function summarizeBenchmark({
         ? "safety-gate-failed"
         : !qualityNonInferior
           ? "quality-regression"
+          : pairedQualityNoninferiorityGate === false
+            ? "paired-quality-noninferiority-gate-failed"
           : !qualityGate
             ? "quality-gate-failed"
             : !reliabilityGate
               ? "reliability-gate-failed"
-              : !protocol.passed
+              : !baseProtocol.passed
                 ? "comparison-protocol-gate-failed"
                 : workflowGate === false
                   ? "workflow-gate-failed"
-                : categoryGate === false
-                  ? "category-gate-failed"
-                  : outcomeScoreGate === false
-                    ? "outcome-score-floor-gate-failed"
-                    : !pairedRegressionGate
-                      ? "paired-candidate-regression"
-                  : repeatGate === false
-                      ? "repeat-gate-failed"
-                      : requiresConfidenceEfficiency && efficiencyConfidenceGate === false
-                        ? "efficiency-confidence-gate-failed"
-                        : tokenClaimAllowed
-                          ? `${candidateSurface}-more-efficient`
-                          : "insufficient-efficiency-evidence",
-      note: `Raw metrics and hidden verifier results are authoritative. Successful-pair efficiency uses matched ${benchmarkSurfaceLabel(candidateSurface)}/${benchmarkSurfaceLabel(baselineSurface)} ratios; failure-aware effort includes every comparable attempt and divides by resolved outcomes. Confidence intervals cluster repeats by scenario family. Claim scope is ${claimEligibility.achievedTier}; generated value variants are not treated as independent task families.`
+                  : categoryGate === false
+                    ? "category-gate-failed"
+                    : outcomeScoreGate === false
+                      ? "outcome-score-floor-gate-failed"
+                      : !pairedRegressionGate
+                        ? "paired-candidate-regression"
+                        : !candidateTaskContinuityGate
+                          ? "candidate-task-continuity-gate-failed"
+                        : !canonicalProductionIdentityGate
+                          ? "canonical-production-identity-gate-failed"
+                          : requestsTokenSavingClaim && releaseClaimConfigurationGate === false
+                            ? "release-claim-configuration-gate-failed"
+                          : requestsTokenSavingClaim && codexBaselineGate === false
+                            ? "codex-baseline-gate-failed"
+                          : requestsTokenSavingClaim && cleanReleaseSourceGate === false
+                              ? "clean-release-source-gate-failed"
+                            : requiresHostReadiness && hostReadinessGate === false
+                              ? "host-readiness-history-gate-failed"
+                              : requiresProviderWireSurface && providerWireSurfaceGate === false
+                                ? "provider-wire-surface-gate-failed"
+                                : requiresCausalContextReceipt && causalContextEvidenceGate === false
+                                  ? "causal-context-evidence-gate-failed"
+                                  : fullSuiteGate === false
+                                    ? "full-suite-gate-failed"
+                                  : requiresStability && infrastructureRetryGate === false
+                                    ? "stability-infrastructure-retry-gate-failed"
+                                    : requiresStability && unknownInfrastructureUsageGate === false
+                                      ? "stability-unknown-usage-gate-failed"
+                                      : requestsTokenSavingClaim && infrastructureFailureLedgerGate === false
+                                        ? "stability-failure-ledger-gate-failed"
+                                      : requestsTokenSavingClaim && acceptedUsageCompletenessGate === false
+                                        ? "accepted-usage-completeness-gate-failed"
+                                        : requestsTokenSavingClaim && allAttemptUsageCompletenessGate === false
+                                          ? "all-attempt-usage-completeness-gate-failed"
+                                        : requestsNormalizedCostClaim && normalizedCostClaimConfigurationGate === false
+                                          ? "normalized-cost-configuration-gate-failed"
+                                          : requestsNormalizedCostClaim && normalizedCostGates.applicabilityGate === false
+                                            ? "normalized-cost-pricing-applicability-gate-failed"
+                                            : requestsNormalizedCostClaim && normalizedCostGates.evidenceGate === false
+                                              ? "normalized-cost-evidence-gate-failed"
+                                              : requestsNormalizedCostClaim && normalizedCostGates.confidenceGate === false
+                                                ? "normalized-cost-confidence-gate-failed"
+                                                : requestsNormalizedCostClaim && normalizedCostGates.bandGate === false
+                                                  ? "normalized-cost-band-ratio-gate-failed"
+                                                  : requestsNormalizedCostClaim && normalizedCostGates.familyGate === false
+                                                    ? "normalized-cost-family-ratio-gate-failed"
+                                    : !outcomeEvidenceGate
+                                      ? "paired-outcome-evidence-gate-failed"
+                                      : repeatGate === false
+                                        ? "repeat-gate-failed"
+                                        : primaryUsesFixedWorkload && primaryEfficiencyGate === false
+                                          ? "primary-efficiency-gate-failed"
+                                        : requiresPerformance && performanceEvidenceGate === false
+                                          ? "performance-evidence-gate-failed"
+                                          : requiresPerformance && performancePointEstimateGate === false
+                                            ? "performance-point-regression"
+                                            : requiresPerformance && performanceConfidenceGate === false
+                                              ? "performance-confidence-gate-failed"
+                                              : durationBandGate.passed === false
+                                                ? "performance-band-ratio-gate-failed"
+                                                : durationFamilyGate === false
+                                                  ? "performance-family-ratio-gate-failed"
+                                              : requiresBandEfficiency && freshTokenBandGate.passed === false
+                                                ? "efficiency-band-ratio-gate-failed"
+                                              : freshTokenFamilyGate === false
+                                                ? "efficiency-family-ratio-gate-failed"
+                                              : requiresConfidenceEfficiency
+                                                && successfulPairEfficiencyRole === "blocking"
+                                                && efficiencyConfidenceGate === false
+                                                ? "efficiency-confidence-gate-failed"
+                                                : tokenClaimAllowed
+                                                  ? `${candidateSurface}-more-efficient`
+                                                  : "observational-efficiency-only",
+      note: `Raw metrics and hidden verifier results are authoritative. Fixed-workload efficiency includes every predeclared paired attempt, including exact provider-started failed-attempt usage, without conditioning token measurement on task outcome; quality and continuity remain independent hard gates. Successful-pair efficiency uses matched ${benchmarkSurfaceLabel(candidateSurface)}/${benchmarkSurfaceLabel(baselineSurface)} resolved-outcome ratios; failure-aware effort divides every comparable attempt by resolved outcomes. Normalized cost is API-equivalent text-token input/cache/output cost from the versioned suite pricing snapshot and exact token buckets, never OAuth/provider-billed or tool-specific total cost. Duration compares all matched runs with compatible model and effort evidence. Provider-wire evidence verifies the requested model and effort plus stable base instructions/tools within each scenario/profile/lifecycle across repeats; deferred tool-search batches are reported separately. Confidence intervals cluster repeats by scenario family. Claim scope is ${claimEligibility.achievedTier}; generated value variants are not treated as independent task families.`
     },
-    runs
-  };
+    runs: reportRuns
+  }, suite);
 }