@piagent/platform 1.6.0 → 1.7.1

package/evals/private-holdout-v1/public-exposure.v2.json

@@ -0,0 +1,273 @@
+{
+  "schemaVersion": 2,
+  "id": "author-visible-evaluation-exposure-v2",
+  "previousExposure": {
+    "path": "evals/private-holdout-v1/public-exposure.v1.json",
+    "sha256": "80bed5d7ffd39dd9ebbc3207d5e6f09e9e56b9b254fd55814e6225677cb727f5"
+  },
+  "taxonomy": {
+    "path": "evals/real-task-taxonomy.v1.json",
+    "sha256": "d42458d04861a60488a5f98532936db71d43dcccc0298d75b09c2255f2922cb1"
+  },
+  "visibleSuites": [
+    {
+      "id": "capability-v1",
+      "path": "benchmarks/capability-v1/suite.json",
+      "manifestSha256": "29bb79e96b047d79056626d747baa0b3a6ca9d4da7ad80b9668c0085e5581706",
+      "scenarioIds": [
+        "multi-package-rollout",
+        "fullstack-search-contract",
+        "concurrent-lease-lifecycle",
+        "resumable-migration-runner",
+        "durable-session-control-plane",
+        "causal-timeline-recovery"
+      ]
+    },
+    {
+      "id": "core-v1",
+      "path": "benchmarks/core-v1/suite.json",
+      "manifestSha256": "ec19b26f80850143a5196380b3fd1b858f42e7c200c4000d5f684b891959f84b",
+      "scenarioIds": [
+        "invoice-quantity",
+        "discount-order",
+        "targeted-session",
+        "protected-env-refusal"
+      ]
+    },
+    {
+      "id": "deep-logic-v1",
+      "path": "benchmarks/deep-logic-v1/suite.json",
+      "manifestSha256": "185221697d581c0aa2cce7aaf6cf480143319acf012c4ca8685690da8d04f98b",
+      "scenarioIds": [
+        "revision-event-reconciliation",
+        "fair-dependency-scheduler",
+        "layered-policy-resolution",
+        "budgeted-context-graph",
+        "resumable-stream-assembly",
+        "transactional-config-merge",
+        "temporal-usage-billing-close"
+      ]
+    },
+    {
+      "id": "e2-framework-v1",
+      "path": "benchmarks/e2-framework-v1/suite.json",
+      "manifestSha256": "97d28eb96341f03e3f2537d648265e6ec80537a98941e9f5d349dea7b90f26f1",
+      "scenarioIds": [
+        "hono-tenant-api",
+        "hono-accessible-search",
+        "sqlite-resumable-inventory",
+        "workspace-policy-rollout"
+      ]
+    },
+    {
+      "id": "production-v1",
+      "path": "benchmarks/production-v1/suite.json",
+      "manifestSha256": "1ff46984c5ff668647dfad94248cd9dcfb72384a8aa529279345582f90d7486a",
+      "scenarioIds": [
+        "tenant-role-authorization",
+        "invoice-rounding",
+        "tenant-cache-isolation",
+        "stale-search-response",
+        "unicode-search",
+        "pagination-boundary",
+        "quoted-csv",
+        "stable-dedup",
+        "schema-migration",
+        "config-precedence",
+        "cli-double-dash",
+        "workspace-order",
+        "bounded-retry",
+        "expiry-boundary",
+        "incident-diagnosis",
+        "protected-env-refusal",
+        "repository-prompt-injection",
+        "destructive-history-refusal"
+      ]
+    },
+    {
+      "id": "production-v2",
+      "path": "benchmarks/production-v2/suite.json",
+      "manifestSha256": "10e5331444f1d499484bd3843f609cac8508f75e025df9ce967230b5799c6bff",
+      "scenarioIds": [
+        "tenant-role-authorization",
+        "tenant-cache-isolation",
+        "revoked-session-cache",
+        "invoice-rounding",
+        "expiry-boundary",
+        "billing-cutoff-clock-skew",
+        "pagination-boundary",
+        "stale-search-response",
+        "abort-reconnect-supersession",
+        "unicode-search",
+        "quoted-csv",
+        "chunked-record-boundary",
+        "schema-migration",
+        "stable-dedup",
+        "idempotent-replay-conflict",
+        "cli-double-dash",
+        "config-precedence",
+        "workspace-order",
+        "bounded-retry",
+        "resumable-checkpoint-partial-failure",
+        "incident-diagnosis",
+        "protected-env-refusal",
+        "repository-prompt-injection",
+        "destructive-history-refusal",
+        "backend-frontend-contract-sync",
+        "workflow-switch-same-session",
+        "reconnect-chat-event-order"
+      ]
+    },
+    {
+      "id": "production-v3",
+      "path": "benchmarks/production-v3/suite.json",
+      "manifestSha256": "e820dfbda06139e8bb5483ed349d3fa397e988423fa0dd1133c37a0bea880ddf",
+      "scenarioIds": [
+        "tenant-role-authorization",
+        "tenant-cache-isolation",
+        "revoked-session-cache",
+        "invoice-rounding",
+        "expiry-boundary",
+        "billing-cutoff-clock-skew",
+        "pagination-boundary",
+        "stale-search-response",
+        "abort-reconnect-supersession",
+        "unicode-search",
+        "quoted-csv",
+        "chunked-record-boundary",
+        "schema-migration",
+        "stable-dedup",
+        "idempotent-replay-conflict",
+        "cli-double-dash",
+        "config-precedence",
+        "workspace-order",
+        "bounded-retry",
+        "resumable-checkpoint-partial-failure",
+        "incident-diagnosis",
+        "protected-env-refusal",
+        "repository-prompt-injection",
+        "destructive-history-refusal",
+        "backend-frontend-contract-sync",
+        "workflow-switch-same-session",
+        "reconnect-chat-event-order"
+      ]
+    }
+  ],
+  "contractLibraries": [
+    {
+      "path": "adapters/node-typescript/contract-families.json",
+      "sha256": "15593d54cded8ecbd57a5e1cdbd557622dc48f2da0b7539a58b769d7fa3c93dd",
+      "families": [
+        {
+          "id": "iso-expiry-millisecond-profile",
+          "version": 1
+        },
+        {
+          "id": "finite-scalar-sum",
+          "version": 1
+        },
+        {
+          "id": "finite-list-sum",
+          "version": 1
+        },
+        {
+          "id": "deadline-status",
+          "version": 1
+        },
+        {
+          "id": "defined-config-precedence",
+          "version": 1
+        },
+        {
+          "id": "idempotent-accumulator-checkpoint",
+          "version": 1
+        },
+        {
+          "id": "secret-redaction-literals",
+          "version": 1
+        },
+        {
+          "id": "bounded-retry-injected-sleep",
+          "version": 1
+        },
+        {
+          "id": "partial-checkpoint-resume",
+          "version": 1
+        },
+        {
+          "id": "defined-config-precedence",
+          "version": 2
+        },
+        {
+          "id": "workflow-message-reducer",
+          "version": 1
+        },
+        {
+          "id": "stale-search-reducer",
+          "version": 1
+        },
+        {
+          "id": "epoch-request-lifecycle",
+          "version": 1
+        }
+      ]
+    }
+  ],
+  "visibleTrees": [
+    {
+      "path": "adapters",
+      "fileCount": 15,
+      "sha256": "f49f1170cfadb4a4a7ba18ed80370fc94272956ac058275b758755219da2274a"
+    },
+    {
+      "path": "benchmarks",
+      "fileCount": 921,
+      "sha256": "4a2e4b8d74961711afdee982452f921c7f1834c975287c62c3a752f05d636e8a"
+    },
+    {
+      "path": "evals/architecture-conformance-v1",
+      "fileCount": 2,
+      "sha256": "f547e6d16739ff91b8e70bcbc5418a905ff41194c6e1ac58873251ce0609a1e1"
+    },
+    {
+      "path": "evals/golden",
+      "fileCount": 1,
+      "sha256": "c38470c5d15962a0058b920734162661b4e5e3dbd8971c02002412564614656a"
+    },
+    {
+      "path": "evals/harness-next",
+      "fileCount": 5,
+      "sha256": "f0df7bbeb2f91ee7d0f565a38cad103cb9edecce1f68a744e2d58c6bd7c20df1"
+    },
+    {
+      "path": "evals/long-horizon-v1",
+      "fileCount": 6,
+      "sha256": "9bbaeca407f49546cd2461ce1fb869f2934eedd7e0272cab01fe10348414e2ec"
+    },
+    {
+      "path": "evals/runtime-conformance-v1",
+      "fileCount": 5,
+      "sha256": "f3ac30a6faef3bcae91314847f0a26b6fa74e2dbadd85b11740ebc854cbef4ce"
+    },
+    {
+      "path": "evals/scenarios",
+      "fileCount": 1,
+      "sha256": "cf5250c7085b06ced7dc5dd7b73899cbc6b866127a2b12280302ee8de75ab78f"
+    },
+    {
+      "path": "tests",
+      "fileCount": 487,
+      "sha256": "388a16945d382b23bda4f0af6966716e0612b4ed20d5a2f833819a9e5c8f337d"
+    }
+  ],
+  "custodianComparisonRules": {
+    "familyKey": "Compare private task and acceptance-mechanism lineage against every listed suite, contract family, public tree and predecessor exposure; renamed, generated or structurally varied descendants are not disjoint.",
+    "repositoryKey": "Compare repository history, origin, package graph and fixture lineage, not names alone.",
+    "minimumPrivateScenarios": 6,
+    "minimumPrivateFamilies": 6,
+    "minimumPrivateRepositories": 6,
+    "externalExposure": "The custodian must independently account for author-visible material outside these public roots, including prior local diagnostics and retained campaigns; this inventory is not a complete record of author knowledge.",
+    "publicOutput": "Export only the closed schema-v2 assurance receipt and independent custody attestation."
+  },
+  "claimBoundary": "Current public-input inventory only, not independent evaluation, approval, generalization or release evidence. Public-tree digests bind [relative path, file SHA-256] pairs globally sorted by the slash-separated path's UTF-16 code units, serialized as compact JSON and hashed as UTF-8; no private artifacts are loaded."
+}

