@piagent/platform 1.6.0 → 1.7.1

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

@@ -0,0 +1,189 @@
+const FAST_SERVICE_TIERS = new Set(["fast", "priority"]);
+
+function normalizedTier(value) {
+  const tier = typeof value === "string" ? value.trim().toLowerCase() : "";
+  return ["default", "fast", "priority"].includes(tier) ? tier : null;
+}
+
+function uniqueTiers(values) {
+  return [...new Set((Array.isArray(values) ? values : []).map(normalizedTier).filter(Boolean))].sort();
+}
+
+function evidenceForRun(run) {
+  if (run?.surface === "piagent") return run.providerWireEvidence?.serviceTier ?? run.serviceTierEvidence ?? null;
+  if (run?.surface === "codex-cli") return run.usage?.serviceTierEvidence ?? run.serviceTierEvidence ?? null;
+  return run?.serviceTierEvidence ?? null;
+}
+
+function classifyRun(run, requestedServiceTier) {
+  const evidence = evidenceForRun(run);
+  const requestedTiers = uniqueTiers(evidence?.requestedTiers);
+  const observedRequestTiers = uniqueTiers(evidence?.observedRequestTiers);
+  const providerResponseTiers = uniqueTiers(evidence?.providerResponseTiers);
+  const evidenceSourceVerified = run?.surface === "piagent"
+    ? evidence?.source === "piagent-provider-request-telemetry"
+    : run?.surface === "codex-cli"
+      ? evidence?.source === "codex-controlled-invocation-rollout-settings"
+        && evidence.identityBound === true
+        && evidence.invocationBound === true
+        && evidence.coverageBound === true
+        && evidence.settingsBound === true
+        && Array.isArray(evidence.diagnostics)
+        && evidence.diagnostics.length === 0
+      : false;
+  const defaultFallback = [...requestedTiers, ...observedRequestTiers, ...providerResponseTiers].includes("default")
+    || Number(evidence?.defaultFallbackEvents ?? 0) > 0;
+  const evidenceEvents = Number.isSafeInteger(evidence?.events) ? evidence.events : 0;
+  const providerStartedEvents = Number.isSafeInteger(run?.usage?.execution?.providerStartedAttempts)
+    ? run.usage.execution.providerStartedAttempts
+    : 0;
+  const wireEvents = Number.isSafeInteger(run?.providerWireEvidence?.wireEvents)
+    ? run.providerWireEvidence.wireEvents
+    : 0;
+  const appliedEvents = Number.isSafeInteger(evidence?.appliedEvents) ? evidence.appliedEvents : 0;
+  const appliedFastEvents = Number.isSafeInteger(evidence?.appliedFastEvents) ? evidence.appliedFastEvents : 0;
+  const executionConfigurationCoverageVerified = run?.surface === "piagent"
+    ? providerStartedEvents > 0
+      && wireEvents > 0
+      && evidenceEvents === providerStartedEvents
+      && evidenceEvents === wireEvents
+      && evidence?.requestedFastEvents === evidenceEvents
+      && evidence?.observedFastRequestEvents === evidenceEvents
+      && evidence?.fastModeEvents === evidenceEvents
+      && appliedEvents === evidenceEvents
+      && appliedFastEvents === evidenceEvents
+    : run?.surface === "codex-cli"
+      ? providerStartedEvents > 0
+        && evidenceEvents === providerStartedEvents
+        && evidence?.providerStartedEvents === providerStartedEvents
+        && evidence?.invocationEvents === providerStartedEvents
+        && evidence?.initialInvocationEvents === 1
+        && evidence?.resumeInvocationEvents === providerStartedEvents - 1
+        && evidence?.resumeSettingsEvents === providerStartedEvents - 1
+        && evidence?.turnContextEvents === providerStartedEvents
+        && evidence?.coverageBound === true
+      : false;
+  const expectedObservedRequestTier = run?.surface === "piagent" ? "priority" : null;
+  const executionConfigurationVerified = requestedServiceTier === "fast"
+    && evidenceEvents > 0
+    && requestedTiers.length === 1
+    && requestedTiers[0] === "fast"
+    && observedRequestTiers.length === 1
+    && observedRequestTiers.every((tier) => expectedObservedRequestTier === null
+      ? FAST_SERVICE_TIERS.has(tier)
+      : tier === expectedObservedRequestTier)
+    && evidenceSourceVerified
+    && executionConfigurationCoverageVerified
+    && !defaultFallback;
+  const providerResponseVerified = providerResponseTiers.length === 0
+    ? null
+    : providerResponseTiers.every((tier) => FAST_SERVICE_TIERS.has(tier)) && !defaultFallback;
+  return {
+    scenarioId: run?.scenarioId ?? null,
+    repeat: run?.repeat ?? null,
+    surface: run?.surface ?? null,
+    source: evidence?.source ?? "unavailable",
+    evidenceSourceVerified,
+    events: evidenceEvents,
+    providerStartedEvents,
+    wireEvents,
+    appliedEvents,
+    appliedFastEvents,
+    initialInvocationEvents: Number(evidence?.initialInvocationEvents ?? 0),
+    resumeInvocationEvents: Number(evidence?.resumeInvocationEvents ?? 0),
+    resumeSettingsEvents: Number(evidence?.resumeSettingsEvents ?? 0),
+    turnContextEvents: Number(evidence?.turnContextEvents ?? 0),
+    requestedTiers,
+    observedRequestTiers,
+    providerResponseTiers,
+    responseEvidence: Array.isArray(evidence?.responseEvidence) ? [...evidence.responseEvidence] : [],
+    executionConfigurationCoverageVerified,
+    executionConfigurationVerified,
+    providerResponseVerified,
+    defaultFallback
+  };
+}
+
+/**
+ * Fast-mode claims are intentionally two-stage. The execution-configuration
+ * gate combines exact Piagent outbound-request telemetry with a strict,
+ * identity-bound Codex initial invocation and exact resume-settings coverage;
+ * it does not claim both surfaces expose the same wire evidence. The response
+ * gate separately proves the provider reported fast/priority when the host
+ * exposes that field. A missing response tier never inherits a configuration
+ * value: an actual provider-processing-tier claim remains unavailable until
+ * every run exposes response evidence. Any observed `default` value fails the
+ * execution-configuration gate.
+ */
+export function summarizeBenchmarkServiceTierEvidence(runs, { requestedServiceTier, requestedModel, required = false } = {}) {
+  const gpt56FastReferenceRates = requestedServiceTier === "fast"
+    && /(?:^|\/)gpt-5\.6(?:-|$)/.test(String(requestedModel ?? ""));
+  const records = (Array.isArray(runs) ? runs : []).map((run) => classifyRun(run, requestedServiceTier));
+  const bySurface = Object.fromEntries([...new Set(records.map((record) => record.surface).filter(Boolean))]
+    .sort()
+    .map((surface) => {
+      const surfaceRecords = records.filter((record) => record.surface === surface);
+      return [surface, {
+        runs: surfaceRecords.length,
+        executionConfigurationVerifiedRuns: surfaceRecords.filter((record) => record.executionConfigurationVerified).length,
+        executionConfigurationCoverageVerifiedRuns: surfaceRecords.filter((record) => record.executionConfigurationCoverageVerified).length,
+        providerResponseVerifiedRuns: surfaceRecords.filter((record) => record.providerResponseVerified === true).length,
+        providerResponseEvidenceRuns: surfaceRecords.filter((record) => record.providerResponseVerified !== null).length,
+        defaultFallbackRuns: surfaceRecords.filter((record) => record.defaultFallback).length,
+        missingExecutionConfigurationEvidenceRuns: surfaceRecords.filter((record) => !record.executionConfigurationVerified).length,
+        incompleteExecutionConfigurationCoverageRuns: surfaceRecords.filter((record) => !record.executionConfigurationCoverageVerified).length,
+        missingProviderResponseEvidenceRuns: surfaceRecords.filter((record) => record.providerResponseVerified === null).length
+      }];
+    }));
+  const expectedSurfaces = ["piagent", "codex-cli"];
+  const surfaceCoverage = expectedSurfaces.every((surface) => Number(bySurface[surface]?.runs ?? 0) > 0);
+  const executionConfigurationParityGate = !required ? null : requestedServiceTier === "fast"
+    && records.length > 0
+    && surfaceCoverage
+    && records.every((record) => record.executionConfigurationVerified);
+  const responseEvidenceRecords = records.filter((record) => record.providerResponseVerified !== null);
+  const providerResponseEvidenceGate = !required
+    ? null
+    : records.some((record) => record.providerResponseVerified === false)
+      ? false
+      : responseEvidenceRecords.length > 0
+        ? responseEvidenceRecords.every((record) => record.providerResponseVerified === true)
+        : null;
+  return {
+    schemaVersion: 1,
+    required,
+    requestedServiceTier: requestedServiceTier ?? null,
+    acceptedProviderResponseTiers: [...FAST_SERVICE_TIERS],
+    runs: records.length,
+    bySurface,
+    executionConfigurationParityGate,
+    providerResponseEvidenceGate,
+    passed: !required ? null : executionConfigurationParityGate === true && providerResponseEvidenceGate !== false,
+    claimBoundary: "fast-execution-configuration-parity",
+    actualProviderProcessingTierClaimAllowed: providerResponseEvidenceGate === true
+      && responseEvidenceRecords.length === records.length,
+    claimPolicy: "execution-configuration-hard-gate; piagent-fast-intent-must-map-to-applied-priority-outbound-telemetry-for-every-provider-start-and-wire-event; codex-cli-requires-one-strict-identity-bound-initial-invocation-plus-exact-priority-resume-settings-coverage; provider-response-tier-gated-when-host-exposes-it; literal-fast-or-default-pi-wire-tier-fails",
+    subscriptionCreditAccounting: {
+      blocking: false,
+      includedInTokenRatio: false,
+      actualBillingMode: "unverified",
+      applicableMultiplier: null,
+      referenceRates: {
+        chatgptSubscriptionCredits: gpt56FastReferenceRates
+          ? { multiplier: 2.5, applicability: "reference-only" }
+          : null,
+        apiFastTokenPricing: gpt56FastReferenceRates
+          ? { multiplier: 2, applicability: "reference-only" }
+          : null
+      },
+      status: gpt56FastReferenceRates ? "reference-rates-only-billing-mode-unverified" : "not-applicable-or-unavailable",
+      source: "OpenAI Codex Fast mode reference rates for GPT-5.6",
+      note: "Reference rates are reported separately; no multiplier is applied until the run's billing mode is independently verified."
+    },
+    records
+  };
+}
+
+export function benchmarkFastExecutionConfigurationVerified(run) {
+  return classifyRun(run, "fast").executionConfigurationVerified;
+}

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

