@openwop/openwop-conformance 2.45.30 → 2.46.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # `@openwop/openwop-conformance` Changelog
 
+## [2.46.0] — 2026-10-10 — RFC 0242: a negotiation record says what was asked for, and an inbound negotiation has a home
+
+A minor, not a patch: `host-event.schema.json` gains a cross-file `$ref` to `run-event-payloads.schema.json#/$defs/negotiationDecided` (COMPATIBILITY.md §2.1). A validator that pre-registers a fixed list of peer schemas must register `run-event-payloads.schema.json` before compiling `host-event.schema.json`.
+
+- **`requested` on `negotiation.decided` (RFC 0242 §A).** `v2-negotiation-decided-emitted` gains two legs, `0242.requested.outbound` and `.mcp`: the record's `requested` equals the version the host's client named to the suite's peer, read from what the peer received. A downgrade is now visible as an `accepted` record whose `version` differs from `requested`.
+- **New `v2-negotiation-decided-inbound` (RFC 0242 §B).** Gated on an inbound A2A or MCP surface (`a2a.agentCardUrl`, `mcp.serverUrls`, `mcp.serverMount`), with no seam:
+  - `0242.inbound.listed`: such a host lists `negotiation.decided` as a durable `hostEvents` type.
+  - `0242.inbound.recorded` / `.refused` (and `.mcp`): with `/host/events` open, an authenticated inbound exchange naming `preferredVersion`, then one naming a version below the floor, each leaves a durable, runless `negotiation.decided` host event with the right `outcome` and `requested`.
+  - Proven against the v2 reference host with the §B implementation: every leg passes, and every record leg fails when the host drops `requested`. On a host that serves A2A or MCP inbound without listing the type, `listed` fails and the record legs are `inapplicable`, naming it.
+- **New lib `negotiation-record.ts`** with self-tests: `askedVersion`, `judgeRequested`, `judgeListed`, `judgeInboundRecord`.
+- **What a host's next bundle shows:** a host that serves A2A or MCP inbound records `0242.inbound.listed` `executed-fail` until it lists the type; the v2 reference host and openwop-app follow (RFC 0242 G1). A host that advertises neither surface is unaffected.
+
 ## [2.45.30] — 2026-10-09 — the seams profile floor is seam-driven
 
 - **`openwop-conformance-seams-v2` no longer certifies on a host that mounts no seams.** Its predicate is a `conformance` block at the discovery root, deliberately necessary and not sufficient: on a host that does not advertise `conformance.seamsProfile`, every floor leg records `inapplicable`, so the profile is claimed with `witnessCount 0` and not certified. But a floor row is recorded per scenario file, and two floor files had a leg that runs without a seam. openwop-app's production bundle `4683d9f89` (suite 2.45.28) carries a `conformance` block holding only `certificationBundleUrl`, and certified the profile on the facet leg alone.

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 652 scenario files under `src/scenarios/`. By target major ([`scenario-majors.json`](./scenario-majors.json)): 212 files run against a v2 host and 455 against a v1 host; 15 of them run at both.
+The current suite has 653 scenario files under `src/scenarios/`. By target major ([`scenario-majors.json`](./scenario-majors.json)): 213 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: 652 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: 653 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/coverage.md

