@openwop/openwop-conformance 2.25.0 → 2.27.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # `@openwop/openwop-conformance` Changelog
 
+## [2.27.0] — 2026-09-19 — the four RFC 0158 recovery rows
+
+- `v2-durability-recovery.test.ts` — `kill-after-accept` (hold-dispatch), `kill-during-execution` (never observable as completed without re-execution), `duplicate-delivery` (counted per effect identity), `bound-is-derived` (an explicitly-labelled paper check that MUST NOT be cited as evidence the mechanism runs).
+- **Disposition rule:** no `POST /host/durability/kill` route ⇒ `inapplicable` (the host claims no rung); route present but an operator precondition unmet ⇒ `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`.
+- README scenario counts 522 → 523. Suite pinned to corpus `2.27.0`.
+
+## [2.26.0] — 2026-09-19 — RFC 0188 Accepted
+
+- No scenario change. Suite pinned to corpus `2.26.0`; the reference-host bundle it certified is checked in at suite 2.25.0.
+
 ## [2.25.0] — 2026-09-19 — a leg that asserted nothing
 
 - `v2-webhook-durable-delivery` — the `0188.dead-letter-content-free` leg read a **fresh** subscription's sink, looped over zero rows, and asserted nothing; RFC 0148 §A resolves that silent return to `blocked`, denying certification. It now exhausts a real delivery first and asserts over the records it gets, and records `blocked` with a reason when the sink is empty.

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.25.0 @openwop/spec-artifacts@2.25.0
+npm install --legacy-peer-deps @openwop/openwop-conformance@2.27.0 @openwop/spec-artifacts@2.27.0
 # or run without install:
 npx @openwop/openwop-conformance --base-url https://api.example.com --api-key hk_test_...
 ```
@@ -132,7 +132,7 @@ Exit code is non-zero on any failed assertion. `--certify` distinguishes: `0`
 
 ## What's Covered
 
-The current suite has 522 scenario files under `src/scenarios/`.
+The current suite has 523 scenario files under `src/scenarios/`.
 - 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.
 - 2026-08-19 (suite `1.137.0 → 1.138.0`): NEW `durability-poison-exhaustion.test.ts` — RFC 0158 §C.8, the FIRST row of that RFC's conformance table to land. Asserts what `failure-path.test.ts` cannot: not just that deterministically failing work reaches terminal, but that attempts STOP — counted on the log, re-counted after a scaled quiet window, asserted unchanged. A host still redelivering records more. Seam-gated on the existing event-log seam (`blocked` = unobservable, not unmet) and outside every profile floor.
 - 2026-08-19 (suite `1.136.15 → 1.137.0`): NEW `replay-fanout-suppression.test.ts` — capability-gated on `webhooks.supported`, **outside every profile floor**; witnesses `replay.md` §"Host-initiated fan-out is an external effect", which was the largest normative MUST NOT on the replay surface with no scenario and no SECURITY invariant. Three legs in ONE `it` against ONE receiver and ONE subscription — a positive control, the MUST NOT, and a `branch` boundary leg — because "no delivery arrived" passes identically when delivery never worked, so absence is asserted only after presence is proven on that exact wiring. A host with an SSRF guard correctly refuses the loopback receiver and records `blocked`: **unobservable, not unmet.**
@@ -477,7 +477,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: 522 scenario files. Use [`coverage.md`](./coverage.md) for current grade/gap tracking.
+Current source tree: 523 scenario files. Use [`coverage.md`](./coverage.md) for current grade/gap tracking.
 
 ## Remaining Gaps
 

package/coverage.md

@@ -144,6 +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`. |
 | `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.25.0",
-  "stampSha256": "240fb0a1cba70c2a5263b6ef5e150614de639d3cac668c4f7d7875780e0e0a49"
+  "version": "2.27.0",
+  "stampSha256": "8153cf598a911513c1d0232d3ee2e6f33a999660b8e6a404aed1171cd421eddb"
 }

package/package.json

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

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": 579,
-    "tests": 2198,
-    "withStableId": 2198,
+    "files": 580,
+    "tests": 2202,
+    "withStableId": 2202,
     "interpolatedTitles": 0,
-    "explicitIds": 2152
+    "explicitIds": 2156
   },
   "records": [
     {
@@ -26647,6 +26647,62 @@
         }
       ]
     },
+    {
+      "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,
+      "title": "accepted work survives a kill before dispatch and dispatches on resume",
+      "explicitId": "openwop.requirement.0158.kill-after-accept",
+      "citations": [
+        {
+          "section": "RFC 0158 §B.4",
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "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,
+      "title": "work executing at a real process death is never reported complete, and resumes",
+      "explicitId": "openwop.requirement.0158.kill-during-execution",
+      "citations": [
+        {
+          "section": "RFC 0158 §B.4 / §E item 11",
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "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,
+      "title": "the same accepted work delivered twice fires each effect exactly once",
+      "explicitId": "openwop.requirement.0158.duplicate-delivery",
+      "citations": [
+        {
+          "section": "RFC 0158 §C",
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "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,
+      "title": "the declared recovery bound is derived from the mechanism that enforces it",
+      "explicitId": "openwop.requirement.0158.bound-is-derived",
+      "citations": [
+        {
+          "section": "RFC 0158 §B.5",
+          "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/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": 522,
+    "files": 523,
     "v1": 445,
-    "v2": 79
+    "v2": 80
   },
   "majors": {
     "a2a-1-0-agent-card.test.ts": [
@@ -1277,6 +1277,9 @@
     "v2-dual-stack-negotiation.test.ts": [
       2
     ],
+    "v2-durability-recovery.test.ts": [
+      2
+    ],
     "v2-effect-identity-business-key.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.25.0",
-  "corpusTag": "v2.25.0",
+  "version": "2.27.0",
+  "corpusTag": "v2.27.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": "f8a8a952166e13505d28e6859788f3269493fe4c440433442214b282334fef72",
-    "api/v2/asyncapi.yaml": "b165823a2a95a9bbefcb1d71d7768b2031342297077e0c89e414c69eec917ed6",
-    "api/v2/openapi.yaml": "b131c9fbde1e2d39dca11287f277ee9d51d1b83b684f5713f9c6e277f07636ce",
+    "api/seams-v2.yaml": "1dce94833d8e1c8701b45f41280b592ca65c2eb989933635bdf2bda4c5ec92e1",
+    "api/v2/asyncapi.yaml": "e662cd1be3c79e3ca89ff24f0a021c1ce8e9e77d239c3a1f931edde241914525",
+    "api/v2/openapi.yaml": "04cba9484da8fb7a7708d8c927d273daa4775cf9ae9d7dadeb92f9e7a19a174f",
     "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": "c17bb554c788d68fafc3413593dc6686aef0ad65864e925a9d19c4c3833bd0f5",
+    "spec/v1/core-standard-manifest.json": "7a1f2b95997a643482a2223033ad47de828f91b0c1c38f57fe132d80d87dd651",
     "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": "c315b1ff1a7b15dce5e0a0fda70abe67067f39ac5f171668ba8d637867133c51",
+    "spec/v2/release.json": "b1577166696dbdb289d57b52b15c31e62f46848ded4d92b3bf2076920bdcb185",
     "spec/v2/retention-floors.json": "eaf3722d95c79947af1d4269ef85117e126518c588cfcf1a2b21b97269f51624"
   },
-  "corpusCommit": "f0ab0fc3a632d984a9cac159b349e908d54b6919"
+  "corpusCommit": "7032550dc695e608f809cc097196952e80764abe"
 }

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

@@ -0,0 +1,243 @@
+/**
+ * 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.
+ *
+ * ── The disposition ruling, which is the load-bearing design decision ────────
+ * §E says an unmet OPERATOR PRECONDITION is `blocked` with the precondition
+ * named, never a silent skip or a pass. §E also says the seam is "a
+ * non-normative host-extension route … it advertises nothing … a host that
+ * never runs the durability exercises exposes no such route. It is test
+ * infrastructure, not protocol surface."
+ *
+ * Those two sentences describe DIFFERENT states, and collapsing them would
+ * strip certification from the entire fleet the day these rows enter the
+ * major-2 lane, because a `blocked` row denies certification (RFC 0168 §E.1):
+ *
+ *   - NO SEAM ROUTE AT ALL  → `inapplicable`. The host exposes no durability
+ *     seam, which under §E.10 (no capability field is minted) is exactly how a
+ *     host says it claims no durable-execution rung. Blocking a host for a
+ *     claim it never made is the false-refusal half of the same error as a
+ *     vacuous pass.
+ *   - SEAM PRESENT, PRECONDITION UNMET → `blocked`, precondition NAMED. The
+ *     host offered the exercise and could not complete it. That is §E's case.
+ *
+ * ── Why a real kill, and why the interval is kill → RESUMPTION ───────────────
+ * §D.9 rejects "claim semantics asserted without a process death", and §B.4
+ * bounds the interval until another instance becomes eligible to RESUME the
+ * work — not until the work finishes. Timing kill → terminal adds the work's
+ * own execution time and makes a conformant host report a figure over its own
+ * derived bound: a §B.5 violation that did not happen. Both measured failures
+ * are recorded in the RFC.
+ *
+ * ── What this file deliberately does not do ─────────────────────────────────
+ * `durability/peer-resume` is the `durable-multi-instance` discriminator and is
+ * NOT required for the rung these rows witness. §E makes it bundle-witnessed
+ * via an opaque per-boot incarnation token, not black-box observable, so a
+ * scenario here could only ever record `blocked` on the ≥2-instances
+ * precondition. It is omitted rather than written as a row that can never pass
+ * — the defect this session found in `0188.dead-letter-content-free`.
+ *
+ * @see RFCS/0158-durable-execution-and-disaster-recovery-qualification.md §B.4 §D.9 §E
+ */
+
+import { describe, expect, it } from 'vitest';
+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 { req } from '../lib/requirement-ids.js';
+
+const FIXTURE = 'conformance-noop';
+
+/** The host-extension seam these rows drive. Non-normative; advertises nothing. */
+const KILL_SEAM = '/host/durability/kill';
+
+/** How long to wait for the service to answer again after a real termination. */
+const RESUME_WINDOW_MS = 30_000;
+
+type SeamState =
+  | { kind: 'absent'; why: string }
+  | { kind: 'present' };
+
+/**
+ * Probe the seam WITHOUT firing it. A `404`/`405` means the route is not
+ * mounted; anything else means the host offered it and the exercise is on.
+ * A GET is used on purpose: firing the kill to discover whether it exists
+ * would terminate a host that never claimed the rung.
+ */
+async function probeSeam(): Promise<SeamState> {
+  const r = await driver.get(KILL_SEAM);
+  if (r.status === 404 || r.status === 405) {
+    return { kind: 'absent', why: `no RFC 0158 durability seam at ${KILL_SEAM} (HTTP ${r.status}) — §E: the seam advertises nothing and a host that never runs the durability exercises exposes no such route, so this host claims no durable-execution rung` };
+  }
+  return { kind: 'present' };
+}
+
+/** Wait for the service to answer discovery again; null when it never does. */
+async function waitBack(deadlineMs: number): Promise<number | null> {
+  const started = Date.now();
+  while (Date.now() - started < deadlineMs) {
+    try {
+      const r = await driver.get('/.well-known/openwop');
+      if (r.status === 200) return Date.now() - started;
+    } catch { /* the process is down; that is the point */ }
+    await new Promise((r) => setTimeout(r, 250));
+  }
+  return null;
+}
+
+/** Count the run-lifecycle re-starts on a run: §B.4's resumption observation. */
+async function runStartedCount(runId: string): Promise<number> {
+  const r = await driver.get(`/runs/${encodeURIComponent(runId)}/events`);
+  if (r.status !== 200) return -1;
+  const events = (r.json as { events?: Array<{ type?: string }> } | null)?.events ?? [];
+  return events.filter((e) => e.type === 'run.started').length;
+}
+
+describe('v2-durability-recovery (RFC 0158 §B.4, §D.9, §E — the durable-single-instance rows)', () => {
+  it('accepted work survives a kill before dispatch and dispatches on resume', async () => {
+    const doc = await v2Discovery();
+    if (!doc) return softSkip('blocked', 'v2 discovery unreachable');
+    if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', `${FIXTURE} fixture not advertised — no work to accept`);
+    const seam = await probeSeam();
+    if (seam.kind === 'absent') return softSkip('inapplicable', seam.why);
+
+    // §E item 11: kill-after-accept is a HOLD-DISPATCH row, not a
+    // termination-timing row. On a host where acceptance and dispatch are
+    // microseconds apart, racing a kill into that window cannot reliably hit
+    // it — so the seam holds dispatch, the kill lands during the hold, and the
+    // accepted-but-undispatched work dispatches on resume.
+    const fired = await driver.post(KILL_SEAM, { mode: 'after-accept', workflowId: FIXTURE });
+    if (fired.status >= 400) {
+      return softSkip('blocked', `the durability seam answered ${fired.status} for mode=after-accept — the host exposes the route but could not stage the exercise`);
+    }
+    const runId = (fired.json as { runId?: unknown } | null)?.runId;
+    if (typeof runId !== 'string') {
+      return softSkip('blocked', 'the seam staged a kill but named no runId, so there is no accepted work to follow across the death');
+    }
+
+    const backIn = await waitBack(scaledTimeoutMs(RESUME_WINDOW_MS));
+    if (backIn === null) {
+      // §E: kill rows need a RESTART SUPERVISOR — a black-box suite cannot
+      // restart a killed single instance. Name the precondition rather than
+      // reporting a host defect that is really a harness gap.
+      return softSkip('blocked', 'the service never answered again within the window — the operator precondition for this row is a restart supervisor (something must restart the killed instance; the suite cannot)');
+    }
+
+    const starts = await runStartedCount(runId);
+    expect(
+      starts >= 1,
+      req('openwop.requirement.0158.kill-after-accept', 'RFC 0158 §B.4', `work accepted before a real process death MUST dispatch on resume — the run's log MUST show it being executed after the kill, observed ${starts} run.started (service answered again after ${backIn}ms)`),
+    ).toBe(true);
+  }, 120_000);
+
+  it('work executing at a real process death is never reported complete, and resumes', async () => {
+    const doc = await v2Discovery();
+    if (!doc) return softSkip('blocked', 'v2 discovery unreachable');
+    if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', `${FIXTURE} fixture not advertised — no work to execute`);
+    const seam = await probeSeam();
+    if (seam.kind === 'absent') return softSkip('inapplicable', seam.why);
+
+    const fired = await driver.post(KILL_SEAM, { mode: 'during-execution', workflowId: FIXTURE });
+    if (fired.status >= 400) {
+      return softSkip('blocked', `the durability seam answered ${fired.status} for mode=during-execution — the host exposes the route but could not stage the exercise`);
+    }
+    const runId = (fired.json as { runId?: unknown } | null)?.runId;
+    if (typeof runId !== 'string') {
+      return softSkip('blocked', 'the seam staged a kill but named no runId, so the in-flight work cannot be followed across the death');
+    }
+
+    const backIn = await waitBack(scaledTimeoutMs(RESUME_WINDOW_MS));
+    if (backIn === null) {
+      return softSkip('blocked', 'the service never answered again within the window — the operator precondition for this row is a restart supervisor (something must restart the killed instance; the suite cannot)');
+    }
+
+    // §E item 11's first clause, and the one a host is most likely to get
+    // wrong: work that was executing when the process died MUST NOT be
+    // observable as completed. A host that marks it complete on restart has
+    // reported success for work it never finished.
+    const snap = await driver.get(`/runs/${encodeURIComponent(runId)}`);
+    const status = (snap.json as { status?: unknown } | null)?.status;
+    const starts = await runStartedCount(runId);
+    expect(
+      status !== 'completed' || starts > 1,
+      req('openwop.requirement.0158.kill-during-execution', 'RFC 0158 §B.4 / §E item 11', `work executing at a real process death MUST NOT be observable as completed without having been re-executed — read status ${String(status)} with ${starts} run.started (service answered again after ${backIn}ms); §B.4 measures kill → RESUMPTION, never kill → terminal`),
+    ).toBe(true);
+  }, 120_000);
+
+  it('the same accepted work delivered twice fires each effect exactly once', async () => {
+    const doc = await v2Discovery();
+    if (!doc) return softSkip('blocked', 'v2 discovery unreachable');
+    const seam = await probeSeam();
+    if (seam.kind === 'absent') return softSkip('inapplicable', seam.why);
+
+    const fired = await driver.post(KILL_SEAM, { mode: 'duplicate-delivery', workflowId: FIXTURE });
+    if (fired.status >= 400) {
+      return softSkip('blocked', `the durability seam answered ${fired.status} for mode=duplicate-delivery — the host exposes the route but could not stage a double delivery`);
+    }
+    const runId = (fired.json as { runId?: unknown } | null)?.runId;
+    if (typeof runId !== 'string') {
+      return softSkip('blocked', 'the seam staged a duplicate delivery but named no runId');
+    }
+
+    const eff = await driver.get(`/runs/${encodeURIComponent(runId)}/effects`);
+    if (eff.status !== 200) {
+      return softSkip('blocked', `GET /runs/{runId}/effects answered ${eff.status} — per-identity invocation counts are unobservable, so the assertion would be vacuous`);
+    }
+    const effects = (eff.json as { effects?: Array<Record<string, unknown>> } | null)?.effects ?? [];
+    if (effects.length === 0) {
+      return softSkip('blocked', 'the staged run recorded no effects — there is no identity to count invocations against, and an end-state assertion is exactly what §C rules out');
+    }
+    // §C: assert INVOCATION COUNTS PER IDENTITY, not final state. A legal end
+    // state is precisely what a double-fire produces, so an end-state
+    // assertion passes on the defect it exists to catch.
+    const byIdentity = new Map<string, number>();
+    for (const e of effects) {
+      const id = String(e['effectId'] ?? e['keying'] ?? '');
+      if (id === '') continue;
+      byIdentity.set(id, (byIdentity.get(id) ?? 0) + 1);
+    }
+    const doubled = [...byIdentity.entries()].filter(([, n]) => n > 1);
+    expect(
+      doubled.length === 0,
+      req('openwop.requirement.0158.duplicate-delivery', 'RFC 0158 §C', `the same accepted work delivered twice MUST fire each effect exactly once, asserted per effect identity — ${byIdentity.size} identity/identities recorded, ${doubled.length} fired more than once${doubled.length ? ` (${doubled.map(([k, n]) => `${k}×${n}`).join(', ')})` : ''}`),
+    ).toBe(true);
+  }, 120_000);
+
+  it('the declared recovery bound is derived from the mechanism that enforces it', async () => {
+    const doc = await v2Discovery();
+    if (!doc) return softSkip('blocked', 'v2 discovery unreachable');
+    const seam = await probeSeam();
+    if (seam.kind === 'absent') return softSkip('inapplicable', seam.why);
+
+    const terms = await driver.get('/host/durability/bound');
+    if (terms.status === 404 || terms.status === 405) {
+      return softSkip('blocked', 'the host exposes the durability seam but serves no recovery-bound terms — §E puts the per-class arithmetic in the RFC 0148 evidence bundle where a reader can recompute it, and there is nothing here to recompute');
+    }
+    const body = (terms.json as { bound?: unknown; terms?: unknown } | null) ?? {};
+    const bound = typeof body.bound === 'number' ? body.bound : null;
+    const parts = Array.isArray(body.terms) ? (body.terms as unknown[]) : null;
+    if (bound === null || parts === null || parts.length === 0) {
+      return softSkip('blocked', 'the recovery-bound response names no { bound, terms[] } — §E asks for the per-class arithmetic, not a single total (Unresolved Question 1), and a total alone cannot be recomputed');
+    }
+    const summed = parts.reduce<number>((acc, t) => acc + (typeof (t as { ms?: unknown }).ms === 'number' ? (t as { ms: number }).ms : Number.NaN), 0);
+    // THIS ROW IS A PAPER CHECK BY CONSTRUCTION AND THE RFC SAYS SO. It checks
+    // that the declared number follows from the stated mechanism. It cannot
+    // check that the mechanism RUNS: a host whose sweeper wedges has a
+    // derivation that stays perfectly correct while the bound is not produced
+    // at all — a run sat unclaimed for 16 minutes against a derived bound of
+    // 12.5 with every isolated check of the mechanism passing. Only the kill
+    // rows above witness liveness, and this row MUST NOT be cited for it.
+    expect(
+      Number.isFinite(summed) && Math.abs(summed - bound) <= 1,
+      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);
+});