@openwop/openwop-conformance 2.36.1 → 2.37.1

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": 553,
+    "files": 557,
     "v1": 448,
-    "v2": 113
+    "v2": 117
   },
   "majors": {
     "a2a-1-0-agent-card.test.ts": [
@@ -1250,6 +1250,9 @@
     "v2-a2a-agent-cards.test.ts": [
       2
     ],
+    "v2-a2a-client-error-details.test.ts": [
+      2
+    ],
     "v2-a2a-operation-map.test.ts": [
       2
     ],
@@ -1364,6 +1367,9 @@
     "v2-id-grammar.test.ts": [
       2
     ],
+    "v2-idempotency-in-flight.test.ts": [
+      2
+    ],
     "v2-idempotency-key-grammar.test.ts": [
       2
     ],
@@ -1373,6 +1379,9 @@
     "v2-interop-trace-context.test.ts": [
       2
     ],
+    "v2-interrupt-resolve-terminal.test.ts": [
+      2
+    ],
     "v2-interrupt-token-scheme.test.ts": [
       2
     ],
@@ -1508,6 +1517,9 @@
     "v2-run-snapshot-etag.test.ts": [
       2
     ],
+    "v2-sse-last-event-id-cursor.test.ts": [
+      2
+    ],
     "v2-sse-last-event-id.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.36.1",
-  "corpusTag": "v2.36.0",
+  "version": "2.37.1",
+  "corpusTag": "v2.37.1",
   "files": {
     "api/.redocly.lint-ignore.yaml": "bf5a8350b88a72fa43f59605ed8d903ed24b6cfccda5e45509c9f6ed9ee4e712",
     "api/asyncapi.yaml": "d5ecb9ee6114582be3b1f662c84bfac9ae96dae7bacb853e461168f70a8e1c7d",
     "api/grpc/openwop.proto": "c3e72bb17cba514ee98feb6434e6c9b6ea6795bfd086489ec69fd882dd1ad977",
-    "api/openapi.yaml": "d19c3d4af7fd0e2305dd5fee3d5b984c6d0e9b1824d72d8dffc714a92b248269",
+    "api/openapi.yaml": "6366b5514be71098e9ea41fc81ff52bc39db1a547b353c0b344cc2a2bf5370aa",
     "api/redocly.yaml": "b0604c89b2ca6d5076ec25725c539dad44a741a811fe524439ee6daef8baa09f",
-    "api/seams-v2.yaml": "591e917af3c0e79fbe831690b35383bcc6976dd2e0ef0660c5e3bce5541dc9c2",
-    "api/v2/asyncapi.yaml": "813a73c8c1e25c55cb60d92aecf2fc1361ab84894c4e15a378c49d11dd0f1984",
-    "api/v2/openapi.yaml": "e5156f2a6d241cec8bb4f5dd872400b4bc021dff61e572ab4b11c52105d18f22",
+    "api/seams-v2.yaml": "02711723089859b95144d788c0caabf215305570c7d48be1da5d2a5e21eff4e1",
+    "api/v2/asyncapi.yaml": "d492342046d1ec3a2dc43a28c4cf6d821d6319c30a8552cbc8fcd13806f7b2df",
+    "api/v2/openapi.yaml": "ba67b61f0e716444308ef7bc00416b8eee5829c28b67c5070358d35c3ca64d36",
     "api/v2/redocly.yaml": "1e66b60e6118ad11a823bb620678be464d99dfe50a40e3e6f93ec9429b88b34c",
     "schemas/README.md": "0c0b737ffcf8f30e7d2809cec8a498232de710f41443212922ad8337cdde0b51",
     "schemas/a2a-task-state.schema.json": "75d5049dea8bd873ff0e7546f1c60c8d36c219bec7084264360be54a8be30ae1",
@@ -116,8 +116,8 @@
     "schemas/v2/artifact.schema.json": "85b9dc284d39b99d2a66fa8cbf47f2dd3d8526d3bd6cc411ad315b372de38975",
     "schemas/v2/audit-verify-result.schema.json": "a748dfadb5155adfde8a91045e76b0db6695005fe559035d71670fdd55edb3ba",
     "schemas/v2/budget-policy.schema.json": "c7449daeb6e1d95e7a047b8c2814d3d54748697c27046972834874867d9b5f4c",
-    "schemas/v2/capabilities.schema.json": "0b895f892c4f29317782a81dd2c6ca6f90de972d99248d65d5eb0c3ab96e1b5d",
-    "schemas/v2/certification-bundle.schema.json": "9caf701cf991644aeb3a95beedd4acdef0b3fb351c41b0eaaa804e658af75642",
+    "schemas/v2/capabilities.schema.json": "79ddbbda4686fe66ec5b0aaf9bafb2385e2f8ccbb1ee39087d75cef9fd1f1628",
+    "schemas/v2/certification-bundle.schema.json": "cb8ddf29a008b1c2e731fd61f855bf072790b700e458c702c40434b6fd47ba73",
     "schemas/v2/channel-presence-payload.schema.json": "4eeb224910e6f7eee3ab5e7c3899559c25c83a26d0022e0ad195c4672611977a",
     "schemas/v2/channel-written-payload.schema.json": "ccecff3c71a3275ad8db035ac0e04db25e6f8d23cf091ddbcd5a60d1be1cbb6b",
     "schemas/v2/chat-card-pack-manifest.schema.json": "f7cf09b30d3e1d2251620d84ea9f65541438d015ab44aec10d1dcfe68d8bd496",
@@ -204,38 +204,38 @@
     "schemas/workspace-file.schema.json": "464de85c2a068243084ee9c1d969bc7cd5d8f7948574e58450d6493c38a0e1e4",
     "spec/v1/alias-detectors.json": "2401fcb1c18cdd688c018b3d716ae6bca85c5e356220ee2b793bd9d81872412d",
     "spec/v1/capability-declaration-classes.json": "e7729aed5c4b4e1dd02abab0530f14cc95f5d4070fe51fb139e7f5cccefa00c6",
-    "spec/v1/core-standard-manifest.json": "99e982c47f276fd0acd7791ed80bedf815c13ec2b9ca74a4e97b53e30d77f7d7",
+    "spec/v1/core-standard-manifest.json": "c92119aa65b12b7f670cc59e7768177d20f8f47173e7fbd15c3b0a6ef340810a",
     "spec/v1/deprecations.json": "2d03f4729810280147ea08c630ea65434f2dc5370567d0aac41c3595f8337d40",
     "spec/v1/deprecations.schema.json": "3e393c405d2a41b467d8c5e3c468549078df1ce6a6d2588fc488097b95d9b55b",
     "spec/v1/event-codemap.json": "3da60d884157793a360da532a9fcbbfb5285636db325a74cec94b34622186d97",
     "spec/v1/event-codemap.schema.json": "d05933b2e88103aff51a2f774df97b9bda065e0fc88dbd9b114cc47a32189174",
     "spec/v1/extensions.json": "79a60754aa16cbdbdb604f8e5c00038af535a1690a4d07bd5ff7c38f0256a7bc",
-    "spec/v1/gaps.json": "3002e1a77b9011de98e6e1178fbb934059794b0bcecd09519ea127331ae99073",
+    "spec/v1/gaps.json": "c20fe027514c8778b34c8fadde8bc7d1db5c4034638d76d297cc89a5bcae7ba2",
     "spec/v1/gaps.schema.json": "8fd83259f556553c9df0f53e7a82ca8c2a4771d471197f69b4e2ae0ceeacfd66",
     "spec/v1/migrations.json": "8839497d6a4830b53fa7867014a8336f0d725ef2346352e54fb580b7947897af",
     "spec/v1/migrations.schema.json": "886779aa6c22e646db097f5df210adb018a4dd14a7b815465a18c8a7056c8f72",
-    "spec/v1/operation-path-manifest.json": "5f5f4e3842669371730ebbd1aace3fb794192615f0018dc144f484ba5db82ac3",
-    "spec/v1/spec-gaps.json": "eb3bfcb9c7d05c9a6845d4a40ec9493cfaa5a671932daf1af561310136fdabe8",
+    "spec/v1/operation-path-manifest.json": "968c2fceb27cf76acbb14f7d250798f913bbbd3e9789dd3fb2a32c1ef536e771",
+    "spec/v1/spec-gaps.json": "ea9612af55bea9dae3e82223d4f714243f8f590b0193f1188257b13491a38afc",
     "spec/v2/README.md": "ccfed7d978ce7293a6d8f3c0f6045835dfb7e488f2b67a68f6b04d67c4b0cfc9",
     "spec/v2/core/capabilities.md": "e22381fed3a93376ad478fa7f07571fdad9653aefd7c05f189a2ef45a49f6c63",
-    "spec/v2/core/conformance.md": "4998af6d64dd6073a396715b5d91476304041dc1493a82885c6c91f098e28e81",
+    "spec/v2/core/conformance.md": "975bf95049247530d723e81051b6e64bd2a1f9d150183dec391cae48e35af7cc",
     "spec/v2/core/connection-packs.md": "7257339a4fc125011bf89961588c949cb058a0c0f7d9808ad08a5288deb3f8fc",
     "spec/v2/core/conversation.md": "c9a937e410fdb4e092cec2f05a7cab8b5232745090cfb20041c03c70ccbb5cdc",
-    "spec/v2/core/errors.md": "0210177647748efc5fe9affe29a9029152c4f983248ca88c6375601d7e636591",
-    "spec/v2/core/events.md": "ee0f7d2cff5bfa29c38b77f73269d7d755b8036cb1a5c7b08f02de92c54f3490",
+    "spec/v2/core/errors.md": "619cd74381c41acf33d012eb1afd834e148ac292663a1a6fa6744dbaff9661d9",
+    "spec/v2/core/events.md": "3df1866a89fb765c78adf79b8d51f96c59584dee9aa88d59179b88a681d827da",
     "spec/v2/core/form-content-packs.md": "55ea021b5f676f5851f420b3597262fbf6642108bddeb726922f8c5dd96c968b",
-    "spec/v2/core/headers.md": "c0e954d08e777e43816fbbabca61f303b78db09596b878d818b7a5022a1b6e7c",
+    "spec/v2/core/headers.md": "38c03524e3aeea30862432d203faffb8b0b05ec65136d223e96ab06941c3717b",
     "spec/v2/core/host-services.md": "c3ff93201d642edf835e9ae84f06a17edd207f9d351f8bfd70572be05bbfd894",
-    "spec/v2/core/idempotency.md": "a8492ec66569c00f6f559b75b80d93adbbc0e964a24e8dfedfe4057e47d69a9f",
+    "spec/v2/core/idempotency.md": "b61d4a200526485937897dd7ebca092e68424a80624e0be7a0b7db8cdbd54403",
     "spec/v2/core/identity.md": "d15667552019f64316be9b65c6e5696c10766581405f05da3907fb47f36e6459",
-    "spec/v2/core/interop.md": "5b7d2742eef309b1590b8d6690e5435b00c2ce6b395284684e3591cb9ed47bab",
-    "spec/v2/core/interrupt.md": "e0199472da7d0412721ab487a07c82fe78cbc9b60612bfcfc3cb876dc1a8c96f",
+    "spec/v2/core/interop.md": "ec8239d6d430e0d6df4db51d23bcbbbf9bc989bdb7e487e8312a104485ab6d16",
+    "spec/v2/core/interrupt.md": "1dc94f7c791dd5a547b1abafde6a8a76acd3d2993d288057f302f57911dc83bf",
     "spec/v2/core/node-pack-runtimes.md": "c435ad506f618831b6c0a9fd9150d83a5dc6caa1e3d755b949af2ff8949f1140",
     "spec/v2/core/oauth.md": "08e558a742259e75cfb2123f4c364d238dc4c57eea1a3c25d8f420ab4dff8244",
     "spec/v2/core/overview.md": "8f9d4a68b6185664e40d226cb82d9a9270a6c6630e3db59bddff300be781947d",
     "spec/v2/core/packs.md": "3107db14f68f36f5c0d8a13a6f0b3ca9ebef7ff890b8133894bfd28a63462d9b",
     "spec/v2/core/persistence.md": "d32736bd74e51df7c552565b4105a8ec801ece6d2292c8676421368ee9bffec1",
-    "spec/v2/core/replay.md": "1166ea8dc73f825b3fd1ef083085eea72cc2a2663b5939a61d1c69d8466991b3",
+    "spec/v2/core/replay.md": "c0412290c805231f5b975acc0c094465c627cd600abec34efa034cbf0a4520cf",
     "spec/v2/core/runs.md": "c7dcc5116648f42cadecdcd4c949b194272908cbc4b1fbc7321956d5b3a713af",
     "spec/v2/core/security-defaults.md": "b54c055bea0a3c5417751a7423e390ef59b5f9acd6911f1b4b754e1a4578e7e2",
     "spec/v2/core/tool-catalog.md": "35f1a3fd509db0fc0490ddf400686fe94dc4b20c98064d5ebe776da516153e60",
@@ -246,7 +246,7 @@
     "spec/v2/corrections.schema.json": "4ac595b9a6d7f66d53de03fe0edbe0dc58de46426932387bfdc0ceb3cf949a3e",
     "spec/v2/declaration.json": "84bd247804e625b0a5d66f2011726626e8a9b21e55c479cc9ba239e6b5c358a6",
     "spec/v2/declaration.schema.json": "881c08b455aa12c41a0a0ec43a960ab78b75ff1302188f7eaaa43074ed4cff7a",
-    "spec/v2/errors.json": "769e77369aa9bae7ba9c3728fc8ce04795d20ca4baa2a22056b70d0f5a2c4801",
+    "spec/v2/errors.json": "287a8bb487be96a2938b2101dd737ee87336440b3777a37dd44954726ed891b1",
     "spec/v2/event-codemap.json": "37869a03cdfd8758b57e6f350641a6ebbd383231cebda51f5473ad85f94ab74c",
     "spec/v2/event-codemap.schema.json": "b173f2a9bcc0bf9b62a474ce3b91e1431d597e64fd1560fc58662cd8606eaf9c",
     "spec/v2/ext/README.md": "ff91a503e0795e1b898e37d9e445add2d5975529723f7b32b2599b60a24c1ae3",
@@ -273,7 +273,7 @@
     "spec/v2/facets/auth.schema.json": "668f183fc15a6fb058c53635d3457db5a821f551a90141d08676a7a28917b0a9",
     "spec/v2/facets/envelopeStrictness.schema.json": "28be0a27f880bd45ec1222a16155f5e9167bbca57bf0322970fe1eb2654562aa",
     "spec/v2/facets/heartbeat.schema.json": "81d7fa1895a8b0241bd07cf00a7e7905bef0fd14eb3427325261c62eee5746a6",
-    "spec/v2/facets/interrupt.schema.json": "3cc228b9bee48922b22bd6b0bee1a3244dc83d377a616cfb523435368da11ebb",
+    "spec/v2/facets/interrupt.schema.json": "2110ef32c3f880bf706475ef4cf8ddf97ff06871b8e6003a5edbcf4439f1fb70",
     "spec/v2/facets/mcp.schema.json": "7060657dfcff170f079beed160e3db7c1d3cc4410cd3cf64863baf6459f781cd",
     "spec/v2/facets/oauth.schema.json": "3a0cbe249d3bd5a5982349ae7ba2534776cc958e4a57e0fbeabf2bdab6e99e69",
     "spec/v2/facets/packs.schema.json": "d544a280419c0052ce0f3c3b378f7aa04085cadc31df52a3c8f43da600b131b1",
@@ -285,16 +285,16 @@
     "spec/v2/facets/webhooks.schema.json": "2fac635ee5fbc10a14a1a46cf512a11bac660bfbabe0aea79f6c7b657ecb9e4e",
     "spec/v2/facets/workflowChainPacks.schema.json": "ea625ce818fbeb746478f00f31f96ee9613d538e4409c258c1bfb517acdeaba9",
     "spec/v2/id-field-bindings.json": "9f6fd280250447e26a6704811c352bb8f2ff6c4bd242befe3da0ba38962370e9",
-    "spec/v2/interop-map.json": "245bae77503ceba332436ff48054c4de63a414dc02ada4bc3f083740615c6986",
-    "spec/v2/interop-map.schema.json": "4997f4b877495e6884c525e95b85bf0011aa1b498506a49510d8bb890594ca0d",
+    "spec/v2/interop-map.json": "a6bddce7f774f26ed178d2dd2e7268251acc9b1c9119e53dac116aa9c4fb2da0",
+    "spec/v2/interop-map.schema.json": "0017c882df34ee215e2e0729de051490e09d43aac3d2c949285698ed51832f12",
     "spec/v2/migrations.json": "651954938a1e154c0b6f1e3dd6e105889d30de3bb65789f21de7f77a12869e9e",
     "spec/v2/migrations.schema.json": "b91ade6320ad1b1185c9495b9424f3aa63438ed8e412c45171c227d82c0afd86",
     "spec/v2/path-manifest.json": "ae9b56d03a701061fd48ad0b73cb0373493f6a4547da92763b422295b5e19535",
     "spec/v2/peer-dependency-aliases.json": "d10299280abee08258502925bc327293ee413e0108cd6e6ec75ff6110653308d",
     "spec/v2/profiles.json": "0636f19fceae625390003a347e70ef4797d84766b5c24ce8a02cea52aadebca4",
-    "spec/v2/release.json": "39087f64480a257ee2996f153c8530e6250480bfe7d8b9d12c17156b85faa32a",
+    "spec/v2/release.json": "9422440ed08e9d8ff3e8190c3e91e862025fa8b5b49d468a536806f5a841ac13",
     "spec/v2/retention-floors.json": "eaf3722d95c79947af1d4269ef85117e126518c588cfcf1a2b21b97269f51624",
-    "spec/v2/surface-baseline.json": "efdb4e5e0eb16689e20dea2be6f326971bb5707990c31896ca4cf24c6a5bbfed"
+    "spec/v2/surface-baseline.json": "13cfe5c31c3727a2e36980aa3e5a42f8ce1474b35beb99c5b71f487db006e71a"
   },
-  "corpusCommit": "21f518e4e2af1d10280fc121789bc97837a3b009"
+  "corpusCommit": "0d370019eaaa841491be58d196e6d7a6934c71f0"
 }

package/src/lib/a2a-error-info.ts

@@ -0,0 +1,44 @@
+/**
+ * RFC 0211 — reading an A2A 1.0 error's details.
+ *
+ * A2A v1.0.1 §9.5: a JSON-RPC error's `data` is an ARRAY of ProtoJSON `Any`
+ * objects, each carrying `@type`; §10.6/§11.6 name `google.rpc.ErrorInfo`
+ * (`reason` UPPER_SNAKE without the `Error` suffix, `domain`
+ * `a2a-protocol.org`, `metadata` a `map<string,string>`). The v2 profile makes
+ * the ErrorInfo entry a MUST on the JSON-RPC binding (`interop.md`
+ * §"The operation mappings", A2A error details).
+ */
+
+export const ERROR_INFO_TYPE = 'type.googleapis.com/google.rpc.ErrorInfo';
+export const A2A_ERROR_DOMAIN = 'a2a-protocol.org';
+
+export interface ErrorInfo { reason?: unknown; domain?: unknown; metadata?: unknown }
+
+/** The ErrorInfo entries of an upstream-shaped `data` array (empty when `data` is not an array). */
+export function errorInfos(data: unknown): ErrorInfo[] {
+  if (!Array.isArray(data)) return [];
+  return data.filter((x): x is Record<string, unknown> => typeof x === 'object' && x !== null && (x as Record<string, unknown>)['@type'] === ERROR_INFO_TYPE) as ErrorInfo[];
+}
+
+/**
+ * The normalised details of an error, for comparing two answers (RFC 0211 §D):
+ * per element `@type`, `reason`, `domain` and the sorted metadata keys, with an
+ * echo of the requested id removed. Comparing `Object.keys(data)` instead is
+ * vacuous: a one-element array has keys `["0"]` whatever it discloses.
+ */
+export function normaliseErrorData(data: unknown, requestedId?: string): Array<Record<string, unknown>> {
+  if (!Array.isArray(data)) return [{ notAnArray: typeof data, keys: data && typeof data === 'object' ? Object.keys(data as object).sort() : [] }];
+  return data.map((x) => {
+    const e = (typeof x === 'object' && x !== null ? x : {}) as Record<string, unknown>;
+    const md = (typeof e['metadata'] === 'object' && e['metadata'] !== null ? e['metadata'] : {}) as Record<string, unknown>;
+    const keys = Object.keys(md).filter((k) => !(requestedId !== undefined && md[k] === requestedId)).sort();
+    return { type: e['@type'], reason: e['reason'], domain: e['domain'], metadataKeys: keys };
+  });
+}
+
+/** True when a body is the OpenWOP error envelope `{ error: "<code>", message }` (schemas/v2/error-envelope.schema.json). */
+export function isOpenwopEnvelope(body: unknown): boolean {
+  if (typeof body !== 'object' || body === null) return false;
+  const b = body as Record<string, unknown>;
+  return typeof b['error'] === 'string' && typeof b['message'] === 'string' && !('jsonrpc' in b);
+}

package/src/lib/a2a-fake-peer.ts

@@ -38,8 +38,9 @@
  * @see https://a2a-protocol.org/v0.3.0/specification
  */
 
-import { resolvePublicFront } from './webhook-receiver.js';
-import { createServer, type Server } from 'node:http';
+import { randomBytes } from 'node:crypto';
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from 'node:http';
+import { frontedEndpoint, registerBehindFront, routeFronted, unregisterBehindFront } from './front-mux.js';
 import type { AddressInfo } from 'node:net';
 
 export type A2ATaskState =
@@ -138,13 +139,30 @@ export interface A2APeerInvocation {
   readonly headers: Readonly<Record<string, string>>;
 }
 
+/**
+ * A2A 1.0.1 §9.5: a JSON-RPC error's `data` is an ARRAY of ProtoJSON `Any` objects,
+ * each carrying `@type`; §10.6/§11.6 name `google.rpc.ErrorInfo` with the error type in
+ * UPPER_SNAKE (no "Error" suffix) as `reason` and `a2a-protocol.org` as `domain`.
+ * `ErrorInfo.metadata` is `map<string,string>`, so list values travel comma-joined.
+ * Through suite 2.36.1 this peer emitted a bare `{ reason, domain }` object, a shape no
+ * upstream SDK sends (a2a-js 1.2.0 and a2a-python 1.1.5 both send the array).
+ */
+export function a2aErrorInfo(reason: string, metadata: Record<string, string> = {}): Array<Record<string, unknown>> {
+  const info: Record<string, unknown> = { '@type': 'type.googleapis.com/google.rpc.ErrorInfo', reason, domain: 'a2a-protocol.org' };
+  if (Object.keys(metadata).length > 0) info['metadata'] = metadata;
+  return [info];
+}
+
 export class A2AFakePeer {
   private _server: Server | null = null;
   private _boundPort = 0;
+  /** This fake's path segment behind a shared public front (`lib/front-mux.ts`). */
+  private readonly _nonce = randomBytes(9).toString('hex');
   private readonly _tasks = new Map<string, A2ATask>();
   private readonly _invocations: A2APeerInvocation[] = [];
   private _nextStateOverride: A2ATaskState | null = null;
   private _nextPeerAssertsAuthority = false;
+  private _legacyErrorData = false;
   private _taskIdCounter = 0;
   private readonly _protocolVersions: readonly A2AProtocolVersion[];
 
@@ -168,19 +186,26 @@ export class A2AFakePeer {
 
   async start(port: number = 0): Promise<void> {
     return new Promise((resolve, reject) => {
-      const server = createServer((req, res) => {
+      const dispatch = (req: IncomingMessage, res: ServerResponse): void => {
         this._handle(req, res).catch((err) => {
           if (!res.headersSent) {
             res.writeHead(500, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({ error: String(err) }));
           }
         });
+      };
+      // Whichever fake owns the pinned port also carries every other fake's
+      // nonce-pathed traffic (`lib/front-mux.ts`) — ask that first.
+      const server = createServer((req, res) => {
+        if (routeFronted('OPENWOP_A2A_FAKE_PEER_URL', req, res)) return;
+        dispatch(req, res);
       });
       server.on('error', reject);
       server.listen(port, '127.0.0.1', () => {
         const addr = server.address() as AddressInfo;
         this._server = server;
         this._boundPort = addr.port;
+        registerBehindFront('OPENWOP_A2A_FAKE_PEER_URL', this._nonce, dispatch);
         resolve();
       });
     });
@@ -190,6 +215,7 @@ export class A2AFakePeer {
     if (!this._server) return;
     const server = this._server;
     this._server = null;
+    unregisterBehindFront('OPENWOP_A2A_FAKE_PEER_URL', this._nonce);
     return new Promise((resolve, reject) => {
       server.close((err) => (err ? reject(err) : resolve()));
     });
@@ -208,7 +234,23 @@ export class A2AFakePeer {
    * fixed port to forward to.
    */
   hostFacingEndpoint(): string {
-    return resolvePublicFront('OPENWOP_A2A_FAKE_PEER_URL', this.endpoint()).url;
+    return frontedEndpoint('OPENWOP_A2A_FAKE_PEER_URL', 'OPENWOP_A2A_FAKE_PEER_PORT', this.endpoint(), this._boundPort, this._nonce);
+  }
+
+  /**
+   * RFC 0211 §F: answer errors with the pre-2.37.0 bare `{ reason, domain, metadata }`
+   * object instead of the upstream `Any[]`, so a scenario can hold a host's A2A client
+   * to reading BOTH shapes through 2.x. Cleared by `reset()`.
+   */
+  setLegacyErrorData(on: boolean): void {
+    this._legacyErrorData = on;
+  }
+
+  private _errorData(reason: string, metadata: Record<string, string>): unknown {
+    const arr = a2aErrorInfo(reason, metadata);
+    if (!this._legacyErrorData) return arr;
+    const { ['@type']: _t, ...rest } = arr[0]!;
+    return rest;
   }
 
   reset(): void {
@@ -216,6 +258,7 @@ export class A2AFakePeer {
     this._invocations.length = 0;
     this._nextStateOverride = null;
     this._nextPeerAssertsAuthority = false;
+    this._legacyErrorData = false;
     this._taskIdCounter = 0;
   }
 
@@ -436,15 +479,15 @@ export class A2AFakePeer {
           error: {
             code: A2A10_ERR.VERSION_NOT_SUPPORTED,
             message: `A2A protocol version ${requested} is not supported by this agent`,
-            data: { reason: 'VERSION_NOT_SUPPORTED', domain: 'a2a-protocol.org', requested, supportedVersions: [...this._protocolVersions] },
+            data: this._errorData('VERSION_NOT_SUPPORTED', { requested, supportedVersions: this._protocolVersions.join(',') }),
           },
         });
         return;
       }
       const version: A2AProtocolVersion = requested as A2AProtocolVersion;
       const ok = (result: unknown) => json(200, { jsonrpc: '2.0', id: rpcId, result });
-      const err = (code: number, message: string, reason: string, extra: Record<string, unknown> = {}) =>
-        json(200, { jsonrpc: '2.0', id: rpcId, error: { code, message, data: { reason, domain: 'a2a-protocol.org', ...extra } } });
+      const err = (code: number, message: string, reason: string, metadata: Record<string, string> = {}) =>
+        json(200, { jsonrpc: '2.0', id: rpcId, error: { code, message, data: this._errorData(reason, metadata) } });
 
       if (version === '1.0') {
         // ── A2A 1.0 JSON-RPC binding (spec §9.4) ──

package/src/lib/effect-receiver.ts

@@ -0,0 +1,135 @@
+/**
+ * The suite's own destination for ONE staged outbound effect — the oracle RFC
+ * 0158 §C's exactly-once claim is counted at.
+ *
+ * ── Why this file exists (2.37.0) ────────────────────────────────────────────
+ * Two scenarios stage the SAME host seam (`POST /host/durability/kill`,
+ * `mode=duplicate-delivery`) and each counted arrivals at its own copy of a
+ * receiver: `v2-durability-recovery.test.ts` (`0158.duplicate-delivery`) and
+ * `v2-terminal-event-once.test.ts` (`0194.terminal-once.duplicate-delivery`).
+ * Both handed the seam the SAME destination — `resolveRegistrationUrl(...)`,
+ * which on a tunnelled cut returns `OPENWOP_WEBHOOK_RECEIVER_URL` verbatim, a
+ * byte-identical string for every caller.
+ *
+ * An outbound effect's Layer-2 identity is its BUSINESS identity — tenant,
+ * workflow, node, request digest, and no runId (`spec/v1/idempotency.md`
+ * §"Layer 2 Keying"; RFC 0150 §B). Two exercises that stage the same fixture at
+ * the same URL therefore have the SAME effect identity, and a conformant host
+ * MUST resolve the second one to the first one's recorded outcome instead of
+ * calling out again. Measured on the v2 reference host: exercise 1 landed one
+ * arrival; exercise 2, identical URL, landed ZERO and its ledger row read
+ * `invocationId: "deduplicated-of:<run 1>"`.
+ *
+ * So whichever of the two legs vitest happened to run SECOND observed zero
+ * arrivals — `blocked` on loopback, and a hard `executed-fail` on a tunnelled
+ * cut, where zero deliveries must never read as a pass. Nothing about the host
+ * changed between runs; only the file order did. That is a suite defect: the
+ * row measured cross-exercise deduplication (correct behaviour) instead of the
+ * within-exercise exactly-once RFC 0158 §C actually states.
+ *
+ * The fix is here rather than in either scenario, because two copies of a
+ * receiver are what let the two legs collide in the first place: every
+ * destination this helper mints carries a fresh NONCE in its path, so every
+ * exercise has its own effect identity by construction, and each receiver
+ * counts ONLY the arrivals bearing its own nonce. A stale retry aimed at a
+ * shared front can no longer be counted as this exercise's second fire, and a
+ * sibling leg can no longer consume this exercise's identity.
+ *
+ * @see spec/v1/idempotency.md §"Layer 2 Keying"
+ * @see RFCS/0158-durable-execution-and-disaster-recovery-qualification.md §C
+ */
+
+import { randomBytes } from 'node:crypto';
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from 'node:http';
+import { receiverBinding, resolveRegistrationUrl } from './webhook-receiver.js';
+
+export interface EffectArrival {
+  /** The request line's path, as the host addressed it. */
+  readonly path: string;
+  readonly method: string;
+  readonly at: number;
+  /** False when the path carried some other exercise's nonce (or none). */
+  readonly mine: boolean;
+}
+
+export interface EffectReceiver {
+  readonly server: Server;
+  /** The destination handed to the host: the public front when one is wired, else the local address. */
+  readonly url: string;
+  /** True when `url` is an operator-supplied public front rather than this listener's address. */
+  readonly tunnelled: boolean;
+  /** The local address this listener actually answers on — for failure detail. */
+  readonly localUrl: string;
+  /** The per-exercise nonce that makes this destination, and so this effect's identity, unique. */
+  readonly nonce: string;
+  /** Arrivals bearing this exercise's nonce. THE count RFC 0158 §C asks for. */
+  arrivals(): number;
+  /** Arrivals at this listener that belong to some other exercise — reported, never counted. */
+  foreign(): number;
+  all(): readonly EffectArrival[];
+  close(): Promise<void>;
+}
+
+/**
+ * Wait until at least one arrival is observed, or `budgetMs` elapses.
+ *
+ * A blind sleep measures the host's effect LATENCY, not its exactly-once
+ * behaviour: on a loaded machine the one legitimate delivery can trail the
+ * run's terminal status by more than a fixed window, and the row then reads
+ * zero and calls a conformant host non-conformant. Waiting FOR the arrival and
+ * only then waiting OUT the quiet window keeps both halves honest — the first
+ * bound may be generous without weakening anything, because the assertion that
+ * follows is that a SECOND arrival never comes.
+ */
+export async function waitForFirstArrival(rx: EffectReceiver, budgetMs: number): Promise<number> {
+  const deadline = Date.now() + budgetMs;
+  while (rx.arrivals() === 0 && Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  return rx.arrivals();
+}
+
+/**
+ * Start a receiver for exactly one staged effect.
+ *
+ * Honours `OPENWOP_WEBHOOK_RECEIVER_PORT` so a tunnelled cut forwards here (a
+ * certification cut already runs `--max-workers 1`, so the pinned port is not
+ * contended). The nonce is in the PATH, never the port, so the destination is
+ * distinct per exercise whether the port is pinned, ephemeral, or replaced by
+ * an operator's public front.
+ */
+export async function startEffectReceiver(): Promise<EffectReceiver> {
+  const nonce = randomBytes(9).toString('hex');
+  const path = `/effect/${nonce}`;
+  const seen: EffectArrival[] = [];
+  const server = createServer((request: IncomingMessage, res: ServerResponse) => {
+    request.on('data', () => { /* drain */ });
+    request.on('end', () => {
+      const requestPath = request.url ?? '';
+      // Matched by CONTAINMENT, not equality: a TLS-terminating front may add
+      // or strip a prefix, and the nonce is what identifies the exercise.
+      seen.push({ path: requestPath, method: request.method ?? '', at: Date.now(), mine: requestPath.includes(nonce) });
+      res.writeHead(204);
+      res.end();
+    });
+  });
+  const pinned = Number(process.env['OPENWOP_WEBHOOK_RECEIVER_PORT'] ?? '');
+  const bindPort = Number.isInteger(pinned) && pinned > 0 && pinned < 65536 ? pinned : 0;
+  const binding = receiverBinding();
+  await new Promise<void>((resolve) => server.listen(bindPort, binding.bind, () => resolve()));
+  const addr = server.address();
+  const port = typeof addr === 'object' && addr ? addr.port : 0;
+  const localUrl = `http://${binding.advertise}:${port}${path}`;
+  // The front is resolved on the ORIGIN and the nonce path appended, so the
+  // per-exercise path survives a tunnel — `resolveRegistrationUrl` returns the
+  // operator's value verbatim and would otherwise drop it.
+  const front = resolveRegistrationUrl(`http://${binding.advertise}:${port}`);
+  const url = `${front.url.replace(/\/+$/, '')}${path}`;
+  return {
+    server, url, localUrl, nonce, tunnelled: front.tunnelled,
+    arrivals: () => seen.filter((a) => a.mine).length,
+    foreign: () => seen.filter((a) => !a.mine).length,
+    all: () => seen,
+    close: () => new Promise<void>((r) => server.close(() => r())),
+  };
+}

package/src/lib/front-mux.ts

@@ -0,0 +1,102 @@
+/**
+ * One public front, many suite fakes — path multiplexing behind
+ * `OPENWOP_A2A_FAKE_PEER_URL` / `OPENWOP_MCP_FAKE_SERVER_URL`.
+ *
+ * ── Why this file exists (2.37.0) ────────────────────────────────────────────
+ * An operator fronts ONE listener per fixture: the tunnel forwards the public
+ * https origin to the pinned `_PORT`, where `setup.ts` starts the shared fake.
+ * Several scenarios also construct a fake of their OWN — pinned to a protocol
+ * version the shared one does not speak (a 0.3-only peer for the floor, a
+ * 2025-06-18-only server for negotiation) or just fresh — start it on an
+ * ephemeral port, and hand the host `hostFacingEndpoint()`. Until 2.37.0 that
+ * returned the front URL verbatim, so on a tunnelled cut the host's request
+ * went through the tunnel to the SHARED fake while the scenario read its own,
+ * which had seen nothing. Two consequences, both measured on the v2 reference
+ * host:
+ *
+ *   - `0207.a2a-traceparent-carried` recorded `blocked` in every public cut
+ *     ("the suite peer received no SendMessage") — the host's A2A client had
+ *     reached the suite, just not the listener that was counting;
+ *   - the floor and authenticated-negotiation legs passed VACUOUSLY: the
+ *     refusal is forced by the seam's `peerOffersOnly` knob, and the wire check
+ *     "no below-floor call reached the peer" iterated a peer nobody called.
+ *
+ * Loopback cuts never showed it, because each fake's local address is distinct.
+ *
+ * The fix is the shape openwop#1513 used for the effect receiver: a per-fake
+ * NONCE in the path. A fake that does not own the pinned port is handed
+ * `${front}/fx/<nonce>`; whichever fake DOES own it (every fake's handler asks
+ * first) strips the prefix and dispatches to the registered instance. Every
+ * fake is then reachable through the one front, and each one counts only what
+ * was addressed to it.
+ */
+
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { resolvePublicFront } from './webhook-receiver.js';
+
+type Handler = (req: IncomingMessage, res: ServerResponse) => void;
+
+/**
+ * The path prefix a fronted nonce lives under. Exported so a caller that mints
+ * its OWN destination (`scoped-receiver.ts`, which needs the nonce
+ * unconditionally rather than only when it loses the pinned port) spells the
+ * path the same way `routeFronted` parses it.
+ */
+export const FRONT_MUX_PREFIX = '/fx/';
+const PREFIX = FRONT_MUX_PREFIX;
+const registry = new Map<string, Map<string, Handler>>();
+
+function pinnedPort(portEnv: string): number {
+  const n = Number(process.env[portEnv] ?? '');
+  return Number.isInteger(n) && n > 0 && n < 65536 ? n : 0;
+}
+
+/** Make `handler` reachable at `${front}/fx/<nonce>` through whichever fake owns the pinned port. */
+export function registerBehindFront(frontEnv: string, nonce: string, handler: Handler): void {
+  let m = registry.get(frontEnv);
+  if (!m) registry.set(frontEnv, (m = new Map()));
+  m.set(nonce, handler);
+}
+
+export function unregisterBehindFront(frontEnv: string, nonce: string): void {
+  registry.get(frontEnv)?.delete(nonce);
+}
+
+/**
+ * Dispatch a request addressed to another fake's nonce. Returns true when it
+ * did (the caller then does nothing else). The prefix is stripped so the
+ * target sees exactly the path it would have seen on its own listener.
+ */
+export function routeFronted(frontEnv: string, req: IncomingMessage, res: ServerResponse): boolean {
+  const url = req.url ?? '/';
+  if (!url.startsWith(PREFIX)) return false;
+  const rest = url.slice(PREFIX.length);
+  const slash = rest.indexOf('/');
+  const q = rest.indexOf('?');
+  const end = slash === -1 ? (q === -1 ? rest.length : q) : q === -1 ? slash : Math.min(slash, q);
+  const target = registry.get(frontEnv)?.get(rest.slice(0, end));
+  if (!target) {
+    // Addressed to a fake that has stopped (or never existed). Answer, never
+    // fall through: handling it here would count a stranger's request.
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'no suite fake is registered under this nonce' }));
+    return true;
+  }
+  const tail = rest.slice(end);
+  req.url = tail.startsWith('/') ? tail : `/${tail}`;
+  target(req, res);
+  return true;
+}
+
+/**
+ * The address to hand the host under test. No front ⇒ the local address. A
+ * front and this fake owns the pinned port ⇒ the front itself (unchanged from
+ * before 2.37.0). A front and any other port ⇒ the front plus this fake's
+ * nonce path, which the pinned owner routes back here.
+ */
+export function frontedEndpoint(frontEnv: string, portEnv: string, localUrl: string, boundPort: number, nonce: string): string {
+  const front = resolvePublicFront(frontEnv, localUrl);
+  if (!front.tunnelled) return localUrl;
+  const base = front.url.replace(/\/+$/, '');
+  return boundPort === pinnedPort(portEnv) ? base : `${base}${PREFIX}${nonce}`;
+}