@openwop/openwop-conformance 2.37.1 → 2.39.0

package/src/scenarios/v2-a2a-push-delivery.test.ts

@@ -0,0 +1,246 @@
+/**
+ * RFC 0214 — A2A push delivery, measured at a SUITE-OWNED receiver.
+ * Target major 2.
+ *
+ * Gate: the v2 `a2a` record lists profile `a2a-1.0` AND advertises
+ * `pushNotifications: true`. Otherwise `inapplicable` — the unadvertised host's
+ * obligation is the refusal row (`v2-a2a-operation-map`
+ * `a2a-push-unadvertised-refused`).
+ *
+ * Receiver: `lib/scoped-receiver.ts`, one nonce per exercise behind the
+ * operator's public front (`OPENWOP_WEBHOOK_RECEIVER_URL`, the RFC 0158
+ * receiver). A conforming host REFUSES a loopback, private or plain-http push
+ * destination (RFC 0214 §B, webhooks.md §Egress), so without a public https
+ * front no leg here can be witnessed and each records `blocked` — never a pass,
+ * and never a relaxation of the guard under test.
+ *
+ * Non-vacuity: every leg drives its task to INPUT_REQUIRED FIRST, registers the
+ * config there, and only then resumes — a task that finished before the config
+ * existed would owe no push, and a leg reading "nothing arrived" off it would
+ * measure nothing. On a public front a missing delivery is a FAILURE, except
+ * when other traffic provably reached the listener (`absenceIsUnmeasured`),
+ * which records `blocked`.
+ *
+ * Limit, stated: the delivery-time DNS re-resolve arm of §B cannot be driven
+ * from outside the host (the suite does not control the host's resolver); it is
+ * witnessed by host unit tests, not here. The `token`-only carriage is a SHOULD
+ * (RFC 0214 §C, open question 1) and is not asserted.
+ *
+ * @see RFCS/0214-a2a-push-credential-is-a-destination-credential.md §A–§D
+ * @see spec/v2/core/interop.md §"A2A push delivery"
+ * @see spec/v2/core/security-defaults.md §"Onward hops"
+ */
+import { describe, it, expect } from 'vitest';
+import { randomBytes } from 'node:crypto';
+import type { ServerResponse } from 'node:http';
+import { driver } from '../lib/driver.js';
+import { v2Discovery, familyAdvertised } from '../lib/v2.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { absenceIsUnmeasured, noDeliveryCause, startScopedReceiver, type ScopedHit, type ScopedReceiver } from '../lib/scoped-receiver.js';
+
+export const REQUIRES_HOST_CALLBACK = 'the host POSTs A2A push notifications (StreamResponse statusUpdate) to the suite-owned scoped receiver behind OPENWOP_WEBHOOK_RECEIVER_URL';
+
+const DOC = 'spec/v2/core/interop.md §"A2A push delivery" (RFC 0214)';
+const R = (slug: string): string => `openwop.requirement.0214.${slug}`;
+const PROFILE = 'a2a-1.0';
+const SKILL = 'conformance-approval';
+const ACCEPT = { action: 'accept' };
+const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
+
+interface RpcError { code: number; message?: string; data?: unknown }
+interface Rpc { status: number; result?: Record<string, unknown> | undefined; error?: RpcError | undefined }
+interface Task { id?: string; contextId?: string; status?: { state?: string } }
+
+async function rpc(url: string, method: string, params: unknown): Promise<Rpc> {
+  const headers: Record<string, string> = { 'content-type': 'application/json', accept: 'application/json', 'A2A-Version': '1.0' };
+  const key = process.env.OPENWOP_API_KEY;
+  if (key) headers['authorization'] = `Bearer ${key}`;
+  const res = await fetch(url, { method: 'POST', headers, body: JSON.stringify({ jsonrpc: '2.0', id: randomBytes(4).readUInt32BE(0), method, params }) });
+  const body = (await res.json().catch(() => ({}))) as { result?: Record<string, unknown>; error?: RpcError };
+  return { status: res.status, ...body };
+}
+function taskOf(r: Rpc): Task | undefined {
+  const res = r.result ?? {};
+  return (res['task'] ?? (res['id'] !== undefined ? res : undefined)) as Task | undefined;
+}
+const message = (extra: Record<string, unknown> = {}): Record<string, unknown> => ({ messageId: `conf-0214-${randomBytes(8).toString('hex')}`, role: 'ROLE_USER', parts: [{ text: 'openwop conformance RFC 0214' }], ...extra });
+const acceptMessage = (taskId: string): Record<string, unknown> => message({ taskId, parts: [{ data: ACCEPT }], metadata: { openwop: { interrupt: ACCEPT } } });
+
+type Gate = { ok: true; url: string } | { ok: false; kind: 'inapplicable' | 'blocked'; reason: string };
+async function gate(): Promise<Gate> {
+  if (!(await v2Discovery())) return { ok: false, kind: 'blocked', reason: 'v2 discovery unreachable' };
+  const a2a = await familyAdvertised('a2a');
+  if (!a2a) return { ok: false, kind: 'inapplicable', reason: 'a2a not advertised at major 2' };
+  const profiles = Array.isArray(a2a['profiles']) ? (a2a['profiles'] as unknown[]) : [];
+  if (!profiles.includes(PROFILE)) return { ok: false, kind: 'inapplicable', reason: 'a2a advertised without profile a2a-1.0 — no A2A interface to register a push config on' };
+  if (a2a['pushNotifications'] !== true) return { ok: false, kind: 'inapplicable', reason: 'a2a.pushNotifications not advertised — the refusal row applies (v2-a2a-operation-map a2a-push-unadvertised-refused)' };
+  const cardUrl = a2a['agentCardUrl'];
+  if (typeof cardUrl !== 'string') return { ok: false, kind: 'blocked', reason: 'a2a.agentCardUrl is not advertised' };
+  const res = await fetch(cardUrl, { headers: { accept: 'application/json', 'A2A-Version': '1.0' } });
+  const card = (await res.json().catch(() => ({}))) as { supportedInterfaces?: Array<{ url?: string; protocolBinding?: string; protocolVersion?: string }>; skills?: Array<{ id?: string }> };
+  const iface = (card.supportedInterfaces ?? []).find((i) => i.protocolBinding === 'JSONRPC' && i.protocolVersion === '1.0');
+  if (typeof iface?.url !== 'string') return { ok: false, kind: 'blocked', reason: 'the card lists no JSONRPC 1.0 interface' };
+  const skills = (card.skills ?? []).map((s) => s.id);
+  if (skills.length !== 1 || skills[0] !== SKILL || !isFixtureAdvertised(SKILL)) return { ok: false, kind: 'blocked', reason: `the card routes skills [${skills.join(', ')}]; the legs need exactly ${SKILL} (conformance/fixtures.md)` };
+  return { ok: true, url: iface.url };
+}
+
+/** A receiver that records its own hits and answers each with `answer` (default 204). */
+async function receiver(answer?: (hit: ScopedHit, res: ServerResponse) => void): Promise<{ rx: ScopedReceiver; hits: ScopedHit[] }> {
+  const hits: ScopedHit[] = [];
+  const rx = await startScopedReceiver((hit, res) => {
+    hits.push(hit);
+    if (answer) return answer(hit, res);
+    res.writeHead(204); res.end();
+  });
+  return { rx, hits };
+}
+async function until(pred: () => boolean, ms: number): Promise<boolean> {
+  const end = Date.now() + ms;
+  while (!pred() && Date.now() < end) await new Promise((ok) => setTimeout(ok, 200));
+  return pred();
+}
+const wait = (ms: number): Promise<void> => new Promise((ok) => setTimeout(ok, ms));
+const header = (h: ScopedHit, name: string): string | undefined => { const v = h.headers[name.toLowerCase()]; return Array.isArray(v) ? v.join(',') : v; };
+
+async function runStatus(taskId: string): Promise<string | undefined> {
+  const r = await driver.get(`/runs/${encodeURIComponent(taskId)}`);
+  return r.status === 200 ? ((r.json as { status?: string }).status) : undefined;
+}
+async function settle(taskId: string, want: (s: string | undefined) => boolean, ms = 10000): Promise<string | undefined> {
+  const end = Date.now() + ms;
+  let s = await runStatus(taskId);
+  while (!want(s) && Date.now() < end) { await wait(150); s = await runStatus(taskId); }
+  return s;
+}
+
+/** Start an approval task and hold it at INPUT_REQUIRED — the precondition every leg needs. */
+async function suspendedTask(url: string, id: string): Promise<string> {
+  const r = await rpc(url, 'SendMessage', { message: message() });
+  const task = taskOf(r);
+  expect(typeof task?.id, req(id, DOC, `SendMessage MUST start a task (got ${JSON.stringify(r.error ?? r.result)})`)).toBe('string');
+  expect(await settle(task!.id!, (s) => s === 'waiting-approval'), req(id, DOC, 'precondition: the task MUST be suspended (INPUT_REQUIRED) BEFORE the config is registered, or the leg would measure a push nobody owed')).toBe('waiting-approval');
+  return task!.id!;
+}
+async function create(url: string, taskId: string, dest: string, extra: Record<string, unknown> = {}): Promise<Rpc> {
+  return rpc(url, 'CreateTaskPushNotificationConfig', { taskId, url: dest, ...extra });
+}
+
+/** Why a leg cannot be measured on this cut, or null when it can. */
+function unmeasurable(rx: ScopedReceiver, created: Rpc): string | null {
+  if (!rx.tunnelled) {
+    return `no public https front (OPENWOP_WEBHOOK_RECEIVER_URL) is wired — a conforming host refuses the loopback destination ${rx.url} (RFC 0214 §B), so push delivery cannot be witnessed here${created.error ? ` (Create answered ${JSON.stringify(created.error)})` : ''}`;
+  }
+  return null;
+}
+
+describe('RFC 0214 — v2-a2a-push-delivery (host POSTs A2A push to a suite-owned receiver)', () => {
+  it('§A/§C — a transition after registration is POSTed to the registered destination with the registered Authorization and no OpenWOP signature', async () => {
+    const id = R('a2a-push-delivery-authenticated');
+    const g = await gate();
+    if (!g.ok) return softSkip(g.kind, g.reason);
+    const { rx, hits } = await receiver();
+    try {
+      const taskId = await suspendedTask(g.url, id);
+      const cred = `owpush${randomBytes(12).toString('hex')}`;
+      const created = await create(g.url, taskId, rx.url, { authentication: { scheme: 'Bearer', credentials: cred } });
+      const why = unmeasurable(rx, created);
+      if (why !== null) { await rpc(g.url, 'CancelTask', { id: taskId }); return softSkip('blocked', why); }
+      expect(created.error, req(id, DOC, `Create on a suspended task with the public receiver MUST succeed (got ${JSON.stringify(created.error)})`)).toBeUndefined();
+      await rpc(g.url, 'SendMessage', { message: acceptMessage(taskId) });
+      await settle(taskId, (s) => s !== undefined && TERMINAL.has(s));
+      const arrived = await until(() => hits.length > 0, 20000);
+      if (!arrived && absenceIsUnmeasured(rx)) return softSkip('blocked', noDeliveryCause(rx, 'A2A push'));
+      expect(hits.length, req(id, `${DOC} §C ("at least one attempt")`, `a transition after registration MUST be POSTed at least once to the registered destination — ${noDeliveryCause(rx, 'A2A push')}`)).toBeGreaterThan(0);
+      const h = hits[0]!;
+      expect(h.method, req(id, 'A2A v1.0.1 §4.3.3', 'a push is an HTTP POST')).toBe('POST');
+      expect(header(h, 'authorization'), req(id, `${DOC} §A (A2A v1.0.1 §4.3.3 "MUST include authentication credentials")`, 'the push MUST carry the registered credential as Authorization: {scheme} {credentials}')).toBe(`Bearer ${cred}`);
+      expect((header(h, 'content-type') ?? '').split(';')[0]!.trim(), req(id, 'A2A v1.0.1 §4.3.3', 'the push body is application/a2a+json')).toBe('application/a2a+json');
+      const body = JSON.parse(h.body || '{}') as { statusUpdate?: { taskId?: string; status?: { state?: string } } };
+      expect(body.statusUpdate?.taskId, req(id, 'A2A v1.0.1 §4.3.3 (StreamResponse)', `the push body MUST be a StreamResponse statusUpdate naming the task (got ${h.body.slice(0, 200)})`)).toBe(taskId);
+      const sigId = R('a2a-push-no-openwop-signature');
+      for (const x of hits) {
+        expect(header(x, 'openwop-signature'), req(sigId, `${DOC} §C ("no OpenWOP signature")`, 'an A2A push MUST NOT carry an OpenWOP-Signature — A2A defines no secret exchange to verify it')).toBeUndefined();
+      }
+    } finally { await rx.close(); }
+  }, 60_000);
+
+  it('§B — a 3xx from the destination is a failed delivery: the redirect target receives nothing, credential or not', async () => {
+    const id = R('a2a-push-no-redirect');
+    const g = await gate();
+    if (!g.ok) return softSkip(g.kind, g.reason);
+    const target = await receiver();
+    const origin = await receiver((_hit, res) => { res.writeHead(307, { location: target.rx.url }); res.end(); });
+    try {
+      const taskId = await suspendedTask(g.url, id);
+      const created = await create(g.url, taskId, origin.rx.url, { authentication: { scheme: 'Bearer', credentials: `owredir${randomBytes(10).toString('hex')}` } });
+      const why = unmeasurable(origin.rx, created);
+      if (why !== null) { await rpc(g.url, 'CancelTask', { id: taskId }); return softSkip('blocked', why); }
+      expect(created.error, req(id, DOC, `Create MUST succeed (got ${JSON.stringify(created.error)})`)).toBeUndefined();
+      await rpc(g.url, 'SendMessage', { message: acceptMessage(taskId) });
+      await settle(taskId, (s) => s !== undefined && TERMINAL.has(s));
+      const arrived = await until(() => origin.hits.length > 0, 20000);
+      if (!arrived && absenceIsUnmeasured(origin.rx)) return softSkip('blocked', noDeliveryCause(origin.rx, 'A2A push'));
+      expect(origin.hits.length, req(id, DOC, `positive control: the registered destination MUST receive the push it then redirects — ${noDeliveryCause(origin.rx, 'A2A push')}`)).toBeGreaterThan(0);
+      await wait(4000); // any retry or followed redirect lands in this window
+      expect(target.hits.length, req(id, `${DOC} §B; webhooks.md §Egress ("refuse to follow redirects")`, 'the redirect target MUST receive nothing: a 3xx is a delivery failure and the credential MUST NOT be sent after a redirect')).toBe(0);
+    } finally { await origin.rx.close(); await target.rx.close(); }
+  }, 60_000);
+
+  it('§A — after Delete no further push reaches that destination, while a live config on the same task still receives', async () => {
+    const id = R('a2a-push-discard-on-delete');
+    const g = await gate();
+    if (!g.ok) return softSkip(g.kind, g.reason);
+    const kept = await receiver();
+    const dropped = await receiver();
+    try {
+      const taskId = await suspendedTask(g.url, id);
+      const a = await create(g.url, taskId, kept.rx.url, { authentication: { scheme: 'Bearer', credentials: `owkeep${randomBytes(10).toString('hex')}` } });
+      const why = unmeasurable(kept.rx, a);
+      if (why !== null) { await rpc(g.url, 'CancelTask', { id: taskId }); return softSkip('blocked', why); }
+      const b = await create(g.url, taskId, dropped.rx.url, { authentication: { scheme: 'Bearer', credentials: `owdrop${randomBytes(10).toString('hex')}` } });
+      const dropId = (b.result as { id?: string } | undefined)?.id;
+      expect(typeof dropId, req(id, DOC, `Create of the second config MUST succeed (got ${JSON.stringify(b.error ?? b.result)})`)).toBe('string');
+      const del = await rpc(g.url, 'DeleteTaskPushNotificationConfig', { taskId, id: dropId });
+      expect(del.error, req(id, DOC, `Delete of the caller's own config MUST succeed (got ${JSON.stringify(del.error)})`)).toBeUndefined();
+      await rpc(g.url, 'SendMessage', { message: acceptMessage(taskId) });
+      await settle(taskId, (s) => s !== undefined && TERMINAL.has(s));
+      const arrived = await until(() => kept.hits.length > 0, 20000);
+      if (!arrived && absenceIsUnmeasured(kept.rx)) return softSkip('blocked', noDeliveryCause(kept.rx, 'A2A push'));
+      expect(kept.hits.length, req(id, DOC, `positive control: the config that was NOT deleted MUST still receive the push — ${noDeliveryCause(kept.rx, 'A2A push')}`)).toBeGreaterThan(0);
+      await wait(3000);
+      expect(dropped.hits.length, req(id, `${DOC} §A ("dropped when the config is deleted")`, 'a deleted config MUST receive nothing further — its destination credential is discarded with it')).toBe(0);
+    } finally { await kept.rx.close(); await dropped.rx.close(); }
+  }, 60_000);
+
+  it('§D — a replay fork of a pushed run delivers nothing to the source run\'s destination', async () => {
+    const id = R('a2a-push-fork-no-push');
+    const g = await gate();
+    if (!g.ok) return softSkip(g.kind, g.reason);
+    const replay = await familyAdvertised('replay');
+    const modes = Array.isArray(replay?.['modes']) ? (replay!['modes'] as unknown[]) : [];
+    if (!modes.includes('replay')) return softSkip('inapplicable', 'replay (mode replay) is not advertised — no fork to measure');
+    const { rx, hits } = await receiver();
+    try {
+      const taskId = await suspendedTask(g.url, id);
+      const created = await create(g.url, taskId, rx.url, { authentication: { scheme: 'Bearer', credentials: `owfork${randomBytes(10).toString('hex')}` } });
+      const why = unmeasurable(rx, created);
+      if (why !== null) { await rpc(g.url, 'CancelTask', { id: taskId }); return softSkip('blocked', why); }
+      await rpc(g.url, 'SendMessage', { message: acceptMessage(taskId) });
+      await settle(taskId, (s) => s !== undefined && TERMINAL.has(s));
+      const arrived = await until(() => hits.length > 0, 20000);
+      if (!arrived && absenceIsUnmeasured(rx)) return softSkip('blocked', noDeliveryCause(rx, 'A2A push'));
+      expect(hits.length, req(id, DOC, `positive control: the source run MUST have pushed before the fork — ${noDeliveryCause(rx, 'A2A push')}`)).toBeGreaterThan(0);
+      await wait(3000);
+      const before = hits.length;
+      const fork = await driver.post(`/runs/${encodeURIComponent(taskId)}:fork`, { mode: 'replay' });
+      if (fork.status < 200 || fork.status >= 300) return softSkip('blocked', `replay is advertised but forkRun answered ${fork.status} ${JSON.stringify(fork.json)} — the fork leg is unmeasured`);
+      const child = (fork.json as { runId?: string } | undefined)?.runId;
+      if (typeof child === 'string') await settle(child, (s) => s !== undefined && TERMINAL.has(s), 15000);
+      await wait(4000);
+      expect(hits.length, req(id, `${DOC} §D; replay.md §Suppression ("MUST NOT deliver events a replay re-emits")`, `a replay fork MUST NOT push to the source run's destination (deliveries ${before} before the fork, ${hits.length} after)`)).toBe(before);
+    } finally { await rx.close(); }
+  }, 90_000);
+});

