@openwop/openwop-conformance 2.45.18 → 2.45.20

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # `@openwop/openwop-conformance` Changelog
 
+## [2.45.20] — 2026-10-05 — host events (RFC 0236 Active); `channelPresence` delivery witnessed through the §13 seam at v2
+
+- **New `v2-channel-presence-delivery` (seam-gated).** `conversation.md` now restates two RFC 0110 rules: a host advertising `channelPresence` MUST emit it, and MUST NOT deliver it to a non-member. Two legs check them through the snapshot seam, asking as the member first so an unwired seam is never read as a refusal.
+- **The §13 presence seam exists at v2.** It was never ported to `api/seams-v2.yaml`, so v2 had no way to observe presence. It gains an `observer` field; a non-member observer MUST NOT get `200`.
+- **Proof:** against a double, a leak to a non-member fails only the delivery leg, a refused member fails only the emit leg, and an unwired seam records `blocked`. No host advertises `channelPresence` at v2, so no bundle gains a blocked row.
+
+- **New `v2-host-event-delivery` (RFC 0236, seam-gated).** Six requirement ids over `/host/events` and webhooks: the envelope, ephemeral no-resume, ephemeral no-fan-out, ephemeral registration refused, the `{ hostEvent }` body, and tenant isolation (with `OPENWOP_TEST_TENANT_B_API_KEY`; `inapplicable` without it). Judged by `lib/host-event-witness.ts`.
+- **Proof:** the judges' self-test convicts each defect; a double with one defect per mode fails exactly that leg; the v2 reference host passes 6/6, and a cross-tenant frame or an accepted ephemeral registration fails only its leg there.
+
+## [2.45.19] — 2026-10-05 — a minted tenant-bound id carries no `~`; RFC 0235's registers close
+
+- **New leg `openwop.requirement.0184.mint-no-tilde`** in `v2-bound-id-path-projection`. RFC 0184 §A.2: a host MUST NOT mint a tenant-bound id containing `~`. Only the run this leg creates is checked, because ids minted earlier MUST still resolve.
+- **It bites only under a non-clean tenant.** openwop-app minted `user~3A<hash>/<id>` for personal and org tenants (app ADR 0814). No leg saw it, because the suite's key sat in the clean tenant `default`. On a clean tenant the defect still mints a clean id.
+- **RFC 0235 registers closed (packed `spec/v1/gaps.json`).** Gaps G1 (the v2 reference host's byte-exact comparison) and G2 (no certified witness) close on that host's certified 2.45.18 cut. No scenario changes.
+
 ## [2.45.18] — 2026-10-04 — `If-None-Match` per RFC 9110 (RFC 0235); corpus-only legs leave the host bundle; `.supported` leaves the v2 schemas
 
 - **Seven `v2-*-static` scenarios move to `src/coherence/`.** They read only the corpus, and `conformance.md` §Two products says such a check MUST NOT appear in a host bundle. The bundle schema now excludes their ids.

package/README.md

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

package/dist/spec-artifacts.lock.json

@@ -1,5 +1,5 @@
 {
   "package": "@openwop/spec-artifacts",
-  "version": "2.45.18",
-  "stampSha256": "ebbae5f7e2d21d3cceb270610d2c4e808e9fe98ab7b6e282960281b36fb60d1b"
+  "version": "2.45.20",
+  "stampSha256": "3fedfa905f02f5fc87e0ecea242b9485a56be19b66f7cb2e04c37d6785888604"
 }

package/package.json

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

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": 726,
-    "tests": 2754,
-    "withStableId": 2754,
+    "files": 728,
+    "tests": 2762,
+    "withStableId": 2762,
     "interpolatedTitles": 0,
-    "explicitIds": 2620
+    "explicitIds": 2626
   },
   "records": [
     {
@@ -28969,7 +28969,7 @@
     {
       "id": "openwop.it.v2-bound-id-path-projection.a-tenant-bound-id-is-readable-at-its-escaped-path-segment-links-carry-that-form",
       "file": "v2-bound-id-path-projection.test.ts",
-      "line": 51,
+      "line": 69,
       "title": "a tenant-bound id is readable at its ~-escaped path segment, links carry that form, and a malformed escape is refused",
       "explicitId": "openwop.requirement.0184.bound-id-path-projection",
       "citations": [
@@ -29013,6 +29013,20 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-bound-id-path-projection.a-tenant-bound-id-the-host-mints-for-this-run-contains-no-bites-only-when-the-cr",
+      "file": "v2-bound-id-path-projection.test.ts",
+      "line": 154,
+      "title": "a tenant-bound id the host mints for this run contains no ~ (bites only when the credential tenant is not grammar-clean)",
+      "explicitId": "openwop.requirement.0184.mint-no-tilde",
+      "citations": [
+        {
+          "section": "spec/v2/core/identity.md §5",
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
     {
       "id": "openwop.it.v2-budget-enforcement.a-budgeted-run-emits-budget-reserved-budget-threshold-crossed-and-budget-exhaust",
       "file": "v2-budget-enforcement.test.ts",
@@ -29400,6 +29414,44 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-channel-presence-delivery.a-host-advertising-channelpresence-emits-it-a-member-receives-a-closed-non-vacuo",
+      "file": "v2-channel-presence-delivery.test.ts",
+      "line": 68,
+      "title": "a host advertising channelPresence emits it: a member receives a closed, non-vacuous snapshot",
+      "explicitId": "openwop.requirement.channel-presence.advertised-emits",
+      "citations": [
+        {
+          "section": "spec/v2/core/conversation.md §channelPresence",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "spec/v2/core/conversation.md §channelPresence",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "spec/v2/core/conversation.md §channelPresence",
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-channel-presence-delivery.a-host-does-not-deliver-channel-presence-to-a-non-member",
+      "file": "v2-channel-presence-delivery.test.ts",
+      "line": 78,
+      "title": "a host does not deliver channel.presence to a non-member",
+      "explicitId": "openwop.requirement.channel-presence.non-member-not-delivered",
+      "citations": [
+        {
+          "section": "spec/v2/core/conversation.md §channelPresence",
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
     {
       "id": "openwop.it.v2-client-version-header.a-client-at-the-floor-is-not-below-it-equal-on-major-minor-the-patch-never-decid",
       "file": "v2-client-version-header.test.ts",
@@ -31454,6 +31506,67 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-host-event-delivery.an-emitted-durable-host-event-arrives-on-host-events-as-a-valid-envelope",
+      "file": "v2-host-event-delivery.test.ts",
+      "line": 122,
+      "title": "an emitted durable host event arrives on /host/events as a valid envelope",
+      "explicitId": "openwop.requirement.0236.host-event.envelope",
+      "citations": [
+        {
+          "section": "spec/v2/core/conversation.md §channelPresence",
+          "requirement": "a host advertising channelPresence MUST list channel.presence under hostEvents as ephemeral"
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-host-event-delivery.an-ephemeral-host-event-has-no-id-and-is-not-redelivered-after-last-event-id",
+      "file": "v2-host-event-delivery.test.ts",
+      "line": 136,
+      "title": "an ephemeral host event has no id: and is not redelivered after Last-Event-ID",
+      "explicitId": null,
+      "citations": []
+    },
+    {
+      "id": "openwop.it.v2-host-event-delivery.registerwebhook-refuses-an-ephemeral-host-event-type-with-400-validation-error",
+      "file": "v2-host-event-delivery.test.ts",
+      "line": 153,
+      "title": "registerWebhook refuses an ephemeral host-event type with 400 validation_error",
+      "explicitId": "openwop.requirement.0236.webhook.ephemeral-refused",
+      "citations": [
+        {
+          "section": "spec/v2/core/webhooks.md §Surfaces",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "spec/v2/core/webhooks.md §Surfaces",
+          "requirement": "the refusal code MUST be validation_error"
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-host-event-delivery.a-subscribed-durable-host-event-is-delivered-as-hostevent-signed-the-ephemeral-o",
+      "file": "v2-host-event-delivery.test.ts",
+      "line": 166,
+      "title": "a subscribed durable host event is delivered as { hostEvent }, signed; the ephemeral one is not",
+      "explicitId": "openwop.requirement.0236.webhook.host-variant",
+      "citations": [
+        {
+          "section": "spec/v2/core/webhooks.md §Surfaces",
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-host-event-delivery.a-second-tenant-receives-nothing-for-the-first-tenant-s-host-event",
+      "file": "v2-host-event-delivery.test.ts",
+      "line": 200,
+      "title": "a second tenant receives nothing for the first tenant’s host event",
+      "explicitId": null,
+      "citations": []
+    },
     {
       "id": "openwop.it.v2-i18n-negotiation.the-advertised-i18n-record-is-well-formed-and-lists-its-default-locale",
       "file": "v2-i18n-negotiation.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": 642,
+    "files": 644,
     "v1": 455,
-    "v2": 202
+    "v2": 204
   },
   "majors": {
     "a2a-1-0-agent-card.test.ts": [
@@ -1365,6 +1365,9 @@
     "v2-channel-presence-advertisement.test.ts": [
       2
     ],
+    "v2-channel-presence-delivery.test.ts": [
+      2
+    ],
     "v2-client-version-header.test.ts": [
       2
     ],
@@ -1485,6 +1488,9 @@
     "v2-header-scheme.test.ts": [
       2
     ],
+    "v2-host-event-delivery.test.ts": [
+      2
+    ],
     "v2-i18n-negotiation.test.ts": [
       2
     ],

package/schemas/CORPUS-STAMP.json

@@ -1,19 +1,19 @@
 {
   "_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.18",
-  "corpusTag": "v2.45.18",
+  "version": "2.45.20",
+  "corpusTag": "v2.45.20",
   "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": "56dabe76a0104e27ec5db429d10130c710fd6cc77f9e8c83060ac8642e1bf296",
-    "api/v2/asyncapi.yaml": "99cf46de7c1009d6a7f317a69d1746d8664db94602a3936140f5a51ad0647293",
-    "api/v2/openapi.yaml": "03618b3e70be4a916a88b344f40090e8c0477925c0a40f1447d87872f6772281",
+    "api/seams-v2.yaml": "3d62475a6e5d2f0e005aa58b95c197f8846104d8cb7753c2161d7b6948cb89b4",
+    "api/v2/asyncapi.yaml": "44ea76f380b18c54ccdb51eaa091289212cd044e656c4d97e94df7bf048972e9",
+    "api/v2/openapi.yaml": "4ebf762aabf5d25318923ac0c8a2b865e11d7e07b2a2456ab6b535d91e56da33",
     "api/v2/redocly.yaml": "1e66b60e6118ad11a823bb620678be464d99dfe50a40e3e6f93ec9429b88b34c",
-    "schemas/README.md": "bd1c00fae7b6fda506a75aff841bbdc438d4ce092642a72041203bee999b88de",
+    "schemas/README.md": "a829e3208413062388e52ab6ba714d35889c9c7645db38a290b0c4f4992cd3da",
     "schemas/a2a-task-state.schema.json": "75d5049dea8bd873ff0e7546f1c60c8d36c219bec7084264360be54a8be30ae1",
     "schemas/a2ui-surface-delta-frame.schema.json": "970d434e4fdcb925de64aaace91eb83bfbcfd8f76757a9ce9f339eda5fb3f4e8",
     "schemas/agent-deployment-transition.schema.json": "1ac987fed0f380fa5b4e9a40e8e13316e5ae42d03a0ff42db4be6273e1bfe9f4",
@@ -117,9 +117,9 @@
     "schemas/v2/artifact.schema.json": "85b9dc284d39b99d2a66fa8cbf47f2dd3d8526d3bd6cc411ad315b372de38975",
     "schemas/v2/audit-verify-result.schema.json": "14af8e9283510f0a40e48a2059c929ee44e0fc9fa3cc66a95bfbe90b17c48297",
     "schemas/v2/budget-policy.schema.json": "1de68095db0beb5c7a4be629de26e79f62ebbe748a88d46f36e768edfd1f0d68",
-    "schemas/v2/capabilities.schema.json": "c7a01b2f569139f99ba5e1a5329a42556fbd82bc743f8fd96963304395fc9ef0",
+    "schemas/v2/capabilities.schema.json": "a24c99d07971dde0e4596eba0bf5616e3df4459dc2174e8aebb2c544f964337c",
     "schemas/v2/certification-bundle.schema.json": "9a3c67860f3b0867ff4733d3f8ae0f5d5d747b815ab39b6c255589f103119fa6",
-    "schemas/v2/channel-presence-payload.schema.json": "9a5227f8bcdb2ecd6c606938c8d835781f4654b88a7a30b0d7e8cd4dde1975ad",
+    "schemas/v2/channel-presence-payload.schema.json": "fc03df0c20cc12a25f7ee6a47503a4c5931d79fe3d5ff24815e8fd7c1bcb9a87",
     "schemas/v2/channel-written-payload.schema.json": "ccecff3c71a3275ad8db035ac0e04db25e6f8d23cf091ddbcd5a60d1be1cbb6b",
     "schemas/v2/chat-card-pack-manifest.schema.json": "92a57db2fd4b2463f14ef155fef8e3f18afc78960b646459dcf32efc79ff6bf5",
     "schemas/v2/compact-tool-descriptor.schema.json": "b5c418d72082d5b713bf318212a83397e5be98e56d25ca056302b41b8dd8273b",
@@ -152,6 +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": "d2e2233d6464442c761ca985b0302c8350cabe2d694d3894f65d1696d80bdc98",
     "schemas/v2/ids.schema.json": "65cfaa193be0ca9cf48af39c18c553979e3ec1f7fc04509aaa513b322d7b7e4a",
     "schemas/v2/localized-content-language-settings.schema.json": "3c8350a178037a460f5d87466ccaf9ed5fe3d41497786d2504cc66e42152c8cc",
     "schemas/v2/localized-content-page-response.schema.json": "ef48329749758afb21e4d3cbc3f017abb911f75726819457f35b9f1390332c75",
@@ -192,8 +193,8 @@
     "schemas/v2/trigger-subscription-registration.schema.json": "5f7959f3e13f49399783e47f73101d6af95e5abccea1af2f0014ccbe3e51006c",
     "schemas/v2/trigger-subscription.schema.json": "06abe021712a4bfc5a107a067053cd3cc9704f47ae7066d8449a508c368a0ab2",
     "schemas/v2/ui-plugin-message.schema.json": "879d65867c01656b3962d64283e66364dcb8f626ad26c5fcf2d2d55a79ae0ce9",
-    "schemas/v2/webhook-dead-letter-page.schema.json": "543f5ccc26d8f777684a037172ab7b9fdf70735e5394eeb42e5fa6569503f528",
-    "schemas/v2/webhook-delivery.schema.json": "4e8ab3b722ad1731adf0548c1217f0de62da40de14e8abf77533aee4ace4c079",
+    "schemas/v2/webhook-dead-letter-page.schema.json": "78f3284722c2b42d52ff8a1e6d9b9092ba1ac35c2dbe036f3ff2470b34086d1e",
+    "schemas/v2/webhook-delivery.schema.json": "5f5361ede12098b5c2d685f0aa70fcb07219fd6b68c6ad6af393ca8dd266d56a",
     "schemas/v2/webhook-verification.schema.json": "76e4e0d81143ffd2649bc7adba2aa34f2525e2c4e9f0300a425d908b3163196b",
     "schemas/v2/workflow-chain-pack-manifest.schema.json": "c0e38aa96b029c539415fb7e8a793fd770c3eb5a1b44a818661f9c127c99191b",
     "schemas/v2/workflow-definition.schema.json": "cb1194631d2b96b0975940b916be43a70363b78b1b6716f9cd84b162d3c96615",
@@ -207,14 +208,14 @@
     "schemas/workspace-file.schema.json": "464de85c2a068243084ee9c1d969bc7cd5d8f7948574e58450d6493c38a0e1e4",
     "spec/v1/alias-detectors.json": "0b2f28808ffe0b9d98a187775038c3406bb70919747a788a6e4f866e293ae6d3",
     "spec/v1/capability-declaration-classes.json": "e7729aed5c4b4e1dd02abab0530f14cc95f5d4070fe51fb139e7f5cccefa00c6",
-    "spec/v1/core-standard-manifest.json": "62c1d7adc81e42adb7ec62f634f86e8812835ba07bda83c4ce2e5b67d27d87d5",
+    "spec/v1/core-standard-manifest.json": "d7c4865e30b6eed18c932ca0c4e4bbcbcb3f4cfedfdd560876a436d0ed774ba0",
     "spec/v1/deprecations.json": "a3293072ea951857395d05f0437264e88965f1e9019ff61c55bacfa9c1aaa17c",
     "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": "7fb75c8cceaa8aa6893aa9dc68ae83e57fe0178225a23f376b6de54e74b15ead",
+    "spec/v1/gaps.json": "b745aa2620ae8c9f79e7df7bd7c81559b8929f0bdfae62a7ea15debc29e8f19a",
     "spec/v1/gaps.schema.json": "8fd83259f556553c9df0f53e7a82ca8c2a4771d471197f69b4e2ae0ceeacfd66",
     "spec/v1/migrations.json": "4c50760be70cb644d02427bcaf5749606700edf4513f423903cf3b1d12f5c300",
     "spec/v1/migrations.schema.json": "886779aa6c22e646db097f5df210adb018a4dd14a7b815465a18c8a7056c8f72",
@@ -222,12 +223,12 @@
     "spec/v1/spec-gaps.json": "ea9612af55bea9dae3e82223d4f714243f8f590b0193f1188257b13491a38afc",
     "spec/v2/README.md": "ddea90d7cf14aefffe1a43eeeecd4222dadad1d1e5ac64dceb073990eb93d9ef",
     "spec/v2/core/artifact-type-packs.md": "f734740cc3963f86c9f273a7dace26291bba2855161ddd3540618131a2c8d13e",
-    "spec/v2/core/capabilities.md": "ed4664a38f53cee32d0082d9fe99091ce13a9874081150fdc72b9b41d4ef9e72",
+    "spec/v2/core/capabilities.md": "503fd78ce55aca2cf83b872a5d6086f016470df2d9bcd7fb427b8f16fb9d044a",
     "spec/v2/core/conformance.md": "3ca291e63bc70a6ef829ae8759ad0ded3741ea7aa507bbbdffc57de443ab2ae2",
     "spec/v2/core/connection-packs.md": "c80f95bd6a03698f35c72cdb2b46bd973f49203bbd786c26760e35fa86e6f23d",
-    "spec/v2/core/conversation.md": "354fa57c73d11062e523a44aa75a6353c5c81aefaf306d30c42416a228c82c86",
+    "spec/v2/core/conversation.md": "e0351883a57e90f13d2e9f6f5d3e80080b46be4988617448cb7a0e0c7c0bfbad",
     "spec/v2/core/errors.md": "91f46acc9c9a5532a98cf62c69285d68575c100ff6064f0b1bf94731a087e34a",
-    "spec/v2/core/events.md": "c1a20e3aa6736119ea07aa2cf66faa808a1874d2cde4933033b65506d1742883",
+    "spec/v2/core/events.md": "00746062621ec98052ee323755fbdb10f4fb070439058039e44feb6bb19b073a",
     "spec/v2/core/execution.md": "8a0c9db1bbfb97c008ab9328b7333c1cc3318196e78bfbefb49e781bdf4f9d44",
     "spec/v2/core/form-content-packs.md": "02931227899676fd4581a27017be2a6c4953904717be9b81c29d12f87ab3917d",
     "spec/v2/core/headers.md": "24b0d84ab5521e20f2669fca8006a11f9faf5c2311199e57375b8fa64ce763ed",
@@ -249,11 +250,11 @@
     "spec/v2/core/storage.md": "dc94b985847c1341c7a064f04a6010f0fdbe6c3ab3e555d4362878c81d764c18",
     "spec/v2/core/tool-catalog.md": "d16a9004418719c48301804aefa4d7ab6f41112a4ed83727f552aa1b92b418b0",
     "spec/v2/core/versioning.md": "348a6dc5bd3425efc0016bb6772d5d04ebf578b73eebcdfec6c2d82346a8577e",
-    "spec/v2/core/webhooks.md": "daf6ec03092f4b3fde1eb74a5e2e801ec48db5139a13fcc0fd7fb4a004635ae3",
+    "spec/v2/core/webhooks.md": "b3be00624d07466606c81ff5069744428d16761e16d79807517b171d8293c262",
     "spec/v2/core/workflow-chain-packs.md": "fdce7a8477e269950a2bac05ee6eddbd66eb0b670b464d00054f7196ec05d29c",
     "spec/v2/corrections.json": "3a8d93e33865b692d26a3b6bfd3819766e206b2e0c2a69669baa4bf833d05a49",
     "spec/v2/corrections.schema.json": "46bbffb954d13bd9995aebc912ceeb2544f7064331abf25fd6ab85c81a5cec94",
-    "spec/v2/declaration.json": "e963d3aa73892ee08281227c8a01aa6c06f1b825cdcb26aab029b1ab3f4155bf",
+    "spec/v2/declaration.json": "5ae9b7c84ab841930dd2885f048d99342ee81ba08cf6a6c07015070f8e17b9d1",
     "spec/v2/declaration.schema.json": "ef951633e4070899f64828f5cf1b5f4870270a0360f81dbb49b5b4d6cd407550",
     "spec/v2/eos-override.json": "4c72d2f6a658943b01c1de1643cf294642091933af7832f38ee5495df684cb2d",
     "spec/v2/errors.json": "83f048b0a06952b4af6f125fb66c4212acab51056b411390f1010acd6ab9cdc0",
@@ -287,6 +288,7 @@
     "spec/v2/facets/connections.schema.json": "f998bb206a5814183bb4720cc34fa43b7ab64d61e39a79437b009c589ce8b78e",
     "spec/v2/facets/envelopeStrictness.schema.json": "28be0a27f880bd45ec1222a16155f5e9167bbca57bf0322970fe1eb2654562aa",
     "spec/v2/facets/heartbeat.schema.json": "81d7fa1895a8b0241bd07cf00a7e7905bef0fd14eb3427325261c62eee5746a6",
+    "spec/v2/facets/hostEvents.schema.json": "973ff452cb91356b4c625d0b06c8d2ef335e18183de09e1afde8acead22290b3",
     "spec/v2/facets/interrupt.schema.json": "2110ef32c3f880bf706475ef4cf8ddf97ff06871b8e6003a5edbcf4439f1fb70",
     "spec/v2/facets/mcp.schema.json": "7060657dfcff170f079beed160e3db7c1d3cc4410cd3cf64863baf6459f781cd",
     "spec/v2/facets/oauth.schema.json": "3a0cbe249d3bd5a5982349ae7ba2534776cc958e4a57e0fbeabf2bdab6e99e69",
@@ -309,9 +311,9 @@
     "spec/v2/path-manifest.json": "b84c7561f50c7df0cb61b202bd6595acad3ee7edca7a45f711949bea3c69bd27",
     "spec/v2/peer-dependency-aliases.json": "d10299280abee08258502925bc327293ee413e0108cd6e6ec75ff6110653308d",
     "spec/v2/profiles.json": "180beb9ef2d161766fa23b2987e7e829851e3d316273147cf6a4a3f324befd6b",
-    "spec/v2/release.json": "74d260237e39bc6e3ffd8740a263e9dbe2fc6e75866b51a6d900dffe32b75ad4",
+    "spec/v2/release.json": "84c88ee17dd416060ba7d564fb3d47fdb528c4efa9cd8e483749b77557dac816",
     "spec/v2/retention-floors.json": "eaf3722d95c79947af1d4269ef85117e126518c588cfcf1a2b21b97269f51624",
-    "spec/v2/surface-baseline.json": "4bc82b54af36b5f7611668523349a9bfcc370c4d86812cef8d11dd54f1f14405"
+    "spec/v2/surface-baseline.json": "11600f3b5d689962b34aaa1bdfa4c3e2a47632b914a945b356b825dd494ec9db"
   },
-  "corpusCommit": "332098b793ec36500833b99f40bab66ec5573d77"
+  "corpusCommit": "d6b2495ddf9ac4b82580a9e0f055f29beccfe24a"
 }

package/src/lib/host-event-witness.ts

@@ -0,0 +1,102 @@
+/**
+ * RFC 0236 — host events: the judges `v2-host-event-delivery` applies to what
+ * it observed. Pure: each takes an observation and returns findings, so the
+ * self-test (`host-event-witness.test.ts`) can feed each one a defect and show
+ * it convicts.
+ *
+ * The scenario owns the I/O (the `/host/events` stream, the emit seam, the
+ * scoped webhook receiver). This file owns only "given what arrived, which
+ * `events.md` §Host events / `webhooks.md` §Delivery rule failed?".
+ */
+
+export interface Finding { readonly ok: boolean; readonly message: string }
+export interface AdvertisedType { readonly type: string; readonly delivery: 'durable' | 'ephemeral' }
+export interface Frame { readonly event: string; readonly data: string; readonly id: string | null }
+
+const ok = (message: string): Finding => ({ ok: true, message });
+const bad = (message: string): Finding => ({ ok: false, message });
+
+/** The advertised `hostEvents.types[]`, keeping only well-formed entries. */
+export function advertisedTypes(record: Readonly<Record<string, unknown>> | null): AdvertisedType[] {
+  const raw = Array.isArray(record?.['types']) ? (record['types'] as unknown[]) : [];
+  return raw.flatMap((t) => {
+    const r = t as { type?: unknown; delivery?: unknown };
+    return typeof r.type === 'string' && (r.delivery === 'durable' || r.delivery === 'ephemeral') ? [{ type: r.type, delivery: r.delivery }] : [];
+  });
+}
+
+/** The conformance types the §G seam drives: an `example.*` type of the given class. */
+export function exampleType(types: readonly AdvertisedType[], delivery: AdvertisedType['delivery']): string | null {
+  return types.find((t) => t.type.startsWith('example.') && t.delivery === delivery)?.type ?? null;
+}
+
+/** The frame carrying `eventId`, parsed, or null. */
+export function frameFor(frames: readonly Frame[], eventId: string): { frame: Frame; envelope: Record<string, unknown> } | null {
+  for (const frame of frames) {
+    let env: unknown;
+    try { env = JSON.parse(frame.data); } catch { continue; }
+    if (env !== null && typeof env === 'object' && (env as { eventId?: unknown }).eventId === eventId) return { frame, envelope: env as Record<string, unknown> };
+  }
+  return null;
+}
+
+/**
+ * §A/§B: an emitted event arrives as a valid envelope, labelled with its type,
+ * of its advertised class, with `id:` = `eventId` when durable and no `id:` when
+ * ephemeral. `validate` is the host-event schema validator.
+ */
+export function judgeEnvelope(
+  frames: readonly Frame[], eventId: string, advertised: AdvertisedType,
+  validate: (doc: unknown) => { ok: boolean; errors: string },
+): Finding[] {
+  const hit = frameFor(frames, eventId);
+  if (hit === null) return [bad(`no frame on /host/events carried eventId ${eventId} (${frames.length} frame(s) arrived)`)];
+  const { frame, envelope } = hit;
+  const v = validate(envelope);
+  const out: Finding[] = [
+    v.ok ? ok('the frame is a valid host-event envelope') : bad(`the frame MUST be a valid host-event envelope (no runId, no sequence; closed): ${v.errors}`),
+    frame.event === advertised.type ? ok('event: is the type') : bad(`the frame's event: MUST be the host-event type ${advertised.type}; got ${frame.event}`),
+    envelope['delivery'] === advertised.delivery ? ok('delivery is the advertised class') : bad(`delivery MUST be the advertised class ${advertised.delivery}; got ${JSON.stringify(envelope['delivery'])}`),
+  ];
+  if (advertised.delivery === 'durable') out.push(frame.id === eventId ? ok('durable id: is eventId') : bad(`a durable event's frame id: MUST be its eventId ${eventId}; got ${JSON.stringify(frame.id)}`));
+  else out.push(frame.id === null ? ok('ephemeral frame has no id:') : bad(`an ephemeral event's frame MUST carry no id:; got ${JSON.stringify(frame.id)}`));
+  return out;
+}
+
+/** §C: after a reconnect with `Last-Event-ID`, the ephemeral event is not redelivered. */
+export function judgeNoResume(resumed: readonly Frame[], ephemeralEventId: string): Finding {
+  return frameFor(resumed, ephemeralEventId) === null
+    ? ok('the ephemeral event was not redelivered')
+    : bad(`a host MUST NOT redeliver an ephemeral host event on reconnection; eventId ${ephemeralEventId} arrived again after Last-Event-ID`);
+}
+
+/** §C: no webhook delivery carries the ephemeral event. `bodies` are the raw delivery bodies the subscription received. */
+export function judgeNoFanOut(bodies: readonly string[], ephemeralEventId: string): Finding {
+  const leaked = bodies.some((b) => b.includes(ephemeralEventId));
+  return leaked ? bad(`a host MUST NOT deliver an ephemeral host event through webhooks; a delivery carried eventId ${ephemeralEventId}`) : ok('no delivery carried the ephemeral event');
+}
+
+/** §E: the host body validates, names the event and type, and verifies under the subscription secret. */
+export function judgeHostBody(
+  body: string, eventType: string | undefined, verified: boolean, eventId: string, type: string,
+  validate: (doc: unknown) => { ok: boolean; errors: string },
+): Finding[] {
+  let doc: unknown;
+  try { doc = JSON.parse(body); } catch { return [bad(`the delivery body MUST be JSON; got ${body.slice(0, 120)}`)]; }
+  const v = validate(doc);
+  const he = (doc as { hostEvent?: { eventId?: unknown; type?: unknown } } | null)?.hostEvent;
+  return [
+    v.ok && he !== undefined ? ok('the body is the { hostEvent } delivery') : bad(`a host-event delivery MUST be { hostEvent } and validate against webhook-delivery.schema.json: ${v.ok ? 'no hostEvent' : v.errors}`),
+    he?.eventId === eventId ? ok('the body carries the emitted event') : bad(`the delivery MUST carry the emitted eventId ${eventId}; got ${JSON.stringify(he?.eventId)}`),
+    eventType === type ? ok('OpenWOP-Event-Type is the host-event type') : bad(`OpenWOP-Event-Type MUST be ${type}; got ${JSON.stringify(eventType)}`),
+    verified ? ok('the signature verifies') : bad('the delivery MUST verify under the subscription secret (webhooks.md §Signing is unchanged for host events)'),
+  ];
+}
+
+/** §D: the second tenant's stream received nothing for the first tenant's event, while the first tenant's did (non-vacuous). */
+export function judgeTenantScope(own: readonly Frame[], other: readonly Frame[], eventId: string): Finding[] {
+  return [
+    frameFor(own, eventId) !== null ? ok('the owning tenant received it') : bad(`the owning tenant's stream MUST receive its own event ${eventId} (otherwise the isolation check is vacuous)`),
+    frameFor(other, eventId) === null ? ok('the other tenant did not') : bad(`a host MUST deliver a host event only within its tenant; a second tenant's stream received ${eventId}`),
+  ];
+}

package/src/scenarios/v2-bound-id-path-projection.test.ts

@@ -22,12 +22,29 @@
  * `v2-created-run-readable` already witnesses it. Duplicating it here would red
  * two rows for one defect and tell a bundle reader nothing new.
  *
+ * **Minting (RFC 0184 §A.2), a second `it`.** A host MUST NOT mint a
+ * tenant-bound id containing `~`; ids already minted MUST still resolve, so only
+ * an id this run mints is checked, never every id a body carries. Unescaped, a
+ * literal `~` is ambiguous with the codec's own marker. openwop-app minted
+ * `user~3A<hash>/<id>` for personal and org tenants (app ADR 0814: it projected
+ * the tenant key instead of mapping it), and no leg saw it, because the
+ * conformance key sat in the clean tenant `default`. **The leg bites only when
+ * the suite's credential sits in a tenant whose key is not already clean**: on a
+ * clean tenant a host with that defect still mints a clean id, so a green row is
+ * evidence only under a non-clean posture; the `it` title says so. Proven on
+ * openwop-app 800722836 (2026-10-05): under `acme@corp.example` the ADR 0814 map
+ * passes (`x-61636d65…/…`) and the reverted projection fails
+ * (`acme~40corp.example/…`); under `default` both builds pass. The in-process
+ * harness (`conformance/run.ts`) overwrites `OPENWOP_API_KEYS` with a `:*` key, so
+ * moving the tenant needs that line edited, not just the env var.
+ *
  * The codec's own edge cases (marker escaping, UTF-8 vs UTF-16, malformed
  * decode) are a unit concern and live in `src/lib/bound-id.test.ts`, which is
  * sabotage-checked. This file asserts only what needs a HOST to answer.
  *
  * @see spec/v2/core/identity.md §5
  * @see RFCS/0184-bound-id-path-projection.md §A.1
+ * @see RFCS/0184-bound-id-path-projection.md §A.2
  */
 
 import { describe, it, expect } from 'vitest';
@@ -40,6 +57,7 @@ import { projectBoundId } from '../lib/bound-id.js';
 import { BOUND_ID as BOUND } from '../lib/bound-id.js';
 
 const ID = 'openwop.requirement.0184.bound-id-path-projection';
+const ID_MINT = 'openwop.requirement.0184.mint-no-tilde';
 const DOC = 'spec/v2/core/identity.md §5';
 const NOOP_WORKFLOW_ID = 'conformance-noop';
 
@@ -132,4 +150,21 @@ describe('v2 bound-id path projection (identity.md §5)', () => {
       req(ID, DOC, `a path segment whose '~' is not followed by two hex digits MUST be refused 400 validation_error — got ${malformed?.status ?? 'no response'} ${readErrorCode(malformed?.json) ?? ''}`.trim()),
     ).toBe(400);
   });
+
+  it('a tenant-bound id the host mints for this run contains no ~ (bites only when the credential tenant is not grammar-clean)', async () => {
+    try { if (!(await v2Discovery())) return softSkip('blocked', 'v2 discovery unreachable'); } catch { return softSkip('blocked', 'v2 discovery unreachable'); }
+    const created = await http(() => driver.post('/runs', { workflowId: NOOP_WORKFLOW_ID }));
+    if (created === null) return softSkip('blocked', 'POST /runs unreachable (fetch failed)');
+    if (created.status === 429) return softSkip('blocked', 'POST /runs answered 429 — the run budget, not the wire');
+    const runId = (created.json as { runId?: unknown } | null)?.runId;
+    if (created.status !== 201 || typeof runId !== 'string') {
+      return softSkip('blocked', `POST /runs {workflowId: ${NOOP_WORKFLOW_ID}} answered ${created.status} ${readErrorCode(created.json) ?? ''} — the smallest valid create was refused (fixture not seeded?)`.trim());
+    }
+    // The body carries the bound id, never the projection (identity.md §5: ids in
+    // documents and bodies are bound). So a `~` here was minted, not escaped.
+    expect(
+      runId.includes('~'),
+      req(ID_MINT, DOC, `a host MUST NOT mint a tenant-bound id containing ~ (RFC 0184 §A.2) — the created runId is ${runId}. A literal ~ is ambiguous with the path projection's escape marker; map the tenant key to a clean segment instead of projecting it`),
+    ).toBe(false);
+  });
 });

package/src/scenarios/v2-channel-presence-advertisement.test.ts

@@ -5,7 +5,7 @@
  *
  *   record         the record validates against its capabilities-schema seat;
  *
- * Not here: presence delivery needs a channel conversation the suite can create, and the non-persistence rule lives only in a schema description (TODO §8).
+ * Not here: delivery is `v2-channel-presence-delivery` (seam-gated: v2 has no route that opens a channel), and whether presence is logged is open in `conversation.md`.
  *
  * Dispositions: discovery unreadable ⇒ `blocked`; `channelPresence` absent, or the
  * facet a leg reads absent ⇒ `inapplicable`.

package/src/scenarios/v2-channel-presence-delivery.test.ts

@@ -0,0 +1,86 @@
+/**
+ * v2 — `channel.presence` delivery (`spec/v2/core/conversation.md`
+ * §`channelPresence`; suite 2.45.20, target major 2; seam-gated).
+ *
+ * v2 mints no client route that opens a channel conversation
+ * (`conversation.md`), so presence is observable only through the snapshot
+ * seam (`host-sample-test-seams.md` §13, `api/seams-v2.yaml`
+ * `snapshotChannelPresence`). The seam transiently joins `member` and returns
+ * the payload the host would deliver to `observer`, through its production
+ * membership gate.
+ *
+ *   advertised-emits         a host advertising `channelPresence` MUST emit
+ *                            `channel.presence`: a member's snapshot answers
+ *                            200, validates against the closed payload, and
+ *                            lists that member;
+ *   non-member-not-delivered a host MUST NOT deliver it to a non-member: asked
+ *                            as an outsider, the seam MUST NOT answer 200.
+ *
+ * Every leg asks as `member` first. A 404 there means the seam is not wired
+ * (`seamAbsent`), so the outsider's 403/404 is never mistaken for an unwired
+ * seam, and a refusal is never mistaken for a pass.
+ *
+ * Not here: cross-tenant delivery needs a second tenant's credential; the
+ * suite holds one. Whether presence is logged is unresolved in the corpus
+ * (`conversation.md` names it open), so no leg reads the event log.
+ *
+ * Dispositions: discovery unreadable ⇒ `blocked`; seams profile or
+ * `channelPresence` not advertised ⇒ `inapplicable`; seam unwired ⇒
+ * `seamAbsent`.
+ *
+ * @see spec/v2/core/conversation.md §channelPresence
+ * @see spec/v1/host-sample-test-seams.md §13
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { v2Discovery, familyAdvertised, v2Validator } from '../lib/v2.js';
+import { seamPath, seamsProfileAdvertised } from '../lib/seams.js';
+import { softSkip, seamAbsent } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+const DOC = 'spec/v2/core/conversation.md §channelPresence';
+const ID_EMITS = 'openwop.requirement.channel-presence.advertised-emits';
+const ID_NON_MEMBER = 'openwop.requirement.channel-presence.non-member-not-delivered';
+const SEAM = seamPath('/v1/host/sample/channel-presence/snapshot');
+const CONVERSATION = 'conf:channel-presence:delivery';
+const MEMBER = 'user:conformance-runner';
+const OUTSIDER = 'user:conformance-outsider';
+
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> {
+  try { return await fn(); } catch { return null; }
+}
+
+/** The gate both legs share, then the member's snapshot; a skip reason otherwise. */
+async function asMember(): Promise<OpenWOPResponse | { kind: 'blocked' | 'inapplicable' | 'seam'; reason: string }> {
+  let doc: Record<string, unknown> | null;
+  try { doc = await v2Discovery(); } catch { doc = null; }
+  if (!doc) return { kind: 'blocked', reason: 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0' };
+  if (!seamsProfileAdvertised(doc)) return { kind: 'inapplicable', reason: 'seams profile not advertised (conformance.seamsProfile) — presence is observable only through the §13 seam' };
+  if (!(await familyAdvertised('channelPresence'))) return { kind: 'inapplicable', reason: 'the host does not advertise channelPresence' };
+  const res = await http(() => driver.post(SEAM, { conversationId: CONVERSATION, member: MEMBER }));
+  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 §13` };
+  return res;
+}
+
+describe('v2 channel-presence delivery (conversation.md §channelPresence — seam-gated)', () => {
+  it('a host advertising channelPresence emits it: a member receives a closed, non-vacuous snapshot', async () => {
+    const m = await asMember();
+    if (!('status' in m)) return m.kind === 'seam' ? seamAbsent(m.reason) : softSkip(m.kind, m.reason);
+    expect(m.status, req(ID_EMITS, DOC, `a host advertising channelPresence MUST emit channel.presence; the member snapshot answered ${m.status}`)).toBe(200);
+    const v = v2Validator('channel-presence-payload')(m.json);
+    expect(v.ok, req(ID_EMITS, DOC, `the snapshot MUST be the closed channel.presence payload (${v.errors})`)).toBe(true);
+    const present = (m.json as { present?: unknown } | null)?.present;
+    expect(Array.isArray(present) && present.includes(MEMBER), req(ID_EMITS, DOC, `the joined member ${MEMBER} MUST be present (got ${JSON.stringify(present)})`)).toBe(true);
+  });
+
+  it('a host does not deliver channel.presence to a non-member', async () => {
+    const m = await asMember();
+    if (!('status' in m)) return m.kind === 'seam' ? seamAbsent(m.reason) : softSkip(m.kind, m.reason);
+    if (m.status !== 200) return softSkip('blocked', `the member snapshot answered ${m.status}, so the seam cannot show what an outsider receives (the advertised-emits leg owns that failure)`);
+    const out = await http(() => driver.post(SEAM, { conversationId: CONVERSATION, member: MEMBER, observer: OUTSIDER }));
+    if (out === null) return softSkip('blocked', `${SEAM} unreachable for the outsider request (fetch failed)`);
+    expect(out.status, req(ID_NON_MEMBER, DOC, `a host MUST NOT deliver channel.presence to a non-member: asked as ${OUTSIDER}, the seam answered 200 with ${out.text.slice(0, 200)}`)).not.toBe(200);
+  });
+});

package/src/scenarios/v2-host-event-delivery.test.ts

@@ -0,0 +1,215 @@
+/**
+ * v2 — host events (RFC 0236; `spec/v2/core/events.md` §Host events,
+ * `webhooks.md` §Delivery; suite 2.45.20, target major 2; seam-gated).
+ *
+ * A host event belongs to no run: its envelope has no `runId` and no
+ * `sequence`. It rides `/host/events` beside the heartbeat messages and, when
+ * durable, webhooks. The suite cannot cause one unaided, so every leg drives
+ * the §G emit seam with the `example.*` types a seams-profile host advertises.
+ *
+ *   0236.host-event.envelope         an emitted durable event arrives as a valid
+ *                                    envelope, `event:` = type, `id:` = eventId;
+ *                                    `channel.presence` is listed ephemeral
+ *                                    whenever `channelPresence` is advertised;
+ *   0236.ephemeral.no-resume         an ephemeral frame has no `id:` and is not
+ *                                    redelivered after `Last-Event-ID`;
+ *   0236.webhook.ephemeral-refused   `registerWebhook` naming the ephemeral type
+ *                                    is `400 validation_error`;
+ *   0236.webhook.host-variant        a subscribed durable event arrives as
+ *                                    `{ hostEvent }`, typed and signed;
+ *   0236.ephemeral.no-fan-out        the same subscription never receives the
+ *                                    ephemeral event;
+ *   0236.host-event.tenant-isolation a second tenant's stream receives nothing
+ *                                    for the first tenant's event.
+ *
+ * Judged by `lib/host-event-witness.ts`, whose self-test convicts each defect.
+ *
+ * Dispositions: discovery unreadable ⇒ `blocked`; seams profile or `hostEvents`
+ * not advertised ⇒ `inapplicable`; seam unwired, or no `example.*` type of the
+ * needed class advertised ⇒ `seamAbsent`; no second-tenant credential
+ * (`OPENWOP_TEST_TENANT_B_API_KEY`) ⇒ `inapplicable` for the tenant leg.
+ *
+ * @see RFCS/0236-host-events.md
+ * @see spec/v2/core/events.md §Host events
+ */
+
+import { afterEach, describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { v2Discovery, familyAdvertised, v2Validator } from '../lib/v2.js';
+import { seamPath, seamsProfileAdvertised } from '../lib/seams.js';
+import { softSkip, seamAbsent } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { subscribe, type SseEvent } from '../lib/sse.js';
+import { readErrorCode } from '../lib/error-envelope.js';
+import { absenceIsUnmeasured, noDeliveryCause, startScopedReceiver, type ScopedHit, type ScopedReceiver } from '../lib/scoped-receiver.js';
+import { createReceiverState, verifyWebhookDelivery } from '../lib/webhook-receiver.js';
+import {
+  advertisedTypes, exampleType, judgeEnvelope, judgeHostBody, judgeNoFanOut, judgeNoResume, judgeTenantScope, type AdvertisedType, type Finding,
+} from '../lib/host-event-witness.js';
+
+export const REQUIRES_HOST_CALLBACK = 'the host POSTs host-event webhook deliveries to the suite-owned scoped receiver behind OPENWOP_WEBHOOK_RECEIVER_URL';
+
+const DOC = 'spec/v2/core/events.md §Host events';
+const WDOC = 'spec/v2/core/webhooks.md §Delivery';
+const ID_ENVELOPE = 'openwop.requirement.0236.host-event.envelope';
+const ID_NO_RESUME = 'openwop.requirement.0236.ephemeral.no-resume';
+const ID_REFUSED = 'openwop.requirement.0236.webhook.ephemeral-refused';
+const ID_HOST_BODY = 'openwop.requirement.0236.webhook.host-variant';
+const ID_NO_FAN_OUT = 'openwop.requirement.0236.ephemeral.no-fan-out';
+const ID_TENANT = 'openwop.requirement.0236.host-event.tenant-isolation';
+const SEAM = seamPath('/v1/host/sample/host-events/emit');
+const V2 = { 'OpenWOP-Version': '2.0' };
+const STREAM_MS = 3_000;
+const SECRET = 'openwop-conformance-host-event-secret-0236';
+
+const hostEvent = v2Validator('host-event');
+const webhookDelivery = v2Validator('webhook-delivery');
+const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> {
+  try { return await fn(); } catch { return null; }
+}
+const assertAll = (id: string, doc: string, findings: readonly Finding[]): void => {
+  for (const f of findings) expect(f.ok, req(id, doc, f.message)).toBe(true);
+};
+
+type Skip = { kind: 'blocked' | 'inapplicable' | 'seam'; reason: string };
+const skip = (s: Skip): undefined => (s.kind === 'seam' ? seamAbsent(s.reason) : softSkip(s.kind, s.reason));
+
+/** The shared gate: the advertised types, or why the leg cannot run. */
+async function gate(): Promise<{ types: AdvertisedType[]; record: Record<string, unknown> } | Skip> {
+  let doc: Record<string, unknown> | null;
+  try { doc = await v2Discovery(); } catch { doc = null; }
+  if (!doc) return { kind: 'blocked', reason: 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0' };
+  const record = await familyAdvertised('hostEvents');
+  if (record === null) return { kind: 'inapplicable', reason: 'the host does not advertise hostEvents' };
+  if (!seamsProfileAdvertised(doc)) return { kind: 'inapplicable', reason: 'seams profile not advertised — the suite cannot cause a host event without the RFC 0236 §G emit seam' };
+  return { types: advertisedTypes(record), record };
+}
+
+function pick(types: readonly AdvertisedType[], delivery: AdvertisedType['delivery']): AdvertisedType | Skip {
+  const type = exampleType(types, delivery);
+  return type === null
+    ? { kind: 'seam', reason: `no example.* ${delivery} type is advertised in hostEvents.types — RFC 0236 §G: a seams-profile host advertises one for the suite to drive` }
+    : { type, delivery };
+}
+
+async function emit(type: string): Promise<string | Skip> {
+  const res = await http(() => driver.post(SEAM, { type }));
+  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}) — RFC 0236 §G` };
+  const eventId = (res.json as { eventId?: unknown } | null)?.eventId;
+  if (res.status !== 202 || typeof eventId !== 'string') return { kind: 'blocked', reason: `${SEAM} answered ${res.status} ${readErrorCode(res.json) ?? ''} for ${type}, so no event was produced`.trim() };
+  return eventId;
+}
+
+/** Open `/host/events`, run `act` while it is open, and return every frame. */
+async function streamWhile(act: () => Promise<void>, opts: { lastEventId?: string; bearer?: string } = {}): Promise<SseEvent[]> {
+  const headers: Record<string, string> = { ...V2, ...(opts.bearer ? { Authorization: `Bearer ${opts.bearer}` } : {}) };
+  const sub = subscribe('/host/events', { timeoutMs: STREAM_MS, extraHeaders: headers, ...(opts.lastEventId ? { lastEventId: opts.lastEventId } : {}) });
+  await sleep(400);
+  await act();
+  return [...(await sub).events];
+}
+
+const registered: string[] = [];
+let receiver: ScopedReceiver | null = null;
+afterEach(async () => {
+  for (const id of registered.splice(0)) await driver.delete(`/webhooks/${encodeURIComponent(id)}`).catch(() => undefined);
+  if (receiver) { receiver.server.close(); receiver = null; }
+});
+
+describe('v2 host events (RFC 0236 — seam-gated)', () => {
+  it('an emitted durable host event arrives on /host/events as a valid envelope', async () => {
+    const g = await gate();
+    if ('kind' in g) return skip(g);
+    const d = pick(g.types, 'durable');
+    if ('kind' in d) return skip(d);
+    let eventId: string | Skip = '';
+    const frames = await streamWhile(async () => { eventId = await emit(d.type); });
+    if (typeof eventId !== 'string') return skip(eventId);
+    assertAll(ID_ENVELOPE, DOC, judgeEnvelope(frames, eventId, d, hostEvent));
+    if (await familyAdvertised('channelPresence')) {
+      expect(g.types.some((t) => t.type === 'channel.presence' && t.delivery === 'ephemeral'), req(ID_ENVELOPE, 'spec/v2/core/conversation.md §channelPresence', 'a host advertising channelPresence MUST list channel.presence under hostEvents as ephemeral')).toBe(true);
+    }
+  }, 20_000);
+
+  it('an ephemeral host event has no id: and is not redelivered after Last-Event-ID', async () => {
+    const g = await gate();
+    if ('kind' in g) return skip(g);
+    const d = pick(g.types, 'durable');
+    const e = pick(g.types, 'ephemeral');
+    if ('kind' in d) return skip(d);
+    if ('kind' in e) return skip(e);
+    let durableId: string | Skip = '';
+    let ephemeralId: string | Skip = '';
+    const frames = await streamWhile(async () => { durableId = await emit(d.type); await sleep(150); ephemeralId = await emit(e.type); });
+    if (typeof durableId !== 'string') return skip(durableId);
+    if (typeof ephemeralId !== 'string') return skip(ephemeralId);
+    assertAll(ID_NO_RESUME, DOC, judgeEnvelope(frames, ephemeralId, e, hostEvent));
+    const resumed = await streamWhile(async () => undefined, { lastEventId: durableId });
+    assertAll(ID_NO_RESUME, DOC, [judgeNoResume(resumed, ephemeralId)]);
+  }, 20_000);
+
+  it('registerWebhook refuses an ephemeral host-event type with 400 validation_error', async () => {
+    const g = await gate();
+    if ('kind' in g) return skip(g);
+    const e = pick(g.types, 'ephemeral');
+    if ('kind' in e) return skip(e);
+    const res = await http(() => driver.post('/webhooks', { url: 'https://example.com/openwop-conformance-0236', events: [e.type], secret: SECRET }));
+    if (res === null) return softSkip('blocked', 'POST /webhooks unreachable (fetch failed)');
+    const id = (res.json as { webhookId?: unknown } | null)?.webhookId;
+    if (typeof id === 'string') registered.push(id);
+    expect(res.status, req(ID_REFUSED, 'spec/v2/core/webhooks.md §Surfaces', `events[] naming the ephemeral host-event type ${e.type} MUST be refused 400 validation_error; got ${res.status} ${readErrorCode(res.json) ?? ''}`)).toBe(400);
+    expect(readErrorCode(res.json), req(ID_REFUSED, 'spec/v2/core/webhooks.md §Surfaces', 'the refusal code MUST be validation_error')).toBe('validation_error');
+  }, 20_000);
+
+  it('a subscribed durable host event is delivered as { hostEvent }, signed; the ephemeral one is not', async () => {
+    const g = await gate();
+    if ('kind' in g) return skip(g);
+    if ((await familyAdvertised('webhooks')) === null) return softSkip('inapplicable', 'the host does not advertise webhooks');
+    const d = pick(g.types, 'durable');
+    const e = pick(g.types, 'ephemeral');
+    if ('kind' in d) return skip(d);
+    if ('kind' in e) return skip(e);
+    const hits: ScopedHit[] = [];
+    const rx = await startScopedReceiver((hit, res) => { hits.push(hit); res.writeHead(204); res.end(); });
+    receiver = rx;
+    const reg = await http(() => driver.post('/webhooks', { url: rx.url, events: [d.type], secret: SECRET }));
+    if (reg === null) return softSkip('blocked', 'POST /webhooks unreachable (fetch failed)');
+    if (reg.status === 400 && readErrorCode(reg.json) === 'webhook_url_rejected' && !rx.tunnelled) {
+      return softSkip('blocked', 'the host SSRF guard rejected the loopback receiver (webhooks.md §Egress requires it); set OPENWOP_WEBHOOK_RECEIVER_URL to a public https tunnel');
+    }
+    const webhookId = (reg.json as { webhookId?: unknown } | null)?.webhookId;
+    expect(reg.status, req(ID_HOST_BODY, 'spec/v2/core/webhooks.md §Surfaces', `events[] naming the advertised durable host-event type ${d.type} MUST be accepted; got ${reg.status} ${readErrorCode(reg.json) ?? ''}`)).toBe(201);
+    if (typeof webhookId === 'string') registered.push(webhookId);
+    const ephemeralId = await emit(e.type);
+    if (typeof ephemeralId !== 'string') return skip(ephemeralId);
+    const durableId = await emit(d.type);
+    if (typeof durableId !== 'string') return skip(durableId);
+    for (let waited = 0; waited < 15_000 && !hits.some((h) => h.body.includes(durableId)); waited += 250) await sleep(250);
+    const hit = hits.find((h) => h.body.includes(durableId));
+    if (hit === undefined) {
+      return absenceIsUnmeasured(rx) ? softSkip('blocked', noDeliveryCause(rx)) : softSkip('blocked', `no delivery of ${durableId} arrived within 15 s — ${noDeliveryCause(rx)}`);
+    }
+    const h = (name: string): string | undefined => { const v = hit.headers[name]; return Array.isArray(v) ? v[0] : v; };
+    const verified = verifyWebhookDelivery(SECRET, h('openwop-signature') ?? '', h('openwop-signature-algorithm'), h('openwop-timestamp') ?? '', hit.body, createReceiverState()).accepted === true;
+    assertAll(ID_HOST_BODY, WDOC, judgeHostBody(hit.body, h('openwop-event-type'), verified, durableId, d.type, webhookDelivery));
+    assertAll(ID_NO_FAN_OUT, DOC, [judgeNoFanOut(hits.map((x) => x.body), ephemeralId)]);
+  }, 30_000);
+
+  it('a second tenant receives nothing for the first tenant’s host event', async () => {
+    const g = await gate();
+    if ('kind' in g) return skip(g);
+    const d = pick(g.types, 'durable');
+    if ('kind' in d) return skip(d);
+    const other = process.env['OPENWOP_TEST_TENANT_B_API_KEY']?.trim();
+    if (!other) return softSkip('inapplicable', 'OPENWOP_TEST_TENANT_B_API_KEY (a credential bound to a second tenant) is not set — the cross-tenant check needs it');
+    if (other === process.env['OPENWOP_API_KEY']?.trim()) return softSkip('blocked', 'OPENWOP_TEST_TENANT_B_API_KEY equals OPENWOP_API_KEY — the second credential must resolve to a different tenant');
+    let eventId: string | Skip = '';
+    const otherStream = streamWhile(async () => undefined, { bearer: other });
+    const own = await streamWhile(async () => { eventId = await emit(d.type); });
+    const theirs = await otherStream;
+    if (typeof eventId !== 'string') return skip(eventId);
+    assertAll(ID_TENANT, DOC, judgeTenantScope(own, theirs, eventId));
+  }, 20_000);
+});