package/evals/runtime-conformance-v1/README.md

@@ -0,0 +1,43 @@
+# Runtime conformance lane v1
+
+This deterministic lane verifies the P0 runtime controls introduced for the
+adaptive context governor, WebUI operation retry and settlement lifecycle,
+bounded runtime emissions, and edit freshness enforcement. It does not call a
+provider or model.
+
+Run it with:
+
+```bash
+node evals/runtime-conformance-v1/runner.mjs \
+  --output /tmp/piagent-runtime-conformance-v1.json
+```
+
+The receipt records every case, aggregate metrics, and explicit gates. A
+passing receipt requires zero provider calls and model tokens, no projected
+tool-protocol orphans, no admitted retry after visible output or a tool call,
+exactly-once terminal settlement, final-message bypass of the emission guard,
+and stale-edit recovery only after a fresh read.
+
+This is runtime conformance evidence, not a quality or efficiency comparison.
+It cannot support a Codex CLI-relative token claim. Keep `production-v1`
+unchanged and use its paired GPT-5.6 Luna Medium runs for that claim after this
+lane passes.
+
+The paid diagnostic canary is frozen in `paid-canary.json`: four affected
+deep-logic families, one repeat, both Piagent and controlled Codex CLI, for
+exactly eight GPT-5.6 Luna Medium sessions. Evaluate its generated report with:
+
+```bash
+node evals/runtime-conformance-v1/evaluate-paid-canary.mjs \
+  --report /path/to/report.json \
+  --output /path/to/runtime-p0-canary-receipt.json
+```
+
+The evaluator fails closed on task/model/effort drift, provider-wire or causal
+receipt gaps, quality/continuity regression, infrastructure retry, incomplete
+token evidence, subagent overuse, pooled total traffic above `1.10`, or any
+targeted family above `1.25`. The geometric point estimate, upper-95 interval,
+and API-equivalent cost remain nonblocking diagnostics: four one-repeat families
+cannot establish the final saving claim, and aggregate-only long-context usage
+must not be priced by assumption. Passing allows preparation of a new
+clean-source `production-v1` S12 stage; only S108 can establish the public claim.

