@openwop/openwop-conformance 2.36.1 → 2.37.1

package/src/scenarios/v2-idempotency-in-flight.test.ts

@@ -0,0 +1,132 @@
+/**
+ * `spec/v2/core/idempotency.md` Concurrency row — the loser of a same-key race
+ * (RFC 0213 §B; suite 2.37.0, target major 2; unaided; one run created).
+ *
+ * Of concurrent same-key requests a host MUST process exactly one. The others
+ * MAY wait and receive the winner's response only if it is a final outcome,
+ * marked `OpenWOP-Idempotent-Replay: true`; otherwise the host MUST answer
+ * `409 idempotency_in_flight` with no retry timing in `details`, and SHOULD set
+ * `Retry-After`. The v2 counterpart of the major-1 `highConcurrency.test.ts`.
+ *
+ * N = 5 parallel `POST /runs` with one key. The record is in flight only
+ * while the winning create request is being handled — not while its run
+ * executes — so a host that answers create in milliseconds rarely refuses a
+ * loser; the fixture choice does not widen that window:
+ *   - exactly one distinct runId across the successes (two runs = the claim
+ *     was not honored);
+ *   - every success but one carries `OpenWOP-Idempotent-Replay: true`;
+ *   - every refusal is `409 idempotency_in_flight`, carries no
+ *     `details.retryAfter*`, and a `Retry-After`, when present, parses.
+ *
+ * Non-vacuity: overlap is not guaranteed. When no request was refused in flight
+ * the LOSER leg records `partial-witness` — the 409 branch never ran, so a pass
+ * is not claimed for it.
+ *
+ * Two `it`s over ONE race (2.37.x). §B names two requirement ids and both were
+ * cited from a single `it`, so only the last of them could ever get a ledger
+ * row; the winner id was recorded on no host. The race is driven once and
+ * memoised — driving it twice would measure two unrelated races and halve the
+ * chance that either overlaps — and each leg now carries its own id, so the
+ * winner clause keeps its verdict when the 409 branch does not run.
+ *
+ * @see spec/v2/core/idempotency.md
+ * @see RFCS/0213-three-unstated-v2-outcomes.md §B
+ */
+
+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 DOC = 'spec/v2/core/idempotency.md Concurrency';
+const ID_ONE = 'openwop.requirement.0213.in-flight-one-winner';
+const ID_LOSER = 'openwop.requirement.0213.in-flight-loser-outcome';
+const FIXTURE = 'conformance-delay';
+const N = 5;
+
+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; } }
+function parsesRetryAfter(v: string): boolean { return /^\d+$/.test(v.trim()) || !Number.isNaN(Date.parse(v)); }
+
+/** The race's outcome, or the reason it could not be driven. */
+type Race =
+  | { readonly kind: 'ran'; readonly all: readonly OpenWOPResponse[]; readonly successes: readonly OpenWOPResponse[]; readonly refusals: readonly OpenWOPResponse[] }
+  | { readonly kind: 'blocked'; readonly reason: string };
+
+/**
+ * ONE race, read by both legs.
+ *
+ * RFC 0213 §B names two requirement ids, and until 2.37.x both were cited from
+ * a SINGLE `it()`. The ledger keys on the id and `setup.ts` takes one
+ * `explicitId` per test, so only the LAST one cited got a row:
+ * `0213.in-flight-one-winner` was never recorded on any host, and nothing said
+ * so. (Found by `check-req-only.mjs` rule (d) the moment it learned to resolve a
+ * `const` handed to `req()` — it had compared only call-site literals, so the
+ * violation was invisible when this file was written.)
+ *
+ * Splitting the legs must not split the EXERCISE: the record is in flight only
+ * while the winning create is being handled, so driving the race twice would
+ * measure two unrelated races and halve the chance that either overlaps. The
+ * race is therefore memoised here and both legs await the same result — the
+ * house pattern from `v2-subject-link-record.test.ts`.
+ */
+let race: Promise<Race> | undefined;
+function theRace(): Promise<Race> {
+  return (race ??= drive());
+}
+
+async function drive(): Promise<Race> {
+  if (!(await discovery())) return { kind: 'blocked', reason: 'v2 discovery unreachable' };
+  const key = `openwopconf-inflight-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+  const body = { workflowId: FIXTURE, inputs: { delayMs: 1500 } };
+  const results = await Promise.all(Array.from({ length: N }, () => http(() => driver.post('/runs', body, { headers: { 'Idempotency-Key': key } }))));
+  if (results.some((r) => r === null)) return { kind: 'blocked', reason: 'POST /runs unreachable (fetch failed)' };
+  const rs = results as OpenWOPResponse[];
+  const first = rs.find((r) => r.status >= 200 && r.status < 300);
+  if (first === undefined) {
+    const codes = rs.map((r) => `${r.status} ${readErrorCode(r.json) ?? ''}`.trim()).join(', ');
+    if (rs.every((r) => r.status === 404 || r.status === 422)) return { kind: 'blocked', reason: `the ${FIXTURE} fixture is not runnable (${codes})` };
+  }
+  return {
+    kind: 'ran',
+    all: rs,
+    successes: rs.filter((r) => r.status >= 200 && r.status < 300),
+    refusals: rs.filter((r) => !(r.status >= 200 && r.status < 300)),
+  };
+}
+
+describe('v2 idempotency-in-flight (idempotency.md Concurrency, RFC 0213 §B)', () => {
+  it('concurrent same-key creates yield exactly one run', async () => {
+    const r = await theRace();
+    if (r.kind === 'blocked') return softSkip('blocked', r.reason);
+    expect(r.successes.length, req(ID_ONE, DOC, `at least one of ${N} same-key creates MUST complete (statuses: ${r.all.map((x) => x.status).join(',')})`)).toBeGreaterThan(0);
+    const runIds = new Set(r.successes.map((x) => (x.json as { runId?: unknown } | null)?.runId).filter((x): x is string => typeof x === 'string'));
+    expect(runIds.size, req(ID_ONE, DOC, `a host MUST NOT process two same-key requests: distinct runIds ${[...runIds].join(', ')}`)).toBe(1);
+  }, 60_000);
+
+  it('each loser is a marked replay of a final outcome, or 409 idempotency_in_flight with no retry timing in details', async () => {
+    const r = await theRace();
+    if (r.kind === 'blocked') return softSkip('blocked', r.reason);
+    const unmarked = r.successes.filter((x) => x.headers.get('openwop-idempotent-replay') !== 'true');
+    expect(unmarked.length, req(ID_LOSER, DOC, `exactly one success is the winner; every other MUST carry OpenWOP-Idempotent-Replay: true (${unmarked.length} of ${r.successes.length} unmarked)`)).toBe(1);
+    for (const x of r.refusals) {
+      const code = readErrorCode(x.json);
+      expect({ status: x.status, code }, req(ID_LOSER, DOC, `a loser that is not a replay MUST be 409 idempotency_in_flight (got ${x.status} ${String(code)})`)).toEqual({ status: 409, code: 'idempotency_in_flight' });
+      const details = (x.json as { details?: Record<string, unknown> } | null)?.details ?? {};
+      const timing = Object.keys(details).filter((k) => /^retryAfter/i.test(k));
+      expect(timing, req(ID_LOSER, 'spec/v2/core/errors.md §Retry timing', `retry timing MUST NOT travel in details (found ${timing.join(', ')})`)).toEqual([]);
+      const ra = x.headers.get('retry-after');
+      if (ra !== null) expect(parsesRetryAfter(ra), req(ID_LOSER, DOC, `a Retry-After that is present MUST parse (got ${ra})`)).toBe(true);
+    }
+    // Every loser replayed the winner: RFC 0213 §B permits exactly this (a
+    // loser MAY wait and receive a final outcome, marked). The 409 branch did
+    // not run, so the row is a partial witness — never `blocked`, which would
+    // deny certification (RFC 0168 §E.1) to a host that did nothing wrong.
+    // (#1525's fix, kept verbatim; `r.refusals` is the split form's spelling of
+    // its `refusals`, and it now lands on the LOSER id it is about rather than
+    // on a row shared with the winner clause.)
+    if (r.refusals.length === 0) return softSkip('inapplicable', `no loser was refused in flight — all ${N} answers were successes (each loser a marked replay, which §B permits), so the 409 branch did not run on this host`);
+  }, 60_000);
+});

package/src/scenarios/v2-interrupt-resolve-terminal.test.ts

@@ -0,0 +1,107 @@
+/**
+ * `spec/v2/core/errors.md` §"One code per state" — a resolve after the run
+ * ended (RFC 0213 §C; suite 2.37.0, target major 2; unaided; two runs created).
+ *
+ * A run-scoped resolve against an interrupt whose run is cancelled or completed
+ * MUST return `409 interrupt_already_resolved`; `interrupt_cancelled` is
+ * registered but names no state of the core resolve surfaces, and a host MUST
+ * NOT emit it. A resolve on an unknown run is `404 not_found`.
+ *
+ * Legs:
+ *   1. suspend (`conformance-approval`) → cancel → resolve ⇒ 409
+ *      interrupt_already_resolved (a 410 `interrupt_cancelled`, a vendor
+ *      "gone" code, or a 200 that "resumes" a cancelled run all fail);
+ *   2. suspend → resolve (accept) → completed → resolve again ⇒ the same 409;
+ *   3. a resolve on an unknown own-tenant runId ⇒ 404 not_found.
+ *
+ * The signed-token surface is a SHOULD and needs a token the suite cannot mint;
+ * its terminal outcome is the same row of `interrupt.md` and is not re-tested
+ * here.
+ *
+ * @see spec/v2/core/errors.md §One code per state
+ * @see spec/v2/core/interrupt.md §Resolve
+ * @see RFCS/0213-three-unstated-v2-outcomes.md §C
+ */
+
+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 DOC = 'spec/v2/core/errors.md §One code per state';
+const ID_CANCELLED = 'openwop.requirement.0213.resolve-after-cancel';
+const ID_COMPLETED = 'openwop.requirement.0213.resolve-after-complete';
+const ID_UNKNOWN = 'openwop.requirement.0213.resolve-unknown-run';
+const FIXTURE = 'conformance-approval';
+const NODE_ID = 'gate';
+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 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 waitStatus(runId: string, wanted: ReadonlySet<string>, timeoutMs: number): Promise<string | null> {
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    const s = await statusOf(runId);
+    if (s !== null && wanted.has(s)) return s;
+    if (Date.now() > deadline) return s;
+    await new Promise((r) => setTimeout(r, 250));
+  }
+}
+async function suspended(): Promise<{ runId: string } | { reason: string }> {
+  const res = await http(() => driver.post('/runs', { workflowId: FIXTURE }));
+  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 (${FIXTURE}) answered ${res.status} ${readErrorCode(res.json) ?? ''}`.trim() };
+  const s = await waitStatus(runId, new Set(['waiting-approval', ...TERMINAL]), 10_000);
+  if (s !== 'waiting-approval') return { reason: `the ${FIXTURE} run did not suspend on its approval gate (status ${String(s)})` };
+  return { runId };
+}
+const resolve = (runId: string): Promise<OpenWOPResponse | null> => http(() => driver.post(`/runs/${enc(runId)}/interrupts/${enc(NODE_ID)}`, { resumeValue: { action: 'accept' } }));
+
+describe('v2 interrupt-resolve-terminal (errors.md §One code per state, RFC 0213 §C)', () => {
+  it('a run-scoped resolve after the run was cancelled is 409 interrupt_already_resolved', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    const s = await suspended(); if ('reason' in s) return softSkip('blocked', s.reason);
+    const cancel = await http(() => driver.post(`/runs/${enc(s.runId)}/cancel`, {}));
+    if (cancel === null || cancel.status !== 200) return softSkip('blocked', `POST /runs/{runId}/cancel answered ${cancel?.status ?? 'nothing'} — cancelRun owns that contract`);
+    const settled = await waitStatus(s.runId, new Set(['cancelled']), 10_000);
+    if (settled !== 'cancelled') return softSkip('blocked', `the cancelled run did not reach cancelled within 10 s (status ${String(settled)})`);
+    const res = await resolve(s.runId);
+    if (res === null) return softSkip('blocked', 'the resolve was unreachable (fetch failed)');
+    const code = readErrorCode(res.json);
+    expect({ status: res.status, code }, req(ID_CANCELLED, DOC, `a resolve against a cancelled run MUST return 409 interrupt_already_resolved — never 410 interrupt_cancelled, a vendor code, or a 200 (got ${res.status} ${String(code)})`)).toEqual({ status: 409, code: 'interrupt_already_resolved' });
+  }, 45_000);
+
+  it('a second run-scoped resolve after the run completed is 409 interrupt_already_resolved', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    const s = await suspended(); if ('reason' in s) return softSkip('blocked', s.reason);
+    const first = await resolve(s.runId);
+    if (first === null || first.status < 200 || first.status >= 300) return softSkip('blocked', `the first resolve answered ${first?.status ?? 'nothing'} ${readErrorCode(first?.json) ?? ''} — interrupt resolution owns that contract`);
+    const settled = await waitStatus(s.runId, TERMINAL, 10_000);
+    if (settled !== 'completed') return softSkip('blocked', `the accepted run did not complete within 10 s (status ${String(settled)})`);
+    const res = await resolve(s.runId);
+    if (res === null) return softSkip('blocked', 'the second resolve was unreachable (fetch failed)');
+    const code = readErrorCode(res.json);
+    expect({ status: res.status, code }, req(ID_COMPLETED, DOC, `a resolve against a completed run MUST return 409 interrupt_already_resolved (got ${res.status} ${String(code)})`)).toEqual({ status: 409, code: 'interrupt_already_resolved' });
+  }, 45_000);
+
+  it('a run-scoped resolve on an unknown run is 404 not_found', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    const s = await suspended(); if ('reason' in s) return softSkip('blocked', s.reason);
+    await http(() => driver.post(`/runs/${enc(s.runId)}/cancel`, {}));
+    const slash = s.runId.indexOf('/');
+    if (slash <= 0) return softSkip('blocked', `the created runId ${s.runId} carries no tenant segment — v2-id-grammar owns that contract`);
+    const res = await resolve(`${s.runId.slice(0, slash)}/openwopconformanceunknown${Date.now().toString(36)}`);
+    if (res === null) return softSkip('blocked', 'the resolve was unreachable (fetch failed)');
+    const code = readErrorCode(res.json);
+    expect({ status: res.status, code }, req(ID_UNKNOWN, 'spec/v2/core/interrupt.md §Resolve', `a resolve on an unknown run MUST be 404 not_found (got ${res.status} ${String(code)})`)).toEqual({ status: 404, code: 'not_found' });
+  }, 45_000);
+});

