@piagent/platform 1.6.0 → 1.6.1

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

@@ -0,0 +1,244 @@
+import path from "node:path";
+
+const MAXIMUM_AGGREGATE = 1_000_000_000;
+const adaptiveContextEvents = new Set([
+  "context_governor_projection",
+  "context_governor_projection_noop",
+  "context_governor_compaction_cancelled",
+  "context_governor_deterministic_compaction",
+  "context_governor_deterministic_compaction_skipped"
+]);
+
+function boundedInteger(value) {
+  return Number.isSafeInteger(value) && value >= 0 && value <= MAXIMUM_AGGREGATE;
+}
+
+function normalizePath(value) {
+  if (typeof value !== "string" || !value || value.length > 4_096) return null;
+  const normalized = path.posix.normalize(value.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+/g, "/"));
+  if (!normalized || normalized === "." || path.posix.isAbsolute(normalized)
+    || normalized === ".." || normalized.startsWith("../")) return null;
+  return normalized;
+}
+
+function section(coverageStatus, observedEvents, aggregate, evidenceSource = "context-telemetry") {
+  return { coverageStatus, observedEvents, evidenceSource, aggregate };
+}
+
+function unavailableWebUiSection() {
+  return section("not-observed", 0, null, "provider-free-runtime-conformance");
+}
+
+function savingsAccounting(event) {
+  const accounting = event?.accounting;
+  if (!accounting || typeof accounting !== "object" || Array.isArray(accounting)
+    || !boundedInteger(accounting.estimatedSavingsTokens)
+    || !boundedInteger(accounting.minimumSavingsTokens)
+    || typeof accounting.minimumSavingsMet !== "boolean") return null;
+  return {
+    estimated: accounting.estimatedSavingsTokens,
+    minimum: accounting.minimumSavingsTokens,
+    met: accounting.minimumSavingsMet
+  };
+}
+
+function projectionAccounting(event) {
+  if (!boundedInteger(event?.estimatedSavingsTokens)
+    || !boundedInteger(event?.minimumSavingsTokens)
+    || !boundedInteger(event?.accounting?.billedTraffic?.governorProviderCalls)) return null;
+  return {
+    estimated: event.estimatedSavingsTokens,
+    minimum: event.minimumSavingsTokens,
+    met: event.estimatedSavingsTokens >= event.minimumSavingsTokens,
+    providerCalls: event.accounting.billedTraffic.governorProviderCalls
+  };
+}
+
+function protocolFailure(event) {
+  const protocol = event?.protocol;
+  if (protocol && typeof protocol === "object" && !Array.isArray(protocol)
+    && protocol.intact === false && Array.isArray(protocol.orphanCallIds) && Array.isArray(protocol.orphanResultIds)
+    && protocol.orphanCallIds.length <= MAXIMUM_AGGREGATE
+    && protocol.orphanResultIds.length <= MAXIMUM_AGGREGATE) {
+    return { calls: protocol.orphanCallIds.length, results: protocol.orphanResultIds.length };
+  }
+  const codes = Array.isArray(event?.reasonCodes) ? event.reasonCodes : [];
+  const count = (prefix) => {
+    const match = codes.find((code) => typeof code === "string" && code.startsWith(prefix));
+    const value = match ? Number.parseInt(match.slice(prefix.length), 10) : 0;
+    return boundedInteger(value) ? value : null;
+  };
+  const calls = count("orphan-calls:"), results = count("orphan-results:");
+  return calls === null || results === null ? null : { calls, results };
+}
+
+function adaptiveContextSection(visible) {
+  const events = visible.filter((event) => adaptiveContextEvents.has(event.event));
+  if (events.length === 0) return section("not-observed", 0, null);
+  const aggregate = {
+    projected: 0,
+    noOp: 0,
+    cancelled: 0,
+    deterministicCompactions: 0,
+    hostSummaryFallbacks: 0,
+    estimatedSavingsTokens: 0,
+    minimumSavingsTokens: 0,
+    minimumSavingsMet: 0,
+    minimumSavingsNotMet: 0,
+    governorProviderCalls: 0,
+    deterministicCompactionProviderCalls: 0,
+    protocolIntegrity: { checks: 0, intact: 0, failed: 0, orphanCalls: 0, orphanResults: 0 },
+    definition: "adaptive-context-runtime-receipt-v1"
+  };
+  let complete = true;
+  const add = (key, value) => {
+    const next = aggregate[key] + value;
+    if (!boundedInteger(value) || !boundedInteger(next)) complete = false;
+    else aggregate[key] = next;
+  };
+  const addProtocol = (intact, failure = { calls: 0, results: 0 }, checks = 1) => {
+    const protocol = aggregate.protocolIntegrity;
+    for (const [key, value] of Object.entries({
+      checks,
+      intact: intact ? checks : 0,
+      failed: intact ? 0 : checks,
+      orphanCalls: failure.calls,
+      orphanResults: failure.results
+    })) {
+      const next = protocol[key] + value;
+      if (!boundedInteger(value) || !boundedInteger(next)) complete = false;
+      else protocol[key] = next;
+    }
+  };
+  const addSavings = (accounting) => {
+    add("estimatedSavingsTokens", accounting.estimated);
+    add("minimumSavingsTokens", accounting.minimum);
+    add(accounting.met ? "minimumSavingsMet" : "minimumSavingsNotMet", 1);
+  };
+
+  for (const event of events) {
+    if (event.event === "context_governor_projection") {
+      const accounting = projectionAccounting(event);
+      if (!accounting || event.action !== "project" || !accounting.met) { complete = false; continue; }
+      aggregate.projected += 1;
+      addSavings(accounting);
+      add("governorProviderCalls", accounting.providerCalls);
+      addProtocol(true, undefined, 2);
+      continue;
+    }
+    if (event.event === "context_governor_projection_noop") {
+      const accounting = projectionAccounting(event);
+      if (!accounting || event.action !== "passthrough"
+        || !["no-safe-boundary", "insufficient-savings", "unsafe-tool-protocol"].includes(event.fallback)) {
+        complete = false; continue;
+      }
+      aggregate.noOp += 1;
+      addSavings(accounting);
+      add("governorProviderCalls", accounting.providerCalls);
+      if (event.fallback === "unsafe-tool-protocol") {
+        const failure = protocolFailure(event);
+        if (!failure) complete = false;
+        else addProtocol(false, failure);
+      } else addProtocol(true, undefined, event.fallback === "insufficient-savings" ? 2 : 1);
+      continue;
+    }
+    if (event.event === "context_governor_compaction_cancelled") {
+      aggregate.cancelled += 1;
+      if (event.fallback === "no-op-unsafe-tool-boundary") {
+        const failure = protocolFailure(event);
+        if (!failure) complete = false;
+        else addProtocol(false, failure);
+      } else if (event.fallback === "no-op-insufficient-savings") {
+        const accounting = savingsAccounting(event);
+        if (!accounting || accounting.met) complete = false;
+        else addSavings(accounting);
+        addProtocol(true);
+      } else complete = false;
+      continue;
+    }
+    if (event.event === "context_governor_deterministic_compaction") {
+      const accounting = savingsAccounting(event), billed = event?.accounting?.billedTraffic;
+      const zeroBilled = billed?.measured === true && billed?.inputTokens === 0 && billed?.outputTokens === 0
+        && billed?.cacheReadTokens === 0 && billed?.scope === "local-deterministic-summary-generation";
+      if (!accounting || (!accounting.met && event.minimumSavingsOverride !== "overflow-recovery") || !zeroBilled) {
+        complete = false; continue;
+      }
+      aggregate.deterministicCompactions += 1;
+      addSavings(accounting);
+      addProtocol(true);
+      continue;
+    }
+    if (event.event === "context_governor_deterministic_compaction_skipped") {
+      if (!["host-model-directed-summary", "host-model-overflow-recovery"].includes(event.fallback)) complete = false;
+      else aggregate.hostSummaryFallbacks += 1;
+    }
+  }
+  return section(complete ? "complete" : "partial", events.length, complete ? aggregate : null);
+}
+
+function freshnessPaths(event) {
+  if (!Array.isArray(event?.paths) || event.paths.length === 0 || event.paths.length > 10_000) return null;
+  const paths = event.paths.map(normalizePath);
+  return paths.some((item) => item === null) ? null : [...new Set(paths)];
+}
+
+function editFreshnessSection(visible) {
+  const observations = visible.map((event, index) => ({ event, index }))
+    .filter(({ event }) => ["edit_freshness_snapshot_observed", "edit_freshness_stale"].includes(event.event));
+  if (observations.length === 0) return section("not-observed", 0, null);
+  const snapshots = [], stale = [];
+  let complete = true;
+  for (const item of observations) {
+    const paths = freshnessPaths(item.event);
+    const taskRunId = typeof item.event.taskRunId === "string" && item.event.taskRunId ? item.event.taskRunId : null;
+    if (!paths || !taskRunId) { complete = false; continue; }
+    if (item.event.event === "edit_freshness_snapshot_observed") {
+      if (!["read", "mutation"].includes(item.event.source)) { complete = false; continue; }
+      snapshots.push({ ...item, paths, taskRunId, source: item.event.source });
+    } else {
+      if (typeof item.event.toolCallId !== "string" || !item.event.toolCallId
+        || typeof item.event.enforce !== "boolean") { complete = false; continue; }
+      stale.push({ ...item, paths, taskRunId, toolCallId: item.event.toolCallId, enforce: item.event.enforce });
+    }
+  }
+  let staleBlocks = 0, rereadRecoveries = 0, mutationRecoveries = 0;
+  const enforced = stale.filter((item) => item.enforce);
+  for (const item of enforced) {
+    const initialSnapshot = item.paths.every((target) => snapshots.some((snapshot) => snapshot.index < item.index
+      && snapshot.taskRunId === item.taskRunId && snapshot.source === "read" && snapshot.paths.includes(target)));
+    if (!initialSnapshot) complete = false;
+    const decisionIndex = visible.findIndex((event, index) => index > item.index && event.event === "tool_decision"
+      && event.toolCallId === item.toolCallId && event.decision === "blocked");
+    if (decisionIndex >= 0) staleBlocks += 1;
+    const reread = decisionIndex >= 0 && item.paths.every((target) => snapshots.some((snapshot) => snapshot.index > decisionIndex
+      && snapshot.taskRunId === item.taskRunId && snapshot.source === "read" && snapshot.paths.includes(target)));
+    if (reread) rereadRecoveries += 1;
+    const mutation = reread && item.paths.every((target) => snapshots.some((snapshot) => snapshot.index > decisionIndex
+      && snapshot.taskRunId === item.taskRunId && snapshot.source === "mutation" && snapshot.paths.includes(target)));
+    if (mutation) mutationRecoveries += 1;
+  }
+  const incompleteRecoveries = enforced.length - rereadRecoveries;
+  if (incompleteRecoveries > 0 || staleBlocks !== enforced.length) complete = false;
+  const aggregate = {
+    snapshotObservations: snapshots.length,
+    readSnapshots: snapshots.filter((item) => item.source === "read").length,
+    mutationSnapshots: snapshots.filter((item) => item.source === "mutation").length,
+    staleDetections: stale.length,
+    enforcedStaleDetections: enforced.length,
+    staleBlocks,
+    rereadRecoveries,
+    mutationRecoveries,
+    incompleteRecoveries,
+    definition: "edit-freshness-runtime-receipt-v1"
+  };
+  return section(complete ? "complete" : "partial", observations.length, complete ? aggregate : null);
+}
+
+export function causalRuntimeEvidence(visible) {
+  return {
+    adaptiveContext: adaptiveContextSection(visible),
+    operationLifecycle: unavailableWebUiSection(),
+    boundedEmission: unavailableWebUiSection(),
+    editFreshness: editFreshnessSection(visible)
+  };
+}

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

