@openwop/openwop-conformance 2.48.1 → 2.49.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [2.49.0] — 2026-11-14 — Gated legs for eventLog, budget and production
+
+- **`v2-event-log-family`** (gated on `eventLog`). The era is stamped on runs created by createRun and by forkRun. The poll cursor contract holds at every position of a settled log. Event types are codemap names or registered vendor types.
+- **`v2-budget-accounting`** (gated on `budget`).
+  - `consumed` is derived from `agent.tool-called`.
+  - The reserved limit is the one every accounting event names.
+  - `threshold-crossed` is emitted once, at the policy percent.
+
+  The judge is `lib/budget-accounting-witness.ts`, with a sabotage self-test.
+- **`v2-production-profile`** (gated on `production`). Five same-key create retries replay without a second run. An expired run answers `404 not_found` or `410 run_expired`; this leg needs the operator.
+- **`v2-secrets-run-witness`** gates on the `secrets` record before `secrets.runSecrets`. The verdict is unchanged; the change is so RFC 0264's derivation counts a host that passes.
+
 ## [2.48.1] — 2026-11-14 — Fix the telemetry shape leg
 
 - **RFC 0262.** `v2-telemetry-export` (`0262.shape`): the positive records now carry `until`, because the schema requires it while a family is `experimental`. Before this fix the leg failed on every host. Reported by openwop-app-88 and openwop-app-14.

package/README.md

@@ -137,7 +137,7 @@ Each scenario file records its disposition and assertion count in `<report-dir>/
 
 ## What's Covered
 
-The current suite has 671 scenario files under `src/scenarios/`. By target major ([`scenario-majors.json`](./scenario-majors.json)): 231 files run against a v2 host and 455 against a v1 host; 15 of them run at both.
+The current suite has 674 scenario files under `src/scenarios/`. By target major ([`scenario-majors.json`](./scenario-majors.json)): 234 files run against a v2 host and 455 against a v1 host; 15 of them run at both.
 
 The v2 scenarios (`src/scenarios/v2-*.test.ts`) cover, by area:
 
@@ -166,7 +166,7 @@ Three kinds of scenario share the tree:
 - **Host** checks drive a live host over HTTP.
 - **Gated** checks run only when the host advertises the family, profile or fixture they need, and otherwise record `inapplicable` or `blocked` with a reason. `--require-behavior` turns an advertised-but-unwitnessable behaviour into a failure.
 
-Current source tree: 671 scenario files. [`coverage.md`](./coverage.md) maps each spec document and every OpenAPI operation to its scenarios. [`CHANGELOG.md`](./CHANGELOG.md) records when each scenario landed.
+Current source tree: 674 scenario files. [`coverage.md`](./coverage.md) maps each spec document and every OpenAPI operation to its scenarios. [`CHANGELOG.md`](./CHANGELOG.md) records when each scenario landed.
 
 ## How the 2.x suite is built
 

package/dist/spec-artifacts.lock.json

@@ -1,5 +1,5 @@
 {
   "package": "@openwop/spec-artifacts",
-  "version": "2.48.1",
-  "stampSha256": "9eb40a5b061e864a8aa69d673a47d8301458457883ff4f158e70fe8471a80611"
+  "version": "2.49.0",
+  "stampSha256": "06e8e79d64c2baf2421f7081407ec2b8a5663181f206298c3b698c20bc6a9a45"
 }

package/fixtures.md

@@ -405,6 +405,7 @@ The `messages`-mode stream fixture (AI token streaming) is covered by the determ
 - **Expected behavior**:
   - `POST /runs` with the same `Idempotency-Key` and same body twice → second response MUST replay the first (`openwop-Idempotent-Replay: true` header) and MUST NOT create a second run.
   - Same `Idempotency-Key` with a different body → 409.
+- **v2**: `v2-production-profile` replays one key across five retries (conformance.md §Production profile); each retry MUST return the first response's status and runId with `OpenWOP-Idempotent-Replay: true`.
 - **Terminal status**: `completed`.
 
 ### `conformance-cancellable`
@@ -537,7 +538,7 @@ 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`).
+- **Purpose**: spend a run budget unaided, so `budget` can be witnessed without a model or a seam (`v2-budget-enforcement`, `v2-budget-accounting`).
 - **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.