package/src/scenarios/v2-mcp-mount-map.test.ts

@@ -47,6 +47,9 @@ const META_C = 'io.modelcontextprotocol/clientCapabilities';
 const ERR = { HEADER_MISMATCH: -32020, MISSING_CAPABILITY: -32021, UNSUPPORTED_VERSION: -32022, INVALID_PARAMS: -32602 } as const;
 
 const MAP = JSON.parse(readFileSync(join(SCHEMAS_DIR, '..', 'spec', 'v2', 'interop-map.json'), 'utf8')) as { mcp: { features: Array<{ id: string; requiredFor: string[] }> } };
+// `interruptId` is host-minted and tenant-bound (`<tenant>/<opaque>`); `nodeId` is author-chosen
+// inside a workflow definition and carries no `/`, so the two grammars cannot both admit one string.
+const INTERRUPT_ID = new RegExp((JSON.parse(readFileSync(join(SCHEMAS_DIR, 'v2', 'ids.schema.json'), 'utf8')) as { $defs: { interruptId: { pattern: string } } }).$defs.interruptId.pattern);
 const REQUIRED_FEATURES = MAP.mcp.features.filter((f) => f.requiredFor.includes(PROFILE)).map((f) => f.id).sort();
 
 interface RpcError { code: number; message?: string; data?: Record<string, unknown> }
