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

package/src/scenarios/mcp-mrtr-roundtrip.test.ts

@@ -37,6 +37,7 @@ import { mcpServerMount } from '../lib/mcp-mount.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 import { getMcpFakeServer } from '../lib/mcp-fake-server.js';
+import { req } from '../lib/requirement-ids.js';
 
 export const REQUIRES_HOST_CALLBACK = "the host issues MCP JSON-RPC calls (including the MRTR input_required round trip) to the suite's fake server via /v1/host/sample/mcp/invoke (serverUrl)";
 
@@ -69,23 +70,23 @@ describe.skipIf(!process.env.OPENWOP_BASE_URL)('RFC 0153 §C — mcp-mrtr-roundt
       return seamAbsent(`host advertises mcp-2026-07-28 but the invoke seam /v1/host/sample/mcp/invoke answered ${drive.status}`);
     }
     const calls = server.invocations().filter((i) => i.method === 'tools/call');
-    expect(calls.length, driver.describe('RFCS/0153 §C', 'the host MUST have called the tool at least once for this leg to mean anything')).toBeGreaterThan(0);
+    expect(calls.length, req('openwop.it.mcp-mrtr-roundtrip.input-required-gather-retry-with-inputresponses-echoed-requeststate-as-one-logic', 'RFCS/0153 §C', 'the host MUST have called the tool at least once for this leg to mean anything')).toBeGreaterThan(0);
     const mrtr = (drive.json as { mrtr?: { inputRequiredSeen?: boolean; retried?: boolean; requestStateEchoed?: boolean; result?: unknown } }).mrtr;
     if (mrtr === undefined) {
-      expect(mrtr, driver.describe('host-sample-test-seams.md §23', 'the invoke seam SHOULD report `mrtr: { inputRequiredSeen, retried, requestStateEchoed, result }` for tool "needs_input"; until it does this requirement is unobservable and resolves to `blocked`')).toBeDefined();
-      return;
+      expect(mrtr, req('openwop.it.mcp-mrtr-roundtrip.input-required-gather-retry-with-inputresponses-echoed-requeststate-as-one-logic', 'host-sample-test-seams.md §23', 'the invoke seam SHOULD report `mrtr: { inputRequiredSeen, retried, requestStateEchoed, result }` for tool "needs_input"; until it does this requirement is unobservable and resolves to `blocked`')).toBeDefined();
+      return softSkip('blocked', 'precondition not met — `mrtr === undefined` returned early (seam, prior step, or fixture unavailable)');
     }
-    expect(mrtr.inputRequiredSeen, driver.describe('mcp-integration.md §C.1', 'the host MUST recognise resultType input_required')).toBe(true);
-    expect(mrtr.retried, driver.describe('mcp-integration.md §C.1', 'the host MUST retry the ORIGINAL request with inputResponses (a live callback is not the current profile)')).toBe(true);
+    expect(mrtr.inputRequiredSeen, req('openwop.it.mcp-mrtr-roundtrip.input-required-gather-retry-with-inputresponses-echoed-requeststate-as-one-logic', 'mcp-integration.md §C.1', 'the host MUST recognise resultType input_required')).toBe(true);
+    expect(mrtr.retried, req('openwop.it.mcp-mrtr-roundtrip.input-required-gather-retry-with-inputresponses-echoed-requeststate-as-one-logic', 'mcp-integration.md §C.1', 'the host MUST retry the ORIGINAL request with inputResponses (a live callback is not the current profile)')).toBe(true);
     // Cross-check from the wire: two tools/call, second carries requestState identical to what the server issued.
-    expect(calls.length, driver.describe('mcp-integration.md §C.1', 'initial + retry = two independent JSON-RPC requests on the wire')).toBeGreaterThanOrEqual(2);
+    expect(calls.length, req('openwop.it.mcp-mrtr-roundtrip.input-required-gather-retry-with-inputresponses-echoed-requeststate-as-one-logic', 'mcp-integration.md §C.1', 'initial + retry = two independent JSON-RPC requests on the wire')).toBeGreaterThanOrEqual(2);
     const retry = calls[calls.length - 1]!.params as { requestState?: string; inputResponses?: Record<string, unknown> };
-    expect(typeof retry.requestState, driver.describe('mcp-integration.md §C.1', 'requestState MUST be echoed exactly on the retry')).toBe('string');
-    expect(retry.requestState?.startsWith('mrtr:needs_input:'), 'the echoed requestState is the value the server issued, byte-exact').toBe(true);
-    expect(retry.inputResponses?.['who'], driver.describe('mcp-integration.md §C.1', 'inputResponses MUST answer every requested key')).toBeDefined();
+    expect(typeof retry.requestState, req('openwop.it.mcp-mrtr-roundtrip.input-required-gather-retry-with-inputresponses-echoed-requeststate-as-one-logic', 'mcp-integration.md §C.1', 'requestState MUST be echoed exactly on the retry')).toBe('string');
+    expect(retry.requestState?.startsWith('mrtr:needs_input:'), req('openwop.it.mcp-mrtr-roundtrip.input-required-gather-retry-with-inputresponses-echoed-requeststate-as-one-logic', 'mcp-integration.md §C.1', 'the echoed requestState is the value the server issued, byte-exact')).toBe(true);
+    expect(retry.inputResponses?.['who'], req('openwop.it.mcp-mrtr-roundtrip.input-required-gather-retry-with-inputresponses-echoed-requeststate-as-one-logic', 'mcp-integration.md §C.1', 'inputResponses MUST answer every requested key')).toBeDefined();
     expect(mrtr.requestStateEchoed).toBe(true);
     for (const c of calls) {
-      expect(c.revision, driver.describe('mcp-integration.md §B', 'both calls MUST carry the current revision')).toBe('2026-07-28');
+      expect(c.revision, req('openwop.it.mcp-mrtr-roundtrip.input-required-gather-retry-with-inputresponses-echoed-requeststate-as-one-logic', 'mcp-integration.md §B', 'both calls MUST carry the current revision')).toBe('2026-07-28');
     }
   });
 });