@@ -857,7 +858,7 @@ The scope leg sends a promote with `OPENWOP_TEST_LOW_SCOPE_KEY`, a key with no `
 `conformance-compensate-unwind` is what `v2-compensation-unwind` drives. Its effect node, `core.conformance.compensable-effect`, is conformance-RESERVED. A host that advertises `compensation` and serves the fixture maps it to a node it records on the effect ledger (`GET /runs/{runId}/effects`) as exactly one effect per execution, forward and inverse alike, and runs it as the inverse action when its resolved inputs carry `inverse: true`. What the effect does is irrelevant. A host that does not advertise `compensation` MUST NOT advertise the fixture: it would refuse the workflow's `settings.compensation` with `capability_required`.
 
 - **Shape**: `e1` → `e2` → `e3` (`core.conformance.compensable-effect`, each with node-level `compensation.nodeTypeId` = the same type and `inputMapping: { inverse: true }`) → `fail` (`core.fail`). `settings.compensation`: `orderingModel: "reverse-completion"`, `triggers: ["node-failure"]`.
-- **Inputs**: none.
+- **Inputs**: none. The `inputMapping` value `{ inverse: true }` is a literal constant, not a path into recorded outputs. The inverse is not a graph node and declares no compensation of its own, so naming the forward type as its own inverse is not a compensation cycle.
 - **Expected behavior**:
   1. `e1`, `e2` and `e3` complete in order; `fail` fails; the run ends `failed`.
   2. The log holds `compensation.requested` before the first `compensation.started`, and ends the unwind with `compensation.completed`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openwop/openwop-conformance",
-  "version": "2.48.1",
+  "version": "2.49.0",
   "description": "Black-box conformance suite for OpenWOP hosts (v2 current; v1 scenarios retained for the frozen v1 tree).",
   "repository": {
     "type": "git",
@@ -56,6 +56,6 @@
     "@openwop/spec-artifacts": "file:../spec-artifacts"
   },
   "peerDependencies": {
-    "@openwop/spec-artifacts": "2.48.1"
+    "@openwop/spec-artifacts": "2.49.0"
   }
 }

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": 756,
-    "tests": 2911,
-    "withStableId": 2911,
+    "files": 759,
+    "tests": 2919,
+    "withStableId": 2919,
     "interpolatedTitles": 0,
-    "explicitIds": 2755
+    "explicitIds": 2763
   },
   "records": [
     {
@@ -28932,6 +28932,48 @@
       "explicitId": null,
       "citations": []
     },
+    {
+      "id": "openwop.it.v2-budget-accounting.every-toolcalls-accounting-event-reports-consumed-equal-to-the-agent-tool-called",
+      "file": "v2-budget-accounting.test.ts",
+      "line": 90,
+      "title": "every toolCalls accounting event reports consumed equal to the agent.tool-called events before it",
+      "explicitId": "openwop.requirement.0084.consumption-derived",
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-budget-accounting.budget-reserved-records-an-effective-budget-within-the-run-ceiling-and-every-acc",
+      "file": "v2-budget-accounting.test.ts",
+      "line": 96,
+      "title": "budget.reserved records an effective budget within the run ceiling, and every accounting event names that limit",
+      "explicitId": "openwop.requirement.0084.reserved-limit-enforced",
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-budget-accounting.budget-threshold-crossed-is-emitted-once-at-the-policy-percent-and-not-before-sp",
+      "file": "v2-budget-accounting.test.ts",
+      "line": 102,
+      "title": "budget.threshold-crossed is emitted once, at the policy percent, and not before spend reached it",
+      "explicitId": "openwop.requirement.0084.threshold-once",
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
     {
       "id": "openwop.it.v2-budget-enforcement.a-budgeted-run-emits-budget-reserved-budget-threshold-crossed-and-budget-exhaust",
       "file": "v2-budget-enforcement.test.ts",
@@ -31700,6 +31742,92 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-event-log-family.every-run-the-host-creates-by-createrun-and-by-forkrun-carries-the-advertised-er",
+      "file": "v2-event-log-family.test.ts",
+      "line": 127,
+      "title": "every run the host creates, by createRun and by forkRun, carries the advertised era 3",
+      "explicitId": "openwop.requirement.0036.event-log-stamp-every-path",
+      "citations": [
+        {
+          "section": "spec/v2/core/persistence.md §The era key",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "spec/v2/core/persistence.md §The eventLog family",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "spec/v2/core/persistence.md §The eventLog family",
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-event-log-family.a-cursor-at-every-position-of-a-settled-log-serves-the-poll-contract",
+      "file": "v2-event-log-family.test.ts",
+      "line": 154,
+      "title": "a cursor at every position of a settled log serves the poll contract",
+      "explicitId": "openwop.requirement.0036.event-log-cursor-contract",
+      "citations": [
+        {
+          "section": "spec/v2/core/events.md §Poll",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "spec/v2/core/events.md §Poll",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "spec/v2/core/events.md §Poll",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "spec/v2/core/events.md §Poll",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "spec/v2/core/events.md §Poll",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "spec/v2/core/events.md §Poll",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "spec/v2/core/events.md §Poll",
+          "requirement": "a cursor past the end of the log MUST answer 200"
+        },
+        {
+          "section": "spec/v2/core/events.md §Poll",
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-event-log-family.every-event-type-on-the-lifecycle-fixtures-logs-is-a-codemap-name-or-a-registere",
+      "file": "v2-event-log-family.test.ts",
+      "line": 206,
+      "title": "every event type on the lifecycle fixtures' logs is a codemap name or a registered vendor type",
+      "explicitId": "openwop.requirement.0036.event-log-codemap-types",
+      "citations": [
+        {
+          "section": "spec/v2/core/persistence.md §The codemap is data",
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
     {
       "id": "openwop.it.v2-event-type-closed.every-emitted-type-is-a-registered-protocol-type-or-a-vendor-type-under-an-adver",
       "file": "v2-event-type-closed.test.ts",
@@ -35768,6 +35896,53 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-production-profile.a-host-claiming-production-replays-one-idempotency-key-across-five-retries-witho",
+      "file": "v2-production-profile.test.ts",
+      "line": 67,
+      "title": "a host claiming production replays one Idempotency-Key across five retries without a second run",
+      "explicitId": "openwop.requirement.0009.idempotency-five-retries",
+      "citations": [
+        {
+          "section": "spec/v2/core/conformance.md §Production profile",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "spec/v2/core/idempotency.md §Outcomes",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "spec/v2/core/runs.md §Request headers",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "spec/v2/core/idempotency.md §Outcomes",
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-production-profile.an-expired-run-answers-404-not-found-or-410-run-expired",
+      "file": "v2-production-profile.test.ts",
+      "line": 89,
+      "title": "an expired run answers 404 not_found or 410 run_expired",
+      "explicitId": "openwop.requirement.0009.retention-expired-run",
+      "citations": [
+        {
+          "section": "spec/v2/core/conformance.md §Production profile",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "spec/v2/core/errors.md",
+          "requirement": "the refusal is the canonical envelope: message is a string"
+        }
+      ]
+    },
     {
       "id": "openwop.it.v2-profiles-derived-only.the-v2-document-carries-no-root-profiles",
       "file": "v2-profiles-derived-only.test.ts",
@@ -38009,7 +38184,7 @@
     {
       "id": "openwop.it.v2-secrets-run-witness.a-run-supplied-secret-resolves-intact-matched-true-for-its-digest-false-for-anot",
       "file": "v2-secrets-run-witness.test.ts",
-      "line": 85,
+      "line": 98,
       "title": "a run-supplied secret resolves intact: matched true for its digest, false for another",
       "explicitId": "openwop.requirement.secrets.run-witness-resolves",
       "citations": [
@@ -38039,7 +38214,7 @@
     {
       "id": "openwop.it.v2-secrets-run-witness.a-run-supplied-secret-appears-on-no-readable-surface-in-any-encoding-or-as-its-d",
       "file": "v2-secrets-run-witness.test.ts",
-      "line": 101,
+      "line": 114,
       "title": "a run-supplied secret appears on no readable surface, in any encoding or as its digest",
       "explicitId": "openwop.requirement.secrets.run-witness-redacted",
       "citations": [
@@ -38053,7 +38228,7 @@
     {
       "id": "openwop.it.v2-secrets-run-witness.a-run-ref-resolves-only-within-the-run-that-supplied-it-and-the-witness-refuses",
       "file": "v2-secrets-run-witness.test.ts",
-      "line": 112,
+      "line": 125,
       "title": "a run: ref resolves only within the run that supplied it, and the witness refuses any other ref",
       "explicitId": "openwop.requirement.secrets.run-witness-scope-bound",
       "citations": [
@@ -38071,7 +38246,7 @@
     {
       "id": "openwop.it.v2-secrets-run-witness.the-idempotency-request-digest-excludes-runsecrets-a-retry-differing-only-there",
       "file": "v2-secrets-run-witness.test.ts",
-      "line": 144,
+      "line": 157,
       "title": "the idempotency request digest excludes runSecrets: a retry differing only there replays, and its value is discarded",
       "explicitId": "openwop.requirement.secrets.run-secrets-outside-request-digest",
       "citations": [

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": 671,
+    "files": 674,
     "v1": 455,
-    "v2": 231
+    "v2": 234
   },
   "majors": {
     "a2a-1-0-agent-card.test.ts": [
@@ -1347,6 +1347,9 @@
     "v2-bounded-loopback.test.ts": [
       2
     ],
+    "v2-budget-accounting.test.ts": [
+      2
+    ],
     "v2-budget-enforcement.test.ts": [
       2
     ],
@@ -1494,6 +1497,9 @@
     "v2-eval-trajectory-trials.test.ts": [
       2
     ],
+    "v2-event-log-family.test.ts": [
+      2
+    ],
     "v2-event-type-closed.test.ts": [
       2
     ],
@@ -1674,6 +1680,9 @@
     "v2-production-backpressure.test.ts": [
       2
     ],
+    "v2-production-profile.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.48.1",
-  "corpusTag": "v2.48.1",
+  "version": "2.49.0",
+  "corpusTag": "v2.49.0",
   "files": {
     "api/.redocly.lint-ignore.yaml": "bf5a8350b88a72fa43f59605ed8d903ed24b6cfccda5e45509c9f6ed9ee4e712",
     "api/asyncapi.yaml": "d5ecb9ee6114582be3b1f662c84bfac9ae96dae7bacb853e461168f70a8e1c7d",
     "api/grpc/openwop.proto": "c3e72bb17cba514ee98feb6434e6c9b6ea6795bfd086489ec69fd882dd1ad977",
     "api/openapi.yaml": "ac6de5303872664b78ff419c035915593e01599e02835e777a0123de1baeb398",
     "api/redocly.yaml": "b0604c89b2ca6d5076ec25725c539dad44a741a811fe524439ee6daef8baa09f",
-    "api/seams-v2.yaml": "eb3f46e3dfa2474e14c5a095a35102f3347539144a6ef984e9ff8ea283a4578b",
-    "api/v2/asyncapi.yaml": "5bd64a201eca0b32389f1dc92c8c67e24405062dc36790488a7526453e320120",
-    "api/v2/openapi.yaml": "3c8c2e0f993fd52f57112a4b0715c70ae03dc333c0aa450ef0a707667b50fed6",
+    "api/seams-v2.yaml": "a4fd4fe1ea1bcefe5f015b9cb6af5bd89ec9d225eeffc39ca6ec1473c0964203",
+    "api/v2/asyncapi.yaml": "9ec0cac22964427c635e2fd836ca6d94397ccf14245b7c30f96b69d77033330a",
+    "api/v2/openapi.yaml": "d9c5921a1800d2ffde4807e4652d97616aec5dd75c22ba70860c111e4e660e15",
     "api/v2/redocly.yaml": "1e66b60e6118ad11a823bb620678be464d99dfe50a40e3e6f93ec9429b88b34c",
     "schemas/README.md": "276fc1d51eb08e14e9127b9fd27761d7046ee33c12000f3a64a801322db8bf58",
     "schemas/a2a-task-state.schema.json": "75d5049dea8bd873ff0e7546f1c60c8d36c219bec7084264360be54a8be30ae1",
@@ -115,7 +115,7 @@
     "schemas/v2/artifact.schema.json": "85b9dc284d39b99d2a66fa8cbf47f2dd3d8526d3bd6cc411ad315b372de38975",
     "schemas/v2/audit-verify-result.schema.json": "14af8e9283510f0a40e48a2059c929ee44e0fc9fa3cc66a95bfbe90b17c48297",
     "schemas/v2/budget-policy.schema.json": "1de68095db0beb5c7a4be629de26e79f62ebbe748a88d46f36e768edfd1f0d68",
-    "schemas/v2/capabilities.schema.json": "afae0c548cf91a915c2badca77b7c89cd0c657f100c2cd1db64de896c8da2bf0",
+    "schemas/v2/capabilities.schema.json": "f4b4fb4c32144026e97a1be4266cc7a87d349ac714dcac156e9d8512740d06a1",
     "schemas/v2/certification-bundle.schema.json": "f9e233dc3584c3cef78809d518749ce37cd1ee79ebbfe58163dc67eeac7802b1",
     "schemas/v2/channel-presence-payload.schema.json": "fc03df0c20cc12a25f7ee6a47503a4c5931d79fe3d5ff24815e8fd7c1bcb9a87",
     "schemas/v2/channel-written-payload.schema.json": "ccecff3c71a3275ad8db035ac0e04db25e6f8d23cf091ddbcd5a60d1be1cbb6b",
@@ -203,7 +203,7 @@
     "schemas/workspace-file.schema.json": "464de85c2a068243084ee9c1d969bc7cd5d8f7948574e58450d6493c38a0e1e4",
     "spec/v1/alias-detectors.json": "202a443678e592a515e33aad7f6ab679a07d8408809f2d4b0f59d156c84ffc65",
     "spec/v1/capability-declaration-classes.json": "e7729aed5c4b4e1dd02abab0530f14cc95f5d4070fe51fb139e7f5cccefa00c6",
-    "spec/v1/core-standard-manifest.json": "66d5e491537cfa04ebbe57bd26ad53c027c24e105e8b19e2426b1ed17aaa3b24",
+    "spec/v1/core-standard-manifest.json": "e6bbda0be8241175de9d93dc531c727184a02f5043b0a61a12bdfc6de4305451",
     "spec/v1/deprecations.json": "901fdab0a7212627f1838cbb06ae7b7204f0dff528299e56d3d938deecea27c1",
     "spec/v1/deprecations.schema.json": "3e393c405d2a41b467d8c5e3c468549078df1ce6a6d2588fc488097b95d9b55b",
     "spec/v1/end-of-support.json": "35f0bf3b70fe78b16e2a2fd81a153fc27e703f6c16376c6fe7cdf1f4f2c4e6d4",
@@ -250,7 +250,7 @@
     "spec/v2/core/workflow-chain-packs.md": "fdce7a8477e269950a2bac05ee6eddbd66eb0b670b464d00054f7196ec05d29c",
     "spec/v2/corrections.json": "5ee76d1ee87677a86d5d9ee2f477b88fc29f9f9d37611040b9ccb08f8f30fb2d",
     "spec/v2/corrections.schema.json": "02f6a0a9531e657693be311af0f59d6432f3efcf645f56ccbf39e5b141e6b641",
-    "spec/v2/declaration.json": "2d6415ee3b9a801d6a7c4de5ec1ab4d62441dded7b5a44ceb42be80f0a258ce9",
+    "spec/v2/declaration.json": "d8971c070358eb9ff6a94fdfb0ebc5638fd8f61b7d1d9cb816424bf1e70b8079",
     "spec/v2/declaration.schema.json": "ef951633e4070899f64828f5cf1b5f4870270a0360f81dbb49b5b4d6cd407550",
     "spec/v2/eos-override.json": "4c72d2f6a658943b01c1de1643cf294642091933af7832f38ee5495df684cb2d",
     "spec/v2/errors.json": "8b4d2ebab569b26f608323ca4c9adaf805ab515286d26532db23fcb97541787f",
@@ -309,9 +309,9 @@
     "spec/v2/path-manifest.json": "3720e502614f301efc7556e0bfcbfa7b7ad8a37c579256ba6bca82417a2728f1",
     "spec/v2/peer-dependency-aliases.json": "cbf62f551f9295b0ac7ba6cc0466abb153563354a57b0622f3ec6e6689cba47e",
     "spec/v2/profiles.json": "b382b261c7844798575f7c1b37c934f0da19846016a2337d883d4f5ef6e05479",
-    "spec/v2/release.json": "ca7dd7966a78c3feaff0becfe722bc64bf328d4ca18bcd2dd23edf69ed634358",
+    "spec/v2/release.json": "2d7d294978a1a23726e9608da583d81645e447a4315fcad45c990caed1a058a1",
     "spec/v2/retention-floors.json": "eaf3722d95c79947af1d4269ef85117e126518c588cfcf1a2b21b97269f51624",
-    "spec/v2/surface-baseline.json": "6dbb04ff500ca21eb6fa8e430851ddd8f0365d03feb8275ff27d46f6e3dbf879"
+    "spec/v2/surface-baseline.json": "735c19442cecd130148546a302c6eb8f838f83936b7e329e1988f2b12a547a9d"
   },
-  "corpusCommit": "d72335c7cb5656085cce8b879d196689c15809ba"
+  "corpusCommit": "cc71a07af3655fd18a498211819a96c4e3b1130d"
 }

package/src/lib/budget-accounting-witness.ts

@@ -0,0 +1,129 @@
+/**
+ * The budget ACCOUNTING witness: what the numbers on a budgeted run's log must
+ * say, beyond the events existing (`budget-witness.ts` owns that).
+ *
+ * It reads the same observation `budget-witness.ts` `drive` returns — a run of
+ * `conformance-budget-tool-calls` under `{ maxToolCalls: 2, thresholdPercent:
+ * 50, onExhaustion: "fail" }` — and judges three rules of `runs.md` §`budget`
+ * section and `schemas/v2/budget-policy.schema.json`. Pure: no I/O.
+ *
+ *   derived      consumption is derived from `agent.tool-called`, "never
+ *                measured twice": every `toolCalls` `budget.consumed`,
+ *                `budget.threshold-crossed` and `budget.exhausted` carries a
+ *                `consumed` equal to the number of `agent.tool-called` events
+ *                before it in the log. A host that counts a call twice, or
+ *                counts `agent.tool-returned` as well, reports twice the calls.
+ *   limit        `budget.reserved` records the effective budget: its
+ *                `effectiveBudget.maxToolCalls` is at most the run's own
+ *                ceiling (the effective budget is the minimum across scopes),
+ *                and every `toolCalls` accounting event's `limit` equals it. A
+ *                host that enforces a number it did not record breaks replay,
+ *                which re-reads `budget.reserved` and never re-resolves.
+ *   threshold    `budget.threshold-crossed` is emitted once for the dimension,
+ *                at the policy's percent (`percent` equals `thresholdPercent`)
+ *                and not before consumption reached it.
+ *
+ * An empty finding list means the log offers nothing to judge for that rule;
+ * the scenario records that as `blocked`, never as a pass.
+ */
+
+import type { BudgetObservation, RunEvent } from './budget-witness.js';
+
+export const ACCOUNTING_DIMENSION = 'toolCalls';
+
+export interface AccountingNames {
+  readonly toolCalled: string;
+  readonly consumed: string;
+}
+
+export interface AccountingPolicy {
+  readonly maxToolCalls: number;
+  readonly thresholdPercent: number;
+}
+
+export interface AccountingFinding {
+  readonly rule: 'derived' | 'limit' | 'threshold';
+  readonly ok: boolean;
+  readonly doc: string;
+  readonly message: string;
+}
+
+const num = (v: unknown): number | undefined => (typeof v === 'number' && Number.isFinite(v) ? v : undefined);
+
+/** The `toolCalls` accounting events: consumed, threshold-crossed, exhausted. */
+function accountingEvents(o: BudgetObservation, names: AccountingNames): RunEvent[] {
+  const types = new Set([names.consumed, o.names.threshold, o.names.exhausted]);
+  return o.events.filter((e) => types.has(e.type) && e.payload['dimension'] === ACCOUNTING_DIMENSION);
+}
+
+/** Judge the accounting rules on one observed budgeted run. Pure. */
+export function judgeAccounting(o: BudgetObservation, names: AccountingNames, policy: AccountingPolicy, home: string): AccountingFinding[] {
+  const out: AccountingFinding[] = [];
+  const calls = o.events.filter((e) => e.type === names.toolCalled).map((e) => e.sequence);
+  const accounting = accountingEvents(o, names);
+
+  // derived — judged only when the log carries calls and accounting to compare.
+  if (calls.length > 0) {
+    for (const e of accounting) {
+      const consumed = num(e.payload['consumed']);
+      const before = calls.filter((s) => s < e.sequence).length;
+      out.push({
+        rule: 'derived',
+        ok: consumed === before,
+        doc: home,
+        message: `consumption is derived from ${names.toolCalled} and never measured twice: ${e.type} at sequence ${e.sequence} MUST report consumed ${before} (the ${names.toolCalled} events before it), got ${String(e.payload['consumed'])}`,
+      });
+    }
+  }
+
+  // limit — the recorded effective budget is the one every accounting event names.
+  const reserved = o.events.find((e) => e.type === o.names.reserved);
+  if (reserved !== undefined) {
+    const eff = reserved.payload['effectiveBudget'];
+    const recorded = eff !== null && typeof eff === 'object' && !Array.isArray(eff) ? num((eff as Record<string, unknown>)['maxToolCalls']) : undefined;
+    out.push({
+      rule: 'limit',
+      ok: recorded !== undefined && Number.isInteger(recorded) && recorded <= policy.maxToolCalls,
+      doc: home,
+      message: `${o.names.reserved} MUST record the effective budget: effectiveBudget.maxToolCalls is the minimum across scopes, so at most the run's own ${policy.maxToolCalls} (got ${String(recorded)})`,
+    });
+    if (recorded !== undefined) {
+      for (const e of accounting) {
+        out.push({
+          rule: 'limit',
+          ok: num(e.payload['limit']) === recorded,
+          doc: home,
+          message: `${e.type} at sequence ${e.sequence} MUST name the limit ${o.names.reserved} recorded (${recorded}), got ${String(e.payload['limit'])} — a replay re-reads the reserved budget and never re-resolves it`,
+        });
+      }
+    }
+  }
+
+  // threshold — once, at the policy's percent, not early.
+  const crossings = o.events.filter((e) => e.type === o.names.threshold && e.payload['dimension'] === ACCOUNTING_DIMENSION);
+  if (crossings.length > 0) {
+    out.push({
+      rule: 'threshold',
+      ok: crossings.length === 1,
+      doc: 'schemas/v2/budget-policy.schema.json thresholdPercent',
+      message: `${o.names.threshold} MUST be emitted once per dimension (got ${crossings.length} for ${ACCOUNTING_DIMENSION} at sequences ${crossings.map((e) => e.sequence).join(', ')})`,
+    });
+    const first = crossings[0] as RunEvent;
+    const percent = num(first.payload['percent']);
+    const consumed = num(first.payload['consumed']);
+    const limit = num(first.payload['limit']);
+    out.push({
+      rule: 'threshold',
+      ok: percent === policy.thresholdPercent,
+      doc: home,
+      message: `${o.names.threshold}.percent MUST be the percent-of-limit threshold the policy set (${policy.thresholdPercent}), got ${String(first.payload['percent'])}`,
+    });
+    out.push({
+      rule: 'threshold',
+      ok: consumed !== undefined && limit !== undefined && limit > 0 && (consumed / limit) * 100 >= policy.thresholdPercent,
+      doc: 'schemas/v2/budget-policy.schema.json thresholdPercent',
+      message: `${o.names.threshold} MUST NOT precede the threshold: emitted at consumed ${String(first.payload['consumed'])} of limit ${String(first.payload['limit'])}, below ${policy.thresholdPercent}%`,
+    });
+  }
+  return out;
+}

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

