@openwop/openwop-conformance 2.0.0-rc.37 → 2.0.0-rc.6

package/src/scenarios/era-key-stamped-v1.test.ts

@@ -1,156 +0,0 @@
-/**
- * `spec/v1/version-negotiation.md` §Stamping / §Legacy detection — the two
- * run-document stamping MUSTs, and the legacy rule that makes their absence
- * actively harmful (suite 2.0.0, target major 1; unaided).
- *
- * The rule is a v1 `MUST` and has been since the contract was written:
- *
- *   §Stamping        "Every persisted run document MUST carry an
- *                     `eventLogSchemaVersion: number` field. The current v1
- *                     value is `2`."
- *   §Legacy detection "Hosts identify an older run document as legacy when
- *                     `eventLogSchemaVersion` is undefined or `< 2`" … legacy
- *                     runs have "no event subcollection … Readers MUST fall
- *                     back to the snapshot for state."
- *
- * **Nothing in the suite has ever asserted it.** `version-negotiation.test.ts`
- * opens by claiming it checks "the four version axes (`engineVersion`,
- * `eventLogSchemaVersion`, per-event `schemaVersion`, `pinnedVersions`) appear
- * where the spec says they should" — and `protocolVersion` is the only axis it
- * asserts. Across all 444 v1 scenario files the sole occurrence of the
- * identifier `eventLogSchemaVersion` was that sentence: a docstring describing
- * a check that does not exist. **A comment claiming coverage is worse than no
- * comment**, because it answers "is this tested?" for anyone who greps, and
- * answers it wrongly.
- *
- * Both production hosts were measured on 2026-09-04 and neither stamps the
- * field on any run it has ever served. Each found it independently, after the
- * other published its own greps.
- *
- * The consequence fails in the direction that punishes correctness. A client
- * following §Legacy detection exactly classifies every such run as legacy and
- * reads the snapshot — **ignoring the event log the host is in fact serving**.
- * The host under-serves the conforming reader and over-serves the careless one.
- *
- * Why the schema could not catch it: `run-snapshot.schema.json` requires only
- * `runId`, `workflowId` and `status`, so a snapshot missing the field validates
- * cleanly. The obligation is prose-only, which is exactly the shape that needs
- * a scenario rather than a keyword.
- *
- * @see spec/v1/version-negotiation.md §Stamping
- * @see spec/v1/version-negotiation.md §Legacy detection
- */
-
-import { describe, it, expect } from 'vitest';
-import { driver } from '../lib/driver.js';
-import { softSkip } from '../lib/soft-skip.js';
-import { req } from '../lib/requirement-ids.js';
-
-const ID_STAMPED = 'openwop.requirement.version-negotiation.era-key-stamped';
-const ID_NOT_LEGACY = 'openwop.requirement.version-negotiation.era-key-not-legacy';
-const ID_ENGINE = 'openwop.requirement.version-negotiation.engine-version-stamped';
-const DOC = 'spec/v1/version-negotiation.md §Stamping';
-
-interface Snapshot { readonly eventLogSchemaVersion?: unknown; readonly engineVersion?: unknown }
-
-/** A run this host created moments ago — the one case where "legacy" cannot apply. */
-async function freshRun(): Promise<{ runId: string } | { skip: string }> {
-  try {
-    // v1 path keys are explicit: the driver's unversioned rewrite is a major-2
-    // behaviour, and `/runs` answers 404 on a v1 host. The first version of this
-    // file used `/runs` and therefore SOFT-SKIPPED against a host that violates
-    // the rule — passing vacuously, which is the failure this scenario exists to
-    // catch, committed by the scenario itself.
-    const created = await driver.post('/v1/runs', { workflowId: 'conformance-noop', inputs: {} });
-    if (created.status !== 201) return { skip: `POST /v1/runs answered ${created.status} — no run to inspect` };
-    const runId = (created.json as { runId?: unknown } | null)?.runId;
-    if (typeof runId !== 'string') return { skip: 'POST /v1/runs returned no runId' };
-    return { runId };
-  } catch {
-    return { skip: 'POST /v1/runs unreachable' };
-  }
-}
-
-describe('era-key-stamped-v1 (version-negotiation.md §Stamping)', () => {
-  it('a run the host just created carries eventLogSchemaVersion', async () => {
-    const r = await freshRun();
-    if ('skip' in r) return softSkip('blocked', r.skip);
-
-    let snap;
-    try {
-      snap = await driver.get(`/v1/runs/${encodeURIComponent(r.runId)}`);
-    } catch {
-      return softSkip('blocked', 'GET /v1/runs/{runId} unreachable');
-    }
-    if (snap.status !== 200) return softSkip('blocked', `GET /v1/runs/{runId} answered ${snap.status}`);
-
-    const value = (snap.json as Snapshot | null)?.eventLogSchemaVersion;
-    expect(
-      value,
-      req(ID_STAMPED, DOC, 'every persisted run document MUST carry an eventLogSchemaVersion — the field is prose-only (run-snapshot.schema.json requires just runId, workflowId and status), so a snapshot without it validates cleanly and only this check can see its absence'),
-    ).not.toBeUndefined();
-    expect(
-      typeof value === 'number',
-      req(ID_STAMPED, DOC, `eventLogSchemaVersion MUST be a number (got ${JSON.stringify(value)})`),
-    ).toBe(true);
-  });
-
-  it('a freshly created run is not classified legacy by the host\'s own rule', async () => {
-    const r = await freshRun();
-    if ('skip' in r) return softSkip('blocked', r.skip);
-
-    let snap;
-    try {
-      snap = await driver.get(`/v1/runs/${encodeURIComponent(r.runId)}`);
-    } catch {
-      return softSkip('blocked', 'GET /v1/runs/{runId} unreachable');
-    }
-    if (snap.status !== 200) return softSkip('blocked', `GET /v1/runs/{runId} answered ${snap.status}`);
-    const value = (snap.json as Snapshot | null)?.eventLogSchemaVersion;
-    if (value === undefined) {
-      return softSkip('blocked', 'the field is absent — the stamping leg above records that; legacy classification cannot be judged separately from it');
-    }
-
-    // §Legacy detection: "undefined or < 2" is legacy, and a legacy run means
-    // "no event subcollection … Readers MUST fall back to the snapshot". A host
-    // that serves an event log while stamping a legacy value is telling a
-    // conforming client to ignore the log it is serving.
-    expect(
-      typeof value === 'number' && value >= 2,
-      req(ID_NOT_LEGACY, 'spec/v1/version-negotiation.md §Legacy detection', `a run created moments ago MUST NOT be legacy: legacy is "undefined or < 2", and a legacy run is specified to have no event subcollection so readers MUST fall back to the snapshot. Stamping ${JSON.stringify(value)} on a new run instructs a CONFORMING client to ignore the event log this host is serving it — the failure lands on the correct reader and spares the careless one`),
-    ).toBe(true);
-  });
-
-  it('a run the host just created carries engineVersion — the legacy escape cannot reach it', async () => {
-    const r = await freshRun();
-    if ('skip' in r) return softSkip('blocked', r.skip);
-
-    let snap;
-    try {
-      snap = await driver.get(`/v1/runs/${encodeURIComponent(r.runId)}`);
-    } catch {
-      return softSkip('blocked', 'GET /v1/runs/{runId} unreachable');
-    }
-    if (snap.status !== 200) return softSkip('blocked', `GET /v1/runs/{runId} answered ${snap.status}`);
-
-    // §Stamping: "Every persisted run document MUST carry an `engineVersion:
-    // number` field … Servers MAY omit this field on legacy runs that predate
-    // the contract." The escape is scoped to runs that PREDATE the contract, so
-    // it cannot cover a run created seconds ago — which is why this leg creates
-    // one rather than inspecting whatever happens to be in the store.
-    //
-    // Asserted here because nothing else asserts it ON A RUN: version-fold.test.ts
-    // reads engineVersion from the DISCOVERY document, and wasm-pack-load.test.ts
-    // carries it only as a type field. Both mention the identifier, so a grep
-    // suggests coverage that does not exist for this requirement.
-    const value = (snap.json as Snapshot | null)?.engineVersion;
-    expect(
-      value,
-      req(ID_ENGINE, DOC, 'every persisted run document MUST carry engineVersion; the "MAY omit" escape applies only to legacy runs that predate the contract, and this run was created moments ago'),
-    ).not.toBeUndefined();
-    expect(
-      typeof value === 'number',
-      req(ID_ENGINE, DOC, `engineVersion MUST be a number set to the writer engine's CURRENT_ENGINE_VERSION at write time (got ${JSON.stringify(value)})`),
-    ).toBe(true);
-  });
-});

