@openwop/openwop-conformance 2.45.27 → 2.45.29

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # `@openwop/openwop-conformance` Changelog
 
+## [2.45.29] — 2026-10-08 — purpose labels witnessed without a seam; RFC 0241 Accepted
+
+- **`v2-purpose-propagation-onward` witnesses purpose labels through normative operations.** New fixture `conformance-purpose-relay`: routed as the only skill of one agent's A2A card, it relays an inbound A2A message's text to the suite's fake peer through `core.conformance.a2a-invoke`. The suite labels the inbound message with `metadata.openwop.permittedPurposes`, finds the agent through `GET /agents` and `GetExtendedAgentCard`, and reads the onward label at its peer; a nonce matches each onward message to its inbound one. The §22 seam stays as the fallback, and each note names the path. A host with the fixture advertised but no card routing it, or with the suite's peer not running, records `blocked`. Self-test double: a widened label, a dropped label and a call made under `[]` each fail their leg (`lib/purpose-relay-witness.test.ts`). Proven on a seams-off v2 reference host (openwop-examples #166): both rows `executed-pass`, and each defect `executed-fail`. This replaces the planned RFC 0240: the label already arrives on a real carrier.
+- **No scenario change.** RFC 0241 goes `Accepted` on the v2 reference host's certified seams-off cut on 2.45.28; its gaps G1 and G2 close, which changes the packed `spec/v1/gaps.json`.
+
+## [2.45.28] — 2026-10-08 — two more seam-driven legs, and the backoff ratio, on a public seam-free cut
+
+- **Found by the v2 reference host's first public seams-off cut** (2.45.27, RFC 0241's evidence): all seven target rows `executed-pass`, but four other rows kept the bundle from certifying. Neither shows on a loopback cut.
+  - **`0199.mcp-url-mode` (`v2-mcp-mount-map`) and `0199.a2a-auth-required` (`v2-a2a-operation-map`):** both mint a fresh Subject through the credential mint seam, without checking for the seams profile, and recorded `blocked` when it was absent. They run only where `oauth.credentialInterrupt` is advertised, which this host does only with an https public base. Now `inapplicable` without the seams profile.
+  - **`v2-webhook-durable-delivery`, the exponential-backoff check:** it required the second retry gap to be at least 1.5x the first. Each gap also carries a constant, the receiver round trip a host waits on before scheduling the retry, so the gaps are B + c and 2B + c; through a tunnel (c ≈ 270 ms, base 500 ms) a correct host measured 1.43x. The second gap must now exceed the first by at least a quarter of it.
+- Proven on the v2 reference host: seams off with an https base, both 0199 rows `inapplicable`; the backoff leg passes on the host as is, and fails (510 ms after 604 ms) with the backoff made constant.
+
 ## [2.45.27] — 2026-10-08 — a seam-free host's seam-driven legs record `inapplicable`, not `blocked`
 
 - **Three scenarios recorded `blocked` on a host without the seams profile**, which denies the bundle certification, where the rest of the suite records a seam-driven leg `inapplicable`. Found by the v2 reference host's first seams-off cut (RFC 0241's evidence): 11 rows `blocked`, all `executed-pass` with the seams profile.

package/dist/spec-artifacts.lock.json

@@ -1,5 +1,5 @@
 {
   "package": "@openwop/spec-artifacts",
-  "version": "2.45.27",
-  "stampSha256": "0ed61d1135dbf584a64a1d1780c8919a45a4e46da25798ad095629b94b61f0a1"
+  "version": "2.45.29",
+  "stampSha256": "3ae08679281573bed1e595dd8abaff668d4ccb267cbe7bef4b3d4a86933552f9"
 }

package/fixtures/conformance-purpose-relay.json

@@ -0,0 +1,26 @@
+{
+  "id": "conformance-purpose-relay",
+  "name": "Conformance: Purpose Relay",
+  "version": "1.0",
+  "description": "security-defaults.md §Onward hops. Routed as the only skill of one agent's A2A card: an inbound A2A message starts it, and one core.conformance.a2a-invoke node sends that message's text parts on to the A2A peer the operator configured. The suite labels the inbound message with metadata.openwop.permittedPurposes and reads the onward message at its peer. See conformance/fixtures.md.",
+  "nodes": [
+    {
+      "id": "relay",
+      "typeId": "core.conformance.a2a-invoke",
+      "name": "Relay the inbound message",
+      "position": { "x": 0, "y": 0 },
+      "config": {
+        "skill": "echo",
+        "forward": "inbound-message"
+      },
+      "inputs": {}
+    }
+  ],
+  "edges": [],
+  "triggers": [
+    { "id": "manual", "type": "manual", "enabled": true }
+  ],
+  "variables": [],
+  "metadata": { "tags": ["conformance", "a2a", "purpose-propagation"] },
+  "settings": { "timeout": 30000 }
+}

package/fixtures.md

@@ -44,6 +44,7 @@ All fixtures MUST advertise:
 | ----------------------------------------- | ----------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- | ---------------------------- |
 | Noop                                      | `conformance-noop`                                                                              | Cheapest possible run-lifecycle test                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `completed`                                                                         | ≤ 5s                         |
 | Nondeterminism Sources | `conformance-nondeterminism` | RFC 0237 §D — one `core.conformance.nondeterminism` node draws one value per source the host lists in `nondeterminismPolicy.sources` into the run outputs; a `replay` fork from `fromSeq: 0` MUST reproduce each | `completed`; replay outputs byte-equal per listed source | ≤ 10s |
