@openwop/openwop-conformance 2.0.0-rc.0 → 2.0.0-rc.2

package/src/scenarios/v2-manifest-ceiling-refused.test.ts

@@ -0,0 +1,130 @@
+/**
+ * v2-manifest-ceiling-refused — RFC 0177 §A.1; `spec/v2/core/packs.md` §"The engine range".
+ *
+ * Suite 2.0.0, target major 2. A v2 host MUST read an `engines.openwop` range
+ * with no upper bound as bounded by `<2.0.0` and MUST refuse, at install and on
+ * every publication path, a version whose range does not admit its protocol
+ * major — with `pack_engine_unsupported` (`spec/v2/errors.json`, 400), never
+ * `pack_runtime_requirement_unmet`. Three tiny node packs are built in the test
+ * and PUT through the seams-profile publish seam
+ * (`/conformance/seams/packs-test/{name}/-/{version}.tgz`, RFC 0168 §C.2; the
+ * driver rewrites the v1 seam path under target major 2):
+ *
+ *   1. `>=1.0.0`          (no ceiling)      → refused, pack_engine_unsupported
+ *   2. `>=1.0.0 <2.0.0`   (v1 ceiling)      → refused, pack_engine_unsupported
+ *   3. `>=2.0.0 <3.0.0`   (admits major 2)  → installs (200/201)
+ *
+ * Gated on the `packs` family (RFC 0169 §A.2: presence is the claim) and on
+ * the seams profile (`conformance.seamsProfile: openwop-conformance-seams-v2`);
+ * a host without the profile records `blocked` — the write API is the only
+ * install path the suite can drive.
+ *
+ * @see RFCS/0177-v2-registry-packs-and-extension-tail.md §A.1
+ * @see spec/v2/core/packs.md §"The engine range"
+ * @see api/seams-v2.yaml `putTestPackTarball`
+ */
+
+import { describe, it, expect } from 'vitest';
+import { gzipSync } from 'node:zlib';
+import { driver } from '../lib/driver.js';
+import { readErrorCode } from '../lib/error-envelope.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip, type SoftSkipKind } from '../lib/soft-skip.js';
+import { seamsProfileAdvertised, targetMajor } from '../lib/seams.js';
+import { v2Discovery, gateFamily } from '../lib/v2.js';
+
+const SECTION = 'packs.md §"The engine range" (RFC 0177 §A.1)';
+
+/** One ustar entry: 512-byte header + content padded to a 512 boundary. */
+function tarEntry(name: string, data: Buffer): Buffer {
+  const h = Buffer.alloc(512, 0);
+  h.write(name, 0, 100, 'utf8');
+  h.write('0000644\0', 100, 8, 'utf8');
+  h.write('0000000\0', 108, 8, 'utf8');
+  h.write('0000000\0', 116, 8, 'utf8');
+  h.write(`${data.length.toString(8).padStart(11, '0')}\0`, 124, 12, 'utf8');
+  h.write('00000000000\0', 136, 12, 'utf8');
+  h.write('        ', 148, 8, 'utf8');
+  h.write('0', 156, 1, 'utf8');
+  h.write('ustar\0', 257, 6, 'utf8');
+  h.write('00', 263, 2, 'utf8');
+  let sum = 0;
+  for (const b of h) sum += b;
+  h.write(`${sum.toString(8).padStart(6, '0')}\0 `, 148, 8, 'utf8');
+  const pad = (512 - (data.length % 512)) % 512;
+  return Buffer.concat([h, data, Buffer.alloc(pad, 0)]);
+}
+
+/** A gzipped tarball with `pack.json` at the root (node-packs.md §"Tarball extraction"). */
+function packTarball(files: Record<string, string>): Buffer {
+  return gzipSync(Buffer.concat([...Object.entries(files).map(([n, c]) => tarEntry(n, Buffer.from(c, 'utf8'))), Buffer.alloc(1024, 0)]));
+}
+
+const ENTRY = 'export default { execute: async (input) => input };\n';
+
+function freshName(slug: string): string {
+  return `core.openwop.v2-${slug}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function nodePack(name: string, engines: string): Record<string, unknown> {
+  return {
+    name,
+    version: '1.0.0',
+    kind: 'node',
+    engines: { openwop: engines },
+    runtime: { language: 'javascript', entry: 'index.mjs', format: 'esm' },
+    nodes: [{ typeId: `${name}.echo`, version: '1.0.0', category: 'data', role: 'pure' }],
+  };
+}
+
+async function publish(manifest: Record<string, unknown>) {
+  const name = manifest['name'] as string;
+  const version = manifest['version'] as string;
+  const body = packTarball({ 'pack.json': JSON.stringify(manifest, null, 2), 'index.mjs': ENTRY });
+  return driver.put(`/v1/packs-test/${encodeURIComponent(name)}/-/${encodeURIComponent(version)}.tgz`, body, {
+    headers: { 'Content-Type': 'application/octet-stream' },
+  });
+}
+
+/** The reason this leg cannot run, or null when the seam is reachable. */
+async function preflight(): Promise<{ kind: SoftSkipKind; reason: string } | null> {
+  if (targetMajor() !== 2) return { kind: 'inapplicable', reason: 'suite 2.0.0 v2 scenario: OPENWOP_TARGET_MAJOR is not 2' };
+  let doc: Record<string, unknown> | null;
+  try {
+    doc = await v2Discovery();
+  } catch {
+    doc = null;
+  }
+  if (!doc) return { kind: 'blocked', reason: 'discovery unreachable — /.well-known/openwop (OpenWOP-Version: 2.0) did not answer 200 JSON' };
+  if (!(await gateFamily('packs'))) return { kind: 'inapplicable', reason: 'v2 discovery does not advertise the packs family (RFC 0169 §A.2)' };
+  if (!seamsProfileAdvertised(doc)) return { kind: 'blocked', reason: 'host does not advertise conformance.seamsProfile: openwop-conformance-seams-v2 — the packs-test publish seam is the only install path the suite can drive (RFC 0168 §C.1)' };
+  return null;
+}
+
+describe('v2-manifest-ceiling-refused (RFC 0177 §A.1)', () => {
+  it('an engines.openwop range with no upper bound (>=1.0.0) reads <2.0.0 and is refused at install with pack_engine_unsupported', async () => {
+    const skip = await preflight();
+    if (skip) return softSkip(skip.kind, skip.reason);
+    const res = await publish(nodePack(freshName('unbounded'), '>=1.0.0'));
+    if (res.status === 404) return softSkip('blocked', 'packs-test publish seam answered 404 — seams profile advertised but the seam is not mounted');
+    expect(res.status, req('openwop.requirement.0177.manifest-ceiling-refused.unbounded', SECTION, 'an unbounded range does not admit protocol major 2 and MUST be refused with 400 pack_engine_unsupported')).toBe(400);
+    expect(readErrorCode(res.json), req('openwop.requirement.0177.manifest-ceiling-refused.unbounded', SECTION, 'the refusal code MUST be pack_engine_unsupported (not pack_runtime_requirement_unmet)')).toBe('pack_engine_unsupported');
+  });
+
+  it('a v1 ceiling (>=1.0.0 <2.0.0) is refused at install with pack_engine_unsupported', async () => {
+    const skip = await preflight();
+    if (skip) return softSkip(skip.kind, skip.reason);
+    const res = await publish(nodePack(freshName('v1-ceiling'), '>=1.0.0 <2.0.0'));
+    if (res.status === 404) return softSkip('blocked', 'packs-test publish seam answered 404 — seams profile advertised but the seam is not mounted');
+    expect(res.status, req('openwop.requirement.0177.manifest-ceiling-refused.v1-ceiling', SECTION, 'a <2.0.0 ceiling does not admit protocol major 2 and MUST be refused with 400 pack_engine_unsupported')).toBe(400);
+    expect(readErrorCode(res.json), req('openwop.requirement.0177.manifest-ceiling-refused.v1-ceiling', SECTION, 'the refusal code MUST be pack_engine_unsupported')).toBe('pack_engine_unsupported');
+  });
+
+  it('a range admitting the host major (>=2.0.0 <3.0.0) installs', async () => {
+    const skip = await preflight();
+    if (skip) return softSkip(skip.kind, skip.reason);
+    const res = await publish(nodePack(freshName('v2-installs'), '>=2.0.0 <3.0.0'));
+    if (res.status === 404) return softSkip('blocked', 'packs-test publish seam answered 404 — seams profile advertised but the seam is not mounted');
+    expect([200, 201].includes(res.status), req('openwop.requirement.0177.manifest-ceiling-refused.v2-installs', SECTION, `a manifest whose range admits major 2 MUST install (got ${res.status} ${readErrorCode(res.json) ?? ''})`)).toBe(true);
+  });
+});

package/src/scenarios/v2-manifest-hatch-carried.test.ts

@@ -0,0 +1,120 @@
+/**
+ * v2-manifest-hatch-carried — RFC 0177 §C.2; `spec/v2/core/packs.md`
+ * §"The manifest schema family".
+ *
+ * Suite 2.0.0, target major 2. Every pack-authored document MUST admit the
+ * vendor hatch `^(openwop-|x-|vendor\.)` — including the two nested documents
+ * RFC 0138 deferred, `agent-manifest` (inside `node-pack-manifest.agents[]`)
+ * and `prompt-template` (inside `prompt-pack-manifest.prompts[]`). A consumer
+ * that does not recognise a hatch property MUST ignore it and MUST NOT reject
+ * the document.
+ *
+ *   1. a node pack whose `agents[0]` carries `x-vendor-note` installs.
+ *   2. a prompt pack whose `prompts[0]` (a PromptTemplate) carries
+ *      `x-vendor-note` installs; a host that does not install `kind: prompt`
+ *      packs at all (`pack_kind_invalid`) records `skipped` for that leg.
+ *
+ * Installs through the seams-profile publish seam
+ * (`/conformance/seams/packs-test/…`, RFC 0168 §C.2). Gated on `packs` + the
+ * seams profile.
+ *
+ * @see RFCS/0177-v2-registry-packs-and-extension-tail.md §C.2
+ * @see spec/v2/core/packs.md §"The manifest schema family"
+ * @see schemas/v2/agent-manifest.schema.json, schemas/v2/prompt-template.schema.json
+ */
+
+import { describe, it, expect } from 'vitest';
+import { gzipSync } from 'node:zlib';
+import { driver } from '../lib/driver.js';
+import { readErrorCode } from '../lib/error-envelope.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip, type SoftSkipKind } from '../lib/soft-skip.js';
+import { seamsProfileAdvertised, targetMajor } from '../lib/seams.js';
+import { v2Discovery, gateFamily } from '../lib/v2.js';
+
+const SECTION = 'packs.md §"The manifest schema family" (RFC 0177 §C.2)';
+
+function tarEntry(name: string, data: Buffer): Buffer {
+  const h = Buffer.alloc(512, 0);
+  h.write(name, 0, 100, 'utf8');
+  h.write('0000644\0', 100, 8, 'utf8');
+  h.write('0000000\0', 108, 8, 'utf8');
+  h.write('0000000\0', 116, 8, 'utf8');
+  h.write(`${data.length.toString(8).padStart(11, '0')}\0`, 124, 12, 'utf8');
+  h.write('00000000000\0', 136, 12, 'utf8');
+  h.write('        ', 148, 8, 'utf8');
+  h.write('0', 156, 1, 'utf8');
+  h.write('ustar\0', 257, 6, 'utf8');
+  h.write('00', 263, 2, 'utf8');
+  let sum = 0;
+  for (const b of h) sum += b;
+  h.write(`${sum.toString(8).padStart(6, '0')}\0 `, 148, 8, 'utf8');
+  const pad = (512 - (data.length % 512)) % 512;
+  return Buffer.concat([h, data, Buffer.alloc(pad, 0)]);
+}
+function packTarball(files: Record<string, string>): Buffer {
+  return gzipSync(Buffer.concat([...Object.entries(files).map(([n, c]) => tarEntry(n, Buffer.from(c, 'utf8'))), Buffer.alloc(1024, 0)]));
+}
+const ENTRY = 'export default { execute: async (input) => input };\n';
+function freshName(slug: string): string {
+  return `core.openwop.v2-${slug}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+async function publish(manifest: Record<string, unknown>, files: Record<string, string>) {
+  const name = manifest['name'] as string;
+  const version = manifest['version'] as string;
+  const body = packTarball({ 'pack.json': JSON.stringify(manifest, null, 2), ...files });
+  return driver.put(`/v1/packs-test/${encodeURIComponent(name)}/-/${encodeURIComponent(version)}.tgz`, body, {
+    headers: { 'Content-Type': 'application/octet-stream' },
+  });
+}
+async function preflight(): Promise<{ kind: SoftSkipKind; reason: string } | null> {
+  if (targetMajor() !== 2) return { kind: 'inapplicable', reason: 'suite 2.0.0 v2 scenario: OPENWOP_TARGET_MAJOR is not 2' };
+  let doc: Record<string, unknown> | null;
+  try {
+    doc = await v2Discovery();
+  } catch {
+    doc = null;
+  }
+  if (!doc) return { kind: 'blocked', reason: 'discovery unreachable — /.well-known/openwop (OpenWOP-Version: 2.0) did not answer 200 JSON' };
+  if (!(await gateFamily('packs'))) return { kind: 'inapplicable', reason: 'v2 discovery does not advertise the packs family (RFC 0169 §A.2)' };
+  if (!seamsProfileAdvertised(doc)) return { kind: 'blocked', reason: 'host does not advertise conformance.seamsProfile: openwop-conformance-seams-v2 — the packs-test publish seam is the only install path the suite can drive (RFC 0168 §C.1)' };
+  return null;
+}
+
+describe('v2-manifest-hatch-carried (RFC 0177 §C.2)', () => {
+  it('an x- field inside agents[0] of a node pack is ignored, not rejected — the pack installs', async () => {
+    const skip = await preflight();
+    if (skip) return softSkip(skip.kind, skip.reason);
+    const name = freshName('hatch-agent');
+    const manifest = {
+      name,
+      version: '1.0.0',
+      kind: 'node',
+      engines: { openwop: '>=2.0.0 <3.0.0' },
+      runtime: { language: 'javascript', entry: 'index.mjs', format: 'esm' },
+      nodes: [{ typeId: `${name}.echo`, version: '1.0.0', category: 'data', role: 'pure' }],
+      agents: [{ agentId: `${name}.helper`, persona: 'Hatch Helper', modelClass: 'general', 'x-vendor-note': 'a hatch property the host MUST ignore' }],
+    };
+    const res = await publish(manifest, { 'index.mjs': ENTRY });
+    if (res.status === 404) return softSkip('blocked', 'packs-test publish seam answered 404 — seams profile advertised but the seam is not mounted');
+    expect([200, 201].includes(res.status), req('openwop.requirement.0177.manifest-hatch-carried.agents-x-field', SECTION, `agent-manifest admits ^(openwop-|x-|vendor\\.) — a pack whose agents[0] carries x-vendor-note MUST install (got ${res.status} ${readErrorCode(res.json) ?? ''})`)).toBe(true);
+  });
+
+  it('an x- field inside a prompt template of a prompt pack is ignored, not rejected — the pack installs', async () => {
+    const skip = await preflight();
+    if (skip) return softSkip(skip.kind, skip.reason);
+    const name = freshName('hatch-prompt');
+    const manifest = {
+      name,
+      version: '1.0.0',
+      kind: 'prompt',
+      engines: { openwop: '>=2.0.0 <3.0.0' },
+      prompts: [{ templateId: `${name}.system`, version: '1.0.0', kind: 'system', text: 'You are a conformance fixture.', 'x-vendor-note': 'a hatch property the host MUST ignore' }],
+    };
+    const res = await publish(manifest, {});
+    if (res.status === 404) return softSkip('blocked', 'packs-test publish seam answered 404 — seams profile advertised but the seam is not mounted');
+    const code = readErrorCode(res.json);
+    if (res.status >= 400 && code === 'pack_kind_invalid') return softSkip('skipped', 'host does not install kind: prompt packs (pack_kind_invalid) — the prompt-template hatch cannot be observed on this host');
+    expect([200, 201].includes(res.status), req('openwop.requirement.0177.manifest-hatch-carried.prompt-template-x-field', SECTION, `prompt-template admits ^(openwop-|x-|vendor\\.) — a prompt pack whose prompts[0] carries x-vendor-note MUST install (got ${res.status} ${code ?? ''})`)).toBe(true);
+  });
+});

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

@@ -0,0 +1,48 @@
+/**
+ * v2 — `min-client-version` (suite 2.0.0; RFC 0172 §A.5, row C5.8;
+ * `spec/v2/core/versioning.md` §1.5 "Client precedence and minClientVersion").
+ *
+ * Witness class: witnessable — gated on a host that sets `minClientVersion`.
+ * `minClientVersion` is a MUST: a host MAY refuse a client below it with
+ * `426 client_version_unsupported`. A host that does not advertise it records
+ * `inapplicable`. A request announcing `OpenWOP-Client-Version: 0.0.1` (below
+ * 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`.
+ */
+
+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 DOC = 'spec/v2/core/versioning.md §1.5';
+const VERSION = /^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)$/;
+
+async function discovery(): Promise<Record<string, unknown> | null> {
+  try { return await v2Discovery(); } catch { return null; }
+}
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> {
+  try { return await fn(); } catch { return null; }
+}
+
+describe('v2 min-client-version (RFC 0172 §A.5 — gated on minClientVersion)', () => {
+  it('a client below minClientVersion is refused with 426 client_version_unsupported', 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');
+    const floor = doc['minClientVersion'];
+    if (floor === undefined) return softSkip('inapplicable', 'the host does not advertise minClientVersion — the 426 refusal is gated on a host that sets it');
+    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)');
+    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);
+  });
+});