package/src/scenarios/v2-advertised-path-space-served.test.ts

@@ -1,140 +0,0 @@
-/**
- * RFC 0172 §A.1 / `spec/v2/core/versioning.md` §1.2 — a host that advertises
- * major 2 serves the major-2 PATH SPACE, not just the major-2 discovery
- * document (suite 2.0.0, target major 2; unaided).
- *
- * `v2-version-header-honored` checks that `OpenWOP-Version` is honored or
- * refused rather than ignored. It probes `/.well-known/openwop`, because that
- * is the one resource whose representation the header selects. **It therefore
- * cannot see a host that negotiates correctly on the well-known resource and
- * has mounted almost none of the rest of the v2 surface.**
- *
- * That is not hypothetical. A tier-1 host advertising
- * `protocolVersions: ["1.1","2.0"]` was found serving **two of fifteen**
- * top-level segments of the v2 path space: its unversioned mount was a
- * deliberate allowlist (`['/runs','/interrupts']`, chosen over a blanket
- * `/v1`-strip because the host serves a large non-`/v1` surface a blanket
- * rewrite would shadow) and the list was simply incomplete. Every probe used to
- * call the dual stack live — `protocolVersions`, `preferredVersion`, the
- * response header, the two differing representations — hits `/.well-known`, so
- * every one of them passed. `POST /webhooks` under major 2 returned `404` while
- * `POST /v1/webhooks` returned `201`. The host found this itself by applying
- * the artifact rule to a scenario it had first classified as a harness defect.
- *
- * The discriminator is a PAIR, not a single probe, because "this host does not
- * implement webhooks at all" and "this host implements webhooks but did not
- * mount them under major 2" are different facts that a lone `404` cannot
- * separate:
- *
- *   /v1<path> exists  AND  <path> is 404 under major 2  ⇒  the advertisement
- *   overstates: the surface exists and major 2 does not reach it.
- *
- *   both 404  ⇒  the host does not serve that surface in either major. Not this
- *   scenario's business, and recorded as neither pass nor failure.
- *
- * Only parameterless GETs from `spec/v2/path-manifest.json` are probed: they
- * need no fixture, mutate nothing, and a route that is not mounted answers 404
- * regardless of auth, so the check is unaided and safe against a live host.
- *
- * @see spec/v2/core/versioning.md §1.2
- * @see RFCS/0172-v2-versioning-and-release.md §A.1
- */
-
-import { describe, it, expect } from 'vitest';
-import { loadEnv } from '../lib/env.js';
-import { softSkip } from '../lib/soft-skip.js';
-import { req } from '../lib/requirement-ids.js';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { SCHEMAS_DIR } from '../lib/paths.js';
-
-const ID = 'openwop.requirement.0172.advertised-path-space-served';
-const DOC = 'spec/v2/core/versioning.md §1.2';
-
-/** The well-known resource is the one the HEADER selects; it has no /v1 twin to pair against. */
-const NOT_PAIRABLE = new Set(['/.well-known/openwop']);
-
-interface Probe { readonly status: number | null }
-
-async function get(path: string, major2: boolean): Promise<Probe> {
-  const { baseUrl, apiKey } = loadEnv();
-  const headers: Record<string, string> = { Accept: 'application/json' };
-  if (major2) headers['OpenWOP-Version'] = '2.0';
-  if (apiKey) headers['authorization'] = `Bearer ${apiKey}`;
-  try {
-    const res = await fetch(`${baseUrl.replace(/\/$/, '')}${path}`, { headers });
-    return { status: res.status };
-  } catch {
-    return { status: null };
-  }
-}
-
-function parameterlessGets(): string[] {
-  try {
-    const manifest = JSON.parse(
-      readFileSync(join(SCHEMAS_DIR, '..', 'spec', 'v2', 'path-manifest.json'), 'utf8'),
-    ) as { operations?: ReadonlyArray<{ method: string; path: string }> };
-    return (manifest.operations ?? [])
-      .filter((o) => o.method === 'GET' && !o.path.includes('{') && !NOT_PAIRABLE.has(o.path))
-      .map((o) => o.path)
-      .sort();
-  } catch {
-    return [];
-  }
-}
-
-describe('v2-advertised-path-space-served (RFC 0172 §A.1)', () => {
-  it('a host advertising major 2 reaches the surfaces it already serves under /v1', async () => {
-    const { baseUrl } = loadEnv();
-    const bare = await (async () => {
-      try {
-        const res = await fetch(`${baseUrl.replace(/\/$/, '')}/.well-known/openwop`, { headers: { Accept: 'application/json' } });
-        return res.status === 200 ? ((await res.json()) as Record<string, unknown>) : null;
-      } catch {
-        return null;
-      }
-    })();
-    if (!bare) return softSkip('blocked', 'the discovery document is unreadable, so the advertised majors are unknown');
-
-    const versions = Array.isArray(bare['protocolVersions']) ? (bare['protocolVersions'] as unknown[]).map(String) : [];
-    if (!new Set(versions.map((v) => v.split('.')[0])).has('2')) {
-      return softSkip('inapplicable', `the host advertises [${versions.join(', ') || 'no protocolVersions'}] — it does not claim major 2, so there is no path space to hold it to`);
-    }
-
-    const paths = parameterlessGets();
-    if (paths.length === 0) return softSkip('blocked', 'spec/v2/path-manifest.json is unreadable from this layout');
-
-    const overstated: string[] = [];
-    const served: string[] = [];
-    let pairable = 0;
-    for (const path of paths) {
-      const v1 = await get(`/v1${path}`, false);
-      if (v1.status === null) return softSkip('blocked', `the host became unreachable while probing /v1${path}`);
-      // The host does not serve this surface in EITHER major. Legitimate, and a
-      // different question from the one asked here.
-      if (v1.status === 404) continue;
-      pairable += 1;
-
-      const v2 = await get(path, true);
-      if (v2.status === null) return softSkip('blocked', `the host became unreachable while probing ${path}`);
-      // Any status but 404 means the route is MOUNTED — 401/403/422 all answer
-      // "this path exists". Only 404 says major 2 cannot reach it.
-      if (v2.status === 404) overstated.push(`${path} (/v1 → ${v1.status}, major 2 → 404)`);
-      else served.push(path);
-    }
-
-    if (pairable === 0) {
-      return softSkip('inapplicable', 'no parameterless GET in the v2 manifest is served under /v1 either, so there is no pair to compare and the advertisement cannot be checked this way');
-    }
-
-    expect(
-      overstated,
-      req(ID, DOC, `a host advertising major 2 MUST reach, under major 2, the surfaces it already serves under /v1 — advertising the major is a claim about the PATH SPACE and not only about the well-known resource, whose representation the header selects and which therefore passes even when almost nothing else is mounted (${overstated.length} of ${pairable} pairable surface(s) unreachable: ${overstated.slice(0, 6).join('; ')})`),
-    ).toEqual([]);
-
-    expect(
-      served.length,
-      req(ID, DOC, 'at least one non-well-known surface MUST be reachable under major 2, or the advertisement rests entirely on the one resource the header selects'),
-    ).toBeGreaterThan(0);
-  });
-});

