@piagent/platform 1.6.1 → 1.8.0

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

@@ -1,6 +1,11 @@
 import { benchmarkProviderWireEvidenceMatchesRequest } from "./benchmark-provider-wire.js";
-import { productionProviderFreeEvidenceContextValidationErrors } from "./benchmark-provider-free-evidence.js";
+import { productionCampaignAttemptCoverage, productionCampaignExpectedAttempts, publicProductionBenchmarkCampaignEvidence } from "./benchmark-campaign.js";
+import {
+  productionProviderFreeEvidenceContextValidationErrors,
+  productionProviderFreeLaneDefinitions
+} from "./benchmark-provider-free-evidence.js";
 import { summarizeBenchmarkSubagentBudget } from "./benchmark-codex-relative-efficiency.js";
+import { summarizeBenchmarkServiceTierEvidence } from "./benchmark-service-tier.js";
 import {
   benchmarkPricingSnapshotValidationErrors,
   normalizeBenchmarkUsageCost
@@ -15,10 +20,22 @@ import { atMostWithinFloatingPrecision, geometricMean } from "./benchmark-statis
 import { pairedOutcomeFloorStop } from "./benchmark-stop-policy.js";
 import { workflowContinuityEvidenceComplete } from "./benchmark-summary-support.js";
 import { summarizeBenchmarkTimingDiagnostics } from "./benchmark-timing-diagnostics.js";
-import { exactBenchmarkAttemptUsage } from "./benchmark-usage.js";
+import { benchmarkInfrastructureFailureLedgerIssues } from "./benchmark-usage.js";
+import {
+  partialCatastrophicSpendEvidence,
+  productionV2EarlyDetectionValidationErrors
+} from "./benchmark-production-stage-validation.js";
+import {
+  MEASUREMENT_INVALIDATING_ONLY_STOP_POLICY,
+  PAIRED_OUTCOME_FLOOR_STOP_POLICY,
+  productionExecutionValidationErrors,
+  productionMeasurementInvalidatingRecordIssues
+} from "./benchmark-production-completion.js";
+export { productionGuardBindingMatches } from "./benchmark-production-completion.js";
 
 const TOKEN_FIELDS = Object.freeze(["input", "output", "cacheRead", "cacheWrite", "reasoning", "fresh", "total"]);
 const PRODUCTION_STAGE_CONTROL_POLICY = "production-v1-provider-spend-v1";
+const REQUIRED_PROVIDER_FREE_LANE_IDS = Object.freeze(productionProviderFreeLaneDefinitions().map((lane) => lane.id));
 
 function nonEmptyString(value) {
   return typeof value === "string" && value.trim().length > 0;
@@ -33,14 +50,10 @@ function validStageBoundaries(stageBoundaries) {
       && (index === 0 || value > stageBoundaries[index - 1]));
 }
 
-export function productionGuardBindingMatches(manifest, spendControl) {
-  return JSON.stringify(manifest?.productionGuards ?? null)
-    === JSON.stringify(spendControl?.productionGuards ?? null);
-}
-
 export function productionSpendControlValidationErrors(control, {
   suiteId,
   expectedSessions,
+  suite,
   requireHostReadiness = control?.hostReadiness?.required === true
 } = {}) {
   const errors = [];
@@ -50,18 +63,7 @@ export function productionSpendControlValidationErrors(control, {
   if (!nonEmptyString(control.rootSeed) || control.rootSeed.length > 200) errors.push("invalid-root-seed");
 
   const execution = control.execution;
-  if (!execution || typeof execution !== "object" || Array.isArray(execution)) errors.push("missing-execution-contract");
-  else {
-    if (!Array.isArray(execution.surfaces)
-      || execution.surfaces.length !== 2
-      || new Set(execution.surfaces).size !== 2
-      || execution.surfaces.some((surface) => !nonEmptyString(surface))) errors.push("invalid-execution-surfaces");
-    if (execution.model !== null && !nonEmptyString(execution.model)) errors.push("invalid-execution-model");
-    if (execution.thinking !== null && !nonEmptyString(execution.thinking)) errors.push("invalid-execution-thinking");
-    if (!Number.isSafeInteger(execution.repeats) || execution.repeats <= 0) errors.push("invalid-execution-repeats");
-    if (execution.infrastructureRetries !== 0) errors.push("infrastructure-retries-must-be-zero");
-    if (execution.stopAfterFailedPair !== true) errors.push("stop-after-failed-pair-must-be-enabled");
-  }
+  errors.push(...productionExecutionValidationErrors(execution, { suiteId, suite }));
 
   if (requireHostReadiness) {
     errors.push(...benchmarkHostReadinessPolicyValidationErrors(control.hostReadiness)
@@ -113,11 +115,17 @@ export function productionSpendControlValidationErrors(control, {
       || partial.includeExactFailedAttempts !== true) errors.push("invalid-production-partial-fresh-spend-guard");
     const providerFree = guards.providerFreeEvidence;
     if (providerFree?.requiredBeforeFirstPaidSession !== true
-      || JSON.stringify(providerFree.requiredLaneIds) !== JSON.stringify(["runtime-conformance-v1", "long-horizon-v1", "webui-parity-v1"])
+      || JSON.stringify(providerFree.requiredLaneIds) !== JSON.stringify(REQUIRED_PROVIDER_FREE_LANE_IDS)
       || providerFree.requireCleanCommitAndTreeBinding !== true
       || providerFree.requireProductionConfigurationBinding !== true
       || providerFree.requireRunnerAndLaneConfigurationDigests !== true) errors.push("invalid-production-provider-free-evidence-guard");
+    const campaign = guards.campaignAccounting;
+    if (["production-v2", "production-v3"].includes(suiteId) && (campaign?.requiredBeforeFirstPaidSession !== true
+      || campaign.requireSingleOutputResumeLineage !== true
+      || campaign.includeEveryProviderStartedAttempt !== true
+      || campaign.unknownUsageFailsClosed !== true)) errors.push("invalid-production-campaign-accounting-guard");
   }
+  errors.push(...productionV2EarlyDetectionValidationErrors(control, { suiteId, suite }));
   return errors;
 }
 
@@ -370,90 +378,6 @@ function pairRatioEvidence(pairRecords, valueFor) {
   };
 }
 
-function allAttemptFreshTokens(run) {
-  const failures = Array.isArray(run?.infrastructureFailures) ? run.infrastructureFailures : [];
-  const ledgerExact = Number.isSafeInteger(run?.infrastructureRetries)
-    && Number.isSafeInteger(run?.infrastructureAttempts)
-    && failures.length === run.infrastructureRetries
-    && run.infrastructureAttempts === run.infrastructureRetries + 1;
-  const attempts = [
-    { usage: run?.usage, status: run?.usageStatus ?? "measured" },
-    ...failures.map((failure) => ({
-      usage: failure?.usage,
-      status: failure?.usageStatus ?? "unknown-after-provider-start"
-    }))
-  ];
-  const exact = ledgerExact && attempts.every((attempt) => exactBenchmarkAttemptUsage(attempt.usage, attempt.status));
-  return {
-    exact,
-    attempts: attempts.length,
-    fresh: exact ? attempts.reduce((sum, attempt) => sum + Number(attempt.usage?.fresh ?? 0), 0) : null
-  };
-}
-
-function partialCatastrophicSpendEvidence(pairRecords, {
-  maximumPooledFreshRatio,
-  maximumObservedFamilyFreshRatio
-}) {
-  const records = pairRecords.map(({ pair, candidate, baseline }) => {
-    const candidateUsage = allAttemptFreshTokens(candidate);
-    const baselineUsage = allAttemptFreshTokens(baseline);
-    const exact = candidateUsage.exact && baselineUsage.exact
-      && baselineUsage.fresh > 0 && candidateUsage.fresh >= 0;
-    return {
-      pairId: pair.id,
-      scenarioId: pair.scenarioId,
-      repeat: pair.repeat,
-      exact,
-      baselineFresh: exact ? baselineUsage.fresh : null,
-      candidateFresh: exact ? candidateUsage.fresh : null,
-      baselineAttempts: baselineUsage.attempts,
-      candidateAttempts: candidateUsage.attempts
-    };
-  });
-  const exact = records.length > 0 && records.every((record) => record.exact);
-  const baselineFresh = exact ? records.reduce((sum, record) => sum + record.baselineFresh, 0) : null;
-  const candidateFresh = exact ? records.reduce((sum, record) => sum + record.candidateFresh, 0) : null;
-  const pooledRatio = exact && baselineFresh > 0 ? candidateFresh / baselineFresh : null;
-  const byFamily = new Map();
-  for (const record of records) {
-    const family = byFamily.get(record.scenarioId) ?? { scenarioId: record.scenarioId, records: [] };
-    family.records.push(record);
-    byFamily.set(record.scenarioId, family);
-  }
-  const families = [...byFamily.values()].map((family) => {
-    const familyExact = family.records.length > 0 && family.records.every((record) => record.exact);
-    const baseline = familyExact ? family.records.reduce((sum, record) => sum + record.baselineFresh, 0) : null;
-    const candidate = familyExact ? family.records.reduce((sum, record) => sum + record.candidateFresh, 0) : null;
-    return {
-      scenarioId: family.scenarioId,
-      observedPairs: family.records.length,
-      exact: familyExact,
-      ratio: familyExact && baseline > 0 ? candidate / baseline : null
-    };
-  }).sort((left, right) => left.scenarioId.localeCompare(right.scenarioId));
-  const familyFailures = families.filter((family) => !family.exact
-    || !Number.isFinite(family.ratio)
-    || !atMostWithinFloatingPrecision(family.ratio, maximumObservedFamilyFreshRatio));
-  const passed = exact
-    && Number.isFinite(pooledRatio)
-    && atMostWithinFloatingPrecision(pooledRatio, maximumPooledFreshRatio)
-    && familyFailures.length === 0;
-  return {
-    schemaVersion: 1,
-    exactUsageIncludingFailedAttempts: exact,
-    maximumPooledFreshRatio,
-    maximumObservedFamilyFreshRatio,
-    pooledRatio,
-    baselineFresh,
-    candidateFresh,
-    familyFailures,
-    families,
-    records,
-    passed
-  };
-}
-
 function candidateOutcomeFailures(pairRecords, floor) {
   return pairRecords.map(({ pair, candidate }) => {
     const failures = [];
@@ -497,6 +421,7 @@ export function buildBenchmarkStageDiagnostic({
   baselineSurface,
   requestedModel,
   requestedThinking,
+  requestedServiceTier,
   suite,
   manifest,
   hostReadinessPolicy = null,
@@ -572,10 +497,21 @@ export function buildBenchmarkStageDiagnostic({
   const outcomeFloorConfigured = Number.isFinite(outcomeFloor);
   const outcomeFailures = outcomeFloorConfigured ? candidateOutcomeFailures(pairRecords, outcomeFloor) : [];
   const outcomeFloorPassed = outcomeFloorConfigured
-    && manifest?.stopAfterFailedPair === true
     && pairRecords.length > 0
     && outcomeFailures.length === 0;
   const qualityPassed = noBaselineOnlyRegressionPassed && observedGradeNonInferiorPassed && outcomeFloorPassed;
+  const completeMeasurementPolicy = manifest?.campaignStopPolicy === MEASUREMENT_INVALIDATING_ONLY_STOP_POLICY;
+  const qualityDecisionRole = completeMeasurementPolicy ? "final-only" : "blocking";
+  const fastServiceTierRequired = suite?.releaseGate?.requireFastServiceTier === true;
+  const measurementContext = { requestedModel, requestedThinking, requestedServiceTier, requireFastServiceTier: fastServiceTierRequired };
+  const measurementValidityFailures = completeMeasurementPolicy
+    ? acceptedRuns.map((run) => ({
+        runId: runKey(run).replaceAll("\0", ":"),
+        issues: productionMeasurementInvalidatingRecordIssues(run, measurementContext)
+      })).filter((item) => item.issues.length > 0)
+    : [];
+  const measurementValidityPassed = !completeMeasurementPolicy || (acceptedRuns.length > 0
+    && measurementValidityFailures.length === 0);
 
   const acceptedUsageFailures = acceptedRuns.map((run) => ({ runId: runKey(run).replaceAll("\0", ":"), issues: exactUsageIssues(run) }))
     .filter((item) => item.issues.length > 0);
@@ -607,6 +543,12 @@ export function buildBenchmarkStageDiagnostic({
     && pairedModelThinkingFailures.length === 0
     && wireGroups.length > 0
     && wireDriftGroups.length === 0;
+  const serviceTierEvidence = summarizeBenchmarkServiceTierEvidence(acceptedRuns, {
+    requestedServiceTier,
+    requestedModel,
+    required: fastServiceTierRequired
+  });
+  const fastServiceTierPassed = !fastServiceTierRequired || serviceTierEvidence.passed === true;
   const causalContextRequired = suite?.releaseGate?.requireCausalContextReceipt === true;
   const causalContextSummary = summarizeBenchmarkCausalContextEvidence(piRuns, { required: causalContextRequired });
   const causalContextAvailableRuns = causalContextSummary.currentAvailableRuns;
@@ -618,7 +560,8 @@ export function buildBenchmarkStageDiagnostic({
     ? productionProviderFreeEvidenceContextValidationErrors(manifest?.providerFreeEvidence, {
       source: manifest?.sourceIdentity,
       candidateProvenance: manifest?.candidateProvenance,
-      configurationDigest: manifest?.configurationDigest
+      providerFreeConfigurationDigest: manifest?.providerFreeConfigurationDigest,
+      treatmentDerivation: manifest?.treatmentDerivation
     })
     : [];
   const providerFreeObservedLaneIds = Array.isArray(manifest?.providerFreeEvidence?.lanes)
@@ -660,7 +603,8 @@ export function buildBenchmarkStageDiagnostic({
     && acceptedRuns.length < expectedRuns.length;
   const partialSpend = partialCatastrophicSpendEvidence(pairRecords, {
     maximumPooledFreshRatio: partialGuard?.maximumPooledFreshRatio,
-    maximumObservedFamilyFreshRatio: partialGuard?.maximumObservedFamilyFreshRatio
+    maximumObservedFamilyFreshRatio: partialGuard?.maximumObservedFamilyFreshRatio,
+    suite
   });
   const partialSpendPassed = !partialSpendRequired || partialSpend.passed;
 
@@ -693,15 +637,10 @@ export function buildBenchmarkStageDiagnostic({
     && durationEfficiency.pairRegressions.length === 0
     && durationEfficiency.familyRegressions.length === 0;
 
-  const retryEvidenceFailures = acceptedRuns.map((run) => {
-    const issues = [];
-    if (!Number.isInteger(run.infrastructureRetries) || run.infrastructureRetries < 0) issues.push("invalid-infrastructure-retry-count");
-    if (!Array.isArray(run.infrastructureFailures)) issues.push("missing-infrastructure-failure-ledger");
-    else if (Number.isInteger(run.infrastructureRetries) && run.infrastructureFailures.length !== run.infrastructureRetries) {
-      issues.push("retry-ledger-count-mismatch");
-    }
-    return { runId: runKey(run).replaceAll("\0", ":"), issues };
-  }).filter((item) => item.issues.length > 0);
+  const retryEvidenceFailures = benchmarkInfrastructureFailureLedgerIssues(acceptedRuns).map((failure) => ({
+    runId: [failure.scenarioId, failure.surface, failure.repeat].join(":"),
+    issues: failure.issues
+  }));
   const infrastructureRetries = acceptedRuns.reduce((sum, run) => sum + (Number.isInteger(run.infrastructureRetries) ? run.infrastructureRetries : 0), 0);
   const failedAttempts = acceptedRuns.reduce((sum, run) => sum + (Array.isArray(run.infrastructureFailures) ? run.infrastructureFailures.length : 0), 0);
   const failedAttemptUnknownUsage = acceptedRuns.reduce((sum, run) => sum + (run.infrastructureFailures ?? [])
@@ -721,6 +660,24 @@ export function buildBenchmarkStageDiagnostic({
     && recoveredProviderAttempts === 0;
   const unknownUsageAttempts = failedAttemptUnknownUsage + manifestUnknownUsage;
   const unknownUsagePassed = unknownUsageAttempts === 0 && tokenClaimsUnavailableReason === null;
+  const campaignRequired = suite?.releaseGate?.requireCampaignAccounting === true
+    || manifest?.productionGuards?.campaignAccounting?.requiredBeforeFirstPaidSession === true;
+  const campaignEvidence = manifest?.campaignEvidence;
+  const expectedCampaignIdentities = productionCampaignExpectedAttempts(acceptedRuns);
+  const expectedCampaignAttempts = expectedCampaignIdentities.length + recoveredProviderAttempts;
+  const campaignAttemptCoveragePassed = recoveredProviderAttempts === 0
+    && productionCampaignAttemptCoverage(expectedCampaignIdentities, campaignEvidence);
+  const campaignAccountingPassed = !campaignRequired || (campaignEvidence?.required === true
+    && campaignEvidence.passed === true
+    && campaignEvidence.complete === true
+    && campaignEvidence.exactOutputLineage === true
+    && campaignEvidence.runId === (manifest?.runId ?? runId)
+    && campaignEvidence.configurationDigest === manifest?.configurationDigest
+    && campaignEvidence.providerStartedAttempts === expectedCampaignAttempts
+    && campaignEvidence.settledAttempts === expectedCampaignAttempts
+    && campaignEvidence.unknownAttempts === 0
+    && campaignAttemptCoveragePassed
+    && campaignEvidence.allAttempts?.complete === true);
 
   const pairBoundary = incompleteObservedPairs.length === 0
     && duplicateRuns.length === 0
@@ -731,8 +688,10 @@ export function buildBenchmarkStageDiagnostic({
     && [...pairs.values()].every((pair) => pair.expectedSurfaces.size === 2
       && pair.expectedSurfaces.has(candidateSurface)
       && pair.expectedSurfaces.has(baselineSurface));
-  const executionContractPassed = manifest?.stopAfterFailedPair === true
-    && manifest?.infrastructureRetries === 0;
+  const executionContractPassed = manifest?.infrastructureRetries === 0
+    && (completeMeasurementPolicy
+      ? manifest?.stopAfterFailedPair === false
+      : manifest?.stopAfterFailedPair === true);
   const cleanReleaseSourceRequired = suite?.schemaVersion === 2
     && suite?.releaseGate?.requireEfficiencyClaim === true
     && suite?.releaseGate?.requireFullSuiteForClaim === true;
@@ -766,6 +725,7 @@ export function buildBenchmarkStageDiagnostic({
     diagnosticCheck("recognized-spend-control-pause", recognizedPause, { reason }),
     diagnosticCheck("paired-contract", pairContractPassed, { candidateSurface, baselineSurface }),
     diagnosticCheck("spend-control-execution-contract", executionContractPassed, {
+      campaignStopPolicy: manifest?.campaignStopPolicy ?? PAIRED_OUTCOME_FLOOR_STOP_POLICY,
       stopAfterFailedPair: manifest?.stopAfterFailedPair === true,
       infrastructureRetries: Number.isInteger(manifest?.infrastructureRetries) ? manifest.infrastructureRetries : null
     }),
@@ -781,17 +741,29 @@ export function buildBenchmarkStageDiagnostic({
     }, hostReadinessRequired ? "blocking" : "observational"),
     diagnosticCheck("pause-on-pair-boundary", pairBoundary, { incompleteObservedPairs: incompleteObservedPairs.length }),
     diagnosticCheck("observed-complete-pair", completePairs.length > 0, { observedCompletePairs: completePairs.length }),
-    diagnosticCheck("no-baseline-pass-piagent-fail", noBaselineOnlyRegressionPassed, { regressions: baselineOnlyRegressions.length }),
+    diagnosticCheck("measurement-validity", measurementValidityPassed, {
+      required: completeMeasurementPolicy,
+      failures: measurementValidityFailures
+    }),
+    diagnosticCheck("no-baseline-pass-piagent-fail", noBaselineOnlyRegressionPassed,
+      { regressions: baselineOnlyRegressions.length }, qualityDecisionRole),
     diagnosticCheck("observed-paired-grade-noninferior", observedGradeNonInferiorPassed, {
       incomparablePairs: pairedGradeComparabilityFailures.length,
       regressions: pairedGradeRegressions.length
-    }),
+    }, qualityDecisionRole),
     diagnosticCheck("candidate-outcome-floor", outcomeFloorPassed, {
       minimumOutcomeScoreExclusive: outcomeFloorConfigured ? outcomeFloor : null,
       failures: outcomeFailures.length
-    }),
+    }, qualityDecisionRole),
     diagnosticCheck("accepted-usage-exact", acceptedUsagePassed, { failures: acceptedUsageFailures.length }),
     diagnosticCheck("provider-wire-model-thinking-parity", providerParityPassed, { failures: piParityFailures.length + pairedModelThinkingFailures.length + wireDriftGroups.length }),
+    diagnosticCheck("fast-execution-configuration-parity", fastServiceTierPassed, {
+      required: fastServiceTierRequired,
+      requestedServiceTier: requestedServiceTier ?? null,
+      executionConfigurationParityGate: serviceTierEvidence.executionConfigurationParityGate,
+      providerResponseEvidenceGate: serviceTierEvidence.providerResponseEvidenceGate,
+      bySurface: serviceTierEvidence.bySurface
+    }),
     diagnosticCheck("piagent-causal-context-receipts", causalContextPassed, {
       required: causalContextRequired,
       availableRuns: causalContextAvailableRuns,
@@ -811,6 +783,16 @@ export function buildBenchmarkStageDiagnostic({
     }),
     diagnosticCheck("no-infrastructure-retry", retryGatePassed, { retries: infrastructureRetries }),
     diagnosticCheck("no-unknown-attempt-usage", unknownUsagePassed, { unknownUsageAttempts }),
+    diagnosticCheck("durable-campaign-all-attempt-accounting", campaignAccountingPassed, {
+      required: campaignRequired,
+      campaignId: campaignEvidence?.campaignId ?? null,
+      expectedAttempts: expectedCampaignAttempts,
+      providerStartedAttempts: campaignEvidence?.providerStartedAttempts ?? null,
+      settledAttempts: campaignEvidence?.settledAttempts ?? null,
+      unknownAttempts: campaignEvidence?.unknownAttempts ?? null,
+      exactOutputLineage: campaignEvidence?.exactOutputLineage === true,
+      attemptCoveragePassed: campaignAttemptCoveragePassed
+    }),
     diagnosticCheck("production-subagent-budget", !subagentBudgetRequired || subagentBudget.passed, {
       required: subagentBudgetRequired,
       attempts: subagentBudget.attempts,
@@ -818,15 +800,19 @@ export function buildBenchmarkStageDiagnostic({
       maximumObservedSessionsPerAttempt: subagentBudget.maximumObservedSessionsPerAttempt,
       trafficShare: subagentBudget.trafficShare,
       failures: subagentBudget.failures
-    }),
+    }, completeMeasurementPolicy ? "final-only" : "blocking"),
     diagnosticCheck("partial-stage-catastrophic-fresh-spend", partialSpendPassed, {
       required: partialSpendRequired,
       pooledRatio: partialSpend.pooledRatio,
       maximumPooledFreshRatio: partialSpend.maximumPooledFreshRatio,
       familyFailures: partialSpend.familyFailures,
+      sampleUnit: partialSpend.sampleUnit,
+      aggregation: partialSpend.aggregation,
+      familyResolutionPassed: partialSpend.familyResolutionPassed,
+      familyResolutionIssues: partialSpend.familyResolutionIssues,
       maximumObservedFamilyFreshRatio: partialSpend.maximumObservedFamilyFreshRatio,
       exactUsageIncludingFailedAttempts: partialSpend.exactUsageIncludingFailedAttempts
-    }),
+    }, completeMeasurementPolicy ? "final-only" : "blocking"),
     diagnosticCheck("no-observed-fresh-token-regression", freshEfficiencyPassed, {
       incomparablePairs: freshEfficiency.incomparablePairs.length,
       pairRegressions: freshEfficiency.pairRegressions.length,
@@ -879,6 +865,7 @@ export function buildBenchmarkStageDiagnostic({
     quality: {
       rule: "no-baseline-pass-piagent-fail-and-candidate-outcomes-above-the-release-floor",
       passed: qualityPassed,
+      decisionRole: qualityDecisionRole,
       noBaselineOnlyRegressionPassed,
       observedGradeNonInferiorPassed,
       observedCompletePairs: completePairs.length,
@@ -898,6 +885,14 @@ export function buildBenchmarkStageDiagnostic({
         failures: [{ failures: ["outcome-floor-not-configured"] }]
       }
     },
+    measurementValidity: {
+      policy: completeMeasurementPolicy
+        ? MEASUREMENT_INVALIDATING_ONLY_STOP_POLICY
+        : PAIRED_OUTCOME_FLOOR_STOP_POLICY,
+      required: completeMeasurementPolicy,
+      passed: measurementValidityPassed,
+      failures: measurementValidityFailures
+    },
     acceptedUsage: {
       rule: "every-accepted-session-has-exact-provider-token-buckets",
       passed: acceptedUsagePassed,
@@ -910,6 +905,7 @@ export function buildBenchmarkStageDiagnostic({
       passed: providerParityPassed,
       requestedModel: requestedModel ?? null,
       requestedThinking: requestedThinking ?? null,
+      requestedServiceTier: requestedServiceTier ?? null,
       observedPiRuns: piRuns.length,
       verifiedPiRuns: piRuns.length - piParityFailures.length,
       piRunFailures: piParityFailures,
@@ -917,6 +913,7 @@ export function buildBenchmarkStageDiagnostic({
       wireGroups,
       wireDriftGroups
     },
+    serviceTierEvidence,
     causalContextEvidence: {
       rule: "every-observed-piagent-session-preserves-a-complete-privacy-safe-causal-context-receipt",
       passed: causalContextPassed,
@@ -948,10 +945,12 @@ export function buildBenchmarkStageDiagnostic({
       manifestUnknownUsage,
       tokenClaimsUnavailableReason
     },
+    campaignAccounting: publicProductionBenchmarkCampaignEvidence(campaignEvidence)
+      ?? { required: campaignRequired, passed: !campaignRequired },
     hostReadiness: hostReadinessHistory,
     timingDiagnostics: summarizeBenchmarkTimingDiagnostics(acceptedRuns),
     spendFutilityReview: {
-      rule: "partial-stages-from-the-frozen-boundary-enforce-exact-all-attempt-pooled-and-family-fresh-spend-ceilings; this-is-not-the-final-40-percent-claim-gate",
+      rule: "partial-stages-from-the-frozen-boundary-enforce-exact-all-attempt-pooled-and-family-fresh-spend-ceilings; this-is-not-the-final-family-upper95-net35-or-fast-execution-configuration-parity-claim-gate",
       passed: partialSpendPassed && (!subagentBudgetRequired || subagentBudget.passed),
       freshTokens: { passed: freshEfficiencyPassed, ...freshEfficiency },
       partialStageCatastrophicFreshSpend: { required: partialSpendRequired, ...partialSpend },
@@ -969,11 +968,28 @@ export function buildBenchmarkStageDiagnostic({
     checks,
     blockingReasons,
     stageAdvanceAllowed: blockingReasons.length === 0,
-    decisionContract: {
-      blocking: "quality-model-parity-task-continuity-exact-usage-subagent-budget-and-partial-stage-catastrophic-fresh-spend",
-      finalOnly: ["0.60-upper95-fresh-token-reduction"],
+    decisionContract: completeMeasurementPolicy ? {
+      blocking: "measurement-validity-identity-configuration-exact-usage-ledger-and-evidence-integrity-only",
+      finalOnly: [
+        "quality-safety-reliability-workflow-and-category-gates",
+        "paired-quality-and-outcome-floor-gates",
+        "production-subagent-budget",
+        "partial-and-final-fresh-token-ratios",
+        "0.60-upper95-family-fresh-token-ratio",
+        "0.65-pooled-all-attempt-net-fresh-token-ratio"
+      ],
+      observational: ["normalized-api-equivalent-text-token-cost", "duration", "host-load"]
+    } : {
+      blocking: "quality-model-thinking-fast-execution-configuration-parity-task-continuity-exact-usage-subagent-budget-and-partial-stage-catastrophic-fresh-spend",
+      finalOnly: [
+        "0.60-upper95-family-fresh-token-ratio",
+        "0.65-pooled-all-attempt-net-fresh-token-ratio",
+        "fast-execution-configuration-parity-when-required"
+      ],
       observational: ["normalized-api-equivalent-text-token-cost", "duration", "host-load"]
     },
-    claimBoundary: "Provider-free partial-run diagnostic only. Intermediate token measurements cannot make a claim; cost, duration, and host load are observational and non-blocking."
+    claimBoundary: completeMeasurementPolicy
+      ? "Provider-free partial-run diagnostic only. Valid product quality, safety, workflow, subagent-budget, and token-ratio failures are retained for final S108 adjudication; only measurement-invalidating identity, configuration, exact-usage, ledger, grader/harness, or evidence-integrity failures block the next paid stage."
+      : "Provider-free partial-run diagnostic only. Intermediate token measurements cannot make a final family-upper95, net-35 all-attempt, or Fast execution configuration parity claim; cost, duration, and host load are observational and non-blocking."
   };
 }