@openwop/openwop-conformance 2.45.3 → 2.45.4

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # `@openwop/openwop-conformance` Changelog
 
+## [2.45.4] — 2026-10-01 — v2 ports of production-backpressure and budget-enforcement, on a per-major profile
+
+- **The gate runs every host-free scenario** (not packed; no scenario changes). New `scripts/list-host-free-scenarios.mjs` lists the scenarios whose import closure never reaches `lib/driver`, `lib/sse` or `lib/env` and never calls `fetch(`: 70 files today. `scripts/openwop-check.sh` runs them with `OPENWOP_BASE_URL` and `OPENWOP_API_KEY` unset, after the nine hand-listed files.
+  - **Why.** `host-callback-declaration` and `runner-ledger` failed on every host in the 2.45.3 candidate and nothing in CI said so (#1835).
+  - **Proof.** Clean tree: 66 files pass and 4 skip, no failure. With `REQUIRES_HOST_CALLBACK` removed from `v2-tool-authorization-fail-closed`, the step fails on `host-callback-declaration`.
+  - **Limits.** The walk reads static relative imports. `--check` fails if the set is empty or loses a known member. `ai-envelope-shape` is on the hand list and outside the derived set, so the hand list stays.
+- **The 2.45.4 cycle opens.** Two new scenarios and one new fixture change the packed content.
+- **Fix: an unclaimed any-of floor no longer blocks a major-1 bundle** (a 2.45.3 defect). The runner wrote the `openwop.floor.anyof.byok-roundtrip+secrets-run-witness` summary row for every floor in the v1 table, claimed or not. A host that does not advertise secrets records both members `inapplicable`, so it got one `blocked` row for `openwop-secrets`, a profile it never claimed, and a v3 bundle with any `blocked` row certifies nothing (RFC 0168 §E.1). The row is now written only when the profile is claimed. A claimed profile is unchanged: unwitnessed members still record `blocked` and deny it.
+  - **Who was affected:** a major-1 host cutting a v3 bundle on 2.45.3 without claiming `openwop-secrets`. Major-2 bundles never carried the row.
+  - **Proof.** `floor-any-of.test.ts`: the same evidence yields no row unclaimed and a `blocked` row claimed. Found by running the derivation, after reading the code had suggested the row was harmless.
+- **What differs between majors is now data** (`src/lib/major-profile.ts`). One table row per major holds the run path, the version headers, the event names (from the codemap), where retry timing lives, how a family is advertised, and how a run budget rides on `createRun`. A shared witness takes a profile and never names a major, so a port to a later major is one row plus a thin scenario file. A major with no row throws; it never falls back to an older major's rules.
+- **New scenario `v2-production-backpressure`** (major 2, unaided; `conformance.md` §Production profile). Gated on `production.backpressure.inflightCap`. The suite holds that many event streams open, waits for each to open, and sends one more request.
+  - `openwop.requirement.production.backpressure-refusal`: the extra request answers `503 service_unavailable` with `Retry-After`, equal to `retryAfterSeconds` where advertised.
+  - `openwop.requirement.0171.error-registry.no-retry-details`: the refusal carries no `details.retryAfter*`. v1 required `details.retryAfter`; v2 forbids it.
+  - **Dispositions.** No `production`, `backpressure` or `inflightCap`, a cap above 64, or an unadvertised hold or probe fixture: `inapplicable`. A slot that cannot be held, or a probe with no response: `blocked`.
+  - **Not ported:** v1's "discovery is exempt from the cap" leg. No v2 document states it.
+- **New scenario `v2-budget-enforcement`** (major 2, unaided; `runs.md` §`budget` section). At major 2 a budget rides on `createRun` (`configurable.budget`), so no seam is needed. The suite runs the new fixture with `{ maxToolCalls: 2, thresholdPercent: 50, onExhaustion: "fail" }` and reads the log through the poll.
+  - `openwop.requirement.runs.budget-lifecycle`: `budget.reserved`, `budget.threshold-crossed` and `budget.exhausted`, in order.
+  - `openwop.requirement.runs.budget-enforcement`: a `hard` host emits `cap.breached` (`budget-tool-calls`) and fails the run `budget_exhausted`; an `advisory` host does not stop it.
+  - `openwop.requirement.runs.budget-content-free`: no `budget.*` or `cap.breached` payload carries pricing or a credential.
+  - **Dispositions.** No `budget`, no `toolCalls` dimension, or the fixture unadvertised: `inapplicable`. The fixture is the opt-in, so a host that advertises `budget` without seeding it is unwitnessed, not blocked. A refused valid create: `executed-fail`.
+  - **Not ported:** v1's `budget_model_denied` leg. It needs a fixture that resolves a model without a seam.
+- **New fixture `conformance-budget-tool-calls`**: one `core.conformance.mock-agent` with three scripted tool calls.
+- **Proof.** No host serves either family unaided at major 2, so both witnesses are proven against `src/lib/scratch-host.ts`, a profile-driven test double: 29 self-tests, one defect each (`backpressure-witness.test.ts`, `budget-witness.test.ts`, `major-profile.test.ts`). The scenario files were also run end to end against a conforming and a defective scratch host.
+
 ## [2.45.3] — 2026-10-01 — RFC 0229 (Active): a production host can witness secret resolution without an oracle; v2 tenant-isolation witnesses for storage, fs, memory, workspace, queues and secrets
 
 - **Two self-checks that failed on every host are fixed before the cut.** Found by running the candidate on openwop-app at major 1 against 2.45.2: four rows went `executed-pass` → `executed-fail`, and both files failed the same way with no host.

package/README.md

@@ -135,7 +135,7 @@ Exit code is non-zero on any failed assertion. `--certify` distinguishes: `0`
 
 ## What's Covered
 
-The current suite has 587 scenario files under `src/scenarios/`.
+The current suite has 589 scenario files under `src/scenarios/`.
 - 2026-09-29 (suite 2.45.0, openwop#1763): NEW `v2-cors-preflight.test.ts` — `headers.md` §Cross-origin preflight. For every operation it preflights with `Origin`, the method, and the operation's declared request headers (plus `authorization` / `content-type` where they apply, from `spec/v2/path-manifest.json`), and reads the answer as the Fetch standard's CORS-preflight check does. Self-gated: `inapplicable` when no operation's preflight grants `OPENWOP_CORS_ORIGIN` (default `https://conformance.invalid`).
 - 2026-09-23 (suite 2.37.0 cycle, RFC 0213): NEW `v2-sse-last-event-id-cursor.test.ts` (a `Last-Event-ID` past the log is an exclusive cursor; a malformed id, when refused, is `400 validation_error`; the cursor never changes the answer for an unknown or foreign-tenant run — public test of `event-cursor-after-authorization`), `v2-idempotency-in-flight.test.ts` (five concurrent same-key creates yield one run; each loser is a marked replay or `409 idempotency_in_flight` with no retry timing in `details`; `partial-witness` when no loser was refused in flight) and `v2-interrupt-resolve-terminal.test.ts` (a run-scoped resolve after cancel or completion is `409 interrupt_already_resolved`, never `interrupt_cancelled`). All three sit off the core-standard floor until measured on the three bundle hosts.
 - 2026-09-03 (suite `1.157.0 -> 1.158.0`, gap G17): NEW `idempotency-concurrent-claim.test.ts` — drives the new `host-sample-test-seams.md` §25 concurrent duplicate-delivery seam for the RFC 0150 §B / `idempotency.md` §"Concurrent duplicates (Layer 2)" atomic-claim MUST, which is unconditional and had no witness of any kind. Asserts every executor mints the SAME `logicalInvocationId` **before** asserting `delivered === 1` — without the identity check a host passes by minting different ids and never colliding, one effect because nothing raced. Not profile-gated and so not opt-out-able (the obligation is unconditional); an unmounted seam records `blocked`, which is not certifiable. Graduates `layer2-invocation-claim-atomic` reference-impl -> protocol.
@@ -482,7 +482,7 @@ Server-required (added in 1.7.0):
 | ------------- | ----------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | **Redaction** | [`capabilities.md`](../spec/v1/capabilities.md) §"Secrets" + NFR-7 + §"aiProviders" | Vendor-neutral assertions that the server doesn't leak secret material. Three scenario groups: (a) discovery shape contract — `secrets` + `aiProviders` advertisements are well-formed regardless of `secrets.supported`; when `supported === true`, scopes MUST be non-empty + `resolution === 'host-managed'`; `byok ⊆ supported`. (b) bearer-token redaction — invalid Bearer canary in `Authorization` header is not echoed in the 401 response body. (c) credentialRef echo control — gated on `secrets.supported === true`; canary planted in `configurable.ai.credentialRef` MUST NOT appear in any RunEvent payload (poll-based capture; transport-agnostic). Uses runtime-built canary fixtures (`lib/canaries.ts`) that defeat static secret scanners. 6 scenarios. |
 
-Current source tree: 587 scenario files. Use [`coverage.md`](./coverage.md) for current grade/gap tracking.
+Current source tree: 589 scenario files. Use [`coverage.md`](./coverage.md) for current grade/gap tracking.
 
 ## Remaining Gaps
 

package/dist/lib/scenario-disposition.js

@@ -26,7 +26,7 @@
  * host or a vitest subprocess.
  */
 import { scenarioFileOfItId } from './requirement-ids.js';
-import { PROFILE_FLOOR_SCENARIOS, floorMemberFiles } from './profiles.js';
+import { DEPRECATED_PROFILE_ALIASES, PROFILE_FLOOR_SCENARIOS, floorMemberFiles } from './profiles.js';
 import { targetMajor } from './seams.js';
 import { PKG_ROOT_PATH } from './paths.js';
 import { v2ProfileFloorFiles } from './requirement-registry.js';
@@ -399,10 +399,20 @@ document) {
     // no member failing; `inapplicable`/`skipped` members never satisfy it. v1
     // hand table only, like the prefix groups (the major-2 floors have none).
     const groups = new Map();
+    //
+    // Only for a CLAIMED profile's floor (2.45.4). The row is `blocked` when no
+    // member was witnessed, and a v1 floor reads `inapplicable` as certifiable, so
+    // the row cannot simply say `inapplicable`. But 2.45.3 wrote it for every
+    // floor in the table: a host that does not advertise secrets records both
+    // members `inapplicable`, got one `blocked` row for a profile it never
+    // claimed, and a bundle with any `blocked` row certifies nothing (RFC 0168
+    // §E.1). A group nobody claims is not a requirement on this host.
+    const claimed = new Set(claimedProfiles.map((p) => DEPRECATED_PROFILE_ALIASES[p] ?? p));
     if (!v2FloorsActive())
-        for (const floor of Object.values(PROFILE_FLOOR_SCENARIOS))
-            for (const g of floor.requiredAnyOf ?? [])
-                groups.set(requirementIdForAnyOf(g), g);
+        for (const [profile, floor] of Object.entries(PROFILE_FLOOR_SCENARIOS))
+            if (claimed.has(profile))
+                for (const g of floor.requiredAnyOf ?? [])
+                    groups.set(requirementIdForAnyOf(g), g);
     for (const [id, members] of [...groups.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
         const scenarioId = `anyof:${members.join('|')}`;
         const matching = members.map((f) => perFile.get(f)).filter((r) => r !== undefined);

package/dist/spec-artifacts.lock.json

@@ -1,5 +1,5 @@
 {
   "package": "@openwop/spec-artifacts",
-  "version": "2.45.3",
-  "stampSha256": "2b7ce94326d2cb0fa88b311a7d6d89c0a0b68f03e66934ad49a19722904a75e7"
+  "version": "2.45.4",
+  "stampSha256": "1b559bef6691e393c6dc1cdd29e661a8bbec495e43529135d56aba30e1d0a704"
 }

package/fixtures/conformance-budget-tool-calls.json

@@ -0,0 +1,81 @@
+{
+  "id": "conformance-budget-tool-calls",
+  "name": "Conformance: Budget (tool calls)",
+  "version": "1.0",
+  "description": "Spends a run budget without a model or a seam. One `core.conformance.mock-agent` node makes three scripted tool calls, so a run created with `budget.maxToolCalls: 2` crosses its threshold on the first call and is exhausted before the third. See v2-budget-enforcement.test.ts.",
+  "nodes": [
+    {
+      "id": "spender",
+      "typeId": "core.conformance.mock-agent",
+      "name": "Budget Spender",
+      "position": {
+        "x": 0,
+        "y": 0
+      },
+      "config": {
+        "mockToolCalls": [
+          {
+            "toolId": "openwop.echo:echo",
+            "arguments": {
+              "x": 1
+            },
+            "result": {
+              "x": 1
+            },
+            "durationMs": 1
+          },
+          {
+            "toolId": "openwop.echo:echo",
+            "arguments": {
+              "x": 2
+            },
+            "result": {
+              "x": 2
+            },
+            "durationMs": 1
+          },
+          {
+            "toolId": "openwop.echo:echo",
+            "arguments": {
+              "x": 3
+            },
+            "result": {
+              "x": 3
+            },
+            "durationMs": 1
+          }
+        ],
+        "mockDecision": {
+          "decision": {
+            "next": "done"
+          },
+          "confidence": 1
+        }
+      },
+      "inputs": {},
+      "agent": {
+        "agentId": "core.conformance.budget-spender",
+        "modelClass": "reasoning"
+      }
+    }
+  ],
+  "edges": [],
+  "triggers": [
+    {
+      "id": "manual",
+      "type": "manual",
+      "enabled": true
+    }
+  ],
+  "variables": [],
+  "metadata": {
+    "tags": [
+      "conformance",
+      "budget",
+      "rfc-0084"
+    ]
+  },
+  "settings": {
+    "timeout": 15000
+  }
+}

package/fixtures.md

@@ -73,6 +73,7 @@ All fixtures MUST advertise:
 | Agent Identity                            | `conformance-agent-identity`                                                                    | Phase 1 — `RunSnapshot.agent` / `runOrchestrator` AgentRef wire-shape                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `completed`                                                                         | ≤ 10s                        |
 | Agent Reasoning                           | `conformance-agent-reasoning`                                                                   | Phase 1 / RFC 0023 — `agent.*` event family emission + `callId` pairing on `core.conformance.mock-agent`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `completed`                                                                         | ≤ 15s                        |
 | Agent Reasoning Streaming                 | `conformance-agent-reasoning-streaming`                                                         | RFC 0024 — `core.conformance.mock-agent` with `mockReasoning.streamChunks` drives incremental `agent.reasoning.delta` events (sequence 0..N-1) followed by exactly one closing `agent.reasoned` whose `reasoning` equals the concatenation. Gated on `capabilities.agents.reasoning.streaming: true`.                                                                                                                                                                                                                                                                                                                                                     | `completed`                                                                         | ≤ 15s                        |
+| Budget (tool calls)                       | `conformance-budget-tool-calls`                                                                 | `runs.md` §`budget` section — one `core.conformance.mock-agent` makes three scripted tool calls, so a run budget is spent with no model and no seam. Seeding it opts the host in to `v2-budget-enforcement` | `completed`; `failed` (`budget_exhausted`) under a hard budget below 3 calls | ≤ 15s                        |
 | Agent Low-Confidence                      | `conformance-agent-low-confidence`                                                              | Phase 1 / CP-1 / RFC 0023 — `core.conformance.mock-agent` emits `agent.decided` with confidence < threshold; host MUST follow with `node.suspended { reason: 'low-confidence' }`                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `waiting-approval` (suspends)                                                       | unbounded (suspends)         |
 | Message Reducer                           | `conformance-message-reducer`                                                                   | Phase 1 — `message` reducer idempotency on duplicate `messageId`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `completed`                                                                         | ≤ 10s                        |
 | Agent Pack Install                        | `conformance-agent-pack-install`                                                                | Phase 2 — pack `agents[]` surface as AgentManifest at `GET /v1/packs`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `completed`                                                                         | ≤ 5s                         |
@@ -371,6 +372,16 @@ The `messages`-mode stream fixture (AI token streaming) is covered by the determ
 
 ---
 
+
+### `conformance-budget-tool-calls`
+
+- **Purpose**: spend a run budget unaided, so `budget` can be witnessed without a model or a seam (`v2-budget-enforcement`).
+- **Shape**: one `core.conformance.mock-agent` node with three `mockToolCalls`. Each call counts once against the `toolCalls` dimension.
+- **Inputs**: none.
+- **Expected behavior**: created with `configurable.budget = { maxToolCalls: 2, thresholdPercent: 50, onExhaustion: "fail" }`, the run emits `budget.reserved`, then `budget.threshold-crossed`, then `budget.exhausted`. A host advertising `enforce: "hard"` then emits `cap.breached` (`kind: "budget-tool-calls"`) and fails the run `budget_exhausted`; an `advisory` host lets it complete.
+- **Terminal status**: `completed` with no budget; `failed` under a hard budget below three calls.
+- **Opt-in**: a host that advertises `budget` without seeding this fixture records `inapplicable` for the witness.
+
 ## `conformance-version-fold` (closes F5)
 
 - **Consuming scenario**: `conformance/src/scenarios/version-fold.test.ts` (added 2026-06-11; previously this fixture had no consuming scenario).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openwop/openwop-conformance",
-  "version": "2.45.3",
+  "version": "2.45.4",
   "description": "Production-ready black-box conformance suite for OpenWOP v1.0 compliant servers.",
   "repository": {
     "type": "git",
@@ -56,6 +56,6 @@
     "@openwop/spec-artifacts": "file:../spec-artifacts"
   },
   "peerDependencies": {
-    "@openwop/spec-artifacts": "2.45.3"
+    "@openwop/spec-artifacts": "2.45.4"
   }
 }

package/requirements.json

@@ -2,11 +2,11 @@
   "$comment": "GENERATED by conformance/scripts/generate-requirement-registry.mjs — do not edit. One record per it()/test() in src/scenarios. Ids: openwop.it.<file-stem>.<title-slug>[~n] (src/lib/requirement-ids.ts). A record with id null has an interpolated title; its run-time row is keyed by the rendered title and maps here by file+line only. Renamed ids need a row in requirement-aliases.json.",
   "generatedFrom": "src/scenarios/*.test.ts",
   "counts": {
-    "files": 662,
-    "tests": 2535,
-    "withStableId": 2535,
+    "files": 664,
+    "tests": 2540,
+    "withStableId": 2540,
     "interpolatedTitles": 0,
-    "explicitIds": 2411
+    "explicitIds": 2416
   },
   "records": [
     {
@@ -23601,7 +23601,7 @@
     {
       "id": "openwop.it.runner-ledger.a-floor-file-that-vitest-passed-but-that-recorded-nothing-is-unclassified-when-a",
       "file": "runner-ledger.test.ts",
-      "line": 146,
+      "line": 143,
       "title": "a floor file that vitest passed but that recorded NOTHING is unclassified when a ledger exists — silence is not a witness",
       "explicitId": "openwop.it.runner-ledger.a-floor-file-that-vitest-passed-but-that-recorded-nothing-is-unclassified-when-a",
       "citations": [
@@ -23614,7 +23614,7 @@
     {
       "id": "openwop.it.runner-ledger.a-vacuous-pass-executed-pass-with-assertioncount-0-on-a-claimed-floor-is-unclass",
       "file": "runner-ledger.test.ts",
-      "line": 158,
+      "line": 155,
       "title": "a VACUOUS pass (executed-pass with assertionCount 0) on a claimed floor is unclassified and REJECTS certification",
       "explicitId": "openwop.it.runner-ledger.a-vacuous-pass-executed-pass-with-assertioncount-0-on-a-claimed-floor-is-unclass",
       "citations": [
@@ -23627,7 +23627,7 @@
     {
       "id": "openwop.it.runner-ledger.a-skipped-file-with-no-ledger-entry-is-blocked-unclassified-and-it-never-reads-a",
       "file": "runner-ledger.test.ts",
-      "line": 167,
+      "line": 164,
       "title": "a skipped file with no ledger entry is blocked (unclassified) — and it never reads as skipped/inapplicable",
       "explicitId": "openwop.it.runner-ledger.a-skipped-file-with-no-ledger-entry-is-blocked-unclassified-and-it-never-reads-a",
       "citations": [
@@ -23640,7 +23640,7 @@
     {
       "id": "openwop.it.runner-ledger.a-recorded-inapplicable-skipped-is-certifiable-and-not-unclassified-a-recorded-e",
       "file": "runner-ledger.test.ts",
-      "line": 179,
+      "line": 176,
       "title": "a recorded inapplicable/skipped is certifiable and NOT unclassified; a recorded executed-fail blocks but is classified",
       "explicitId": "openwop.it.runner-ledger.a-recorded-inapplicable-skipped-is-certifiable-and-not-unclassified-a-recorded-e",
       "citations": [
@@ -23653,7 +23653,7 @@
     {
       "id": "openwop.it.runner-ledger.a-discoveryonly-profile-certifies-with-an-empty-floor-an-unknown-profile-does-no",
       "file": "runner-ledger.test.ts",
-      "line": 192,
+      "line": 189,
       "title": "a discoveryOnly profile certifies with an empty floor; an unknown profile does not",
       "explicitId": "openwop.it.runner-ledger.a-discoveryonly-profile-certifies-with-an-empty-floor-an-unknown-profile-does-no",
       "citations": [
@@ -23666,7 +23666,7 @@
     {
       "id": "openwop.it.runner-ledger.a-runtime-derived-profile-openwop-node-packs-is-held-only-when-every-floor-row-i",
       "file": "runner-ledger.test.ts",
-      "line": 199,
+      "line": 196,
       "title": "a RUNTIME-DERIVED profile (openwop-node-packs) is HELD only when every floor row is a witnessed pass; otherwise it is not held — not rejected, not blocked",
       "explicitId": "openwop.it.runner-ledger.a-runtime-derived-profile-openwop-node-packs-is-held-only-when-every-floor-row-i",
       "citations": [
@@ -23683,7 +23683,7 @@
     {
       "id": "openwop.it.runner-ledger.the-runner-s-a-resolution-of-a-silent-zero-assertion-file-blocked-marker-is-stil",
       "file": "runner-ledger.test.ts",
-      "line": 234,
+      "line": 231,
       "title": "the runner's §A resolution of a silent zero-assertion file (blocked + marker) is STILL unclassified for a claimed floor",
       "explicitId": "openwop.it.runner-ledger.the-runner-s-a-resolution-of-a-silent-zero-assertion-file-blocked-marker-is-stil",
       "citations": [
@@ -23696,7 +23696,7 @@
     {
       "id": "openwop.it.runner-ledger.with-no-ledger-at-all-every-skipped-file-is-blocked-and-the-runner-says-so-the-p",
       "file": "runner-ledger.test.ts",
-      "line": 247,
+      "line": 244,
       "title": "with no ledger at all, every skipped file is blocked and the runner says so (the pre-S6 honest reading)",
       "explicitId": "openwop.it.runner-ledger.with-no-ledger-at-all-every-skipped-file-is-blocked-and-the-runner-says-so-the-p",
       "citations": [
@@ -23709,7 +23709,7 @@
     {
       "id": "openwop.it.runner-ledger.notes-are-keyed-to-the-current-test-file-worst-first-when-mixed-and-read-back-wi",
       "file": "runner-ledger.test.ts",
-      "line": 257,
+      "line": 254,
       "title": "notes are keyed to the current test file, worst-first when mixed, and read back with joined reasons",
       "explicitId": "openwop.it.runner-ledger.notes-are-keyed-to-the-current-test-file-worst-first-when-mixed-and-read-back-wi",
       "citations": [
@@ -23722,7 +23722,7 @@
     {
       "id": "openwop.it.runner-ledger.files-that-finished-before-this-one-appear-in-the-ledger-file-with-an-assertion",
       "file": "runner-ledger.test.ts",
-      "line": 279,
+      "line": 276,
       "title": "files that finished before this one appear in the ledger file with an assertion count",
       "explicitId": "openwop.it.runner-ledger.files-that-finished-before-this-one-appear-in-the-ledger-file-with-an-assertion",
       "citations": [
@@ -28618,6 +28618,48 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-budget-enforcement.a-budgeted-run-emits-budget-reserved-budget-threshold-crossed-and-budget-exhaust",
+      "file": "v2-budget-enforcement.test.ts",
+      "line": 76,
+      "title": "a budgeted run emits budget.reserved, budget.threshold-crossed and budget.exhausted in order",
+      "explicitId": "openwop.requirement.runs.budget-lifecycle",
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-budget-enforcement.a-hard-host-stops-the-run-budget-exhausted-after-cap-breached-and-an-advisory-ho",
+      "file": "v2-budget-enforcement.test.ts",
+      "line": 82,
+      "title": "a hard host stops the run budget_exhausted after cap.breached, and an advisory host does not stop it",
+      "explicitId": "openwop.requirement.runs.budget-enforcement",
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-budget-enforcement.no-budget-or-cap-breached-payload-carries-pricing-or-a-credential",
+      "file": "v2-budget-enforcement.test.ts",
+      "line": 89,
+      "title": "no budget.* or cap.breached payload carries pricing or a credential",
+      "explicitId": "openwop.requirement.runs.budget-content-free",
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
     {
       "id": "openwop.it.v2-bundle-v3-signed.a-signed-v3-bundle-validates-against-the-closed-root-schema-an-extra-root-key-is",
       "file": "v2-bundle-v3-signed.test.ts",
@@ -33153,6 +33195,34 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-production-backpressure.with-inflightcap-slots-held-the-next-request-is-refused-503-service-unavailable",
+      "file": "v2-production-backpressure.test.ts",
+      "line": 58,
+      "title": "with inflightCap slots held, the next request is refused 503 service_unavailable with Retry-After",
+      "explicitId": "openwop.requirement.production.backpressure-refusal",
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-production-backpressure.the-refusal-carries-its-retry-timing-in-the-retry-after-header-only",
+      "file": "v2-production-backpressure.test.ts",
+      "line": 66,
+      "title": "the refusal carries its retry timing in the Retry-After header only",
+      "explicitId": "openwop.requirement.0171.error-registry.no-retry-details",
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
     {
       "id": "openwop.it.v2-profiles-derived-only.the-v2-document-carries-no-root-profiles",
       "file": "v2-profiles-derived-only.test.ts",

package/scenario-majors.json

@@ -1,9 +1,9 @@
 {
   "$comment": "GENERATED by conformance/scripts/generate-scenario-majors.mjs (RFC 0168 §D.3). Do not edit; add a file to BOTH_MAJORS in the generator to target both majors.",
   "counts": {
-    "files": 587,
+    "files": 589,
     "v1": 454,
-    "v2": 148
+    "v2": 150
   },
   "majors": {
     "a2a-1-0-agent-card.test.ts": [
@@ -1317,6 +1317,9 @@
     "v2-bound-id-path-projection.test.ts": [
       2
     ],
+    "v2-budget-enforcement.test.ts": [
+      2
+    ],
     "v2-bundle-v3-signed.test.ts": [
       2
     ],
@@ -1521,6 +1524,9 @@
     "v2-preferred-version-default.test.ts": [
       2
     ],
+    "v2-production-backpressure.test.ts": [
+      2
+    ],
     "v2-profiles-derived-only.test.ts": [
       2
     ],

package/schemas/CORPUS-STAMP.json

@@ -1,17 +1,17 @@
 {
   "_comment": "Provenance of @openwop/spec-artifacts (RFC 0168 §D.2). files: SHA-256 per file; the conformance suite compares the installed peer against dist/spec-artifacts.lock.json at start.",
   "package": "@openwop/spec-artifacts",
-  "version": "2.45.3",
-  "corpusTag": "v2.45.3",
+  "version": "2.45.4",
+  "corpusTag": "v2.45.4",
   "files": {
     "api/.redocly.lint-ignore.yaml": "bf5a8350b88a72fa43f59605ed8d903ed24b6cfccda5e45509c9f6ed9ee4e712",
     "api/asyncapi.yaml": "d5ecb9ee6114582be3b1f662c84bfac9ae96dae7bacb853e461168f70a8e1c7d",
     "api/grpc/openwop.proto": "c3e72bb17cba514ee98feb6434e6c9b6ea6795bfd086489ec69fd882dd1ad977",
     "api/openapi.yaml": "ad37a5a5c732ad46100fc03c3f4243fdd4f2976e330f02a8791b6b5b10a8a0c1",
     "api/redocly.yaml": "b0604c89b2ca6d5076ec25725c539dad44a741a811fe524439ee6daef8baa09f",
-    "api/seams-v2.yaml": "1f22ab7223019080332312b0fc9f7eb4c97bca2eebd57cab886acd1d6e3081d0",
-    "api/v2/asyncapi.yaml": "5b74151b1867c3c234203aa1f2dfb1ceeea216e013395e8696da02d4a8630412",
-    "api/v2/openapi.yaml": "05a07d9cd1e7f80da1e7044aace1073bf4ab584186cdd67979ba2664f90a80d0",
+    "api/seams-v2.yaml": "e4a8e19b494d12c0d105ed8d1d27337995564a6443cb8a747521a9d67977b52b",
+    "api/v2/asyncapi.yaml": "d53ca2c06a47282a0cc39d9e0b6b488068da0ad2c91c3166598b005dcf72aa21",
+    "api/v2/openapi.yaml": "24bce91f02de6527121f12ab23916c4f96bab2cbf8f2203208c1d3a444c632c5",
     "api/v2/redocly.yaml": "1e66b60e6118ad11a823bb620678be464d99dfe50a40e3e6f93ec9429b88b34c",
     "schemas/README.md": "0c0b737ffcf8f30e7d2809cec8a498232de710f41443212922ad8337cdde0b51",
     "schemas/a2a-task-state.schema.json": "75d5049dea8bd873ff0e7546f1c60c8d36c219bec7084264360be54a8be30ae1",
@@ -204,7 +204,7 @@
     "schemas/workspace-file.schema.json": "464de85c2a068243084ee9c1d969bc7cd5d8f7948574e58450d6493c38a0e1e4",
     "spec/v1/alias-detectors.json": "0b2f28808ffe0b9d98a187775038c3406bb70919747a788a6e4f866e293ae6d3",
     "spec/v1/capability-declaration-classes.json": "e7729aed5c4b4e1dd02abab0530f14cc95f5d4070fe51fb139e7f5cccefa00c6",
-    "spec/v1/core-standard-manifest.json": "746278bbf9cf46840ba3bd5a85683251ddbc379466585f54e582754ce684d637",
+    "spec/v1/core-standard-manifest.json": "aa1ecb9c1f1c1c3039f948b137e4672031fad29103bb9ac4166eb4ff89b7c85e",
     "spec/v1/deprecations.json": "a3293072ea951857395d05f0437264e88965f1e9019ff61c55bacfa9c1aaa17c",
     "spec/v1/deprecations.schema.json": "3e393c405d2a41b467d8c5e3c468549078df1ce6a6d2588fc488097b95d9b55b",
     "spec/v1/event-codemap.json": "3da60d884157793a360da532a9fcbbfb5285636db325a74cec94b34622186d97",
@@ -303,9 +303,9 @@
     "spec/v2/path-manifest.json": "27c2307b84376b2f22bea4e2213fc7e33ef3bf8fd1d18039f7955edb00dc9c9a",
     "spec/v2/peer-dependency-aliases.json": "d10299280abee08258502925bc327293ee413e0108cd6e6ec75ff6110653308d",
     "spec/v2/profiles.json": "180beb9ef2d161766fa23b2987e7e829851e3d316273147cf6a4a3f324befd6b",
-    "spec/v2/release.json": "0befa21e6634c82cd3d6be9e487f79b7bf77fd3143ce3e0aed301230753b21bc",
+    "spec/v2/release.json": "d1b495b89fc43030e607d7dc312732500f0433e84656ccc88ad8c80c2ac444b1",
     "spec/v2/retention-floors.json": "eaf3722d95c79947af1d4269ef85117e126518c588cfcf1a2b21b97269f51624",
-    "spec/v2/surface-baseline.json": "fd44c977c6646c0bcbd85f9f5c4dce620bba29ee56b10cd077e3f71437e0276a"
+    "spec/v2/surface-baseline.json": "9e17340cea86146899703c91246ddd5a5403c68e40e749f0ad1958801f60b619"
   },
-  "corpusCommit": "f84011f0ce7ba068e53c1aa2b92d17fa97f5df5f"
+  "corpusCommit": "5a4ad1ab0a3584c7ea30f4b32f4599e53ce1f75a"
 }

package/src/lib/backpressure-witness.ts

@@ -0,0 +1,163 @@
+/**
+ * The backpressure witness, shared by every major (`major-profile.ts`).
+ *
+ * A host that advertises `production.backpressure.inflightCap` names a number
+ * the suite can saturate: `cap` long-lived requests hold the slots and the
+ * next request must be refused `503 service_unavailable` with `Retry-After`.
+ *
+ * Two halves, so each can be proven alone:
+ *   - {@link saturate} drives the host and returns what it saw (or why it
+ *     could not see anything). It asserts nothing.
+ *   - {@link judge} is pure: observation in, findings out. The scenario turns
+ *     findings into `expect` calls; the self-test feeds it a conforming and a
+ *     defective observation and checks the verdicts differ.
+ *
+ * Run with `--no-file-parallelism`: saturating the cap leaves no headroom for
+ * a neighbouring scenario's requests.
+ */
+
+import { driver, type OpenWOPResponse } from './driver.js';
+import { loadEnv } from './env.js';
+import { readErrorCode } from './error-envelope.js';
+import { isFixtureAdvertised } from './fixtures.js';
+import type { MajorProfile } from './major-profile.js';
+
+/** The long-running fixture that holds a slot, and the cheap one that probes. */
+export const HOLD_FIXTURE = 'conformance-delay';
+export const PROBE_FIXTURE = 'conformance-noop';
+/** Long enough that the first slot is still held when the last is filled; the runs are cancelled afterwards. */
+const HOLD_MS = 15_000;
+/** The most streams the suite will hold open. A larger advertised cap is not saturated. */
+export const MAX_SATURABLE_CAP = 64;
+const STREAM_OPEN_MS = 5_000;
+const RETRY_DETAIL_KEYS = ['retryAfter', 'retryAfterMs', 'retryAfterSeconds'] as const;
+
+export interface Refusal {
+  readonly cap: number;
+  readonly status: number;
+  readonly code: string | undefined;
+  readonly retryAfterHeader: string | null;
+  readonly details: Record<string, unknown> | null;
+  readonly advertisedRetryAfterSeconds: number | undefined;
+}
+export type Saturation =
+  | { readonly kind: 'skip'; readonly disposition: 'inapplicable' | 'blocked'; readonly reason: string }
+  | { readonly kind: 'refused'; readonly refusal: Refusal };
+
+export interface Finding {
+  /** Which rule the finding is about; the scenario maps it to a requirement id. */
+  readonly rule: 'refusal' | 'retry-after-advertised' | 'retry-timing';
+  readonly ok: boolean;
+  readonly doc: string;
+  readonly message: string;
+}
+
+const isRecord = (v: unknown): v is Record<string, unknown> => v !== null && typeof v === 'object' && !Array.isArray(v);
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> {
+  try { return await fn(); } catch { return null; }
+}
+
+/** Hold `cap` slots with long-lived event streams, send one more request, and report its answer. */
+export async function saturate(profile: MajorProfile, discovery: unknown): Promise<Saturation> {
+  const production = profile.family(discovery, 'production');
+  if (production === null) return { kind: 'skip', disposition: 'inapplicable', reason: 'the host does not advertise production' };
+  const bp = production['backpressure'];
+  if (!isRecord(bp)) return { kind: 'skip', disposition: 'inapplicable', reason: 'the host does not advertise production.backpressure' };
+  const cap = bp['inflightCap'];
+  if (typeof cap !== 'number' || !Number.isInteger(cap) || cap < 1) {
+    return { kind: 'skip', disposition: 'inapplicable', reason: 'the host does not advertise production.backpressure.inflightCap — there is no cap the suite can saturate' };
+  }
+  if (cap > MAX_SATURABLE_CAP) return { kind: 'skip', disposition: 'inapplicable', reason: `inflightCap ${cap} is above the ${MAX_SATURABLE_CAP} streams the suite will hold open — not saturated` };
+  for (const f of [HOLD_FIXTURE, PROBE_FIXTURE]) {
+    if (!isFixtureAdvertised(f)) return { kind: 'skip', disposition: 'inapplicable', reason: `${f} fixture not advertised — the suite cannot hold or probe a slot` };
+  }
+
+  const env = loadEnv();
+  const streams: AbortController[] = [];
+  const pending: Promise<number | null>[] = [];
+  const runIds: string[] = [];
+  try {
+    for (let i = 0; i < cap; i++) {
+      const created = await http(() => driver.post(profile.runsPath, { workflowId: HOLD_FIXTURE, inputs: { delayMs: HOLD_MS } }));
+      if (created === null) return { kind: 'skip', disposition: 'blocked', reason: `POST ${profile.runsPath} unreachable while filling slot ${i + 1} of ${cap}` };
+      const runId = (created.json as { runId?: unknown } | undefined)?.runId;
+      if (created.status !== 201 || typeof runId !== 'string') {
+        return { kind: 'skip', disposition: 'blocked', reason: `slot ${i + 1} of ${cap} could not be filled: POST ${profile.runsPath} answered ${created.status} ${readErrorCode(created.json) ?? ''} (already saturated by a parallel file? run with --no-file-parallelism)`.trim() };
+      }
+      runIds.push(runId);
+      const ctl = new AbortController();
+      streams.push(ctl);
+      // `Accept: text/event-stream` keeps the request in flight; without it a
+      // negotiating host answers a one-shot snapshot and the slot drops.
+      const stream = fetch(`${env.baseUrl}${profile.runsPath}/${encodeURIComponent(runId)}/events`, {
+        headers: { Authorization: `Bearer ${env.apiKey}`, Accept: 'text/event-stream', ...profile.versionHeaders },
+        signal: ctl.signal,
+      }).then((r) => r.status, () => null);
+      pending.push(stream);
+      // The slot is held once the stream's headers are back, not after a
+      // guessed delay. A probe sent before that would convict a host for a slot
+      // the suite had not yet taken.
+      const opened = await Promise.race([stream, new Promise<'slow'>((r) => setTimeout(() => r('slow'), STREAM_OPEN_MS))]);
+      if (opened !== 200) {
+        return { kind: 'skip', disposition: 'blocked', reason: `slot ${i + 1} of ${cap} was not held: the event stream ${opened === 'slow' ? `did not open within ${STREAM_OPEN_MS} ms` : opened === null ? 'failed to connect' : `answered ${opened}`}` };
+      }
+    }
+
+    const probe = await http(() => driver.post(profile.runsPath, { workflowId: PROBE_FIXTURE }));
+    if (probe === null) return { kind: 'skip', disposition: 'blocked', reason: `the cap+1 probe got no response (POST ${profile.runsPath})` };
+    const accepted = (probe.json as { runId?: unknown } | undefined)?.runId;
+    if (probe.status === 201 && typeof accepted === 'string') runIds.push(accepted);
+    const body = isRecord(probe.json) ? probe.json : {};
+    const advertised = bp['retryAfterSeconds'];
+    return {
+      kind: 'refused',
+      refusal: {
+        cap,
+        status: probe.status,
+        code: readErrorCode(probe.json) ?? undefined,
+        retryAfterHeader: probe.headers.get('retry-after'),
+        details: isRecord(body['details']) ? body['details'] : null,
+        advertisedRetryAfterSeconds: typeof advertised === 'number' ? advertised : undefined,
+      },
+    };
+  } finally {
+    // The held runs outlive their streams. Cancel them so the next file does
+    // not meet a saturated host.
+    for (const c of streams) c.abort();
+    if (runIds.length > 0) {
+      const bulk = await http(() => driver.post(`${profile.runsPath}:bulk-cancel`, { runIds }));
+      if (bulk === null || bulk.status >= 400) {
+        for (const id of runIds) await http(() => driver.post(`${profile.runsPath}/${encodeURIComponent(id)}/cancel`, {}));
+      }
+    }
+    await Promise.allSettled(pending);
+  }
+}
+
+/** What the refusal must look like at this major. Pure. */
+export function judge(profile: MajorProfile, r: Refusal): Finding[] {
+  const home = `${profile.specRoot}/${profile.major === 1 ? 'production-profile.md §Backpressure' : 'conformance.md §Production profile'}`;
+  const out: Finding[] = [];
+  out.push({ rule: 'refusal', ok: r.status === 503, doc: home, message: `with inflightCap ${r.cap} slots held, the next request MUST be refused 503 (got ${r.status})` });
+  out.push({ rule: 'refusal', ok: r.code === 'service_unavailable', doc: home, message: `the refusal MUST carry the code service_unavailable (got ${r.code ?? 'none'})` });
+  const header = (r.retryAfterHeader ?? '').trim();
+  out.push({ rule: 'refusal', ok: header.length > 0, doc: home, message: 'the 503 MUST set Retry-After' });
+
+  if (r.advertisedRetryAfterSeconds !== undefined) {
+    out.push({
+      rule: 'retry-after-advertised',
+      ok: /^\d+$/.test(header) && Number(header) === r.advertisedRetryAfterSeconds,
+      doc: 'capabilities.schema.json production.backpressure.retryAfterSeconds',
+      message: `Retry-After MUST equal the advertised retryAfterSeconds ${r.advertisedRetryAfterSeconds} (got "${header}")`,
+    });
+  }
+
+  if (profile.retryTiming === 'header-only') {
+    const spelled = RETRY_DETAIL_KEYS.filter((k) => r.details !== null && k in r.details);
+    out.push({ rule: 'retry-timing', ok: spelled.length === 0, doc: `${profile.specRoot}/errors.md §Retry timing`, message: `retry timing lives in the Retry-After header only; details MUST NOT carry ${spelled.join(', ') || 'retryAfter*'}` });
+  } else {
+    const d = r.details?.['retryAfter'];
+    out.push({ rule: 'retry-timing', ok: typeof d === 'number' && /^\d+$/.test(header) && d === Number(header), doc: home, message: 'details.retryAfter MUST be numeric and equal the Retry-After header in seconds' });
+  }
+  return out;
+}

package/src/lib/budget-witness.ts

@@ -0,0 +1,165 @@
+/**
+ * The run-budget witness, shared by every major that gives a budget a run wire
+ * surface (`major-profile.ts` `runBudget`).
+ *
+ * Unaided: the suite creates a run of `conformance-budget-tool-calls` (three
+ * scripted tool calls, no model, no seam) with a two-call budget, waits for it
+ * to end, and reads its event log through the poll.
+ *
+ * Two halves, as in `backpressure-witness.ts`: {@link drive} observes and
+ * asserts nothing; {@link judge} is pure.
+ *
+ * The fixture is the opt-in. A host that advertises `budget` without seeding it
+ * records `inapplicable`: the family is then unwitnessed at this major, which
+ * the coverage report shows, and the host is not denied certification for a
+ * fixture it was never asked to seed.
+ */
+
+import { driver, type OpenWOPResponse } from './driver.js';
+import { readErrorCode } from './error-envelope.js';
+import { isFixtureAdvertised } from './fixtures.js';
+import type { MajorProfile } from './major-profile.js';
+
+export const BUDGET_FIXTURE = 'conformance-budget-tool-calls';
+/** The fixture makes 3 calls: 50% is crossed on the first, and the budget cannot cover the third. */
+export const BUDGET_POLICY = { maxToolCalls: 2, thresholdPercent: 50, onExhaustion: 'fail' } as const;
+const DIMENSION = 'toolCalls';
+const CAP_KIND = 'budget-tool-calls';
+/** Keys a `budget.*` or `cap.breached` payload must never carry (`budget-no-pricing-leak`). */
+export const PRICING_KEYS = ['pricing', 'priceTable', 'prices', 'rate', 'rates', 'unitPrice', 'costModel', 'tokenPrice', 'secret', 'apiKey'] as const;
+const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
+
+export interface RunEvent { readonly type: string; readonly sequence: number; readonly payload: Record<string, unknown> }
+export interface BudgetObservation {
+  readonly enforce: 'hard' | 'advisory' | undefined;
+  readonly status: string;
+  readonly errorCode: string | undefined;
+  readonly events: readonly RunEvent[];
+  /** This major's names for the four events the witness reads. */
+  readonly names: { readonly reserved: string; readonly threshold: string; readonly exhausted: string; readonly capBreached: string };
+}
+export type BudgetRun =
+  | { readonly kind: 'skip'; readonly disposition: 'inapplicable' | 'blocked'; readonly reason: string }
+  | { readonly kind: 'refused'; readonly status: number; readonly code: string | undefined }
+  | { readonly kind: 'observed'; readonly observation: BudgetObservation };
+
+export interface Finding {
+  readonly rule: 'create' | 'lifecycle' | 'hard-stop' | 'advisory' | 'content-free';
+  readonly ok: boolean;
+  readonly doc: string;
+  readonly message: string;
+}
+
+const isRecord = (v: unknown): v is Record<string, unknown> => v !== null && typeof v === 'object' && !Array.isArray(v);
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> {
+  try { return await fn(); } catch { return null; }
+}
+
+async function readEvents(profile: MajorProfile, runId: string): Promise<RunEvent[] | null> {
+  const out: RunEvent[] = [];
+  let after = 0;
+  for (let page = 0; page < 50; page++) {
+    const res = await http(() => driver.get(`${profile.runsPath}/${encodeURIComponent(runId)}/events/poll?timeout=1&afterSequence=${after}`));
+    if (res === null || res.status !== 200) return page === 0 ? null : out;
+    const batch = (res.json as { events?: unknown } | undefined)?.events;
+    if (!Array.isArray(batch) || batch.length === 0) return out;
+    for (const e of batch) {
+      if (!isRecord(e) || typeof e['type'] !== 'string' || typeof e['sequence'] !== 'number') continue;
+      out.push({ type: e['type'], sequence: e['sequence'], payload: isRecord(e['payload']) ? e['payload'] : {} });
+      after = Math.max(after, e['sequence']);
+    }
+  }
+  return out;
+}
+
+/** Create the budgeted run, wait for it to end, and return its log. */
+export async function drive(profile: MajorProfile, discovery: unknown, timeoutMs = 20_000): Promise<BudgetRun> {
+  const family = profile.family(discovery, 'budget');
+  if (family === null) return { kind: 'skip', disposition: 'inapplicable', reason: 'the host does not advertise budget' };
+  const fragment = profile.runBudget(BUDGET_POLICY);
+  if (fragment === null) return { kind: 'skip', disposition: 'inapplicable', reason: `major ${profile.major} gives a run budget no createRun surface` };
+  const dims = family['dimensions'];
+  if (!Array.isArray(dims) || !dims.includes(DIMENSION)) return { kind: 'skip', disposition: 'inapplicable', reason: `budget.dimensions does not list ${DIMENSION} — the host does not enforce the dimension this witness spends` };
+  if (!isFixtureAdvertised(BUDGET_FIXTURE)) return { kind: 'skip', disposition: 'inapplicable', reason: `${BUDGET_FIXTURE} fixture not advertised — the host has not opted in to the unaided budget witness` };
+
+  const names = {
+    reserved: profile.eventType('budget.reserved'),
+    threshold: profile.eventType('budget.threshold.crossed'),
+    exhausted: profile.eventType('budget.exhausted'),
+    capBreached: profile.eventType('cap.breached'),
+  };
+  if (names.reserved === undefined || names.threshold === undefined || names.exhausted === undefined || names.capBreached === undefined) {
+    return { kind: 'skip', disposition: 'blocked', reason: `the event name map for major ${profile.major} is not on disk in this layout — the witness will not guess event names` };
+  }
+
+  const created = await http(() => driver.post(profile.runsPath, { workflowId: BUDGET_FIXTURE, ...fragment }));
+  if (created === null) return { kind: 'skip', disposition: 'blocked', reason: `POST ${profile.runsPath} unreachable (fetch failed)` };
+  if (created.status === 429) return { kind: 'skip', disposition: 'blocked', reason: `POST ${profile.runsPath} answered 429 — the run budget of the host, not the wire` };
+  const runId = (created.json as { runId?: unknown } | undefined)?.runId;
+  if (created.status !== 201 || typeof runId !== 'string') return { kind: 'refused', status: created.status, code: readErrorCode(created.json) ?? undefined };
+
+  const deadline = Date.now() + timeoutMs;
+  let snap: Record<string, unknown> | null = null;
+  for (;;) {
+    const res = await http(() => driver.get(`${profile.runsPath}/${encodeURIComponent(runId)}`));
+    snap = res?.status === 200 && isRecord(res.json) ? res.json : null;
+    if (snap !== null && TERMINAL.has(String(snap['status']))) break;
+    if (Date.now() > deadline) {
+      await http(() => driver.post(`${profile.runsPath}/${encodeURIComponent(runId)}/cancel`, {}));
+      return { kind: 'skip', disposition: 'blocked', reason: `the budgeted run did not reach a terminal status within ${timeoutMs} ms (last: ${snap === null ? 'unreadable' : String(snap['status'])})` };
+    }
+    await new Promise((r) => setTimeout(r, 250));
+  }
+  const events = await readEvents(profile, runId);
+  if (events === null) return { kind: 'skip', disposition: 'blocked', reason: `GET ${profile.runsPath}/{runId}/events/poll unreadable — the run ended but its log could not be read` };
+
+  const enforce = family['enforce'];
+  const error = snap['error'];
+  return {
+    kind: 'observed',
+    observation: {
+      enforce: enforce === 'hard' || enforce === 'advisory' ? enforce : undefined,
+      status: String(snap['status']),
+      errorCode: isRecord(error) && typeof error['code'] === 'string' ? error['code'] : undefined,
+      events,
+      names: names as BudgetObservation['names'],
+    },
+  };
+}
+
+/** What the log must show at this major. Pure. */
+export function judge(profile: MajorProfile, o: BudgetObservation): Finding[] {
+  const home = `${profile.specRoot}/runs.md §budget section`;
+  const first = (type: string): RunEvent | undefined => o.events.find((e) => e.type === type);
+  const reserved = first(o.names.reserved);
+  const threshold = first(o.names.threshold);
+  const exhausted = first(o.names.exhausted);
+  const breach = o.events.find((e) => e.type === o.names.capBreached && typeof e.payload['kind'] === 'string' && (e.payload['kind'] as string).startsWith('budget-'));
+  const out: Finding[] = [];
+
+  out.push({ rule: 'lifecycle', ok: reserved !== undefined, doc: home, message: `a budgeted run MUST emit ${o.names.reserved}` });
+  out.push({ rule: 'lifecycle', ok: threshold !== undefined && typeof threshold.payload['percent'] === 'number', doc: home, message: `spending past thresholdPercent MUST emit ${o.names.threshold} with a numeric percent` });
+  out.push({ rule: 'lifecycle', ok: exhausted !== undefined, doc: home, message: `a budget that cannot cover the run MUST emit ${o.names.exhausted}` });
+  if (reserved !== undefined && threshold !== undefined && exhausted !== undefined) {
+    out.push({ rule: 'lifecycle', ok: reserved.sequence < threshold.sequence && threshold.sequence < exhausted.sequence, doc: home, message: `the log MUST order ${o.names.reserved} < ${o.names.threshold} < ${o.names.exhausted}` });
+  }
+
+  if (o.enforce === 'hard') {
+    out.push({ rule: 'hard-stop', ok: breach !== undefined && breach.payload['kind'] === CAP_KIND, doc: home, message: `hard exhaustion under onExhaustion: fail MUST emit ${o.names.capBreached} with kind ${CAP_KIND} (got ${breach === undefined ? 'none' : String(breach.payload['kind'])})` });
+    if (breach !== undefined && exhausted !== undefined) {
+      out.push({ rule: 'hard-stop', ok: exhausted.sequence <= breach.sequence, doc: home, message: `${o.names.capBreached} MUST NOT precede ${o.names.exhausted}` });
+    }
+    out.push({ rule: 'hard-stop', ok: o.status === 'failed' && o.errorCode === 'budget_exhausted', doc: home, message: `hard exhaustion MUST fail the run budget_exhausted (got ${o.status} ${o.errorCode ?? ''})`.trim() });
+  }
+  if (o.enforce === 'advisory') {
+    out.push({ rule: 'advisory', ok: breach === undefined && o.errorCode !== 'budget_exhausted', doc: home, message: 'an advisory host MUST NOT stop the run' });
+  }
+
+  const leaks: string[] = [];
+  for (const e of o.events) {
+    if (!e.type.startsWith('budget.') && e !== breach) continue;
+    for (const k of PRICING_KEYS) if (k in e.payload) leaks.push(`${e.type}.${k}`);
+  }
+  out.push({ rule: 'content-free', ok: leaks.length === 0, doc: home, message: `budget.* and cap.breached MUST NOT carry rate cards, unit prices or credentials (found ${leaks.join(', ') || 'none'})` });
+  return out;
+}

package/src/lib/major-profile.ts

@@ -0,0 +1,93 @@
+/**
+ * What differs between protocol majors, as data.
+ *
+ * A scenario that is "the same requirement at another major" used to be a
+ * copy of the earlier file with the paths, event names and envelope rules
+ * edited by hand. The differences are few and regular, so they live in one
+ * table here. A shared witness (`backpressure-witness.ts`) takes a profile and
+ * never names a major; the scenario file for each major is a thin wrapper.
+ *
+ * **Adding a major** is one row in {@link MAJOR_PROFILES} plus one thin
+ * scenario file per ported witness. `majorProfile()` throws on a major with no
+ * row, so a missing row is a loud failure and never a silent fall back to an
+ * older major's rules.
+ *
+ * Keep a field here only when a shared witness reads it. A rule one major
+ * states and another does not is not a field: the witness asks the profile
+ * whether the rule binds (see `retryTiming`), and cites the document that
+ * states it.
+ */
+
+import { capabilityFamily } from './discovery-capabilities.js';
+import { codemapV1toV2 } from './era2-seed.js';
+
+export interface MajorProfile {
+  readonly major: number;
+  /** The run collection, e.g. `/v1/runs` or `/runs`. */
+  readonly runsPath: string;
+  /** Headers a raw `fetch` must add to speak this major (the driver adds its own). */
+  readonly versionHeaders: Readonly<Record<string, string>>;
+  /** Where the corpus states this major's rules, for requirement citations. */
+  readonly specRoot: string;
+  /**
+   * Where retry timing lives on an error response. `header-and-details`: the
+   * envelope repeats `Retry-After` in `details.retryAfter`. `header-only`: the
+   * header is the only place, and `details.retryAfter*` is forbidden.
+   */
+  readonly retryTiming: 'header-and-details' | 'header-only';
+  /** The advertised record for a capability family, or `null` when the host does not advertise it. */
+  family(doc: unknown, key: string): Record<string, unknown> | null;
+  /**
+   * The `createRun` body fragment that carries a run budget policy, or `null`
+   * when this major has no run wire surface for one (a witness that needs it
+   * is then `inapplicable` at this major).
+   */
+  runBudget(policy: Readonly<Record<string, unknown>>): Record<string, unknown> | null;
+  /**
+   * This major's name for an event, given its era-1 name. `undefined` when the
+   * mapping is not on disk in this layout: the caller records that as an
+   * unread observation and never guesses a name.
+   */
+  eventType(era1Name: string): string | undefined;
+}
+
+const isRecord = (v: unknown): v is Record<string, unknown> => v !== null && typeof v === 'object' && !Array.isArray(v);
+
+export const MAJOR_PROFILES: Readonly<Record<number, MajorProfile>> = {
+  1: {
+    major: 1,
+    runsPath: '/v1/runs',
+    versionHeaders: {},
+    specRoot: 'spec/v1',
+    retryTiming: 'header-and-details',
+    // v1: a family is advertised when its record says `supported: true`.
+    family: (doc, key) => {
+      const rec = capabilityFamily(doc, key);
+      return isRecord(rec) && rec['supported'] === true ? rec : null;
+    },
+    // v1 budgets are driven through a host seam, not `createRun`.
+    runBudget: () => null,
+    eventType: (era1Name) => era1Name,
+  },
+  2: {
+    major: 2,
+    runsPath: '/runs',
+    versionHeaders: { 'OpenWOP-Version': '2.0' },
+    specRoot: 'spec/v2/core',
+    retryTiming: 'header-only',
+    // v2: presence of the record is the advertisement.
+    family: (doc, key) => {
+      const rec = isRecord(doc) ? doc[key] : undefined;
+      return isRecord(rec) ? rec : null;
+    },
+    runBudget: (policy) => ({ configurable: { version: 1, budget: { ...policy } } }),
+    eventType: (era1Name) => codemapV1toV2().get(era1Name),
+  },
+};
+
+/** The profile for a major. Throws when the table has no row for it. */
+export function majorProfile(major: number): MajorProfile {
+  const p = MAJOR_PROFILES[major];
+  if (p === undefined) throw new Error(`no MajorProfile for major ${major} — add a row to MAJOR_PROFILES in lib/major-profile.ts`);
+  return p;
+}

package/src/lib/scenario-disposition.ts

@@ -27,7 +27,7 @@
  */
 
 import { scenarioFileOfItId } from './requirement-ids.js';
-import { PROFILE_FLOOR_SCENARIOS, floorMemberFiles } from './profiles.js';
+import { DEPRECATED_PROFILE_ALIASES, PROFILE_FLOOR_SCENARIOS, floorMemberFiles } from './profiles.js';
 import { targetMajor } from './seams.js';
 import { PKG_ROOT_PATH } from './paths.js';
 import { v2ProfileFloorFiles } from './requirement-registry.js';
@@ -478,7 +478,16 @@ export function deriveRequirementDispositions(
   // no member failing; `inapplicable`/`skipped` members never satisfy it. v1
   // hand table only, like the prefix groups (the major-2 floors have none).
   const groups = new Map<string, readonly string[]>();
-  if (!v2FloorsActive()) for (const floor of Object.values(PROFILE_FLOOR_SCENARIOS)) for (const g of floor.requiredAnyOf ?? []) groups.set(requirementIdForAnyOf(g), g);
+  //
+  // Only for a CLAIMED profile's floor (2.45.4). The row is `blocked` when no
+  // member was witnessed, and a v1 floor reads `inapplicable` as certifiable, so
+  // the row cannot simply say `inapplicable`. But 2.45.3 wrote it for every
+  // floor in the table: a host that does not advertise secrets records both
+  // members `inapplicable`, got one `blocked` row for a profile it never
+  // claimed, and a bundle with any `blocked` row certifies nothing (RFC 0168
+  // §E.1). A group nobody claims is not a requirement on this host.
+  const claimed = new Set(claimedProfiles.map((p) => DEPRECATED_PROFILE_ALIASES[p] ?? p));
+  if (!v2FloorsActive()) for (const [profile, floor] of Object.entries(PROFILE_FLOOR_SCENARIOS)) if (claimed.has(profile)) for (const g of floor.requiredAnyOf ?? []) groups.set(requirementIdForAnyOf(g), g);
   for (const [id, members] of [...groups.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
     const scenarioId = `anyof:${members.join('|')}`;
     const matching = members.map((f) => perFile.get(f)).filter((r): r is DerivedRequirement => r !== undefined);

package/src/lib/scratch-host.ts

@@ -0,0 +1,130 @@
+/**
+ * A scratch host: the smallest HTTP server a shared witness can be proven
+ * against, in both directions, inside the suite's own self-tests.
+ *
+ * Some families are advertised by no reference host, so a new witness for them
+ * cannot be sabotage-proved against a real one. A witness that was never seen
+ * to fail is not a witness. The scratch host serves a discovery document and a
+ * scripted run surface, and each self-test turns on ONE defect to show the
+ * witness convicts it.
+ *
+ * It is a test double, not a host: it executes nothing, and nothing it does is
+ * evidence about any implementation. It takes a {@link MajorProfile}, so the
+ * same double proves the next major's port.
+ */
+
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from 'node:http';
+import type { AddressInfo } from 'node:net';
+import type { MajorProfile } from './major-profile.js';
+
+export interface ScriptedEvent { readonly type: string; readonly payload?: Record<string, unknown> | undefined }
+export interface ScriptedRun {
+  readonly status: 'completed' | 'failed' | 'running';
+  readonly error?: { readonly code: string; readonly message: string };
+  readonly events: readonly ScriptedEvent[];
+}
+export interface ScratchRefusal {
+  readonly status: number;
+  readonly headers?: Readonly<Record<string, string>>;
+  readonly body: Record<string, unknown>;
+}
+export interface ScratchOptions {
+  readonly profile: MajorProfile;
+  /** The discovery document, served as given. */
+  readonly discovery: Readonly<Record<string, unknown>>;
+  /** What a created run looks like, by workflowId and request body. Default: an empty running run. */
+  readonly script?: ((workflowId: string, body: Readonly<Record<string, unknown>>) => ScriptedRun) | undefined;
+  /** Concurrent in-flight requests admitted before {@link refusal} answers. Unset: no cap. */
+  readonly inflightCap?: number | undefined;
+  readonly refusal?: ScratchRefusal | undefined;
+}
+
+interface StoredRun { readonly id: string; run: ScriptedRun }
+
+export class ScratchHost {
+  private server: Server | undefined;
+  private readonly runs = new Map<string, StoredRun>();
+  private inflight = 0;
+  private seq = 0;
+  url = '';
+
+  constructor(private opts: ScratchOptions) {}
+
+  /** Swap behaviour between cases. The address stays the same, since the driver caches its base URL per file. */
+  reconfigure(next: Partial<ScratchOptions>): void {
+    this.opts = { ...this.opts, ...next };
+    this.runs.clear();
+  }
+
+  async start(): Promise<string> {
+    this.server = createServer((req, res) => { void this.handle(req, res); });
+    await new Promise<void>((r) => this.server!.listen(0, '127.0.0.1', r));
+    this.url = `http://127.0.0.1:${(this.server.address() as AddressInfo).port}`;
+    return this.url;
+  }
+
+  async stop(): Promise<void> {
+    const s = this.server;
+    if (s === undefined) return;
+    s.closeAllConnections();
+    await new Promise<void>((r) => s.close(() => r()));
+  }
+
+  private send(res: ServerResponse, status: number, body: unknown, headers: Readonly<Record<string, string>> = {}): void {
+    res.writeHead(status, { 'content-type': 'application/json', ...headers });
+    res.end(JSON.stringify(body));
+  }
+
+  private async body(req: IncomingMessage): Promise<Record<string, unknown>> {
+    const chunks: Buffer[] = [];
+    for await (const c of req) chunks.push(c as Buffer);
+    try {
+      const v: unknown = JSON.parse(Buffer.concat(chunks).toString('utf8') || '{}');
+      return v !== null && typeof v === 'object' && !Array.isArray(v) ? (v as Record<string, unknown>) : {};
+    } catch { return {}; }
+  }
+
+  private async handle(req: IncomingMessage, res: ServerResponse): Promise<void> {
+    const path = (req.url ?? '/').split('?')[0] ?? '/';
+    const runs = this.opts.profile.runsPath;
+    // Discovery is never counted against the cap.
+    if (req.method === 'GET' && path === '/.well-known/openwop') return this.send(res, 200, this.opts.discovery);
+
+    const cap = this.opts.inflightCap;
+    if (cap !== undefined && this.inflight >= cap) {
+      const r = this.opts.refusal ?? { status: 503, headers: { 'retry-after': '1' }, body: { error: 'service_unavailable', message: 'at capacity' } };
+      return this.send(res, r.status, r.body, r.headers);
+    }
+    this.inflight++;
+    res.on('close', () => { this.inflight--; });
+
+    if (req.method === 'POST' && path === runs) {
+      const body = await this.body(req);
+      const workflowId = String(body['workflowId'] ?? '');
+      const id = `scratch/run-${++this.seq}`;
+      this.runs.set(id, { id, run: this.opts.script?.(workflowId, body) ?? { status: 'running', events: [] } });
+      return this.send(res, 201, { runId: id, status: 'running' });
+    }
+    if (req.method === 'POST' && path === `${runs}:bulk-cancel`) return this.send(res, 200, { results: [] });
+
+    const m = new RegExp(`^${runs}/([^/]+)(/events/poll|/events|/cancel)?$`).exec(path);
+    const stored = m ? this.runs.get(decodeURIComponent(m[1] as string)) : undefined;
+    if (!m || stored === undefined) return this.send(res, 404, { error: 'not_found', message: 'no such route or run' });
+    const tail = m[2];
+    if (tail === '/cancel') return this.send(res, 200, { status: 'cancelled' });
+    if (tail === '/events') {
+      // Held open until the client aborts: this is what occupies a slot.
+      res.writeHead(200, { 'content-type': 'text/event-stream' });
+      res.write(': held\n\n');
+      return;
+    }
+    if (tail === '/events/poll') {
+      const after = Number(new URL(req.url ?? '/', 'http://x').searchParams.get('afterSequence') ?? '0');
+      const events = stored.run.events
+        .map((e, i) => ({ eventId: `e${i + 1}`, runId: stored.id, type: e.type, payload: e.payload ?? {}, sequence: i + 1, schemaVersion: 2, timestamp: new Date(0).toISOString() }))
+        .filter((e) => e.sequence > after);
+      return this.send(res, 200, { events });
+    }
+    return this.send(res, 200, { runId: stored.id, workflowId: 'scratch', status: stored.run.status, ...(stored.run.error === undefined ? {} : { error: stored.run.error }) });
+  }
+}

package/src/scenarios/runner-ledger.test.ts

@@ -135,12 +135,9 @@ describe('RFC 0148 §A (S6) — the runner derivation', () => {
       expect(p.disposition).toBe('executed-pass');
       expect(p.scenarioId).toBe(`${prefix}*`);
     }
-    // An any-of group belongs to its own profile's floor (RFC 0229 §E). None of
-    // its members is in this synthetic report, so its summary row is honestly
-    // `blocked`, and it is not one of the requirements this floor certifies on.
-    const foreignAnyOf = d.requirements.filter((r) => r.scenarioId.startsWith('anyof:') && !(floor.requiredAnyOf ?? []).some((g) => g.join('|') === r.scenarioId.slice('anyof:'.length)));
-    for (const r of foreignAnyOf) expect(r.disposition, r.requirementId).toBe('blocked');
-    expect(d.totals.executedPass).toBe(d.requirements.length - foreignAnyOf.length);
+    // An any-of group's summary row is written only for a claimed profile's floor
+    // (2.45.4), so this floor's rows are all there is and every one passed.
+    expect(d.totals.executedPass).toBe(d.requirements.length);
   });
 
   it('a floor file that vitest passed but that recorded NOTHING is unclassified when a ledger exists — silence is not a witness', () => {

package/src/scenarios/v2-budget-enforcement.test.ts

@@ -0,0 +1,94 @@
+/**
+ * v2 — a run budget is reserved, crossed, exhausted and enforced
+ * (`spec/v2/core/runs.md` §`budget` section). The v1 twin is
+ * `budget-enforcement`, which drives a host seam; at major 2 the budget rides
+ * on `createRun` (`configurable.budget`), so this witness is unaided. The
+ * logic is `lib/budget-witness.ts`; what differs between majors is the profile
+ * row in `lib/major-profile.ts`.
+ *
+ * The suite creates a run of `conformance-budget-tool-calls` (three scripted
+ * tool calls) with `{ maxToolCalls: 2, thresholdPercent: 50, onExhaustion:
+ * "fail" }` and reads its log through the poll.
+ *
+ *   lifecycle     `budget.reserved`, `budget.threshold-crossed` (numeric
+ *                 `percent`) and `budget.exhausted`, in that order. Both
+ *                 enforce modes owe these.
+ *   enforcement   `enforce: hard`: `cap.breached` with kind
+ *                 `budget-tool-calls`, not before `budget.exhausted`, and the
+ *                 run fails `budget_exhausted`. `enforce: advisory`: the run is
+ *                 not stopped.
+ *   content-free  no `budget.*` or `cap.breached` payload carries a rate card,
+ *                 a unit price or a credential.
+ *
+ * Dispositions: no `budget`, `toolCalls` not in `budget.dimensions`, or the
+ * fixture unadvertised ⇒ `inapplicable`. The fixture is the opt-in: a host
+ * that advertises `budget` and has not seeded it is unwitnessed here, not
+ * blocked. A valid budgeted create that is refused ⇒ `executed-fail`.
+ *
+ * Not ported: v1's model-denied leg (`budget_model_denied`). It needs a
+ * fixture that resolves a model, and none does so without a seam.
+ *
+ * Proven both ways against the scratch host in `lib/budget-witness.test.ts`.
+ *
+ * @see spec/v2/core/runs.md §`budget` section
+ * @see conformance/fixtures.md §conformance-budget-tool-calls
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Discovery } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { majorProfile } from '../lib/major-profile.js';
+import { drive, judge, type BudgetRun, type Finding } from '../lib/budget-witness.js';
+
+const PROFILE = majorProfile(2);
+const DOC = 'spec/v2/core/runs.md §budget section';
+const ID_LIFECYCLE = 'openwop.requirement.runs.budget-lifecycle';
+const ID_ENFORCEMENT = 'openwop.requirement.runs.budget-enforcement';
+const ID_CONTENT_FREE = 'openwop.requirement.runs.budget-content-free';
+
+/** One budgeted run per file: three legs read the same log. */
+let once: Promise<BudgetRun> | undefined;
+function budgetRun(): Promise<BudgetRun> {
+  once ??= (async (): Promise<BudgetRun> => {
+    let doc: Record<string, unknown> | null;
+    try { doc = await v2Discovery(); } catch { doc = null; }
+    if (!doc) return { kind: 'skip', disposition: 'blocked', reason: 'v2 discovery unreachable — /.well-known/openwop did not answer 200 with a JSON body under OpenWOP-Version: 2.0' };
+    return drive(PROFILE, doc);
+  })();
+  return once;
+}
+
+type Leg = { readonly skip: { readonly disposition: 'inapplicable' | 'blocked'; readonly reason: string } } | { readonly findings: Finding[] };
+
+/** The findings for one leg, or why there are none. A refused create fails the leg here. */
+async function leg(id: string, rules: ReadonlyArray<Finding['rule']>): Promise<Leg> {
+  const r = await budgetRun();
+  if (r.kind === 'skip') return { skip: { disposition: r.disposition, reason: r.reason } };
+  if (r.kind === 'refused') {
+    expect(r.status, req(id, DOC, `a host that advertises budget and the fixture MUST accept a valid configurable.budget (got ${r.status} ${r.code ?? ''})`.trim())).toBe(201);
+    return { findings: [] }; // unreachable: a refusal is never 201
+  }
+  return { findings: judge(PROFILE, r.observation).filter((f) => rules.includes(f.rule)) };
+}
+
+describe('v2 budget enforcement (runs.md §budget section)', () => {
+  it('a budgeted run emits budget.reserved, budget.threshold-crossed and budget.exhausted in order', async () => {
+    const l = await leg(ID_LIFECYCLE, ['lifecycle']);
+    if ('skip' in l) return softSkip(l.skip.disposition, l.skip.reason);
+    for (const f of l.findings) expect(f.ok, req(ID_LIFECYCLE, f.doc, f.message)).toBe(true);
+  });
+
+  it('a hard host stops the run budget_exhausted after cap.breached, and an advisory host does not stop it', async () => {
+    const l = await leg(ID_ENFORCEMENT, ['hard-stop', 'advisory']);
+    if ('skip' in l) return softSkip(l.skip.disposition, l.skip.reason);
+    if (l.findings.length === 0) return softSkip('inapplicable', 'budget.enforce is not advertised — neither the hard stop nor the advisory rule binds');
+    for (const f of l.findings) expect(f.ok, req(ID_ENFORCEMENT, f.doc, f.message)).toBe(true);
+  });
+
+  it('no budget.* or cap.breached payload carries pricing or a credential', async () => {
+    const l = await leg(ID_CONTENT_FREE, ['content-free']);
+    if ('skip' in l) return softSkip(l.skip.disposition, l.skip.reason);
+    for (const f of l.findings) expect(f.ok, req(ID_CONTENT_FREE, f.doc, f.message)).toBe(true);
+  });
+});

package/src/scenarios/v2-production-backpressure.test.ts

@@ -0,0 +1,74 @@
+/**
+ * v2 — a host at capacity answers `503 service_unavailable` with `Retry-After`
+ * (`spec/v2/core/conformance.md` §Production profile, `backpressure` facet).
+ * The v1 twin is `production-backpressure`; the logic both share is
+ * `lib/backpressure-witness.ts`, and what differs between majors is the
+ * profile row in `lib/major-profile.ts`.
+ *
+ * Unaided. Gated on `production.backpressure.inflightCap`, the number a host
+ * advertises so the suite can saturate it: `inflightCap` event streams hold
+ * the slots and one more request is sent.
+ *
+ *   refusal        the extra request answers `503`, code `service_unavailable`,
+ *                  with `Retry-After`; where `retryAfterSeconds` is advertised
+ *                  the header equals it.
+ *   retry timing   the refusal carries no `details.retryAfter*`
+ *                  (`errors.md` §Retry timing). This is where v2 differs from
+ *                  v1, which required `details.retryAfter`.
+ *
+ * Dispositions: no `production`, no `backpressure`, no `inflightCap`, an
+ * `inflightCap` above 64 (the most streams the suite holds open), or the hold
+ * or probe fixture unadvertised ⇒ `inapplicable`. A slot that cannot be
+ * filled, or a probe with no response ⇒ `blocked`.
+ *
+ * v1's "discovery is exempt from the cap" leg is not ported: no v2 document
+ * states it.
+ *
+ * Run with `--no-file-parallelism`. Proven both ways against the scratch host
+ * in `lib/backpressure-witness.test.ts`.
+ *
+ * @see spec/v2/core/conformance.md §Production profile
+ * @see spec/v2/core/errors.md §Retry timing
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Discovery } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { majorProfile } from '../lib/major-profile.js';
+import { judge, saturate, type Saturation } from '../lib/backpressure-witness.js';
+
+const PROFILE = majorProfile(2);
+const ID_REFUSAL = 'openwop.requirement.production.backpressure-refusal';
+const ID_TIMING = 'openwop.requirement.0171.error-registry.no-retry-details';
+
+/** One saturation per file: two legs read the same refusal. */
+let once: Promise<Saturation> | undefined;
+function saturation(): Promise<Saturation> {
+  once ??= (async (): Promise<Saturation> => {
+    let doc: Record<string, unknown> | null;
+    try { doc = await v2Discovery(); } catch { doc = null; }
+    if (!doc) return { kind: 'skip', disposition: 'blocked', reason: 'v2 discovery unreachable — /.well-known/openwop did not answer 200 with a JSON body under OpenWOP-Version: 2.0' };
+    return saturate(PROFILE, doc);
+  })();
+  return once;
+}
+
+describe('v2 production backpressure (conformance.md §Production profile)', () => {
+  it('with inflightCap slots held, the next request is refused 503 service_unavailable with Retry-After', async () => {
+    const s = await saturation();
+    if (s.kind === 'skip') return softSkip(s.disposition, s.reason);
+    for (const f of judge(PROFILE, s.refusal).filter((x) => x.rule !== 'retry-timing')) {
+      expect(f.ok, req(ID_REFUSAL, f.doc, f.message)).toBe(true);
+    }
+  });
+
+  it('the refusal carries its retry timing in the Retry-After header only', async () => {
+    const s = await saturation();
+    if (s.kind === 'skip') return softSkip(s.disposition, s.reason);
+    if (s.refusal.status !== 503) return softSkip('blocked', `no 503 was observed at inflightCap + 1 (got ${s.refusal.status}) — there is no refusal whose details could be read`);
+    for (const f of judge(PROFILE, s.refusal).filter((x) => x.rule === 'retry-timing')) {
+      expect(f.ok, req(ID_TIMING, f.doc, f.message)).toBe(true);
+    }
+  });
+});