@@ -30,7 +30,7 @@ Each scenario that targets major 2 is listed once, under the [`spec/v2/core/`](.
 | [`i18n.md`](../spec/v2/core/i18n.md) | `v2-content-locale-keys.test.ts`, `v2-i18n-negotiation.test.ts`, `v2-localized-content-delivery.test.ts` |
 | [`idempotency.md`](../spec/v2/core/idempotency.md) | `v2-durability-recovery.test.ts`, `v2-idempotency-in-flight.test.ts`, `v2-idempotency-key-grammar.test.ts` |
 | [`identity.md`](../spec/v2/core/identity.md) | `auth-challenge-no-oracle.test.ts`, `v2-assurance-downgrade-audited.test.ts`, `v2-auth-challenge.test.ts`, `v2-authorization-advertisement.test.ts`, `v2-bound-id-kinds.test.ts`, `v2-bound-id-path-projection.test.ts`, `v2-id-grammar.test.ts`, `v2-interrupt-token-scheme.test.ts`, `v2-lane-exp-only-bound.test.ts`, `v2-lane-issuer-advertised.test.ts`, `v2-oidc-id-token-audience.test.ts`, `v2-owner-subject-required.test.ts`, `v2-protected-resource-metadata.test.ts`, `v2-revocation-honored.test.ts`, `v2-subject-link-record.test.ts` |
-| [`interop.md`](../spec/v2/core/interop.md) | `otel-mcp-semconv-projection.test.ts`, `v2-a2a-agent-cards.test.ts`, `v2-a2a-client-error-details.test.ts`, `v2-a2a-operation-map.test.ts`, `v2-a2a-push-delivery.test.ts`, `v2-interop-trace-context.test.ts`, `v2-legacy-profiles-absent.test.ts`, `v2-mcp-mount-map.test.ts`, `v2-mcp-tasks.test.ts`, `v2-minimum-version-refused.test.ts`, `v2-mrtr-rounds-ceiling.test.ts`, `v2-negotiation-authenticated.test.ts`, `v2-negotiation-decided-emitted.test.ts`, `v2-no-transport-advertisement.test.ts`, `v2-refresh-sla.test.ts` |
+| [`interop.md`](../spec/v2/core/interop.md) | `otel-mcp-semconv-projection.test.ts`, `v2-a2a-agent-cards.test.ts`, `v2-a2a-client-error-details.test.ts`, `v2-a2a-operation-map.test.ts`, `v2-a2a-push-delivery.test.ts`, `v2-interop-trace-context.test.ts`, `v2-legacy-profiles-absent.test.ts`, `v2-mcp-mount-map.test.ts`, `v2-mcp-tasks.test.ts`, `v2-minimum-version-refused.test.ts`, `v2-mrtr-rounds-ceiling.test.ts`, `v2-negotiation-authenticated.test.ts`, `v2-negotiation-decided-emitted.test.ts`, `v2-negotiation-decided-inbound.test.ts`, `v2-no-transport-advertisement.test.ts`, `v2-refresh-sla.test.ts` |
 | [`interrupt.md`](../spec/v2/core/interrupt.md) | `v2-approval-reject-disposition.test.ts`, `v2-approver-enforced.test.ts`, `v2-callback-url-guarded.test.ts` |
 | [`node-pack-runtimes.md`](../spec/v2/core/node-pack-runtimes.md) | `v2-node-pack-runtimes-advertisement.test.ts`, `v2-wasm-memory-cap.test.ts`, `v2-wasm-abi-reject.test.ts` |
 | [`oauth.md`](../spec/v2/core/oauth.md) | `v2-credential-interrupt.test.ts`, `v2-credentials-advertisement.test.ts`, `v2-oauth-client-pkce-state-iss.test.ts`, `v2-oauth-mcp-reach-discovery.test.ts` |

package/dist/spec-artifacts.lock.json

@@ -1,5 +1,5 @@
 {
   "package": "@openwop/spec-artifacts",
-  "version": "2.45.30",
-  "stampSha256": "6288136786dfe99c80a73565b1e77f9b2f5e881fa5c1f140c4d826d3aba15f9c"
+  "version": "2.46.0",
+  "stampSha256": "70bf58cf8fa96a28ef6cf5004d231a34d7be813c61faed31fc33c1b2fde9d0c8"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openwop/openwop-conformance",
-  "version": "2.45.30",
+  "version": "2.46.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.45.30"
+    "@openwop/spec-artifacts": "2.46.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": 740,
-    "tests": 2783,
-    "withStableId": 2783,
+    "files": 741,
+    "tests": 2790,
+    "withStableId": 2790,
     "interpolatedTitles": 0,
-    "explicitIds": 2645
+    "explicitIds": 2646
   },
   "records": [
     {
@@ -33579,7 +33579,7 @@
     {
       "id": "openwop.it.v2-negotiation-decided-emitted.an-a2a-exchange-leaves-negotiation-decided-on-the-host-log",
       "file": "v2-negotiation-decided-emitted.test.ts",
-      "line": 143,
+      "line": 166,
       "title": "an A2A exchange leaves negotiation.decided on the host log",
       "explicitId": null,
       "citations": []
@@ -33587,11 +33587,73 @@
     {
       "id": "openwop.it.v2-negotiation-decided-emitted.an-mcp-exchange-leaves-negotiation-decided-on-the-host-log",
       "file": "v2-negotiation-decided-emitted.test.ts",
-      "line": 146,
+      "line": 169,
       "title": "an MCP exchange leaves negotiation.decided on the host log",
       "explicitId": null,
       "citations": []
     },
+    {
+      "id": "openwop.it.v2-negotiation-decided-emitted.an-a2a-record-names-the-version-the-host-asked-for-rfc-0242-a-2",
+      "file": "v2-negotiation-decided-emitted.test.ts",
+      "line": 172,
+      "title": "an A2A record names the version the host asked for (RFC 0242 §A.2)",
+      "explicitId": null,
+      "citations": []
+    },
+    {
+      "id": "openwop.it.v2-negotiation-decided-emitted.an-mcp-record-names-the-revision-the-host-asked-for-rfc-0242-a-2",
+      "file": "v2-negotiation-decided-emitted.test.ts",
+      "line": 175,
+      "title": "an MCP record names the revision the host asked for (RFC 0242 §A.2)",
+      "explicitId": null,
+      "citations": []
+    },
+    {
+      "id": "openwop.it.v2-negotiation-decided-inbound.a-host-serving-a2a-or-mcp-inbound-lists-negotiation-decided-as-a-durable-host-ev",
+      "file": "v2-negotiation-decided-inbound.test.ts",
+      "line": 134,
+      "title": "a host serving A2A or MCP inbound lists negotiation.decided as a durable host-event type",
+      "explicitId": "openwop.requirement.0242.inbound.listed",
+      "citations": [
+        {
+          "section": "interop.md §The audit event",
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-negotiation-decided-inbound.an-inbound-a2a-exchange-at-preferredversion-is-recorded-accepted-with-requested",
+      "file": "v2-negotiation-decided-inbound.test.ts",
+      "line": 143,
+      "title": "an inbound A2A exchange at preferredVersion is recorded accepted, with requested",
+      "explicitId": null,
+      "citations": []
+    },
+    {
+      "id": "openwop.it.v2-negotiation-decided-inbound.an-inbound-a2a-exchange-below-minimumversion-is-recorded-refused-with-requested",
+      "file": "v2-negotiation-decided-inbound.test.ts",
+      "line": 146,
+      "title": "an inbound A2A exchange below minimumVersion is recorded refused, with requested",
+      "explicitId": null,
+      "citations": []
+    },
+    {
+      "id": "openwop.it.v2-negotiation-decided-inbound.an-inbound-mcp-exchange-at-preferredversion-is-recorded-accepted-with-requested",
+      "file": "v2-negotiation-decided-inbound.test.ts",
+      "line": 149,
+      "title": "an inbound MCP exchange at preferredVersion is recorded accepted, with requested",
+      "explicitId": null,
+      "citations": []
+    },
+    {
+      "id": "openwop.it.v2-negotiation-decided-inbound.an-inbound-mcp-exchange-below-minimumrevision-is-recorded-refused-with-requested",
+      "file": "v2-negotiation-decided-inbound.test.ts",
+      "line": 152,
+      "title": "an inbound MCP exchange below minimumRevision is recorded refused, with requested",
+      "explicitId": null,
+      "citations": []
+    },
     {
       "id": "openwop.it.v2-no-transport-advertisement.the-v2-root-carries-no-supportedtransports-and-no-grpc-block",
       "file": "v2-no-transport-advertisement.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": 652,
+    "files": 653,
     "v1": 455,
-    "v2": 212
+    "v2": 213
   },
   "majors": {
     "a2a-1-0-agent-card.test.ts": [
@@ -1581,6 +1581,9 @@
     "v2-negotiation-decided-emitted.test.ts": [
       2
     ],
+    "v2-negotiation-decided-inbound.test.ts": [
+      2
+    ],
     "v2-no-transport-advertisement.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.30",
-  "corpusTag": "v2.45.30",
+  "version": "2.46.0",
+  "corpusTag": "v2.46.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": "87950b612a26253dfce8dd55703b32ca164e61c56ba6d038e40626e3e6d69b1e",
-    "api/v2/asyncapi.yaml": "99aef28ec33b361d146d2b176714122f95c444967de4993f416f54b17a37ac81",
-    "api/v2/openapi.yaml": "97ed2c29a064cfce269dc746503e4059c42093e64590ae828de9f392917698dc",
+    "api/seams-v2.yaml": "d9a148a5136c34759cf8b92330e3a5f82dba06b25ce7ca22330e94b2c616bdde",
+    "api/v2/asyncapi.yaml": "c742c8d76aac957c9f508f15145e6440e195b13130a8ee2669d0d37f8dd4eaae",
+    "api/v2/openapi.yaml": "ea5ada57301b530f95f7410280e85fe96e32b91b96031fdae22df5e1d6c6e65f",
     "api/v2/redocly.yaml": "1e66b60e6118ad11a823bb620678be464d99dfe50a40e3e6f93ec9429b88b34c",
     "schemas/README.md": "276fc1d51eb08e14e9127b9fd27761d7046ee33c12000f3a64a801322db8bf58",
     "schemas/a2a-task-state.schema.json": "75d5049dea8bd873ff0e7546f1c60c8d36c219bec7084264360be54a8be30ae1",
@@ -152,7 +152,7 @@
     "schemas/v2/goal.schema.json": "ad104ed5a3866736b8fed9d7c0b23dc82af526b5bef4afe848f01fc3af2161e9",
     "schemas/v2/heartbeat-evaluated.schema.json": "c897b0792fd518d6e12879851027252af1529f5e420c3eaf434ad7af284ecc05",
     "schemas/v2/heartbeat-state-changed.schema.json": "eb68d0082aa996650e3a6b8ccf32457f959cebc7e6728cc7c331b9d171a4bef6",
-    "schemas/v2/host-event.schema.json": "655b5475b1aeb41c8fc4ff7b6fc7e31a0fcc18fd59f368336ccbc138e6ba395e",
+    "schemas/v2/host-event.schema.json": "8ecb5ae218ea6ba71b2aa52905c7851d125d6ca3c5108718739e84b3d6041d02",
     "schemas/v2/ids.schema.json": "65cfaa193be0ca9cf48af39c18c553979e3ec1f7fc04509aaa513b322d7b7e4a",
     "schemas/v2/localized-content-language-settings.schema.json": "3c8350a178037a460f5d87466ccaf9ed5fe3d41497786d2504cc66e42152c8cc",
     "schemas/v2/localized-content-page-response.schema.json": "ef48329749758afb21e4d3cbc3f017abb911f75726819457f35b9f1390332c75",
@@ -174,7 +174,7 @@
     "schemas/v2/residency.schema.json": "3fd23c9732beb140504e81560fc426eb6764d547e56da5fb92c5a5c7bf04db3a",
     "schemas/v2/run-ancestry-response.schema.json": "334c17f2062dea62726ca1d07b8be3f169cdc422af843c1def5fb317039814c9",
     "schemas/v2/run-diff-response.schema.json": "8bdb2045c274580038bd74781f7d062f5049839797c164a89de4ed89edc53a74",
-    "schemas/v2/run-event-payloads.schema.json": "cb331e0b5adf8374124426a77a4f5c915df62b944e97cdaf3107cfe44733a629",
+    "schemas/v2/run-event-payloads.schema.json": "ff80204f4a9a55da482d8c7d54d6dbb8682e13fff155d4fc26fa5b7fa0790b83",
     "schemas/v2/run-event.schema.json": "2f0d7416bd376c56affe97b6b2b49981532e8e9ff45c0a162cf806c78b3e7fb7",
     "schemas/v2/run-list-response.schema.json": "c2dbc34768dcf64528914a213aa3cb55952e8e3e90a64b04a9423b2a19749d38",
     "schemas/v2/run-options.schema.json": "f0e9f494d80086c2ed2cf9fe87df54e5b4e66601699c4a1089f4edbc7ba58867",
@@ -208,14 +208,14 @@
     "schemas/workspace-file.schema.json": "464de85c2a068243084ee9c1d969bc7cd5d8f7948574e58450d6493c38a0e1e4",
     "spec/v1/alias-detectors.json": "22444c22bb88c568339ef512553f9fc38146e22b566d11ab8608f655d688d19c",
     "spec/v1/capability-declaration-classes.json": "e7729aed5c4b4e1dd02abab0530f14cc95f5d4070fe51fb139e7f5cccefa00c6",
-    "spec/v1/core-standard-manifest.json": "1b343f616416e2b92ae3c085bc147f6fb23aa9d366a4488431207e3d0f86bd97",
+    "spec/v1/core-standard-manifest.json": "1ecf2f7820fe47528c5c77bbe0d44ede95ef27cb1a8de209bb5104a4186c3722",
     "spec/v1/deprecations.json": "e723bc11d7272c71789ad1303bb7f21809a8a024abf57594f9d5c35dc199ece9",
     "spec/v1/deprecations.schema.json": "3e393c405d2a41b467d8c5e3c468549078df1ce6a6d2588fc488097b95d9b55b",
     "spec/v1/end-of-support.json": "35f0bf3b70fe78b16e2a2fd81a153fc27e703f6c16376c6fe7cdf1f4f2c4e6d4",
     "spec/v1/event-codemap.json": "3da60d884157793a360da532a9fcbbfb5285636db325a74cec94b34622186d97",
     "spec/v1/event-codemap.schema.json": "d05933b2e88103aff51a2f774df97b9bda065e0fc88dbd9b114cc47a32189174",
     "spec/v1/extensions.json": "79a60754aa16cbdbdb604f8e5c00038af535a1690a4d07bd5ff7c38f0256a7bc",
-    "spec/v1/gaps.json": "44a1f30d4dd851ac7609fef7dfbd3f7e55404f97130dbe094132f9cd4b71c468",
+    "spec/v1/gaps.json": "7f26aee1bbae95945d29f4e2ecabb672c6833bc42f6f45f71e4880b7d09c130a",
     "spec/v1/gaps.schema.json": "8fd83259f556553c9df0f53e7a82ca8c2a4771d471197f69b4e2ae0ceeacfd66",
     "spec/v1/migrations.json": "4c50760be70cb644d02427bcaf5749606700edf4513f423903cf3b1d12f5c300",
     "spec/v1/migrations.schema.json": "886779aa6c22e646db097f5df210adb018a4dd14a7b815465a18c8a7056c8f72",
@@ -228,7 +228,7 @@
     "spec/v2/core/connection-packs.md": "c80f95bd6a03698f35c72cdb2b46bd973f49203bbd786c26760e35fa86e6f23d",
     "spec/v2/core/conversation.md": "8d6abedf6af408a74577753bfca24719d318e2632e10b45ff5d63bdcf31a8aaa",
     "spec/v2/core/errors.md": "e48838701b86bbfe0ffee77b18a8ffc4e5f04724b4318507d9771da653f8da0f",
-    "spec/v2/core/events.md": "d0f902edc080e9789e4fd05850a1264d905ebe5b06045b6a7a22486e22ef3091",
+    "spec/v2/core/events.md": "370621629c2439747f2e4ddab4780eea4345354f79e5098739d66823873f3105",
     "spec/v2/core/execution.md": "8a0c9db1bbfb97c008ab9328b7333c1cc3318196e78bfbefb49e781bdf4f9d44",
     "spec/v2/core/form-content-packs.md": "02931227899676fd4581a27017be2a6c4953904717be9b81c29d12f87ab3917d",
     "spec/v2/core/headers.md": "f69fe81e4a3ad21879bb85948660c16860eb05bf152928c31aa4898f6d7d1887",
@@ -236,7 +236,7 @@
     "spec/v2/core/i18n.md": "882904b7d59f992ab1e5f7346167161a54cf665b8fee47e64a3862cf9133a580",
     "spec/v2/core/idempotency.md": "adbd317a6ebb57c2759c076297b31f67def9e391576bccd0bbea787b13e85872",
     "spec/v2/core/identity.md": "02656ffa413b5546342b8580ae928a74e621460746df74d7db50ff4df41d2310",
-    "spec/v2/core/interop.md": "fb1d72bb76afda1c2b4394daf019982c207dbb490087ab141daf6eb2446e2eef",
+    "spec/v2/core/interop.md": "6ec8259117bdb387b9323ca22c707b3b8571c00034e461c4ce79f4070c4d6b4a",
     "spec/v2/core/interrupt.md": "10f15dfe30baa0fc748aea0a067f9b271bea316fde6b598d78f77edc296f698a",
     "spec/v2/core/node-pack-runtimes.md": "e1088cb69b8c3c67256c494063328916c2980ab1aa97a7063de25bab82fdb1e5",
     "spec/v2/core/oauth.md": "c069ae4f9aae2eafe14c07c0bf709aa7ade0dcc821973d740400d49d901f7061",
@@ -313,9 +313,9 @@
     "spec/v2/path-manifest.json": "7b5679a4dad98c80d855361d88a98c8a4e045af15e310862a05b285b815dc9fc",
     "spec/v2/peer-dependency-aliases.json": "d10299280abee08258502925bc327293ee413e0108cd6e6ec75ff6110653308d",
     "spec/v2/profiles.json": "3d84d7712e93d1e823e362615d5f4aaba0789ea4e044b3774965876fbb8829a7",
-    "spec/v2/release.json": "b7dea408ef966d034c55aeb0987fe926d88c4009479bd92816c7c87acfb384cf",
+    "spec/v2/release.json": "418d1ab00135f629e6e6e4b0dae213dc85dfc5418bdf3177f91d8508ad4f90cb",
     "spec/v2/retention-floors.json": "eaf3722d95c79947af1d4269ef85117e126518c588cfcf1a2b21b97269f51624",
-    "spec/v2/surface-baseline.json": "5f58750fdbd55de45cf31c1f7dee09f68c7b1a40c86d20a046f8c2bc52c0c740"
+    "spec/v2/surface-baseline.json": "d17b41008a6572efd3b6d1178aa630be645b6cd135032814bcd4b618ad980811"
   },
-  "corpusCommit": "0f13b5191bd0e29c8b4a8219a059361e27834ea2"
+  "corpusCommit": "5d0b99eeb2f8d2682516c73bc7dda9c18a0f1aee"
 }

package/src/lib/negotiation-record.ts

@@ -0,0 +1,108 @@
+/**
+ * RFC 0242 — judging a `negotiation.decided` record (`spec/v2/core/interop.md`
+ * §The audit event).
+ *
+ * Two facts the record must carry beyond RFC 0175 §D.3:
+ *   - `requested`: the version the requesting side named (§A.2). Outbound the
+ *     host is the requester, and the suite's fake peer saw what it asked for;
+ *     inbound the suite is the requester and knows what it named.
+ *   - where it lands: a negotiation with no run is a durable host event (§B.2),
+ *     listed in `hostEvents.types[]` whenever an inbound surface is advertised
+ *     (§B.3).
+ *
+ * Pure functions only, so `negotiation-record.test.ts` can prove each judge
+ * fails on the defect it exists to catch.
+ */
+
+export interface Finding { readonly ok: boolean; readonly message: string }
+
+export const EVENT = 'negotiation.decided';
+
+interface Invocation { readonly headers: Readonly<Record<string, string>>; readonly params?: unknown }
+
+const META_V = 'io.modelcontextprotocol/protocolVersion';
+
+/**
+ * The version the host asked a suite peer for, read from what the peer
+ * received: A2A's `A2A-Version` header; MCP's `MCP-Protocol-Version` header,
+ * else the `_meta` protocol version, else legacy `initialize`'s
+ * `protocolVersion`. `null` when the host named none, in which case §A.2 does
+ * not require `requested`.
+ */
+export function askedVersion(protocol: 'a2a' | 'mcp', invocations: readonly Invocation[]): string | null {
+  for (const inv of invocations) {
+    if (protocol === 'a2a') {
+      const v = inv.headers['a2a-version'];
+      if (typeof v === 'string' && v.length > 0) return v;
+      continue;
+    }
+    const h = inv.headers['mcp-protocol-version'];
+    if (typeof h === 'string' && h.length > 0) return h;
+    const p = (inv.params ?? {}) as Record<string, unknown>;
+    const meta = (p['_meta'] ?? {}) as Record<string, unknown>;
+    if (typeof meta[META_V] === 'string') return meta[META_V] as string;
+    if (typeof p['protocolVersion'] === 'string') return p['protocolVersion'] as string;
+  }
+  return null;
+}
+
+/** §A.2: `requested` is present and equals what was named. */
+export function judgeRequested(payload: Readonly<Record<string, unknown>>, named: string): Finding {
+  const got = payload['requested'];
+  if (typeof got !== 'string') return { ok: false, message: `${EVENT} MUST carry requested when a version was named (named ${named}; the record has none) — RFC 0242 §A.2` };
+  return got === named
+    ? { ok: true, message: 'requested matches the named version' }
+    : { ok: false, message: `${EVENT}.requested MUST equal the version the requesting side named: named ${named}, recorded ${got} — RFC 0242 §A.2` };
+}
+
+/** Whether discovery advertises an inbound A2A or MCP surface (§B.3's condition). */
+export function inboundServed(doc: Readonly<Record<string, unknown>>): { a2a: boolean; mcp: boolean } {
+  const a2a = doc['a2a'] as Record<string, unknown> | undefined;
+  const mcp = doc['mcp'] as Record<string, unknown> | undefined;
+  const urls = Array.isArray(mcp?.['serverUrls']) ? (mcp!['serverUrls'] as unknown[]) : [];
+  return {
+    a2a: typeof a2a?.['agentCardUrl'] === 'string',
+    mcp: mcp !== undefined && (urls.length > 0 || mcp['serverMount'] !== undefined),
+  };
+}
+
+/** §B.3: an inbound surface implies `{ type: negotiation.decided, delivery: durable }` in `hostEvents.types[]`. */
+export function judgeListed(doc: Readonly<Record<string, unknown>>): Finding {
+  const served = inboundServed(doc);
+  const which = [served.a2a ? 'a2a.agentCardUrl' : null, served.mcp ? 'mcp.serverUrls/serverMount' : null].filter(Boolean).join(' and ');
+  const he = doc['hostEvents'] as Record<string, unknown> | undefined;
+  if (he === undefined) return { ok: false, message: `the host serves ${which} inbound, so it MUST advertise hostEvents listing ${EVENT} (durable) — RFC 0242 §B.3` };
+  const types = Array.isArray(he['types']) ? (he['types'] as Array<Record<string, unknown>>) : [];
+  const row = types.find((t) => t?.['type'] === EVENT);
+  if (!row) return { ok: false, message: `the host serves ${which} inbound, so hostEvents.types[] MUST list ${EVENT} — RFC 0242 §B.3` };
+  return row['delivery'] === 'durable'
+    ? { ok: true, message: `${EVENT} listed durable` }
+    : { ok: false, message: `${EVENT} MUST be listed with delivery durable, not ${String(row['delivery'])} — RFC 0242 §B.2` };
+}
+
+/**
+ * §B.2: the host event recording one inbound exchange. `envelopes` are the
+ * parsed `data:` of every `negotiation.decided` frame seen while the exchange
+ * ran; the judge picks the one whose `requested` is the version the suite
+ * named, so a concurrent exchange cannot satisfy it.
+ */
+export function judgeInboundRecord(
+  envelopes: readonly Record<string, unknown>[],
+  expect: { protocol: 'a2a' | 'mcp'; named: string; outcome: 'accepted' | 'refused' },
+): Finding[] {
+  const mine = envelopes.filter((e) => ((e['payload'] ?? {}) as Record<string, unknown>)['requested'] === expect.named
+    && ((e['payload'] ?? {}) as Record<string, unknown>)['protocol'] === expect.protocol);
+  if (mine.length === 0) {
+    return [{ ok: false, message: `an inbound ${expect.protocol} exchange naming ${expect.named} MUST leave a ${EVENT} host event on /host/events with requested ${expect.named}; ${envelopes.length} ${EVENT} frame(s) seen, none matching — RFC 0242 §B.2, §A.2` }];
+  }
+  const e = mine[mine.length - 1]!;
+  const p = (e['payload'] ?? {}) as Record<string, unknown>;
+  const out: Finding[] = [];
+  out.push(e['delivery'] === 'durable' ? { ok: true, message: 'durable' } : { ok: false, message: `the host event MUST be durable, got ${String(e['delivery'])} — RFC 0242 §B.2` });
+  out.push(!('runId' in e) && !('sequence' in e) ? { ok: true, message: 'runless' } : { ok: false, message: 'a host event carries no runId or sequence — events.md §Host events' });
+  out.push(p['outcome'] === expect.outcome ? { ok: true, message: 'outcome' } : { ok: false, message: `the exchange was ${expect.outcome === 'accepted' ? 'served' : 'refused'}, so the recorded outcome MUST be ${expect.outcome}, got ${String(p['outcome'])}` });
+  if (expect.outcome === 'accepted') {
+    out.push(typeof p['version'] === 'string' ? { ok: true, message: 'version' } : { ok: false, message: 'an accepted record names the version used — interop.md §The audit event' });
+  }
+  return out;
+}

package/src/scenarios/v2-negotiation-decided-emitted.test.ts

@@ -22,6 +22,9 @@
  * Callback-shaped (the host calls the suite's peer): unwitnessable when the
  * host is in a separate network namespace — `../lib/host-callback.ts`.
  *
+ * RFC 0242 §A.2 adds two legs: the record's `requested` equals the version the
+ * host's client named to the suite's peer (read from what the peer received).
+ *
  * @see spec/v2/core/interop.md §Negotiation is a protocol
  */
 
@@ -39,6 +42,7 @@ import { getA2AFakePeer } from '../lib/a2a-fake-peer.js';
 import { getMcpFakeServer } from '../lib/mcp-fake-server.js';
 import { softSkip, seamAbsent } from '../lib/soft-skip.js';
 import { req } from '../lib/requirement-ids.js';
+import { askedVersion, judgeRequested } from '../lib/negotiation-record.js';
 
 export const REQUIRES_HOST_CALLBACK = "the host's A2A/MCP client calls the suite's fake peer/server through the invoke seams; the negotiation.decided event is then read on the host's own log";
 
@@ -83,7 +87,10 @@ function originDigest(url: string): string {
   return createHash('sha256').update(new URL(url).origin, 'utf8').digest('hex');
 }
 
-async function leg(protocol: 'a2a' | 'mcp', id: string): Promise<void> {
+type Exchange = { driven: { status: number; body: Record<string, unknown> }; runId: string; decided: EventRow[]; peer: NonNullable<ReturnType<typeof getA2AFakePeer>> | NonNullable<ReturnType<typeof getMcpFakeServer>>; validate: NonNullable<ReturnType<typeof payloadValidator>> };
+
+/** Gate, drive one exchange through the seam, and read the run's records; `undefined` once a skip is recorded. */
+async function exchange(protocol: 'a2a' | 'mcp'): Promise<Exchange | undefined> {
   const doc = await discovery();
   if (!doc) return softSkip('blocked', 'discovery unreachable');
   const facet = await familyAdvertised(protocol);
@@ -94,15 +101,31 @@ async function leg(protocol: 'a2a' | 'mcp', id: string): Promise<void> {
   peer.reset();
   const validate = payloadValidator();
   if (!validate) return softSkip('blocked', 'run-event-payloads.schema.json#/$defs/negotiationDecided not readable from SCHEMAS_DIR');
-
   const driven = await drive(protocol, peer.hostFacingEndpoint());
   if (!driven) return softSkip('blocked', 'invoke seam unavailable (reason recorded above)');
   const runId = driven.body['runId'];
   if (typeof runId !== 'string') {
     return softSkip('blocked', `the ${protocol} invoke seam answered ${driven.status} without a runId — the host log that carries ${EVENT} is not addressable from the suite (the seam MUST name the run whose log recorded the decision)`);
   }
-  const events = await eventsOf(runId);
-  const decided = events.filter((e) => e.type === EVENT);
+  const decided = (await eventsOf(runId)).filter((e) => e.type === EVENT);
+  return { driven, runId, decided, peer, validate };
+}
+
+/** RFC 0242 §A.2: the record names the version the host asked the peer for. */
+async function requestedLeg(protocol: 'a2a' | 'mcp', id: string): Promise<void> {
+  const x = await exchange(protocol);
+  if (!x) return;
+  const named = askedVersion(protocol, x.peer.invocations());
+  if (named === null) return softSkip('inapplicable', `the host's ${protocol} client named no version to the suite's peer, so RFC 0242 §A.2 does not require requested`);
+  expect(x.decided.length, req(id, 'interop.md §The audit event', `the exchange MUST leave ${EVENT} on run ${x.runId} (RFC 0175 §D.3)`)).toBeGreaterThan(0);
+  const f = judgeRequested(x.decided[x.decided.length - 1]!.payload ?? {}, named);
+  expect(f.ok, req(id, 'interop.md §The audit event', f.message)).toBe(true);
+}
+
+async function leg(protocol: 'a2a' | 'mcp', id: string): Promise<void> {
+  const x = await exchange(protocol);
+  if (!x) return;
+  const { driven, runId, decided, peer, validate } = x;
   expect(
     decided.length,
     req(id, 'interop.md §The audit event', `every ${protocol} negotiation outcome MUST emit ${EVENT} on the host's own event log (RFC 0175 §D.3) — none found on run ${runId}`),
@@ -146,4 +169,10 @@ describe('RFC 0175 §D.3 — negotiation-decided-emitted (gated on a2a/mcp + sea
   it('an MCP exchange leaves negotiation.decided on the host log', async () => {
     await leg('mcp', 'openwop.requirement.0175.negotiation-decided-emitted.mcp');
   });
+  it('an A2A record names the version the host asked for (RFC 0242 §A.2)', async () => {
+    await requestedLeg('a2a', 'openwop.requirement.0242.requested.outbound');
+  });
+  it('an MCP record names the revision the host asked for (RFC 0242 §A.2)', async () => {
+    await requestedLeg('mcp', 'openwop.requirement.0242.requested.outbound.mcp');
+  });
 });

package/src/scenarios/v2-negotiation-decided-inbound.test.ts

@@ -0,0 +1,155 @@
+/**
+ * RFC 0242 §B — an inbound negotiation is recorded as a durable host event
+ * (suite 2.46.0, target major 2; gated on an inbound a2a/mcp surface).
+ *
+ * `spec/v2/core/interop.md` §The audit event: every negotiation outcome MUST
+ * emit a `negotiation.decided` record — on its run's log, or, with no run, as
+ * the caller's durable host event (`schemas/v2/host-event.schema.json`,
+ * `payload` = `run-event-payloads.schema.json#/$defs/negotiationDecided`). A
+ * host serving either protocol inbound (`a2a.agentCardUrl`, `mcp.serverUrls`,
+ * `mcp.serverMount`) MUST list the type as durable in `hostEvents.types[]`,
+ * and `requested` MUST carry the version the caller named.
+ *
+ * How it is witnessed, with no seam: the suite reads discovery for §B.3, then
+ * acts as an authenticated inbound client. With `/host/events` open it makes
+ * one exchange naming `preferredVersion` (expected `accepted`) and one naming
+ * a version below the floor (expected `refused`), and finds each record by its
+ * `requested`. A2A names the version in `A2A-Version` on a JSON-RPC `GetTask`
+ * for a task that does not exist; MCP names it in `MCP-Protocol-Version` and
+ * `_meta` on `tools/list`. Neither call changes host state.
+ *
+ * @see RFCS/0242-negotiation-decided-requested-and-inbound.md
+ * @see spec/v2/core/interop.md §Negotiation is a protocol
+ * @see spec/v2/core/events.md §Host events
+ */
+
+import { describe, it, expect } from 'vitest';
+import { randomBytes } from 'node:crypto';
+import { v2Discovery, familyAdvertised, v2Validator } from '../lib/v2.js';
+import { loadEnv } from '../lib/env.js';
+import { subscribe } from '../lib/sse.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { EVENT, inboundServed, judgeInboundRecord, judgeListed } from '../lib/negotiation-record.js';
+
+const DOC = 'interop.md §The audit event';
+const ID_LISTED = 'openwop.requirement.0242.inbound.listed';
+const ID_A2A = 'openwop.requirement.0242.inbound.recorded';
+const ID_A2A_REFUSED = 'openwop.requirement.0242.inbound.refused';
+const ID_MCP = 'openwop.requirement.0242.inbound.recorded.mcp';
+const ID_MCP_REFUSED = 'openwop.requirement.0242.inbound.refused.mcp';
+const A2A_BELOW = '0.3';
+const MCP_BELOW = '2025-06-18';
+const META_V = 'io.modelcontextprotocol/protocolVersion';
+const STREAM_MS = 3_000;
+
+const hostEvent = v2Validator('host-event');
+const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));
+const absolute = (u: string): string => (/^https?:\/\//i.test(u) ? u : `${loadEnv().baseUrl}${u.startsWith('/') ? '' : '/'}${u}`);
+
+/** `a.b` versions and ISO-date revisions both order correctly as compared here. */
+function below(candidate: string, floor: string): boolean {
+  if (/^\d+\.\d+$/.test(candidate) && /^\d+\.\d+$/.test(floor)) {
+    const [cm, cn] = candidate.split('.').map(Number);
+    const [fm, fn] = floor.split('.').map(Number);
+    return cm! < fm! || (cm === fm && cn! < fn!);
+  }
+  return candidate < floor;
+}
+
+type Surface = { url: string; preferred: string; floor: string };
+type Gate = { ok: true; doc: Record<string, unknown>; surface: Surface } | { ok: false; kind: 'blocked' | 'inapplicable'; reason: string };
+
+async function gate(protocol: 'a2a' | 'mcp'): Promise<Gate> {
+  let doc: Record<string, unknown> | null;
+  try { doc = await v2Discovery(); } catch { doc = null; }
+  if (!doc) return { ok: false, kind: 'blocked', reason: 'v2 discovery unreachable' };
+  const facet = await familyAdvertised(protocol);
+  if (!facet || !inboundServed(doc)[protocol]) return { ok: false, kind: 'inapplicable', reason: `the host serves no inbound ${protocol} surface (${protocol === 'a2a' ? 'a2a.agentCardUrl' : 'mcp.serverUrls / mcp.serverMount'} absent)` };
+  if (!judgeListed(doc).ok) return { ok: false, kind: 'inapplicable', reason: `hostEvents.types[] does not list ${EVENT}, so the host emits no such host event; ${ID_LISTED} records that failure` };
+  const preferred = facet['preferredVersion'];
+  const floor = protocol === 'a2a' ? facet['minimumVersion'] : facet['minimumRevision'];
+  if (typeof preferred !== 'string' || typeof floor !== 'string') return { ok: false, kind: 'blocked', reason: `the ${protocol} facet lacks preferredVersion or its floor` };
+  if (protocol === 'mcp') {
+    const urls = Array.isArray(facet['serverUrls']) ? (facet['serverUrls'] as unknown[]).filter((u): u is string => typeof u === 'string' && u.length > 0) : [];
+    if (urls.length === 0) return { ok: false, kind: 'blocked', reason: 'mcp is served inbound with no mcp.serverUrls[0] — the mount is unaddressable' };
+    return { ok: true, doc, surface: { url: absolute(urls[0]!), preferred, floor } };
+  }
+  const res = await fetch(String(facet['agentCardUrl']), { headers: { accept: 'application/json', 'A2A-Version': preferred } }).catch(() => null);
+  if (!res || res.status !== 200) return { ok: false, kind: 'blocked', reason: `the advertised agentCardUrl answered ${res?.status ?? 'nothing'}` };
+  const card = (await res.json().catch(() => ({}))) as { supportedInterfaces?: Array<{ url?: string; protocolBinding?: string }> };
+  const iface = (card.supportedInterfaces ?? []).find((i) => i.protocolBinding === 'JSONRPC' && typeof i.url === 'string');
+  if (!iface) return { ok: false, kind: 'blocked', reason: 'the public agent card lists no JSONRPC interface to send an inbound request to' };
+  return { ok: true, doc, surface: { url: absolute(iface.url!), preferred, floor } };
+}
+
+/** One inbound exchange naming `version`; the caller's bearer authenticates it (`interop.md` §Authentication). */
+async function exchange(protocol: 'a2a' | 'mcp', url: string, version: string): Promise<void> {
+  const headers: Record<string, string> = { 'content-type': 'application/json', accept: 'application/json, text/event-stream', authorization: `Bearer ${loadEnv().apiKey}` };
+  const id = randomBytes(4).readUInt32BE(0);
+  let body: Record<string, unknown>;
+  if (protocol === 'a2a') {
+    headers['A2A-Version'] = version;
+    body = { jsonrpc: '2.0', id, method: 'GetTask', params: { id: `conf-0242-${randomBytes(8).toString('hex')}` } };
+  } else {
+    headers['MCP-Protocol-Version'] = version;
+    headers['Mcp-Method'] = 'tools/list';
+    body = { jsonrpc: '2.0', id, method: 'tools/list', params: { _meta: { [META_V]: version } } };
+  }
+  await fetch(url, { method: 'POST', headers, body: JSON.stringify(body) }).then((r) => r.text()).catch(() => undefined);
+}
+
+/** Open `/host/events`, make the exchange, and return the parsed envelope of every `negotiation.decided` frame. */
+async function recordsOf(protocol: 'a2a' | 'mcp', url: string, version: string): Promise<{ envelopes: Record<string, unknown>[]; invalid: string[] }> {
+  const sub = subscribe('/host/events', { timeoutMs: STREAM_MS, extraHeaders: { 'OpenWOP-Version': '2.0' } });
+  await sleep(400);
+  await exchange(protocol, url, version);
+  const frames = (await sub).events.filter((f) => f.event === EVENT);
+  const envelopes: Record<string, unknown>[] = [];
+  const invalid: string[] = [];
+  for (const f of frames) {
+    let env: unknown;
+    try { env = JSON.parse(f.data); } catch { invalid.push('non-JSON data'); continue; }
+    const v = hostEvent(env);
+    if (!v.ok) invalid.push(v.errors);
+    if (env && typeof env === 'object') envelopes.push(env as Record<string, unknown>);
+  }
+  return { envelopes, invalid };
+}
+
+async function inboundLeg(protocol: 'a2a' | 'mcp', id: string, which: 'accepted' | 'refused'): Promise<void> {
+  const g = await gate(protocol);
+  if (!g.ok) return softSkip(g.kind, g.reason);
+  const candidate = protocol === 'a2a' ? A2A_BELOW : MCP_BELOW;
+  if (which === 'refused' && !below(candidate, g.surface.floor)) {
+    return softSkip('inapplicable', `the ${protocol} floor ${g.surface.floor} is at or below ${candidate}, the lowest version the suite can name — nothing below the floor to ask for`);
+  }
+  const named = which === 'accepted' ? g.surface.preferred : candidate;
+  const { envelopes, invalid } = await recordsOf(protocol, g.surface.url, named);
+  expect(invalid, req(id, 'events.md §Host events', `every ${EVENT} host event MUST validate against host-event.schema.json: ${invalid.join('; ')}`)).toEqual([]);
+  for (const f of judgeInboundRecord(envelopes, { protocol, named, outcome: which })) expect(f.ok, req(id, DOC, f.message)).toBe(true);
+}
+
+describe('RFC 0242 §B — an inbound negotiation is a durable host event (gated on an inbound a2a/mcp surface)', () => {
+  it('a host serving A2A or MCP inbound lists negotiation.decided as a durable host-event type', async () => {
+    let doc: Record<string, unknown> | null;
+    try { doc = await v2Discovery(); } catch { doc = null; }
+    if (!doc) return softSkip('blocked', 'v2 discovery unreachable');
+    const served = inboundServed(doc);
+    if (!served.a2a && !served.mcp) return softSkip('inapplicable', 'the host advertises no inbound A2A or MCP surface (a2a.agentCardUrl, mcp.serverUrls, mcp.serverMount)');
+    const f = judgeListed(doc);
+    expect(f.ok, req(ID_LISTED, DOC, f.message)).toBe(true);
+  });
+  it('an inbound A2A exchange at preferredVersion is recorded accepted, with requested', async () => {
+    await inboundLeg('a2a', ID_A2A, 'accepted');
+  });
+  it('an inbound A2A exchange below minimumVersion is recorded refused, with requested', async () => {
+    await inboundLeg('a2a', ID_A2A_REFUSED, 'refused');
+  });
+  it('an inbound MCP exchange at preferredVersion is recorded accepted, with requested', async () => {
+    await inboundLeg('mcp', ID_MCP, 'accepted');
+  });
+  it('an inbound MCP exchange below minimumRevision is recorded refused, with requested', async () => {
+    await inboundLeg('mcp', ID_MCP_REFUSED, 'refused');
+  });
+});