@openwop/openwop-conformance 2.45.7 → 2.45.9

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # `@openwop/openwop-conformance` Changelog
 
+## [2.45.9] — 2026-10-02 — a trigger leg that observed nothing is inapplicable, not blocked
+
+- **Fix: `trigger-stream-cdc-sources` no longer records `blocked` on a host that serves neither `stream` nor `change`.** The ingest leg skipped both sources on such a host and then passed with zero assertions and no reason. RFC 0148 §A records that as `blocked`, and a `blocked` row denies a major-1 bundle (RFC 0168 §E.1). It now records `inapplicable`, with the reason. The dedup leg's pre-RFC 0127 branch said `blocked` for the same condition and now says `inapplicable`. An unwired seam is still `blocked`, and a host that advertises either source and refuses it still fails.
+  - **Found by** openwop-app's 2.45.8 seam-free run, ahead of its RFC 0230 certified cut. My own harness run with the seams on recorded the same row, so the seams play no part in it.
+  - **Proof.** On openwop-app's in-process harness, the row was `blocked` before the change and is `inapplicable` with the reason after it. All nine tests pass.
+
+## [2.45.8] — 2026-10-02 — RFC 0229 Accepted on MyndHyve's production cut; a v2 witness for tableStorage schema enforcement
+
+- **The 2.45.8 cycle opens.** RFC 0229's and RFC 0228's gap registers change the packed `spec/v1/gaps.json`.
+- **New scenario `v2-table-schema-enforcement`** (major 2, unaided; RFC 0228 gap G4). The v1 twin `table-schema-enforcement` drives a test seam; this port runs the new `conformance-table-schema-probe` fixture three times, each on a fresh table declared `{ k: string, n: number }`. Logic in `lib/table-schema-witness.ts`.
+  - `openwop.requirement.storage.table-schema-control-insert-completes`: a well-typed insert completes. It is the positive control.
+  - `openwop.requirement.storage.table-schema-insert-mistyped-refused`: an insert with `n: "not-a-number"` fails the probe node `validation_error` with `details.service: tableStorage`.
+  - `openwop.requirement.storage.table-schema-update-mistyped-refused`: an update setting `n` to a string fails the same way.
+
+  **Dispositions.** `tableStorage` not advertised, or the fixture not advertised: `inapplicable`. The fixture is the opt-in, as for the budget and safeFetch witnesses. A fixture run that cannot be created, finish or be read: `blocked`. A failed control: the control row fails and the two refusal rows are `blocked`, since a host that refuses every insert would pass them vacuously.
+
+  **Sabotage.** `lib/table-schema-witness.test.ts`, eight cases against the scratch host. A host that accepts a mistyped insert, or a mistyped update, fails only that row. v1's `table_schema_violation` fails both refusal rows. `validation_error` without `details.service` fails and cites `errors.md` §Host-service refusals. A probe that refuses everything fails the control.
+
+  **Host impact: none today.** No host advertises `tableStorage` at major 2, so all three rows record `inapplicable`.
+- **New fixture `conformance-table-schema-probe`** (`fixtures.md` §The tableStorage schema probe fixture). Its node `core.conformance.table-schema-probe` is conformance-RESERVED and calls the host's own `ctx.storage.table`. A host MUST NOT advertise it unless it advertises `tableStorage`.
+- **`trigger-bridge-delivery` runs every witness path a host offers (RFC 0230).** Until now the signed public-ingest path ran only when the delivery seams were absent. With the seams mounted it never ran. Without them, the seam-only leg 4 was red, so the profile did not certify, and an uncertified bundle is not acceptance evidence (RFC 0174 §B.1). Legs 1–3 now run the seam path whenever the seams are served, and the signed-ingest path whenever `triggerBridge.ingestion.inboundSigning` is advertised. A host that offers both must pass both, and each row notes which paths ran.
+  - **`trigger-refused-event-keeps-subscription`** records `inapplicable`, not seam-absent, on a host with no seams that advertises `inboundSigning`. The dead-letter leg above already witnesses the same rule on its signed ingest, and in strict mode this file used to fail such a host right after that leg had observed it.
+  - **Proof.** On openwop-app's in-process harness, with the seams on and `OPENWOP_TRIGGER_INBOUND_SIGNING=true`, all four legs pass. A sabotaged dedup assertion on the signed path fails leg 1, so that path now runs on a host that also serves the seams.
+
 ## [2.45.7] — 2026-10-02 — a strict-mode host that does not advertise `workspace` is not failed; RFC 0231 Accepted
 
 - **Fix: `v2-workspace-scope-from-identity` no longer fails a strict-mode host that does not advertise `workspace`.** The file gated with `gateFamily('workspace')`, which under `--require-behavior` fails an unadvertised family unless the operator opts it out. Its own header says an unadvertised family is `inapplicable`, and its sibling isolation scenarios (`v2-storage-`, `v2-queue-cross-tenant-isolation`) read with `familyAdvertised` and recorded `inapplicable` in the same run. It now reads with `familyAdvertised`.

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 590 scenario files under `src/scenarios/`.
+The current suite has 591 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: 590 scenario files. Use [`coverage.md`](./coverage.md) for current grade/gap tracking.
+Current source tree: 591 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.7",
-  "stampSha256": "23ca7bff43af86c11279cbf51fbd7cfe67ced0171b808fb24cb33c03cf50e0d1"
+  "version": "2.45.9",
+  "stampSha256": "513673157cfa9c0ebe94e89a0c48dfe28c39cfdea2c528269612951589ec44f4"
 }

package/fixtures/conformance-table-schema-probe.json

@@ -0,0 +1,24 @@
+{
+  "id": "conformance-table-schema-probe",
+  "name": "Conformance: v2 tableStorage schema probe",
+  "version": "1.0",
+  "description": "Fixture for `v2-table-schema-enforcement.test.ts` (spec/v2/core/storage.md §`tableStorage`: rows MUST conform to the table's declared schema). One node, `core.conformance.table-schema-probe` (conformance-RESERVED): a host that advertises `tableStorage` maps it to a node that calls its OWN `ctx.storage.table` for the run's tenant with the run's inputs and nothing else. Every action first calls `createTable(table, { k: \"string\", n: \"number\" })`. `action: control` then inserts `{ k: \"control\", n: 1 }` and completes with `outputs.result = { inserted: true, rowId }`. `action: insert-mistyped` inserts `{ k: \"mistyped\", n: \"not-a-number\" }`; if the host accepts it the node completes with `{ inserted: true, rowId }`. `action: update-mistyped` inserts `{ k: \"to-update\", n: 2 }`, then calls `update(table, rowId, { n: \"not-a-number\" })`; if the host accepts it the node completes with `{ updated: true, rowId }`. The node does no type checking of its own. A rejection fails the node with the rejection's code and details, unchanged. A host that does not advertise `tableStorage` MUST NOT advertise this fixture.",
+  "nodes": [
+    {
+      "id": "table-schema-probe",
+      "typeId": "core.conformance.table-schema-probe",
+      "name": "Probe ctx.storage.table schema enforcement",
+      "position": { "x": 0, "y": 0 },
+      "config": {},
+      "inputs": {}
+    }
+  ],
+  "edges": [],
+  "triggers": [{ "id": "manual", "type": "manual", "enabled": true }],
+  "variables": [
+    { "name": "action", "type": "string", "defaultValue": "control" },
+    { "name": "table", "type": "string" }
+  ],
+  "metadata": { "tags": ["conformance", "storage", "tableStorage"] },
+  "settings": { "timeout": 0 }
+}