package/src/scenarios/v2-a2ui-v09-surface.test.ts

@@ -44,6 +44,7 @@ const CATALOG = 'https://a2ui.org/specification/v0_9/catalogs/basic/catalog.json
 const clone = <T>(o: T): T => JSON.parse(JSON.stringify(o)) as T;
 const POSITIVE = JSON.parse(readFileSync(join(FIXTURES_DIR, 'a2ui-v09', 'positive-approve-brief.json'), 'utf8')) as Json;
 const V1_SURFACE: Json = { catalogVersion: '0.9.1', surface: { title: 'Kickoff', components: [{ component: 'heading', text: 'Kickoff', level: 2 }, { component: 'action.button', id: 'go', label: 'Go', action: { target: 'resume' } }] } };
+const V1_LATER: Json = { catalogVersion: '0.9.1', surface: { title: 'Kickoff, later', components: [{ component: 'heading', text: 'Kickoff, later', level: 2 }] } };
 
 let seq = 0;
 const nonce = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
@@ -217,8 +218,16 @@ describe('RFC 0209 §C.11 — recorded surfaces are returned as recorded (seam-g
       const sequence = (r.json as { sequence: number }).sequence;
       const events = await eventsOf(runId);
       expect(carries(events, payload), req('openwop.it.v2-a2ui-v09-surface.recorded-as-recorded', 'RFC 0209 §C.11', 'the run\'s poll MUST return the recorded surface payload byte-equal — no surface is regenerated')).toBe(true);
-      const fork = await driver.post(`/runs/${encodeURIComponent(runId)}:fork`, { mode: 'replay', fromSeq: sequence + 1 });
-      expect(fork.status, req('openwop.it.v2-a2ui-v09-surface.recorded-as-recorded', 'RFC 0209 §C.11', `POST :fork at fromSeq ${sequence + 1} MUST answer 201, got ${code(fork)}`)).toBe(201);
+      // The surface is the last event of the suspended run, so `sequence + 1`
+      // names no event and runs.md §Fork REQUIRES 422 fork_point_invalid for it.
+      // Record one more envelope on the same surface and fork AT that event:
+      // the surface (sequence < fromSeq) is fixed history, the later one re-executes.
+      const later = await emit(runId, envelope(2, v2(sid('rec'), [dataMsg()])));
+      expect(later.status, req('openwop.it.v2-a2ui-v09-surface.recorded-as-recorded', 'RFC 0209 §C.9', `an updateDataModel on the live surface MUST be admitted (it supplies the fork point), got ${code(later)}`)).toBe(201);
+      const fromSeq = (later.json as { sequence: number }).sequence;
+      expect(fromSeq > sequence, req('openwop.it.v2-a2ui-v09-surface.recorded-as-recorded', 'api/seams-v2.yaml emitA2uiSurface', `a later recording names a later sequence (surface ${sequence}, update ${fromSeq})`)).toBe(true);
+      const fork = await driver.post(`/runs/${encodeURIComponent(runId)}:fork`, { mode: 'replay', fromSeq });
+      expect(fork.status, req('openwop.it.v2-a2ui-v09-surface.recorded-as-recorded', 'RFC 0209 §C.11', `POST :fork at fromSeq ${fromSeq} (a recorded event after the surface) MUST answer 201, got ${code(fork)}`)).toBe(201);
       const forkId = (fork.json as { runId: string }).runId;
       expect(carries(await eventsOf(forkId), payload), req('openwop.it.v2-a2ui-v09-surface.recorded-as-recorded', 'RFC 0209 §C.11', 'a fork at a fromSeq after the surface MUST carry it unchanged')).toBe(true);
       await done(forkId);
@@ -234,8 +243,13 @@ describe('RFC 0209 §C.11 — recorded surfaces are returned as recorded (seam-g
       expect(r.status, req('openwop.requirement.0209.legacy-readable', 'RFC 0209 §C.11', `a version-1 surface at floor 1 MUST be admitted, got ${code(r)}`)).toBe(201);
       const sequence = (r.json as { sequence: number }).sequence;
       expect(carries(await eventsOf(runId), V1_SURFACE), req('openwop.requirement.0209.legacy-readable', 'RFC 0209 §C.11', 'the poll MUST return the version-1 surface byte-equal')).toBe(true);
-      const fork = await driver.post(`/runs/${encodeURIComponent(runId)}:fork`, { mode: 'replay', fromSeq: sequence + 1 });
-      expect(fork.status, req('openwop.requirement.0209.legacy-readable', 'RFC 0209 §C.11', `POST :fork MUST answer 201, got ${code(fork)}`)).toBe(201);
+      // As in the version-2 leg: fork at a recorded event after the surface, never at `sequence + 1` (no such event; 422 fork_point_invalid).
+      const later = await emit(runId, envelope(1, V1_LATER));
+      expect(later.status, req('openwop.requirement.0209.legacy-readable', 'RFC 0209 §C.11', `a second version-1 surface at floor 1 MUST be admitted (it supplies the fork point), got ${code(later)}`)).toBe(201);
+      const fromSeq = (later.json as { sequence: number }).sequence;
+      expect(fromSeq > sequence, req('openwop.requirement.0209.legacy-readable', 'api/seams-v2.yaml emitA2uiSurface', `a later recording names a later sequence (surface ${sequence}, next ${fromSeq})`)).toBe(true);
+      const fork = await driver.post(`/runs/${encodeURIComponent(runId)}:fork`, { mode: 'replay', fromSeq });
+      expect(fork.status, req('openwop.requirement.0209.legacy-readable', 'RFC 0209 §C.11', `POST :fork at fromSeq ${fromSeq} (a recorded event after the surface) MUST answer 201, got ${code(fork)}`)).toBe(201);
       const forkId = (fork.json as { runId: string }).runId;
       expect(carries(await eventsOf(forkId), V1_SURFACE), req('openwop.requirement.0209.legacy-readable', 'RFC 0209 §C.11', 'a fork at a later fromSeq MUST carry the version-1 surface unchanged')).toBe(true);
       await done(forkId);

package/src/scenarios/v2-content-locale-keys.test.ts

@@ -21,6 +21,11 @@
  * `Content-Language` names the tag (case-insensitively, RFC 5646 §2.1.1) and
  * the section carries the overlay.
  *
+ * Gate: the family is advertised by the PRESENCE of its record
+ * (`familyAdvertised`, RFC 0169 §A.2) — never by a `supported` flag, which the
+ * closed v2 `content` record cannot carry. `v2-family-gate-no-supported.test.ts`
+ * (a suite self-test) keeps that gate from coming back.
+ *
  * Sabotage: a host that 400s the extended-tag write, or that serves only the
  * base locale for it, fails the leg (write status / `Content-Language` /
  * overlay assertion respectively).
@@ -52,7 +57,11 @@ describe('v2-content-locale-keys (RFC 0206)', () => {
     const doc = await v2Discovery().catch(() => null);
     if (doc === null) return softSkip('blocked', 'v2 discovery unreachable');
     const content = await familyAdvertised('content');
-    if (content === null || content['supported'] !== true) return softSkip('inapplicable', 'the host does not advertise the content family (no content surface to deliver an extended locale from)');
+    // RFC 0169 §A.2: at major 2 the record's presence IS the claim. The v2
+    // `content` record is closed and has no `supported` field, so a gate on
+    // `supported === true` recorded `inapplicable` on every conforming host and
+    // this row could never execute (corrected 2026-09-24).
+    if (content === null) return softSkip('inapplicable', 'the host does not advertise the content family (no content surface to deliver an extended locale from)');
     const base = typeof content['baseLocale'] === 'string' ? content['baseLocale'] : null;
     const supported = Array.isArray(content['supportedLocales']) ? content['supportedLocales'].filter((x): x is string => typeof x === 'string') : [];
     const keyRe = new RegExp(LOCALE_KEY_PATTERN);

package/src/scenarios/v2-mrtr-rounds-ceiling.test.ts

@@ -85,7 +85,13 @@ describe('RFC 0175 §E.1 — mrtr-rounds-ceiling (gated on mcp + mrtr)', () => {
     if (!loopKnown) {
       return softSkip('blocked', `the suite MCP fake server cannot loop — its only MRTR tool (needs_input) completes on the first retry; a \`${LOOP_TOOL}\` fixture tool that re-issues input_required ${rounds} times is required to drive maxRounds + 1`);
     }
-    expect(res.status, req('openwop.requirement.0175.mrtr-rounds-ceiling.refused', 'interop.md §The MCP round ceiling', `round ${rounds} (maxRounds + 1) MUST be refused with 422`)).toBe(422);
+    // The failure message carries the host's code, the fake's count and the
+    // body (2.38.0). The 2026-09-24 public v2-reference cut on 2.37.1 recorded
+    // `expected 400 to be 422` and nothing else — the same leg passes on every
+    // loopback run of that host — so whether the 400 was the host refusing a
+    // round the fake answered, or a round the tunnel failed to carry, could not
+    // be read from the record.
+    expect(res.status, req('openwop.requirement.0175.mrtr-rounds-ceiling.refused', 'interop.md §The MCP round ceiling', `round ${rounds} (maxRounds + 1) MUST be refused with 422 (got ${res.status} ${String(readErrorCode(res.json))}; the fake served ${served.length} tools/call; body ${res.text.slice(0, 400)})`)).toBe(422);
     expect(readErrorCode(res.json), req('openwop.requirement.0175.mrtr-rounds-ceiling.refused', 'errors.json mcp_mrtr_rounds_exceeded', `the refusal MUST carry ${CODE}`)).toBe(CODE);
     expect(
       served.length,

package/src/scenarios/v2-oauth-client-pkce-state-iss.test.ts

@@ -118,7 +118,13 @@ describe('RFC 0199 §A — v2-oauth-client-pkce-state-iss (host as OAuth client,
     n = d.codeExchanges().length;
     const replay = await userAgentGet(cbA!, key);
     expect([replay.status >= 400, d.codeExchanges().length], req(id, `${DOC} rule 2`, `a replayed (already consumed) state MUST be refused with no token request (got ${replay.status})`)).toEqual([true, n]);
-  });
+    // 120 s, not the 30 s default (2.38.0): this leg makes eight sequential
+    // round trips — two grants, two consents, four callbacks — and on a public
+    // cut every one crosses the operator's tunnel to the AS double. The
+    // 2026-09-24 public v2-reference cut on 2.37.1 timed out here at 30 s while
+    // the sibling legs (pkce-s256, iss-validated, same-user-callback), which
+    // make fewer trips, passed. No assertion or window inside the leg changes.
+  }, 120_000);
 
   it('a callback authenticated as another Subject makes no token request and stores nothing', async () => {
     const r = await ready();

package/vectors/jcs-v1.json

@@ -0,0 +1,294 @@
+{
+  "$comment": [
+    "RFC 0212 — cross-language vectors for canonical JSON (RFC 8785 JCS) with the OpenWOP I-JSON refusal set.",
+    "Every signed or hashed preimage in the corpus MUST reproduce `canonical` and `sha256` for each `objects` entry, `canonical` for each `numbers` entry, and MUST refuse each `refusals` entry with a refusal (the `refuse` kind is informative).",
+    "Generated by a reference implementation that parses JSON TEXT (so duplicates, integer magnitude and lone surrogates are visible before coercion) and cross-checked against RFC 8785 Appendix B and §3.2.2/§3.2.3."
+  ],
+  "spec": "RFC 8785; RFC 7493 (I-JSON); RFC 0212",
+  "hash": "sha256, lowercase hex, over the UTF-8 bytes of `canonical`",
+  "numbers": [
+    {
+      "ieee754": "0000000000000000",
+      "canonical": "0"
+    },
+    {
+      "ieee754": "8000000000000000",
+      "canonical": "0"
+    },
+    {
+      "ieee754": "0000000000000001",
+      "canonical": "5e-324"
+    },
+    {
+      "ieee754": "8000000000000001",
+      "canonical": "-5e-324"
+    },
+    {
+      "ieee754": "7fefffffffffffff",
+      "canonical": "1.7976931348623157e+308"
+    },
+    {
+      "ieee754": "ffefffffffffffff",
+      "canonical": "-1.7976931348623157e+308"
+    },
+    {
+      "ieee754": "4340000000000000",
+      "canonical": "9007199254740992"
+    },
+    {
+      "ieee754": "c340000000000000",
+      "canonical": "-9007199254740992"
+    },
+    {
+      "ieee754": "4430000000000000",
+      "canonical": "295147905179352830000"
+    },
+    {
+      "ieee754": "44b52d02c7e14af5",
+      "canonical": "9.999999999999997e+22"
+    },
+    {
+      "ieee754": "44b52d02c7e14af6",
+      "canonical": "1e+23"
+    },
+    {
+      "ieee754": "44b52d02c7e14af7",
+      "canonical": "1.0000000000000001e+23"
+    },
+    {
+      "ieee754": "444b1ae4d6e2ef4e",
+      "canonical": "999999999999999700000"
+    },
+    {
+      "ieee754": "444b1ae4d6e2ef4f",
+      "canonical": "999999999999999900000"
+    },
+    {
+      "ieee754": "444b1ae4d6e2ef50",
+      "canonical": "1e+21"
+    },
+    {
+      "ieee754": "3eb0c6f7a0b5ed8c",
+      "canonical": "9.999999999999997e-7"
+    },
+    {
+      "ieee754": "3eb0c6f7a0b5ed8d",
+      "canonical": "0.000001"
+    },
+    {
+      "ieee754": "41b3de4355555553",
+      "canonical": "333333333.3333332"
+    },
+    {
+      "ieee754": "41b3de4355555554",
+      "canonical": "333333333.33333325"
+    },
+    {
+      "ieee754": "41b3de4355555555",
+      "canonical": "333333333.3333333"
+    },
+    {
+      "ieee754": "41b3de4355555556",
+      "canonical": "333333333.3333334"
+    },
+    {
+      "ieee754": "41b3de4355555557",
+      "canonical": "333333333.33333343"
+    },
+    {
+      "ieee754": "becbf647612f3696",
+      "canonical": "-0.0000033333333333333333"
+    },
+    {
+      "ieee754": "43143ff3c1cb0959",
+      "canonical": "1424953923781206.2"
+    }
+  ],
+  "numberRefusals": [
+    {
+      "ieee754": "7fffffffffffffff",
+      "refuse": "non-finite"
+    },
+    {
+      "ieee754": "7ff0000000000000",
+      "refuse": "non-finite"
+    }
+  ],
+  "objects": [
+    {
+      "id": "rfc8785-3.2.2",
+      "why": "RFC 8785 §3.2.2 worked example: number shortest-round-trip, string escapes, member sort.",
+      "input": "{\"numbers\": [333333333.33333329, 1E30, 4.50, 2e-3, 0.000000000000000000000000001], \"string\": \"\\u20ac$\\u000F\\u000aA'\\u0042\\u0022\\u005c\\\\\\\"\\/\", \"literals\": [null, true, false]}",
+      "canonical": "{\"literals\":[null,true,false],\"numbers\":[333333333.3333333,1e+30,4.5,0.002,1e-27],\"string\":\"€$\\u000f\\nA'B\\\"\\\\\\\\\\\"/\"}",
+      "sha256": "2d5e01a318d0f0879ab568c4be289c8b1f64ef8921a53c6277d5e069978baacb"
+    },
+    {
+      "id": "rfc8785-3.2.3-sort",
+      "why": "RFC 8785 §3.2.3: members sorted by UTF-16 code units — CR, \"1\", U+0080, ö, €, 😀 (surrogate pair D83D), דּ (FB33). Locale collation gives a different order.",
+      "input": "{\"€\":\"Euro Sign\",\"\\r\":\"Carriage Return\",\"דּ\":\"Hebrew Letter Dalet With Dagesh\",\"1\":\"One\",\"😀\":\"Emoji: Grinning Face\",\"\\u0080\":\"Control\",\"ö\":\"Latin Small Letter O With Diaeresis\"}",
+      "canonical": "{\"\\r\":\"Carriage Return\",\"1\":\"One\",\"€\":\"Control\",\"ö\":\"Latin Small Letter O With Diaeresis\",\"€\":\"Euro Sign\",\"😀\":\"Emoji: Grinning Face\",\"דּ\":\"Hebrew Letter Dalet With Dagesh\"}",
+      "sha256": "5e321556d22018a9656991a9e94f77ec175fa193e52a2429d312f8419ec8b08c"
+    },
+    {
+      "id": "integer-like-keys",
+      "why": "Keys \"10\" and \"9\" sort by code unit (\"1\" < \"9\"). A canonicalizer that rebuilds a JS object and calls JSON.stringify emits {\"9\":…,\"10\":…} — the sabotage this vector exists for.",
+      "input": "{\"9\":\"nine\",\"10\":\"ten\",\"a\":0}",
+      "canonical": "{\"10\":\"ten\",\"9\":\"nine\",\"a\":0}",
+      "sha256": "ac5e0767681af2d226a2a4df567cee9cd3254a7819a7643f8bddbfa690792dad"
+    },
+    {
+      "id": "nested-sort",
+      "why": "Sorting applies at every level; arrays keep their order.",
+      "input": "{\"b\":[{\"z\":1,\"a\":2},{\"y\":[3,1,2]}],\"a\":{\"d\":null,\"c\":true}}",
+      "canonical": "{\"a\":{\"c\":true,\"d\":null},\"b\":[{\"a\":2,\"z\":1},{\"y\":[3,1,2]}]}",
+      "sha256": "fc8d1753fb837b89a49b6335715adb82c262e9a6bbfe7f4e7b8993e297951cca"
+    },
+    {
+      "id": "control-escapes",
+      "why": "U+0000–U+001F: short forms for \\b \\t \\n \\f \\r, lowercase \\u00xx otherwise; U+007F and U+2028 are emitted raw; \"/\" is not escaped.",
+      "input": "{\"s\":\"\\u0000\\u0007\\b\\t\\n\\u000b\\f\\r\\u001f\\u007f
/\"}",
+      "canonical": "{\"s\":\"\\u0000\\u0007\\b\\t\\n\\u000b\\f\\r\\u001f
/\"}",
+      "sha256": "993e6efcefb9f0bc08a2f896edce693cd6e80aa50ed6337ae0921b06a656c1a3"
+    },
+    {
+      "id": "non-ascii-raw",
+      "why": "Non-ASCII is emitted as raw UTF-8, never \\u-escaped (em dash, as in 625 registry pack strings).",
+      "input": "{\"title\":\"a — b\",\"emoji\":\"😀\"}",
+      "canonical": "{\"emoji\":\"😀\",\"title\":\"a — b\"}",
+      "sha256": "d2a26872e24a775a770515e000f1bb85a0949c08b40621292b7e70037006d02d"
+    },
+    {
+      "id": "nfc-composed",
+      "why": "U+00E9 (composed). MUST NOT hash equal to the decomposed vector: JCS applies no Unicode normalization.",
+      "input": "{\"name\":\"café\"}",
+      "canonical": "{\"name\":\"café\"}",
+      "sha256": "645fa443126a8954fc6d871912b8fc67bc2ee8feae417efe55546251962ca74d"
+    },
+    {
+      "id": "nfd-decomposed",
+      "why": "U+0065 U+0301 (decomposed). Pair with nfc-composed.",
+      "input": "{\"name\":\"café\"}",
+      "canonical": "{\"name\":\"café\"}",
+      "sha256": "4b7186ff40a64bfae3cb4bd75ac13b0de5ee693190f20812aaff208a77560ca7"
+    },
+    {
+      "id": "numbers-in-document",
+      "why": "Numbers inside a document: -0 → 0, 1.0 → 1, 1e21 → 1e+21, 1e-7 → 1e-7, 0.1+0.2 shortest form, 2^53−1 accepted.",
+      "input": "{\"n\":[-0,1.0,1e21,1e-7,0.30000000000000004,9007199254740991,-9007199254740991]}",
+      "canonical": "{\"n\":[0,1,1e+21,1e-7,0.30000000000000004,9007199254740991,-9007199254740991]}",
+      "sha256": "430e3fefe48227fd5ed7df3ba8b5a6da008c2077858a44bd265d4c7812c498c1"
+    },
+    {
+      "id": "empty-containers",
+      "why": "Empty object and array.",
+      "input": "{\"a\":{},\"b\":[]}",
+      "canonical": "{\"a\":{},\"b\":[]}",
+      "sha256": "aeeba1e56a144077f89e26c930dad7cf933e9383cfb8e33ddff618233b29be76"
+    }
+  ],
+  "refusals": [
+    {
+      "id": "duplicate-name",
+      "why": "I-JSON §2.3: duplicate member names.",
+      "input": "{\"a\":1,\"a\":2}",
+      "refuse": "duplicate-name"
+    },
+    {
+      "id": "lone-high-surrogate",
+      "why": "I-JSON §2.1: a lone surrogate is not a Unicode scalar value.",
+      "input": "{\"s\":\"\\ud800\"}",
+      "refuse": "lone-surrogate"
+    },
+    {
+      "id": "lone-low-surrogate",
+      "why": "I-JSON §2.1.",
+      "input": "{\"s\":\"x\\udc00\"}",
+      "refuse": "lone-surrogate"
+    },
+    {
+      "id": "integer-above-range",
+      "why": "Integer literal 2^53+1 exceeds ±(2^53−1) (I-JSON §2.2); a double cannot hold it exactly and a Python verifier would keep it exact — the two canonical forms differ.",
+      "input": "{\"n\":9007199254740993}",
+      "refuse": "integer-out-of-range"
+    },
+    {
+      "id": "integer-below-range",
+      "why": "Integer literal −2^53.",
+      "input": "{\"n\":-9007199254740992}",
+      "refuse": "integer-out-of-range"
+    },
+    {
+      "id": "nan-token",
+      "why": "NaN is not JSON. A JS canonicalizer given an in-memory NaN MUST refuse, not emit null.",
+      "input": "{\"n\":NaN}",
+      "refuse": "not-json"
+    },
+    {
+      "id": "infinity-overflow",
+      "why": "1e400 parses to Infinity: non-finite.",
+      "input": "{\"n\":1e400}",
+      "refuse": "non-finite"
+    }
+  ],
+  "ordering": {
+    "why": "witnessSha256 rows[] and RFC 0150 tools[] sort by UTF-16 code units of the key. Locale collation disagrees in both listed locales; a verifier using either computes a different digest.",
+    "ids": [
+      "d",
+      "h",
+      "ch",
+      "i",
+      "chain-pin-exact",
+      "h2",
+      "get_weather",
+      "getWeather",
+      "A",
+      "a",
+      "a-b",
+      "ab"
+    ],
+    "codeUnit": [
+      "A",
+      "a",
+      "a-b",
+      "ab",
+      "ch",
+      "chain-pin-exact",
+      "d",
+      "getWeather",
+      "get_weather",
+      "h",
+      "h2",
+      "i"
+    ],
+    "localeCs": [
+      "a",
+      "A",
+      "a-b",
+      "ab",
+      "d",
+      "get_weather",
+      "getWeather",
+      "h",
+      "h2",
+      "ch",
+      "chain-pin-exact",
+      "i"
+    ],
+    "localeEn": [
+      "a",
+      "A",
+      "a-b",
+      "ab",
+      "ch",
+      "chain-pin-exact",
+      "d",
+      "get_weather",
+      "getWeather",
+      "h",
+      "h2",
+      "i"
+    ],
+    "differsFromCs": true,
+    "differsFromEn": true
+  }
+}