@@ -1,4 +1,11 @@
 import { benchmarkProviderWireEvidenceMatchesRequest } from "./benchmark-provider-wire.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
@@ -13,9 +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 { 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,6 +53,7 @@ function validStageBoundaries(stageBoundaries) {
 export function productionSpendControlValidationErrors(control, {
   suiteId,
   expectedSessions,
+  suite,
   requireHostReadiness = control?.hostReadiness?.required === true
 } = {}) {
   const errors = [];
@@ -42,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)
@@ -89,6 +99,33 @@ export function productionSpendControlValidationErrors(control, {
     const finalSessions = control.stages.at(-1)?.cumulativeSessions;
     if (Number.isSafeInteger(expectedSessions) && finalSessions !== expectedSessions) errors.push("final-stage-session-count-mismatch");
   }
+  const guards = control.productionGuards;
+  if (suiteId === "production-v1" && (!guards || typeof guards !== "object" || Array.isArray(guards))) errors.push("missing-production-guards");
+  else if (guards !== undefined) {
+    const subagents = guards.subagents;
+    if (subagents?.required !== true
+      || subagents.maximumSessionsPerAttempt !== 1
+      || subagents.maximumTrafficShare !== 0.05
+      || subagents.requireExactAllAttemptEvidence !== true
+      || subagents.requireExplainedSessionCount !== true) errors.push("invalid-production-subagent-guard");
+    const partial = guards.partialFreshSpend;
+    if (partial?.requiredFromCumulativeSessions !== 12
+      || partial.maximumPooledFreshRatio !== 1.1
+      || partial.maximumObservedFamilyFreshRatio !== 1.25
+      || 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(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;
 }
 
@@ -384,6 +421,7 @@ export function buildBenchmarkStageDiagnostic({
   baselineSurface,
   requestedModel,
   requestedThinking,
+  requestedServiceTier,
   suite,
   manifest,
   hostReadinessPolicy = null,
@@ -459,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);
@@ -494,11 +543,39 @@ 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;
   const causalContextPassed = !causalContextRequired
     || causalContextSummary.currentCoverageStatus === "complete";
+  const providerFreeGuard = manifest?.productionGuards?.providerFreeEvidence;
+  const providerFreeEvidenceRequired = providerFreeGuard?.requiredBeforeFirstPaidSession === true;
+  const providerFreeEvidenceErrors = providerFreeEvidenceRequired
+    ? productionProviderFreeEvidenceContextValidationErrors(manifest?.providerFreeEvidence, {
+      source: manifest?.sourceIdentity,
+      candidateProvenance: manifest?.candidateProvenance,
+      providerFreeConfigurationDigest: manifest?.providerFreeConfigurationDigest,
+      treatmentDerivation: manifest?.treatmentDerivation
+    })
+    : [];
+  const providerFreeObservedLaneIds = Array.isArray(manifest?.providerFreeEvidence?.lanes)
+    ? manifest.providerFreeEvidence.lanes.map((lane) => lane?.id)
+    : [];
+  const providerFreeEvidencePassed = !providerFreeEvidenceRequired
+    || (providerFreeEvidenceErrors.length === 0
+      && Array.isArray(providerFreeGuard.requiredLaneIds)
+      && JSON.stringify(providerFreeObservedLaneIds) === JSON.stringify(providerFreeGuard.requiredLaneIds));
+  const adaptiveContextStatuses = piRuns.map((run) => run?.causalContextReceipt?.aggregates?.runtimeCausal?.adaptiveContext?.coverageStatus ?? "not-observed");
+  const partialAdaptiveContextRuns = adaptiveContextStatuses.filter((status) => status === "partial").length;
+  const notObservedAdaptiveContextRuns = adaptiveContextStatuses.filter((status) => status === "not-observed").length;
+  const adaptiveContextCoveragePassed = !providerFreeEvidenceRequired || (partialAdaptiveContextRuns === 0
+    && (notObservedAdaptiveContextRuns === 0 || providerFreeEvidencePassed));
 
   const freshEfficiency = pairRatioEvidence(pairRecords, ({ candidate, baseline }) => ({
     baseline: baseline?.usage?.fresh,
@@ -508,6 +585,28 @@ export function buildBenchmarkStageDiagnostic({
     && freshEfficiency.incomparablePairs.length === 0
     && freshEfficiency.pairRegressions.length === 0
     && freshEfficiency.familyRegressions.length === 0;
+  const guardPolicy = manifest?.productionGuards;
+  const subagentGuard = guardPolicy?.subagents;
+  const subagentBudget = summarizeBenchmarkSubagentBudget(acceptedRuns, {
+    candidateSurface,
+    policy: {
+      schemaVersion: 1,
+      id: "production-subagent-budget-v1",
+      maximumSubagentSessionsPerAttempt: subagentGuard?.maximumSessionsPerAttempt,
+      maximumSubagentTrafficShare: subagentGuard?.maximumTrafficShare
+    }
+  });
+  const subagentBudgetRequired = subagentGuard?.required === true;
+  const partialGuard = guardPolicy?.partialFreshSpend;
+  const partialSpendRequired = Number.isSafeInteger(partialGuard?.requiredFromCumulativeSessions)
+    && acceptedRuns.length >= partialGuard.requiredFromCumulativeSessions
+    && acceptedRuns.length < expectedRuns.length;
+  const partialSpend = partialCatastrophicSpendEvidence(pairRecords, {
+    maximumPooledFreshRatio: partialGuard?.maximumPooledFreshRatio,
+    maximumObservedFamilyFreshRatio: partialGuard?.maximumObservedFamilyFreshRatio,
+    suite
+  });
+  const partialSpendPassed = !partialSpendRequired || partialSpend.passed;
 
   const pricingSnapshot = suite?.pricingSnapshot;
   const pricingSnapshotErrors = benchmarkPricingSnapshotValidationErrors(pricingSnapshot);
@@ -538,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 ?? [])
@@ -566,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
@@ -576,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;
@@ -611,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
     }),
@@ -626,25 +741,78 @@ 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,
       piagentRuns: piRuns.length,
       unavailableRuns: piRuns.length - causalContextAvailableRuns
     }),
+    diagnosticCheck("source-bound-provider-free-evidence", providerFreeEvidencePassed, {
+      required: providerFreeEvidenceRequired,
+      expectedLaneIds: providerFreeGuard?.requiredLaneIds ?? [],
+      observedLaneIds: providerFreeObservedLaneIds,
+      errors: providerFreeEvidenceErrors
+    }),
+    diagnosticCheck("adaptive-context-runtime-coverage", adaptiveContextCoveragePassed, {
+      partialRuns: partialAdaptiveContextRuns,
+      notObservedRuns: notObservedAdaptiveContextRuns,
+      notObservedCoveredBySameSourceProviderFreeLane: providerFreeEvidencePassed
+    }),
     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,
+      exactAttempts: subagentBudget.exactAttempts,
+      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,
@@ -697,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,
@@ -716,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,
@@ -728,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,
@@ -735,12 +913,26 @@ export function buildBenchmarkStageDiagnostic({
       wireGroups,
       wireDriftGroups
     },
+    serviceTierEvidence,
     causalContextEvidence: {
       rule: "every-observed-piagent-session-preserves-a-complete-privacy-safe-causal-context-receipt",
       passed: causalContextPassed,
       piagentRuns: piRuns.length,
       ...causalContextSummary
     },
+    providerFreeEvidence: {
+      required: providerFreeEvidenceRequired,
+      passed: providerFreeEvidencePassed,
+      errors: providerFreeEvidenceErrors,
+      expectedLaneIds: providerFreeGuard?.requiredLaneIds ?? [],
+      observedLaneIds: providerFreeObservedLaneIds
+    },
+    adaptiveContextRuntimeCoverage: {
+      passed: adaptiveContextCoveragePassed,
+      partialRuns: partialAdaptiveContextRuns,
+      notObservedRuns: notObservedAdaptiveContextRuns,
+      delegatedToProviderFreeEvidence: notObservedAdaptiveContextRuns > 0 && providerFreeEvidencePassed
+    },
     infrastructure: {
       retryGatePassed,
       retryEvidenceFailures,
@@ -753,12 +945,16 @@ export function buildBenchmarkStageDiagnostic({
       manifestUnknownUsage,
       tokenClaimsUnavailableReason
     },
+    campaignAccounting: publicProductionBenchmarkCampaignEvidence(campaignEvidence)
+      ?? { required: campaignRequired, passed: !campaignRequired },
     hostReadiness: hostReadinessHistory,
     timingDiagnostics: summarizeBenchmarkTimingDiagnostics(acceptedRuns),
     spendFutilityReview: {
-      rule: "observed-pair-and-observed-family-point-ratios-must-not-exceed-1; this-is-not-the-final-40-percent-claim-gate",
-      passed: freshEfficiencyPassed && normalizedCostPassed && durationEfficiencyPassed,
+      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 },
+      subagentBudget,
       normalizedApiEquivalentTextTokenCost: {
         billedCost: false,
         scope: "model-text-token-input-cache-output-only",
@@ -772,11 +968,28 @@ export function buildBenchmarkStageDiagnostic({
     checks,
     blockingReasons,
     stageAdvanceAllowed: blockingReasons.length === 0,
-    decisionContract: {
-      blocking: "quality-model-parity-task-continuity-and-exact-usage-only",
-      finalOnly: ["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."
   };
 }