+| Purpose Relay | `conformance-purpose-relay` | `security-defaults.md` §Onward hops — the only skill of one agent's A2A card; one `core.conformance.a2a-invoke` node sends the inbound message's text on to the configured peer, re-emitting its `permittedPurposes` label | `completed`, or `failed` when the label is `[]` | ≤ 30s |
 | Identity                                  | `conformance-identity`                                                                          | Verifies input/output passthrough                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `completed`                                                                         | ≤ 5s                         |
 | Delay                                     | `conformance-delay`                                                                             | Verifies poll/SSE behavior over time                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `completed`                                                                         | ≤ 30s (input-controlled)     |
 | Failure                                   | `conformance-failure`                                                                           | Verifies error-event surface                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `failed`                                                                            | ≤ 5s                         |
@@ -160,6 +161,14 @@ The `messages`-mode stream fixture (AI token streaming) is covered by the determ
 - **Expected behavior**: the run reaches `completed`, and `run.completed.outputs` carries one string per listed source. A `replay` fork with `fromSeq: 0` reaches `completed` with byte-equal outputs for every listed source.
 - **Advertise only if** the host lists `nondeterminismPolicy.sources` and records the drawn values. Consumed by `v2-nondeterminism-sources`.
 
+### `conformance-purpose-relay`
+
+- **Purpose**: witness `security-defaults.md` §Onward hops through normative operations: the label arrives on a real carrier (an inbound A2A message's `metadata.openwop.permittedPurposes`) and leaves on a real onward hop. No seam.
+- **Shape**: one node, `relay` (`core.conformance.a2a-invoke`, the reserved typeId `conformance-a2a-task-roundtrip` uses), with `config.forward: "inbound-message"`: it sends the text parts of the A2A message that started the run, unchanged, to the A2A peer the operator configured (the suite's fake peer, `OPENWOP_A2A_FAKE_PEER=true`).
+- **Routing**: the host routes this workflow as the only skill (`skills[].id` = `conformance-purpose-relay`) of one agent in the caller's `GET /agents` inventory, reached through that agent's `a2aTenant` (`interop.md` §Per-agent cards). It is never a skill of the host card, which keeps `conformance-approval` as its one skill.
+- **Expected behavior**: an inbound `SendMessage` to that agent starts one run. With no label, or a non-empty one, the peer receives one `SendMessage` whose text parts equal the inbound ones and, when labelled, whose `metadata.openwop.permittedPurposes` is a subset of the received label. With `[]`, the peer receives nothing; the run's terminal status is the host's.
+- **Advertise only if** the host advertises `purposePropagation` with an onward hop, the `a2a-1.0` profile and `a2a.agentCards`, and its A2A client re-emits labels. Consumed by `v2-purpose-propagation-onward`.
+
 ### `conformance-noop`
 
 - **Purpose**: cheapest run-lifecycle test. Used by `runs-lifecycle.test.ts` (v1) and `v2-created-run-readable.test.ts` (v2), and by most run-surface scenarios, to verify create, read and the terminal event end-to-end.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openwop/openwop-conformance",
-  "version": "2.45.27",
+  "version": "2.45.29",
   "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.27"
+    "@openwop/spec-artifacts": "2.45.29"
   }
 }

package/requirements.json