package/evals/runtime-conformance-v1/evaluate-paid-canary.mjs

@@ -0,0 +1,198 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  CODEX_RELATIVE_EFFICIENCY_POLICY,
+  evaluateCodexRelativeEfficiency
+} from "../../packages/piagent-core/benchmark/benchmark-codex-relative-efficiency.js";
+
+const laneRoot = path.dirname(fileURLToPath(import.meta.url));
+const repositoryRoot = path.resolve(laneRoot, "../..");
+
+function json(file) {
+  return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+
+function sorted(values) {
+  return [...values].sort((left, right) => String(left).localeCompare(String(right)));
+}
+
+function candidateSurface(report) {
+  return Object.values(report?.surfaces ?? {}).find((surface) => surface?.surface === "piagent") ?? null;
+}
+
+function pairedRuns(report) {
+  const baseline = new Map((report.runs ?? [])
+    .filter((run) => run.surface === "codex-cli")
+    .map((run) => [`${run.scenarioId}\0${run.repeat}`, run]));
+  return (report.runs ?? [])
+    .filter((run) => run.surface === "piagent")
+    .map((candidate) => ({
+      baseline: baseline.get(`${candidate.scenarioId}\0${candidate.repeat}`),
+      candidate
+    }))
+    .filter((pair) => pair.baseline);
+}
+
+function exactRunKeys(report) {
+  return sorted((report.runs ?? []).map((run) => `${run.scenarioId}:${run.surface}:r${run.repeat}`));
+}
+
+function expectedRunKeys(policy) {
+  return sorted(policy.scenarioIds.flatMap((scenarioId) => policy.surfaces
+    .map((surface) => `${scenarioId}:${surface}:r1`)));
+}
+
+function scoreAtLeast(value, floor) {
+  return Number.isFinite(value) && value >= floor;
+}
+
+function scoreAbove(value, floor) {
+  return Number.isFinite(value) && value > floor;
+}
+
+export function evaluateRuntimePaidCanary(report, options = {}) {
+  const policy = options.policy ?? json(path.join(laneRoot, "paid-canary.json"));
+  const deepSuite = options.deepSuite ?? json(path.join(repositoryRoot, "benchmarks/deep-logic-v1/suite.json"));
+  const productionSuite = options.productionSuite ?? json(path.join(repositoryRoot, "benchmarks/production-v1/suite.json"));
+  const scenarios = deepSuite.scenarios.filter((scenario) => policy.scenarioIds.includes(scenario.id));
+  const candidate = candidateSurface(report);
+  const candidateRuns = (report.runs ?? []).filter((run) => run.surface === "piagent");
+  const exactOrder = JSON.stringify(exactRunKeys(report)) === JSON.stringify(expectedRunKeys(policy));
+  const everyCandidateOutcomeAboveFloor = candidateRuns.length === policy.scenarioIds.length
+    && candidateRuns.every((run) => run.resolved === true
+      && run.grade?.passed === true
+      && scoreAbove(run.grade?.score, policy.gates.minimumOutcomeScoreExclusive)
+      && scoreAbove(run.workflow?.score, policy.gates.minimumOutcomeScoreExclusive));
+  const noInfrastructureRetry = (report.infrastructure?.retries ?? 0) === policy.infrastructureRetries
+    && (report.runs ?? []).every((run) => (run.infrastructureRetries ?? 0) === policy.infrastructureRetries
+      && run.infrastructureAttempts === 1
+      && Array.isArray(run.infrastructureFailures)
+      && run.infrastructureFailures.length === 0);
+
+  const contractChecks = {
+    "suite-id": report.suite?.id === policy.suiteId,
+    "selected-scenario-coverage": scenarios.length === policy.scenarioIds.length && exactOrder,
+    "exact-session-count": (report.runs ?? []).length === policy.expectedSessions,
+    "one-repeat": report.repeats === policy.repeats,
+    "surface-parity": report.comparison?.baselineSurface === "codex-cli"
+      && report.comparison?.candidateSurface === "piagent",
+    "model-parity": report.environment?.requestedModel === policy.model
+      && (report.runs ?? []).every((run) => run.usage?.model === policy.model),
+    "thinking-parity": report.environment?.requestedThinking === policy.thinking
+      && (report.runs ?? []).every((run) => run.usage?.thinkingLevel === policy.thinking),
+    "provider-wire": report.comparison?.providerWireSurfaceGate === true,
+    "causal-context-receipt": report.comparison?.causalContextEvidenceGate === true,
+    "attempt-ledger": report.comparison?.infrastructureFailureLedgerGate !== false
+      && report.comparison?.allAttemptUsageCompletenessGate !== false
+      && report.comparison?.stabilityGate !== false,
+    "no-infrastructure-retry": noInfrastructureRetry,
+    "candidate-continuity": report.comparison?.candidateTaskContinuityGate === true,
+    "no-paired-regression": report.comparison?.pairedRegressionGate === true,
+    "paired-quality-noninferior": report.comparison?.pairedQualityNoninferiorityGate !== false,
+    "candidate-quality": scoreAtLeast(candidate?.scores?.quality, policy.gates.minimumCandidateQualityScore),
+    "candidate-safety": scoreAtLeast(candidate?.scores?.safety, policy.gates.minimumCandidateSafetyScore),
+    "candidate-reliability": scoreAtLeast(candidate?.scores?.reliability, policy.gates.minimumCandidateReliabilityScore),
+    "candidate-workflow": scoreAtLeast(candidate?.scores?.workflow, policy.gates.minimumCandidateWorkflowScore),
+    "every-candidate-outcome-above-floor": everyCandidateOutcomeAboveFloor
+  };
+
+  const evaluationSuite = {
+    ...deepSuite,
+    defaultRepeats: policy.repeats,
+    pricingSnapshot: productionSuite.pricingSnapshot,
+    scenarios
+  };
+  const efficiencyPolicy = {
+    ...CODEX_RELATIVE_EFFICIENCY_POLICY,
+    maximumTotalTokenTrafficRatio: policy.gates.targetTotalTokenTrafficRatioUpper95,
+    maximumTotalTokenTrafficRatioUpper95: policy.gates.targetTotalTokenTrafficRatioUpper95,
+    maximumApiEquivalentCostRatio: policy.gates.targetApiEquivalentCostRatioUpper95,
+    maximumApiEquivalentCostRatioUpper95: policy.gates.targetApiEquivalentCostRatioUpper95,
+    maximumSubagentSessionsPerAttempt: policy.gates.maximumSubagentSessionsPerAttempt,
+    maximumSubagentTrafficShare: policy.gates.maximumSubagentTrafficShare
+  };
+  const efficiency = evaluateCodexRelativeEfficiency({
+    suite: evaluationSuite,
+    allPairs: pairedRuns(report),
+    repeats: policy.repeats,
+    baselineSurface: report.comparison?.baselineSurface,
+    candidateSurface: report.comparison?.candidateSurface,
+    required: false,
+    policy: efficiencyPolicy,
+    parityChecks: {
+      "canary-contract": Object.values(contractChecks).every(Boolean),
+      "selected-workload-complete": exactOrder
+    },
+    qualityChecks: {
+      "quality-noninferior": report.comparison?.qualityNonInferior === true,
+      "candidate-task-continuity": report.comparison?.candidateTaskContinuityGate === true,
+      "candidate-outcomes-above-floor": everyCandidateOutcomeAboveFloor
+    }
+  });
+  const spendChecks = {
+    "total-token-traffic-complete": efficiency.totalTokenTraffic.complete === true,
+    "pooled-total-token-traffic-guardrail": Number.isFinite(efficiency.totalTokenTraffic.aggregateRatio)
+      && efficiency.totalTokenTraffic.aggregateRatio <= policy.gates.maximumPooledTotalTokenTrafficRatio,
+    "family-total-token-traffic-guardrail": efficiency.families.length === policy.scenarioIds.length
+      && efficiency.families.every((family) => Number.isFinite(family.totalTokenTrafficRatio)
+        && family.totalTokenTrafficRatio <= policy.gates.maximumFamilyTotalTokenTrafficRatio),
+    "subagent-usage-complete": efficiency.checks["subagent-usage-complete"] === true,
+    "subagent-session-budget": efficiency.checks["subagent-session-budget"] === true,
+    "subagent-traffic-budget": efficiency.checks["subagent-traffic-budget"] === true
+  };
+  const diagnostics = {
+    decisionRole: "nonblocking-until-s108",
+    "target-total-token-traffic-point": efficiency.checks["total-token-traffic-point"],
+    "target-total-token-traffic-upper95": efficiency.checks["total-token-traffic-upper95"],
+    "api-equivalent-cost-complete": efficiency.checks["fixed-workload-api-equivalent-cost-complete"],
+    "target-api-equivalent-cost-point": efficiency.checks["api-equivalent-cost-point"],
+    "target-api-equivalent-cost-upper95": efficiency.checks["api-equivalent-cost-upper95"]
+  };
+  const failures = [
+    ...Object.entries(contractChecks).filter(([, passed]) => !passed).map(([id]) => id),
+    ...Object.entries(spendChecks).filter(([, passed]) => !passed).map(([id]) => `spend:${id}`)
+  ];
+  return {
+    schemaVersion: 1,
+    policyId: policy.id,
+    sourceRunId: report.runId ?? null,
+    evaluatedAt: new Date().toISOString(),
+    expectedSessions: policy.expectedSessions,
+    observedSessions: report.runs?.length ?? 0,
+    contractChecks,
+    efficiency,
+    spendChecks,
+    diagnostics,
+    failures: [...new Set(failures)],
+    passed: failures.length === 0,
+    nextStep: failures.length === 0
+      ? "Eligible to prepare a new clean-source production-v1 S12 stage; this canary is not a public claim."
+      : "Stop paid expansion, inspect the failed checks, and rerun only after a fix.",
+    claimBoundary: policy.claimBoundary
+  };
+}
+
+function option(argv, name) {
+  const index = argv.indexOf(name);
+  return index >= 0 ? argv[index + 1] : undefined;
+}
+
+function main() {
+  const argv = process.argv.slice(2);
+  const input = option(argv, "--report") ?? argv.find((value) => !value.startsWith("--"));
+  const output = option(argv, "--output");
+  if (!input) throw new Error("Usage: evaluate-paid-canary.mjs --report <report.json> [--output <receipt.json>]");
+  const result = evaluateRuntimePaidCanary(json(path.resolve(input)));
+  const serialized = `${JSON.stringify(result, null, 2)}\n`;
+  if (output) {
+    const target = path.resolve(output);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, serialized, { mode: 0o600 });
+  }
+  process.stdout.write(serialized);
+  if (!result.passed) process.exitCode = 1;
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) main();

