@openwop/openwop-conformance 2.42.6 → 2.42.8

package/src/scenarios/v2-client-version-header.test.ts

@@ -0,0 +1,124 @@
+/**
+ * v2 — `OpenWOP-Client-Version` (suite 2.42.8; RFC 0219;
+ * `spec/v2/core/versioning.md` §1.5 "Client precedence and minClientVersion").
+ *
+ * A client announces the protocol version it implements in
+ * `OpenWOP-Client-Version: <major>.<minor>[.<patch>]`. A host that advertises
+ * `minClientVersion` MAY refuse a client below it with `426
+ * client_version_unsupported`, and MUST NOT refuse anything else on version
+ * grounds. Every leg probes `GET /.well-known/openwop` under
+ * `OpenWOP-Version: 2.0` (the discovery document is not exempt from refusal).
+ *
+ *   floor-comparison     (gated on minClientVersion) `<floor>`, `<floor>.0` and
+ *                        `<floor>.99` are served: equal on major.minor is not
+ *                        below, and the patch never decides.
+ *   malformed-not-refused (gated on a host that refuses `0.0.1` with 426) the
+ *                        malformed values `not-a-version`, `1`, `01.0` and
+ *                        `1.0-rc.1` are treated as absent and served — never
+ *                        426, never 400. A host that serves `0.0.1` does not
+ *                        exercise the refusal, so a served malformed value
+ *                        proves nothing there: `inapplicable`.
+ *   absent-not-refused   a header-less request is never 426 (every host); on a
+ *                        host that refuses `0.0.1` with 426, it is also served.
+ *   no-floor-no-refusal  (hosts advertising NO minClientVersion) `0.0.1` is
+ *                        served, not 426. None of today's certified hosts is in
+ *                        this state, so it records `inapplicable` on each.
+ *
+ * Unwitnessed and recorded in RFC 0219's falsifiability table: a host choosing
+ * a major or a representation from the header, and the header used as an
+ * authentication or authorization input.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { v2Discovery } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+const DOC = 'spec/v2/core/versioning.md §1.5';
+const PATH = '/.well-known/openwop';
+const FLOOR = /^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)$/;
+/** Below any floor a host can advertise except `0.0`, which nothing is below. */
+const BELOW = '0.0.1';
+const MALFORMED = ['not-a-version', '1', '01.0', '1.0-rc.1'] as const;
+
+async function discovery(): Promise<Record<string, unknown> | null> {
+  try { return await v2Discovery(); } catch { return null; }
+}
+async function probe(clientVersion: string | null): Promise<OpenWOPResponse | null> {
+  const headers: Record<string, string> = { 'OpenWOP-Version': '2.0' };
+  if (clientVersion !== null) headers['OpenWOP-Client-Version'] = clientVersion;
+  try { return await driver.get(PATH, { authenticated: false, headers }); } catch { return null; }
+}
+const served = (r: OpenWOPResponse): boolean => r.status >= 200 && r.status < 300;
+
+/** The advertised floor, or a skip reason. */
+async function advertisedFloor(): Promise<{ floor: string } | { skip: [kind: 'blocked' | 'inapplicable', reason: string] }> {
+  const doc = await discovery();
+  if (!doc) return { skip: ['blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 with a JSON body under OpenWOP-Version: 2.0'] };
+  const floor = doc['minClientVersion'];
+  if (floor === undefined) return { skip: ['inapplicable', 'the host does not advertise minClientVersion — the floor legs are gated on a host that sets it'] };
+  // The floor's own grammar is v2-min-client-version's row; a floor this leg cannot read compares nothing.
+  if (typeof floor !== 'string' || !FLOOR.test(floor)) return { skip: ['inapplicable', `minClientVersion ${JSON.stringify(floor)} is not <major>.<minor> — judged by v2-min-client-version, nothing to compare here`] };
+  if (floor === '0.0') return { skip: ['inapplicable', 'minClientVersion is 0.0 — no well-formed client version is below it, so no refusal can be provoked'] };
+  return { floor };
+}
+
+/** Gate for the legs that need a host which actually refuses a below-floor client. */
+async function refusingHost(): Promise<{ floor: string } | { skip: [kind: 'blocked' | 'inapplicable', reason: string] }> {
+  const f = await advertisedFloor();
+  if ('skip' in f) return f;
+  const control = await probe(BELOW);
+  if (control === null) return { skip: ['blocked', `GET ${PATH} with OpenWOP-Client-Version: ${BELOW} unreachable (fetch failed)`] };
+  if (served(control)) return { skip: ['inapplicable', `the host advertises minClientVersion ${f.floor} but served a client announcing ${BELOW} (${control.status}) — refusal is a MAY; a served header-less or malformed request distinguishes nothing on a host that refuses nobody`] };
+  if (control.status !== 426) return { skip: ['blocked', `the control (${BELOW}, below minClientVersion ${f.floor}) answered ${control.status} — neither served nor 426; v2-min-client-version records that as a failure, and this leg has no refusal to compare against`] };
+  return f;
+}
+
+describe('v2 OpenWOP-Client-Version (RFC 0219 — versioning.md §1.5)', () => {
+  it('a client at the floor is not below it: equal on major.minor, the patch never decides', async () => {
+    const f = await advertisedFloor();
+    if ('skip' in f) return softSkip(...f.skip);
+    for (const v of [f.floor, `${f.floor}.0`, `${f.floor}.99`]) {
+      const res = await probe(v);
+      if (res === null) return softSkip('blocked', `GET ${PATH} with OpenWOP-Client-Version: ${v} unreachable (fetch failed)`);
+      expect(res.status, req('openwop.requirement.0219.floor-comparison', DOC, `a client announcing ${v} is not below minClientVersion ${f.floor} (major and minor compared as integers; the patch never decides) and MUST be served, not refused (got ${res.status})`)).not.toBe(426);
+      expect(served(res), req('openwop.requirement.0219.floor-comparison', DOC, `a well-formed OpenWOP-Client-Version at the floor MUST NOT make the request fail — ${v} got ${res.status}`)).toBe(true);
+    }
+  });
+
+  it('a malformed OpenWOP-Client-Version is treated as absent: never 426, never 400', async () => {
+    const f = await refusingHost();
+    if ('skip' in f) return softSkip(...f.skip);
+    for (const v of MALFORMED) {
+      const res = await probe(v);
+      if (res === null) return softSkip('blocked', `GET ${PATH} with OpenWOP-Client-Version: ${v} unreachable (fetch failed)`);
+      expect(res.status, req('openwop.requirement.0219.malformed-not-refused', DOC, `a value outside the grammar (${JSON.stringify(v)}) MUST be treated as absent, so it MUST NOT be refused 426 client_version_unsupported (floor ${f.floor})`)).not.toBe(426);
+      expect(res.status, req('openwop.requirement.0219.malformed-not-refused', DOC, `a value outside the grammar (${JSON.stringify(v)}) MUST NOT produce a 400`)).not.toBe(400);
+      expect(served(res), req('openwop.requirement.0219.malformed-not-refused', DOC, `a malformed value is treated as absent and a header-less request is served — ${JSON.stringify(v)} got ${res.status}`)).toBe(true);
+    }
+  });
+
+  it('a request without OpenWOP-Client-Version is served where a below-floor one is refused', async () => {
+    // A 426 to a header-less request is a violation on ANY host, floor or not — probe it before the gate,
+    // because a host that refuses it also refuses the header-less discovery read the gate depends on.
+    const res = await probe(null);
+    if (res === null) return softSkip('blocked', `GET ${PATH} without OpenWOP-Client-Version unreachable (fetch failed)`);
+    expect(res.status, req('openwop.requirement.0219.absent-not-refused', DOC, 'a host MUST NOT answer 426 client_version_unsupported to a request that carries no OpenWOP-Client-Version')).not.toBe(426);
+    const f = await refusingHost();
+    // partial-witness-ok: the header-less request was not refused 426 (asserted above, binding on every host);
+    // that it is SERVED distinguishes something only on a host that refuses a below-floor client.
+    if ('skip' in f) return softSkip(...f.skip);
+    expect(served(res), req('openwop.requirement.0219.absent-not-refused', DOC, `a host MUST NOT refuse a request because it omits OpenWOP-Client-Version (got ${res.status})`)).toBe(true);
+  });
+
+  it('a host that advertises no minClientVersion refuses no client on version grounds', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 with a JSON body under OpenWOP-Version: 2.0');
+    if (doc['minClientVersion'] !== undefined) return softSkip('inapplicable', `the host advertises minClientVersion ${JSON.stringify(doc['minClientVersion'])} — this leg is for a host with no floor`);
+    const res = await probe(BELOW);
+    if (res === null) return softSkip('blocked', `GET ${PATH} with OpenWOP-Client-Version: ${BELOW} unreachable (fetch failed)`);
+    expect(res.status, req('openwop.requirement.0219.no-floor-no-refusal', DOC, `a host that advertises no minClientVersion MUST NOT answer 426 client_version_unsupported (a client announcing ${BELOW})`)).not.toBe(426);
+    expect(served(res), req('openwop.requirement.0219.no-floor-no-refusal', DOC, `a well-formed OpenWOP-Client-Version MUST NOT make the request fail on a host with no floor (got ${res.status})`)).toBe(true);
+  });
+});

