@openwop/openwop-conformance 2.0.0-rc.47 → 2.0.0-rc.49

package/README.md

@@ -112,7 +112,7 @@ Exit code is non-zero on any failed assertion. `--certify` distinguishes: `0`
 
 ## What's Covered
 
-The current suite has 505 scenario files under `src/scenarios/`.
+The current suite has 513 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.**
@@ -457,7 +457,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: 505 scenario files. Use [`coverage.md`](./coverage.md) for current grade/gap tracking.
+Current source tree: 513 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.0.0-rc.47",
-  "stampSha256": "e01df77670a96a963b5061a29eb92f4f77e204c8ea65061dba2787a44a97e135"
+  "version": "2.0.0-rc.49",
+  "stampSha256": "7e65e852ca8df98dbfd604c7da903894a0cbd15feec6fe88f2e0879f88187f22"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openwop/openwop-conformance",
-  "version": "2.0.0-rc.47",
+  "version": "2.0.0-rc.49",
   "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.0.0-rc.47"
+    "@openwop/spec-artifacts": "2.0.0-rc.49"
   }
 }

package/requirement-aliases.json

@@ -1,4 +1,6 @@
 {
   "$comment": "old id → new id. Add a row when a test title is reworded so bundles citing the old id still resolve.",
-  "aliases": {}
+  "aliases": {
+    "openwop.it.v2-run-cancel.cancelling-a-terminal-run-answers-409-run-terminal-or-200-idempotently-the-prose": "openwop.it.v2-run-cancel.cancelling-a-terminal-run-is-refused-409-run-terminal"
+  }
 }

package/requirements.json

@@ -2,9 +2,9 @@
   "$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": 554,
-    "tests": 2133,
-    "withStableId": 2132,
+    "files": 562,
+    "tests": 2145,
+    "withStableId": 2144,
     "interpolatedTitles": 1,
     "explicitIds": 2057
   },