package/fixtures.md

@@ -118,6 +118,7 @@ All fixtures MUST advertise:
 | v2 `ctx.mcp` Client                       | `conformance-mcp-client`                                                                        | RFC 0204 — one `core.conformance.mcp-client` node (conformance-RESERVED) calls the host's `ctx.mcp.<method>` with the run's inputs and completes with `outputs.result` = the resolved value verbatim; a rejection fails the node with its code. See §"The `ctx.mcp` fixture (RFC 0204)" | `completed`, or `failed` (`not_found`) for an unknown `serverId` | ≤ 30s |
 | v2 Storage Tenant-Isolation Probe | `conformance-storage-probe` | `storage.md` §Shared rules — one `core.conformance.storage-probe` node (conformance-RESERVED) calls the host's own storage `family` for the run's tenant: `write` stores `value` at `key`, `read` returns every value and key the family's isolated reads return for `key`, `delete` removes it. See §"The storage probe fixtures" | `completed`, or `failed` (`forbidden` / `not_found`) for a refused read | ≤ 30s |
 | v2 fs Sandbox Probe | `conformance-fs-probe` | `storage.md` §`fs` — one `core.conformance.fs-probe` node (conformance-RESERVED) calls the host's own `ctx.fs.read` / `write` with the run's `path`, unchanged; a rejection fails the node with its code and details. Operator symlink `<sandboxRoot>/conformance/escape-link` points outside the root. See §"The storage probe fixtures" | `completed` inside the root; `failed` (`forbidden`, `details.reason: path-outside-sandbox`) for an escape | ≤ 30s |
+| v2 tableStorage Schema Probe | `conformance-table-schema-probe` | `storage.md` §`tableStorage` — one `core.conformance.table-schema-probe` node (conformance-RESERVED) creates a table `{ k: string, n: number }` with the host's own `ctx.storage.table`, then inserts a well-typed row (`control`), a row whose `n` is a string (`insert-mistyped`), or updates `n` to a string (`update-mistyped`). See §"The tableStorage schema probe fixture" | `completed` for `control`; `failed` (`validation_error`, `details.service: tableStorage`) for a mistyped write | ≤ 30s |
 | v2 safeFetch SSRF Probe | `conformance-safefetch-probe` | `host-services.md` §`httpClient` — one `core.conformance.safefetch-probe` node (conformance-RESERVED) calls the host's own `ctx.http.safeFetch(url)` with the run's `url`, unchanged; completes with the response `status` only; a rejection fails the node with its code and details. See §"The safeFetch probe fixture" | `failed` (`egress_denied`, `details.reason: ssrf-blocked`) for a refused target | ≤ 60s |
 | A2A Task Roundtrip                        | `conformance-a2a-task-roundtrip`                                                                | Track 6 — host consumes the conformance suite's synthetic A2A peer; covers drift points #3 (`AUTH_REQUIRED`) and #4 (`REJECTED`). Node `core.conformance.a2a-invoke` is a **conformance-RESERVED** typeId (renamed 2026-08-16 from `core.a2a.invoke`, a multi-segment `core.*` id no host shipped and the corpus never defined): a host that consumes A2A peers MUST map it to its A2A bridge node (a host-extension node — `a2a-integration.md` §"State projection"); a host that does not consume A2A MUST NOT advertise this fixture                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `failed` or `waiting-input` (per `driftScenario` input)                             | ≤ 30s                        |
 | WASM Pack Roundtrip                       | `conformance-wasm-pack-roundtrip`                                                               | RFC 0008 — invokes `vendor.openwop.rust-hello.greet` (loaded WASM pack); exercises required exports + at least one import                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `completed`                                                                         | ≤ 10s                        |
@@ -725,6 +726,28 @@ For `v2-tool-catalog-annotations`' unclassified-MCP leg, a host that advertises
 
 ---
 
+## The tableStorage schema probe fixture (storage.md)
+
+`conformance-table-schema-probe` is what `v2-table-schema-enforcement` drives. Its node, `core.conformance.table-schema-probe`, is conformance-RESERVED: a host that advertises `tableStorage` maps it to a node that calls its OWN `ctx.storage.table` (`spec/v2/core/storage.md` §`tableStorage`) for the run's tenant, and nothing else. It is a fixture, not a seam: it runs through `POST /runs` under the caller's own credential.
+
+**Inputs.** `action` (`control` | `insert-mistyped` | `update-mistyped`) and `table`, a fresh name per run.
+
+**Every action** first calls `createTable(table, { k: "string", n: "number" })`.
+
+| `action` | Then | Completes with |
+|---|---|---|
+| `control` | `insert(table, { k: "control", n: 1 })` | `outputs.result = { inserted: true, rowId }` |
+| `insert-mistyped` | `insert(table, { k: "mistyped", n: "not-a-number" })` | `{ inserted: true, rowId }`, only if the host accepts it |
+| `update-mistyped` | `insert(table, { k: "to-update", n: 2 })`, then `update(table, rowId, { n: "not-a-number" })` | `{ updated: true, rowId }`, only if the host accepts it |
+
+- **Rejection.** The node fails with the rejection's code and details unchanged (`errors.md` §Host-service refusals). A schema divergence is `validation_error` with `details.service: tableStorage`.
+- **No checking of its own.** The node passes the row through, so the host's own schema enforcement is what is exercised.
+- **Cleanup.** None: each run names a fresh table. A host that caps the number of tables MAY drop probe tables on its own schedule.
+
+A host MUST NOT advertise the fixture unless it advertises `tableStorage`.
+
+---
+
 ## The safeFetch probe fixture (host-services.md)
 
 `conformance-safefetch-probe` is what `v2-safefetch-ssrf-refused` drives. Its node, `core.conformance.safefetch-probe`, is conformance-RESERVED: a host that advertises `httpClient.safeFetch` maps it to a node that calls its OWN `ctx.http.safeFetch(url)` (`spec/v2/core/host-services.md` §`httpClient`) with the run's `url` input unchanged, method `GET`, no headers and no body, and nothing else. It is a fixture, not a seam: it runs through `POST /runs` under the caller's own credential.