@@ -1,4 +1,6 @@
 import { benchmarkProviderWireEvidenceMatchesRequest } from "./benchmark-provider-wire.js";
+import { productionProviderFreeEvidenceContextValidationErrors } from "./benchmark-provider-free-evidence.js";
+import { summarizeBenchmarkSubagentBudget } from "./benchmark-codex-relative-efficiency.js";
 import {
   benchmarkPricingSnapshotValidationErrors,
   normalizeBenchmarkUsageCost
@@ -13,6 +15,7 @@ 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";
 
 const TOKEN_FIELDS = Object.freeze(["input", "output", "cacheRead", "cacheWrite", "reasoning", "fresh", "total"]);
 const PRODUCTION_STAGE_CONTROL_POLICY = "production-v1-provider-spend-v1";
@@ -30,6 +33,11 @@ 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,
@@ -89,6 +97,27 @@ 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(["runtime-conformance-v1", "long-horizon-v1", "webui-parity-v1"])
+      || providerFree.requireCleanCommitAndTreeBinding !== true
+      || providerFree.requireProductionConfigurationBinding !== true
+      || providerFree.requireRunnerAndLaneConfigurationDigests !== true) errors.push("invalid-production-provider-free-evidence-guard");
+  }
   return errors;
 }
 
@@ -341,6 +370,90 @@ 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 = [];
@@ -499,6 +612,27 @@ export function buildBenchmarkStageDiagnostic({
   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,
+      configurationDigest: manifest?.configurationDigest
+    })
+    : [];
+  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 +642,27 @@ 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
+  });
+  const partialSpendPassed = !partialSpendRequired || partialSpend.passed;
 
   const pricingSnapshot = suite?.pricingSnapshot;
   const pricingSnapshotErrors = benchmarkPricingSnapshotValidationErrors(pricingSnapshot);