package/src/scenarios/v2-effect-identity-business-key.test.ts

@@ -29,6 +29,15 @@ import { softSkip, blockedDespiteAssertions } from '../lib/soft-skip.js';
 import { startEffectReceiver } from '../lib/effect-receiver.js';
 import { req } from '../lib/requirement-ids.js';
 
+/**
+ * The retry leg hands the host the address of the suite's OWN receiver
+ * (`lib/effect-receiver.ts`, since 2.42.4) and the host calls it — a connection
+ * the host originates back to the harness. `host-callback-declaration` requires
+ * that to be declared; 2.42.4 added the receiver and not the declaration, so
+ * the self-check failed on every host that runs the full catalog.
+ */
+export const REQUIRES_HOST_CALLBACK = 'the host makes the retried outbound effect call to the suite-owned effect receiver (OPENWOP_WEBHOOK_RECEIVER_PORT)';
+
 const FIXTURE = 'conformance-noop';
 const KEYING = ['business-identity', 'activity-recipe'];
 const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
@@ -73,6 +82,9 @@ describe('RFC 0173 §B — effect-identity-business-key (gated on idempotency)',
     const body = res.json as { runId?: unknown; effects?: Array<{ effectId?: unknown; keying?: unknown; providerKey?: unknown }> } | null;
     const effects = body?.effects ?? [];
     if (res.status === 200 && check.ok && body?.runId === runId && effects.length === 0) {
+      // partial-witness-ok: no assertion has passed at runtime. The only earlier
+      // expect runs solely when the create is not 201, and then it throws, so this
+      // skip is a zero-assertion `inapplicable` (the gate reads source order).
       return softSkip('inapplicable', 'the noop fixture issued no external effect — the ledger read is well-formed but the per-row keying leg had no rows (an effect-issuing fixture would exercise it)');
     }
     expect(

package/src/scenarios/v2-ext-family-claims.test.ts

@@ -0,0 +1,62 @@
+/**
+ * v2-ext-family-claims — RFC 0220 §B, the `claims-check` witness for the 11
+ * discovery-only extension families (suite 2.42.7, target major 2).
+ *
+ * Each family is a reservation: v2 defines no portable operation for it, so the
+ * only thing a server-oriented suite can check is the claim itself. A host that
+ * advertises `extensions["<org>.<extensionName>"]` records `executed-pass` under
+ * `openwop.family.<key>` when the claim is well formed (lib/ext-claims.ts), and
+ * `executed-fail` when it is not. A host that does not advertise the family
+ * records `inapplicable`.
+ *
+ * Why not behaviorGate: an ext family is outside every profile
+ * (spec/v2/ext/README.md), so strict mode has nothing to demand here — a host
+ * that serves no `kanban` has made no promise about one. The gate is the claim.
+ *
+ * Every req() id is a literal so the requirement registry collects it. That a
+ * leg exists for every claims-check family in the declaration is a corpus fact,
+ * checked by the self-test in src/lib/ext-claims.test.ts, not by a host run.
+ *
+ * @see RFCS/0220-ext-families-graduate-on-evidence.md
+ * @see spec/v2/ext/README.md
+ * @see spec/v2/core/capabilities.md §3.2
+ */
+import { describe, it, expect } from 'vitest';
+import { v2Discovery } from '../lib/v2.js';
+import { extDeclaration, classifyExtClaim } from '../lib/ext-claims.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+const LEGS = ['brand', 'canvas', 'chat', 'coordination', 'dataIntegration', 'entities', 'kanban', 'knowledge', 'launchStudio', 'messaging', 'webResearch'] as const;
+
+async function leg(key: (typeof LEGS)[number], cite: (why: string) => string): Promise<undefined> {
+  const decl = extDeclaration();
+  if (!decl) return softSkip('blocked', 'spec/v2/declaration.json is not resolvable in this layout — the extension name and the org registry come from it, and guessing either would make the suite the registry (conformance.md §Whose fact is the reason?)');
+  const family = decl.families.find((f) => f.key === key);
+  if (!family) return softSkip('blocked', `the declaration has no ext row for ${key} — this leg is stale against the corpus`);
+  const doc = await v2Discovery();
+  if (!doc) return softSkip('blocked', 'v2 discovery unreachable');
+  const claims = classifyExtClaim(doc, family, decl);
+  if (claims.length === 1 && claims[0].state === 'absent') return softSkip('inapplicable', `no extensions["<org>.${family.extensionName}"] record under a registered org — the host does not advertise ${key}`);
+  for (const c of claims) {
+    if (c.state === 'absent') continue;
+    expect(c.state, cite(c.state === 'malformed' ? `extensions["${c.key}"]: ${c.why}` : `extensions["${c.key}"] is a well-formed claim`)).toBe('well-formed');
+  }
+  return undefined;
+}
+
+const S = (key: string): string => `spec/v2/ext/${key}/README.md §Conformance`;
+
+describe('RFC 0220 §B — an extension family is claimed in a well-formed extensions record (claims-check)', () => {
+  it('brand', () => leg('brand', (why) => req('openwop.family.brand', S('brand'), why)));
+  it('canvas', () => leg('canvas', (why) => req('openwop.family.canvas', S('canvas'), why)));
+  it('chat', () => leg('chat', (why) => req('openwop.family.chat', S('chat'), why)));
+  it('coordination', () => leg('coordination', (why) => req('openwop.family.coordination', S('coordination'), why)));
+  it('dataIntegration', () => leg('dataIntegration', (why) => req('openwop.family.dataIntegration', S('dataIntegration'), why)));
+  it('entities', () => leg('entities', (why) => req('openwop.family.entities', S('entities'), why)));
+  it('kanban', () => leg('kanban', (why) => req('openwop.family.kanban', S('kanban'), why)));
+  it('knowledge', () => leg('knowledge', (why) => req('openwop.family.knowledge', S('knowledge'), why)));
+  it('launchStudio', () => leg('launchStudio', (why) => req('openwop.family.launchStudio', S('launchStudio'), why)));
+  it('messaging', () => leg('messaging', (why) => req('openwop.family.messaging', S('messaging'), why)));
+  it('webResearch', () => leg('webResearch', (why) => req('openwop.family.webResearch', S('webResearch'), why)));
+});

package/src/scenarios/v2-ext-rest-transport.test.ts

@@ -0,0 +1,151 @@
+/**
+ * v2-ext-rest-transport — RFC 0220 §C, the behavioral witness for the
+ * `restTransport` extension family (suite 2.42.7, target major 2).
+ *
+ * Gate: the host advertises `extensions["<org>.rest-transport"]` under a
+ * registered org (spec/v2/ext/restTransport/README.md §The claim). Absent ⇒
+ * `inapplicable`. A malformed claim fails the claim leg; it does not skip.
+ *
+ * Legs, both recorded under `openwop.family.restTransport` so the family row is
+ * the least certifiable of them (requirement-ledger fold):
+ *
+ *   1. `conditionalRunGet: true` — the `conformance-approval` fixture parks at
+ *      `waiting-approval`, a stable state. The 200 carries a strong ETag, a
+ *      matching If-None-Match gets 304 with no body, and once the approval is
+ *      resolved and the run completes the ETag differs — a 304 across that
+ *      transition would be stale (runs.md §"Caching and encoding").
+ *   2. `contentEncodings` — for each advertised coding, the response carries
+ *      that `Content-Encoding` and decodes to the identity body byte for byte.
+ *
+ * A leg whose facet the record does not set records `inapplicable` for itself
+ * only: a host that claims one facet has promised nothing about the other.
+ *
+ * Ported from the v1 `run-transport-economy` scenario, which reads the v1 root
+ * key; this one reads the v2 extensions record.
+ *
+ * @see RFCS/0220-ext-families-graduate-on-evidence.md
+ * @see spec/v2/ext/restTransport/README.md
+ * @see spec/v2/core/runs.md §"Caching and encoding"
+ */
+import { describe, it, expect } from 'vitest';
+import { gunzipSync, brotliDecompressSync } from 'node:zlib';
+import * as zlib from 'node:zlib';
+import { driver } from '../lib/driver.js';
+import { loadEnv } from '../lib/env.js';
+import { v2Discovery } from '../lib/v2.js';
+import { extDeclaration, classifyExtClaim } from '../lib/ext-claims.js';
+import { pollUntilStatus, pollUntilTerminal } from '../lib/polling.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+type Json = Record<string, unknown>;
+type Encoding = 'gzip' | 'br' | 'zstd';
+const APPROVAL_FIXTURE = 'conformance-approval';
+const APPROVAL_NODE_ID = 'gate';
+const NOOP_FIXTURE = 'conformance-noop';
+const SECTION = 'spec/v2/ext/restTransport/README.md §What the claim adds';
+const R = (why: string): string => req('openwop.family.restTransport', SECTION, why);
+
+type Claim = { ok: true; record: Json; key: string } | { ok: false; kind: 'inapplicable' | 'blocked'; reason: string };
+
+/** The one well-formed rest-transport record, or why there is none. A malformed claim is asserted here, not skipped. */
+async function claim(): Promise<Claim> {
+  const decl = extDeclaration();
+  if (!decl) return { ok: false, kind: 'blocked', reason: 'spec/v2/declaration.json is not resolvable in this layout — the extension name and the org registry come from it' };
+  const family = decl.families.find((f) => f.key === 'restTransport');
+  if (!family) return { ok: false, kind: 'blocked', reason: 'the declaration has no ext row for restTransport — this scenario is stale against the corpus' };
+  const doc = await v2Discovery();
+  if (!doc) return { ok: false, kind: 'blocked', reason: 'v2 discovery unreachable' };
+  const claims = classifyExtClaim(doc, family, decl);
+  if (claims.length === 1 && claims[0].state === 'absent') return { ok: false, kind: 'inapplicable', reason: 'no extensions["<org>.rest-transport"] record under a registered org — the host does not advertise restTransport' };
+  for (const c of claims) {
+    if (c.state === 'malformed') expect(c.state, R(`extensions["${c.key}"]: ${c.why}`)).toBe('well-formed');
+  }
+  const first = claims.find((c) => c.state === 'well-formed');
+  if (!first || first.state !== 'well-formed') return { ok: false, kind: 'blocked', reason: 'no well-formed rest-transport claim' };
+  return { ok: true, record: ((doc['extensions'] as Json)[first.key] ?? {}) as Json, key: first.key };
+}
+
+function advertisedEncodings(record: Json): Encoding[] {
+  const raw = record['contentEncodings'];
+  return Array.isArray(raw) ? raw.filter((e): e is Encoding => e === 'gzip' || e === 'br' || e === 'zstd') : [];
+}
+
+describe('RFC 0220 §C — restTransport: conditional GET on the run snapshot', () => {
+  it('a strong ETag on the 200, 304 on a match while the run is parked, and a new ETag once it completes', async () => {
+    const c = await claim();
+    if (!c.ok) return softSkip(c.kind, c.reason);
+    if (c.record['conditionalRunGet'] !== true) return softSkip('inapplicable', `extensions["${c.key}"].conditionalRunGet is not true — the host claims no validator`);
+
+    const create = await driver.post('/runs', { workflowId: APPROVAL_FIXTURE });
+    // Any non-201 is the suite's precondition failing (fixture, credential), not the claim — the v2-a2ui gate's convention.
+    if (create.status !== 201) return softSkip('blocked', `POST /runs {workflowId: ${APPROVAL_FIXTURE}} answered ${create.status} — the run the leg needs could not be created`);
+    const runId = (create.json as { runId: string }).runId;
+    const path = `/runs/${encodeURIComponent(runId)}`;
+    await pollUntilStatus(runId, 'waiting-approval', { timeoutMs: 10_000 });
+
+    const parked = await driver.get(path);
+    expect(parked.status, R('the parked run reads 200')).toBe(200);
+    const etagParked = parked.headers.get('etag');
+    expect(etagParked, R('a host whose record sets conditionalRunGet: true MUST carry an ETag on every 200 of GET /runs/{runId}')).toBeTruthy();
+    expect(etagParked?.startsWith('W/'), R('the ETag MUST be strong')).toBe(false);
+
+    const revalidate = await driver.get(path, { headers: { 'If-None-Match': etagParked as string } });
+    expect(revalidate.status, R('a matching If-None-Match MUST receive 304 while the run has not advanced (runs.md §"Caching and encoding")')).toBe(304);
+    expect(revalidate.text, R('the 304 MUST carry no body')).toBe('');
+
+    const resolve = await driver.post(`${path}/interrupts/${encodeURIComponent(APPROVAL_NODE_ID)}`, { resumeValue: { action: 'accept' } });
+    expect(resolve.status, R('the approval resolves (control: the run must advance for the rotation check to mean anything)')).toBe(200);
+    const terminal = await pollUntilTerminal(runId, { timeoutMs: 10_000 });
+    expect(terminal.status, R('the run completes')).toBe('completed');
+
+    const done = await driver.get(path);
+    const etagDone = done.headers.get('etag');
+    expect(etagDone, R('the completed run still carries an ETag')).toBeTruthy();
+    expect(etagDone, R('the ETag MUST change once the run advances; the parked ETag would otherwise answer 304 for a changed run')).not.toBe(etagParked);
+    const stale = await driver.get(path, { headers: { 'If-None-Match': etagParked as string } });
+    expect(stale.status, R('the parked ETag MUST NOT match the completed run')).toBe(200);
+  });
+});
+
+describe('RFC 0220 §C — restTransport: each advertised coding round-trips', () => {
+  it('each coding in contentEncodings is produced when asked for alone and decodes to the identity body', async () => {
+    const c = await claim();
+    if (!c.ok) return softSkip(c.kind, c.reason);
+    const encodings = advertisedEncodings(c.record);
+    if (encodings.length === 0) return softSkip('inapplicable', `extensions["${c.key}"].contentEncodings lists no coding — the host claims none`);
+
+    const create = await driver.post('/runs', { workflowId: NOOP_FIXTURE });
+    // Any non-201 is the suite's precondition failing (fixture, credential), not the claim — the v2-a2ui gate's convention.
+    if (create.status !== 201) return softSkip('blocked', `POST /runs {workflowId: ${NOOP_FIXTURE}} answered ${create.status} — the run the leg needs could not be created`);
+    const runId = (create.json as { runId: string }).runId;
+    await pollUntilTerminal(runId, { timeoutMs: 10_000 });
+
+    // A raw fetch, not the driver: the driver decodes JSON, and the oracle here is bytes.
+    const env = loadEnv();
+    const url = `${env.baseUrl}/runs/${encodeURIComponent(runId)}`;
+    const base = { Authorization: `Bearer ${env.apiKey}`, Accept: 'application/json', 'OpenWOP-Version': '2.0' };
+    const identity = await fetch(url, { headers: { ...base, 'Accept-Encoding': 'identity' } });
+    expect(identity.status, R('the identity read is 200')).toBe(200);
+    const identityBytes = Buffer.from(await identity.arrayBuffer());
+    expect(identityBytes.length, R('the identity body is non-empty')).toBeGreaterThan(0);
+
+    const zstdMaybe: { zstdDecompressSync?: (b: Buffer) => Buffer } = zlib;
+    for (const enc of encodings) {
+      const res = await fetch(url, { headers: { ...base, 'Accept-Encoding': enc } });
+      expect(res.status, R(`the ${enc} read is 200`)).toBe(200);
+      expect(res.headers.get('content-encoding'), R(`a coding listed in contentEncodings MUST be produced when it is the only one asked for (${enc})`)).toBe(enc);
+      expect((res.headers.get('vary') ?? '').toLowerCase(), R('a compressed response MUST carry Vary: Accept-Encoding (runs.md §"Caching and encoding")')).toContain('accept-encoding');
+      const bytes = Buffer.from(await res.arrayBuffer());
+      // Node's fetch decodes gzip and br in transit, so equal bytes already prove the round trip.
+      const decode = enc === 'gzip' ? gunzipSync : enc === 'br' ? brotliDecompressSync : zstdMaybe.zstdDecompressSync;
+      // No zstd decoder in this Node: the coding was produced (asserted above); the byte compare needs a decoder the suite lacks.
+      if (!bytes.equals(identityBytes) && !decode) continue;
+      let decoded = bytes;
+      if (!bytes.equals(identityBytes) && decode) {
+        try { decoded = Buffer.from(decode(bytes)); } catch { /* not compressed bytes either: a real mismatch, compared below */ }
+      }
+      expect(decoded.equals(identityBytes), R(`the ${enc}-decoded body MUST be byte-identical to the identity body`)).toBe(true);
+    }
+  });
+});

package/src/scenarios/v2-id-grammar.test.ts

@@ -28,9 +28,11 @@ import { readErrorCode } from '../lib/error-envelope.js';
 import { softSkip } from '../lib/soft-skip.js';
 import { req } from '../lib/requirement-ids.js';
 import { BOUND_ID as RUN_ID } from '../lib/bound-id.js';
+import { scaledTimeoutMs } from '../lib/polling.js';
 
 const DOC = 'spec/v2/core/identity.md §5';
 const NOOP_WORKFLOW_ID = 'conformance-noop';
+const EVENTS_DEADLINE_MS = 20_000;
 const FOREIGN_RUN_ID = 'openwop-conformance-foreign-tenant/foreignopaque0123456789abcdef';
 
 async function discovery(): Promise<Record<string, unknown> | null> {
@@ -63,17 +65,27 @@ describe('v2 id-grammar (RFC 0170 §D.1)', () => {
   it('every id on the run events matches its ids.schema.json kind', async () => {
     const c = await createRun();
     if ('reason' in c) return softSkip('blocked', c.reason);
-    const res = await http(() => driver.get(`/runs/${encodeURIComponent(c.runId)}/events/poll?timeout=1`));
-    if (res === null || res.status !== 200) return softSkip('blocked', `GET /runs/{runId}/events/poll answered ${res?.status ?? 'no response'}`);
-    const events = (res.json as { events?: unknown } | undefined)?.events;
-    if (!Array.isArray(events) || events.length === 0) return softSkip('blocked', 'the poll returned no events for the run just created — nothing to check the eventId / runId / nodeId grammars against');
+    // Poll until the run has recorded an event. A single 1 s poll straight after
+    // the create raced the host's dispatch: a host that queues the run (Cloud
+    // Tasks on MyndHyve) can legitimately have no event yet, and `blocked` is
+    // bundle-fatal (2.42.8; MyndHyve cut 3 on 2.42.7). A host that records
+    // nothing for a noop run inside the scaled deadline is still `blocked`.
+    const deadline = Date.now() + scaledTimeoutMs(EVENTS_DEADLINE_MS);
+    let res: OpenWOPResponse | null = null;
+    let events: unknown;
+    do {
+      res = await http(() => driver.get(`/runs/${encodeURIComponent(c.runId)}/events/poll?timeout=5`));
+      if (res === null || res.status !== 200) return softSkip('blocked', `GET /runs/{runId}/events/poll answered ${res?.status ?? 'no response'}`);
+      events = (res.json as { events?: unknown } | undefined)?.events;
+    } while ((!Array.isArray(events) || events.length === 0) && Date.now() < deadline);
+    if (!Array.isArray(events) || events.length === 0) return softSkip('blocked', `the poll returned no events for the run just created within ${scaledTimeoutMs(EVENTS_DEADLINE_MS)} ms — nothing to check the eventId / runId / nodeId grammars against`);
     const validate = v2Validator('run-event');
     for (const ev of events) {
       const r = validate(ev);
       expect(r.ok, req('openwop.requirement.0170.id-grammar.events', DOC, `every RunEventDoc id (eventId, runId, nodeId, causationId) MUST match its kind — event ${String((ev as { eventId?: unknown }).eventId)} (${r.errors})`)).toBe(true);
       expect((ev as { runId?: unknown }).runId, req('openwop.requirement.0170.id-grammar.events', DOC, 'every event MUST carry the run\'s own runId')).toBe(c.runId);
     }
-  });
+  }, scaledTimeoutMs(EVENTS_DEADLINE_MS) + 15_000);
 
   it('a run id whose tenant segment is not the caller\'s is refused', async () => {
     if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 with a JSON body under OpenWOP-Version: 2.0');

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

@@ -147,6 +147,9 @@ describe('v2 idempotency-in-flight (idempotency.md Concurrency, RFC 0213 §B)',
     // (#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.)
+    // partial-witness-ok: the winner/replay clauses were asserted above; RFC 0213 §B lets every
+    // loser wait for a marked replay, so the 409 branch is an outcome this host did not take,
+    // not an unobserved obligation.
     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);
   // The deterministic §B witness (host-sample-test-seams.md §26): the seam only

package/src/scenarios/v2-legacy-profiles-absent.test.ts

@@ -41,11 +41,10 @@ describe('RFC 0175 §C.1 — legacy-profiles-absent (unaided)', () => {
   it('no -legacy id appears in a2a.profiles or mcp.profiles and each id matches its facet pattern', async () => {
     const doc = await discovery();
     if (!doc) return softSkip('blocked', 'discovery unreachable');
-    let checked = 0;
-    for (const family of ['a2a', 'mcp'] as const) {
-      const profiles = profilesOf(doc, family);
-      if (profiles === null) continue;
-      checked++;
+    const families = (['a2a', 'mcp'] as const).filter((family) => profilesOf(doc, family) !== null);
+    if (families.length === 0) return softSkip('inapplicable', 'host advertises neither a2a nor mcp — no profiles[] to check for a -legacy id');
+    for (const family of families) {
+      const profiles = profilesOf(doc, family)!;
       for (const id of profiles) {
         expect(
           /-legacy$/.test(id),
@@ -64,7 +63,6 @@ describe('RFC 0175 §C.1 — legacy-profiles-absent (unaided)', () => {
         req('openwop.requirement.0175.legacy-profiles-absent', `facets/${family}.schema.json`, `the ${family} facet MUST validate against its facet schema (capabilities.schema.json ${family}): ${check.errors}`),
       ).toBe(true);
     }
-    if (checked === 0) softSkip('inapplicable', 'host advertises neither a2a nor mcp — no profiles[] to check for a -legacy id');
   });
 
   it('no root profiles[] exists in the v2 representation', async () => {

package/src/scenarios/v2-mcp-tasks.test.ts

@@ -309,7 +309,7 @@ describe('RFC 0198 — v2-mcp-tasks (MCP Tasks on the server mount; disconnect c
     if (f.result?.['resultType'] === 'task') terminal = await pollTask(m.url, String(f.result['taskId']), (s) => ['completed', 'failed', 'cancelled'].includes(s), 10_000);
     else {
       // unfailable-leg audit wave 2, 2026-09-27: this branch returned
-      // softSkip('inapplicable') after the input_required asserts — a
+      // an inapplicable soft-skip after the input_required asserts — a
       // partial-witness PASS at both majors even when the synchronous answer
       // was NOT a tool-error outcome. The synchronous CallToolResult of a
       // failed run MUST still carry isError true; the task projection itself

package/src/scenarios/v2-min-client-version.test.ts

@@ -9,16 +9,19 @@
  * any advertised floor) is sent; when the host refuses, the refusal MUST be the
  * registered code at its registered status in the closed envelope; a host that
  * exercises the MAY by serving the request records `inapplicable` with that
- * reason. `OpenWOP-Client-Version` is the `OpenWOP-<Name>` header this
- * scenario uses to announce the client; it is not yet declared in
- * `api/v2/openapi.yaml` / `headers.md`.
+ * reason. `OpenWOP-Client-Version` is declared in `api/v2/openapi.yaml` /
+ * `headers.md` and specified in versioning.md §1.5 (RFC 0219), so a non-`2xx`,
+ * non-`426` answer to a well-formed below-floor value is a refusal in an
+ * unregistered form: a failure, not `blocked` (RFC 0219, Unresolved question 4,
+ * decided 2026-09-27). The header's other legs (at-floor, absent, malformed, no
+ * floor) are `v2-client-version-header`.
  */
 
 import { describe, it, expect } from 'vitest';
 import { driver, type OpenWOPResponse } from '../lib/driver.js';
 import { v2Discovery, v2Validator } from '../lib/v2.js';
 import { readErrorCode } from '../lib/error-envelope.js';
-import { blockedDespiteAssertions, softSkip } from '../lib/soft-skip.js';
+import { softSkip } from '../lib/soft-skip.js';
 import { req } from '../lib/requirement-ids.js';
 
 const DOC = 'spec/v2/core/versioning.md §1.5';
@@ -40,19 +43,22 @@ describe('v2 min-client-version (RFC 0172 §A.5 — gated on minClientVersion)',
     expect(typeof floor === 'string' && VERSION.test(floor), req('openwop.requirement.0172.min-client-version', DOC, 'minClientVersion MUST use the <major>.<minor> grammar (axis 15, as axis 1)')).toBe(true);
     const res = await http(() => driver.get('/.well-known/openwop', { authenticated: false, headers: { 'OpenWOP-Client-Version': '0.0.1' } }));
     if (res === null) return softSkip('blocked', 'GET /.well-known/openwop with OpenWOP-Client-Version unreachable (fetch failed)');
-    // unfailable-leg audit wave 2, 2026-09-27: every non-426 answer — including
-    // a 4xx/5xx that refused the client in an unregistered form — recorded
-    // `inapplicable` AFTER the grammar assert, i.e. a partial-witness PASS of
-    // the 426 refusal row. Only a SERVED request (2xx) is the MAY exercised; any
-    // other non-426 answer is `blocked`. Not asserted as a failure:
-    // `OpenWOP-Client-Version` is not yet declared in api/v2/openapi.yaml /
-    // headers.md, so a non-2xx here is not provably a version refusal.
-    if (res.status !== 426 && (res.status < 200 || res.status >= 300)) {
-      return blockedDespiteAssertions(`the host advertises minClientVersion ${String(floor)} and answered ${res.status} to a client announcing 0.0.1 — neither served (the MAY) nor refused with the registered 426 client_version_unsupported; the refusal form was not observed`);
-    }
+    // RFC 0219 Q4 (2026-09-27): the header is declared, so a host that answers a
+    // well-formed below-floor value with anything but 2xx (the MAY: served) or
+    // 426 client_version_unsupported refuses a declared header in an
+    // unregistered form. That is a failure. Before RFC 0219 it recorded `blocked`.
+    expect(res.status === 426 || (res.status >= 200 && res.status < 300), req('openwop.requirement.0172.min-client-version', DOC, `a client announcing 0.0.1 below minClientVersion ${String(floor)} MUST be served or refused with 426 client_version_unsupported — the host answered ${res.status}`)).toBe(true);
+    // partial-witness-ok: the minClientVersion grammar MUST was asserted above; refusing a
+    // below-floor client is a MAY and this host served it, so the 426 shape binds nothing.
     if (res.status !== 426) return softSkip('inapplicable', `the host advertises minClientVersion ${String(floor)} but served a client announcing 0.0.1 (${res.status}) — refusal is a MAY; nothing further is observable`);
     expect(readErrorCode(res.json), req('openwop.requirement.0172.min-client-version', DOC, 'a 426 refusal MUST carry client_version_unsupported')).toBe('client_version_unsupported');
     const r = v2Validator('error-envelope')(res.json);
     expect(r.ok, req('openwop.requirement.0172.min-client-version', 'spec/v2/core/errors.md §The envelope', `the refusal MUST be the closed error envelope (${r.errors})`)).toBe(true);
+    // RFC 0219 Q5: details.minClientVersion is OPTIONAL; when a host sends it, it names the floor
+    // (errors.json registers its grammar, which the envelope validator above already checked).
+    const details = (res.json as { details?: { minClientVersion?: unknown } } | null)?.details;
+    if (details && details.minClientVersion !== undefined) {
+      expect(details.minClientVersion, req('openwop.requirement.0172.min-client-version', DOC, `a refusal's details.minClientVersion MUST name the advertised floor ${String(floor)}`)).toBe(floor);
+    }
   });
 });

package/src/scenarios/v2-preferred-version-default.test.ts

@@ -8,7 +8,8 @@
  * served `preferredVersion`'s major, so a header-less `GET /.well-known/openwop`
  * is the `preferredVersion` representation and its `OpenWOP-Version` response
  * header names that major. The header-less fetch bypasses the driver (which
- * stamps `OpenWOP-Version: 2.0` under target major 2).
+ * stamps `OpenWOP-Version: 2.0` under target major 2). Any OTHER unversioned path
+ * is the v2 surface (§1.2), so a header-less request there is served major 2.
  */
 
 import { describe, it, expect } from 'vitest';
@@ -67,6 +68,23 @@ describe('v2 preferred-version-default (RFC 0172 §A.1, §A.3)', () => {
       expect(Array.isArray(body?.['protocolVersions']) && typeof body?.['preferredVersion'] === 'string', req('openwop.requirement.0172.preferred-version-default.headerless', 'spec/v2/core/capabilities.md §1', 'the v1 representation MUST carry protocolVersions[] and preferredVersion additively so a single fetch names the other major')).toBe(true);
     }
   });
+  it('a header-less request on any other unversioned path is served major 2', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 with a JSON body under OpenWOP-Version: 2.0');
+    // versioning.md §1.2/§1.3: an unversioned operation path is the v2 surface, so the
+    // header-less default (preferredVersion) applies to /.well-known/openwop only. Any
+    // answer carries OpenWOP-Version (§1.4), so an unknown run id is enough to read it.
+    const path = `/runs/openwop-conformance~2F${'h'.repeat(22)}`;
+    let version: string | null = null;
+    try {
+      const res = await fetch(`${loadEnv().baseUrl}${path}`, { headers: { Accept: 'application/json', Authorization: `Bearer ${loadEnv().apiKey}` } });
+      await res.text();
+      version = res.headers.get('openwop-version');
+    } catch {
+      return softSkip('blocked', `header-less GET ${path} unreachable (fetch failed)`);
+    }
+    expect(version?.trim().split('.')[0], req('openwop.requirement.0172.preferred-version-default.unversioned-is-v2', 'spec/v2/core/versioning.md §1.2, §1.3', `a header-less request on an unversioned operation path MUST be served major 2 and say so in OpenWOP-Version — the preferredVersion default is for /.well-known/openwop only (got ${JSON.stringify(version)})`)).toBe('2');
+  });
   it('through the overlap preferredVersion names a 1.x member', async () => {
     const doc = await discovery();
     if (!doc) return softSkip('blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 with a JSON body under OpenWOP-Version: 2.0');

package/src/scenarios/v2-refresh-sla.test.ts

@@ -38,12 +38,14 @@ describe('RFC 0175 §D.4 — refresh-sla (unaided; gated on a2a or mcp)', () =>
       { family: 'a2a', offered: 'versions', preferred: 'preferredVersion', floor: 'minimumVersion' },
       { family: 'mcp', offered: 'revisions', preferred: 'preferredVersion', floor: 'minimumRevision' },
     ];
-    let checked = 0;
-    const now = Date.now();
+    const advertised: Array<{ f: (typeof facets)[number]; rec: Record<string, unknown> }> = [];
     for (const f of facets) {
       const rec = await familyAdvertised(f.family);
-      if (!rec) continue;
-      checked++;
+      if (rec) advertised.push({ f, rec });
+    }
+    if (advertised.length === 0) return softSkip('inapplicable', 'host advertises neither a2a nor mcp — no refreshedAt to check');
+    const now = Date.now();
+    for (const { f, rec } of advertised) {
       const refreshedAt = rec['refreshedAt'];
       expect(
         typeof refreshedAt === 'string' && DATE.test(refreshedAt),
@@ -73,6 +75,5 @@ describe('RFC 0175 §D.4 — refresh-sla (unaided; gated on a2a or mcp)', () =>
         req('openwop.requirement.0175.refresh-sla', 'interop.md §The facets', `${f.family}.${f.floor} MUST be one of the offered ${f.offered}[] — a floor below every offer refuses nothing`),
       ).toContain(rec[f.floor]);
     }
-    if (checked === 0) return softSkip('inapplicable', 'host advertises neither a2a nor mcp — no refreshedAt to check');
   });
 });

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

@@ -10,9 +10,9 @@
  * 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.
+ * On the core-standard floor since 2.42.7, beside `v2-sse-last-event-id`. It was
+ * held off until the three bundle hosts were measured (rc.59 precedent); all
+ * three recorded it executed-pass, two with partial-witness on the SHOULD leg only.
  *
  * Legs, on one completed noop run:
  *   1. a future id (last + 1000) ⇒ 200, zero frames, closed by the server — a

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

@@ -92,6 +92,8 @@ describe('v2 sse-last-event-id (events.md §SSE frames)', () => {
     // 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;
+    // partial-witness-ok: every Last-Event-ID MUST was asserted above on the debug stream; the
+    // state.snapshot-first rule binds only a host serving values mode.
     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);