package/package.json

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

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": 665,
-    "tests": 2542,
-    "withStableId": 2542,
+    "files": 666,
+    "tests": 2545,
+    "withStableId": 2545,
     "interpolatedTitles": 0,
-    "explicitIds": 2418
+    "explicitIds": 2421
   },
   "records": [
     {
@@ -26311,7 +26311,7 @@
     {
       "id": "openwop.it.trigger-bridge-delivery.de-dups-by-dedupkey-a-repeated-delivery-is-effectively-once",
       "file": "trigger-bridge-delivery.test.ts",
-      "line": 149,
+      "line": 158,
       "title": "de-dups by dedupKey: a repeated delivery is effectively-once",
       "explicitId": "openwop.requirement.0083.trigger-delivery.dedup",
       "citations": [
@@ -26347,7 +26347,7 @@
     {
       "id": "openwop.it.trigger-bridge-delivery.dead-letters-an-exhausted-or-refused-delivery-without-starting-a-run",
       "file": "trigger-bridge-delivery.test.ts",
-      "line": 172,
+      "line": 182,
       "title": "dead-letters an exhausted or refused delivery without starting a run",
       "explicitId": "openwop.requirement.0083.trigger-delivery.dead-letter",
       "citations": [
@@ -26380,7 +26380,7 @@
     {
       "id": "openwop.it.trigger-bridge-delivery.links-delivery-run-causation-on-run-started",
       "file": "trigger-bridge-delivery.test.ts",
-      "line": 194,
+      "line": 205,
       "title": "links delivery→run causation on run.started",
       "explicitId": "openwop.requirement.0083.trigger-delivery.causation",
       "citations": [
@@ -26416,7 +26416,7 @@
     {
       "id": "openwop.it.trigger-bridge-delivery.keeps-the-run-less-trigger-events-content-free",
       "file": "trigger-bridge-delivery.test.ts",
-      "line": 222,
+      "line": 234,
       "title": "keeps the run-less trigger events content-free",
       "explicitId": null,
       "citations": []
@@ -26732,7 +26732,7 @@
     {
       "id": "openwop.it.trigger-refused-event-keeps-subscription.a-refused-event-dead-letters-only-its-delivery-the-subscription-stays-active-and",
       "file": "trigger-refused-event-keeps-subscription.test.ts",
-      "line": 55,
+      "line": 57,
       "title": "a refused event dead-letters only its delivery; the subscription stays active and a verified event then delivers",
       "explicitId": "openwop.requirement.trigger-bridge.refused-event-keeps-subscription",
       "citations": [
@@ -26916,7 +26916,7 @@
     {
       "id": "openwop.it.trigger-stream-cdc-sources.stream-dedup-the-same-broker-coordinates-delivered-twice-are-effectively-once-c",
       "file": "trigger-stream-cdc-sources.test.ts",
-      "line": 201,
+      "line": 210,
       "title": "stream dedup — the same broker coordinates delivered twice are effectively-once (§C-1 floor)",
       "explicitId": "openwop.it.trigger-stream-cdc-sources.stream-dedup-the-same-broker-coordinates-delivered-twice-are-effectively-once-c",
       "citations": [
@@ -34929,6 +34929,48 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-table-schema-enforcement.a-well-typed-insert-completes-positive-control",
+      "file": "v2-table-schema-enforcement.test.ts",
+      "line": 65,
+      "title": "a well-typed insert completes (positive control)",
+      "explicitId": "openwop.requirement.storage.table-schema-control-insert-completes",
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-table-schema-enforcement.an-insert-whose-column-type-diverges-from-the-schema-is-refused-validation-error",
+      "file": "v2-table-schema-enforcement.test.ts",
+      "line": 71,
+      "title": "an insert whose column type diverges from the schema is refused validation_error",
+      "explicitId": "openwop.requirement.storage.table-schema-insert-mistyped-refused",
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-table-schema-enforcement.an-update-whose-column-type-diverges-from-the-schema-is-refused-validation-error",
+      "file": "v2-table-schema-enforcement.test.ts",
+      "line": 77,
+      "title": "an update whose column type diverges from the schema is refused validation_error",
+      "explicitId": "openwop.requirement.storage.table-schema-update-mistyped-refused",
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
     {
       "id": "openwop.it.v2-terminal-event-once.every-run-observed-to-a-terminal-state-has-exactly-one-terminal-event-and-no-for",
       "file": "v2-terminal-event-once.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": 590,
+    "files": 591,
     "v1": 454,
-    "v2": 151
+    "v2": 152
   },
   "majors": {
     "a2a-1-0-agent-card.test.ts": [
@@ -1620,6 +1620,9 @@
     "v2-subject-link-record.test.ts": [
       2
     ],
+    "v2-table-schema-enforcement.test.ts": [
+      2
+    ],
     "v2-terminal-event-once.test.ts": [
       2
     ],

package/schemas/CORPUS-STAMP.json

@@ -1,17 +1,17 @@
 {
   "_comment": "Provenance of @openwop/spec-artifacts (RFC 0168 §D.2). files: SHA-256 per file; the conformance suite compares the installed peer against dist/spec-artifacts.lock.json at start.",
   "package": "@openwop/spec-artifacts",
-  "version": "2.45.7",
-  "corpusTag": "v2.45.7",
+  "version": "2.45.9",
+  "corpusTag": "v2.45.9",
   "files": {
     "api/.redocly.lint-ignore.yaml": "bf5a8350b88a72fa43f59605ed8d903ed24b6cfccda5e45509c9f6ed9ee4e712",
     "api/asyncapi.yaml": "d5ecb9ee6114582be3b1f662c84bfac9ae96dae7bacb853e461168f70a8e1c7d",
     "api/grpc/openwop.proto": "c3e72bb17cba514ee98feb6434e6c9b6ea6795bfd086489ec69fd882dd1ad977",
     "api/openapi.yaml": "ad37a5a5c732ad46100fc03c3f4243fdd4f2976e330f02a8791b6b5b10a8a0c1",
     "api/redocly.yaml": "b0604c89b2ca6d5076ec25725c539dad44a741a811fe524439ee6daef8baa09f",
-    "api/seams-v2.yaml": "c248954e6382322c769fd44e6888f739644bcee2becfacabff3de173a9f40d71",
-    "api/v2/asyncapi.yaml": "63f837b7f56a5b5d17b1c34ffb47337ceb72e0027f8682c2f082c4df3e9dd856",
-    "api/v2/openapi.yaml": "d3c23e3c30db36ebe2ace9273f0262f927a4a44dc0ea4807ea9e94f607b661d3",
+    "api/seams-v2.yaml": "1a3d28d791ba5316741a2863a04fc73aab2b00c6959964658ff1e3ad8523820f",
+    "api/v2/asyncapi.yaml": "8e6f4c64c5f06409f926d5cfc78c503e3733885ab09f5d563ade7143f071530f",
+    "api/v2/openapi.yaml": "da7e2a67630d825530726bcd2f170cf99735351c9f4872750bf179dd283cf1f2",
     "api/v2/redocly.yaml": "1e66b60e6118ad11a823bb620678be464d99dfe50a40e3e6f93ec9429b88b34c",
     "schemas/README.md": "0c0b737ffcf8f30e7d2809cec8a498232de710f41443212922ad8337cdde0b51",
     "schemas/a2a-task-state.schema.json": "75d5049dea8bd873ff0e7546f1c60c8d36c219bec7084264360be54a8be30ae1",
@@ -204,13 +204,13 @@
     "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": "592b87877bb6f713f77e6f4f64d671a63a119a71372405370d8a426cfab4113a",
+    "spec/v1/core-standard-manifest.json": "f1e9f2551bd9695a8e16bb070e7180281378f4822921fa1aab7adcc60a5cca10",
     "spec/v1/deprecations.json": "a3293072ea951857395d05f0437264e88965f1e9019ff61c55bacfa9c1aaa17c",
     "spec/v1/deprecations.schema.json": "3e393c405d2a41b467d8c5e3c468549078df1ce6a6d2588fc488097b95d9b55b",
     "spec/v1/event-codemap.json": "3da60d884157793a360da532a9fcbbfb5285636db325a74cec94b34622186d97",
     "spec/v1/event-codemap.schema.json": "d05933b2e88103aff51a2f774df97b9bda065e0fc88dbd9b114cc47a32189174",
     "spec/v1/extensions.json": "79a60754aa16cbdbdb604f8e5c00038af535a1690a4d07bd5ff7c38f0256a7bc",
-    "spec/v1/gaps.json": "95c1c9242a97fafd75d5ca040c2ca07e146dbfa6d9be1fcee9ba882da0efd8ed",
+    "spec/v1/gaps.json": "fa1b564fe59db6a708b9488d15aab445919fcc3621e8cf8121901b90b7b4c234",
     "spec/v1/gaps.schema.json": "8fd83259f556553c9df0f53e7a82ca8c2a4771d471197f69b4e2ae0ceeacfd66",
     "spec/v1/migrations.json": "4c50760be70cb644d02427bcaf5749606700edf4513f423903cf3b1d12f5c300",
     "spec/v1/migrations.schema.json": "886779aa6c22e646db097f5df210adb018a4dd14a7b815465a18c8a7056c8f72",
@@ -303,9 +303,9 @@
     "spec/v2/path-manifest.json": "27c2307b84376b2f22bea4e2213fc7e33ef3bf8fd1d18039f7955edb00dc9c9a",
     "spec/v2/peer-dependency-aliases.json": "d10299280abee08258502925bc327293ee413e0108cd6e6ec75ff6110653308d",
     "spec/v2/profiles.json": "180beb9ef2d161766fa23b2987e7e829851e3d316273147cf6a4a3f324befd6b",
-    "spec/v2/release.json": "4cc5a5efe139e3ef205ccba16dcc52a684cc65d682a24c195af7ad8a236896ad",
+    "spec/v2/release.json": "db1ff3ccb0a8e5446734924122582f7909b7860eb0e097b8275753ff97681d37",
     "spec/v2/retention-floors.json": "eaf3722d95c79947af1d4269ef85117e126518c588cfcf1a2b21b97269f51624",
-    "spec/v2/surface-baseline.json": "b7b01715d4b07dcefd055a937e8f865896e35017ff89f99a3b1aa1a801bbdb87"
+    "spec/v2/surface-baseline.json": "3cc12012d8f0437b2dd8280e18ac472063afffb30af25d1f1a126e20f9aee674"
   },
-  "corpusCommit": "501121df013767d1adfcc3a342d82737d6fbd054"
+  "corpusCommit": "458e139f76c2469f90f187ee41ae1d7070748adf"
 }

package/src/lib/table-schema-witness.ts

@@ -0,0 +1,125 @@
+/**
+ * The tableStorage schema witness (`spec/v2/core/storage.md` §`tableStorage`:
+ * "an insert or update whose column types diverge from it MUST be refused").
+ *
+ * Unaided: the suite runs the `conformance-table-schema-probe` fixture three
+ * times, each on a fresh table declared `{ k: string, n: number }`:
+ *
+ *   control          a well-typed insert MUST complete. Without it, a host
+ *                    whose probe refuses everything passes the other legs.
+ *   insert-mistyped  an insert with `n: "not-a-number"` MUST be refused.
+ *   update-mistyped  an update setting `n` to a string MUST be refused.
+ *
+ * A refusal is `validation_error` with `details.service: tableStorage`
+ * (`errors.md` §Host-service refusals; RFC 0228 maps v1's
+ * `table_schema_violation` to it).
+ *
+ * Two halves, as in `budget-witness.ts`: {@link drive} observes and asserts
+ * nothing; {@link judge} is pure.
+ */
+
+import { randomUUID } from 'node:crypto';
+import { driver, type OpenWOPResponse } from './driver.js';
+import { readErrorCode } from './error-envelope.js';
+import { isFixtureAdvertised } from './fixtures.js';
+
+export const TABLE_FIXTURE = 'conformance-table-schema-probe';
+export const NODE_ID = 'table-schema-probe';
+export type ProbeAction = 'control' | 'insert-mistyped' | 'update-mistyped';
+export const ACTIONS: readonly ProbeAction[] = ['control', 'insert-mistyped', 'update-mistyped'];
+const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
+const DOC = 'spec/v2/core/storage.md §tableStorage';
+const REFUSAL_DOC = 'spec/v2/core/errors.md §Host-service refusals';
+
+export interface ProbeOutcome {
+  readonly action: ProbeAction;
+  readonly status: string;
+  readonly code: string | null;
+  readonly service: unknown;
+}
+export type TableRun =
+  | { readonly kind: 'skip'; readonly disposition: 'inapplicable' | 'blocked'; readonly reason: string }
+  | { readonly kind: 'observed'; readonly outcomes: Readonly<Record<ProbeAction, ProbeOutcome>> };
+
+export interface TableFinding {
+  readonly rule: ProbeAction;
+  readonly ok: boolean;
+  readonly doc: string;
+  readonly message: string;
+}
+
+const isRecord = (v: unknown): v is Record<string, unknown> => v !== null && typeof v === 'object' && !Array.isArray(v);
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> {
+  try { return await fn(); } catch { return null; }
+}
+const enc = (id: string): string => encodeURIComponent(id);
+
+async function probe(action: ProbeAction, timeoutMs: number): Promise<ProbeOutcome | string> {
+  const table = `conformance_schema_${randomUUID().replace(/-/g, '').slice(0, 16)}`;
+  const created = await http(() => driver.post('/runs', { workflowId: TABLE_FIXTURE, inputs: { action, table } }));
+  if (created === null) return 'POST /runs unreachable (fetch failed)';
+  if (created.status === 429) return 'POST /runs answered 429 — the run budget of the host, not the wire';
+  const runId = (created.json as { runId?: unknown } | undefined)?.runId;
+  if (created.status !== 201 || typeof runId !== 'string') return `POST /runs {workflowId: ${TABLE_FIXTURE}} answered ${created.status} ${readErrorCode(created.json) ?? ''} — the fixture run was refused`.trim();
+
+  const deadline = Date.now() + timeoutMs;
+  let status = '';
+  for (;;) {
+    const snap = await http(() => driver.get(`/runs/${enc(runId)}`));
+    status = String((snap?.json as { status?: unknown } | undefined)?.status ?? '');
+    if (TERMINAL.has(status)) break;
+    if (Date.now() > deadline) {
+      await http(() => driver.post(`/runs/${enc(runId)}/cancel`, {}));
+      return `the ${action} run did not reach a terminal status within ${timeoutMs} ms (last: ${status || 'unreadable'})`;
+    }
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  const ev = await http(() => driver.get(`/runs/${enc(runId)}/events/poll?timeout=1`));
+  const events = (ev?.json as { events?: unknown } | undefined)?.events;
+  if (ev?.status !== 200 || !Array.isArray(events)) return `GET /runs/{runId}/events/poll answered ${ev?.status ?? 'nothing'} — the run ended but its log could not be read`;
+  const failed = (events as Array<{ type?: unknown; payload?: unknown }>).find((e) => e.type === 'node.failed' && isRecord(e.payload) && e.payload['nodeId'] === NODE_ID)?.payload as Record<string, unknown> | undefined;
+  const error = isRecord(failed?.['error']) ? failed['error'] : null;
+  const details = isRecord(error?.['details']) ? error['details'] : null;
+  return { action, status, code: typeof error?.['code'] === 'string' ? error['code'] : null, service: details?.['service'] };
+}
+
+/** Gate, then one fixture run per action. Asserts nothing. */
+export async function drive(doc: unknown, timeoutMs = 30_000): Promise<TableRun> {
+  const family = isRecord(doc) ? doc['tableStorage'] : undefined;
+  if (!isRecord(family)) return { kind: 'skip', disposition: 'inapplicable', reason: 'tableStorage is not advertised in the v2 discovery root' };
+  if (!isFixtureAdvertised(TABLE_FIXTURE)) return { kind: 'skip', disposition: 'inapplicable', reason: `${TABLE_FIXTURE} fixture not advertised — tableStorage has no protocol path, and the host has not opted in to the unaided schema witness` };
+  const outcomes: Partial<Record<ProbeAction, ProbeOutcome>> = {};
+  for (const action of ACTIONS) {
+    const o = await probe(action, timeoutMs);
+    if (typeof o === 'string') return { kind: 'skip', disposition: 'blocked', reason: o };
+    outcomes[action] = o;
+  }
+  return { kind: 'observed', outcomes: outcomes as Record<ProbeAction, ProbeOutcome> };
+}
+
+const show = (o: ProbeOutcome): string => `${o.status}${o.code ? ` ${o.code}` : ''}${o.service !== undefined ? ` (details.service ${JSON.stringify(o.service)})` : ''}`;
+
+/** What each run must show. Pure. */
+export function judge(outcomes: Readonly<Record<ProbeAction, ProbeOutcome>>): TableFinding[] {
+  const c = outcomes.control;
+  const out: TableFinding[] = [{
+    rule: 'control',
+    ok: c.status === 'completed',
+    doc: 'conformance/fixtures.md §The tableStorage schema probe fixture',
+    message: `a well-typed insert into a table declared { k: string, n: number } MUST complete (got ${show(c)})`,
+  }];
+  for (const action of ['insert-mistyped', 'update-mistyped'] as const) {
+    const o = outcomes[action];
+    const verb = action === 'insert-mistyped' ? 'an insert' : 'an update';
+    const refused = o.status === 'failed' && o.code === 'validation_error';
+    out.push({
+      rule: action,
+      ok: refused && o.service === 'tableStorage',
+      doc: refused ? REFUSAL_DOC : DOC,
+      message: refused
+        ? `a refused tableStorage call with the generic code validation_error MUST carry details.service: tableStorage (got ${show(o)})`
+        : `${verb} whose column types diverge from the declared schema MUST be refused, as validation_error (got ${show(o)})`,
+    });
+  }
+  return out;
+}

package/src/scenarios/trigger-bridge-delivery.test.ts

@@ -16,16 +16,24 @@
  *      (a dead-lettered attempt, `trigger.subscription.state.changed`) carry no
  *      inbound content.
  *
- * TWO WITNESS PATHS. The SEAM path (primary, whenever the host serves them)
- * drives `POST /v1/host/sample/trigger-bridge/deliver` and reads the test
- * event-log seam. When the seams are absent — as they are on every production
- * host — legs 1–3 run the NORMATIVE-SURFACE path of RFC 0230 if the host
- * advertises `triggerBridge.ingestion.inboundSigning: ["standard-webhooks-1"]`:
- * register a webhook subscription and POST Standard-Webhooks-signed bodies to its
- * `ingestUrl` with no OpenWOP credential. Each row notes which path ran
- * (`observed:`). Leg 4 has no normative-surface path — the run-less events are
- * on no run's log — so it stays seam-witnessed and records seam-absent
- * otherwise; it remains in the floor (the floor never narrows).
+ * TWO WITNESS PATHS, and a host is measured on EVERY path it offers (2.45.8).
+ * The SEAM path drives `POST /v1/host/sample/trigger-bridge/deliver` and reads
+ * the test event-log seam; it runs whenever the host serves the seams. The
+ * NORMATIVE-SURFACE path of RFC 0230 registers a webhook subscription and POSTs
+ * Standard-Webhooks-signed bodies to its `ingestUrl` with no OpenWOP credential;
+ * legs 1–3 run it whenever the host advertises
+ * `triggerBridge.ingestion.inboundSigning: ["standard-webhooks-1"]`. A host that
+ * offers both must pass both, and each row notes which ran (`observed:`).
+ *
+ * Until 2.45.8 the normative-surface path ran only when the seams were absent.
+ * That left it unwitnessable on a certified bundle: with the seams mounted it
+ * never ran, and without them leg 4 (seam-only) is red, the profile does not
+ * certify, and an uncertified bundle supplies no acceptance evidence
+ * (RFC 0174 §B.1).
+ *
+ * Leg 4 has no normative-surface path — the run-less events are on no run's
+ * log — so it stays seam-witnessed and records seam-absent otherwise; it
+ * remains in the floor (the floor never narrows).
  *
  * Spec references:
  *   - spec/v1/trigger-bridge.md (§C, §F.2, §F.6)
@@ -65,13 +73,17 @@ function expectContentFree(id: string, payload: Record<string, unknown>, where:
   }
 }
 
-type Path = 'seam' | 'normative' | null;
+/** The witness paths this host offers. Both are run when both are offered. */
+async function witnessPaths(): Promise<{ seam: boolean; normative: boolean }> {
+  return { seam: await isEventLogSeamAvailable(), normative: await inboundSigningAdvertised() };
+}
 
-/** Which witness path this host supports: the seams when present, else RFC 0230's. */
-async function witnessPath(): Promise<Path> {
-  if (await isEventLogSeamAvailable()) return 'seam';
-  if (await inboundSigningAdvertised()) return 'normative';
-  return null;
+/** `ran`, or `absent` when the delivery seam turned out to be unwired; the leg then records it with `seamAbsent`. */
+const SEAM_UNWIRED = 'host advertises openwop-trigger-bridge but the delivery seam is unwired';
+type SeamLeg = 'ran' | 'absent';
+
+function notePaths(seam: boolean, normative: boolean, extra = ''): void {
+  noteObservation([seam ? 'seam path' : '', normative ? 'normative-surface path (RFC 0230)' : ''].filter((x) => x !== '').join(' + ') + extra);
 }
 
 const NO_PATH = 'host advertises openwop-trigger-bridge but neither the event-log seam nor an RFC 0230 inboundSigning ingest is available';
@@ -82,14 +94,14 @@ function bareRunId(runId: string): string {
 }
 
 /** The seam witness path (primary when the host serves the seams). */
-async function dedupViaSeam(): Promise<undefined> {
+async function dedupViaSeam(): Promise<SeamLeg> {
     // The dedupKey is MINTED PER EXERCISE, and that is load-bearing (2.37.0):
     // §C-1's dedup window is a ≥24h floor, so a literal key collides with an
     // earlier run the same day and convicts a conformant host. The repetition
     // §C-1 is about happens INSIDE `driveDelivery`'s `scenario: 'dedup'`.
     const dedupKey = freshDedupKey('queue');
     const dedup = await driveDelivery({ scenario: 'dedup', dedupKey, source: 'queue' });
-    if (dedup === null) return seamAbsent('host advertises openwop-trigger-bridge but the delivery seam is unwired');
+    if (dedup === null) return 'absent';
     const dedupEvents = requireEvents(
       await queryTestEvents(dedup.runId ?? '__dedup__', { type: 'trigger.delivery.attempted' }),
       'trigger.delivery.attempted (dedup)',
@@ -100,15 +112,14 @@ async function dedupViaSeam(): Promise<undefined> {
       expect(typeof e.payload.outcome === 'string' && DELIVERY_OUTCOMES.includes(e.payload.outcome as string), req(R_DEDUP, 'run-event-payloads.schema.json#triggerDeliveryAttempted', 'outcome MUST be delivered|retrying|dead-lettered')).toBe(true);
       expectContentFree(R_DEDUP, e.payload, 'trigger.delivery.attempted');
     }
-    noteObservation('seam path');
     await resetTestSeam();
-  return undefined;
+  return 'ran';
 }
 
 /** The seam witness path (primary when the host serves the seams). */
-async function deadLetterViaSeam(): Promise<undefined> {
+async function deadLetterViaSeam(): Promise<SeamLeg> {
     const exhaust = await driveDelivery({ scenario: 'exhaust', source: 'webhook' });
-    if (exhaust === null) return seamAbsent('host advertises openwop-trigger-bridge but the delivery seam is unwired');
+    if (exhaust === null) return 'absent';
     const exKey = exhaust.runId ?? '__exhaust__';
     const exhaustEvents = requireEvents(await queryTestEvents(exKey, { type: 'trigger.delivery.attempted' }), 'trigger.delivery.attempted (exhaust)');
     expect(exhaustEvents.length >= 1, req(R_DEAD_LETTER, 'trigger-bridge.md §C-2', 'an exhausted delivery MUST emit ≥1 trigger.delivery.attempted')).toBe(true);
@@ -120,13 +131,12 @@ async function deadLetterViaSeam(): Promise<undefined> {
     for (const e of stateEvents) {
       expect(typeof e.payload.toState === 'string' && SUBSCRIPTION_STATES.includes(e.payload.toState as string), req(R_DEAD_LETTER, 'trigger-bridge.md §B', 'toState MUST be in the four-state vocabulary')).toBe(true);
     }
-    noteObservation('seam path');
     await resetTestSeam();
-  return undefined;
+  return 'ran';
 }
 
 /** The seam witness path (primary when the host serves the seams). */
-async function causationViaSeam(): Promise<undefined> {
+async function causationViaSeam(): Promise<SeamLeg> {
     const delivered = await driveDelivery({ scenario: 'deliver', source: 'schedule' });
     expect(delivered !== null && typeof delivered.runId === 'string' && (delivered.runId as string).length > 0, req(R_CAUSATION, 'trigger-bridge.md §C', 'a successful delivery MUST create a run')).toBe(true);
     const deliveredRunId = delivered!.runId as string;
@@ -140,18 +150,18 @@ async function causationViaSeam(): Promise<undefined> {
       typeof runStarted.causationId === 'string' && (runStarted.causationId as string).length > 0 && runStarted.causationId === deliveredEvent!.eventId,
       req(R_CAUSATION, 'trigger-bridge.md §C / RFC 0040', 'run.started.causationId MUST EQUAL the delivery id (the trigger.delivery.attempted{delivered} eventId) — resolvable via /ancestry'),
     ).toBe(true);
-    noteObservation('seam path');
     await resetTestSeam();
-  return undefined;
+  return 'ran';
 }
 
 describe('trigger-bridge-delivery (RFC 0083 §C)', () => {
   it('de-dups by dedupKey: a repeated delivery is effectively-once', async () => {
     if (!behaviorGate('openwop-trigger-bridge', await isTriggerBridgeProfileAdvertised())) return;
-    const path = await witnessPath();
-    if (path === null) return seamAbsent(NO_PATH);
+    const paths = await witnessPaths();
+    if (!paths.seam && !paths.normative) return seamAbsent(NO_PATH);
 
-    if (path === 'seam') return dedupViaSeam();
+    if (paths.seam && (await dedupViaSeam()) === 'absent') return seamAbsent(SEAM_UNWIRED);
+    if (!paths.normative) return notePaths(true, false);
 
     // Normative-surface path (RFC 0230 §C Identity + §D).
     const sub = await registerSignedWebhook('none');
@@ -166,15 +176,16 @@ describe('trigger-bridge-delivery (RFC 0083 §C)', () => {
     expect(again.status, req(R_DEDUP, 'trigger-bridge.md §F.6 / §C-1', `a repeated webhook-id MUST answer 200 duplicate, starting no new run (got ${again.status})`)).toBe(200);
     expect(again.json?.outcome, req(R_DEDUP, 'trigger-bridge.md §F.6', 'the dedup no-op MUST say outcome "duplicate"')).toBe('duplicate');
     expect(again.json?.runId, req(R_DEDUP, 'trigger-bridge.md §F.4', 'a dedup no-op MUST return the PRIOR runId')).toBe(runId);
-    noteObservation('normative-surface path (RFC 0230)');
+    notePaths(paths.seam, true);
   });
 
   it('dead-letters an exhausted or refused delivery without starting a run', async () => {
     if (!behaviorGate('openwop-trigger-bridge', await isTriggerBridgeProfileAdvertised())) return;
-    const path = await witnessPath();
-    if (path === null) return seamAbsent(NO_PATH);
+    const paths = await witnessPaths();
+    if (!paths.seam && !paths.normative) return seamAbsent(NO_PATH);
 
-    if (path === 'seam') return deadLetterViaSeam();
+    if (paths.seam && (await deadLetterViaSeam()) === 'absent') return seamAbsent(SEAM_UNWIRED);
+    if (!paths.normative) return notePaths(true, false);
 
     // Normative-surface path (RFC 0230 §C Verification + §C.1).
     const sub = await registerSignedWebhook('required');
@@ -188,15 +199,16 @@ describe('trigger-bridge-delivery (RFC 0083 §C)', () => {
     expect(state, req(R_DEAD_LETTER, 'trigger-bridge.md §F.6 (RFC 0230 §C.1)', `a refused post MUST NOT change the subscription's state (got ${String(state)})`)).toBe('active');
     const ok = await signedIngest(sub, body);
     expect(ok.status, req(R_DEAD_LETTER, 'trigger-bridge.md §F.6 (RFC 0230 §C.1)', `after a refused post the subscription MUST still deliver a correctly signed one (got ${ok.status})`)).toBe(202);
-    noteObservation('normative-surface path (RFC 0230)');
+    notePaths(paths.seam, true);
   });
 
   it('links delivery→run causation on run.started', async () => {
     if (!behaviorGate('openwop-trigger-bridge', await isTriggerBridgeProfileAdvertised())) return;
-    const path = await witnessPath();
-    if (path === null) return seamAbsent(NO_PATH);
+    const paths = await witnessPaths();
+    if (!paths.seam && !paths.normative) return seamAbsent(NO_PATH);
 
-    if (path === 'seam') return causationViaSeam();
+    if (paths.seam && (await causationViaSeam()) === 'absent') return seamAbsent(SEAM_UNWIRED);
+    if (!paths.normative) return notePaths(true, false);
 
     // Normative-surface path: a signed delivery, then the run's own event log.
     const sub = await registerSignedWebhook('none');
@@ -216,7 +228,7 @@ describe('trigger-bridge-delivery (RFC 0083 §C)', () => {
       expect(causationId, req(R_CAUSATION, 'trigger-bridge.md §C / RFC 0040', 'run.started.causationId MUST EQUAL the delivered attempt event id')).toBe(deliveredEvent.eventId);
       expectContentFree(R_CAUSATION, (deliveredEvent.payload ?? {}) as Record<string, unknown>, 'trigger.delivery.attempted');
     }
-    noteObservation(`normative-surface path (RFC 0230)${deliveredEvent === undefined ? '; the delivered attempt event is not on the run log, so equality was not checked' : ''}`);
+    notePaths(paths.seam, true, deliveredEvent === undefined ? '; on the normative-surface path the delivered attempt event is not on the run log, so equality was not checked there' : '');
   });
 
   it('keeps the run-less trigger events content-free', async () => {

package/src/scenarios/trigger-refused-event-keeps-subscription.test.ts

@@ -24,7 +24,9 @@
  *
  * Gated on the `openwop-trigger-bridge` profile and on
  * `triggerBridge.ingestion.externalSources` listing `webhook`. The uncredentialed
- * public path (RFC 0230, `inboundSigning`) is witnessed separately.
+ * public path (RFC 0230, `inboundSigning`) is witnessed separately, by the
+ * dead-letter leg of `trigger-bridge-delivery`. A host with no seams that
+ * advertises `inboundSigning` therefore records `inapplicable` here.
  *
  * @see spec/v1/trigger-bridge.md §F.2
  * @see spec/v2/core/webhooks.md §Inbound triggers
@@ -36,7 +38,7 @@ import { driver } from '../lib/driver.js';
 import { seamAbsent, softSkip } from '../lib/soft-skip.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
-import { isTriggerBridgeProfileAdvertised } from '../lib/triggerBridge.js';
+import { inboundSigningAdvertised, isTriggerBridgeProfileAdvertised } from '../lib/triggerBridge.js';
 import { queryTestEvents, requireEvents, isEventLogSeamAvailable } from '../lib/event-log-query.js';
 import { req } from '../lib/requirement-ids.js';
 
@@ -59,7 +61,14 @@ describe('trigger-refused-event-keeps-subscription (trigger-bridge.md §F.2)', (
     if (!sources.includes('webhook')) {
       return softSkip('inapplicable', 'triggerBridge.ingestion.externalSources does not list webhook, so the host verifies no inbound webhook event');
     }
-    if (!(await isEventLogSeamAvailable())) return seamAbsent('host ingests external webhooks but the event-log seam is absent');
+    if (!(await isEventLogSeamAvailable())) {
+      // A host with no seams that serves RFC 0230's signed ingest is measured on this same rule
+      // there: the dead-letter leg of `trigger-bridge-delivery` posts a badly signed event, reads the
+      // subscription back `active`, and delivers a signed one (RFC 0230 §C.1). Until 2.45.8 this
+      // file failed such a host in strict mode as "not observable" right after that leg observed it.
+      if (await inboundSigningAdvertised()) return softSkip('inapplicable', 'no delivery seam on this host; the rule is witnessed on its signed public ingest by openwop.requirement.0083.trigger-delivery.dead-letter (RFC 0230 §C.1)');
+      return seamAbsent('host ingests external webhooks but the event-log seam is absent');
+    }
 
     // ---- 1. The refused event -------------------------------------------
     const refusedRes = await driver.post(SEAM, { scenario: 'refused', source: 'webhook' });

package/src/scenarios/trigger-stream-cdc-sources.test.ts

@@ -166,9 +166,18 @@ describe.skipIf(HTTP_SKIP)('trigger-stream-cdc: behavioral ingestion + dedup (ca
       },
     ];
 
+    // Post every source first, so a host that serves neither is recorded before any assertion.
+    const served: { body: Record<string, unknown>; res: Awaited<ReturnType<typeof driver.post>> }[] = [];
     for (const body of bodies) {
       const res = await driver.post('/v1/host/sample/trigger-bridge/ingest', body);
-      if ((res.status === 404 || res.status === 405 || res.status === 400 || res.status === 422) && !advertisesNew) continue; // pre-0127 host — soft-skip this source
+      if ((res.status === 404 || res.status === 405 || res.status === 400 || res.status === 422) && !advertisesNew) continue; // pre-0127 host: this source is not served
+      served.push({ body, res });
+    }
+    // Until 2.45.9 a host that advertises neither source and refuses both passed this leg with zero
+    // assertions and no reason, which RFC 0148 §A records as `blocked` and which denies a major-1 bundle.
+    if (served.length === 0) return softSkip('inapplicable', 'triggerBridge.ingestion.externalSources lists neither stream nor change, and the host refused both (a pre-RFC 0127 host)');
+
+    for (const { body, res } of served) {
       expect(
         res.status < 400,
         req('openwop.it.trigger-stream-cdc-sources.a-stream-and-a-change-event-each-ingest-to-a-run-with-a-schema-valid-envelope-an', 
@@ -220,7 +229,7 @@ describe.skipIf(HTTP_SKIP)('trigger-stream-cdc: behavioral ingestion + dedup (ca
     const dedupKey = freshStreamDedupKey();
     const first = await driveDelivery({ scenario: 'dedup', dedupKey, source: 'stream' });
     if (first === null) return softSkip('blocked', 'precondition not met — `first === null` returned early (delivery seam unwired — soft-skip) (seam, prior step, or fixture unavailable)'); // delivery seam unwired — soft-skip
-    if (first.outcome === undefined && !external.includes('stream')) return softSkip('blocked', 'precondition not met — `first.outcome === undefined && !external.includes(\'stream\')` returned early (pre-0127 host — soft-skip) (seam, prior step, or fixture unavailable)'); // pre-0127 host — soft-skip
+    if (first.outcome === undefined && !external.includes('stream')) return softSkip('inapplicable', 'triggerBridge.ingestion.externalSources does not list stream, and the delivery seam reported no outcome for a stream source (a pre-RFC 0127 host)');
     expect(
       first.deliveredCount === 1 || first.outcome === 'delivered',
       req('openwop.it.trigger-stream-cdc-sources.stream-dedup-the-same-broker-coordinates-delivered-twice-are-effectively-once-c', 

package/src/scenarios/v2-table-schema-enforcement.test.ts

@@ -0,0 +1,82 @@
+/**
+ * v2 — a `tableStorage` row MUST conform to the table's declared schema
+ * (`spec/v2/core/storage.md` §`tableStorage`). The v1 twin is
+ * `table-schema-enforcement`, which drives the `/v1/host/sample/test/surface`
+ * seam; this port is unaided, through the `conformance-table-schema-probe`
+ * fixture. The logic is `lib/table-schema-witness.ts`.
+ *
+ *   control          a well-typed insert into `{ k: string, n: number }`
+ *                    completes (the positive control).
+ *   insert-mistyped  an insert with `n: "not-a-number"` fails the probe node
+ *                    `validation_error`, `details.service: tableStorage`.
+ *   update-mistyped  an update setting `n` to a string fails the same way.
+ *
+ * The refusal code is v2's: RFC 0228 maps v1's `table_schema_violation` to
+ * `validation_error`, and a generic code carries `details.service`
+ * (`errors.md` §Host-service refusals).
+ *
+ * Dispositions: `tableStorage` not in the v2 root, or the fixture not
+ * advertised ⇒ `inapplicable`. The fixture is the opt-in, as for the budget
+ * and safeFetch witnesses. A fixture run that cannot be created or read ⇒
+ * `blocked`. A failed control ⇒ the control row fails and the two refusal
+ * rows are not asserted, since a host that refuses every insert would pass
+ * them vacuously.
+ *
+ * Proven both ways against the scratch host in
+ * `lib/table-schema-witness.test.ts`.
+ *
+ * @see spec/v2/core/storage.md §tableStorage
+ * @see conformance/fixtures.md §The tableStorage schema probe fixture
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Discovery } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { drive, judge, type TableFinding, type TableRun } from '../lib/table-schema-witness.js';
+
+const ID_CONTROL = 'openwop.requirement.storage.table-schema-control-insert-completes';
+const ID_INSERT = 'openwop.requirement.storage.table-schema-insert-mistyped-refused';
+const ID_UPDATE = 'openwop.requirement.storage.table-schema-update-mistyped-refused';
+
+/** One set of probe runs per file: the three legs read it. */
+let once: Promise<TableRun> | undefined;
+function tableRun(): Promise<TableRun> {
+  once ??= (async (): Promise<TableRun> => {
+    let doc: Record<string, unknown> | null;
+    try { doc = await v2Discovery(); } catch { doc = null; }
+    if (!doc) return { kind: 'skip', disposition: 'blocked', reason: 'v2 discovery unreachable — /.well-known/openwop did not answer 200 with a JSON body under OpenWOP-Version: 2.0' };
+    return drive(doc);
+  })();
+  return once;
+}
+
+type Leg = { readonly skip: readonly ['inapplicable' | 'blocked', string] } | { readonly finding: TableFinding };
+async function leg(rule: TableFinding['rule']): Promise<Leg> {
+  const r = await tableRun();
+  if (r.kind === 'skip') return { skip: [r.disposition, r.reason] };
+  const findings = judge(r.outcomes);
+  const control = findings.find((f) => f.rule === 'control')!;
+  if (rule !== 'control' && !control.ok) return { skip: ['blocked', `the control insert did not complete, so a refusal here would prove nothing (${control.message})`] };
+  return { finding: findings.find((f) => f.rule === rule)! };
+}
+
+describe('v2 tableStorage schema enforcement (storage.md §tableStorage)', () => {
+  it('a well-typed insert completes (positive control)', async () => {
+    const l = await leg('control');
+    if ('skip' in l) return softSkip(...l.skip);
+    expect(l.finding.ok, req(ID_CONTROL, l.finding.doc, l.finding.message)).toBe(true);
+  }, 120_000);
+
+  it('an insert whose column type diverges from the schema is refused validation_error', async () => {
+    const l = await leg('insert-mistyped');
+    if ('skip' in l) return softSkip(...l.skip);
+    expect(l.finding.ok, req(ID_INSERT, l.finding.doc, l.finding.message)).toBe(true);
+  }, 120_000);
+
+  it('an update whose column type diverges from the schema is refused validation_error', async () => {
+    const l = await leg('update-mistyped');
+    if ('skip' in l) return softSkip(...l.skip);
+    expect(l.finding.ok, req(ID_UPDATE, l.finding.doc, l.finding.message)).toBe(true);
+  }, 120_000);
+});