@@ -200,6 +203,44 @@ describe('RFC 0208 — v2-mcp-mount-map (host as MCP 2026-07-28 server, gated on
     expect(forged.error !== undefined || forged.status >= 400, req(id, 'interop-map.json mcp.mrtr requestState (host as server)', `a requestState that fails integrity verification MUST be refused (got ${forged.status} ${JSON.stringify(forged.result)})`)).toBe(true);
   });
 
+  it('the MRTR input-request key is the open interrupt’s interruptId, never the node it suspended on', async () => {
+    const m = await mount();
+    if (!m.ok) return skip(m);
+    const missing = needFixtures(['conformance-approval']);
+    if (missing) return softSkip('blocked', missing);
+    const id = R('mcp-mrtr-input-request-key');
+    const TOOL = 'conformance-approval';
+    const caps = { elicitation: {} };
+    const runs = async (): Promise<string[]> => ((((await driver.get(`/runs?workflowId=${TOOL}&limit=50`)).json as { runs?: Array<{ runId?: string }> } | undefined)?.runs ?? []).map((x) => String(x.runId)));
+    const listable = await familyAdvertised('runList');
+    const before = listable ? await runs() : [];
+    // TWO runs of ONE workflow: both suspend at the SAME node, so a node-keyed host
+    // advertises the SAME key for two different outstanding interrupts and the key stops
+    // naming the request. (`tasks/get` projects this same key — mcp.tasks.status.)
+    const a = await toolCall(m.url, TOOL, {}, { caps });
+    const b = await toolCall(m.url, TOOL, {}, { caps });
+    expect([a.result?.['resultType'], b.result?.['resultType']], req(id, 'interop-map.json mcp.mrtr InputRequiredResult (host as server)', `both calls MUST answer InputRequiredResult (got ${JSON.stringify([a.error ?? a.result, b.error ?? b.result])})`)).toEqual(['input_required', 'input_required']);
+    const keys = [a, b].map((r) => Object.keys((r.result?.['inputRequests'] ?? {}) as Record<string, unknown>));
+    expect(keys.map((k) => k.length), req(id, 'interop-map.json mcp.tasks.status waiting-approval', `inputRequests carries exactly one key per open interrupt (got ${JSON.stringify(keys)})`)).toEqual([1, 1]);
+    const [ka, kb] = [keys[0]![0]!, keys[1]![0]!];
+    expect([INTERRUPT_ID.test(ka), INTERRUPT_ID.test(kb)], req(id, 'interop-map.json mcp.mrtr InputRequiredResult (host as server); schemas/v2/ids.schema.json interruptId', `the key MUST be the interrupt’s interruptId, which is tenant-bound (${INTERRUPT_ID.source}) and so can never be an author-chosen nodeId (got ${JSON.stringify([ka, kb])})`)).toEqual([true, true]);
+    expect(ka === kb, req(id, 'interop-map.json mcp.mrtr InputRequiredResult (host as server)', `two outstanding interrupts MUST NOT share a key — these runs suspend at the same node, so an equal key is that node’s id, not either interrupt’s (got ${ka})`)).toBe(false);
+    if (listable) {
+      // The positive tie: the key is an id the run’s own log minted, not merely a well-formed
+      // string. Runs another leg started in parallel only widen the pool, never narrow it.
+      const minted = new Set<string>();
+      for (const runId of (await runs()).filter((r) => !before.includes(r))) {
+        const poll = await driver.get(`/runs/${encodeURIComponent(runId)}/events/poll?timeout=1`);
+        for (const e of ((poll.json as { events?: Array<{ type?: string; payload?: { interruptId?: unknown } }> } | undefined)?.events ?? [])) if (e.type === 'node.suspended' && typeof e.payload?.interruptId === 'string') minted.add(e.payload.interruptId);
+      }
+      expect([minted.has(ka), minted.has(kb)], req(id, 'interop-map.json mcp.mrtr InputRequiredResult (host as server); runs.md node.suspended', `each key MUST be an interruptId the run’s own node.suspended carries (keys ${JSON.stringify([ka, kb])}; minted ${JSON.stringify([...minted])})`)).toEqual([true, true]);
+    }
+    // …and that key is the one the retry answers: the state minted beside it resolves the run.
+    const done = await toolCall(m.url, TOOL, { requestState: a.result?.['requestState'], inputResponses: { [ka]: { action: 'accept', content: { action: 'accept' } } } }, { caps });
+    expect([done.error, done.result?.['resultType'], done.result?.['isError']], req(id, 'interop-map.json mcp.mrtr inputResponses[key] (host as server)', `the interruptId key MUST be the key inputResponses is read under (got ${JSON.stringify(done.error ?? done.result)})`)).toEqual([undefined, 'complete', false]);
+    await toolCall(m.url, TOOL, { requestState: b.result?.['requestState'], inputResponses: { [kb]: { action: 'decline' } } }, { caps });
+  });
+
   it('a list that differs per caller is cacheScope private', async () => {
     const other = process.env.OPENWOP_TEST_TENANT_B_API_KEY;
     if (!other) return softSkip('blocked', 'OPENWOP_TEST_TENANT_B_API_KEY (a credential bound to a second tenant) is not set — the cross-caller half cannot run');

package/src/scenarios/v2-negotiation-authenticated.test.ts

@@ -101,6 +101,12 @@ describe('RFC 0175 §D.1 — negotiation-authenticated (gated on a2a/mcp + seams
     try {
       const res = await driver.post(`${SEAMS_PREFIX}/sample/a2a/invoke`, { peerUrl: peer.hostFacingEndpoint(), authenticated: false, peerOffersOnly: A2A_LOWER });
       if (res.status === 404 || res.status === 403 || res.status === 405) return seamAbsent(`host advertises a2a but ${SEAMS_PREFIX}/sample/a2a/invoke answered ${res.status} (host-sample-test-seams.md §22)`);
+      // A SUCCESS is only evidence if the host negotiated with THIS peer — the
+      // one that offers only the lower version. Before 2.37.0, on a tunnelled
+      // cut, the host reached the shared fake instead and this leg read an
+      // untouched peer (`lib/front-mux.ts`). A refusal needs no contact (not
+      // calling satisfies the MUST NOT); a success with none is `blocked`.
+      if (res.status < 400 && peer.invocations().length === 0) return softSkip('blocked', `the seam answered ${res.status} and the lower-version suite peer at ${peer.hostFacingEndpoint()} received no request — the exchange this row measures did not reach it`);
       const wire = peer.invocations().filter((i) => i.method !== 'GET').map((i) => String(i.headers['a2a-version'] ?? ''));
       await assertNotLowered('openwop.requirement.0175.negotiation-authenticated', preferred, A2A_LOWER, res, wire);
     } finally {
@@ -121,6 +127,13 @@ describe('RFC 0175 §D.1 — negotiation-authenticated (gated on a2a/mcp + seams
     try {
       const res = await driver.post(`${SEAMS_PREFIX}/sample/mcp/invoke`, { serverUrl: server.hostFacingEndpoint(), authenticated: false });
       if (res.status === 404 || res.status === 403 || res.status === 405) return seamAbsent(`host advertises mcp but ${SEAMS_PREFIX}/sample/mcp/invoke answered ${res.status} (host-sample-test-seams.md §23)`);
+      // This leg has no seam knob forcing the lower offer: the ONLY thing that
+      // makes the exchange unauthenticated-and-lower is this server. Before
+      // 2.37.0 a tunnelled cut sent the host to the shared fake, which offers
+      // preferredVersion, so the leg passed having measured nothing
+      // (`lib/front-mux.ts`). A refusal needs no contact; a success with none
+      // is `blocked`, never a pass.
+      if (res.status < 400 && server.invocations().length === 0) return softSkip('blocked', `the seam answered ${res.status} and the lower-revision suite server at ${server.hostFacingEndpoint()} received no request — the exchange this row measures did not reach it`);
       const wire = server.invocations().map((i) => String(i.headers['mcp-protocol-version'] ?? ''));
       await assertNotLowered('openwop.requirement.0175.negotiation-authenticated.mcp', preferred, MCP_LOWER, res, wire);
     } finally {

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

@@ -0,0 +1,133 @@
+/**
+ * `spec/v2/core/events.md` §SSE frames — `Last-Event-ID` is an exclusive
+ * cursor (RFC 0213 §A; suite 2.37.0, target major 2; unaided; one run created).
+ *
+ * `Last-Event-ID: N` streams the events with `sequence > N`. When N is at or
+ * beyond the last persisted sequence there is no backlog: a terminal run's
+ * stream closes without a frame. A host MUST NOT refuse a well-formed
+ * non-negative integer because no event carries that sequence; any other value
+ * SHOULD be refused `400 validation_error`. The header is evaluated only after
+ * the caller is authorized to read the run: for a run the caller cannot read
+ * the answer MUST be the one the host gives without the header.
+ *
+ * Off the core-standard floor: `v2-sse-last-event-id` is the floor scenario and
+ * this file adds legs a committed claim was never measured against (rc.59
+ * precedent). Promotion waits until the three bundle hosts are measured.
+ *
+ * Legs, on one completed noop run:
+ *   1. a future id (last + 1000) ⇒ 200, zero frames, closed by the server — a
+ *      host that 400s the id fails the status, one that resumes from 0 fails
+ *      the frame count;
+ *   2. `Last-Event-ID: abc` ⇒ if refused, `400 validation_error` (SHOULD: a
+ *      host that ignores it is recorded, not failed);
+ *   3. an unknown own-tenant runId and a forged foreign-tenant runId answer the
+ *      same status and error code with and without the header; and — the
+ *      threat itself — an EXISTING run of a second tenant
+ *      (`OPENWOP_TEST_TENANT_B_API_KEY`) answers the same with no header, a
+ *      cursor inside its log and a cursor past it. A host that reads the
+ *      cursor before authorizing can only be told apart on a run that
+ *      exists; without the second credential the leg records
+ *      `partial-witness`, because the nonexistent-run comparisons cannot
+ *      catch that host.
+ *
+ * @see spec/v2/core/events.md §SSE frames
+ * @see RFCS/0213-three-unstated-v2-outcomes.md §A
+ */
+
+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 DOC = 'spec/v2/core/events.md §SSE frames';
+const ID_CURSOR = 'openwop.requirement.0213.last-event-id-exclusive-cursor';
+const ID_MALFORMED = 'openwop.requirement.0213.last-event-id-malformed';
+const ID_AUTHZ = 'openwop.requirement.0213.last-event-id-after-authorization';
+const NOOP = 'conformance-noop';
+const V2 = { 'OpenWOP-Version': '2.0' };
+const FOREIGN_RUN_ID = '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; } }
+const enc = (id: string): string => encodeURIComponent(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(bearer?: string): Promise<{ runId: string } | { reason: string }> {
+  const as = bearer === undefined ? {} : { authenticated: false, headers: { Authorization: `Bearer ${bearer}` } };
+  const res = await http(() => driver.post('/runs', { workflowId: NOOP }, as));
+  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)}`, as));
+    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' };
+}
+
+/** Status and error code of a stream request, never reading an SSE body (a 200 is reported as-is). */
+async function answer(path: string, lastEventId?: string): Promise<{ status: number; code: string | null }> {
+  const probe = await subscribe(path, { timeoutMs: 5_000, extraHeaders: V2, ...(lastEventId === undefined ? {} : { lastEventId }) });
+  if (probe.status === 200) return { status: 200, code: null };
+  const headers: Record<string, string> = { Accept: 'text/event-stream' };
+  if (lastEventId !== undefined) headers['Last-Event-ID'] = lastEventId;
+  const res = await http(() => driver.get(path, { headers }));
+  return { status: probe.status, code: res === null ? null : (readErrorCode(res.json) ?? null) };
+}
+
+describe('v2 sse-last-event-id-cursor (events.md §SSE frames, RFC 0213 §A)', () => {
+  it('a Last-Event-ID past the log is an exclusive cursor: a terminal run answers 200 with no frame and closes', 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');
+    const seqs = full.events.map(seqOf).filter((n): n is number => n !== null);
+    if (full.status !== 200 || seqs.length === 0) return softSkip('blocked', `the full stream did not yield numbered frames (status ${full.status}, ${seqs.length} ids) — v2-sse-last-event-id owns that contract`);
+    const future = String(Math.max(...seqs) + 1000);
+    const past = await subscribe(path, { timeoutMs: 8_000, extraHeaders: V2, lastEventId: future });
+    expect(past.status, req(ID_CURSOR, DOC, `a well-formed Last-Event-ID no event carries (${future}) MUST NOT be refused — got ${past.status}`)).toBe(200);
+    expect(past.events.length, req(ID_CURSOR, DOC, `a cursor past the end of a terminal run's log MUST yield no frame — a host resuming from 0 re-sends all ${seqs.length} (got ${past.events.length})`)).toBe(0);
+    expect(past.closedBy, req(ID_CURSOR, DOC, 'on a terminal run the host MUST close the empty stream itself')).toBe('server');
+  }, 45_000);
+
+  it('a Last-Event-ID that is not a non-negative integer, when refused, is 400 validation_error', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    const c = await createSettled(); if ('reason' in c) return softSkip('blocked', c.reason);
+    const got = await answer(`/runs/${enc(c.runId)}/events?streamMode=debug`, 'abc');
+    if (got.status === 200) return softSkip('inapplicable', 'the host accepted Last-Event-ID: abc (the refusal is a SHOULD — recorded, not failed)');
+    expect(got.status, req(ID_MALFORMED, DOC, `a refused malformed Last-Event-ID SHOULD be 400 — got ${got.status}`)).toBe(400);
+    expect(got.code, req(ID_MALFORMED, 'spec/v2/core/errors.md', `the refusal MUST carry validation_error — got ${String(got.code)}`)).toBe('validation_error');
+  }, 30_000);
+
+  it('the cursor never changes the answer for a run the caller cannot read', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    const c = await createSettled(); if ('reason' in c) return softSkip('blocked', c.reason);
+    const slash = c.runId.indexOf('/');
+    if (slash <= 0) return softSkip('blocked', `the created runId ${c.runId} carries no tenant segment — v2-id-grammar owns that contract`);
+    const unknown = `${c.runId.slice(0, slash)}/openwopconformanceunknown${Date.now().toString(36)}`;
+    for (const [label, runId] of [['unknown own-tenant run', unknown], ['foreign-tenant run', FOREIGN_RUN_ID]] as const) {
+      const path = `/runs/${enc(runId)}/events?streamMode=debug`;
+      const bare = await answer(path);
+      const cursor = await answer(path, '0');
+      expect(bare.status, req(ID_AUTHZ, 'spec/v2/core/runs.md §Identity', `a ${label} MUST NOT be streamed (got ${bare.status})`)).not.toBe(200);
+      expect({ status: cursor.status, code: cursor.code }, req(ID_AUTHZ, DOC, `for a ${label} the answer with Last-Event-ID (${cursor.status} ${String(cursor.code)}) MUST equal the answer without it (${bare.status} ${String(bare.code)})`)).toEqual({ status: bare.status, code: bare.code });
+    }
+    const other = process.env.OPENWOP_TEST_TENANT_B_API_KEY;
+    if (!other) return softSkip('blocked', 'OPENWOP_TEST_TENANT_B_API_KEY is not set — the existing-foreign-run comparison, the only one a cursor-first host fails, did not run');
+    const theirs = await createSettled(other); if ('reason' in theirs) return softSkip('blocked', `tenant B could not create a run: ${theirs.reason}`);
+    if (theirs.runId.slice(0, theirs.runId.indexOf('/')) === c.runId.slice(0, slash)) return softSkip('blocked', 'OPENWOP_TEST_TENANT_B_API_KEY binds the same tenant as OPENWOP_API_KEY — the leg needs a second tenant');
+    const path = `/runs/${enc(theirs.runId)}/events?streamMode=debug`;
+    const bare = await answer(path);
+    expect(bare.status, req(ID_AUTHZ, 'spec/v2/core/runs.md §Identity', `another tenant's existing run MUST NOT be streamed (got ${bare.status})`)).not.toBe(200);
+    for (const cur of ['0', '1000']) {
+      const got = await answer(path, cur);
+      expect({ status: got.status, code: got.code }, req(ID_AUTHZ, DOC, `for another tenant's existing run the answer with Last-Event-ID ${cur} (${got.status} ${String(got.code)}) MUST equal the answer without it (${bare.status} ${String(bare.code)})`)).toEqual({ status: bare.status, code: bare.code });
+    }
+  }, 45_000);
+});