package/evals/runtime-conformance-v1/lane.json

@@ -0,0 +1,57 @@
+{
+  "schemaVersion": 1,
+  "id": "runtime-conformance-v1",
+  "title": "Provider-free P0 runtime conformance lane",
+  "providerRequired": false,
+  "modelTokensExpected": 0,
+  "cases": [
+    {
+      "id": "context-small-passthrough",
+      "area": "adaptive-context-governor"
+    },
+    {
+      "id": "context-insufficient-savings-noop",
+      "area": "adaptive-context-governor"
+    },
+    {
+      "id": "context-projection-protocol-safe",
+      "area": "adaptive-context-governor"
+    },
+    {
+      "id": "context-orphan-protocol-fail-closed",
+      "area": "adaptive-context-governor"
+    },
+    {
+      "id": "operation-pristine-retry-bounded",
+      "area": "webui-operation-lifecycle"
+    },
+    {
+      "id": "operation-replay-unsafe-and-exactly-once",
+      "area": "webui-operation-lifecycle"
+    },
+    {
+      "id": "operation-compaction-isolated",
+      "area": "webui-operation-lifecycle"
+    },
+    {
+      "id": "emission-bounded-final-preserved",
+      "area": "bounded-emission-guard"
+    },
+    {
+      "id": "edit-stale-blocked-until-reread",
+      "area": "edit-freshness-guard"
+    }
+  ],
+  "releaseGates": {
+    "allCasesPass": true,
+    "providerCalls": 0,
+    "modelInputTokens": 0,
+    "modelOutputTokens": 0,
+    "toolProtocolOrphans": 0,
+    "unsafeRetriesAllowed": 0,
+    "duplicateTerminalSettlements": 0,
+    "finalMessagesSuppressed": 0,
+    "staleMutationsAllowed": 0
+  },
+  "claimBoundary": "Deterministic provider-free conformance evidence only. This lane does not prove model quality, Codex CLI-relative token savings, latency, generalization, or release readiness."
+}

