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

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 513 scenario files under `src/scenarios/`.
+The current suite has 515 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: 513 scenario files. Use [`coverage.md`](./coverage.md) for current grade/gap tracking.
+Current source tree: 515 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.49",
-  "stampSha256": "7e65e852ca8df98dbfd604c7da903894a0cbd15feec6fe88f2e0879f88187f22"
+  "version": "2.0.0-rc.51",
+  "stampSha256": "a38af8e2fe02ce47112f275efab5ad93a735d658600251125116ca482fb0c187"
 }

package/package.json

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

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": 562,
-    "tests": 2145,
-    "withStableId": 2144,
+    "files": 564,
+    "tests": 2148,
+    "withStableId": 2147,
     "interpolatedTitles": 1,
     "explicitIds": 2057
   },
@@ -28147,7 +28147,7 @@
     {
       "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,
+      "line": 63,
       "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": [
@@ -28171,6 +28171,11 @@
           "requirement": "the foreign-tenant entry MUST be ok: false",
           "interpolated": true
         },
+        {
+          "section": "api/v2/openapi.yaml bulkCancelRuns results[].error",
+          "requirement": null,
+          "interpolated": true
+        },
         {
           "section": "spec/v2/core/identity.md §5",
           "requirement": null,
@@ -28495,6 +28500,179 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-sse-last-event-id.last-event-id-resumes-at-the-next-sequence-never-re-emits-the-resumption-point-l",
+      "file": "v2-sse-last-event-id.test.ts",
+      "line": 59,
+      "title": "Last-Event-ID resumes at the next sequence, never re-emits the resumption point, loses nothing, and at the last id yields nothing",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "the completed log MUST stream as at least one frame",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "frames MUST arrive in log order",
+          "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": "the host MUST close the empty resume itself",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-stream-mode-refusal.a-value-outside-the-pattern-a-forbidden-combination-and-an-unimplemented-mode-ar",
+      "file": "v2-stream-mode-refusal.test.ts",
+      "line": 64,
+      "title": "a value outside the pattern, a forbidden combination, and an unimplemented mode are refused 400 unsupported_stream_mode with details.supported — before content negotiation",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "the refusal MUST be unsupported_stream_mode",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "a host MUST implement updates, so supported MUST list it",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "the refusal MUST be unsupported_stream_mode",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "the refusal MUST be unsupported_stream_mode",
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-stream-mode-refusal.updates-streams-200-text-event-stream-with-frames-bufferms-yields-at-least-one-b",
+      "file": "v2-stream-mode-refusal.test.ts",
+      "line": 95,
+      "title": "updates streams 200 text/event-stream with frames; bufferMs yields at least one batch frame whose data is an array and loses nothing; without bufferMs no frame is batch",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "spec/v2/core/events.md §SSE frames",
+          "requirement": "the completed run's log MUST stream as at least one frame before the server closes"
+        },
+        {
+          "section": "spec/v2/core/events.md §SSE frames",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "spec/v2/core/events.md §SSE frames",
+          "requirement": "without bufferMs no frame is a batch (the control for the batch leg)"
+        },
+        {
+          "section": "spec/v2/core/events.md §SSE frames",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "spec/v2/core/events.md §SSE frames",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "spec/v2/core/events.md §SSE frames",
+          "requirement": "a batch frame's data MUST be an array of RunEventDoc"
+        },
+        {
+          "section": "spec/v2/core/events.md §SSE frames",
+          "requirement": "batching MUST NOT lose or reorder events: the flattened buffered stream equals the unbuffered log (a one-element batch and an unbatched frame are both tolerated)"
+        }
+      ]
+    },
     {
       "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": 513,
+    "files": 515,
     "v1": 445,
-    "v2": 69
+    "v2": 71
   },
   "majors": {
     "a2a-1-0-agent-card.test.ts": [
@@ -1411,6 +1411,12 @@
     "v2-run-snapshot-etag.test.ts": [
       2
     ],
+    "v2-sse-last-event-id.test.ts": [
+      2
+    ],
+    "v2-stream-mode-refusal.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.49",
+  "version": "2.0.0-rc.51",
   "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": "93ecc218d08555eeac0d652768b78050ae7a4847301ddc6664c7415ab12e038a",
-    "api/v2/asyncapi.yaml": "bec2259c5ce9ea7c0935093bdae856570b83d2242d5e298b0b6a8684424a7a83",
-    "api/v2/openapi.yaml": "fc4ee6fdf254f2b414038be709acaeaa6f283505ad8545d1ec6b53d83d1bea25",
+    "api/seams-v2.yaml": "3bd8fb68e7af5ced2bc4d732f01e788c416e61a548247d53975ceabef9054447",
+    "api/v2/asyncapi.yaml": "e452411b20f85d148c87204fbcdbc50673fa61566043df17942b7c20a107ea76",
+    "api/v2/openapi.yaml": "0471cf3410038f001f24ca297176297061a3e5490db3d2fdad4567d0a8187bf2",
     "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": "2e09ac2c32a0c0b7098b0ffeaa2822b5dd82b69c23bb3c07d6be2053e2102b19",
+    "schemas/v2/error-envelope.schema.json": "72d3332fad8fa36d07439c830acf352eefc6da2379374faa2ebbe49e98b8cb08",
     "schemas/v2/eval-summary.schema.json": "bcb165148531d33b7dc01de83da3a049d19ebbef6d12300b17a234c7b03d77d9",
     "schemas/v2/export-bundle.schema.json": "bd28905a7729437ab7f2ad8bb33e13a371b2bf5605a7eb2962a0d246de312d69",
     "schemas/v2/form-content-pack-manifest.schema.json": "307884e57946703b6f86ec283034bf56beb68bea4a000743ebbc9eebeed31b07",
@@ -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": "790bd9d6f00c2d258c0d66d56ed1aea0e0edf8d3b8d1ca7aa70db393b252ee48",
+    "spec/v1/core-standard-manifest.json": "4dad678d815ae55f911ae770a1b6444da7c49691cb0b2806a9a280642a5beed5",
     "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": "63583dec5a4b6de0bacc2894b0752b3da128a0afed80f3dc244e552bc0dd0e55",
+    "spec/v2/errors.json": "f179414a92f30b5dadf26e9e57699649a67324bd7186d5287647d17605d137d3",
     "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": "0c1e10938fd53b0b4798e9ac7c92727c3d5c83643847cbb1da91a6920800f27f",
+    "spec/v2/release.json": "a09f7660ca91bc333c48cbabbb42bd20b78542b471fe35147d1fa9021b4e40cd",
     "spec/v2/retention-floors.json": "eaf3722d95c79947af1d4269ef85117e126518c588cfcf1a2b21b97269f51624"
   },
-  "corpusCommit": "67da501622b8d75dff385cb7f20ff8b96f6dd311"
+  "corpusCommit": "0c2de2edb7b12baa95940bffda7b3a046ed7078a"
 }