package/src/scenarios/v2-run-completed-outputs.test.ts

@@ -1,93 +0,0 @@
-/**
- * `spec/v2/core/events.md` §Payloads — `run.completed` MUST carry `outputs`
- * (suite 2.0.0, target major 2; unaided).
- *
- * This requirement is one day old, and the reason it needed writing is the
- * reason this file exists. Both majors' payload schemas NAMED `outputs` on
- * `runCompleted` and REQUIRED nothing. v1 also left the object open. So a
- * tier-1 host emitted the singular `output` for its entire life and validated
- * every time; v2 closing the object caught the EXTRA key — and that is the
- * only reason anyone looked. Nothing in either major has ever caught an ABSENT
- * one: a host emitting `run.completed {}` validates in v1 and, until rc.35, in
- * v2. Seventeen scenario files mention `run.completed`; none read its payload.
- *
- * A key that no schema requires and no scenario reads is a requirement that
- * exists only as a property name — the same shape as `eventLogSchemaVersion`,
- * which lived in a schema `description` for the life of v1 while two hosts
- * shipped without it. Asserting the EFFECT (the terminal event of a run that
- * completed carries an outputs object) is the only form of this check a
- * permissive emitter cannot satisfy by accident.
- *
- * @see spec/v2/core/events.md §Payloads
- * @see schemas/v2/run-event-payloads.schema.json $defs/runCompleted
- */
-
-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 { softSkip } from '../lib/soft-skip.js';
-import { req } from '../lib/requirement-ids.js';
-
-const ID = 'openwop.requirement.0171.run-completed-outputs';
-const DOC = 'spec/v2/core/events.md §Payloads';
-const NOOP_WORKFLOW_ID = 'conformance-noop';
-
-async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> {
-  try { return await fn(); } catch { return null; }
-}
-
-async function createRun(): Promise<{ runId: string } | { reason: string }> {
-  try { if (!(await v2Discovery())) return { reason: 'v2 discovery unreachable' }; } catch { return { reason: 'v2 discovery unreachable' }; }
-  const res = await http(() => driver.post('/runs', { workflowId: NOOP_WORKFLOW_ID }));
-  if (res === null) return { reason: 'POST /runs unreachable (fetch failed)' };
-  const runId = (res.json as { runId?: unknown } | undefined)?.runId;
-  if (res.status !== 201 || typeof runId !== 'string') return { reason: `POST /runs {workflowId: ${NOOP_WORKFLOW_ID}} answered ${res.status} ${readErrorCode(res.json) ?? ''} — the smallest valid create was refused (fixture not seeded?)`.trim() };
-  return { runId };
-}
-
-interface Ev { readonly type?: unknown; readonly payload?: unknown }
-
-/** Poll until the terminal event lands. The noop workflow completes in well under a second; the bound is for a slow host, not a slow workflow. */
-async function terminalEvent(runId: string): Promise<{ ev: Ev } | { reason: string }> {
-  let last: string | null = null;
-  for (let i = 0; i < 20; i += 1) {
-    const res = await http(() => driver.get(`/runs/${encodeURIComponent(runId)}/events/poll?timeout=1`));
-    if (res === null) return { reason: 'GET /runs/{runId}/events/poll unreachable (fetch failed)' };
-    if (res.status !== 200) return { reason: `GET /runs/{runId}/events/poll answered ${res.status}` };
-    const events = (res.json as { events?: unknown } | undefined)?.events;
-    if (Array.isArray(events)) {
-      const hit = events.find((e): e is Ev => typeof (e as Ev)?.type === 'string' && (e as Ev).type === 'run.completed');
-      if (hit) return { ev: hit };
-      const failed = events.find((e): e is Ev => typeof (e as Ev)?.type === 'string' && /^run\.(failed|cancelled)$/.test(String((e as Ev).type)));
-      if (failed) return { reason: `the noop run reached ${String(failed.type)} rather than run.completed — nothing to assert outputs on` };
-      last = `${events.length} event(s), none terminal`;
-    }
-    await new Promise((r) => setTimeout(r, 250));
-  }
-  return { reason: `run.completed never appeared (${last ?? 'no events'}) — the host may not run the noop workflow to completion` };
-}
-
-describe('v2 run-completed-outputs (events.md §Payloads)', () => {
-  it('the run.completed event of a run that completed carries an outputs object', async () => {
-    const c = await createRun();
-    if ('reason' in c) return softSkip('blocked', c.reason);
-    const t = await terminalEvent(c.runId);
-    if ('reason' in t) return softSkip('blocked', t.reason);
-
-    const payload = (t.ev.payload ?? null) as { outputs?: unknown; output?: unknown } | null;
-    expect(
-      payload !== null && typeof payload === 'object',
-      req(ID, DOC, 'run.completed MUST carry a payload object'),
-    ).toBe(true);
-    expect(
-      payload !== null && typeof payload.outputs === 'object' && payload.outputs !== null && !Array.isArray(payload.outputs),
-      req(ID, DOC, `run.completed MUST carry \`outputs\` as an object (an empty object is valid) — a client cannot tell "no outputs" from "outputs not rendered" when the key is absent, and no schema in either major required it until rc.35, which is how a host emitted the singular \`output\` for its whole life. Got keys ${JSON.stringify(payload ? Object.keys(payload) : null)}`),
-    ).toBe(true);
-
-    // The schema now requires it too; assert through the validator so the two
-    // cannot drift apart again without this leg saying which one moved.
-    const r = v2Validator('run-event')(t.ev);
-    expect(r.ok, req(ID, DOC, `the terminal event MUST validate against run-event.schema.json, whose runCompleted payload now requires outputs (${r.errors})`)).toBe(true);
-  });
-});

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