package/src/scenarios/v2-terminal-event-once.test.ts

@@ -15,10 +15,20 @@
  * finish after the first terminal event. Growth after a terminal event is the
  * violation's own evidence, not an inconclusive read.
  *
+ * 2.37.0 — the duplicate-delivery leg takes its receiver from
+ * `lib/effect-receiver.ts` rather than a local copy. Both this file and
+ * `v2-durability-recovery.test.ts` drive the same host seam, and both handed it
+ * the SAME destination URL; on a tunnelled cut that is one byte-identical
+ * string, so the two exercises shared one Layer-2 effect identity and a
+ * conformant host deduplicated the second one away. This leg survived it (it
+ * asserts on the LOG, and tolerates zero arrivals); `0158.duplicate-delivery`,
+ * which counts arrivals, did not, and flapped with vitest's file order. The
+ * shared receiver mints a per-exercise nonce so the collision cannot recur.
+ *
  * @see spec/v2/core/events.md §The terminal event
+ * @see spec/v1/idempotency.md §"Layer 2 Keying"
  * @see RFCS/0194-terminal-event-ends-forward-execution.md
  */
-import { createServer, type IncomingMessage, type Server, type ServerResponse } from 'node:http';
 import { describe, expect, it } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { v2Discovery } from '../lib/v2.js';