package/src/scenarios/v2-minimum-version-refused.test.ts

@@ -0,0 +1,141 @@
+/**
+ * RFC 0175 §D.2 — `minimum-version-refused` (suite 2.0.0, target major 2; gated on a2a/mcp + seams).
+ *
+ * A host advertises a floor (`a2a.minimumVersion` / `mcp.minimumRevision`); a
+ * negotiation that would land below it MUST fail closed with
+ * `interop_version_unsupported` (400, `spec/v2/errors.json`) whether or not
+ * policy permits an explicit downgrade above the floor, and the
+ * `negotiation.decided` event MUST say `outcome: refused` (`spec/v2/core/interop.md`
+ * §The floor, §The audit event; RFC 0175 §D.2/§D.3; invariant
+ * `interop-minimum-version-enforced`).
+ *
+ * How the below-floor peer is produced: the suite constructs its OWN single-era
+ * peer offering only a version below the advertised floor — `A2AFakePeer`
+ * with `['0.3']`, `McpFakeServer` with `['2025-06-18']` — and points the host at
+ * it through the §22/§23 invoke seams (`peerOffersOnly` for A2A). When the
+ * host's floor is at or below the lowest version the suite can offer there is
+ * nothing below the floor to offer, and the leg records `blocked` naming that.
+ *
+ * Callback-shaped (the host calls the suite's peer): unwitnessable when the
+ * host is in a separate network namespace — `../lib/host-callback.ts`.
+ *
+ * @see spec/v2/core/interop.md §Negotiation is a protocol
+ * @see SECURITY/threat-model-interop.md (interop-minimum-version-enforced)
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { v2Discovery, familyAdvertised } from '../lib/v2.js';
+import { seamsProfileAdvertised, SEAMS_PREFIX } from '../lib/seams.js';
+import { A2AFakePeer } from '../lib/a2a-fake-peer.js';
+import { McpFakeServer } from '../lib/mcp-fake-server.js';
+import { readErrorCode } from '../lib/error-envelope.js';
+import { softSkip, seamAbsent } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+export const REQUIRES_HOST_CALLBACK = "the host's A2A/MCP client calls a suite-owned peer that offers only a version below the advertised floor";
+
+const CODE = 'interop_version_unsupported';
+const A2A_LOWEST = '0.3';
+const MCP_LOWEST = '2025-06-18';
+
+async function discovery(): Promise<Record<string, unknown> | null> {
+  try { return await v2Discovery(); } catch { return null; }
+}
+
+function a2aBelow(a: string, b: string): boolean {
+  const [am, an] = a.split('.').map(Number);
+  const [bm, bn] = b.split('.').map(Number);
+  return am! < bm! || (am === bm && an! < bn!);
+}
+
+interface EventRow { type?: unknown; payload?: Record<string, unknown> }
+async function decidedEvents(runId: string): Promise<EventRow[]> {
+  const res = await driver.get(`/runs/${encodeURIComponent(runId)}/events/poll?timeout=1`);
+  const events = res.status === 200 ? ((res.json as { events?: EventRow[] } | null)?.events ?? []) : [];
+  return events.filter((e) => e.type === 'negotiation.decided');
+}
+
+async function assertRefused(id: string, protocol: 'a2a' | 'mcp', floor: string, res: { status: number; json: unknown }): Promise<void> {
+  expect(
+    res.status,
+    req(id, 'interop.md §The floor', `a negotiation that would land below ${protocol}'s floor (${floor}) MUST fail closed with 400 (RFC 0175 §D.2)`),
+  ).toBe(400);
+  expect(
+    readErrorCode(res.json),
+    req(id, 'errors.json interop_version_unsupported', `the refusal MUST carry ${CODE} in the canonical envelope`),
+  ).toBe(CODE);
+  const details = (res.json as { details?: Record<string, unknown> } | null)?.details ?? {};
+  if (details['protocol'] !== undefined) {
+    expect(details['protocol'], req(id, 'host-sample-test-seams.md §22/§23', `details.protocol MUST name ${protocol}`)).toBe(protocol);
+  }
+  const runId = (res.json as { runId?: unknown } | null)?.runId ?? details['runId'];
+  if (typeof runId !== 'string') {
+    softSkip('blocked', `the refusal names no runId — the negotiation.decided { outcome: refused } event on the host log is not addressable from the suite`);
+    return;
+  }
+  const decided = await decidedEvents(runId);
+  expect(decided.length, req(id, 'interop.md §The audit event', 'the refused outcome MUST also emit negotiation.decided (RFC 0175 §D.3 — every outcome, including the fail-closed one)')).toBeGreaterThan(0);
+  const last = decided[decided.length - 1]!.payload ?? {};
+  expect(last['outcome'], req(id, 'run-event-payloads.schema.json negotiationDecided.outcome', 'the event MUST say outcome: refused')).toBe('refused');
+  expect(last['reason'], req(id, 'run-event-payloads.schema.json negotiationDecided.reason', 'the reason MUST be below-floor')).toBe('below-floor');
+  if (last['floor'] !== undefined) expect(last['floor'], req(id, 'run-event-payloads.schema.json negotiationDecided.floor', 'the recorded floor MUST equal the advertised one')).toBe(floor);
+}
+
+describe('RFC 0175 §D.2 — minimum-version-refused (gated on a2a/mcp + seams)', () => {
+  it('an A2A peer offering only a version below minimumVersion is refused', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', 'discovery unreachable');
+    const facet = await familyAdvertised('a2a');
+    if (!facet) return softSkip('inapplicable', 'a2a facet not advertised — no floor to enforce');
+    if (!seamsProfileAdvertised(doc)) return softSkip('blocked', 'the below-floor exchange is driven through the seams profile — conformance.seamsProfile is not openwop-conformance-seams-v2');
+    const floor = String(facet['minimumVersion']);
+    if (!a2aBelow(A2A_LOWEST, floor)) {
+      return softSkip('blocked', `the advertised a2a.minimumVersion (${floor}) is at or below the lowest version the suite peer can offer (${A2A_LOWEST}) — nothing below the floor can be offered; a peer speaking a lower A2A revision is needed`);
+    }
+    const peer = new A2AFakePeer({ protocolVersions: ['0.3'] });
+    await peer.start();
+    try {
+      const res = await driver.post(`${SEAMS_PREFIX}/sample/a2a/invoke`, { peerUrl: peer.endpoint(), authenticated: true, peerOffersOnly: A2A_LOWEST });
+      if (res.status === 404 || res.status === 403 || res.status === 405) return seamAbsent(`host advertises a2a but ${SEAMS_PREFIX}/sample/a2a/invoke answered ${res.status} (host-sample-test-seams.md §22)`);
+      await assertRefused('openwop.requirement.0175.minimum-version-refused', 'a2a', floor, res);
+      // The wire leg: the host MUST NOT have spoken the below-floor version to the peer.
+      for (const c of peer.invocations().filter((i) => i.method !== 'GET')) {
+        expect(
+          a2aBelow(String(c.headers['a2a-version'] ?? ''), floor),
+          req('openwop.requirement.0175.minimum-version-refused', 'interop.md §The floor', `no call to the peer may carry an A2A-Version below the floor (got ${String(c.headers['a2a-version'])})`),
+        ).toBe(false);
+      }
+    } finally {
+      await peer.stop();
+    }
+  });
+
+  it('an MCP server offering only a revision below minimumRevision is refused', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', 'discovery unreachable');
+    const facet = await familyAdvertised('mcp');
+    if (!facet) return softSkip('inapplicable', 'mcp facet not advertised — no floor to enforce');
+    if (!seamsProfileAdvertised(doc)) return softSkip('blocked', 'the below-floor exchange is driven through the seams profile — conformance.seamsProfile is not openwop-conformance-seams-v2');
+    const floor = String(facet['minimumRevision']);
+    if (!(MCP_LOWEST < floor)) {
+      return softSkip('blocked', `the advertised mcp.minimumRevision (${floor}) is at or below the lowest revision the suite server can offer (${MCP_LOWEST}) — nothing below the floor can be offered`);
+    }
+    const server = new McpFakeServer({ protocolVersions: ['2025-06-18'] });
+    await server.start();
+    try {
+      const res = await driver.post(`${SEAMS_PREFIX}/sample/mcp/invoke`, { serverUrl: server.endpoint(), requestVersion: MCP_LOWEST });
+      if (res.status === 404 || res.status === 403 || res.status === 405) return seamAbsent(`host advertises mcp but ${SEAMS_PREFIX}/sample/mcp/invoke answered ${res.status} (host-sample-test-seams.md §23)`);
+      await assertRefused('openwop.requirement.0175.minimum-version-refused.mcp', 'mcp', floor, res);
+      for (const c of server.invocations()) {
+        const v = String(c.headers['mcp-protocol-version'] ?? '');
+        expect(
+          v !== '' && v < floor,
+          req('openwop.requirement.0175.minimum-version-refused.mcp', 'interop.md §The floor', `no call to the server may carry an MCP-Protocol-Version below the floor (got ${v})`),
+        ).toBe(false);
+      }
+    } finally {
+      await server.stop();
+    }
+  });
+});

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

@@ -0,0 +1,95 @@
+/**
+ * RFC 0175 §E.1 — `mrtr-rounds-ceiling` (suite 2.0.0, target major 2; gated on mcp + mrtr).
+ *
+ * `mcp.mrtr.maxRounds` (integer 1–16) is the advertised ceiling on multi-round
+ * tool-result rounds; the host MUST refuse an `input_required` round beyond it
+ * with `mcp_mrtr_rounds_exceeded` (422, `spec/v2/errors.json`); RFC 0153 G9
+ * closes (`spec/v2/core/interop.md` §The MCP round ceiling; RFC 0175 row C8.7).
+ *
+ * Legs:
+ *   1. unaided on the gate: the facet's `maxRounds` is an integer in 1..16;
+ *   2. behavioural: drive `maxRounds + 1` `input_required` rounds through the
+ *      suite's fake MCP server via the §23 invoke seam. The suite's server
+ *      (`McpFakeServer`) has ONE MRTR tool, `needs_input`, which completes on
+ *      the first retry — it cannot re-issue `input_required` N times — so the
+ *      behavioural leg records `blocked` naming the fixture it needs: a
+ *      `needs_input_loop` tool that answers `input_required` for
+ *      `arguments.rounds` retries before completing.
+ *
+ * @see spec/v2/core/interop.md §The MCP round ceiling
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { v2Discovery, familyAdvertised } from '../lib/v2.js';
+import { seamsProfileAdvertised, SEAMS_PREFIX } from '../lib/seams.js';
+import { getMcpFakeServer } from '../lib/mcp-fake-server.js';
+import { readErrorCode } from '../lib/error-envelope.js';
+import { softSkip, seamAbsent } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+export const REQUIRES_HOST_CALLBACK = "the host's MCP client drives MRTR rounds against the suite's fake server through /conformance/seams/sample/mcp/invoke";
+
+const CODE = 'mcp_mrtr_rounds_exceeded';
+const LOOP_TOOL = 'needs_input_loop';
+
+async function discovery(): Promise<Record<string, unknown> | null> {
+  try { return await v2Discovery(); } catch { return null; }
+}
+
+function maxRoundsOf(facet: Record<string, unknown>): unknown {
+  const mrtr = facet['mrtr'];
+  return mrtr && typeof mrtr === 'object' ? (mrtr as { maxRounds?: unknown }).maxRounds : undefined;
+}
+
+describe('RFC 0175 §E.1 — mrtr-rounds-ceiling (gated on mcp + mrtr)', () => {
+  it('mcp.mrtr.maxRounds is an integer ceiling in 1..16', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', 'discovery unreachable');
+    const facet = await familyAdvertised('mcp');
+    if (!facet) return softSkip('inapplicable', 'mcp facet not advertised — no MRTR ceiling');
+    const maxRounds = maxRoundsOf(facet);
+    if (maxRounds === undefined) return softSkip('inapplicable', 'mcp.mrtr not advertised — the host offers no multi-round tool results');
+    expect(
+      Number.isInteger(maxRounds) && (maxRounds as number) >= 1 && (maxRounds as number) <= 16,
+      req('openwop.requirement.0175.mrtr-rounds-ceiling', 'facets/mcp.schema.json mrtr.maxRounds', `maxRounds MUST be an integer in 1..16 (got ${JSON.stringify(maxRounds)}) — "the host MUST bound the number of rounds (host policy)" was a MUST with no number (RFC 0153 G9)`),
+    ).toBe(true);
+  });
+
+  it('round maxRounds + 1 is refused with mcp_mrtr_rounds_exceeded', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', 'discovery unreachable');
+    const facet = await familyAdvertised('mcp');
+    if (!facet) return softSkip('inapplicable', 'mcp facet not advertised — no MRTR ceiling');
+    const maxRounds = maxRoundsOf(facet);
+    if (!Number.isInteger(maxRounds)) return softSkip('inapplicable', 'mcp.mrtr.maxRounds not advertised — no ceiling to exceed');
+    if (!seamsProfileAdvertised(doc)) return softSkip('blocked', 'the rounds are driven through the seams profile (§23 invoke seam) — conformance.seamsProfile is not openwop-conformance-seams-v2');
+    const server = getMcpFakeServer();
+    if (server === null) return softSkip('blocked', 'the suite MCP fake server (OPENWOP_MCP_FAKE_SERVER=true) is not started in this run');
+    server.reset();
+    // The suite server's only MRTR tool, `needs_input`, completes on the first
+    // retry: it cannot re-issue input_required maxRounds+1 times. The fixture
+    // this leg needs is a `needs_input_loop` tool on McpFakeServer that answers
+    // input_required for `arguments.rounds` retries before completing.
+    const rounds = (maxRounds as number) + 1;
+    const res = await driver.post(`${SEAMS_PREFIX}/sample/mcp/invoke`, {
+      serverUrl: server.endpoint(),
+      tool: LOOP_TOOL,
+      arguments: { rounds },
+      clientCapabilities: { elicitation: {} },
+      elicitationAnswer: { name: 'Ada' },
+    });
+    if (res.status === 404 || res.status === 403 || res.status === 405) return seamAbsent(`host advertises mcp.mrtr but ${SEAMS_PREFIX}/sample/mcp/invoke answered ${res.status} (host-sample-test-seams.md §23)`);
+    const served = server.invocations().filter((i) => i.method === 'tools/call');
+    const loopKnown = served.some((i) => (i.params as { name?: unknown } | null)?.name === LOOP_TOOL) && !res.text.includes('Unknown tool');
+    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);
+    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,
+      req('openwop.requirement.0175.mrtr-rounds-ceiling.refused', 'interop.md §The MCP round ceiling', `the host MUST NOT issue a retry beyond the ceiling — the server saw ${served.length} tools/call for a ceiling of ${String(maxRounds)}`),
+    ).toBeLessThanOrEqual((maxRounds as number) + 1);
+  });
+});