@@ -1,124 +0,0 @@
-/**
- * RFC 0172 §A.3 — the `OpenWOP-Version` header is HONORED or REFUSED, never
- * ignored (suite 2.0.0, target major 2; unaided).
- *
- * A host that does not implement v2 has two correct answers to
- * `OpenWOP-Version: 2`: serve the v2 representation, or refuse with `406
- * protocol_version_unsupported`. There is a third thing it can do, and it is
- * the dangerous one — return `200` with the v1 document, ignoring the header
- * entirely.
- *
- * That third case is invisible to every presence-gated scenario in the suite.
- * A scenario that skips when a v2 shape is absent records `inapplicable`
- * whether the host REFUSED major 2 or silently handed back v1; both are
- * non-failures, so a bundle looks clean while witnessing nothing. This is not
- * hypothetical: it is the shape that let RFC 0165 sit `Accepted` on a host
- * that served none of it — the acceptance cited merged PRs, the gated
- * scenarios recorded `inapplicable`, and nothing in the chain ever compared
- * the two representations. Measured on a live tier-1 host 2026-09-04:
- * `OpenWOP-Version: 2` returned `200` with a body byte-identical to the
- * header-less fetch. Credit to the openwop-app session for the probe.
- *
- * The check is cheap and needs no v2 support: fetch the resource twice, once
- * with the header and once without. A host advertising two majors MUST NOT
- * return the same bytes for both, because the two representations differ by
- * construction (`capabilities.md` §1). A host advertising one major MUST
- * refuse rather than ignore.
- *
- * @see spec/v2/core/versioning.md §1.3
- * @see RFCS/0172-v2-versioning-and-release.md §A.3
- */
-
-import { describe, it, expect } from 'vitest';
-import { loadEnv } from '../lib/env.js';
-import { softSkip } from '../lib/soft-skip.js';
-import { req } from '../lib/requirement-ids.js';
-
-const ID = 'openwop.requirement.0172.version-header-honored';
-const DOC = 'spec/v2/core/versioning.md §1.3';
-const PATH = '/.well-known/openwop';
-
-interface Fetched {
-  readonly status: number;
-  readonly body: string;
-  readonly version: string | null;
-}
-
-async function fetchRepresentation(header: string | null): Promise<Fetched | null> {
-  const { baseUrl, apiKey } = loadEnv();
-  const headers: Record<string, string> = { Accept: 'application/json' };
-  if (header !== null) headers['OpenWOP-Version'] = header;
-  if (apiKey) headers['authorization'] = `Bearer ${apiKey}`;
-  try {
-    const res = await fetch(`${baseUrl.replace(/\/$/, '')}${PATH}`, { headers });
-    return { status: res.status, body: await res.text(), version: res.headers.get('openwop-version') };
-  } catch {
-    return null;
-  }
-}
-
-describe('v2-version-header-honored (RFC 0172 §A.3)', () => {
-  it('OpenWOP-Version is honored or refused — never ignored', async () => {
-    const bare = await fetchRepresentation(null);
-    const asked = await fetchRepresentation('2.0');
-    if (bare === null || asked === null) {
-      return softSkip('blocked', `${PATH} unreachable for one of the two probes — the comparison needs both`);
-    }
-    if (bare.status !== 200) {
-      return softSkip('blocked', `the header-less GET ${PATH} answered ${bare.status}; there is no baseline representation to compare against`);
-    }
-
-    // A refusal is a correct answer and ends the check: the host has told the
-    // truth about not serving major 2.
-    if (asked.status === 406) {
-      expect(
-        asked.status,
-        req(ID, DOC, 'a host that does not serve major 2 MUST refuse with 406 protocol_version_unsupported, which it did'),
-      ).toBe(406);
-      return softSkip('inapplicable', 'the host refused major 2 with the specified 406 — a correct answer, and there is no second representation to compare bytes against');
-    }
-    if (asked.status !== 200) {
-      return softSkip('blocked', `GET ${PATH} with OpenWOP-Version: 2.0 answered ${asked.status} — neither the v2 representation (200) nor the specified refusal (406), so this scenario cannot rule on it`);
-    }
-
-    // 200 means the host claims to have served major 2. The bytes decide
-    // whether it actually did.
-    expect(
-      asked.body === bare.body,
-      req(ID, DOC, `answering 200 to OpenWOP-Version: 2.0 with a body byte-identical to the header-less fetch means the header was IGNORED, not honored — the host served v1 and called it v2. Refusing with 406 is the correct answer for a host that does not implement major 2; silently returning v1 is the one answer that no presence-gated scenario can detect, because an absent v2 shape records \`inapplicable\` whether the host refused or ignored`),
-    ).toBe(false);
-  });
-
-  it('a host advertising two majors serves two different representations', async () => {
-    const bare = await fetchRepresentation(null);
-    if (bare === null || bare.status !== 200) {
-      return softSkip('blocked', `the header-less GET ${PATH} answered ${bare?.status ?? 'no response'}`);
-    }
-    let doc: Record<string, unknown>;
-    try {
-      doc = JSON.parse(bare.body) as Record<string, unknown>;
-    } catch {
-      return softSkip('blocked', `${PATH} did not return a JSON object`);
-    }
-    const versions = Array.isArray(doc['protocolVersions']) ? (doc['protocolVersions'] as unknown[]).map(String) : [];
-    const majors = new Set(versions.map((v) => v.split('.')[0]));
-    if (!(majors.has('1') && majors.has('2'))) {
-      return softSkip('inapplicable', `the host advertises [${versions.join(', ') || 'no protocolVersions'}] — one major or none, so there is no second representation to differ from`);
-    }
-
-    const asked = await fetchRepresentation('2.0');
-    if (asked === null) return softSkip('blocked', `${PATH} unreachable under OpenWOP-Version: 2.0`);
-    expect(
-      asked.status,
-      req(ID, DOC, `a host advertising both majors MUST serve major 2 when asked for it, not refuse (got ${asked.status})`),
-    ).toBe(200);
-    expect(
-      asked.body === bare.body,
-      req(ID, DOC, 'the v1 document and the closed v2 root differ by construction (capabilities.md §1), so a host advertising both majors returning identical bytes for both has advertised a major it does not actually serve'),
-    ).toBe(false);
-    expect(
-      asked.version?.trim().split('.')[0] ?? null,
-      req(ID, DOC, `the response to OpenWOP-Version: 2.0 MUST carry OpenWOP-Version naming the major it served (got ${String(asked.version)})`),
-    ).toBe('2');
-  });
-});