@@ -643,8 +798,35 @@ export function buildBenchmarkStageDiagnostic({
       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("production-subagent-budget", !subagentBudgetRequired || subagentBudget.passed, {
+      required: subagentBudgetRequired,
+      attempts: subagentBudget.attempts,
+      exactAttempts: subagentBudget.exactAttempts,
+      maximumObservedSessionsPerAttempt: subagentBudget.maximumObservedSessionsPerAttempt,
+      trafficShare: subagentBudget.trafficShare,
+      failures: subagentBudget.failures
+    }),
+    diagnosticCheck("partial-stage-catastrophic-fresh-spend", partialSpendPassed, {
+      required: partialSpendRequired,
+      pooledRatio: partialSpend.pooledRatio,
+      maximumPooledFreshRatio: partialSpend.maximumPooledFreshRatio,
+      familyFailures: partialSpend.familyFailures,
+      maximumObservedFamilyFreshRatio: partialSpend.maximumObservedFamilyFreshRatio,
+      exactUsageIncludingFailedAttempts: partialSpend.exactUsageIncludingFailedAttempts
+    }),
     diagnosticCheck("no-observed-fresh-token-regression", freshEfficiencyPassed, {
       incomparablePairs: freshEfficiency.incomparablePairs.length,
       pairRegressions: freshEfficiency.pairRegressions.length,
@@ -741,6 +923,19 @@ export function buildBenchmarkStageDiagnostic({
       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,
@@ -756,9 +951,11 @@ export function buildBenchmarkStageDiagnostic({
     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-40-percent-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",
@@ -773,8 +970,8 @@ export function buildBenchmarkStageDiagnostic({
     blockingReasons,
     stageAdvanceAllowed: blockingReasons.length === 0,
     decisionContract: {
-      blocking: "quality-model-parity-task-continuity-and-exact-usage-only",
-      finalOnly: ["fresh-token-reduction"],
+      blocking: "quality-model-parity-task-continuity-exact-usage-subagent-budget-and-partial-stage-catastrophic-fresh-spend",
+      finalOnly: ["0.60-upper95-fresh-token-reduction"],
       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."

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

@@ -19,7 +19,8 @@ const RELEASE_GATE_FIELDS = new Set([
   "maximumNormalizedCostRatioUpper95", "maximumBandNormalizedCostRatio", "maximumFamilyNormalizedCostRatio",
   "maximumInfrastructureRetries", "primaryEfficiencyEstimand", "requireEfficiencyClaim", "requireFullSuiteForClaim",
   "requireStableProviderWireSurface", "requireNormalizedCostClaim", "requireHostReadinessForClaim",
-  "requireCausalContextReceipt"
+  "requireCausalContextReceipt", "requireSubagentBudget", "maximumSubagentSessionsPerAttempt",
+  "maximumSubagentTrafficShare", "requireProviderFreeEvidence"
 ]);
 const EXECUTION_CONTRACT_FIELDS = new Set(["surfaces", "model", "thinking", "codexMode"]);
 const THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
@@ -163,6 +164,26 @@ export function benchmarkSuiteValidationErrors(input) {
       if (input.releaseGate.requireCausalContextReceipt !== undefined && typeof input.releaseGate.requireCausalContextReceipt !== "boolean") {
         errors.push("releaseGate.requireCausalContextReceipt must be a boolean");
       }
+      if (input.releaseGate.requireSubagentBudget !== undefined && typeof input.releaseGate.requireSubagentBudget !== "boolean") {
+        errors.push("releaseGate.requireSubagentBudget must be a boolean");
+      }
+      if (input.releaseGate.requireProviderFreeEvidence !== undefined && typeof input.releaseGate.requireProviderFreeEvidence !== "boolean") {
+        errors.push("releaseGate.requireProviderFreeEvidence must be a boolean");
+      }
+      const maximumSubagentSessions = input.releaseGate.maximumSubagentSessionsPerAttempt;
+      if (maximumSubagentSessions !== undefined
+        && (!Number.isSafeInteger(maximumSubagentSessions) || maximumSubagentSessions < 0 || maximumSubagentSessions > 10)) {
+        errors.push("releaseGate.maximumSubagentSessionsPerAttempt must be between 0 and 10");
+      }
+      const maximumSubagentTrafficShare = input.releaseGate.maximumSubagentTrafficShare;
+      if (maximumSubagentTrafficShare !== undefined
+        && (!Number.isFinite(maximumSubagentTrafficShare) || maximumSubagentTrafficShare < 0 || maximumSubagentTrafficShare > 1)) {
+        errors.push("releaseGate.maximumSubagentTrafficShare must be between 0 and 1");
+      }
+      if (input.releaseGate.requireSubagentBudget === true) {
+        if (maximumSubagentSessions === undefined) errors.push("releaseGate.maximumSubagentSessionsPerAttempt is required when requireSubagentBudget is true");
+        if (maximumSubagentTrafficShare === undefined) errors.push("releaseGate.maximumSubagentTrafficShare is required when requireSubagentBudget is true");
+      }
     }
   }
   if (input.pricingSnapshot !== undefined) {

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

@@ -30,6 +30,10 @@ export const RELEASE_FAILURE_MESSAGES = Object.freeze({
   "efficiency-category-coverage": "Comparable token evidence does not cover every required category.",
   "failure-aware-efficiency": "Tokens per resolved outcome exceed the suite limit or failed-attempt usage is unknown.",
   "primary-efficiency": "The predeclared primary efficiency estimand lacks complete family/category evidence or its upper 95% ratio exceeds the suite limit.",
+  "codex-relative-efficiency": "The fixed-workload Piagent/Codex CLI comparison lacks exact parity or quality evidence, exceeds 0.70 total token traffic or API-equivalent cost at the point/upper-95 bound, or exceeds the subagent budget.",
+  "production-subagent-budget": "Production Piagent attempts lack exact child-session accounting, exceed one subagent per attempt, or spend more than 5% of candidate provider traffic on subagents.",
+  "provider-free-evidence": "The production run lacks same-source clean-commit runtime-conformance, long-horizon, or WebUI-parity evidence bound to exact lane configuration and runner bytes.",
+  "adaptive-context-runtime-coverage": "At least one Piagent runtime receipt reports partial adaptive-context evidence, or not-observed evidence lacks a same-source provider-free coverage lane.",
   "repeat-count": "The run used fewer repeats than the suite minimum.",
   "efficiency-confidence": "The upper 95% token-ratio bound exceeds the suite limit.",
   "efficiency-band-ratio": "At least one category, profile, lifecycle, or difficulty fresh-token ratio exceeds the suite limit.",

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

@@ -20,8 +20,8 @@ function plainObject(value) {
 
 export function exactBenchmarkMeasuredUsage(usage) {
   return usage?.usageCompleteness === "exact"
-    && Number.isInteger(usage?.sessions) && usage.sessions > 0
-    && TOKEN_FIELDS.every((field) => Number.isFinite(usage?.[field]) && usage[field] >= 0)
+    && Number.isSafeInteger(usage?.sessions) && usage.sessions > 0
+    && TOKEN_FIELDS.every((field) => Number.isSafeInteger(usage?.[field]) && usage[field] >= 0)
     && usage.fresh === usage.input + usage.output
     && usage.total === usage.input + usage.cacheRead + usage.cacheWrite + usage.output
     && usage.reasoning <= usage.output;
@@ -29,8 +29,10 @@ export function exactBenchmarkMeasuredUsage(usage) {
 
 function knownPreProviderZero(usage, status) {
   return status === "known-pre-provider-zero"
-    && Number(usage?.sessions ?? 0) === 0
-    && TOKEN_FIELDS.every((field) => Number(usage?.[field] ?? 0) === 0);
+    && Number.isSafeInteger(usage?.sessions ?? 0)
+    && (usage?.sessions ?? 0) === 0
+    && TOKEN_FIELDS.every((field) => Number.isSafeInteger(usage?.[field] ?? 0)
+      && (usage?.[field] ?? 0) === 0);
 }
 
 export function exactBenchmarkAttemptUsage(usage, status) {
@@ -107,6 +109,7 @@ export function benchmarkInfrastructureFailureLedgerIssues(runs) {
 
 export function aggregateSessionUsage(sessions) {
   const totals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0, total: 0, cost: 0 };
+  const subagentTokens = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0, total: 0 };
   const models = new Set();
   const thinkingLevels = new Set();
   const toolNames = {};
@@ -115,6 +118,9 @@ export function aggregateSessionUsage(sessions) {
   const contextSnapshots = [];
   for (const session of sessions) {
     for (const key of Object.keys(totals)) totals[key] += Number(session.tokens?.[key] ?? 0);
+    if (session.isSubagent) {
+      for (const key of Object.keys(subagentTokens)) subagentTokens[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);
@@ -136,6 +142,10 @@ export function aggregateSessionUsage(sessions) {
     fresh: totals.input + totals.output,
     sessions: sessions.length,
     subagentSessions: sessions.filter((session) => session.isSubagent).length,
+    subagentTokens: {
+      ...subagentTokens,
+      fresh: subagentTokens.input + subagentTokens.output
+    },
     toolCalls,
     toolNames: Object.fromEntries(Object.entries(toolNames).sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))),
     messages,
@@ -231,6 +241,7 @@ function finishCodexUsage(state) {
     usageCompleteness: "exact",
     sessions: 1,
     subagentSessions: 0,
+    subagentTokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0, fresh: 0, total: 0 },
     toolCalls: Object.values(sortedTools).reduce((sum, value) => sum + value, 0),
     toolNames: sortedTools,
     messages: state.messages,

package/packages/piagent-core/capabilities/runtime-integrity.js

@@ -4,6 +4,7 @@ import path from "node:path";
 export const CORE_RUNTIME_INTEGRITY_FILES = Object.freeze([
   "packages/piagent-core/runtime/context/adaptive-planner.ts",
   "packages/piagent-core/runtime/context/retrieval-route-policy.ts",
+  "packages/piagent-core/extensions/acceptance-behavior-proof.js",
   "packages/piagent-core/extensions/acceptance-contract-semantics.js",
   "packages/piagent-core/extensions/acceptance-executable-evidence.js",
   "packages/piagent-core/extensions/acceptance-language-adapters.js",
@@ -133,6 +134,7 @@ export const CORE_RUNTIME_INTEGRITY_FILES = Object.freeze([
   "packages/piagent-core/runtime/runtime-limits.ts",
   "packages/piagent-core/runtime/session/message-signals.ts",
   "packages/piagent-core/runtime/session/model-authorship-state.ts",
+  "packages/piagent-core/runtime/session/operator-request-carry.ts",
   "packages/piagent-core/runtime/session/performance-review-state.ts",
   "packages/piagent-core/runtime/session/runtime-state.ts",
   "packages/piagent-core/runtime/session/system-prompt.ts",
@@ -154,6 +156,7 @@ export const CORE_RUNTIME_INTEGRITY_FILES = Object.freeze([
   "packages/piagent-core/runtime/tools/phase-tools.ts",
   "packages/piagent-core/runtime/tools/phase-tool-runtime.ts",
   "packages/piagent-core/runtime/workflows/input-routing.ts",
+  "packages/piagent-core/runtime/workflows/runtime-intake-compaction.ts",
   "packages/piagent-core/runtime/workflows/task-intake.ts",
   "scripts/piagent-cli.mjs",
   "scripts/register-typescript-loader.mjs",