@@ -119,23 +120,23 @@ describe.skipIf(!process.env.OPENWOP_BASE_URL)('RFC 0153 §C — mcp-mrtr-roundt
     if (reg.status === 404 || reg.status === 403) return seamAbsent(`host advertises mcp-2026-07-28 with a server mount but the sample-workflow seam /v1/host/sample/workflows answered ${reg.status}`);
     // A 4xx here is a SUITE defect (the fixture this leg posts is malformed),
     // not seam absence and not a host finding — fail loudly at the source.
-    expect(reg.status, driver.describe('host-sample-test-seams.md §"sample workflows"', `the registration fixture MUST be accepted; a 4xx means the fixture this leg posts is malformed (suite defect): ${JSON.stringify(reg.json).slice(0, 200)}`)).toBeLessThan(400);
+    expect(reg.status, req('openwop.it.mcp-mrtr-roundtrip.a-suspending-tool-answers-input-required-with-elicitation-requeststate-the-retry', 'host-sample-test-seams.md §"sample workflows"', `the registration fixture MUST be accepted; a 4xx means the fixture this leg posts is malformed (suite defect): ${JSON.stringify(reg.json).slice(0, 200)}`)).toBeLessThan(400);
     const hdr = { 'MCP-Protocol-Version': '2026-07-28', 'Mcp-Method': 'tools/call', 'Mcp-Name': TOOL };
     const first = await driver.post(await mcpServerMount(), { jsonrpc: '2.0', id: 1, method: 'tools/call', params: { name: TOOL, arguments: {}, _meta: { [META_V]: '2026-07-28', [META_C]: { elicitation: {} } } } }, { headers: hdr });
     if (first.status === 404) return seamAbsent('host advertises an MCP server mount but /v1/host/sample/mcp answered 404');
     const r1 = first.json as { result?: { resultType?: string; inputRequests?: Record<string, { method?: string }>; requestState?: string }; error?: { code: number } };
-    expect(r1.error, driver.describe('mcp-integration.md §C.2', `tools/call MUST NOT error: ${JSON.stringify(r1.error)}`)).toBeUndefined();
-    expect(r1.result?.resultType, driver.describe('mcp-integration.md §C.2', 'a run reaching waiting-input MUST answer the in-flight tools/call with resultType input_required (not a live callback)')).toBe('input_required');
+    expect(r1.error, req('openwop.it.mcp-mrtr-roundtrip.a-suspending-tool-answers-input-required-with-elicitation-requeststate-the-retry', 'mcp-integration.md §C.2', `tools/call MUST NOT error: ${JSON.stringify(r1.error)}`)).toBeUndefined();
+    expect(r1.result?.resultType, req('openwop.it.mcp-mrtr-roundtrip.a-suspending-tool-answers-input-required-with-elicitation-requeststate-the-retry', 'mcp-integration.md §C.2', 'a run reaching waiting-input MUST answer the in-flight tools/call with resultType input_required (not a live callback)')).toBe('input_required');
     const key = Object.keys(r1.result?.inputRequests ?? {})[0];
-    expect(key, driver.describe('mcp-integration.md §C.2', 'inputRequests MUST carry the elicitation')).toBeDefined();
+    expect(key, req('openwop.it.mcp-mrtr-roundtrip.a-suspending-tool-answers-input-required-with-elicitation-requeststate-the-retry', 'mcp-integration.md §C.2', 'inputRequests MUST carry the elicitation')).toBeDefined();
     expect(r1.result?.inputRequests?.[key!]?.method).toBe('elicitation/create');
-    expect(typeof r1.result?.requestState, driver.describe('mcp-integration.md §C.2', 'requestState MUST be present (opaque, integrity-protected, bound to principal/TTL/request/runId/interrupt token)')).toBe('string');
+    expect(typeof r1.result?.requestState, req('openwop.it.mcp-mrtr-roundtrip.a-suspending-tool-answers-input-required-with-elicitation-requeststate-the-retry', 'mcp-integration.md §C.2', 'requestState MUST be present (opaque, integrity-protected, bound to principal/TTL/request/runId/interrupt token)')).toBe('string');
     const retry = await driver.post(await mcpServerMount(), { jsonrpc: '2.0', id: 2, method: 'tools/call', params: { name: TOOL, arguments: {}, requestState: r1.result!.requestState, inputResponses: { [key!]: { action: 'accept', content: { name: 'Ada' } } }, _meta: { [META_V]: '2026-07-28', [META_C]: { elicitation: {} } } } }, { headers: hdr });
     const r2 = retry.json as { result?: { resultType?: string }; error?: { code: number } };
     expect(r2.error).toBeUndefined();
-    expect(['complete', 'input_required'], driver.describe('mcp-integration.md §C.2', 'the retry MUST resolve the interrupt (complete) or ask for the next pending input')).toContain(r2.result?.resultType);
+    expect(['complete', 'input_required'], req('openwop.it.mcp-mrtr-roundtrip.a-suspending-tool-answers-input-required-with-elicitation-requeststate-the-retry', 'mcp-integration.md §C.2', 'the retry MUST resolve the interrupt (complete) or ask for the next pending input')).toContain(r2.result?.resultType);
     const forged = await driver.post(await mcpServerMount(), { jsonrpc: '2.0', id: 3, method: 'tools/call', params: { name: TOOL, arguments: {}, requestState: 'forged', inputResponses: { [key!]: { action: 'accept', content: { name: 'Eve' } } }, _meta: { [META_V]: '2026-07-28', [META_C]: { elicitation: {} } } } }, { headers: hdr });
     const r3 = forged.json as { result?: { resultType?: string }; error?: { code: number } };
-    expect(r3.error !== undefined || forged.status >= 400, driver.describe('mcp-integration.md §C.2', 'a requestState that fails integrity verification MUST be refused (upstream: attacker-controlled input)')).toBe(true);
+    expect(r3.error !== undefined || forged.status >= 400, req('openwop.it.mcp-mrtr-roundtrip.a-suspending-tool-answers-input-required-with-elicitation-requeststate-the-retry', 'mcp-integration.md §C.2', 'a requestState that fails integrity verification MUST be refused (upstream: attacker-controlled input)')).toBe(true);
   });
 });

package/src/scenarios/mcp-server-elicitation-bridge.test.ts