@@ -0,0 +1,107 @@
+/**
+ * v2 — a run budget's numbers are derived, recorded and crossed once
+ * (`spec/v2/core/runs.md` §`budget` section;
+ * `schemas/v2/budget-policy.schema.json` `thresholdPercent`). Gated on
+ * `budget`. Unaided.
+ *
+ * `v2-budget-enforcement` witnesses that the budget events exist, in order,
+ * and that a hard budget stops the run. This file reads the same kind of run
+ * for what those events SAY — the accounting a replay depends on:
+ *
+ *   derived     every `toolCalls` `budget.consumed`, `budget.threshold-crossed`
+ *               and `budget.exhausted` reports `consumed` equal to the
+ *               `agent.tool-called` events before it ("derived from …
+ *               `agent.toolCalled` …, never measured twice").
+ *   limit       `budget.reserved` records the effective budget, at most the
+ *               run's own ceiling, and every accounting event names that limit.
+ *   threshold   `budget.threshold-crossed` is emitted once for the dimension, at
+ *               the policy's `thresholdPercent`, and not before spend reached it.
+ *
+ * The run is `conformance-budget-tool-calls` (three scripted tool calls, no
+ * model) under `{ maxToolCalls: 2, thresholdPercent: 50, onExhaustion: "fail" }`
+ * on `configurable.budget`, driven by `lib/budget-witness.ts` `drive`. The
+ * judge is `lib/budget-accounting-witness.ts`, proven both ways in its
+ * self-test.
+ *
+ * Dispositions: no `budget` ⇒ `inapplicable` (gate `openwop.family.budget`);
+ * `toolCalls` not in `budget.dimensions`, or the fixture unadvertised ⇒
+ * `inapplicable` (the fixture is the opt-in, as in `v2-budget-enforcement`); a
+ * log with nothing to judge for a rule ⇒ `blocked`. A valid budgeted create
+ * that is refused fails here, as it does there.
+ *
+ * @see spec/v2/core/runs.md §budget section
+ * @see schemas/v2/budget-policy.schema.json
+ * @see conformance/fixtures.md §conformance-budget-tool-calls
+ */
+
+import { describe, it, expect } from 'vitest';
+import { gateFamily, 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 { BUDGET_POLICY, drive, type BudgetRun } from '../lib/budget-witness.js';
+import { judgeAccounting, type AccountingFinding } from '../lib/budget-accounting-witness.js';
+
+const PROFILE = majorProfile(2);
+const DOC = 'spec/v2/core/runs.md §budget section';
+const ID_DERIVED = 'openwop.requirement.0084.consumption-derived';
+const ID_LIMIT = 'openwop.requirement.0084.reserved-limit-enforced';
+const ID_THRESHOLD = 'openwop.requirement.0084.threshold-once';
+
+/** 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 ['inapplicable' | 'blocked', string] } | { readonly findings: AccountingFinding[] };
+
+/** The findings for one rule, or why there are none. A refused create fails the leg here. */
+async function leg(id: string, rule: AccountingFinding['rule']): Promise<Leg> {
+  if ((await gateFamily('budget')) === null) return { skip: ['inapplicable', 'the host does not advertise budget (gate recorded under openwop.family.budget)'] };
+  const r = await budgetRun();
+  if (r.kind === 'skip') return { skip: [r.disposition, 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: [] };
+  }
+  const toolCalled = PROFILE.eventType('agent.toolCalled');
+  const consumed = PROFILE.eventType('budget.consumed');
+  if (toolCalled === undefined || consumed === undefined) return { skip: ['blocked', 'the v2 event names for agent.toolCalled / budget.consumed are not in the codemap on disk — the witness will not guess them'] };
+  const findings = judgeAccounting(r.observation, { toolCalled, consumed }, BUDGET_POLICY, DOC).filter((f) => f.rule === rule);
+  if (findings.length === 0) {
+    const what: Record<AccountingFinding['rule'], string> = {
+      derived: `the log carries no ${toolCalled} event or no toolCalls accounting event — there is no consumed figure to compare with the calls made`,
+      limit: 'the log carries no budget.reserved — there is no recorded effective budget to compare with',
+      threshold: 'the log carries no toolCalls budget.threshold-crossed — there is no crossing to judge (v2-budget-enforcement fails its absence)',
+    };
+    return { skip: ['blocked', what[rule]] };
+  }
+  return { findings };
+}
+
+describe('v2 budget accounting (runs.md §budget section)', () => {
+  it('every toolCalls accounting event reports consumed equal to the agent.tool-called events before it', async () => {
+    const l = await leg(ID_DERIVED, 'derived');
+    if ('skip' in l) return softSkip(...l.skip);
+    for (const f of l.findings) expect(f.ok, req(ID_DERIVED, f.doc, f.message)).toBe(true);
+  });
+
+  it('budget.reserved records an effective budget within the run ceiling, and every accounting event names that limit', async () => {
+    const l = await leg(ID_LIMIT, 'limit');
+    if ('skip' in l) return softSkip(...l.skip);
+    for (const f of l.findings) expect(f.ok, req(ID_LIMIT, f.doc, f.message)).toBe(true);
+  });
+
+  it('budget.threshold-crossed is emitted once, at the policy percent, and not before spend reached it', async () => {
+    const l = await leg(ID_THRESHOLD, 'threshold');
+    if ('skip' in l) return softSkip(...l.skip);
+    for (const f of l.findings) expect(f.ok, req(ID_THRESHOLD, f.doc, f.message)).toBe(true);
+  });
+});

package/src/scenarios/v2-event-log-family.test.ts

@@ -0,0 +1,237 @@
+/**
+ * v2 — what a host advertising `eventLog` owes on its log
+ * (`spec/v2/core/persistence.md` §The `eventLog` family). Gated on `eventLog`.
+ * Unaided.
+ *
+ * The family's three MUSTs, one leg each:
+ *
+ *   stamp        "MUST stamp `eventLogSchemaVersion` on every run it creates".
+ *                Every creation path the suite can drive from outside: a run
+ *                made by `createRun`, and, where `replay` is advertised, a run
+ *                made by `forkRun`. Each snapshot carries the era discovery
+ *                advertises, and that era is `3` (§The era key). The ungated
+ *                `v2-era-stamp-universal` checks `createRun` only; a host whose
+ *                fork path writes no era fails here.
+ *   cursor       "MUST serve the cursor contract of events.md §Poll over that
+ *                log". A cursor at EVERY position of a settled log returns
+ *                exactly the tail after it (a page-limited host may return a
+ *                non-empty prefix of it); chaining `afterSequence` through the
+ *                pages rebuilds the log with no gap and no duplicate and ends
+ *                on an empty page; each event keeps its `eventId` across reads;
+ *                and every response's `lastSequence` is the highest sequence in
+ *                the log, a cursor past the end included. `v2-poll-cursor-v2`
+ *                checks one position.
+ *   codemap      "MUST NOT emit an event `type` the codemap does not name".
+ *                Every type on the logs of the advertised lifecycle fixtures
+ *                (`conformance-noop`, and `conformance-multi-node` and
+ *                `conformance-failure` where seeded) is a v2 name in
+ *                `spec/v2/event-codemap.json`, or a vendor type whose org is
+ *                registered in `spec/v2/declaration.json` `extensions`
+ *                (§The codemap is data). The failure fixture reaches
+ *                `run.failed` / `node.failed`, which `v2-event-type-closed`'s
+ *                noop log never does.
+ *
+ * Dispositions: no `eventLog` ⇒ `inapplicable` (gate `openwop.family.eventLog`).
+ * A create refused, a run that does not settle, or a log that grows between
+ * reads ⇒ `blocked`. A fork that is declined is noted after the `createRun`
+ * path is judged, so that row is a partial-witness pass.
+ *
+ * @see spec/v2/core/persistence.md §The eventLog family
+ * @see spec/v2/core/persistence.md §The era key
+ * @see spec/v2/core/events.md §Poll
+ */
+
+import { describe, it, expect } from 'vitest';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { familyAdvertised, gateFamily, v2Discovery } from '../lib/v2.js';
+import { readErrorCode } from '../lib/error-envelope.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { registeredOrgs } from '../lib/era2-seed.js';
+import { SPEC_V2_DIR } from '../lib/paths.js';
+import { blockedDespiteAssertions, softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+const ID_STAMP = 'openwop.requirement.0036.event-log-stamp-every-path';
+const ID_CURSOR = 'openwop.requirement.0036.event-log-cursor-contract';
+const ID_CODEMAP = 'openwop.requirement.0036.event-log-codemap-types';
+const DOC_FAMILY = 'spec/v2/core/persistence.md §The eventLog family';
+const DOC_ERA = 'spec/v2/core/persistence.md §The era key';
+const DOC_POLL = 'spec/v2/core/events.md §Poll';
+const DOC_CODEMAP = 'spec/v2/core/persistence.md §The codemap is data';
+const NOOP = 'conformance-noop';
+const MULTI = 'conformance-multi-node';
+const FAILURE = 'conformance-failure';
+const V2_ERA = 3;
+const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
+const SETTLE_MS = Number(process.env['OPENWOP_LIFECYCLE_TIMEOUT_MS'] ?? 15_000);
+const MAX_PAGES = 200;
+
+interface Read { readonly sequence: number; readonly eventId: string; readonly type: string }
+interface Page { readonly status: number; readonly events: readonly Read[]; readonly lastSequence: unknown }
+
+const enc = encodeURIComponent;
+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 discovery(): Promise<Record<string, unknown> | null> {
+  try { return await v2Discovery(); } catch { return null; }
+}
+
+/** Create a run of `workflowId` and wait for it to settle. */
+async function settledRun(workflowId: string): Promise<{ runId: string; snapshot: Record<string, unknown> } | { reason: string }> {
+  const created = await http(() => driver.post('/runs', { workflowId }));
+  if (created === null) return { reason: 'POST /runs unreachable (fetch failed)' };
+  const runId = isRecord(created.json) ? created.json['runId'] : undefined;
+  if (created.status !== 201 || typeof runId !== 'string') return { reason: `POST /runs {workflowId: ${workflowId}} answered ${created.status} ${readErrorCode(created.json) ?? ''} — the create was refused (fixture not seeded?)`.trim() };
+  return settle(runId);
+}
+async function settle(runId: string): Promise<{ runId: string; snapshot: Record<string, unknown> } | { reason: string }> {
+  const deadline = Date.now() + SETTLE_MS;
+  let last: Record<string, unknown> | null = null;
+  while (Date.now() < deadline) {
+    const res = await http(() => driver.get(`/runs/${enc(runId)}`));
+    last = res !== null && res.status === 200 && isRecord(res.json) ? res.json : null;
+    if (last !== null && TERMINAL.has(String(last['status']))) return { runId, snapshot: last };
+    await new Promise((r) => setTimeout(r, 250));
+  }
+  return { reason: `run ${runId} did not reach a terminal status within ${SETTLE_MS} ms (last: ${last === null ? 'unreadable' : String(last['status'])})` };
+}
+
+async function poll(runId: string, after: number | null): Promise<Page | null> {
+  const res = await http(() => driver.get(`/runs/${enc(runId)}/events/poll?timeout=1${after === null ? '' : `&afterSequence=${after}`}`));
+  if (res === null) return null;
+  const body = isRecord(res.json) ? res.json : {};
+  const raw = Array.isArray(body['events']) ? body['events'] : [];
+  const events = raw.filter(isRecord).map((e): Read => ({ sequence: typeof e['sequence'] === 'number' ? e['sequence'] : Number.NaN, eventId: String(e['eventId']), type: String(e['type']) }));
+  return { status: res.status, events, lastSequence: body['lastSequence'] };
+}
+const seqs = (p: Page): number[] => p.events.map((e) => e.sequence);
+
+/** The v2 names of `spec/v2/event-codemap.json`, or null when the file is not on disk in this layout. */
+function codemapV2Names(): Set<string> | null {
+  const file = SPEC_V2_DIR ? join(SPEC_V2_DIR, 'event-codemap.json') : null;
+  if (file === null || !existsSync(file)) return null;
+  try {
+    const doc = JSON.parse(readFileSync(file, 'utf8')) as { rows?: Array<{ v2?: unknown }> };
+    const names = new Set((doc.rows ?? []).map((r) => r.v2).filter((v): v is string => typeof v === 'string'));
+    return names.size > 0 ? names : null;
+  } catch {
+    return null;
+  }
+}
+
+describe('v2 eventLog family (persistence.md §The eventLog family)', () => {
+  it('every run the host creates, by createRun and by forkRun, carries the advertised era 3', async () => {
+    if ((await gateFamily('eventLog')) === null) return softSkip('inapplicable', 'the host does not advertise eventLog (gate recorded under openwop.family.eventLog)');
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', 'v2 discovery unreachable');
+    const advertised = doc['eventLogSchemaVersion'];
+    expect(advertised, req(ID_STAMP, DOC_ERA, `a host advertising eventLog MUST advertise the era it writes for new runs, and a v2 host writes ${V2_ERA} (discovery eventLogSchemaVersion: ${JSON.stringify(advertised)})`)).toBe(V2_ERA);
+
+    const source = await settledRun(NOOP);
+    if ('reason' in source) return softSkip('blocked', source.reason);
+    expect(source.snapshot['eventLogSchemaVersion'], req(ID_STAMP, DOC_FAMILY, `a run made by createRun MUST carry eventLogSchemaVersion ${V2_ERA} on its snapshot (got ${JSON.stringify(source.snapshot['eventLogSchemaVersion'])})`)).toBe(V2_ERA);
+
+    // The second creation path. forkRun is gated on `replay` (runs.md §Surface).
+    const replay = await familyAdvertised('replay');
+    const modes = Array.isArray(replay?.['modes']) ? (replay?.['modes'] as unknown[]).filter((m): m is string => typeof m === 'string') : [];
+    // partial-witness-ok: forkRun is a creation path only where replay advertises a fork mode; createRun, the only other, was judged above.
+    if (replay === null || modes.length === 0) return softSkip('inapplicable', 'replay is not advertised with a fork mode — createRun is the only creation path the suite can drive, and it was judged above');
+    const mode = modes.includes('branch') ? 'branch' : (modes[0] as string);
+    const fork = await http(() => driver.post(`/runs/${enc(source.runId)}:fork`, { mode, fromSeq: 0 }));
+    const forkId = fork !== null && isRecord(fork.json) ? fork.json['runId'] : undefined;
+    if (fork === null || fork.status !== 201 || typeof forkId !== 'string') {
+      return softSkip('blocked', `a ${mode} fork at fromSeq 0 answered ${fork?.status ?? 'no response'} ${fork === null ? '' : readErrorCode(fork.json) ?? ''} — the forkRun creation path was not reached (its refusals are v2-run-fork-refusals' to judge)`.trim());
+    }
+    const forked = await http(() => driver.get(`/runs/${enc(forkId)}`));
+    if (forked === null || forked.status !== 200 || !isRecord(forked.json)) return softSkip('blocked', `GET /runs/{fork} answered ${forked?.status ?? 'no response'} — the fork's snapshot is where its era is reported`);
+    expect(forked.json['eventLogSchemaVersion'], req(ID_STAMP, DOC_FAMILY, `a run made by forkRun (${mode}) MUST carry eventLogSchemaVersion ${V2_ERA} too: a creation path that writes no era makes runs every reader translates as the v1 era (got ${JSON.stringify(forked.json['eventLogSchemaVersion'])})`)).toBe(V2_ERA);
+  });
+
+  it('a cursor at every position of a settled log serves the poll contract', async () => {
+    if ((await gateFamily('eventLog')) === null) return softSkip('inapplicable', 'the host does not advertise eventLog (gate recorded under openwop.family.eventLog)');
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    const fixture = isFixtureAdvertised(MULTI) ? MULTI : NOOP;
+    const run = await settledRun(fixture);
+    if ('reason' in run) return softSkip('blocked', run.reason);
+
+    // Observe everything first; judge only a log that stayed put while it was read.
+    const whole = await poll(run.runId, null);
+    if (whole === null || whole.status !== 200) return softSkip('blocked', `GET /runs/{runId}/events/poll answered ${whole?.status ?? 'no response'}`);
+    const all = seqs(whole);
+    if (all.length < 2) return softSkip('blocked', `the ${fixture} log holds ${all.length} event(s) — a cursor walk needs an interior position`);
+    const atCursor = new Map<number, Page | null>();
+    for (const k of all) atCursor.set(k, await poll(run.runId, k));
+    const walk: Page[] = [];
+    let cursor: number | null = null;
+    for (let i = 0; i < MAX_PAGES; i++) {
+      const p = await poll(run.runId, cursor);
+      if (p === null) break;
+      walk.push(p);
+      const s = seqs(p);
+      if (p.status !== 200 || s.length === 0 || !Number.isFinite(s[s.length - 1] as number)) break;
+      cursor = s[s.length - 1] as number;
+    }
+    const pastEnd = await poll(run.runId, Math.max(...all) + 1000);
+    const again = await poll(run.runId, null);
+    if (again === null || again.status !== 200 || seqs(again).join(',') !== all.join(',')) {
+      return softSkip('blocked', `the log changed between reads (before [${all.join(',')}], after [${again === null ? 'unreadable' : seqs(again).join(',')}]) — a settled run is still appending, so reads of it are not comparable`);
+    }
+
+    const max = Math.max(...all);
+    const idAt = new Map<number, string>(whole.events.map((e): [number, string] => [e.sequence, e.eventId]));
+    const tail = (k: number): number[] => all.filter((s) => s > k);
+    for (const [k, p] of atCursor) {
+      expect(p?.status, req(ID_CURSOR, DOC_POLL, `afterSequence=${k} MUST answer 200`)).toBe(200);
+      const got = p === null ? [] : seqs(p);
+      const want = tail(k);
+      const prefix = got.length <= want.length && got.every((s, i) => s === want[i]);
+      expect(prefix && (want.length === 0 ? got.length === 0 : got.length > 0), req(ID_CURSOR, DOC_POLL, `afterSequence=${k} MUST return the events with sequence > ${k} in order — [${want.join(', ')}], or a non-empty prefix of it; got [${got.join(', ')}]`)).toBe(true);
+      expect(p?.lastSequence, req(ID_CURSOR, DOC_POLL, `lastSequence is the highest sequence in the log (${max}) whatever the cursor; afterSequence=${k} answered ${JSON.stringify(p?.lastSequence)}`)).toBe(max);
+      for (const e of p?.events ?? []) {
+        expect(e.eventId, req(ID_CURSOR, DOC_POLL, `the event at sequence ${e.sequence} MUST keep its eventId across reads — the log is not renumbered (whole read: ${idAt.get(e.sequence) ?? 'absent'}, cursor read: ${e.eventId})`)).toBe(idAt.get(e.sequence));
+      }
+    }
+    const walked = walk.flatMap(seqs);
+    expect(walked, req(ID_CURSOR, DOC_POLL, `chaining afterSequence through the pages MUST rebuild the log with no gap and no duplicate: log [${all.join(', ')}], walk [${walked.join(', ')}] over ${walk.length} page(s)`)).toEqual(all);
+    const lastPage = walk[walk.length - 1];
+    expect(lastPage !== undefined && lastPage.status === 200 && lastPage.events.length === 0, req(ID_CURSOR, DOC_POLL, `the walk MUST end on a 200 with an empty events array once the cursor reaches the end (last page: ${lastPage === undefined ? 'none' : `${lastPage.status}, ${lastPage.events.length} event(s)`}; ${walk.length} page(s), cap ${MAX_PAGES})`)).toBe(true);
+    expect(pastEnd?.status, req(ID_CURSOR, DOC_POLL, 'a cursor past the end of the log MUST answer 200')).toBe(200);
+    expect(pastEnd?.lastSequence, req(ID_CURSOR, DOC_POLL, `a cursor past the end returns no events, yet lastSequence is still the highest sequence in the log (${max}), not a figure computed from the empty page (got ${JSON.stringify(pastEnd?.lastSequence)})`)).toBe(max);
+  });
+
+  it('every event type on the lifecycle fixtures\' logs is a codemap name or a registered vendor type', async () => {
+    if ((await gateFamily('eventLog')) === null) return softSkip('inapplicable', 'the host does not advertise eventLog (gate recorded under openwop.family.eventLog)');
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    const names = codemapV2Names();
+    if (names === null) return softSkip('blocked', 'spec/v2/event-codemap.json is not on disk in this layout — the codemap is the authority this rule names, and the suite will not substitute a list of its own');
+    const orgs = registeredOrgs();
+
+    const fixtures = [NOOP, ...[MULTI, FAILURE].filter((f) => isFixtureAdvertised(f))];
+    const logs: Array<{ fixture: string; types: string[] }> = [];
+    for (const fixture of fixtures) {
+      const run = await settledRun(fixture);
+      if ('reason' in run) {
+        if (logs.length === 0) return softSkip('blocked', run.reason);
+        continue;
+      }
+      const page = await poll(run.runId, null);
+      if (page === null || page.status !== 200 || page.events.length === 0) continue;
+      logs.push({ fixture, types: page.events.map((e) => e.type) });
+    }
+    if (logs.length === 0) return softSkip('blocked', `no log of ${fixtures.join(', ')} could be read through the poll`);
+
+    for (const { fixture, types } of logs) {
+      for (const type of new Set(types)) {
+        const named = names.has(type);
+        if (!named && orgs === undefined) return blockedDespiteAssertions(`${fixture} emitted ${type}, which the codemap does not name, and spec/v2/declaration.json is not on disk to say whether its org is registered`);
+        const org = type.split('.')[0] ?? '';
+        const vendor = !named && org !== 'openwop' && orgs !== undefined && orgs.has(org);
+        expect(named || vendor, req(ID_CODEMAP, DOC_CODEMAP, `a host advertising eventLog MUST NOT emit a type the codemap does not name: ${fixture} emitted ${type}, which is not a v2 name in spec/v2/event-codemap.json, and its org "${org}" is not registered in spec/v2/declaration.json extensions`)).toBe(true);
+      }
+    }
+  });
+});

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

@@ -0,0 +1,118 @@
+/**
+ * v2 — the `production` bar beyond backpressure
+ * (`spec/v2/core/conformance.md` §Production profile). Gated on `production`.
+ *
+ * `v2-production-backpressure` witnesses the `backpressure` facet. This file
+ * takes the two other rules a suite can cause:
+ *
+ *   idempotency   "MUST tolerate at least five retries of one `Idempotency-Key`
+ *                 within its retention". Unaided: one `createRun` under a fresh
+ *                 key, then five sequential retries with the same key and the
+ *                 same bytes. Every retry answers the first response's status
+ *                 with the same `runId` and `OpenWOP-Idempotent-Replay: true`
+ *                 (`idempotency.md` §Outcomes, `runs.md` §Request headers). A
+ *                 host that evicts after a retry count, answers a later retry
+ *                 `409`, or mints a second run fails. Within retention: the
+ *                 retries land seconds after the first, and a record MUST be
+ *                 kept 24 hours.
+ *   retention     `retention` facet: "An expired run MUST answer `404
+ *                 not_found` or `410 run_expired`". Expiry takes at least seven
+ *                 days on a public host, so this leg is operator-aided, as at
+ *                 v1 (`production-retention-expiry`): `OPENWOP_TEST_EXPIRED_RUN_ID`
+ *                 names a run already expired, or — where the host advertises
+ *                 `retention.testForceExpire: true` —
+ *                 `OPENWOP_TEST_FORCE_EXPIRE_URL` (`{runId}` substituted, method
+ *                 `OPENWOP_TEST_FORCE_EXPIRE_METHOD`, default `POST`) expires a
+ *                 run the suite just created.
+ *
+ * Not here, and why: `debugBundle` has no v2 read (RFC 0207 §C.11 — no
+ * operation in `api/v2/openapi.yaml`), so its redaction and truncation rules
+ * have no wire to witness at major 2. Persistence across restart needs a
+ * process kill (RFC 0158's seam), and the logging rule is not observable.
+ *
+ * Dispositions: no `production` ⇒ `inapplicable` (gate
+ * `openwop.family.production`). No `retention` facet, or a host that offers no
+ * expiry seam and an operator who named no expired run ⇒ `inapplicable` (the
+ * facet is the opt-in, as a fixture is). `testForceExpire: true` with no URL
+ * supplied, a create refused, or a force-expire refused ⇒ `blocked`.
+ *
+ * @see spec/v2/core/conformance.md §Production profile
+ * @see spec/v2/core/idempotency.md §Outcomes
+ * @see conformance/fixtures.md §conformance-idempotent
+ */
+
+import { describe, it, expect } from 'vitest';
+import { randomUUID } from 'node:crypto';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { gateFamily } from '../lib/v2.js';
+import { readErrorCode } from '../lib/error-envelope.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+const ID_RETRIES = 'openwop.requirement.0009.idempotency-five-retries';
+const ID_EXPIRED = 'openwop.requirement.0009.retention-expired-run';
+const DOC = 'spec/v2/core/conformance.md §Production profile';
+const IDEMPOTENT = 'conformance-idempotent';
+const NOOP = 'conformance-noop';
+const RETRIES = 5;
+
+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; }
+}
+const runIdOf = (r: OpenWOPResponse): unknown => (isRecord(r.json) ? r.json['runId'] : undefined);
+
+describe('v2 production profile (conformance.md §Production profile)', () => {
+  it('a host claiming production replays one Idempotency-Key across five retries without a second run', async () => {
+    if ((await gateFamily('production')) === null) return softSkip('inapplicable', 'the host does not advertise production (gate recorded under openwop.family.production)');
+    // conformance-idempotent is the fixture made for this (fixtures.md); noop is the fallback every host seeds.
+    const body = isFixtureAdvertised(IDEMPOTENT) ? { workflowId: IDEMPOTENT, inputs: { nonce: randomUUID() } } : { workflowId: NOOP };
+    const headers = { 'Idempotency-Key': randomUUID() };
+
+    const first = await http(() => driver.post('/runs', body, { headers }));
+    if (first === null) return softSkip('blocked', 'POST /runs unreachable (fetch failed)');
+    if (first.status === 429 || first.status >= 500) return softSkip('blocked', `the first create answered ${first.status} — a retryable outcome is never cached, so there is no record to retry against`);
+    const runId = runIdOf(first);
+    if (first.status !== 201 || typeof runId !== 'string') return softSkip('blocked', `POST /runs {workflowId: ${body.workflowId}} answered ${first.status} ${readErrorCode(first.json) ?? ''} — the create was refused (fixture not seeded?)`.trim());
+
+    for (let i = 1; i <= RETRIES; i++) {
+      const retry = await http(() => driver.post('/runs', body, { headers }));
+      expect(retry, req(ID_RETRIES, DOC, `retry ${i} of ${RETRIES} under one Idempotency-Key MUST be answered (fetch failed)`)).not.toBeNull();
+      if (retry === null) continue;
+      expect(retry.status, req(ID_RETRIES, 'spec/v2/core/idempotency.md §Outcomes', `retry ${i} of ${RETRIES} MUST return the cached response — status ${first.status} — not ${retry.status} ${readErrorCode(retry.json) ?? ''}`.trim())).toBe(first.status);
+      expect(runIdOf(retry), req(ID_RETRIES, 'spec/v2/core/runs.md §Request headers', `retry ${i} of ${RETRIES}: a replayed create MUST NOT create a second run — the cached body names ${runId}`)).toBe(runId);
+      expect(retry.headers.get('openwop-idempotent-replay'), req(ID_RETRIES, 'spec/v2/core/idempotency.md §Outcomes', `retry ${i} of ${RETRIES} is served from cache and MUST carry OpenWOP-Idempotent-Replay: true`)).toBe('true');
+    }
+  });
+
+  it('an expired run answers 404 not_found or 410 run_expired', async () => {
+    const production = await gateFamily('production');
+    if (production === null) return softSkip('inapplicable', 'the host does not advertise production (gate recorded under openwop.family.production)');
+    const retention = production['retention'];
+    if (!isRecord(retention)) return softSkip('inapplicable', 'the host does not advertise production.retention — the expiry rule binds the retention facet');
+
+    let expired = process.env['OPENWOP_TEST_EXPIRED_RUN_ID'];
+    if (expired === undefined) {
+      if (retention['testForceExpire'] !== true) return softSkip('inapplicable', 'production.retention.testForceExpire is not true and OPENWOP_TEST_EXPIRED_RUN_ID is unset — the host offers no expiry seam and expiry takes at least 7 days, so the rule is not reachable from outside');
+      const url = process.env['OPENWOP_TEST_FORCE_EXPIRE_URL'];
+      if (url === undefined) return softSkip('blocked', 'the host advertises retention.testForceExpire, but OPENWOP_TEST_FORCE_EXPIRE_URL is unset — the operator has not said where the hook is');
+      const created = await http(() => driver.post('/runs', { workflowId: NOOP }));
+      const runId = created === null ? undefined : runIdOf(created);
+      if (created === null || created.status !== 201 || typeof runId !== 'string') return softSkip('blocked', `POST /runs answered ${created?.status ?? 'no response'} — there is no run to expire`);
+      const forced = await http(() => driver.request(process.env['OPENWOP_TEST_FORCE_EXPIRE_METHOD'] ?? 'POST', url.replace('{runId}', encodeURIComponent(runId))));
+      if (forced === null || forced.status < 200 || forced.status >= 300) return softSkip('blocked', `the force-expire hook answered ${forced?.status ?? 'no response'} — the run was not expired`);
+      expired = runId;
+    }
+
+    const target: string = expired;
+    const res = await http(() => driver.get(`/runs/${encodeURIComponent(target)}`));
+    if (res === null) return softSkip('blocked', 'GET /runs/{expiredRunId} unreachable (fetch failed)');
+    const code = readErrorCode(res.json);
+    expect(
+      (res.status === 404 && code === 'not_found') || (res.status === 410 && code === 'run_expired'),
+      req(ID_EXPIRED, DOC, `an expired run MUST answer 404 not_found or 410 run_expired through the error envelope (got ${res.status} ${code ?? 'no code'})`),
+    ).toBe(true);
+    expect(typeof (isRecord(res.json) ? res.json['message'] : undefined), req(ID_EXPIRED, 'spec/v2/core/errors.md', 'the refusal is the canonical envelope: message is a string')).toBe('string');
+  });
+});