@@ -32919,7 +32919,7 @@
     {
       "id": "openwop.it.v2-mcp-mount-map.form-mode-is-never-emitted-for-a-nested-schema-or-a-sensitive-format-password-fi",
       "file": "v2-mcp-mount-map.test.ts",
-      "line": 344,
+      "line": 345,
       "title": "form mode is never emitted for a nested schema or a sensitive (format password) field",
       "explicitId": "openwop.requirement.0199.form-mode-no-secret",
       "citations": [
@@ -35437,15 +35437,10 @@
     {
       "id": "openwop.it.v2-purpose-propagation-onward.a-received-label-is-re-emitted-on-the-onward-message-never-widened",
       "file": "v2-purpose-propagation-onward.test.ts",
-      "line": 83,
+      "line": 147,
       "title": "a received label is re-emitted on the onward message, never widened",
       "explicitId": "openwop.requirement.purpose-propagation.onward-reemit-no-widen",
       "citations": [
-        {
-          "section": "spec/v2/core/security-defaults.md §Onward hops",
-          "requirement": null,
-          "interpolated": true
-        },
         {
           "section": "spec/v2/core/security-defaults.md §Onward hops",
           "requirement": null,
@@ -35456,7 +35451,7 @@
     {
       "id": "openwop.it.v2-purpose-propagation-onward.an-empty-label-means-no-onward-call-while-an-unlabelled-control-call-goes-throug",
       "file": "v2-purpose-propagation-onward.test.ts",
-      "line": 102,
+      "line": 164,
       "title": "an empty label means no onward call, while an unlabelled control call goes through",
       "explicitId": "openwop.requirement.purpose-propagation.empty-no-onward",
       "citations": [
@@ -38110,7 +38105,7 @@
     {
       "id": "openwop.it.v2-webhook-durable-delivery.an-exhausted-delivery-is-dead-lettered-never-dropped",
       "file": "v2-webhook-durable-delivery.test.ts",
-      "line": 430,
+      "line": 435,
       "title": "an exhausted delivery is dead-lettered, never dropped",
       "explicitId": "openwop.requirement.0173.webhook-durable-delivery.dead-letter",
       "citations": [
@@ -38149,7 +38144,7 @@
     {
       "id": "openwop.it.v2-webhook-durable-delivery.the-dead-letter-read-is-served-and-its-records-carry-no-payload",
       "file": "v2-webhook-durable-delivery.test.ts",
-      "line": 539,
+      "line": 544,
       "title": "the dead-letter read is served and its records carry no payload",
       "explicitId": "openwop.requirement.0188.dead-letter-read",
       "citations": [
@@ -38162,7 +38157,7 @@
     {
       "id": "openwop.it.v2-webhook-durable-delivery.after-unregister-the-dead-letter-read-answers-404-not-found-as-for-a-subscriptio",
       "file": "v2-webhook-durable-delivery.test.ts",
-      "line": 560,
+      "line": 565,
       "title": "after unregister, the dead-letter read answers 404 not_found, as for a subscription that never existed",
       "explicitId": "openwop.requirement.0217.dead-letter-read-after-unregister",
       "citations": [
@@ -38189,7 +38184,7 @@
     {
       "id": "openwop.it.v2-webhook-durable-delivery.a-dead-letter-record-carries-no-delivered-payload",
       "file": "v2-webhook-durable-delivery.test.ts",
-      "line": 593,
+      "line": 598,
       "title": "a dead-letter record carries no delivered payload",
       "explicitId": "openwop.requirement.0188.dead-letter-content-free",
       "citations": [
@@ -38207,7 +38202,7 @@
     {
       "id": "openwop.it.v2-webhook-durable-delivery.every-logged-event-of-a-subscribed-type-reaches-a-healthy-receiver-at-least-once",
       "file": "v2-webhook-durable-delivery.test.ts",
-      "line": 688,
+      "line": 693,
       "title": "every logged event of a subscribed type reaches a healthy receiver at least once within the retry bound",
       "explicitId": "openwop.requirement.0173.webhook-delivery-complete",
       "citations": [

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.27",
-  "corpusTag": "v2.45.27",
+  "version": "2.45.29",
+  "corpusTag": "v2.45.29",
   "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": "9b9455816461b5fc267d1f9a1624667f9f6bd81d2e251731767cca142cd9d0e0",
-    "api/v2/asyncapi.yaml": "ec80cec238dcb350f741b49138ed92c9d60f110fcb8ad4bdff2cf44c83c8e1d8",
-    "api/v2/openapi.yaml": "e3cff1191d97def0575096d0ec450622a39c1126ca4baaa72c24079ab3b50774",
+    "api/seams-v2.yaml": "13a3eb746eb57dad9ffc605ea4e1e0877a0a9064d44294d0d7df892b042de1b5",
+    "api/v2/asyncapi.yaml": "f34721690c724c94a974fdd9e9972e76694900c7a9005d33ec921d3f4e2ff8bf",
+    "api/v2/openapi.yaml": "d5e63eafe148c73173da3f5b5668fa44f81bc74682818c57009a5f9c8821912e",
     "api/v2/redocly.yaml": "1e66b60e6118ad11a823bb620678be464d99dfe50a40e3e6f93ec9429b88b34c",
     "schemas/README.md": "276fc1d51eb08e14e9127b9fd27761d7046ee33c12000f3a64a801322db8bf58",
     "schemas/a2a-task-state.schema.json": "75d5049dea8bd873ff0e7546f1c60c8d36c219bec7084264360be54a8be30ae1",
@@ -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": "7e44d633d25ceae4d0d8de5462337e666c3a827c1a003e27b7005edd915fc909",
+    "spec/v1/core-standard-manifest.json": "fcfef02287da21d0337db64fa9f5ddef5a940dac8ae0ce1f92b4bb925af59237",
     "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": "a0aec8f5ddf1002d46a461a9c7d930c8f0656a19b68bb1f52d183b97cc1962cf",
+    "spec/v1/gaps.json": "d7d2d1ecf668bc5b8ae84b947cc4449f9409d5a5169be97c3740457ee0672dcf",
     "spec/v1/gaps.schema.json": "8fd83259f556553c9df0f53e7a82ca8c2a4771d471197f69b4e2ae0ceeacfd66",
     "spec/v1/migrations.json": "4c50760be70cb644d02427bcaf5749606700edf4513f423903cf3b1d12f5c300",
     "spec/v1/migrations.schema.json": "886779aa6c22e646db097f5df210adb018a4dd14a7b815465a18c8a7056c8f72",
@@ -313,9 +313,9 @@
     "spec/v2/path-manifest.json": "7b5679a4dad98c80d855361d88a98c8a4e045af15e310862a05b285b815dc9fc",
     "spec/v2/peer-dependency-aliases.json": "d10299280abee08258502925bc327293ee413e0108cd6e6ec75ff6110653308d",
     "spec/v2/profiles.json": "180beb9ef2d161766fa23b2987e7e829851e3d316273147cf6a4a3f324befd6b",
-    "spec/v2/release.json": "5edf0eb76b4b2d61addd3ebda82c0fa7cbfe9228665050da798cf1f26962cdbe",
+    "spec/v2/release.json": "d14466e510b339345c3f2be3ceaecb2b85725823e33f71d08a7262c4d0cf47bf",
     "spec/v2/retention-floors.json": "eaf3722d95c79947af1d4269ef85117e126518c588cfcf1a2b21b97269f51624",
-    "spec/v2/surface-baseline.json": "d75c8f150df9625594cb6405b603e4f6f4d0e8d0d62ce198d0028c1133e9cbfd"
+    "spec/v2/surface-baseline.json": "5bbf069900b52dd544cae741fef714f4107567eb4b21c4e32a032864feec8a46"
   },
-  "corpusCommit": "4bf2cc5a47102975d8710f50f619b3e4f1fcd9d8"
+  "corpusCommit": "ada50d896fc1edad8046f5d75ae7a5c621d689cd"
 }

package/src/lib/purpose-relay-witness.ts

@@ -0,0 +1,54 @@
+/**
+ * Purpose labels on the onward hop, judged from what the suite's A2A peer received
+ * (`spec/v2/core/security-defaults.md` §Onward hops; fixture `conformance-purpose-relay`).
+ *
+ * The scenario labels an inbound A2A message, tags its text with a nonce, and reads
+ * the peer's `SendMessage` calls. These functions find the onward message for a nonce
+ * and judge it, so a self-test double can show each defect failing its leg.
+ */
+
+/** One `SendMessage` the peer received: its JSON-RPC body. */
+export interface PeerSend { readonly body: unknown }
+
+type Msg = { parts?: unknown; metadata?: { openwop?: { permittedPurposes?: unknown } } };
+
+function messageOf(body: unknown): Msg | undefined {
+  return (body as { params?: { message?: Msg } } | undefined)?.params?.message;
+}
+
+/** The text parts of a message body, joined. A2A 1.0 `{ text }` and 0.3 `{ kind: 'text', text }` both count. */
+export function textOf(body: unknown): string {
+  const parts = messageOf(body)?.parts;
+  if (!Array.isArray(parts)) return '';
+  return parts.map((p) => (typeof (p as { text?: unknown })?.text === 'string' ? (p as { text: string }).text : '')).join('');
+}
+
+/** The onward sends carrying `nonce` in their text: the relay of one inbound message. */
+export function relaysOf(sends: readonly PeerSend[], nonce: string): PeerSend[] {
+  return sends.filter((s) => textOf(s.body).includes(nonce));
+}
+
+/** The label an onward message carries, as sent. */
+export function labelOf(body: unknown): unknown {
+  return messageOf(body)?.metadata?.openwop?.permittedPurposes;
+}
+
+export type Verdict = { ok: true } | { ok: false; reason: string };
+
+/** A received label MUST be re-emitted on the onward message, narrowing and never widening. */
+export function judgeReemit(received: readonly string[], onward: unknown): Verdict {
+  if (!Array.isArray(onward)) return { ok: false, reason: `the onward message carries no metadata.openwop.permittedPurposes (got ${JSON.stringify(onward)})` };
+  const widened = onward.map(String).filter((p) => !received.includes(p));
+  if (widened.length > 0) return { ok: false, reason: `the onward label widens the received one ${JSON.stringify(received)}: it adds ${JSON.stringify(widened)}` };
+  return { ok: true };
+}
+
+/**
+ * `[]` means no onward use. `controlRelays` is what an unlabelled control message
+ * produced: with none, a missing relay under `[]` proves nothing (`blocked`).
+ */
+export function judgeEmpty(controlRelays: number, emptyRelays: number): Verdict | 'blocked' {
+  if (controlRelays === 0) return 'blocked';
+  if (emptyRelays > 0) return { ok: false, reason: `the peer received ${emptyRelays} message(s) relaying the []-labelled data` };
+  return { ok: true };
+}

package/src/scenarios/v2-a2a-operation-map.test.ts

@@ -38,7 +38,7 @@ import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { softSkip } from '../lib/soft-skip.js';
 import { SCHEMAS_DIR } from '../lib/paths.js';
 import { req } from '../lib/requirement-ids.js';
-import { SEAMS_PREFIX } from '../lib/seams.js';
+import { SEAMS_PREFIX, seamsProfileAdvertised } from '../lib/seams.js';
 import { unservedDestination } from '../lib/scoped-receiver.js';
 import { errorInfos, normaliseErrorData, isOpenwopEnvelope, A2A_ERROR_DOMAIN } from '../lib/a2a-error-info.js';
 
@@ -513,6 +513,7 @@ describe('RFC 0208 — v2-a2a-operation-map (host as A2A 1.0 server, gated on a2
     const oauth = await familyAdvertised('oauth');
     if (oauth?.['credentialInterrupt'] !== true) return softSkip('inapplicable', 'oauth.credentialInterrupt is not advertised — the host raises no credential interrupt to project (RFC 0199 §C.1)');
     if (!isFixtureAdvertised('conformance-credential')) return softSkip('blocked', 'fixture conformance-credential is not in the advertised fixtures[]');
+    if (!seamsProfileAdvertised(await v2Discovery().catch(() => null))) return softSkip('inapplicable', 'a fresh Subject is minted through the seams profile (credential mint seam) — conformance.seamsProfile is not openwop-conformance-seams-v2');
     // A fresh Subject, so no credential another scenario acquired satisfies the node.
     const minted = await driver.post(`${SEAMS_PREFIX}/sample/auth/credential/mint`, { lane: 'api-key' }).catch(() => null);
     const bearer = (minted?.json as { credential?: unknown } | undefined)?.credential;

package/src/scenarios/v2-mcp-mount-map.test.ts

@@ -34,7 +34,7 @@ import { loadEnv } from '../lib/env.js';
 import { softSkip } from '../lib/soft-skip.js';
 import { SCHEMAS_DIR } from '../lib/paths.js';
 import { req } from '../lib/requirement-ids.js';
-import { SEAMS_PREFIX } from '../lib/seams.js';
+import { SEAMS_PREFIX, seamsProfileAdvertised } from '../lib/seams.js';
 
 export const HOST_CALLBACK_NOT_REQUIRED = 'the suite is the MCP client: every leg POSTs JSON-RPC to the mount the host advertises in mcp.serverUrls; nothing harness-hosted is handed to the host';
 
@@ -308,6 +308,7 @@ describe('RFC 0208 — v2-mcp-mount-map (host as MCP 2026-07-28 server, gated on
     if (oauth?.['credentialInterrupt'] !== true) return softSkip('inapplicable', 'oauth.credentialInterrupt is not advertised — the host raises no credential interrupt to bridge (RFC 0199 §C.1)');
     const missing = needFixtures(['conformance-credential']);
     if (missing) return softSkip('blocked', missing);
+    if (!seamsProfileAdvertised(await v2Discovery().catch(() => null))) return softSkip('inapplicable', 'a fresh Subject is minted through the seams profile (credential mint seam) — conformance.seamsProfile is not openwop-conformance-seams-v2');
     const minted = await driver.post(`${SEAMS_PREFIX}/sample/auth/credential/mint`, { lane: 'api-key' }).catch(() => null);
     const bearer = (minted?.json as { credential?: unknown } | undefined)?.credential;
     if (typeof bearer !== 'string') return softSkip('blocked', 'the credential mint seam did not mint a fresh Subject — a Subject that may already hold a credential makes the leg vacuous');

package/src/scenarios/v2-purpose-propagation-onward.test.ts

@@ -1,41 +1,53 @@
 /**
  * v2 — purpose labels on the onward hop (`spec/v2/core/security-defaults.md`
- * §Onward hops; suite 2.45.23, target major 2; seam-gated).
+ * §Onward hops; suite 2.45.23, target major 2; relay path suite 2.45.29).
  *
  * A host advertising `purposePropagation` MUST re-emit a `permittedPurposes`
  * label it received on every onward hop of the same data, narrowing and never
- * widening, and MUST treat `[]` as no onward use. The v1 twin read a
- * self-reported forward seam; this file observes a real onward hop instead.
- * The suite plays both ends: it hands the host a label through the §22 `invoke`
- * seam (`permittedPurposes`), and its fake A2A peer receives what the host's
- * production A2A client actually sends.
+ * widening, and MUST treat `[]` as no onward use. The suite plays both ends.
  *
- *   onward-reemit-no-widen   the onward message carries
- *                            `metadata.openwop.permittedPurposes`, a subset of
- *                            the label sent;
- *   empty-no-onward          with `[]` the host makes no onward call, while an
- *                            unlabelled control call through the same seam
- *                            reaches the peer (non-arrival is evidence, not a
- *                            dead pipe).
+ * Two ways in, the first preferred:
  *
- * Not here: the derived-output rule (a merge of labelled inputs carries their
- * intersection) needs two inputs on one hop; the seam forwards one.
+ *   relay   normative operations only. The suite sends an A2A `SendMessage`,
+ *           labelled with `metadata.openwop.permittedPurposes`, to the agent whose
+ *           card routes the fixture `conformance-purpose-relay` (found through
+ *           `GET /agents` and `GetExtendedAgentCard`, `interop.md` §Per-agent
+ *           cards). The fixture relays the message's text to the suite's shared
+ *           fake A2A peer, which reads the onward label. A nonce in the text
+ *           matches each onward message to its inbound one.
+ *   seam    the §22 `invoke` seam takes `permittedPurposes` and a peer URL.
+ *
+ *   onward-reemit-no-widen   the onward message carries the label, a subset of
+ *                            the one received;
+ *   empty-no-onward          with `[]` nothing reaches the peer, while an
+ *                            unlabelled control message does (non-arrival is
+ *                            evidence, not a dead pipe).
+ *
+ * Not here: a merge of labelled inputs carrying their intersection is RFC 0128
+ * §3 text that v2 prose does not state.
  *
  * Dispositions: discovery unreadable ⇒ `blocked`; `purposePropagation` absent,
- * `propagatesOnward` false, `a2a` absent or no seams profile ⇒ `inapplicable`;
- * seam unwired ⇒ `seamAbsent`.
+ * `propagatesOnward` false or `a2a` absent ⇒ `inapplicable`; neither the relay
+ * (`a2a-1.0` + `agentCards` + the fixture advertised) nor the seams profile ⇒
+ * `inapplicable`; the fixture advertised but no card routing it, or the suite's
+ * fake peer not running ⇒ `blocked`; seam unwired ⇒ `seamAbsent`. Each note names
+ * the path used.
  *
  * @see spec/v2/core/security-defaults.md §Onward hops
+ * @see conformance/fixtures.md §conformance-purpose-relay
  * @see spec/v1/host-sample-test-seams.md §22
  */
 
 import { describe, it, expect } from 'vitest';
+import { randomBytes } from 'node:crypto';
 import { driver, type OpenWOPResponse } from '../lib/driver.js';
 import { v2Discovery, familyAdvertised } from '../lib/v2.js';
 import { SEAMS_PREFIX, seamsProfileAdvertised } from '../lib/seams.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { softSkip, seamAbsent } from '../lib/soft-skip.js';
 import { req } from '../lib/requirement-ids.js';
-import { A2AFakePeer, type A2APeerInvocation } from '../lib/a2a-fake-peer.js';
+import { A2AFakePeer, getA2AFakePeer, type A2APeerInvocation } from '../lib/a2a-fake-peer.js';
+import { relaysOf, labelOf, judgeReemit, judgeEmpty, type PeerSend } from '../lib/purpose-relay-witness.js';
 
 export const REQUIRES_HOST_CALLBACK = "the host's A2A client calls the suite's fake A2A peer";
 
@@ -43,6 +55,7 @@ const DOC = 'spec/v2/core/security-defaults.md §Onward hops';
 const ID_REEMIT = 'openwop.requirement.purpose-propagation.onward-reemit-no-widen';
 const ID_EMPTY = 'openwop.requirement.purpose-propagation.empty-no-onward';
 const SEAM = `${SEAMS_PREFIX}/sample/a2a/invoke`;
+const RELAY = 'conformance-purpose-relay';
 const LABEL = ['openwop-conformance-analytics', 'openwop-conformance-support'];
 
 async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> {
@@ -52,68 +65,120 @@ async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse
 type Skip = { kind: 'blocked' | 'inapplicable' | 'seam'; reason: string };
 const skip = (s: Skip): undefined => (s.kind === 'seam' ? seamAbsent(s.reason) : softSkip(s.kind, s.reason));
 
-async function gate(): Promise<Skip | null> {
+/** The relay agent: the host's JSONRPC 1.0 interface and the agent's routing value. */
+interface Relay { kind: 'relay'; rpcUrl: string; tenant: string; peer: A2AFakePeer }
+type Path = Relay | { kind: 'seam' };
+
+async function rpc(url: string, method: string, params: unknown): Promise<{ status: number; result?: Record<string, unknown>; error?: unknown } | null> {
+  const headers: Record<string, string> = { 'content-type': 'application/json', accept: 'application/json', 'A2A-Version': '1.0' };
+  const key = process.env['OPENWOP_API_KEY'];
+  if (key) headers['authorization'] = `Bearer ${key}`;
+  try {
+    const res = await fetch(url, { method: 'POST', headers, body: JSON.stringify({ jsonrpc: '2.0', id: randomBytes(4).readUInt32BE(0), method, params }) });
+    const body = (await res.json().catch(() => ({}))) as { result?: Record<string, unknown>; error?: unknown };
+    return { status: res.status, ...(body.result !== undefined ? { result: body.result } : {}), ...(body.error !== undefined ? { error: body.error } : {}) };
+  } catch {
+    return null;
+  }
+}
+
+/** Find the agent whose card routes the relay fixture; a Skip when the relay cannot be driven. */
+async function relayPath(a2a: Record<string, unknown>): Promise<Relay | Skip> {
+  const peer = getA2AFakePeer();
+  if (peer === null) return { kind: 'blocked', reason: `relay path: the host advertises ${RELAY}, whose onward peer is the suite's fake A2A peer, and OPENWOP_A2A_FAKE_PEER is not enabled` };
+  const cardUrl = a2a['agentCardUrl'];
+  if (typeof cardUrl !== 'string') return { kind: 'blocked', reason: 'relay path: a2a.agentCardUrl is not advertised' };
+  const card = await fetch(cardUrl, { headers: { accept: 'application/json', 'A2A-Version': '1.0' } }).then((r) => r.json() as Promise<{ supportedInterfaces?: Array<{ url?: string; protocolBinding?: string; protocolVersion?: string }> }>).catch(() => null);
+  const rpcUrl = card?.supportedInterfaces?.find((i) => i.protocolBinding === 'JSONRPC' && i.protocolVersion === '1.0')?.url;
+  if (typeof rpcUrl !== 'string') return { kind: 'blocked', reason: `relay path: the public card at ${cardUrl} lists no JSONRPC 1.0 interface` };
+  const inv = await http(() => driver.get('/agents'));
+  const agents = inv?.status === 200 ? ((inv.json as { agents?: Array<{ a2aTenant?: unknown }> } | undefined)?.agents ?? []) : [];
+  for (const a of agents) {
+    if (typeof a.a2aTenant !== 'string') continue;
+    const c = await rpc(rpcUrl, 'GetExtendedAgentCard', { tenant: a.a2aTenant });
+    const skills = (c?.result?.['skills'] as Array<{ id?: unknown }> | undefined) ?? [];
+    if (skills.length === 1 && skills[0]?.id === RELAY) return { kind: 'relay', rpcUrl, tenant: a.a2aTenant, peer };
+  }
+  return { kind: 'blocked', reason: `relay path: the host advertises ${RELAY}, but no agent in the caller's GET /agents has a card whose only skill is ${RELAY}` };
+}
+
+async function gate(): Promise<Path | Skip> {
   let doc: Record<string, unknown> | null;
   try { doc = await v2Discovery(); } catch { doc = null; }
   if (!doc) return { kind: 'blocked', reason: 'v2 discovery unreachable' };
   const pp = await familyAdvertised('purposePropagation');
   if (pp === null) return { kind: 'inapplicable', reason: 'the host does not advertise purposePropagation' };
   if (pp['propagatesOnward'] === false) return { kind: 'inapplicable', reason: 'purposePropagation.propagatesOnward is false — the host has no onward hop' };
-  if (!(await familyAdvertised('a2a'))) return { kind: 'inapplicable', reason: 'a2a not advertised — the onward hop observed here is the host A2A client' };
-  if (!seamsProfileAdvertised(doc)) return { kind: 'inapplicable', reason: 'the onward hop is driven through the §22 invoke seam — the seams profile is not advertised' };
-  return null;
+  const a2a = await familyAdvertised('a2a');
+  if (a2a === null) return { kind: 'inapplicable', reason: 'a2a not advertised — the onward hop observed here is the host A2A client' };
+  const profiles = Array.isArray(a2a['profiles']) ? (a2a['profiles'] as unknown[]) : [];
+  if (profiles.includes('a2a-1.0') && a2a['agentCards'] === true && isFixtureAdvertised(RELAY)) return relayPath(a2a);
+  if (seamsProfileAdvertised(doc)) return { kind: 'seam' };
+  return { kind: 'inapplicable', reason: `neither path is offered: the relay needs the a2a-1.0 profile, a2a.agentCards and the ${RELAY} fixture; the §22 invoke seam needs the seams profile` };
 }
 
 /** The message sends the peer received. */
 const sends = (peer: A2AFakePeer): A2APeerInvocation[] => peer.invocations().filter((i) => i.rpcMethod === 'SendMessage' || i.rpcMethod === 'message/send');
 
-function labelOf(inv: A2APeerInvocation): unknown {
-  const body = inv.body as { params?: { message?: { metadata?: { openwop?: { permittedPurposes?: unknown } } } } } | undefined;
-  return body?.params?.message?.metadata?.openwop?.permittedPurposes;
+/**
+ * Cause one onward hop of `nonce`, labelled or not. Relay: an inbound SendMessage,
+ * which blocks until the run is terminal (interop-map a2a SendMessage). Seam: §22.
+ * Returns the onward sends carrying the nonce, or a Skip.
+ */
+async function cause(path: Path, peer: A2AFakePeer, nonce: string, permittedPurposes?: string[]): Promise<PeerSend[] | Skip> {
+  if (path.kind === 'relay') {
+    const message = { messageId: `purpose-${nonce}`, role: 'ROLE_USER', parts: [{ text: `relay ${nonce}` }], ...(permittedPurposes ? { metadata: { openwop: { permittedPurposes } } } : {}) };
+    const r = await rpc(path.rpcUrl, 'SendMessage', { tenant: path.tenant, message });
+    if (r === null) return { kind: 'blocked', reason: `relay path: SendMessage to ${path.rpcUrl} failed to connect` };
+    if (r.status >= 400 && permittedPurposes?.length !== 0) return { kind: 'blocked', reason: `relay path: SendMessage answered HTTP ${r.status}` };
+  } else {
+    const res = await http(() => driver.post(SEAM, { peerUrl: peer.hostFacingEndpoint(), ...(permittedPurposes ? { permittedPurposes } : {}) }));
+    if (res === null) return { kind: 'blocked', reason: `${SEAM} unreachable (fetch failed)` };
+    if (res.status === 404 || res.status === 405) return { kind: 'seam', reason: `${SEAM} not mounted (${res.status}) — host-sample-test-seams.md §22` };
+    // The seam's onward message carries no nonce: every send after the call is its relay.
+    return sends(peer).map((i) => ({ body: i.body }));
+  }
+  return relaysOf(sends(peer).map((i) => ({ body: i.body })), nonce);
 }
 
-async function invoke(peer: A2AFakePeer, permittedPurposes?: string[]): Promise<OpenWOPResponse | Skip> {
-  const res = await http(() => driver.post(SEAM, { peerUrl: peer.hostFacingEndpoint(), ...(permittedPurposes ? { permittedPurposes } : {}) }));
-  if (res === null) return { kind: 'blocked', reason: `${SEAM} unreachable (fetch failed)` };
-  if (res.status === 404 || res.status === 405) return { kind: 'seam', reason: `${SEAM} not mounted (${res.status}) — host-sample-test-seams.md §22` };
-  return res;
-}
+const nonce = (): string => `n-${randomBytes(6).toString('hex')}`;
 
-describe('v2 purpose labels on the onward hop (security-defaults.md §Onward hops — seam-gated)', () => {
+describe('v2 purpose labels on the onward hop (security-defaults.md §Onward hops)', () => {
   it('a received label is re-emitted on the onward message, never widened', async () => {
     const g = await gate();
-    if (g) return skip(g);
-    const peer = new A2AFakePeer({ protocolVersions: ['1.0'] });
-    await peer.start();
+    if ('reason' in g) return skip(g);
+    const peer = g.kind === 'relay' ? g.peer : new A2AFakePeer({ protocolVersions: ['1.0'] });
+    if (g.kind === 'seam') await peer.start();
     try {
-      const res = await invoke(peer, LABEL);
-      if (!('status' in res)) return skip(res);
-      const sent = sends(peer)[0];
-      if (sent === undefined) return softSkip('blocked', `the seam answered ${res.status} and the suite peer received no message — the host's A2A client never reached it`);
-      const label = labelOf(sent);
-      expect(Array.isArray(label), req(ID_REEMIT, DOC, `the onward message MUST carry the received label as metadata.openwop.permittedPurposes (got ${JSON.stringify(label)})`)).toBe(true);
-      const widened = (Array.isArray(label) ? label : []).filter((p) => !LABEL.includes(String(p)));
-      expect(widened, req(ID_REEMIT, DOC, `the onward label MUST NOT widen the received one (${JSON.stringify(LABEL)}); it added ${JSON.stringify(widened)}`)).toEqual([]);
+      const relayed = await cause(g, peer, nonce(), LABEL);
+      if (!Array.isArray(relayed)) return skip(relayed);
+      const sent = relayed[0];
+      if (sent === undefined) return softSkip('blocked', `${g.kind} path: the labelled data never reached the suite peer, so there is no onward message to read`);
+      const v = judgeReemit(LABEL, labelOf(sent.body));
+      expect(v.ok ? '' : v.reason, req(ID_REEMIT, DOC, `${g.kind} path: the onward message MUST carry the received label as metadata.openwop.permittedPurposes, never widened`)).toBe('');
     } finally {
-      await peer.stop();
+      if (g.kind === 'seam') await peer.stop();
     }
   });
 
   it('an empty label means no onward call, while an unlabelled control call goes through', async () => {
     const g = await gate();
-    if (g) return skip(g);
-    const peer = new A2AFakePeer({ protocolVersions: ['1.0'] });
-    await peer.start();
+    if ('reason' in g) return skip(g);
+    const peer = g.kind === 'relay' ? g.peer : new A2AFakePeer({ protocolVersions: ['1.0'] });
+    if (g.kind === 'seam') await peer.start();
     try {
-      const control = await invoke(peer);
-      if (!('status' in control)) return skip(control);
+      const control = await cause(g, peer, nonce());
+      if (!Array.isArray(control)) return skip(control);
       const before = sends(peer).length;
-      if (before === 0) return softSkip('blocked', `the unlabelled control call answered ${control.status} but reached no peer, so a missing call under [] would prove nothing`);
-      const res = await invoke(peer, []);
-      if (!('status' in res)) return skip(res);
-      expect(sends(peer).length - before, req(ID_EMPTY, DOC, `a host MUST treat [] as no onward use: the seam answered ${res.status}, and the peer received ${sends(peer).length - before} message(s) for the []-labelled data`)).toBe(0);
+      const empty = await cause(g, peer, nonce(), []);
+      if (!Array.isArray(empty)) return skip(empty);
+      // The seam's sends carry no nonce: count what arrived after the control.
+      const emptyRelays = g.kind === 'seam' ? sends(peer).length - before : empty.length;
+      const v = judgeEmpty(control.length, emptyRelays);
+      if (v === 'blocked') return softSkip('blocked', `${g.kind} path: the unlabelled control message reached no peer, so a missing call under [] would prove nothing`);
+      expect(v.ok ? '' : v.reason, req(ID_EMPTY, DOC, `${g.kind} path: a host MUST treat [] as no onward use`)).toBe('');
     } finally {
-      await peer.stop();
+      if (g.kind === 'seam') await peer.stop();
     }
   });
 });

package/src/scenarios/v2-webhook-durable-delivery.test.ts

@@ -403,18 +403,23 @@ describe('RFC 0173 §B — webhook-durable-delivery (gated on webhooks)', () =>
         // Unfailable-leg audit (2026-09-26): `> 0 ms` alone let a host advertising
         // `backoff: exponential` that retried in a tight loop (any constant
         // spacing, even a few ms) pass. An exponential backoff MUST widen, so with
-        // three or more attempts the second gap is at least 1.5x the first (not
-        // 2x: jitter tolerance). Only the first two gaps are compared, so a host
-        // whose schedule hits its cap later is not convicted. `fixed` gets no
-        // equivalent: its base interval is not on the wire (see the comment above
-        // the `!retried` branch), so there is no floor to measure against.
+        // three or more attempts the second gap is wider than the first by at least
+        // a quarter of it. Not 1.5x: each gap also carries a constant c, the
+        // receiver round trip a host waits on before scheduling the retry, so the
+        // gaps are B + c and 2B + c, and a public cut's tunnel (c ≈ 270 ms
+        // against a 500 ms base, 2026-10-08) put a correct host at 1.43x. A
+        // constant spacing still fails: its gaps differ only by jitter. Only the
+        // first two gaps are compared, so a host whose schedule hits its cap
+        // later is not convicted. `fixed` gets no equivalent: its base interval
+        // is not on the wire (see the comment above the `!retried` branch), so
+        // there is no floor to measure against.
         if (policy.backoff === 'exponential' && times.length >= 3) {
           const gap1 = times[1]! - times[0]!;
           const gap2 = times[2]! - times[1]!;
           expect(
-            gap2,
-            req('openwop.requirement.0173.webhook-durable-delivery', 'webhooks.md §Durability', `retry attempts for ${key} MUST follow the advertised exponential backoff — the second gap (${gap2}ms) MUST be at least 1.5x the first (${gap1}ms); a constant spacing is not exponential`),
-          ).toBeGreaterThanOrEqual(1.5 * gap1);
+            gap2 - gap1,
+            req('openwop.requirement.0173.webhook-durable-delivery', 'webhooks.md §Durability', `retry attempts for ${key} MUST follow the advertised exponential backoff — the second gap (${gap2}ms) MUST exceed the first (${gap1}ms) by at least a quarter of it; a constant spacing is not exponential`),
+          ).toBeGreaterThanOrEqual(0.25 * gap1);
         }
       }
     } else {