@@ -14,8 +14,9 @@
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { discoveryFamilies } from '../lib/discovery-capabilities.js';
-import { seamAbsent } from '../lib/soft-skip.js';
+import { seamAbsent, softSkip } from '../lib/soft-skip.js';
 import { mcpServerMount } from '../lib/mcp-mount.js';
+import { req } from '../lib/requirement-ids.js';
 
 interface DiscoveryDoc {
   capabilities?: Record<string, unknown>;
@@ -32,9 +33,9 @@ async function readCap(): Promise<Record<string, unknown> | null> {
 
 async function rpc(method: string, params?: Record<string, unknown>) {
   const id = Math.floor(Math.random() * 1e6);
-  const req: Record<string, unknown> = { jsonrpc: '2.0', id, method };
-  if (params !== undefined) req.params = params;
-  const res = await driver.post(await mcpServerMount(), req);
+  const reqBody: Record<string, unknown> = { jsonrpc: '2.0', id, method };
+  if (params !== undefined) reqBody.params = params;
+  const res = await driver.post(await mcpServerMount(), reqBody);
   return { status: res.status, body: res.json as { result?: unknown; error?: { code: number; message: string } } };
 }
 
@@ -51,11 +52,11 @@ async function registerElicitationHandlerWorkflow(): Promise<boolean> {
 describe('mcp-server-elicitation-bridge: advertisement shape (RFC 0020)', () => {
   it('elicitationBridge is a boolean when serverMount.supported', async () => {
     const cap = await readCap();
-    if (!cap || cap.supported !== true) return;
-    if (cap.elicitationBridge === undefined) return;
+    if (!cap || cap.supported !== true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!cap || cap.supported !== true` returned early');
+    if (cap.elicitationBridge === undefined) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `cap.elicitationBridge === undefined` returned early');
     expect(
       typeof cap.elicitationBridge,
-      driver.describe('RFC 0020 §B', 'mcp.serverMount.elicitationBridge MUST be boolean when present'),
+      req('openwop.it.mcp-server-elicitation-bridge.elicitationbridge-is-a-boolean-when-servermount-supported', 'RFC 0020 §B', 'mcp.serverMount.elicitationBridge MUST be boolean when present'),
     ).toBe('boolean');
   });
 });
@@ -63,8 +64,8 @@ describe('mcp-server-elicitation-bridge: advertisement shape (RFC 0020)', () =>
 describe('mcp-server-elicitation-bridge: behavioral (RFC 0020 §A point 3)', () => {
   it('elicitation/create bridges into a handle-elicitation workflow', async () => {
     const cap = await readCap();
-    if (!cap || cap.supported !== true || cap.elicitationBridge !== true) return;
-    if (!(await registerElicitationHandlerWorkflow())) return;
+    if (!cap || cap.supported !== true || cap.elicitationBridge !== true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!cap || cap.supported !== true || cap.elicitationBridge !== true` returned early');
+    if (!(await registerElicitationHandlerWorkflow())) return softSkip('blocked', 'precondition not met — `!(await registerElicitationHandlerWorkflow())` returned early (seam, prior step, or fixture unavailable)');
 
     const r = await rpc('elicitation/create', {
       message: 'What is your name?',
@@ -75,11 +76,11 @@ describe('mcp-server-elicitation-bridge: behavioral (RFC 0020 §A point 3)', ()
       },
     });
     if (r.status === 404) return seamAbsent(`host advertises an MCP server mount but the mount (capabilities.mcp.serverUrls[0], else /v1/host/sample/mcp) answered ${r.status} — RFC 0153 §B is unobservable at the path the host itself advertised`);
-    expect(r.status, 'JSON-RPC envelope MUST 200').toBe(200);
+    expect(r.status, req('openwop.it.mcp-server-elicitation-bridge.elicitation-create-bridges-into-a-handle-elicitation-workflow', 'RFC 0020 §A point 3', 'JSON-RPC envelope MUST 200')).toBe(200);
     const dispatched = !!r.body.result || (!!r.body.error && r.body.error.code !== -32601);
     expect(
       dispatched,
-      driver.describe(
+      req('openwop.it.mcp-server-elicitation-bridge.elicitation-create-bridges-into-a-handle-elicitation-workflow', 
         'RFC 0020 §A point 3',
         'elicitation/create MUST dispatch to handle-elicitation workflow (not return method_not_found)',
       ),
@@ -88,7 +89,7 @@ describe('mcp-server-elicitation-bridge: behavioral (RFC 0020 §A point 3)', ()
       const result = r.body.result as { action?: string };
       expect(
         ['pending', 'accept', 'decline', 'cancel'].includes(result.action ?? ''),
-        'elicitation response action MUST be one of {pending,accept,decline,cancel}',
+        req('openwop.it.mcp-server-elicitation-bridge.elicitation-create-bridges-into-a-handle-elicitation-workflow', 'RFC 0020 §A point 3', 'elicitation response action MUST be one of {pending,accept,decline,cancel}'),
       ).toBe(true);
     }
   });

package/src/scenarios/mcp-server-prompt-roundtrip.test.ts

@@ -9,8 +9,9 @@
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { discoveryFamilies } from '../lib/discovery-capabilities.js';
-import { seamAbsent } from '../lib/soft-skip.js';
+import { seamAbsent, softSkip } from '../lib/soft-skip.js';
 import { mcpServerMount } from '../lib/mcp-mount.js';
+import { req } from '../lib/requirement-ids.js';
 
 interface DiscoveryDoc {
   capabilities?: Record<string, unknown>;
@@ -27,9 +28,9 @@ async function readCap(): Promise<Record<string, unknown> | null> {
 
 async function rpc(method: string, params?: Record<string, unknown>) {
   const id = Math.floor(Math.random() * 1e6);
-  const req: Record<string, unknown> = { jsonrpc: '2.0', id, method };
-  if (params !== undefined) req.params = params;
-  const res = await driver.post(await mcpServerMount(), req);
+  const reqBody: Record<string, unknown> = { jsonrpc: '2.0', id, method };
+  if (params !== undefined) reqBody.params = params;
+  const res = await driver.post(await mcpServerMount(), reqBody);
   return { status: res.status, body: res.json as { result?: unknown; error?: { code: number; message: string } } };
 }
 
@@ -56,28 +57,28 @@ async function registerPromptWorkflow(): Promise<boolean> {
 describe('mcp-server-prompt-roundtrip: advertisement shape (RFC 0020)', () => {
   it('capabilities.mcp.serverMount is either absent or a well-formed object', async () => {
     const cap = await readCap();
-    if (cap === null) return;
-    expect(typeof cap.supported).toBe('boolean');
+    if (cap === null) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `cap === null` returned early');
+    expect(typeof cap.supported, req('openwop.it.mcp-server-prompt-roundtrip.capabilities-mcp-servermount-is-either-absent-or-a-well-formed-object', 'RFC 0020 §A', 'capabilities.mcp.serverMount is either absent or a well-formed object')).toBe('boolean');
   });
 });
 
 describe('mcp-server-prompt-roundtrip: behavioral (RFC 0020)', () => {
   it('prompts/list returns the exposed prompt and prompts/get returns messages', async () => {
     const cap = await readCap();
-    if (!cap || cap.supported !== true) return;
-    if (!(await registerPromptWorkflow())) return;
+    if (!cap || cap.supported !== true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!cap || cap.supported !== true` returned early');
+    if (!(await registerPromptWorkflow())) return softSkip('blocked', 'precondition not met — `!(await registerPromptWorkflow())` returned early (seam, prior step, or fixture unavailable)');
 
     const list = await rpc('prompts/list');
     if (list.status === 404) return seamAbsent(`host advertises an MCP server mount but the mount (capabilities.mcp.serverUrls[0], else /v1/host/sample/mcp) answered ${list.status} — RFC 0153 §B is unobservable at the path the host itself advertised`);
     const prompts = (list.body.result as { prompts?: Array<{ name: string }> } | undefined)?.prompts ?? [];
     expect(
       prompts.find((p) => p.name === PROMPT_NAME),
-      driver.describe('RFC 0020 §A', 'prompts/list MUST include exposed prompts'),
+      req('openwop.it.mcp-server-prompt-roundtrip.prompts-list-returns-the-exposed-prompt-and-prompts-get-returns-messages', 'RFC 0020 §A', 'prompts/list MUST include exposed prompts'),
     ).toBeDefined();
 
     const get = await rpc('prompts/get', { name: PROMPT_NAME, arguments: { topic: 'openwop' } });
     expect(get.status).toBe(200);
     const messages = (get.body.result as { messages?: Array<{ role: string }> } | undefined)?.messages;
-    expect(Array.isArray(messages), 'prompts/get MUST return messages[]').toBe(true);
+    expect(Array.isArray(messages), req('openwop.it.mcp-server-prompt-roundtrip.prompts-list-returns-the-exposed-prompt-and-prompts-get-returns-messages', 'RFC 0020 §A', 'prompts/get MUST return messages[]')).toBe(true);
   });
 });

package/src/scenarios/mcp-server-resource-roundtrip.test.ts

@@ -11,8 +11,9 @@
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { discoveryFamilies } from '../lib/discovery-capabilities.js';
-import { seamAbsent } from '../lib/soft-skip.js';
+import { seamAbsent, softSkip } from '../lib/soft-skip.js';
 import { mcpServerMount } from '../lib/mcp-mount.js';
+import { req } from '../lib/requirement-ids.js';
 
 interface DiscoveryDoc {
   capabilities?: Record<string, unknown>;
@@ -29,9 +30,9 @@ async function readCap(): Promise<Record<string, unknown> | null> {
 
 async function rpc(method: string, params?: Record<string, unknown>) {
   const id = Math.floor(Math.random() * 1e6);
-  const req: Record<string, unknown> = { jsonrpc: '2.0', id, method };
-  if (params !== undefined) req.params = params;
-  const res = await driver.post(await mcpServerMount(), req);
+  const reqBody: Record<string, unknown> = { jsonrpc: '2.0', id, method };
+  if (params !== undefined) reqBody.params = params;
+  const res = await driver.post(await mcpServerMount(), reqBody);
   return { status: res.status, body: res.json as { result?: unknown; error?: { code: number; message: string } } };
 }
 
@@ -58,28 +59,28 @@ async function registerResourceWorkflow(): Promise<boolean> {
 describe('mcp-server-resource-roundtrip: advertisement shape (RFC 0020)', () => {
   it('capabilities.mcp.serverMount is either absent or a well-formed object', async () => {
     const cap = await readCap();
-    if (cap === null) return;
-    expect(typeof cap.supported, 'mcp.serverMount.supported MUST be boolean').toBe('boolean');
+    if (cap === null) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `cap === null` returned early');
+    expect(typeof cap.supported, req('openwop.it.mcp-server-resource-roundtrip.capabilities-mcp-servermount-is-either-absent-or-a-well-formed-object', 'RFC 0020 §A', 'mcp.serverMount.supported MUST be boolean')).toBe('boolean');
   });
 });
 
 describe('mcp-server-resource-roundtrip: behavioral (RFC 0020)', () => {
   it('resources/list returns the exposed resource and resources/read returns content', async () => {
     const cap = await readCap();
-    if (!cap || cap.supported !== true) return;
-    if (!(await registerResourceWorkflow())) return;
+    if (!cap || cap.supported !== true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!cap || cap.supported !== true` returned early');
+    if (!(await registerResourceWorkflow())) return softSkip('blocked', 'precondition not met — `!(await registerResourceWorkflow())` returned early (seam, prior step, or fixture unavailable)');
 
     const list = await rpc('resources/list');
     if (list.status === 404) return seamAbsent(`host advertises an MCP server mount but the mount (capabilities.mcp.serverUrls[0], else /v1/host/sample/mcp) answered ${list.status} — RFC 0153 §B is unobservable at the path the host itself advertised`);
     const resources = (list.body.result as { resources?: Array<{ uri: string }> } | undefined)?.resources ?? [];
     expect(
       resources.find((r) => r.uri === RESOURCE_URI),
-      driver.describe('RFC 0020 §A', 'resources/list MUST include exposed resources'),
+      req('openwop.it.mcp-server-resource-roundtrip.resources-list-returns-the-exposed-resource-and-resources-read-returns-content', 'RFC 0020 §A', 'resources/list MUST include exposed resources'),
     ).toBeDefined();
 
     const read = await rpc('resources/read', { uri: RESOURCE_URI });
     expect(read.status).toBe(200);
     const contents = (read.body.result as { contents?: Array<{ uri: string }> } | undefined)?.contents;
-    expect(Array.isArray(contents), 'resources/read MUST return contents[]').toBe(true);
+    expect(Array.isArray(contents), req('openwop.it.mcp-server-resource-roundtrip.resources-list-returns-the-exposed-resource-and-resources-read-returns-content', 'RFC 0020 §A', 'resources/read MUST return contents[]')).toBe(true);
   });
 });

package/src/scenarios/mcp-server-sampling-bridge.test.ts

@@ -17,8 +17,9 @@
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { discoveryFamilies } from '../lib/discovery-capabilities.js';
-import { seamAbsent } from '../lib/soft-skip.js';
+import { seamAbsent, softSkip } from '../lib/soft-skip.js';
 import { mcpServerMount } from '../lib/mcp-mount.js';
+import { req } from '../lib/requirement-ids.js';
 
 interface DiscoveryDoc {
   capabilities?: Record<string, unknown>;
@@ -35,9 +36,9 @@ async function readCap(): Promise<Record<string, unknown> | null> {
 
 async function rpc(method: string, params?: Record<string, unknown>) {
   const id = Math.floor(Math.random() * 1e6);
-  const req: Record<string, unknown> = { jsonrpc: '2.0', id, method };
-  if (params !== undefined) req.params = params;
-  const res = await driver.post(await mcpServerMount(), req);
+  const reqBody: Record<string, unknown> = { jsonrpc: '2.0', id, method };
+  if (params !== undefined) reqBody.params = params;
+  const res = await driver.post(await mcpServerMount(), reqBody);
   return { status: res.status, body: res.json as { result?: unknown; error?: { code: number; message: string } } };
 }
 
@@ -54,11 +55,11 @@ async function registerSamplingHandlerWorkflow(): Promise<boolean> {
 describe('mcp-server-sampling-bridge: advertisement shape (RFC 0020)', () => {
   it('samplingBridge is a boolean when serverMount.supported', async () => {
     const cap = await readCap();
-    if (!cap || cap.supported !== true) return;
-    if (cap.samplingBridge === undefined) return;
+    if (!cap || cap.supported !== true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!cap || cap.supported !== true` returned early');
+    if (cap.samplingBridge === undefined) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `cap.samplingBridge === undefined` returned early');
     expect(
       typeof cap.samplingBridge,
-      driver.describe('RFC 0020 §B', 'mcp.serverMount.samplingBridge MUST be boolean when present'),
+      req('openwop.it.mcp-server-sampling-bridge.samplingbridge-is-a-boolean-when-servermount-supported', 'RFC 0020 §B', 'mcp.serverMount.samplingBridge MUST be boolean when present'),
     ).toBe('boolean');
   });
 });
@@ -66,19 +67,19 @@ describe('mcp-server-sampling-bridge: advertisement shape (RFC 0020)', () => {
 describe('mcp-server-sampling-bridge: behavioral (RFC 0020 §A point 3)', () => {
   it('sampling/createMessage bridges into a handle-sampling workflow', async () => {
     const cap = await readCap();
-    if (!cap || cap.supported !== true || cap.samplingBridge !== true) return;
-    if (!(await registerSamplingHandlerWorkflow())) return;
+    if (!cap || cap.supported !== true || cap.samplingBridge !== true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!cap || cap.supported !== true || cap.samplingBridge !== true` returned early');
+    if (!(await registerSamplingHandlerWorkflow())) return softSkip('blocked', 'precondition not met — `!(await registerSamplingHandlerWorkflow())` returned early (seam, prior step, or fixture unavailable)');
 
     const r = await rpc('sampling/createMessage', {
       messages: [{ role: 'user', content: { type: 'text', text: 'ping' } }],
       maxTokens: 16,
     });
     if (r.status === 404) return seamAbsent(`host advertises an MCP server mount but the mount (capabilities.mcp.serverUrls[0], else /v1/host/sample/mcp) answered ${r.status} — RFC 0153 §B is unobservable at the path the host itself advertised`);
-    expect(r.status, 'JSON-RPC envelope MUST 200').toBe(200);
+    expect(r.status, req('openwop.it.mcp-server-sampling-bridge.sampling-createmessage-bridges-into-a-handle-sampling-workflow', 'RFC 0020 §A point 3', 'JSON-RPC envelope MUST 200')).toBe(200);
     const dispatched = !!r.body.result || (!!r.body.error && r.body.error.code !== -32601);
     expect(
       dispatched,
-      driver.describe(
+      req('openwop.it.mcp-server-sampling-bridge.sampling-createmessage-bridges-into-a-handle-sampling-workflow', 
         'RFC 0020 §A point 3',
         'sampling/createMessage MUST dispatch to handle-sampling workflow (not return method_not_found)',
       ),

package/src/scenarios/mcp-server-tool-roundtrip.test.ts

@@ -15,8 +15,9 @@
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { discoveryFamilies } from '../lib/discovery-capabilities.js';
-import { seamAbsent } from '../lib/soft-skip.js';
+import { seamAbsent, softSkip } from '../lib/soft-skip.js';
 import { mcpServerMount } from '../lib/mcp-mount.js';
+import { req } from '../lib/requirement-ids.js';
 
 interface DiscoveryDoc {
   capabilities?: Record<string, unknown>;
@@ -33,9 +34,9 @@ async function readCap(): Promise<Record<string, unknown> | null> {
 
 async function rpc(method: string, params?: Record<string, unknown>): Promise<{ status: number; body: { result?: unknown; error?: { code: number; message: string } } }> {
   const id = Math.floor(Math.random() * 1e6);
-  const req: Record<string, unknown> = { jsonrpc: '2.0', id, method };
-  if (params !== undefined) req.params = params;
-  const res = await driver.post(await mcpServerMount(), req);
+  const reqBody: Record<string, unknown> = { jsonrpc: '2.0', id, method };
+  if (params !== undefined) reqBody.params = params;
+  const res = await driver.post(await mcpServerMount(), reqBody);
   return { status: res.status, body: res.json as { result?: unknown; error?: { code: number; message: string } } };
 }
 
@@ -67,10 +68,10 @@ async function registerToolWorkflow(): Promise<boolean> {
 describe('mcp-server-tool-roundtrip: advertisement shape (RFC 0020)', () => {
   it('capabilities.mcp.serverMount is either absent or a well-formed object', async () => {
     const cap = await readCap();
-    if (cap === null) return;
+    if (cap === null) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `cap === null` returned early');
     expect(
       typeof cap.supported,
-      driver.describe(
+      req('openwop.it.mcp-server-tool-roundtrip.capabilities-mcp-servermount-is-either-absent-or-a-well-formed-object', 
         'capabilities.schema.json §mcp.serverMount',
         'capabilities.mcp.serverMount.supported MUST be a boolean when present',
       ),
@@ -81,30 +82,30 @@ describe('mcp-server-tool-roundtrip: advertisement shape (RFC 0020)', () => {
 describe('mcp-server-tool-roundtrip: behavioral (RFC 0020 §A points 1-2)', () => {
   it('tools/list returns the exposed workflow + tools/call returns a CallToolResult', async () => {
     const cap = await readCap();
-    if (!cap || cap.supported !== true) return;
+    if (!cap || cap.supported !== true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!cap || cap.supported !== true` returned early');
     const registered = await registerToolWorkflow();
-    if (!registered) return; // host doesn't expose workflow registration
+    if (!registered) return softSkip('blocked', 'precondition not met — `!registered` returned early (host doesn\'t expose workflow registration) (seam, prior step, or fixture unavailable)'); // host doesn't expose workflow registration
 
     const list = await rpc('tools/list');
     if (list.status === 404) return seamAbsent(`host advertises an MCP server mount but the mount (capabilities.mcp.serverUrls[0], else /v1/host/sample/mcp) answered ${list.status} — RFC 0153 §B is unobservable at the path the host itself advertised`);
-    expect(list.status, 'tools/list MUST 200').toBe(200);
+    expect(list.status, req('openwop.it.mcp-server-tool-roundtrip.tools-list-returns-the-exposed-workflow-tools-call-returns-a-calltoolresult', 'RFC 0020 §A point 2', 'tools/list MUST 200')).toBe(200);
     const tools = (list.body.result as { tools?: Array<{ name: string }> } | undefined)?.tools ?? [];
     const found = tools.find((t) => t.name === TEST_TOOL_NAME);
     expect(
       found,
-      driver.describe(
+      req('openwop.it.mcp-server-tool-roundtrip.tools-list-returns-the-exposed-workflow-tools-call-returns-a-calltoolresult', 
         'RFC 0020 §A point 2',
         'tools/list MUST include workflows exposed via core.openwop.mcp.expose-tool',
       ),
     ).toBeDefined();
 
     const call = await rpc('tools/call', { name: TEST_TOOL_NAME, arguments: { text: 'hello' } });
-    expect(call.status, 'tools/call MUST 200').toBe(200);
+    expect(call.status, req('openwop.it.mcp-server-tool-roundtrip.tools-list-returns-the-exposed-workflow-tools-call-returns-a-calltoolresult', 'RFC 0020 §A point 2', 'tools/call MUST 200')).toBe(200);
     const result = call.body.result as { content?: Array<{ type: string }>; isError?: boolean } | undefined;
     expect(
       Array.isArray(result?.content),
-      driver.describe('RFC 0020 §C', 'CallToolResult MUST contain content[]'),
+      req('openwop.it.mcp-server-tool-roundtrip.tools-list-returns-the-exposed-workflow-tools-call-returns-a-calltoolresult', 'RFC 0020 §C', 'CallToolResult MUST contain content[]'),
     ).toBe(true);
-    expect(typeof result?.isError, 'CallToolResult.isError MUST be boolean').toBe('boolean');
+    expect(typeof result?.isError, req('openwop.it.mcp-server-tool-roundtrip.tools-list-returns-the-exposed-workflow-tools-call-returns-a-calltoolresult', 'RFC 0020 §C', 'CallToolResult.isError MUST be boolean')).toBe('boolean');
   });
 });

package/src/scenarios/mcp-server-untrusted-args.test.ts

@@ -13,8 +13,9 @@
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { discoveryFamilies } from '../lib/discovery-capabilities.js';
-import { seamAbsent } from '../lib/soft-skip.js';
+import { seamAbsent, softSkip } from '../lib/soft-skip.js';
 import { mcpServerMount } from '../lib/mcp-mount.js';
+import { req } from '../lib/requirement-ids.js';
 
 interface DiscoveryDoc {
   capabilities?: Record<string, unknown>;
@@ -31,9 +32,9 @@ async function readCap(): Promise<Record<string, unknown> | null> {
 
 async function rpc(method: string, params?: Record<string, unknown>) {
   const id = Math.floor(Math.random() * 1e6);
-  const req: Record<string, unknown> = { jsonrpc: '2.0', id, method };
-  if (params !== undefined) req.params = params;
-  const res = await driver.post(await mcpServerMount(), req);
+  const reqBody: Record<string, unknown> = { jsonrpc: '2.0', id, method };
+  if (params !== undefined) reqBody.params = params;
+  const res = await driver.post(await mcpServerMount(), reqBody);
   return { status: res.status, body: res.json as { result?: unknown; error?: { code: number; message: string; data?: unknown } } };
 }
 
@@ -65,36 +66,36 @@ async function registerStrictWorkflow(): Promise<boolean> {
 describe('mcp-server-untrusted-args: advertisement shape (RFC 0020)', () => {
   it('capabilities.mcp.serverMount is well-formed when present', async () => {
     const cap = await readCap();
-    if (cap === null) return;
-    expect(typeof cap.supported).toBe('boolean');
+    if (cap === null) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `cap === null` returned early');
+    expect(typeof cap.supported, req('openwop.it.mcp-server-untrusted-args.capabilities-mcp-servermount-is-well-formed-when-present', 'RFC 0020 §D', 'capabilities.mcp.serverMount is well-formed when present')).toBe('boolean');
   });
 });
 
 describe('mcp-server-untrusted-args: behavioral (RFC 0020 §D)', () => {
   it('tools/call with malformed arguments is rejected with JSON-RPC -32602 BEFORE workflow start', async () => {
     const cap = await readCap();
-    if (!cap || cap.supported !== true) return;
-    if (!(await registerStrictWorkflow())) return;
+    if (!cap || cap.supported !== true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!cap || cap.supported !== true` returned early');
+    if (!(await registerStrictWorkflow())) return softSkip('blocked', 'precondition not met — `!(await registerStrictWorkflow())` returned early (seam, prior step, or fixture unavailable)');
 
     const r = await rpc('tools/call', {
       name: TEST_TOOL_NAME,
       arguments: { wrongField: 'no' },
     });
     if (r.status === 404) return seamAbsent(`host advertises an MCP server mount but the mount (capabilities.mcp.serverUrls[0], else /v1/host/sample/mcp) answered ${r.status} — RFC 0153 §B is unobservable at the path the host itself advertised`);
-    expect(r.status, 'JSON-RPC envelope MUST 200').toBe(200);
+    expect(r.status, req('openwop.it.mcp-server-untrusted-args.tools-call-with-malformed-arguments-is-rejected-with-json-rpc-32602-before-workf', 'SECURITY/invariants.yaml mcp-server-untrusted-args', 'JSON-RPC envelope MUST 200')).toBe(200);
     expect(
       r.body.error?.code,
-      driver.describe(
+      req('openwop.it.mcp-server-untrusted-args.tools-call-with-malformed-arguments-is-rejected-with-json-rpc-32602-before-workf', 
         'SECURITY/invariants.yaml mcp-server-untrusted-args',
         'malformed arguments MUST be rejected with -32602 invalid params before workflow start',
       ),
     ).toBe(-32602);
-    expect(r.body.error?.data, 'error.data MUST carry validation violations').toBeDefined();
+    expect(r.body.error?.data, req('openwop.it.mcp-server-untrusted-args.tools-call-with-malformed-arguments-is-rejected-with-json-rpc-32602-before-workf', 'SECURITY/invariants.yaml mcp-server-untrusted-args', 'error.data MUST carry validation violations')).toBeDefined();
   });
 
   it('tools/call with valid arguments is accepted', async () => {
     const cap = await readCap();
-    if (!cap || cap.supported !== true) return;
+    if (!cap || cap.supported !== true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!cap || cap.supported !== true` returned early');
     const r = await rpc('tools/call', {
       name: TEST_TOOL_NAME,
       arguments: { text: 'hello' },
@@ -102,7 +103,7 @@ describe('mcp-server-untrusted-args: behavioral (RFC 0020 §D)', () => {
     if (r.status === 404) return seamAbsent(`host advertises an MCP server mount but the mount (capabilities.mcp.serverUrls[0], else /v1/host/sample/mcp) answered ${r.status} — RFC 0153 §B is unobservable at the path the host itself advertised`);
     expect(r.status).toBe(200);
     if (r.body.error) {
-      expect(r.body.error.code, 'valid args MUST NOT trigger -32602').not.toBe(-32602);
+      expect(r.body.error.code, req('openwop.it.mcp-server-untrusted-args.tools-call-with-valid-arguments-is-accepted', 'RFC 0020 §D', 'valid args MUST NOT trigger -32602')).not.toBe(-32602);
     }
   });
 });

package/src/scenarios/mcp-stateless-request.test.ts

@@ -24,6 +24,7 @@ import { mcpServerMount } from '../lib/mcp-mount.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 import { softSkip, seamAbsent } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
 
 const PROFILE = 'mcp-2026-07-28';
 const META_V = 'io.modelcontextprotocol/protocolVersion';
@@ -52,12 +53,12 @@ describe.skipIf(!process.env.OPENWOP_BASE_URL)('RFC 0153 §B — mcp-header-body
     // (a) Mcp-Method header disagrees with the JSON-RPC method
     const m = await driver.post(await mcpServerMount(), { jsonrpc: '2.0', id: 1, method: 'tools/list', params: { _meta: meta } }, { headers: { 'MCP-Protocol-Version': '2026-07-28', 'Mcp-Method': 'resources/list' } });
     if (m.status === 404 || m.status === 403) return softSkip('blocked', `MCP server mount /v1/host/sample/mcp answered ${m.status}`);
-    expect(m.status, driver.describe('mcp-integration.md §B', 'Mcp-Method MUST equal the body method; disagreement MUST be refused 400 (mcp-header-body-consistent)')).toBe(400);
-    expect((m.json as { error?: { code?: number } }).error?.code, driver.describe('mcp-integration.md §B', 'the refusal is HeaderMismatchError -32020')).toBe(-32020);
+    expect(m.status, req('openwop.it.mcp-stateless-request.mcp-method-body-method-and-mcp-name-params-name-are-refused-400-32020-headermism', 'mcp-integration.md §B', 'Mcp-Method MUST equal the body method; disagreement MUST be refused 400 (mcp-header-body-consistent)')).toBe(400);
+    expect((m.json as { error?: { code?: number } }).error?.code, req('openwop.it.mcp-stateless-request.mcp-method-body-method-and-mcp-name-params-name-are-refused-400-32020-headermism', 'mcp-integration.md §B', 'the refusal is HeaderMismatchError -32020')).toBe(-32020);
     // (b) Mcp-Name header disagrees with params.name on tools/call
     const n = await driver.post(await mcpServerMount(), { jsonrpc: '2.0', id: 2, method: 'tools/call', params: { name: 'echo', arguments: {}, _meta: meta } }, { headers: { 'MCP-Protocol-Version': '2026-07-28', 'Mcp-Method': 'tools/call', 'Mcp-Name': 'not-echo' } });
-    expect(n.status, driver.describe('mcp-integration.md §B', 'Mcp-Name MUST equal params.name; disagreement MUST be refused 400 (mcp-header-body-consistent)')).toBe(400);
-    expect((n.json as { error?: { code?: number } }).error?.code, driver.describe('mcp-integration.md §B', 'the refusal is HeaderMismatchError -32020')).toBe(-32020);
+    expect(n.status, req('openwop.it.mcp-stateless-request.mcp-method-body-method-and-mcp-name-params-name-are-refused-400-32020-headermism', 'mcp-integration.md §B', 'Mcp-Name MUST equal params.name; disagreement MUST be refused 400 (mcp-header-body-consistent)')).toBe(400);
+    expect((n.json as { error?: { code?: number } }).error?.code, req('openwop.it.mcp-stateless-request.mcp-method-body-method-and-mcp-name-params-name-are-refused-400-32020-headermism', 'mcp-integration.md §B', 'the refusal is HeaderMismatchError -32020')).toBe(-32020);
   });
 });
 
@@ -66,13 +67,13 @@ describe.skipIf(!process.env.OPENWOP_BASE_URL)('RFC 0153 §B — mcp-stateless-r
     if (!behaviorGate(PROFILE, await claimsCurrent())) return;
     const a = await list();
     if (a.status === 404 || a.status === 403) return seamAbsent(`host advertises an MCP server mount but the mount (capabilities.mcp.serverUrls[0], else /v1/host/sample/mcp) answered ${a.status} — RFC 0153 §B is unobservable at the path the host itself advertised`);
-    expect(a.status, driver.describe('mcp-integration.md §B', 'a core request MUST succeed without a prior initialize or a session header')).toBe(200);
-    expect(a.body.error, driver.describe('mcp-integration.md §B', `stateless tools/list MUST NOT error: ${JSON.stringify(a.body.error)}`)).toBeUndefined();
-    expect(a.body.result?.resultType, driver.describe('mcp-integration.md §B', 'every current-revision result carries resultType')).toBe('complete');
-    expect(typeof a.body.result?.ttlMs, driver.describe('mcp-integration.md §D', 'tools/list MUST carry ttlMs (>= 0)')).toBe('number');
+    expect(a.status, req('openwop.it.mcp-stateless-request.tools-list-succeeds-with-no-initialize-and-no-session-result-carries-resulttype', 'mcp-integration.md §B', 'a core request MUST succeed without a prior initialize or a session header')).toBe(200);
+    expect(a.body.error, req('openwop.it.mcp-stateless-request.tools-list-succeeds-with-no-initialize-and-no-session-result-carries-resulttype', 'mcp-integration.md §B', `stateless tools/list MUST NOT error: ${JSON.stringify(a.body.error)}`)).toBeUndefined();
+    expect(a.body.result?.resultType, req('openwop.it.mcp-stateless-request.tools-list-succeeds-with-no-initialize-and-no-session-result-carries-resulttype', 'mcp-integration.md §B', 'every current-revision result carries resultType')).toBe('complete');
+    expect(typeof a.body.result?.ttlMs, req('openwop.it.mcp-stateless-request.tools-list-succeeds-with-no-initialize-and-no-session-result-carries-resulttype', 'mcp-integration.md §D', 'tools/list MUST carry ttlMs (>= 0)')).toBe('number');
     expect((a.body.result?.ttlMs ?? -1) >= 0).toBe(true);
-    expect(['public', 'private'], driver.describe('mcp-integration.md §D', 'cacheScope MUST be public|private')).toContain(a.body.result?.cacheScope);
+    expect(['public', 'private'], req('openwop.it.mcp-stateless-request.tools-list-succeeds-with-no-initialize-and-no-session-result-carries-resulttype', 'mcp-integration.md §D', 'cacheScope MUST be public|private')).toContain(a.body.result?.cacheScope);
     const b = await list();
-    expect(JSON.stringify(b.body.result?.tools), driver.describe('mcp-integration.md §B', 'list results MUST NOT vary per connection — two independent requests from the same caller MUST agree')).toBe(JSON.stringify(a.body.result?.tools));
+    expect(JSON.stringify(b.body.result?.tools), req('openwop.it.mcp-stateless-request.tools-list-succeeds-with-no-initialize-and-no-session-result-carries-resulttype', 'mcp-integration.md §B', 'list results MUST NOT vary per connection — two independent requests from the same caller MUST agree')).toBe(JSON.stringify(a.body.result?.tools));
   });
 });

package/src/scenarios/mcp-tool-roundtrip.test.ts

@@ -66,6 +66,7 @@ import { driver } from '../lib/driver.js';
 import { getMcpFakeServer } from '../lib/mcp-fake-server.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { pollUntilTerminal } from '../lib/polling.js';
+import { req } from '../lib/requirement-ids.js';
 
 /**
  * Callback-shaped: the host issues MCP JSON-RPC calls to the suite's fake server.
@@ -210,7 +211,7 @@ describe('mcp-tool-roundtrip: server wire shape', () => {
       },
       1,
     );
-    expect(init.status).toBe(200);
+    expect(init.status, req('openwop.it.mcp-tool-roundtrip.initialize-tools-list-tools-call-round-trip-per-mcp-json-rpc-contract', 'spec/v1/mcp-integration.md', 'initialize + tools/list + tools/call round-trip per MCP JSON-RPC contract')).toBe(200);
     const initResult = (init.json.result ?? {}) as { protocolVersion?: string };
     expect(typeof initResult.protocolVersion).toBe('string');
     // Capture session id from initialize so real SDK-based servers can
@@ -310,7 +311,7 @@ describe('mcp-tool-roundtrip: host-mediated tool invocation', () => {
 
     const invocations = server.invocations();
     const toolCalls = invocations.filter((i) => i.method === 'tools/call');
-    expect(toolCalls.length, driver.describe(
+    expect(toolCalls.length, req('openwop.it.mcp-tool-roundtrip.host-invokes-the-configured-mcp-server-and-surfaces-the-tool-response-in-the-eve', 
       'mcp-integration.md §"Tool invocation"',
       'host MUST invoke `tools/call` on the configured MCP server during the fixture run',
     )).toBeGreaterThan(0);
@@ -325,7 +326,7 @@ describe('mcp-tool-roundtrip: host-mediated tool invocation', () => {
     const events = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/events`);
     const list = (events.json as { events?: Array<{ type: string; payload?: unknown }> }).events ?? [];
     const haystack = JSON.stringify(list).toLowerCase();
-    expect(haystack.includes('echo'), driver.describe(
+    expect(haystack.includes('echo'), req('openwop.it.mcp-tool-roundtrip.host-invokes-the-configured-mcp-server-and-surfaces-the-tool-response-in-the-eve', 
       'mcp-integration.md + threat-model-prompt-injection.md §"UNTRUSTED marker"',
       'host event log MUST surface the MCP tool invocation so observers can audit the trust boundary',
     )).toBe(true);