@@ -26,7 +36,7 @@ import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { softSkip } from '../lib/soft-skip.js';
 import { scaledTimeoutMs } from '../lib/polling.js';
 import { req } from '../lib/requirement-ids.js';
-import { receiverBinding, resolveRegistrationUrl } from '../lib/webhook-receiver.js';
+import { startEffectReceiver, waitForFirstArrival } from '../lib/effect-receiver.js';
 import { terminalShapeViolation, TERMINAL_RUN_EVENTS } from '../lib/terminal-shape.js';
 
 const ONCE = 'openwop.requirement.0194.terminal-once';
@@ -104,35 +114,19 @@ describe('v2 terminal event (RFC 0194 §A)', () => {
     if (probe.status === 404 || probe.status === 405) return softSkip('inapplicable', `no RFC 0158 durability test hook at ${KILL_SEAM} (HTTP ${probe.status}) — a black-box suite cannot make a host redeliver accepted work, so this row needs the hook`);
     const rx = await startEffectReceiver();
     try {
-      const target = resolveRegistrationUrl(rx.url);
-      const fired = await http(() => driver.post(KILL_SEAM, { mode: 'duplicate-delivery', effectUrl: target.url }));
+      const fired = await http(() => driver.post(KILL_SEAM, { mode: 'duplicate-delivery', effectUrl: rx.url }));
       const runId = (fired?.json as { runId?: unknown } | null)?.runId;
       if (fired === null || fired.status >= 400 || typeof runId !== 'string') return softSkip('blocked', `the durability hook answered ${fired?.status ?? 'no response'} for mode=duplicate-delivery — no redelivered run to read`);
       const s = await waitStatus(runId, (x) => TERMINAL_STATUS.has(x), 60_000);
       if (s === null || !TERMINAL_STATUS.has(s)) return softSkip('blocked', `the redelivered run did not reach a terminal status (last: ${s ?? 'unreadable'})`);
-      const deadline = Date.now() + scaledTimeoutMs(20_000);
-      while (rx.arrivals === 0 && Date.now() < deadline) await new Promise((r) => setTimeout(r, 250));
+      await waitForFirstArrival(rx, scaledTimeoutMs(20_000));
       const types = await settledLog(runId);
       if (types === null) return softSkip('blocked', 'GET /runs/{runId}/events/poll did not answer — the log is unobservable');
       expect(types.some((t) => TERMINAL_RUN_EVENTS.has(t)), req(DUP, DOC, 'the redelivered run\'s log reached a terminal event')).toBe(true);
       expect(terminalShapeViolation(types), req(DUP, DOC, `work delivered twice MUST leave exactly one terminal run event and nothing forward after it — log: ${types.join(' ')}`)).toBeNull();
     } finally {
-      await new Promise<void>((ok) => rx.server.close(() => ok()));
+      await rx.close();
     }
   }, 180_000);
 });
 
-async function startEffectReceiver(): Promise<{ server: Server; url: string; arrivals: number }> {
-  const state = { arrivals: 0 };
-  const server = createServer((request: IncomingMessage, res: ServerResponse) => {
-    request.on('data', () => { /* drain */ });
-    request.on('end', () => { state.arrivals++; res.writeHead(204); res.end(); });
-  });
-  const pinned = Number(process.env['OPENWOP_WEBHOOK_RECEIVER_PORT'] ?? '');
-  const bindPort = Number.isInteger(pinned) && pinned > 0 && pinned < 65536 ? pinned : 0;
-  const binding = receiverBinding();
-  await new Promise<void>((resolve) => server.listen(bindPort, binding.bind, () => resolve()));
-  const addr = server.address();
-  const out = { server, url: `http://${binding.advertise}:${typeof addr === 'object' && addr ? addr.port : 0}/effect`, get arrivals() { return state.arrivals; } };
-  return out;
-}