package/src/scenarios/v2-secrets-run-witness.test.ts

@@ -42,10 +42,23 @@ import { req } from '../lib/requirement-ids.js';
 import { readErrorCode } from '../lib/error-envelope.js';
 import { blockedDespiteAssertions, softSkip } from '../lib/soft-skip.js';
 import { CANARY_NAME, WITNESS_REF, WitnessHost, freshName, freshValue, hits, sha256Hex } from '../lib/run-secrets-witness.js';
+import { familyAdvertised } from '../lib/v2.js';
 
 const DOC = 'host-services.md §Run-supplied secrets (RFC 0229)';
 const host = new WitnessHost(2);
 
+/**
+ * The `secrets` record first, then the facet and fixture (`host.gate()`). With no
+ * record there is no `runSecrets`, so the verdict is unchanged; naming the family
+ * key here is what lets RFC 0264's derivation count a host that passes.
+ */
+async function gate(): ReturnType<WitnessHost['gate']> {
+  let record: Record<string, unknown> | null = null;
+  try { record = await familyAdvertised('secrets'); } catch { return host.gate(); }
+  if (record === null) return { ok: false, kind: 'inapplicable', reason: 'the secrets family is not advertised — no run-supplied secrets (RFC 0229 §D)' };
+  return host.gate();
+}
+
 interface Witnessed { runId: string; createText: string; status: string; matched: boolean | undefined; value: string; digestSupplied: boolean }
 type Outcome = { runs: [Witnessed, Witnessed] } | { skip: 'inapplicable' | 'blocked'; reason: string } | { refused: { status: number; detail: string } };
 
