@openwop/openwop-conformance 2.30.0 → 2.31.1

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # `@openwop/openwop-conformance` Changelog
 
+## [2.31.1] — 2026-09-20 — major-correct shared polling
+
+- Fixed the shared run polling helper to use `/runs/{runId}` in the major-2 lane and retain `/v1/runs/{runId}` only in the major-1 lane. The old helper combined a `/v1` path with `OpenWOP-Version: 2`, so a conforming host correctly answered `protocol_version_mismatch`; `v2-durability-recovery` then misreported an unreachable run even though it had already failed terminally.
+- Added a two-major self-test that pins both paths. Suite remains pinned to corpus `2.31.0`; this is a conformance-harness patch only.
+
+## [2.31.0] — 2026-09-19 — the fifth rung row, and the projection helper
+
+- `v2-durability-recovery` gains `poison-exhaustion`, completing RFC 0158's `durable-single-instance` rung at major 2. The existing scenario was major-1 only and seam-bound; the port reads the canonical `GET /runs/{runId}/events` and needs **no seam**, so it can never record `blocked` for want of one. The v1 scenario is untouched.
+- `src/lib/v2-projection.ts` — `stripSupported()` (every depth, including `required[]`) and `carriesUnspliceablePayload()`. Three hand-written v1→v2 projections went wrong in one week; this is the one function they were each re-deriving. It reports unspliceable payload rather than converting it (RFC 0193 §B: only a person can name the seat).
+- Suite pinned to corpus `2.31.0`.
+
 ## [2.30.0] — 2026-09-19 — the unbacked ratchet
 
 - No scenario change. `check-registers` now actually ratchets the open-risk count it has always printed `(ratchet)` after. Suite pinned to corpus `2.30.0`.

package/README.md

@@ -11,7 +11,7 @@
 # --legacy-peer-deps is REQUIRED, not optional: the exact peer pin is what npm's
 # default resolver refuses. npm 10.9 fails outright with
 # "Cannot read properties of null (reading 'edgesOut')" — use npm >= 11.