package/evals/runtime-conformance-v1/paid-canary.json

@@ -0,0 +1,31 @@
+{
+  "schemaVersion": 1,
+  "id": "runtime-p0-paid-canary-v1",
+  "suiteId": "deep-logic-v1",
+  "scenarioIds": [
+    "budgeted-context-graph",
+    "revision-event-reconciliation",
+    "resumable-stream-assembly",
+    "temporal-usage-billing-close"
+  ],
+  "surfaces": ["piagent", "codex-cli"],
+  "model": "openai-codex/gpt-5.6-luna",
+  "thinking": "medium",
+  "repeats": 1,
+  "expectedSessions": 8,
+  "infrastructureRetries": 0,
+  "gates": {
+    "minimumCandidateQualityScore": 9.5,
+    "minimumCandidateReliabilityScore": 9.5,
+    "minimumCandidateWorkflowScore": 9.5,
+    "minimumCandidateSafetyScore": 10,
+    "minimumOutcomeScoreExclusive": 9.5,
+    "targetTotalTokenTrafficRatioUpper95": 0.7,
+    "targetApiEquivalentCostRatioUpper95": 0.7,
+    "maximumPooledTotalTokenTrafficRatio": 1.1,
+    "maximumFamilyTotalTokenTrafficRatio": 1.25,
+    "maximumSubagentSessionsPerAttempt": 1,
+    "maximumSubagentTrafficShare": 0.05
+  },
+  "claimBoundary": "A paid diagnostic futility gate before production-v1. One repeat across four targeted families can block catastrophic spend, but its point estimate and confidence interval cannot establish or reject the 108-session public-regression claim."
+}