@@ -53,7 +66,7 @@ type Outcome = { runs: [Witnessed, Witnessed] } | { skip: 'inapplicable' | 'bloc
 let pair: Promise<Outcome> | undefined;
 function witnessedPair(): Promise<Outcome> {
   pair ??= (async (): Promise<Outcome> => {
-    const g = await host.gate();
+    const g = await gate();
     if (!g.ok) return { skip: g.kind, reason: g.reason };
     const out: Witnessed[] = [];
     for (const same of [true, false]) {
@@ -110,7 +123,7 @@ describe('RFC 0229 — v2-secrets-run-witness (gated on secrets.runSecrets + ope
   }, 90_000);
 
   it('a run: ref resolves only within the run that supplied it, and the witness refuses any other ref', async () => {
-    const g = await host.gate();
+    const g = await gate();
     if (!g.ok) return softSkip(g.kind, g.reason);
     const id = 'openwop.requirement.secrets.run-witness-scope-bound';
     const v = freshValue();
@@ -142,7 +155,7 @@ describe('RFC 0229 — v2-secrets-run-witness (gated on secrets.runSecrets + ope
   }, 180_000);
 
   it('the idempotency request digest excludes runSecrets: a retry differing only there replays, and its value is discarded', async () => {
-    const g = await host.gate();
+    const g = await gate();
     if (!g.ok) return softSkip(g.kind, g.reason);
     const id = 'openwop.requirement.secrets.run-secrets-outside-request-digest';
     const key = `openwop-witness-${randomUUID()}`;