@@ -28081,6 +28081,161 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-run-annotation-not-event.an-annotation-is-created-and-listed-and-never-enters-the-run-s-event-log",
+      "file": "v2-run-annotation-not-event.test.ts",
+      "line": 40,
+      "title": "an annotation is created and listed, and never enters the run's event log",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "schemas/v2/annotation.schema.json",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "listAnnotations MUST return the annotation just created (the control: a host that discards annotations must not pass the log assertion for free)",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "run.annotated is a live notification and MUST NOT enter the event log",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-run-bulk-cancel.101-ids-are-refused-400-validation-error-with-details-maxrunids",
+      "file": "v2-run-bulk-cancel.test.ts",
+      "line": 48,
+      "title": "101 ids are refused 400 validation_error with details.maxRunIds",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "the refusal MUST be validation_error",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-run-bulk-cancel.results-come-back-in-request-order-each-id-processed-independently-a-foreign-id",
+      "file": "v2-run-bulk-cancel.test.ts",
+      "line": 60,
+      "title": "results[] come back in request order, each id processed independently, a foreign id refused in its entry and never as a top-level 403",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "results[] MUST be in request order",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "the foreign-tenant entry MUST be ok: false",
+          "interpolated": true
+        },
+        {
+          "section": "spec/v2/core/identity.md §5",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-run-cancel.cancelling-a-terminal-run-is-refused-409-run-terminal",
+      "file": "v2-run-cancel.test.ts",
+      "line": 65,
+      "title": "cancelling a terminal run is refused 409 run_terminal",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "the refusal MUST be run_terminal",
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-run-cancel.cancelling-a-running-run-answers-200-with-cancelling-cancelled-emits-run-cancell",
+      "file": "v2-run-cancel.test.ts",
+      "line": 79,
+      "title": "cancelling a running run answers 200 with cancelling|cancelled, emits run.cancelled within 5 s, and the snapshot reads cancelled",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "the 200 body MUST carry the run's runId",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "spec/v2/core/events.md §run.cancelled",
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
     {
       "id": "openwop.it.v2-run-completed-outputs.the-run-completed-event-of-a-run-that-completed-carries-an-outputs-object",
       "file": "v2-run-completed-outputs.test.ts",
@@ -28105,6 +28260,241 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-run-diff-identical.two-identical-logs-diff-to-divergedatseq-null-and-empty-eventdiffs-in-a-response",
+      "file": "v2-run-diff-identical.test.ts",
+      "line": 54,
+      "title": "two identical logs diff to divergedAtSeq null and empty eventDiffs, in a response that validates and echoes both ids",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "schemas/v2/run-diff-response.schema.json",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "the response MUST name the two runs it compared",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "identical logs MUST yield empty eventDiffs",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-run-fork-refusals.replay-overlay-400-a-fromseq-outside-the-log-422-fork-point-invalid-a-valid-repl",
+      "file": "v2-run-fork-refusals.test.ts",
+      "line": 38,
+      "title": "replay+overlay → 400; a fromSeq outside the log → 422 fork_point_invalid; a valid replay fork → 201 with the parent's owner verbatim",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "the refusal MUST be fork_point_invalid",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "the 201 MUST name the parent as sourceRunId",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "the 201 MUST echo the mode",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "the 201 MUST carry runId and eventsUrl",
+          "interpolated": true
+        },
+        {
+          "section": "RFCS/0170 §A.4",
+          "requirement": "the child's owner MUST be copied verbatim from the parent"
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-run-options-limits.more-than-100-tags-a-tag-over-256-characters-and-an-unknown-root-key-are-each-re",
+      "file": "v2-run-options-limits.test.ts",
+      "line": 46,
+      "title": "more than 100 tags, a tag over 256 characters, and an unknown root key are each refused 400 validation_error",
+      "explicitId": null,
+      "citations": []
+    },
+    {
+      "id": "openwop.it.v2-run-options-limits.odd-format-tags-and-free-form-metadata-are-accepted-and-surface-unchanged-on-the",
+      "file": "v2-run-options-limits.test.ts",
+      "line": 56,
+      "title": "odd-format tags and free-form metadata are accepted and surface unchanged on the snapshot",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "tags MUST surface unchanged on RunSnapshot",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "metadata MUST be persisted and surface unchanged on RunSnapshot",
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-run-pause-resume.pause-and-resume-on-a-terminal-run-answer-409-with-an-error-envelope",
+      "file": "v2-run-pause-resume.test.ts",
+      "line": 59,
+      "title": "pause and resume on a terminal run answer 409 with an error envelope",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-run-pause-resume.a-running-run-pauses-202-paused-refuses-a-second-pause-409-resumes-202-running-a",
+      "file": "v2-run-pause-resume.test.ts",
+      "line": 77,
+      "title": "a running run pauses (202 paused), refuses a second pause (409), resumes (202 running), and the log carries run.paused then run.resumed",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "the 202 MUST carry the runId",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "spec/v2/core/events.md §run.paused",
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-run-snapshot-etag.a-matching-if-none-match-receives-304-with-no-body-and-the-version-header-a-non",
+      "file": "v2-run-snapshot-etag.test.ts",
+      "line": 34,
+      "title": "a matching If-None-Match receives 304 with no body and the version header; a non-matching one receives 200",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "spec/v2/core/versioning.md §1.4",
+          "requirement": "every response carries OpenWOP-Version, the 304 included"
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "the 200 body is the snapshot",
+          "interpolated": true
+        }
+      ]
+    },
     {
       "id": "openwop.it.v2-stream-sse-projection.every-data-frame-on-the-major-2-stream-carries-the-tenant-bound-runid-of-the-run",
       "file": "v2-stream-sse-projection.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": 505,
+    "files": 513,
     "v1": 445,
-    "v2": 61
+    "v2": 69
   },
   "majors": {
     "a2a-1-0-agent-card.test.ts": [
@@ -1384,9 +1384,33 @@
     "v2-revocation-honored.test.ts": [
       2
     ],
+    "v2-run-annotation-not-event.test.ts": [
+      2
+    ],
+    "v2-run-bulk-cancel.test.ts": [
+      2
+    ],
+    "v2-run-cancel.test.ts": [
+      2
+    ],
     "v2-run-completed-outputs.test.ts": [
       2
     ],
+    "v2-run-diff-identical.test.ts": [
+      2
+    ],
+    "v2-run-fork-refusals.test.ts": [
+      2
+    ],
+    "v2-run-options-limits.test.ts": [
+      2
+    ],
+    "v2-run-pause-resume.test.ts": [
+      2
+    ],
+    "v2-run-snapshot-etag.test.ts": [
+      2
+    ],
     "v2-stream-sse-projection.test.ts": [
       2
     ],

package/schemas/CORPUS-STAMP.json

@@ -1,7 +1,7 @@
 {
   "_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.0.0-rc.47",
+  "version": "2.0.0-rc.49",
   "corpusTag": null,
   "files": {
     "api/.redocly.lint-ignore.yaml": "bf5a8350b88a72fa43f59605ed8d903ed24b6cfccda5e45509c9f6ed9ee4e712",
@@ -9,9 +9,9 @@
     "api/grpc/openwop.proto": "c3e72bb17cba514ee98feb6434e6c9b6ea6795bfd086489ec69fd882dd1ad977",
     "api/openapi.yaml": "39081c59fb696159806b0f2f9a42e7e9ff830d622fcf2ad4159b21357580a955",
     "api/redocly.yaml": "b0604c89b2ca6d5076ec25725c539dad44a741a811fe524439ee6daef8baa09f",
-    "api/seams-v2.yaml": "261192d83c24610ddc6608d1945a3c5ead744a217256215ddec1542fc8736fa4",
-    "api/v2/asyncapi.yaml": "d88f8e208244ce79bc3cc43b4e531bb6b3ca366e3f3ccc1cccd4dbe611171db3",
-    "api/v2/openapi.yaml": "48498431525577ad9057448140c7e75c426b3d040af95f751c591994b0832cef",
+    "api/seams-v2.yaml": "93ecc218d08555eeac0d652768b78050ae7a4847301ddc6664c7415ab12e038a",
+    "api/v2/asyncapi.yaml": "bec2259c5ce9ea7c0935093bdae856570b83d2242d5e298b0b6a8684424a7a83",
+    "api/v2/openapi.yaml": "fc4ee6fdf254f2b414038be709acaeaa6f283505ad8545d1ec6b53d83d1bea25",
     "api/v2/redocly.yaml": "1e66b60e6118ad11a823bb620678be464d99dfe50a40e3e6f93ec9429b88b34c",
     "schemas/README.md": "0c0b737ffcf8f30e7d2809cec8a498232de710f41443212922ad8337cdde0b51",
     "schemas/a2a-task-state.schema.json": "c9365918f993f943b4b619d42551eb066a1ed33a08d895d51b395432a5b1f1bc",
@@ -141,7 +141,7 @@
     "schemas/v2/envelopes/schema.request.schema.json": "be2c5f7aa881cdd252ccff47ac02193659e1393633a1541f4297383205d384a2",
     "schemas/v2/envelopes/schema.response.schema.json": "d049a081267c06c28879c331b147f3ed821b14ccfd93005c67aff64db0a8c68e",
     "schemas/v2/envelopes/ui.a2ui-surface.schema.json": "0a06fbbdc8ba797a6818c79336a98e211ac5ba5747945b4e4098072cd3974d79",
-    "schemas/v2/error-envelope.schema.json": "c08241b74e41f4e3524c25f1c611195ed0e79b49a8ecf63e304add67070bdce5",
+    "schemas/v2/error-envelope.schema.json": "2e09ac2c32a0c0b7098b0ffeaa2822b5dd82b69c23bb3c07d6be2053e2102b19",
     "schemas/v2/eval-summary.schema.json": "bcb165148531d33b7dc01de83da3a049d19ebbef6d12300b17a234c7b03d77d9",
     "schemas/v2/export-bundle.schema.json": "bd28905a7729437ab7f2ad8bb33e13a371b2bf5605a7eb2962a0d246de312d69",
     "schemas/v2/form-content-pack-manifest.schema.json": "307884e57946703b6f86ec283034bf56beb68bea4a000743ebbc9eebeed31b07",
@@ -171,7 +171,7 @@
     "schemas/v2/run-diff-response.schema.json": "6ab6cd265dc7e0a2086c6659c46aa0e7b43e6302949f0adac5d7deb1c7c0ecd3",
     "schemas/v2/run-event-payloads.schema.json": "10f56762616535d01f411afdd98a70ecafc0a961f77aa68cf164b1da458464b4",
     "schemas/v2/run-event.schema.json": "1a9946374af9323b71635d00fed22abe02c300fa2cf3ae3e9c30f3e553e408ec",
-    "schemas/v2/run-options.schema.json": "6d6052596ab0f17acfb00fdfc89907da7724f952e5ffbe1f81d94ba23d4c77cd",
+    "schemas/v2/run-options.schema.json": "ff240805478158cbd2f661979c5eb4f5eda11f9c053b7ba587cb0211a9252d74",
     "schemas/v2/run-orchestrator-decided-event.schema.json": "bb76e15ff72e669f12938684033b55dc567470e1a378e19ffc3fa0e4034ab5a7",
     "schemas/v2/run-snapshot.schema.json": "0ee8a50c6be210db415a7c4345298e70a6ae3dd0dd764ccc514bc1c501437586",
     "schemas/v2/security-advisory.schema.json": "6a382f737730a738d634266315e9d335e5760020a0cdd9f30727c2f987a01770",
@@ -199,7 +199,7 @@
     "schemas/workspace-file.schema.json": "464de85c2a068243084ee9c1d969bc7cd5d8f7948574e58450d6493c38a0e1e4",
     "spec/v1/alias-detectors.json": "fee4594ef49953953ffcd0b3813300067d16b3e65ebff2aac722034ac9b3f545",
     "spec/v1/capability-declaration-classes.json": "e7729aed5c4b4e1dd02abab0530f14cc95f5d4070fe51fb139e7f5cccefa00c6",
-    "spec/v1/core-standard-manifest.json": "c1c51901a9edea30480c4fe3948855043825fc95355385fcfcf052587efb7319",
+    "spec/v1/core-standard-manifest.json": "790bd9d6f00c2d258c0d66d56ed1aea0e0edf8d3b8d1ca7aa70db393b252ee48",
     "spec/v1/deprecations.json": "1d5acb69a9b8ccb57275a95605f74aef1d920685f8407c9d382a46b59dc803bb",
     "spec/v1/deprecations.schema.json": "18c87e78bedc210431f795ae44c5b5d202f2f3317850d5cf86867d4f1fa1cdfb",
     "spec/v1/event-codemap.json": "3da60d884157793a360da532a9fcbbfb5285636db325a74cec94b34622186d97",
@@ -213,7 +213,7 @@
     "spec/v1/spec-gaps.json": "6cc9962c6b969f632e07a78b52a4f61447ff579e2990cbae989866f584a86042",
     "spec/v2/declaration.json": "c15a6a8f08ebd326d1b60398d93d7f7d5abe5c1b8284874fdb13b59f44443210",
     "spec/v2/declaration.schema.json": "b0881a76228dfbd1b85a2ec7b7259a60197f768344535cdb475db6ff719b0e54",
-    "spec/v2/errors.json": "c2dd3fa0401efa0dc78da3b21e32b58a89ed5114cebdde96d3eb999a702118f0",
+    "spec/v2/errors.json": "63583dec5a4b6de0bacc2894b0752b3da128a0afed80f3dc244e552bc0dd0e55",
     "spec/v2/event-codemap.json": "37869a03cdfd8758b57e6f350641a6ebbd383231cebda51f5473ad85f94ab74c",
     "spec/v2/event-codemap.schema.json": "ce2d0ca085d7668d7ef745d2560b385ec6881d24a6d4b47c49931986b2ba642d",
     "spec/v2/ext/provider-idempotency/registry.json": "5b5fecad604fb4ab38da39f5abe697a4e57b05406c398f8afeb377331b2bd965",
@@ -230,8 +230,8 @@
     "spec/v2/path-manifest.json": "034152e09b1458c66810d4050e20a273b2b9b8fe2d92b66e8b819477de58a1be",
     "spec/v2/peer-dependency-aliases.json": "d10299280abee08258502925bc327293ee413e0108cd6e6ec75ff6110653308d",
     "spec/v2/profiles.json": "5019ac8209540bfbeee9c3232530d4e599be0ab926d817ff48edcec8419eb209",
-    "spec/v2/release.json": "a58243063a8b46f46653cd2a8eaf1916661e43e93094e680465d4c7241071de1",
+    "spec/v2/release.json": "0c1e10938fd53b0b4798e9ac7c92727c3d5c83643847cbb1da91a6920800f27f",
     "spec/v2/retention-floors.json": "eaf3722d95c79947af1d4269ef85117e126518c588cfcf1a2b21b97269f51624"
   },
-  "corpusCommit": "ad53400d97752f80dd8115d534202329ed5e88df"
+  "corpusCommit": "67da501622b8d75dff385cb7f20ff8b96f6dd311"
 }

package/src/scenarios/v2-run-annotation-not-event.test.ts

@@ -0,0 +1,71 @@
+/**
+ * `spec/v2/core/runs.md` §Annotations, artifacts, eval summary — an annotation
+ * is a live notification, never a run event (suite 2.0.0, target major 2; gated
+ * on `feedback`; one run created).
+ *
+ * `createAnnotation` answers 201 with `schemas/v2/annotation.schema.json`;
+ * `listAnnotations` returns `{ annotations[] }` carrying it (the control — a host
+ * that discards annotations would otherwise pass the next assertion for free);
+ * the run's event log MUST NOT carry it: no `run.annotated` in the poll, and
+ * the event count MUST NOT grow across the create. `runs.md` §Surface says
+ * `501` when `feedback` is unadvertised while the registry has no 501 code but
+ * `credential_unavailable` (finding 4, filed); 501 or 404 records inapplicable.
+ *
+ * @see spec/v2/core/runs.md §Annotations, artifacts, eval summary
+ * @see schemas/v2/annotation-create.schema.json
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { v2Discovery, gateFamily, v2Validator } from '../lib/v2.js';
+import { readErrorCode } from '../lib/error-envelope.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+const ID = 'openwop.requirement.0170.run-annotation-not-event';
+const DOC = 'spec/v2/core/runs.md §Annotations, artifacts, eval summary';
+const NOOP = 'conformance-noop';
+const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
+
+async function discovery(): Promise<Record<string, unknown> | null> { try { return await v2Discovery(); } catch { return null; } }
+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 events(runId: string): Promise<Array<{ type?: unknown }> | null> {
+  const res = await http(() => driver.get(`/runs/${enc(runId)}/events/poll?timeout=1`));
+  const ev = (res?.json as { events?: unknown } | null)?.events;
+  return res?.status === 200 && Array.isArray(ev) ? (ev as Array<{ type?: unknown }>) : null;
+}
+
+describe('v2 run-annotation-not-event (runs.md §Annotations)', () => {
+  it('an annotation is created and listed, and never enters the run\'s event log', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    if (!(await gateFamily('feedback'))) return softSkip('inapplicable', 'feedback family not advertised (gate recorded under openwop.family.feedback) — annotations are gated on feedback (runs.md §Surface)');
+    const created = await http(() => driver.post('/runs', { workflowId: NOOP }));
+    if (created === null) return softSkip('blocked', 'POST /runs unreachable (fetch failed)');
+    const runId = (created.json as { runId?: unknown } | null)?.runId;
+    if (created.status !== 201 || typeof runId !== 'string') return softSkip('blocked', `POST /runs answered ${created.status} ${readErrorCode(created.json) ?? ''}`.trim());
+    const t0 = Date.now();
+    while (Date.now() - t0 < 10_000) { const s = await http(() => driver.get(`/runs/${enc(runId)}`)); if (s?.status === 200 && TERMINAL.has(String((s.json as { status?: unknown }).status))) break; await new Promise((r) => setTimeout(r, 250)); }
+    const before = await events(runId);
+    if (before === null) return softSkip('blocked', 'GET /runs/{runId}/events/poll did not answer 200 before the annotation');
+
+    const ann = await http(() => driver.post(`/runs/${enc(runId)}/annotations`, { signal: { kind: 'label', label: 'conformance' }, note: 'openwop conformance annotation' }));
+    if (ann === null) return softSkip('blocked', 'POST /runs/{runId}/annotations unreachable (fetch failed)');
+    if (ann.status === 501 || ann.status === 404) return softSkip('blocked', `POST /runs/{runId}/annotations answered ${ann.status} although feedback is advertised — the surface is not mounted (an unadvertised feedback answers 404 not_found; 501 is not a registered shape)`);
+    expect(ann.status, req(ID, DOC, `createAnnotation MUST answer 201 — got ${ann.status} ${readErrorCode(ann.json) ?? ''}`.trim())).toBe(201);
+    const check = v2Validator('annotation')(ann.json);
+    expect(check.ok, req(ID, 'schemas/v2/annotation.schema.json', `the 201 body MUST validate: ${check.errors}`)).toBe(true);
+    const annotationId = (ann.json as { annotationId?: unknown } | null)?.annotationId;
+
+    const list = await http(() => driver.get(`/runs/${enc(runId)}/annotations`));
+    if (list === null) return softSkip('blocked', 'GET /runs/{runId}/annotations unreachable (fetch failed)');
+    expect(list.status, req(ID, DOC, `listAnnotations MUST answer 200 — got ${list.status}`)).toBe(200);
+    const rows = (list.json as { annotations?: unknown } | null)?.annotations;
+    expect(Array.isArray(rows) && rows.some((r) => (r as { annotationId?: unknown }).annotationId === annotationId), req(ID, DOC, 'listAnnotations MUST return the annotation just created (the control: a host that discards annotations must not pass the log assertion for free)')).toBe(true);
+
+    const after = await events(runId);
+    if (after === null) return softSkip('blocked', 'GET /runs/{runId}/events/poll did not answer 200 after the annotation');
+    expect(after.some((e) => String(e.type) === 'run.annotated'), req(ID, DOC, 'run.annotated is a live notification and MUST NOT enter the event log')).toBe(false);
+    expect(after.length, req(ID, DOC, `the event log MUST NOT grow across an annotation (${before.length} → ${after.length})`)).toBe(before.length);
+  }, 30_000);
+});

package/src/scenarios/v2-run-bulk-cancel.test.ts

@@ -0,0 +1,83 @@
+/**
+ * `spec/v2/core/runs.md` §Cancel — `bulkCancelRuns` (suite 2.0.0, target major 2;
+ * unaided).
+ *
+ * Legs:
+ *   1. over the cap: 101 syntactically valid tenant-bound ids MUST be refused
+ *      `400 validation_error` with `details.maxRunIds` (creates nothing);
+ *   2. `[own, foreign-tenant, own]` MUST answer `200 { results[] }` in request
+ *      order even when every entry failed; the foreign entry is `ok: false` with
+ *      an error envelope in the entry — never a top-level 403. The prose names
+ *      `run_forbidden` for a run the caller cannot see while identity.md §5 names
+ *      `id_tenant_mismatch` / `not_found` for a foreign tenant segment; the leg
+ *      accepts any of the three and the disagreement is filed (finding 3). An
+ *      own entry on an already-terminal noop is `ok: true` with
+ *      `cancelling | cancelled` or `ok: false` with `run_terminal` (finding 1).
+ *
+ * The foreign id matches the runId grammar, so a 400 on leg 2 is a host defect,
+ * not body validation.
+ *
+ * @see spec/v2/core/runs.md §Cancel
+ * @see spec/v2/core/identity.md §5
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { v2Discovery } from '../lib/v2.js';
+import { readErrorCode } from '../lib/error-envelope.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+const ID = 'openwop.requirement.0170.run-bulk-cancel';
+const DOC = 'spec/v2/core/runs.md §Cancel';
+const NOOP = 'conformance-noop';
+const FOREIGN = 'openwop-conformance-foreign-tenant/foreignopaque0123456789abcdef';
+
+async function discovery(): Promise<Record<string, unknown> | null> { try { return await v2Discovery(); } catch { return null; } }
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> { try { return await fn(); } catch { return null; } }
+async function create(): Promise<{ runId: string } | { reason: string }> {
+  const res = await http(() => driver.post('/runs', { workflowId: NOOP }));
+  if (res === null) return { reason: 'POST /runs unreachable (fetch failed)' };
+  const runId = (res.json as { runId?: unknown } | null)?.runId;
+  if (res.status !== 201 || typeof runId !== 'string') return { reason: `POST /runs answered ${res.status} ${readErrorCode(res.json) ?? ''} — create refused`.trim() };
+  return { runId };
+}
+interface Entry { runId?: unknown; ok?: unknown; status?: unknown; error?: { code?: unknown } | null }
+
+describe('v2 run-bulk-cancel (runs.md §Cancel)', () => {
+  it('101 ids are refused 400 validation_error with details.maxRunIds', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    const runIds = Array.from({ length: 101 }, (_, i) => `openwop-conformance-bulk-cap/opaque${String(i).padStart(3, '0')}0123456789abcdef`);
+    const res = await http(() => driver.post('/runs:bulk-cancel', { runIds }));
+    if (res === null) return softSkip('blocked', 'POST /runs:bulk-cancel unreachable (fetch failed)');
+    if (res.status === 404) return softSkip('blocked', 'POST /runs:bulk-cancel answered 404 — bulkCancelRuns is a core operation (runs.md §Surface) and is not mounted');
+    expect(res.status, req(ID, DOC, `over the cap (RECOMMENDED 100) the host MUST answer 400 — got ${res.status}`)).toBe(400);
+    expect(readErrorCode(res.json), req(ID, DOC, 'the refusal MUST be validation_error')).toBe('validation_error');
+    const max = (res.json as { error?: { details?: { maxRunIds?: unknown } } } | null)?.error?.details?.maxRunIds;
+    expect(typeof max === 'number' && max >= 1 && max <= 100, req(ID, DOC, `details.maxRunIds MUST state the cap (got ${String(max)})`)).toBe(true);
+  });
+
+  it('results[] come back in request order, each id processed independently, a foreign id refused in its entry and never as a top-level 403', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    const a = await create(); if ('reason' in a) return softSkip('blocked', a.reason);
+    const b = await create(); if ('reason' in b) return softSkip('blocked', b.reason);
+    const runIds = [a.runId, FOREIGN, b.runId];
+    const res = await http(() => driver.post('/runs:bulk-cancel', { runIds, reason: 'conformance' }));
+    if (res === null) return softSkip('blocked', 'POST /runs:bulk-cancel unreachable (fetch failed)');
+    if (res.status === 404) return softSkip('blocked', 'POST /runs:bulk-cancel answered 404 — not mounted');
+    expect(res.status, req(ID, DOC, `bulkCancelRuns MUST answer 200 even when entries fail — a foreign id MUST NOT surface as a top-level ${res.status} ${readErrorCode(res.json) ?? ''}`.trim())).toBe(200);
+    const results = (res.json as { results?: unknown } | null)?.results;
+    expect(Array.isArray(results) && results.length === 3, req(ID, DOC, `results[] MUST carry one entry per requested id (got ${Array.isArray(results) ? results.length : typeof results})`)).toBe(true);
+    const entries = results as Entry[];
+    expect(entries.map((e) => e.runId), req(ID, DOC, 'results[] MUST be in request order')).toEqual(runIds);
+    const foreign = entries[1]!;
+    expect(foreign.ok, req(ID, DOC, 'the foreign-tenant entry MUST be ok: false')).toBe(false);
+    const fcode = String(foreign.error?.code);
+    expect(['id_tenant_mismatch', 'not_found'].includes(fcode), req(ID, 'spec/v2/core/identity.md §5', `an id whose tenant segment is not the caller's MUST be refused inside the entry with id_tenant_mismatch (or not_found where existence is not leaked) — identity.md §5 applies inside a bulk entry exactly as on a path; run_forbidden is for a same-tenant run the caller may not cancel — got ${fcode}`)).toBe(true);
+    for (const own of [entries[0]!, entries[2]!]) {
+      const okShape = own.ok === true && ['cancelling', 'cancelled'].includes(String(own.status));
+      const terminalShape = own.ok === false && String(own.error?.code) === 'run_terminal';
+      expect(okShape || terminalShape, req(ID, DOC, `an own entry MUST be ok: true with cancelling|cancelled, or ok: false run_terminal when the noop already completed — got ${JSON.stringify(own)}`)).toBe(true);
+    }
+  });
+});

package/src/scenarios/v2-run-cancel.test.ts

@@ -0,0 +1,97 @@
+/**
+ * `spec/v2/core/runs.md` §Cancel — `cancelRun` (suite 2.0.0, target major 2).
+ *
+ * Witness class: witnessable — the positive leg is gated on the
+ * `conformance-cancellable` fixture (a run that stays `running` for `delayMs`);
+ * the terminal-run leg is unaided.
+ *
+ * Legs:
+ *   1. cancelling a run that is already terminal — `runs.md` §Cancel is SILENT
+ *      on this case; the registry has `run_terminal` (409) and 200-idempotent is
+ *      the other defensible answer. The leg accepts either, records which, and
+ *      the ambiguity is filed for the prose (rc.48 CHANGELOG, finding 1).
+ *   2. on `conformance-cancellable`: `POST /runs/{runId}/cancel` on a running
+ *      run answers `200 { runId, status: cancelling | cancelled }`; `run.cancelled`
+ *      is in the log within 5 s; the snapshot reads `cancelled`.
+ *
+ * Until rc.48 nothing at major 2 witnessed §Cancel at all — runs.md carried 61
+ * MUSTs and 12 witness sites, every one under §Create.
+ *
+ * @see spec/v2/core/runs.md §Cancel
+ * @see conformance/fixtures.md §conformance-cancellable
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { v2Discovery } from '../lib/v2.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { readErrorCode } from '../lib/error-envelope.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+const ID = 'openwop.requirement.0170.run-cancel';
+const DOC = 'spec/v2/core/runs.md §Cancel';
+const NOOP = 'conformance-noop';
+const CANCELLABLE = 'conformance-cancellable';
+
+async function discovery(): Promise<Record<string, unknown> | null> { try { return await v2Discovery(); } catch { return null; } }
+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 create(body: Record<string, unknown>): Promise<{ runId: string } | { reason: string }> {
+  const res = await http(() => driver.post('/runs', body));
+  if (res === null) return { reason: 'POST /runs unreachable (fetch failed)' };
+  const runId = (res.json as { runId?: unknown } | null)?.runId;
+  if (res.status !== 201 || typeof runId !== 'string') return { reason: `POST /runs answered ${res.status} ${readErrorCode(res.json) ?? ''} — create refused`.trim() };
+  return { runId };
+}
+async function statusOf(runId: string): Promise<string | null> {
+  const res = await http(() => driver.get(`/runs/${enc(runId)}`));
+  return res?.status === 200 ? String((res.json as { status?: unknown } | null)?.status ?? '') : null;
+}
+async function waitFor(runId: string, pred: (s: string) => boolean, ms: number): Promise<string | null> {
+  const t0 = Date.now(); let last: string | null = null;
+  while (Date.now() - t0 < ms) { last = await statusOf(runId); if (last !== null && pred(last)) return last; await new Promise((r) => setTimeout(r, 250)); }
+  return last;
+}
+async function eventTypes(runId: string): Promise<string[] | null> {
+  const res = await http(() => driver.get(`/runs/${enc(runId)}/events/poll?timeout=1`));
+  const events = (res?.json as { events?: unknown } | null)?.events;
+  return res?.status === 200 && Array.isArray(events) ? events.map((e) => String((e as { type?: unknown }).type)) : null;
+}
+const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
+
+describe('v2 run-cancel (runs.md §Cancel)', () => {
+  it('cancelling a terminal run is refused 409 run_terminal', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    const c = await create({ workflowId: NOOP });
+    if ('reason' in c) return softSkip('blocked', c.reason);
+    const s = await waitFor(c.runId, (x) => TERMINAL.has(x), 10_000);
+    if (s === null || !TERMINAL.has(s)) return softSkip('blocked', `the noop run did not reach a terminal status within 10 s (last: ${s ?? 'unreadable'})`);
+    const res = await http(() => driver.post(`/runs/${enc(c.runId)}/cancel`, {}));
+    if (res === null) return softSkip('blocked', 'POST /runs/{runId}/cancel unreachable (fetch failed)');
+    const code = readErrorCode(res.json);
+    const status = (res.json as { status?: unknown } | null)?.status;
+    expect(res.status, req(ID, DOC, `a cancel on a run that is already terminal (${s}) MUST be refused 409 run_terminal — got ${res.status} ${code ?? String(status)}; a 200 echoing the terminal state is outside §Cancel's 200 grammar { runId, status: cancelling | cancelled }`)).toBe(409);
+    expect(code, req(ID, DOC, 'the refusal MUST be run_terminal')).toBe('run_terminal');
+  });
+
+  it('cancelling a running run answers 200 with cancelling|cancelled, emits run.cancelled within 5 s, and the snapshot reads cancelled', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    if (!isFixtureAdvertised(CANCELLABLE)) return softSkip('inapplicable', `${CANCELLABLE} fixture not advertised — no run stays running long enough to cancel`);
+    const c = await create({ workflowId: CANCELLABLE, inputs: { delayMs: 15_000 } });
+    if ('reason' in c) return softSkip('blocked', c.reason);
+    const running = await waitFor(c.runId, (x) => x === 'running' || TERMINAL.has(x), 5_000);
+    if (running !== 'running') return softSkip('blocked', `${CANCELLABLE} did not reach running within 5 s (last: ${running ?? 'unreadable'})`);
+    const res = await http(() => driver.post(`/runs/${enc(c.runId)}/cancel`, { reason: 'conformance' }));
+    if (res === null) return softSkip('blocked', 'POST /runs/{runId}/cancel unreachable (fetch failed)');
+    expect(res.status, req(ID, DOC, `cancelRun on a running run MUST answer 200 — got ${res.status} ${readErrorCode(res.json) ?? ''}`.trim())).toBe(200);
+    const body = res.json as { runId?: unknown; status?: unknown } | null;
+    expect(body?.runId, req(ID, DOC, 'the 200 body MUST carry the run\'s runId')).toBe(c.runId);
+    expect(['cancelling', 'cancelled'].includes(String(body?.status)), req(ID, DOC, `status MUST be cancelling or cancelled (got ${String(body?.status)})`)).toBe(true);
+    const final = await waitFor(c.runId, (x) => x === 'cancelled', 5_000);
+    expect(final, req(ID, DOC, `the snapshot MUST read cancelled within 5 s of an accepted cancel (last: ${final ?? 'unreadable'})`)).toBe('cancelled');
+    const types = await eventTypes(c.runId);
+    expect(types?.includes('run.cancelled') ?? false, req(ID, 'spec/v2/core/events.md §run.cancelled', `the log MUST carry run.cancelled once the cascade completes (types: ${(types ?? []).join(', ')})`)).toBe(true);
+  }, 30_000);
+});

package/src/scenarios/v2-run-diff-identical.test.ts

@@ -0,0 +1,75 @@
+/**
+ * `spec/v2/core/runs.md` §Diff and ancestry — `diffRun` is a pure function of
+ * the two logs (suite 2.0.0, target major 2; unaided; two runs created, a third
+ * when `conformance-failure` is advertised).
+ *
+ * Identical logs MUST yield `divergedAtSeq: null` and empty `eventDiffs`;
+ * `eventId`, `runId`, `timestamp` and other run-scoped fields MUST be excluded
+ * from the comparison — so two `conformance-noop` runs ARE identical logs.
+ * `diffRun` is OPTIONAL (`404` when absent → inapplicable).
+ *
+ * Controls: the response MUST validate against
+ * `schemas/v2/run-diff-response.schema.json` and echo both ids in `a` / `b`
+ * (a host answering `{}` to any pair fails there); and, when
+ * `conformance-failure` is advertised, a noop-vs-failure diff MUST diverge.
+ * Without that fixture the divergence control records `inapplicable`.
+ *
+ * @see spec/v2/core/runs.md §Diff and ancestry
+ * @see schemas/v2/run-diff-response.schema.json
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { v2Discovery, v2Validator } from '../lib/v2.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { readErrorCode } from '../lib/error-envelope.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+const ID = 'openwop.requirement.0170.run-diff-identical';
+const DOC = 'spec/v2/core/runs.md §Diff and ancestry';
+const NOOP = 'conformance-noop';
+const FAILURE = 'conformance-failure';
+const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
+
+async function discovery(): Promise<Record<string, unknown> | null> { try { return await v2Discovery(); } catch { return null; } }
+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 createSettled(workflowId: string): Promise<{ runId: string } | { reason: string }> {
+  const res = await http(() => driver.post('/runs', { workflowId }));
+  if (res === null) return { reason: 'POST /runs unreachable (fetch failed)' };
+  const runId = (res.json as { runId?: unknown } | null)?.runId;
+  if (res.status !== 201 || typeof runId !== 'string') return { reason: `POST /runs {workflowId: ${workflowId}} answered ${res.status} ${readErrorCode(res.json) ?? ''}`.trim() };
+  const t0 = Date.now();
+  while (Date.now() - t0 < 10_000) {
+    const s = await http(() => driver.get(`/runs/${enc(runId)}`));
+    if (s?.status === 200 && TERMINAL.has(String((s.json as { status?: unknown }).status))) return { runId };
+    await new Promise((r) => setTimeout(r, 250));
+  }
+  return { reason: `${workflowId} run ${runId} did not settle within 10 s` };
+}
+interface Diff { a?: unknown; b?: unknown; divergedAtSeq?: unknown; eventDiffs?: unknown }
+
+describe('v2 run-diff-identical (runs.md §Diff and ancestry)', () => {
+  it('two identical logs diff to divergedAtSeq null and empty eventDiffs, in a response that validates and echoes both ids', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    const a = await createSettled(NOOP); if ('reason' in a) return softSkip('blocked', a.reason);
+    const b = await createSettled(NOOP); if ('reason' in b) return softSkip('blocked', b.reason);
+    const res = await http(() => driver.get(`/runs/${enc(a.runId)}:diff?against=${enc(b.runId)}`));
+    if (res === null) return softSkip('blocked', 'GET /runs/{runId}:diff unreachable (fetch failed)');
+    if (res.status === 404) return softSkip('inapplicable', 'diffRun is OPTIONAL and answered 404 (runs.md §Surface)');
+    expect(res.status, req(ID, DOC, `diffRun MUST answer 200 — got ${res.status} ${readErrorCode(res.json) ?? ''}`.trim())).toBe(200);
+    const check = v2Validator('run-diff-response')(res.json);
+    expect(check.ok, req(ID, 'schemas/v2/run-diff-response.schema.json', `the response MUST validate: ${check.errors}`)).toBe(true);
+    const d = res.json as Diff;
+    expect([d.a, d.b], req(ID, DOC, 'the response MUST name the two runs it compared')).toEqual([a.runId, b.runId]);
+    expect(d.divergedAtSeq, req(ID, DOC, `identical logs MUST yield divergedAtSeq: null (got ${String(d.divergedAtSeq)}) — eventId, runId, timestamp and other run-scoped fields MUST be excluded from the comparison`)).toBeNull();
+    expect(d.eventDiffs, req(ID, DOC, 'identical logs MUST yield empty eventDiffs')).toEqual([]);
+    if (!isFixtureAdvertised(FAILURE)) return softSkip('inapplicable', `${FAILURE} fixture not advertised — the divergence control (a noop-vs-failure diff MUST diverge) cannot run`);
+    const f = await createSettled(FAILURE); if ('reason' in f) return softSkip('blocked', f.reason);
+    const dv = await http(() => driver.get(`/runs/${enc(a.runId)}:diff?against=${enc(f.runId)}`));
+    if (dv === null || dv.status !== 200) return softSkip('blocked', `the divergence control diff answered ${dv?.status ?? 'no response'}`);
+    const x = dv.json as Diff;
+    expect(typeof x.divergedAtSeq === 'number' && Array.isArray(x.eventDiffs) && x.eventDiffs.length > 0, req(ID, DOC, `a noop log and a failure log MUST diverge (divergedAtSeq ${String(x.divergedAtSeq)}, ${Array.isArray(x.eventDiffs) ? x.eventDiffs.length : 0} diff(s)) — the identical-logs pass above is only evidence if a different pair does not also read identical`)).toBe(true);
+  }, 45_000);
+});

package/src/scenarios/v2-run-fork-refusals.test.ts

@@ -0,0 +1,70 @@
+/**
+ * `spec/v2/core/runs.md` §Fork — the refusals and the copied owner (suite
+ * 2.0.0, target major 2; gated on `replay`; one run created plus one fork).
+ *
+ * A `replay` fork with a non-empty `runOptionsOverlay` MUST be rejected 400
+ * (the overlay is `branch`-only); a `fromSeq` not in the source log MUST be
+ * rejected `422 fork_point_invalid`; a valid `replay` fork answers `201 {
+ * runId, sourceRunId, mode, status, eventsUrl }` and the child's `owner` is
+ * copied verbatim from the parent (RFC 0170 §A.4). The 201 is the control for
+ * the two refusals. Determinism and side-effect suppression are replay.md's
+ * and witnessed there.
+ *
+ * @see spec/v2/core/runs.md §Fork
+ * @see RFCS/0170 §A.4
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { v2Discovery, gateFamily } from '../lib/v2.js';
+import { readErrorCode } from '../lib/error-envelope.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+const ID = 'openwop.requirement.0170.run-fork-refusals';
+const DOC = 'spec/v2/core/runs.md §Fork';
+const NOOP = 'conformance-noop';
+const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
+
+async function discovery(): Promise<Record<string, unknown> | null> { try { return await v2Discovery(); } catch { return null; } }
+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 snapshot(runId: string): Promise<Record<string, unknown> | null> {
+  const res = await http(() => driver.get(`/runs/${enc(runId)}`));
+  return res?.status === 200 && res.json && typeof res.json === 'object' ? (res.json as Record<string, unknown>) : null;
+}
+
+describe('v2 run-fork-refusals (runs.md §Fork)', () => {
+  it('replay+overlay → 400; a fromSeq outside the log → 422 fork_point_invalid; a valid replay fork → 201 with the parent\'s owner verbatim', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    if (!(await gateFamily('replay'))) return softSkip('inapplicable', 'replay family not advertised (gate recorded under openwop.family.replay) — forkRun is gated on replay (runs.md §Surface)');
+    const created = await http(() => driver.post('/runs', { workflowId: NOOP }));
+    if (created === null) return softSkip('blocked', 'POST /runs unreachable (fetch failed)');
+    const runId = (created.json as { runId?: unknown } | null)?.runId;
+    if (created.status !== 201 || typeof runId !== 'string') return softSkip('blocked', `POST /runs answered ${created.status} ${readErrorCode(created.json) ?? ''}`.trim());
+    const t0 = Date.now(); let parent: Record<string, unknown> | null = null;
+    while (Date.now() - t0 < 10_000) { parent = await snapshot(runId); if (parent && TERMINAL.has(String(parent['status']))) break; await new Promise((r) => setTimeout(r, 250)); }
+    if (!parent || !TERMINAL.has(String(parent['status']))) return softSkip('blocked', 'the noop run did not settle within 10 s');
+
+    const overlay = await http(() => driver.post(`/runs/${enc(runId)}:fork`, { mode: 'replay', runOptionsOverlay: { tags: ['conformance'] } }));
+    if (overlay === null) return softSkip('blocked', 'POST /runs/{runId}:fork unreachable (fetch failed)');
+    if (overlay.status === 404) return softSkip('blocked', 'POST /runs/{runId}:fork answered 404 with replay advertised — forkRun is not mounted');
+    expect(overlay.status, req(ID, DOC, `a replay fork with a non-empty runOptionsOverlay MUST be rejected 400 (the overlay is branch-only) — got ${overlay.status} ${readErrorCode(overlay.json) ?? ''}`.trim())).toBe(400);
+
+    const bad = await http(() => driver.post(`/runs/${enc(runId)}:fork`, { mode: 'branch', fromSeq: 999_999 }));
+    if (bad === null) return softSkip('blocked', 'POST /runs/{runId}:fork unreachable (fetch failed)');
+    expect(bad.status, req(ID, DOC, `a fromSeq not in the source log MUST be rejected 422 — got ${bad.status} ${readErrorCode(bad.json) ?? ''}`.trim())).toBe(422);
+    expect(readErrorCode(bad.json), req(ID, DOC, 'the refusal MUST be fork_point_invalid')).toBe('fork_point_invalid');
+
+    const ok = await http(() => driver.post(`/runs/${enc(runId)}:fork`, { mode: 'replay' }));
+    if (ok === null) return softSkip('blocked', 'POST /runs/{runId}:fork unreachable (fetch failed)');
+    expect(ok.status, req(ID, DOC, `a valid replay fork MUST answer 201 — got ${ok.status} ${readErrorCode(ok.json) ?? ''} (the control for the two refusals above)`.trim())).toBe(201);
+    const body = ok.json as { runId?: unknown; sourceRunId?: unknown; mode?: unknown; eventsUrl?: unknown } | null;
+    expect(body?.sourceRunId, req(ID, DOC, 'the 201 MUST name the parent as sourceRunId')).toBe(runId);
+    expect(body?.mode, req(ID, DOC, 'the 201 MUST echo the mode')).toBe('replay');
+    expect(typeof body?.runId === 'string' && typeof body?.eventsUrl === 'string', req(ID, DOC, 'the 201 MUST carry runId and eventsUrl')).toBe(true);
+    const child = await snapshot(String(body?.runId));
+    if (!child) return softSkip('blocked', 'the child snapshot could not be read');
+    expect(child['owner'], req(ID, 'RFCS/0170 §A.4', 'the child\'s owner MUST be copied verbatim from the parent')).toEqual(parent['owner']);
+  }, 30_000);
+});

package/src/scenarios/v2-run-options-limits.test.ts

@@ -0,0 +1,69 @@
+/**
+ * `spec/v2/core/runs.md` §Run options — `tags`, `metadata`, and the closed
+ * create body (suite 2.0.0, target major 2; unaided; one run created).
+ *
+ * `tags` is opaque: a host MUST NOT reject a tag on format and MUST answer
+ * `400 validation_error` over the limits (100 entries, 256 characters).
+ * `metadata` MUST be persisted and surface unchanged on the snapshot, as MUST
+ * `tags`. The create body is closed at the composition, so an unknown ROOT key
+ * MUST be refused `400 validation_error` (`v2-configurable-closed` covers keys
+ * inside `configurable` only).
+ *
+ * The refusals are the control for the acceptance and vice versa: a host that
+ * accepts everything fails the 400 legs; a host that refuses odd tags fails the
+ * 201 leg. `""` is deliberately not among the odd tags — the schema's
+ * `minLength: 1` is a length rule, not a format rule (finding 4).
+ *
+ * @see spec/v2/core/runs.md §Run options
+ * @see schemas/v2/run-options.schema.json
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { v2Discovery } from '../lib/v2.js';
+import { readErrorCode } from '../lib/error-envelope.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+const ID = 'openwop.requirement.0171.run-options-limits';
+const DOC = 'spec/v2/core/runs.md §Run options';
+const NOOP = 'conformance-noop';
+const ODD_TAGS = ['has space', 'emoji 🚀', 'slash/colon:pipe|', 'UPPER-and_under', 'x'.repeat(256)];
+const METADATA = { nested: { a: 1, b: [1, '2', null, true] }, s: 'unicode ∞ ok', n: 0 };
+
+async function discovery(): Promise<Record<string, unknown> | null> { try { return await v2Discovery(); } catch { return null; } }
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> { try { return await fn(); } catch { return null; } }
+
+async function refused(body: Record<string, unknown>, what: string): Promise<string | null> {
+  const res = await http(() => driver.post('/runs', body));
+  if (res === null) return `POST /runs unreachable (fetch failed) for ${what}`;
+  expect(res.status, req(ID, DOC, `${what} MUST be refused 400 — got ${res.status} ${readErrorCode(res.json) ?? ''}`.trim())).toBe(400);
+  expect(readErrorCode(res.json), req(ID, DOC, `the refusal for ${what} MUST be validation_error`)).toBe('validation_error');
+  return null;
+}
+
+describe('v2 run-options-limits (runs.md §Run options)', () => {
+  it('more than 100 tags, a tag over 256 characters, and an unknown root key are each refused 400 validation_error', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    const probes: Array<[Record<string, unknown>, string]> = [
+      [{ workflowId: NOOP, tags: Array.from({ length: 101 }, (_, i) => `t${i}`) }, '101 tags'],
+      [{ workflowId: NOOP, tags: ['y'.repeat(257)] }, 'a 257-character tag'],
+      [{ workflowId: NOOP, conformanceUnknownRootKey: 1 }, 'an unknown root key on the create body (closed at the composition)'],
+    ];
+    for (const [body, what] of probes) { const r = await refused(body, what); if (r) return softSkip('blocked', r); }
+  });
+
+  it('odd-format tags and free-form metadata are accepted and surface unchanged on the snapshot', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    const res = await http(() => driver.post('/runs', { workflowId: NOOP, tags: ODD_TAGS, metadata: METADATA }));
+    if (res === null) return softSkip('blocked', 'POST /runs unreachable (fetch failed)');
+    expect(res.status, req(ID, DOC, `a host MUST NOT reject a tag on format and MUST accept free-form metadata — got ${res.status} ${readErrorCode(res.json) ?? ''}`.trim())).toBe(201);
+    const runId = (res.json as { runId?: unknown } | null)?.runId;
+    if (typeof runId !== 'string') return softSkip('blocked', 'the 201 carried no runId');
+    const snap = await http(() => driver.get(`/runs/${encodeURIComponent(runId)}`));
+    if (snap === null || snap.status !== 200) return softSkip('blocked', `GET /runs/{runId} answered ${snap?.status ?? 'no response'} for the run just created`);
+    const body = snap.json as { tags?: unknown; metadata?: unknown } | null;
+    expect(body?.tags, req(ID, DOC, 'tags MUST surface unchanged on RunSnapshot')).toEqual(ODD_TAGS);
+    expect(body?.metadata, req(ID, DOC, 'metadata MUST be persisted and surface unchanged on RunSnapshot')).toEqual(METADATA);
+  });
+});

package/src/scenarios/v2-run-pause-resume.test.ts

@@ -0,0 +1,108 @@
+/**
+ * `spec/v2/core/runs.md` §Pause and resume (suite 2.0.0, target major 2).
+ *
+ * Legs:
+ *   1. unaided: `:pause` and `:resume` on a terminal run MUST answer 409 with an
+ *      error envelope. The prose names no code; only `run_terminal` is
+ *      registered (finding 2). The leg asserts 409 + a code and names none. On
+ *      its own this leg is one-sided — a host that answers 409 to everything
+ *      passes it — so its recorded reason says so when leg 2 cannot run.
+ *   2. on `conformance-delay`: pause → `202 { runId, status: paused }`; pause
+ *      again → 409; resume → `202 { runId, status: running }`; the log carries
+ *      `run.paused` then `run.resumed`. The run is cancelled at the end so
+ *      nothing is left running.
+ *
+ * @see spec/v2/core/runs.md §Pause and resume
+ * @see conformance/fixtures.md §conformance-delay
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { v2Discovery } from '../lib/v2.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { readErrorCode } from '../lib/error-envelope.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+const ID = 'openwop.requirement.0170.run-pause-resume';
+const DOC = 'spec/v2/core/runs.md §Pause and resume';
+const NOOP = 'conformance-noop';
+const DELAY = 'conformance-delay';
+const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
+
+async function discovery(): Promise<Record<string, unknown> | null> { try { return await v2Discovery(); } catch { return null; } }
+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 create(body: Record<string, unknown>): Promise<{ runId: string } | { reason: string }> {
+  const res = await http(() => driver.post('/runs', body));
+  if (res === null) return { reason: 'POST /runs unreachable (fetch failed)' };
+  const runId = (res.json as { runId?: unknown } | null)?.runId;
+  if (res.status !== 201 || typeof runId !== 'string') return { reason: `POST /runs answered ${res.status} ${readErrorCode(res.json) ?? ''} — create refused`.trim() };
+  return { runId };
+}
+async function statusOf(runId: string): Promise<string | null> {
+  const res = await http(() => driver.get(`/runs/${enc(runId)}`));
+  return res?.status === 200 ? String((res.json as { status?: unknown } | null)?.status ?? '') : null;
+}
+async function waitFor(runId: string, pred: (s: string) => boolean, ms: number): Promise<string | null> {
+  const t0 = Date.now(); let last: string | null = null;
+  while (Date.now() - t0 < ms) { last = await statusOf(runId); if (last !== null && pred(last)) return last; await new Promise((r) => setTimeout(r, 250)); }
+  return last;
+}
+async function eventTypes(runId: string): Promise<string[] | null> {
+  const res = await http(() => driver.get(`/runs/${enc(runId)}/events/poll?timeout=1`));
+  const events = (res?.json as { events?: unknown } | null)?.events;
+  return res?.status === 200 && Array.isArray(events) ? events.map((e) => String((e as { type?: unknown }).type)) : null;
+}
+
+describe('v2 run-pause-resume (runs.md §Pause and resume)', () => {
+  it('pause and resume on a terminal run answer 409 with an error envelope', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    const c = await create({ workflowId: NOOP });
+    if ('reason' in c) return softSkip('blocked', c.reason);
+    const s = await waitFor(c.runId, (x) => TERMINAL.has(x), 10_000);
+    if (s === null || !TERMINAL.has(s)) return softSkip('blocked', `the noop run did not reach a terminal status within 10 s (last: ${s ?? 'unreadable'})`);
+    const pause = await http(() => driver.post(`/runs/${enc(c.runId)}:pause`, {}));
+    if (pause === null) return softSkip('blocked', 'POST /runs/{runId}:pause unreachable (fetch failed)');
+    if (pause.status === 404) return softSkip('blocked', 'POST /runs/{runId}:pause answered 404 — pauseRun is a core operation (runs.md §Surface) and is not mounted');
+    expect(pause.status, req(ID, DOC, `pause on a terminal (${s}) run MUST answer 409 — got ${pause.status} ${readErrorCode(pause.json) ?? ''}`.trim())).toBe(409);
+    expect(readErrorCode(pause.json), req(ID, DOC, `a pause refused because the run is terminal MUST carry run_terminal (got ${String(readErrorCode(pause.json))})`)).toBe('run_terminal');
+    const resume = await http(() => driver.post(`/runs/${enc(c.runId)}:resume`, {}));
+    if (resume === null) return softSkip('blocked', 'POST /runs/{runId}:resume unreachable (fetch failed)');
+    expect(resume.status, req(ID, DOC, `resume on a run that is not paused MUST answer 409 — got ${resume.status} ${readErrorCode(resume.json) ?? ''}`.trim())).toBe(409);
+    expect(readErrorCode(resume.json), req(ID, DOC, `a resume refused because the run is terminal MUST carry run_terminal (got ${String(readErrorCode(resume.json))})`)).toBe('run_terminal');
+    if (!isFixtureAdvertised(DELAY)) return softSkip('inapplicable', `${DELAY} fixture not advertised — the positive pause/resume leg cannot run, so the two 409s above are witnessed without their control (a host answering 409 to everything would pass them)`);
+  });
+
+  it('a running run pauses (202 paused), refuses a second pause (409), resumes (202 running), and the log carries run.paused then run.resumed', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    if (!isFixtureAdvertised(DELAY)) return softSkip('inapplicable', `${DELAY} fixture not advertised — no run stays running long enough to pause`);
+    const c = await create({ workflowId: DELAY, inputs: { delayMs: 15_000 } });
+    if ('reason' in c) return softSkip('blocked', c.reason);
+    const running = await waitFor(c.runId, (x) => x === 'running' || TERMINAL.has(x), 5_000);
+    if (running !== 'running') return softSkip('blocked', `${DELAY} did not reach running within 5 s (last: ${running ?? 'unreadable'})`);
+    try {
+      const pause = await http(() => driver.post(`/runs/${enc(c.runId)}:pause`, { reason: 'conformance', drainPolicy: 'immediate' }));
+      if (pause === null) return softSkip('blocked', 'POST /runs/{runId}:pause unreachable (fetch failed)');
+      if (pause.status === 404) return softSkip('blocked', 'POST /runs/{runId}:pause answered 404 — not mounted');
+      expect(pause.status, req(ID, DOC, `pauseRun on a running run MUST answer 202 — got ${pause.status} ${readErrorCode(pause.json) ?? ''}`.trim())).toBe(202);
+      const pb = pause.json as { runId?: unknown; status?: unknown } | null;
+      expect(pb?.runId, req(ID, DOC, 'the 202 MUST carry the runId')).toBe(c.runId);
+      expect(pb?.status, req(ID, DOC, `the 202 MUST carry status paused (got ${String(pb?.status)})`)).toBe('paused');
+      const again = await http(() => driver.post(`/runs/${enc(c.runId)}:pause`, {}));
+      expect(again?.status ?? null, req(ID, DOC, `a second pause on a paused run MUST answer 409 — got ${again?.status ?? 'no response'}`)).toBe(409);
+      expect(readErrorCode(again?.json), req(ID, DOC, `a pause refused on a non-terminal run MUST carry run_state_conflict (got ${String(readErrorCode(again?.json))})`)).toBe('run_state_conflict');
+      const runStatus = (again?.json as { error?: { details?: { runStatus?: unknown } } } | null)?.error?.details?.runStatus;
+      expect(runStatus, req(ID, DOC, `run_state_conflict MUST carry details.runStatus naming the status that refused it (got ${String(runStatus)})`)).toBe('paused');
+      const resume = await http(() => driver.post(`/runs/${enc(c.runId)}:resume`, { reason: 'conformance' }));
+      expect(resume?.status ?? null, req(ID, DOC, `resumeRun on a paused run MUST answer 202 — got ${resume?.status ?? 'no response'} ${readErrorCode(resume?.json) ?? ''}`.trim())).toBe(202);
+      const rb = resume?.json as { runId?: unknown; status?: unknown } | null;
+      expect(rb?.status, req(ID, DOC, `the 202 MUST carry status running (got ${String(rb?.status)})`)).toBe('running');
+      const types = await eventTypes(c.runId);
+      const p = types?.indexOf('run.paused') ?? -1; const r = types?.indexOf('run.resumed') ?? -1;
+      expect(p >= 0 && r > p, req(ID, 'spec/v2/core/events.md §run.paused', `the log MUST carry run.paused then run.resumed (types: ${(types ?? []).join(', ')})`)).toBe(true);
+    } finally {
+      await http(() => driver.post(`/runs/${enc(c.runId)}/cancel`, { reason: 'conformance cleanup' }));
+    }
+  }, 30_000);
+});

package/src/scenarios/v2-run-snapshot-etag.test.ts

@@ -0,0 +1,57 @@
+/**
+ * `spec/v2/core/runs.md` §Snapshot — the conditional GET (suite 2.0.0, target
+ * major 2; unaided; one run created).
+ *
+ * The 200 SHOULD carry a strong `ETag`; WHEN PRESENT, a matching
+ * `If-None-Match` MUST receive `304` with no body. The SHOULD gates the MUST:
+ * a host that sends no ETag records `inapplicable`. Every response carries
+ * `OpenWOP-Version` (versioning.md §1.4), the 304 included.
+ *
+ * Control: a non-matching `If-None-Match` MUST receive 200 with the body — a
+ * host that answers 304 to any conditional request fails here. `headers.md`
+ * scopes `If-None-Match` to the discovery document; runs.md applies it to the
+ * snapshot with a MUST (finding 5, filed).
+ *
+ * @see spec/v2/core/runs.md §Snapshot
+ * @see spec/v2/core/versioning.md §1.4
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { v2Discovery } from '../lib/v2.js';
+import { readErrorCode } from '../lib/error-envelope.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+const ID = 'openwop.requirement.0170.run-snapshot-etag';
+const DOC = 'spec/v2/core/runs.md §Snapshot';
+const NOOP = 'conformance-noop';
+
+async function discovery(): Promise<Record<string, unknown> | null> { try { return await v2Discovery(); } catch { return null; } }
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> { try { return await fn(); } catch { return null; } }
+
+describe('v2 run-snapshot-etag (runs.md §Snapshot)', () => {
+  it('a matching If-None-Match receives 304 with no body and the version header; a non-matching one receives 200', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    const created = await http(() => driver.post('/runs', { workflowId: NOOP }));
+    if (created === null) return softSkip('blocked', 'POST /runs unreachable (fetch failed)');
+    const runId = (created.json as { runId?: unknown } | null)?.runId;
+    if (created.status !== 201 || typeof runId !== 'string') return softSkip('blocked', `POST /runs answered ${created.status} ${readErrorCode(created.json) ?? ''} — create refused`.trim());
+    const path = `/runs/${encodeURIComponent(runId)}`;
+    // Let the noop settle so the tag is stable across the two conditional reads.
+    await new Promise((r) => setTimeout(r, 1_000));
+    const first = await http(() => driver.get(path));
+    if (first === null || first.status !== 200) return softSkip('blocked', `GET /runs/{runId} answered ${first?.status ?? 'no response'}`);
+    const etag = first.headers.get('etag');
+    if (!etag) return softSkip('inapplicable', 'the snapshot carries no ETag — runs.md §Snapshot makes the ETag a SHOULD; the 304 rule applies only when it is present');
+    const hit = await http(() => driver.get(path, { headers: { 'If-None-Match': etag } }));
+    if (hit === null) return softSkip('blocked', 'conditional GET unreachable (fetch failed)');
+    expect(hit.status, req(ID, DOC, `a request whose If-None-Match matches the ETag MUST receive 304 — got ${hit.status}`)).toBe(304);
+    expect(hit.text.length, req(ID, DOC, `the 304 MUST carry no body (got ${hit.text.length} byte(s))`)).toBe(0);
+    expect(hit.headers.get('openwop-version'), req(ID, 'spec/v2/core/versioning.md §1.4', 'every response carries OpenWOP-Version, the 304 included')).not.toBeNull();
+    const miss = await http(() => driver.get(path, { headers: { 'If-None-Match': '"openwop-conformance-no-such-tag"' } }));
+    if (miss === null) return softSkip('blocked', 'conditional GET unreachable (fetch failed)');
+    expect(miss.status, req(ID, DOC, `a non-matching If-None-Match MUST receive 200 with the body — got ${miss.status} (a host answering 304 to any conditional request is not honouring the tag)`)).toBe(200);
+    expect((miss.json as { runId?: unknown } | null)?.runId, req(ID, DOC, 'the 200 body is the snapshot')).toBe(runId);
+  });
+});