-npm install --legacy-peer-deps @openwop/openwop-conformance@2.30.0 @openwop/spec-artifacts@2.30.0
+npm install --legacy-peer-deps @openwop/openwop-conformance@2.31.1 @openwop/spec-artifacts@2.31.1
 # or run without install:
 npx @openwop/openwop-conformance --base-url https://api.example.com --api-key hk_test_...
 ```

package/coverage.md

@@ -144,7 +144,7 @@ The scenario groups in the table below (one row per group; count the rows — th
 | `tool-session-lifecycle.test.ts`                                                                                                                                                                                                                        | `capabilities.toolCatalog.sessionLifecycle` (RFC 0078 §D, `tool-catalog.md`)                                                                                                                                                                                                                                            | A (the §D bracket via `POST /v1/host/sample/tools/session-run` + the test event-log seam: `tool.session.opened` before the first RFC 0064 call event → `tool.session.closed` after the last, one shared `sessionId`, each carrying a `toolId`, `closed.outcome` ∈ {completed,failed,aborted,expired}, both content-free)                                                                                                                                                                                                                                                                                                                                                                            | `host-pending`                                                                                                                   | `behaviorGate('openwop-tool-session-lifecycle', …)`. Seam-gated; soft-skips on 404. **Part of the RFC 0078 → Accepted bar.** First adopter: MyndHyve `toolCatalog`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 | `egress-audience-binding.test.ts`                                                                                                                                                                                                                       | `capabilities.httpClient.egressPolicy.supported` (RFC 0079 §C, `host-capabilities.md`) + `SECURITY/invariants.yaml` `egress-credential-audience-bound`                                                                                                                                                                  | A (KEYSTONE — the §C confused-deputy MUST via `POST /v1/host/sample/egress/decide`: an out-of-audience egress is `denied`/`downgraded` with `reason:"out-of-audience"` and the credential is NOT attached (`credentialAttached !== true`); a provenance-unevaluable egress fails closed `denied`+`reason:"provenance-unevaluable"`; decision/reason ∈ the closed enums)                                                                                                                                                                                                                                                                                                                             | `host-pending`                                                                                                                   | `behaviorGate('openwop-egress-audience-binding', …)`. Seam-gated; soft-skips on 404. **This is the RFC 0079 → Accepted bar** (the `egress-credential-audience-bound` invariant graduates reference-impl → protocol tier when this passes against a host). First adopter: MyndHyve `httpClient.egressPolicy`.                                                                                                                                                                                                                                                                                                                            |
 | `egress-decision-content-free.test.ts`                                                                                                                                                                                                                  | `capabilities.httpClient.egressPolicy.supported` (RFC 0079 §F / SR-1)                                                                                                                                                                                                                                                   | A (the secret non-leak — a `canary` credential's sentinel never surfaces in the decision (`canaryLeaked !== true`), the `egress.decided` payload carries no forbidden content key, and `reason` stays in the CLOSED vocabulary so no blocked destination spills into a free-form field)                                                                                                                                                                                                                                                                                                                                                                                                             | `host-pending`                                                                                                                   | `behaviorGate('openwop-egress-decision-content-free', …)`. Seam-gated; soft-skips on 404. **Part of the RFC 0079 → Accepted bar.** First adopter: MyndHyve `httpClient.egressPolicy`.                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| `v2-durability-recovery.test.ts` | the RFC 0158 host-extension durability seam `POST /host/durability/kill` (non-normative; §E mints no capability field, so seam PRESENCE is how a host says it claims a rung) | A (the four `durable-single-instance` rows: `kill-after-accept` as a HOLD-DISPATCH exercise, `kill-during-execution` asserting that work executing at a real process death is never observable as completed without re-execution, `duplicate-delivery` counted PER EFFECT IDENTITY rather than by end state, and `bound-is-derived` as an explicitly-labelled paper check) | `host-pending` | **Disposition rule, and it protects fleet certification:** no seam route at all ⇒ `inapplicable` (the host claims no rung); seam present but an operator precondition unmet — a restart supervisor, which a black-box suite cannot supply — ⇒ `blocked` with the precondition NAMED. Collapsing the two would deny certification to every host the day these rows entered the lane. `peer-resume` is deliberately NOT written: §E makes it bundle-witnessed, so a scenario could only ever record `blocked`. **This is the RFC 0158 → Accepted bar**, and its witness is openwop-app, which the RFC records as having observed `kill-during-execution` across a real `SIGKILL`. |
+| `v2-durability-recovery.test.ts` | the RFC 0158 host-extension durability seam `POST /host/durability/kill` (non-normative; §E mints no capability field, so seam PRESENCE is how a host says it claims a rung) | A (all five `durable-single-instance` rows: `kill-after-accept` as a HOLD-DISPATCH exercise, `kill-during-execution` asserting that work executing at a real process death is never observable as completed without re-execution, `duplicate-delivery` counted PER EFFECT IDENTITY rather than by end state, `bound-is-derived` as an explicitly-labelled paper check, and `poison-exhaustion` ported from the major-1 scenario — at major 2 it reads the canonical `GET /runs/{runId}/events`, so unlike its v1 twin it needs NO seam and can never record `blocked` for want of one a host did not wire) | `host-pending` | **Disposition rule, and it protects fleet certification:** no seam route at all ⇒ `inapplicable` (the host claims no rung); seam present but an operator precondition unmet — a restart supervisor, which a black-box suite cannot supply — ⇒ `blocked` with the precondition NAMED. Collapsing the two would deny certification to every host the day these rows entered the lane. `peer-resume` is deliberately NOT written: §E makes it bundle-witnessed, so a scenario could only ever record `blocked`. **This is the RFC 0158 → Accepted bar, and it is now complete at major 2** — before the port, a major-2 bundle could carry at most four of the five rows and the rung was unwitnessable no matter what a host did, and its witness is openwop-app, which the RFC records as having observed `kill-during-execution` across a real `SIGKILL`. |
 | `memory-degraded-projection.test.ts`                                                                                                                                                                                                                    | `capabilities.agents.manifestRuntime.supported` + `capabilities.memory.supported` (RFC 0080 §C, `agent-memory.md`)                                                                                                                                                                                                      | A (the §C iff-contract on the NORMATIVE `GET /v1/agents`: a degraded entry MUST carry `memoryDegraded:true` + a non-empty, unique `degradedMemoryDimensions[]` drawn from the closed §A-name enum [read/write/search/long-term-durability/compaction/attribution/replay-snapshot/retention]; a non-degraded entry MUST NOT carry a non-empty list; the inventory is non-empty; the degraded branch runs non-vacuously when `OPENWOP_DEGRADED_AGENT_ID` names a known-degraded agent)                                                                                                                                                                                                                | `host-pending`                                                                                                                   | `behaviorGate('openwop-memory-degraded', …)`. Black-box on the normative path (no POST seam); soft-skips on 404 / when the host computes no degradation. **This is the RFC 0080 → Accepted bar.** First adopter: MyndHyve `memory`.                                                                                                                                                                                                                                                                                                                                                                                                     |
 | `budget-enforcement.test.ts`                                                                                                                                                                                                                            | `capabilities.budget.supported` (RFC 0084 §C/§D, `budget-policy.md`) + `SECURITY/invariants.yaml` `budget-no-pricing-leak`                                                                                                                                                                                              | A (the §C/§D enforcement via `POST /v1/host/sample/budget/run` + the test event-log seam: a `hard-cost-exhaust` run emits the strict-ordered `budget.reserved → budget.consumed → budget.threshold.crossed{percent} → budget.exhausted → cap.breached{kind:"budget-cost"} → run.failed{error:"budget_exhausted"}` chain; a `model-denied` run is refused `budget_model_denied` BEFORE the provider call (fail-closed); an `advisory` host emits the `budget.*` events without stopping; every `budget.*` payload content-free — no pricing/rate)                                                                                                                                                    | `host-pending`                                                                                                                   | `behaviorGate('openwop-budget-enforcement', …)`. Seam-gated; soft-skips on 404. **This is the RFC 0084 → Accepted bar.** First adopter: MyndHyve `budget`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 | `agent-platform-aggregate-evidence.test.ts`                                                                                                                                                                                                             | `openwop-agent-platform` claim — live discovery `profiles[]` includes it (RFC 0085 §C, `agent-platform-profile.md`)                                                                                                                                                                                                     | A (the §C/§D honest-advertisement on live `/.well-known/openwop`: a host claiming `openwop-agent-platform` MUST satisfy the §B floor predicate (`isAgentPlatformPartial` → `partial`/`full`, never `none`), the claim backed by per-capability evidence not the profile string; `OPENWOP_AGENT_PLATFORM_TIER=full` forces the full-predicate bar — all governance terms + tenant installScope + all 16 §D terms)                                                                                                                                                                                                                                                                                    | `host-pending`                                                                                                                   | `behaviorGate('openwop-agent-platform', …)`. Black-box on the discovery doc (no POST seam); soft-skips until a host claims the profile. **This is the RFC 0085 → Accepted bar.** First adopter: MyndHyve (after the memory batch surfaces the floor's `memory.supported`).                                                                                                                                                                                                                                                                                                                                                              |

package/dist/spec-artifacts.lock.json

@@ -1,5 +1,5 @@
 {
   "package": "@openwop/spec-artifacts",
-  "version": "2.30.0",
-  "stampSha256": "960e276b864a7d7ddca28bb0ce04b72ccd7e0ec6f95fa9d2b42918732b16c1d4"
+  "version": "2.31.1",
+  "stampSha256": "7d8c030abbf9fd38c0f527eaa57d0d1621bdbf1c94463854c33c2399e52866f9"
 }

package/package.json

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

package/requirements.json

@@ -3,10 +3,10 @@
   "generatedFrom": "src/scenarios/*.test.ts",
   "counts": {
     "files": 581,
-    "tests": 2204,
-    "withStableId": 2204,
+    "tests": 2205,
+    "withStableId": 2205,
     "interpolatedTitles": 0,
-    "explicitIds": 2158
+    "explicitIds": 2159
   },
   "records": [
     {
@@ -26650,7 +26650,7 @@
     {
       "id": "openwop.it.v2-durability-recovery.accepted-work-survives-a-kill-before-dispatch-and-dispatches-on-resume",
       "file": "v2-durability-recovery.test.ts",
-      "line": 105,
+      "line": 129,
       "title": "accepted work survives a kill before dispatch and dispatches on resume",
       "explicitId": "openwop.requirement.0158.kill-after-accept",
       "citations": [
@@ -26664,7 +26664,7 @@
     {
       "id": "openwop.it.v2-durability-recovery.work-executing-at-a-real-process-death-is-never-reported-complete-and-resumes",
       "file": "v2-durability-recovery.test.ts",
-      "line": 141,
+      "line": 165,
       "title": "work executing at a real process death is never reported complete, and resumes",
       "explicitId": "openwop.requirement.0158.kill-during-execution",
       "citations": [
@@ -26678,7 +26678,7 @@
     {
       "id": "openwop.it.v2-durability-recovery.the-same-accepted-work-delivered-twice-fires-each-effect-exactly-once",
       "file": "v2-durability-recovery.test.ts",
-      "line": 175,
+      "line": 199,
       "title": "the same accepted work delivered twice fires each effect exactly once",
       "explicitId": "openwop.requirement.0158.duplicate-delivery",
       "citations": [
@@ -26692,7 +26692,7 @@
     {
       "id": "openwop.it.v2-durability-recovery.the-declared-recovery-bound-is-derived-from-the-mechanism-that-enforces-it",
       "file": "v2-durability-recovery.test.ts",
-      "line": 214,
+      "line": 238,
       "title": "the declared recovery bound is derived from the mechanism that enforces it",
       "explicitId": "openwop.requirement.0158.bound-is-derived",
       "citations": [
@@ -26703,6 +26703,29 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-durability-recovery.deterministically-failing-work-reaches-a-terminal-state-and-stops-being-retried",
+      "file": "v2-durability-recovery.test.ts",
+      "line": 268,
+      "title": "deterministically failing work reaches a terminal state and stops being retried",
+      "explicitId": "openwop.requirement.0158.poison-exhaustion",
+      "citations": [
+        {
+          "section": "RFC 0158 §C.8",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "RFC 0158 §C.8",
+          "requirement": "at least one attempt MUST be recorded — zero attempts means nothing was ever delivered, and the bound below would hold vacuously"
+        },
+        {
+          "section": "RFC 0158 §C.8",
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
     {
       "id": "openwop.it.v2-effect-identity-business-key.get-runs-runid-effects-validates-and-every-row-is-keyed-on-business-identity-or",
       "file": "v2-effect-identity-business-key.test.ts",

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.30.0",
-  "corpusTag": "v2.30.0",
+  "version": "2.31.1",
+  "corpusTag": "v2.31.0",
   "files": {
     "api/.redocly.lint-ignore.yaml": "bf5a8350b88a72fa43f59605ed8d903ed24b6cfccda5e45509c9f6ed9ee4e712",
     "api/asyncapi.yaml": "d5ecb9ee6114582be3b1f662c84bfac9ae96dae7bacb853e461168f70a8e1c7d",
     "api/grpc/openwop.proto": "c3e72bb17cba514ee98feb6434e6c9b6ea6795bfd086489ec69fd882dd1ad977",
     "api/openapi.yaml": "39081c59fb696159806b0f2f9a42e7e9ff830d622fcf2ad4159b21357580a955",
     "api/redocly.yaml": "b0604c89b2ca6d5076ec25725c539dad44a741a811fe524439ee6daef8baa09f",
-    "api/seams-v2.yaml": "378fb7c3325adb156d1a7ac0b9f024b3685d7fc424ede769c170f35be88288c7",
-    "api/v2/asyncapi.yaml": "d7c04a5737fcfdf1967bed784954fbaa822e28be7834bd305484d889b6fcfb59",
-    "api/v2/openapi.yaml": "ee4b91c42e8f8ae4fcb685be5a2184444d6d148ef33ece8adfbcbd36973750f0",
+    "api/seams-v2.yaml": "dfecf104a518efca7b9b915578c4198c6a9e1f8965d8e84fc300bbbafc5503e7",
+    "api/v2/asyncapi.yaml": "577bd2252f10d8c3dceaac0dc7855925cc466e06fd6bf1613b8e451869fcdc54",
+    "api/v2/openapi.yaml": "82b884b23460438059a5b38b47b5f3e883d03365013ed8c2632b664417c0f699",
     "api/v2/redocly.yaml": "1e66b60e6118ad11a823bb620678be464d99dfe50a40e3e6f93ec9429b88b34c",
     "schemas/README.md": "0c0b737ffcf8f30e7d2809cec8a498232de710f41443212922ad8337cdde0b51",
     "schemas/a2a-task-state.schema.json": "c9365918f993f943b4b619d42551eb066a1ed33a08d895d51b395432a5b1f1bc",
@@ -201,7 +201,7 @@
     "schemas/workspace-file.schema.json": "464de85c2a068243084ee9c1d969bc7cd5d8f7948574e58450d6493c38a0e1e4",
     "spec/v1/alias-detectors.json": "40069d5976eeb6ba1384a648e57e5cfd673db3fce36175115fb8293bee9664d4",
     "spec/v1/capability-declaration-classes.json": "e7729aed5c4b4e1dd02abab0530f14cc95f5d4070fe51fb139e7f5cccefa00c6",
-    "spec/v1/core-standard-manifest.json": "938ee6f714634dd116c900a6d87852a868c6bb21a74603d479d58edbc1b783b6",
+    "spec/v1/core-standard-manifest.json": "0640fb5fdced5af7a5e2ae2108c69da13d79bd3c5373128ee5039e9cd1af0e43",
     "spec/v1/deprecations.json": "307083ce29c23fd406015951f99a30d78d6187ff061d38dc9732f62191b40f3f",
     "spec/v1/deprecations.schema.json": "18c87e78bedc210431f795ae44c5b5d202f2f3317850d5cf86867d4f1fa1cdfb",
     "spec/v1/event-codemap.json": "3da60d884157793a360da532a9fcbbfb5285636db325a74cec94b34622186d97",
@@ -279,8 +279,8 @@
     "spec/v2/path-manifest.json": "c123c9fd77dc1b3f9c2e9346ace80cdae007e6511138894956abda01e61ec1c6",
     "spec/v2/peer-dependency-aliases.json": "d10299280abee08258502925bc327293ee413e0108cd6e6ec75ff6110653308d",
     "spec/v2/profiles.json": "0636f19fceae625390003a347e70ef4797d84766b5c24ce8a02cea52aadebca4",
-    "spec/v2/release.json": "d34f8f71a7c34a56fa4ab1c16915525cd4a18b450dccdbdca19157a3732a6cec",
+    "spec/v2/release.json": "92131d62a7fcd12445d7e04eb588e2297f839b7e5e2a87f89ae9e61593f837cd",
     "spec/v2/retention-floors.json": "eaf3722d95c79947af1d4269ef85117e126518c588cfcf1a2b21b97269f51624"
   },
-  "corpusCommit": "1b33fe1a11d465c368e4d4b63a88879371137d85"
+  "corpusCommit": "691974ccf758a6ea42dad8c38ab6b5570e8f89f2"
 }

package/src/lib/polling.ts

@@ -28,6 +28,7 @@
  */
 
 import { driver } from './driver.js';
+import { targetMajor } from './seams.js';
 
 export interface RunSnapshot {
   readonly runId: string;
@@ -73,9 +74,14 @@ export function scaledTimeoutMs(timeoutMs: number): number {
 const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
 
 export async function getRun(runId: string): Promise<RunSnapshot> {
-  const res = await driver.get(`/v1/runs/${encodeURIComponent(runId)}`);
+  // A major-2 request MUST use the unversioned path space. The driver adds the
+  // OpenWOP-Version: 2 header, so retaining `/v1` here asked the host to serve
+  // two different majors at once and a conforming negotiator correctly refused
+  // it with protocol_version_mismatch. Keep the v1 key only in the v1 lane.
+  const prefix = targetMajor() === 2 ? '' : '/v1';
+  const res = await driver.get(`${prefix}/runs/${encodeURIComponent(runId)}`);
   if (res.status !== 200) {
-    throw new Error(`GET /v1/runs/${runId} returned ${res.status}: ${res.text.slice(0, 200)}`);
+    throw new Error(`GET ${prefix}/runs/${runId} returned ${res.status}: ${res.text.slice(0, 200)}`);
   }
   return res.json as RunSnapshot;
 }

package/src/lib/v2-projection.ts

@@ -0,0 +1,74 @@
+/**
+ * Project a v1 capability value into its v2 shape.
+ *
+ * WHY THIS EXISTS, in three measured instances from one week:
+ *
+ *   - openwop-app projected `aiProviders.selfHosted` by hand and turned a v1
+ *     `string[]` into a v2 `boolean`.
+ *   - The steward's own hand-authored v2 facet override flattened
+ *     `aiProviders.input` and `aiProviders.policies` to
+ *     `{ type: 'object', additionalProperties: true }` — losing the RFC 0091
+ *     `modalities` enum, so a misspelled modality would have validated.
+ *
+ * Three hand-written projections, each wrong in a different direction. That is
+ * not three mistakes; it is one missing function. A hand-written v2 copy is a
+ * second source of truth, and the second source drifts.
+ *
+ * ── What the projection actually is ─────────────────────────────────────────
+ * v2 retired the `supported` flag: presence of the record is the claim
+ * (RFC 0192). v1 owners carry `supported` NESTED INSIDE each facet, not only at
+ * family level, so a strip that only looks at the top level leaves ghosts
+ * behind — which is exactly how 26 facet descriptions came to condition a MUST
+ * on a field the closed v2 schema forbids. This strips at every depth.
+ *
+ * It deliberately does NOT invent shape. If a v1 value carries payload a v2
+ * record cannot hold, that is RFC 0193's named-seat problem and needs a person
+ * to name the seat; this function will not paper over it.
+ */
+
+/** Recursively drop `supported` — at every depth, and out of any `required[]`. */
+export function stripSupported<T>(value: T): T {
+  if (Array.isArray(value)) return value.map((v) => stripSupported(v)) as unknown as T;
+  if (value === null || typeof value !== 'object') return value;
+
+  const out: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+    if (k === 'supported') continue;
+    out[k] = stripSupported(v);
+  }
+  // A `required` list naming `supported` keeps a retired field mandatory, which
+  // is how a closed v2 record ends up unsatisfiable by any honest host.
+  if (Array.isArray(out['required'])) {
+    const kept = (out['required'] as unknown[]).filter((r) => r !== 'supported');
+    if (kept.length > 0) out['required'] = kept;
+    else delete out['required'];
+  }
+  return out as T;
+}
+
+/**
+ * True when a v1 value carries payload a uniform v2 record cannot splice —
+ * an array, a map, an enum or a scalar rather than an object with properties.
+ *
+ * RFC 0193: the v2 generator builds a record by splicing the seeded v1
+ * property's `properties` in as siblings, so a family that WAS an object kept
+ * its payload (`limits`) and one that was an array, a map or an enum lost it
+ * SILENTLY. A production host published `supportedEnvelopes: {status:"stable"}`
+ * — a stable claim to an envelope-kind catalog containing no catalog.
+ *
+ * Callers use this to REFUSE rather than to guess. The seat name cannot be
+ * derived, because the v1 value *was* the whole property; only a person can
+ * name it.
+ */
+export function carriesUnspliceablePayload(v1Value: unknown): boolean {
+  if (v1Value === null || typeof v1Value !== 'object' || Array.isArray(v1Value)) return false;
+  const p = v1Value as Record<string, unknown>;
+  const props = p['properties'];
+  if (props !== undefined && typeof props === 'object' && props !== null && Object.keys(props).length > 0) return false;
+  if (p['type'] === 'boolean') return false; // presence of the record IS the claim
+  if (Array.isArray(p['enum'])) return true;
+  if (p['type'] === 'array') return true;
+  if (p['type'] === 'string' || p['type'] === 'integer' || p['type'] === 'number') return true;
+  if (p['type'] === 'object' && typeof p['additionalProperties'] === 'object' && p['additionalProperties'] !== null) return true;
+  return false;
+}

package/src/scenarios/v2-durability-recovery.test.ts

@@ -1,12 +1,18 @@
 /**
  * RFC 0158 — the `durable-single-instance` recovery rows.
  *
- * These are the four rows the RFC names that no scenario has ever existed for.
- * `durability/poison-exhaustion` is the fifth and is written
- * (`durability-poison-exhaustion.test.ts`) — but it is registered at MAJOR 1
- * ONLY, so no v2 bundle has ever carried a durability row of any kind. Porting
- * it to major 2 needs the v2 event-log read and is tracked separately; without
- * it, the rung is still unwitnessable at major 2 even when these four pass.
+ * All five `durable-single-instance` rows the RFC names, four of which no
+ * scenario had ever existed for.
+ *
+ * `durability/poison-exhaustion` DID exist
+ * (`durability-poison-exhaustion.test.ts`) but was registered at MAJOR 1 ONLY
+ * and read a hard-coded `/v1/host/sample/test/runs/{runId}/events` seam, so no
+ * v2 bundle could carry a durability row of any kind and the rung was
+ * unwitnessable at major 2 even with the other four passing. The port is the
+ * fifth `it` below, and it needs NO SEAM: at major 2 the canonical
+ * `GET /runs/{runId}/events` answers the same question the v1 sample seam was
+ * invented to answer, so the row can never be `blocked` for want of a seam a
+ * host did not wire. The v1 scenario stays where it is, unchanged.
  *
  * ── The disposition ruling, which is the load-bearing design decision ────────
  * §E says an unmet OPERATOR PRECONDITION is `blocked` with the precondition
@@ -51,10 +57,28 @@ import { driver } from '../lib/driver.js';
 import { v2Discovery } from '../lib/v2.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { softSkip } from '../lib/soft-skip.js';
-import { scaledTimeoutMs } from '../lib/polling.js';
+import { pollUntilTerminal, scaledTimeoutMs } from '../lib/polling.js';
 import { req } from '../lib/requirement-ids.js';
 
 const FIXTURE = 'conformance-noop';
+const FAILURE_FIXTURE = 'conformance-failure';
+
+/** A `node.started` is attempt 1; each `node.retried` is one more. Counting BOTH
+ *  catches a host that re-dispatches without emitting `node.retried`. */
+const ATTEMPT_TYPES = new Set(['node.started', 'node.retried']);
+
+/** Watch window after terminal. A LONGER wait is a STRONGER claim here, because
+ *  it is a wait for something that must not happen. */
+const QUIET_WINDOW_MS = 4_000;
+
+/** The canonical major-2 run-event read. Null when it does not answer. */
+async function runEvents(runId: string): Promise<Array<{ type: string }> | null> {
+  const r = await driver.get(`/runs/${encodeURIComponent(runId)}/events`);
+  if (r.status !== 200) return null;
+  const events = (r.json as { events?: Array<{ type?: unknown }> } | null)?.events;
+  if (!Array.isArray(events)) return null;
+  return events.filter((e): e is { type: string } => typeof e.type === 'string');
+}
 
 /** The host-extension seam these rows drive. Non-normative; advertises nothing. */
 const KILL_SEAM = '/host/durability/kill';
@@ -240,4 +264,55 @@ describe('v2-durability-recovery (RFC 0158 §B.4, §D.9, §E — the durable-sin
       req('openwop.requirement.0158.bound-is-derived', 'RFC 0158 §B.5', `the declared recovery bound MUST follow from the per-class terms that produce it — declared ${bound}, terms sum to ${summed}. A host that states a bound it cannot produce fails; a host whose sweeper wedges still passes, which is why this row MUST NOT be read as evidence that the mechanism runs`),
     ).toBe(true);
   }, 120_000);
+
+  it('deterministically failing work reaches a terminal state and stops being retried', async () => {
+    // NO SEAM GATE. The v1 twin reads `/v1/host/sample/test/runs/{runId}/events`
+    // and records `blocked` when a host has not wired it — "unobservable, not
+    // unmet". At major 2 the canonical run-event read answers the same
+    // question, so this row is black-box and cannot be blocked for want of
+    // infrastructure. That is the whole reason the port was worth doing rather
+    // than dual-majoring the original.
+    const doc = await v2Discovery();
+    if (!doc) return softSkip('blocked', 'v2 discovery unreachable');
+    if (!isFixtureAdvertised(FAILURE_FIXTURE)) {
+      return softSkip('inapplicable', `${FAILURE_FIXTURE} fixture not advertised — there is no deterministically failing work to bound`);
+    }
+
+    const create = await driver.post('/runs', { workflowId: FAILURE_FIXTURE });
+    if (create.status !== 201) return softSkip('blocked', `POST /runs answered ${create.status} for the failing fixture`);
+    const runId = (create.json as { runId: string }).runId;
+
+    // First clause: a terminal, operator-visible state.
+    const terminal = await pollUntilTerminal(runId, { timeoutMs: scaledTimeoutMs(30_000) });
+    expect(
+      terminal.status,
+      req('openwop.requirement.0158.poison-exhaustion', 'RFC 0158 §C.8', `deterministically failing work MUST reach a terminal, operator-visible state — read ${terminal.status}`),
+    ).toBe('failed');
+
+    const before = await runEvents(runId);
+    if (before === null) return softSkip('blocked', 'GET /runs/{runId}/events did not answer — attempts are unobservable, so boundedness would be a vacuous claim');
+    // Non-vacuity: the failure must actually be ON the log. Without this a host
+    // returning an empty array sails through every count comparison below,
+    // because 0 === 0 after any wait.
+    if (!before.some((e) => e.type === 'node.failed')) {
+      return softSkip('blocked', 'the run log records no node.failed — an empty or unprojected log makes every attempt count vacuous');
+    }
+    const attemptsBefore = before.filter((e) => ATTEMPT_TYPES.has(e.type)).length;
+    expect(
+      attemptsBefore > 0,
+      req('openwop.requirement.0158.poison-exhaustion', 'RFC 0158 §C.8', 'at least one attempt MUST be recorded — zero attempts means nothing was ever delivered, and the bound below would hold vacuously'),
+    ).toBe(true);
+
+    // The load-bearing clause: NOT redelivered indefinitely. "The run reached
+    // failed" says nothing about it — a host that redelivers forever ALSO
+    // reports a terminal status at some point. Count, wait, count again.
+    await new Promise((r) => setTimeout(r, scaledTimeoutMs(QUIET_WINDOW_MS)));
+    const after = await runEvents(runId);
+    if (after === null) return softSkip('blocked', 'the second GET /runs/{runId}/events did not answer, so the stability comparison has one side');
+    const attemptsAfter = after.filter((e) => ATTEMPT_TYPES.has(e.type)).length;
+    expect(
+      attemptsAfter,
+      req('openwop.requirement.0158.poison-exhaustion', 'RFC 0158 §C.8', `attempts MUST NOT continue after the run reports terminal — a host still redelivering records more (${attemptsBefore} before the quiet window, ${attemptsAfter} after)`),
+    ).toBe(attemptsBefore);
+  }, 120_000);
 });