package/src/lib/sse.ts

@@ -33,6 +33,13 @@ export interface SseSubscribeOptions {
   readonly lastEventId?: string;
   /** Optional fetch-level abort. Useful for cancellation in long tests. */
   readonly signal?: AbortSignal;
+  /**
+   * Extra request headers. A major-2 caller MUST pass `OpenWOP-Version: 2.0`:
+   * this helper sends none by itself, and a header-less request on an
+   * unversioned path is served the host's `preferredVersion` major
+   * (versioning.md §1.3) — 1.x through the overlap.
+   */
+  readonly extraHeaders?: Record<string, string>;
 }
 
 export interface SseSubscribeResult {
@@ -62,6 +69,7 @@ export async function subscribe(
   if (opts.lastEventId) {
     headers['Last-Event-ID'] = opts.lastEventId;
   }
+  for (const [k, v] of Object.entries(opts.extraHeaders ?? {})) headers[k] = v;
 
   const internalAbort = new AbortController();
   const timeoutHandle = setTimeout(() => internalAbort.abort(), timeoutMs);

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

@@ -23,7 +23,7 @@
 
 import { describe, it, expect } from 'vitest';
 import { driver, type OpenWOPResponse } from '../lib/driver.js';
-import { v2Discovery } from '../lib/v2.js';
+import { v2Discovery, 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';
@@ -42,7 +42,7 @@ async function create(): Promise<{ runId: string } | { reason: string }> {
   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 }
+interface Entry { runId?: unknown; ok?: unknown; status?: unknown; error?: unknown }
 
 describe('v2 run-bulk-cancel (runs.md §Cancel)', () => {
   it('101 ids are refused 400 validation_error with details.maxRunIds', async () => {
@@ -53,7 +53,10 @@ describe('v2 run-bulk-cancel (runs.md §Cancel)', () => {
     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;
+    // The v2 envelope is { error: <code>, message, details? } — `details` at the ROOT
+    // (schemas/v2/error-envelope.schema.json). rc.48/rc.49 read `error.details`
+    // and reported a host defect that was this reader's; retracted in rc.50.
+    const max = (res.json as { details?: { maxRunIds?: unknown } } | null)?.details?.maxRunIds;
     expect(typeof max === 'number' && max >= 1 && max <= 100, req(ID, DOC, `details.maxRunIds MUST state the cap (got ${String(max)})`)).toBe(true);
   });
 
@@ -72,11 +75,16 @@ describe('v2 run-bulk-cancel (runs.md §Cancel)', () => {
     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);
+    // An entry's `error` IS the error envelope (api/v2/openapi.yaml: `$ref error-envelope`):
+    // { error: <code>, message, details? } nested under the entry — so the code is
+    // `entry.error.error`, read the same way as a top-level envelope.
+    const env = v2Validator('error-envelope')(foreign.error);
+    expect(env.ok, req(ID, 'api/v2/openapi.yaml bulkCancelRuns results[].error', `an ok: false entry's error MUST be the error envelope { error: <code>, message, details? } (schemas/v2/error-envelope.schema.json; the OpenAPI $refs it for results[].error) — got ${JSON.stringify(foreign.error)}: ${env.errors}`)).toBe(true);
+    const fcode = String(readErrorCode(foreign.error));
     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';
+      const terminalShape = own.ok === false && readErrorCode(own.error) === '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-pause-resume.test.ts

@@ -92,7 +92,8 @@ describe('v2 run-pause-resume (runs.md §Pause and resume)', () => {
       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;
+      // `details` sits at the envelope ROOT (schemas/v2/error-envelope.schema.json), not under `error`.
+      const runStatus = (again?.json as { details?: { runStatus?: unknown } } | null)?.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);

package/src/scenarios/v2-sse-last-event-id.test.ts

@@ -0,0 +1,93 @@
+/**
+ * `spec/v2/core/events.md` §SSE frames — `Last-Event-ID` resumes every mode
+ * (suite 2.0.0, target major 2; unaided; one run created).
+ *
+ * The host MUST look up the event with that sequence, MUST begin at the next
+ * sequence, and MUST NOT re-emit the resumption point; in `values` mode the
+ * resumption MUST emit a `state.snapshot` first. Frames carry `id:` = the
+ * sequence (0-based: the first frame's id is `0`, so ids are tested for
+ * presence and parsed, never for truthiness).
+ *
+ * Legs and controls, all on one completed noop run:
+ *   1. the full stream: ≥1 frame, numeric ids, closed by the server;
+ *   2. resume at the first id: the first resumed id is greater, the resumption
+ *      id is absent, and the resumed set equals the full set minus every id at
+ *      or below it — one assertion catches loss and duplication;
+ *   3. resume at the last id: zero frames, closed by server (a host that ignores
+ *      the header re-sends all N against an expected 0; a host that closes
+ *      every stream empty fails leg 1);
+ *   4. if `values` is served: a `values` resume's first frame is
+ *      `event: state.snapshot` (a frame name, not a type — §SSE frames).
+ *
+ * @see spec/v2/core/events.md §SSE frames
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { subscribe, type SseEvent } from '../lib/sse.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.sse-last-event-id';
+const DOC = 'spec/v2/core/events.md §SSE frames';
+const NOOP = 'conformance-noop';
+const V2 = { 'OpenWOP-Version': '2.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; } }
+const enc = (id: string): string => encodeURIComponent(id);
+/** The frame's sequence, or null when the frame carries no id — `0` is a valid id. */
+function seqOf(f: SseEvent): number | null { if (f.id === null || f.id === '') return null; const n = Number.parseInt(f.id, 10); return Number.isFinite(n) ? n : null; }
+
+async function createSettled(): 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) ?? ''}`.trim() };
+  const t0 = Date.now();
+  while (Date.now() - t0 < 10_000) {
+    const s = await http(() => driver.get(`/runs/${enc(runId)}`));
+    if (s?.status === 200 && ['completed', 'failed', 'cancelled'].includes(String((s.json as { status?: unknown }).status))) return { runId };
+    await new Promise((r) => setTimeout(r, 250));
+  }
+  return { reason: 'the noop run did not settle within 10 s' };
+}
+
+describe('v2 sse-last-event-id (events.md §SSE frames)', () => {
+  it('Last-Event-ID resumes at the next sequence, never re-emits the resumption point, loses nothing, and at the last id yields nothing', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    const c = await createSettled(); if ('reason' in c) return softSkip('blocked', c.reason);
+    const path = `/runs/${enc(c.runId)}/events?streamMode=debug`;
+    const full = await subscribe(path, { timeoutMs: 8_000, extraHeaders: V2 });
+    if (full.status === 404) return softSkip('blocked', 'GET /runs/{runId}/events answered 404 — streamRunEvents is a core operation and is not mounted');
+    expect(full.status, req(ID, DOC, `the stream MUST answer 200 — got ${full.status}`)).toBe(200);
+    expect(full.events.length, req(ID, DOC, 'the completed log MUST stream as at least one frame')).toBeGreaterThan(0);
+    expect(full.closedBy, req(ID, DOC, `the host MUST close after the terminal event (closed by ${full.closedBy})`)).toBe('server');
+    const ids = full.events.map(seqOf);
+    expect(ids.every((n) => n !== null), req(ID, DOC, `every frame MUST carry id: = its sequence (frames without a parseable id: ${ids.filter((n) => n === null).length} of ${ids.length})`)).toBe(true);
+    const seqs = ids as number[];
+    expect([...seqs].sort((a, b) => a - b), req(ID, DOC, 'frames MUST arrive in log order')).toEqual(seqs);
+    const first = seqs[0]!; const last = seqs[seqs.length - 1]!;
+
+    const resumed = await subscribe(path, { timeoutMs: 8_000, extraHeaders: V2, lastEventId: String(first) });
+    expect(resumed.status, req(ID, DOC, `a resume with Last-Event-ID MUST answer 200 — got ${resumed.status}`)).toBe(200);
+    const rseqs = resumed.events.map(seqOf).filter((n): n is number => n !== null);
+    expect(rseqs.includes(first), req(ID, DOC, `the host MUST NOT re-emit the resumption point (Last-Event-ID ${first} re-emitted)`)).toBe(false);
+    expect(rseqs, req(ID, DOC, `the host MUST begin at the next sequence and lose nothing: resumed ids (${rseqs.join(',')}) MUST equal the full set minus every id ≤ ${first} (${seqs.filter((n) => n > first).join(',')})`)).toEqual(seqs.filter((n) => n > first));
+
+    const atEnd = await subscribe(path, { timeoutMs: 8_000, extraHeaders: V2, lastEventId: String(last) });
+    expect(atEnd.status, req(ID, DOC, `a resume at the terminal sequence MUST answer 200 — got ${atEnd.status}`)).toBe(200);
+    expect(atEnd.events.length, req(ID, DOC, `a resume at the last sequence (${last}) MUST emit nothing and close — a host ignoring the header re-sends all ${seqs.length} (got ${atEnd.events.length})`)).toBe(0);
+    expect(atEnd.closedBy, req(ID, DOC, 'the host MUST close the empty resume itself')).toBe('server');
+
+    // values: resumption MUST emit a state.snapshot first — only where the host serves values.
+    const probe = await http(() => driver.get(`/runs/${enc(c.runId)}/events?streamMode=bogus`, { headers: { Accept: 'text/event-stream' } }));
+    const supported = (probe?.json as { details?: { supported?: unknown } } | null)?.details?.supported;
+    if (!Array.isArray(supported) || !supported.includes('values')) return softSkip('inapplicable', `values mode not served (details.supported: ${JSON.stringify(supported)}) — the state.snapshot-first resumption leg does not apply`);
+    const values = await subscribe(`/runs/${enc(c.runId)}/events?streamMode=values`, { timeoutMs: 8_000, extraHeaders: V2, lastEventId: String(first) });
+    expect(values.status, req(ID, DOC, `a values resume MUST answer 200 — got ${values.status}`)).toBe(200);
+    expect(values.events[0]?.event ?? null, req(ID, DOC, `in values mode a resumption MUST emit a state.snapshot first (first frame: ${values.events[0]?.event ?? 'none'})`)).toBe('state.snapshot');
+  }, 45_000);
+});

package/src/scenarios/v2-stream-mode-refusal.test.ts

@@ -0,0 +1,118 @@
+/**
+ * `spec/v2/core/events.md` §The events channel — `streamMode` is one pattern,
+ * refused with `400 unsupported_stream_mode`, validated before content
+ * negotiation; `bufferMs` batches (suite 2.0.0, target major 2; unaided; one
+ * run created).
+ *
+ * Legs:
+ *   1. `?streamMode=bogus` → 400 `unsupported_stream_mode`, `details.supported`
+ *      a non-empty array of individual modes; the same request with
+ *      `Accept: application/json` → still 400, never 406 (validation runs
+ *      before content negotiation; the only v2 406 is a version mismatch and
+ *      this request names a listed major); `?streamMode=updates,values` → 400
+ *      (`values` never combines); a mode absent from `supported`, if any → 400.
+ *   2. control: `?streamMode=updates` → 200 `text/event-stream` with ≥1 frame
+ *      (a host that answers 400 to every mode fails here; `updates` is a MUST).
+ *   3. `?bufferMs=200` → at least one `event: batch` frame whose `data:` is an
+ *      array of RunEventDoc, and the flattened frames equal the log in order;
+ *      without `bufferMs` no frame is `batch` (the control). "Every frame is
+ *      batch" is deliberately NOT asserted: a consumer MUST tolerate an
+ *      unbatched frame beside a one-element batch (§SSE frames).
+ *
+ * @see spec/v2/core/events.md §The events channel, §SSE frames
+ * @see spec/v2/errors.json unsupported_stream_mode
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { subscribe, type SseEvent } from '../lib/sse.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.stream-mode-refusal';
+const DOC = 'spec/v2/core/events.md §The events channel';
+const NOOP = 'conformance-noop';
+const MODES = ['values', 'updates', 'messages', 'debug'];
+const V2 = { 'OpenWOP-Version': '2.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; } }
+const enc = (id: string): string => encodeURIComponent(id);
+
+async function createSettled(): 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) ?? ''}`.trim() };
+  const t0 = Date.now();
+  while (Date.now() - t0 < 10_000) {
+    const s = await http(() => driver.get(`/runs/${enc(runId)}`));
+    if (s?.status === 200 && ['completed', 'failed', 'cancelled'].includes(String((s.json as { status?: unknown }).status))) return { runId };
+    await new Promise((r) => setTimeout(r, 250));
+  }
+  return { reason: 'the noop run did not settle within 10 s' };
+}
+
+/** The events a frame carries: a batch frame's array flattened, a plain frame's one document. */
+function docsOf(frame: SseEvent): Array<Record<string, unknown>> {
+  try { const p = JSON.parse(frame.data) as unknown; return (Array.isArray(p) ? p : [p]).filter((x): x is Record<string, unknown> => !!x && typeof x === 'object'); } catch { return []; }
+}
+
+describe('v2 stream-mode-refusal (events.md §The events channel)', () => {
+  it('a value outside the pattern, a forbidden combination, and an unimplemented mode are refused 400 unsupported_stream_mode with details.supported — before content negotiation', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    const c = await createSettled(); if ('reason' in c) return softSkip('blocked', c.reason);
+    const path = `/runs/${enc(c.runId)}/events`;
+    const bogus = await http(() => driver.get(`${path}?streamMode=bogus`, { headers: { Accept: 'text/event-stream' } }));
+    if (bogus === null) return softSkip('blocked', 'GET /runs/{runId}/events unreachable (fetch failed)');
+    if (bogus.status === 404) return softSkip('blocked', 'GET /runs/{runId}/events answered 404 — streamRunEvents is a core operation (runs.md §Surface) and is not mounted');
+    expect(bogus.status, req(ID, DOC, `a streamMode outside the pattern MUST be refused 400 — got ${bogus.status}`)).toBe(400);
+    expect(readErrorCode(bogus.json), req(ID, DOC, 'the refusal MUST be unsupported_stream_mode')).toBe('unsupported_stream_mode');
+    const supported = (bogus.json as { details?: { supported?: unknown } } | null)?.details?.supported;
+    expect(Array.isArray(supported) && supported.length > 0 && supported.every((m) => MODES.includes(String(m))), req(ID, DOC, `details.supported MUST list each individual mode the host serves (got ${JSON.stringify(supported)})`)).toBe(true);
+    expect((supported as string[]).includes('updates'), req(ID, DOC, 'a host MUST implement updates, so supported MUST list it')).toBe(true);
+
+    const negotiated = await http(() => driver.get(`${path}?streamMode=bogus`, { headers: { Accept: 'application/json' } }));
+    expect(negotiated?.status ?? null, req(ID, DOC, `validation MUST run before any content negotiation: a bogus streamMode with Accept: application/json is still 400 unsupported_stream_mode, never 406 (the only v2 406 is a version mismatch and this request names a listed major) — got ${negotiated?.status ?? 'no response'}`)).toBe(400);
+
+    const combo = await http(() => driver.get(`${path}?streamMode=updates,values`, { headers: { Accept: 'text/event-stream' } }));
+    expect(combo?.status ?? null, req(ID, DOC, `values never combines: streamMode=updates,values is outside the pattern and MUST be refused 400 — got ${combo?.status ?? 'no response'}`)).toBe(400);
+    expect(readErrorCode(combo?.json), req(ID, DOC, 'the refusal MUST be unsupported_stream_mode')).toBe('unsupported_stream_mode');
+
+    // The unimplemented-mode leg has something to request only when a mode is
+    // absent from details.supported; a host serving all four has no such mode,
+    // and the three refusals above are its witness.
+    const missing = MODES.find((m) => !(supported as string[]).includes(m));
+    if (missing !== undefined) {
+      const unimpl = await http(() => driver.get(`${path}?streamMode=${missing}`, { headers: { Accept: 'text/event-stream' } }));
+      expect(unimpl?.status ?? null, req(ID, DOC, `a mode the host does not implement (${missing}, absent from details.supported) MUST be refused 400 — got ${unimpl?.status ?? 'no response'}`)).toBe(400);
+      expect(readErrorCode(unimpl?.json), req(ID, DOC, 'the refusal MUST be unsupported_stream_mode')).toBe('unsupported_stream_mode');
+    }
+  }, 30_000);
+
+  it('updates streams 200 text/event-stream with frames; bufferMs yields at least one batch frame whose data is an array and loses nothing; without bufferMs no frame is batch', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    const c = await createSettled(); if ('reason' in c) return softSkip('blocked', c.reason);
+    const path = `/runs/${enc(c.runId)}/events`;
+    const plain = await subscribe(`${path}?streamMode=updates`, { timeoutMs: 8_000, extraHeaders: V2 });
+    if (plain.status === 404) return softSkip('blocked', 'GET /runs/{runId}/events answered 404 — not mounted');
+    expect(plain.status, req(ID, DOC, `updates is a MUST: streamMode=updates MUST answer 200 — got ${plain.status} (the control for the refusals: a host answering 400 to every mode fails here)`)).toBe(200);
+    expect(plain.events.length, req(ID, 'spec/v2/core/events.md §SSE frames', 'the completed run\'s log MUST stream as at least one frame before the server closes')).toBeGreaterThan(0);
+    expect(plain.closedBy, req(ID, 'spec/v2/core/events.md §SSE frames', `the host MUST close after the terminal event (closed by ${plain.closedBy})`)).toBe('server');
+    expect(plain.events.some((f) => f.event === 'batch'), req(ID, 'spec/v2/core/events.md §SSE frames', 'without bufferMs no frame is a batch (the control for the batch leg)')).toBe(false);
+    const plainDocs = plain.events.flatMap(docsOf).map((d) => d['sequence']);
+
+    const buffered = await subscribe(`${path}?streamMode=updates&bufferMs=200`, { timeoutMs: 8_000, extraHeaders: V2 });
+    expect(buffered.status, req(ID, 'spec/v2/core/events.md §SSE frames', `streamMode=updates&bufferMs=200 MUST answer 200 — got ${buffered.status}`)).toBe(200);
+    const batches = buffered.events.filter((f) => f.event === 'batch');
+    expect(batches.length, req(ID, 'spec/v2/core/events.md §SSE frames', `with bufferMs the host accumulates events into event: batch frames — none seen among ${buffered.events.length} frame(s) (${[...new Set(buffered.events.map((f) => f.event))].join(', ')})`)).toBeGreaterThan(0);
+    for (const b of batches) {
+      let parsed: unknown; try { parsed = JSON.parse(b.data); } catch { parsed = undefined; }
+      expect(Array.isArray(parsed), req(ID, 'spec/v2/core/events.md §SSE frames', 'a batch frame\'s data MUST be an array of RunEventDoc')).toBe(true);
+    }
+    const bufferedDocs = buffered.events.flatMap(docsOf).map((d) => d['sequence']);
+    expect(bufferedDocs, req(ID, 'spec/v2/core/events.md §SSE frames', 'batching MUST NOT lose or reorder events: the flattened buffered stream equals the unbuffered log (a one-element batch and an unbatched frame are both tolerated)')).toEqual(plainDocs);
+  }, 30_000);
+});