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

package/src/scenarios/localized-content-delivery.test.ts

@@ -32,11 +32,9 @@ import { join } from 'node:path';
 import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
 import { SCHEMAS_DIR } from '../lib/paths.js';
-import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
-
-const why = (specRef: string, requirement: string): string => `${specRef} — ${requirement}`;
+import { req } from '../lib/requirement-ids.js';
 function loadSchema(name: string): Record<string, unknown> {
   return JSON.parse(readFileSync(join(SCHEMAS_DIR, name), 'utf8')) as Record<string, unknown>;
 }
@@ -90,12 +88,12 @@ describe('localized-content: capability advertisement shape (localized-content.m
   it('capabilities schema declares content with its required fields', () => {
     const caps = loadSchema('capabilities.schema.json');
     const content = (caps.properties as Record<string, { required?: string[]; properties?: Record<string, unknown> }>).content;
-    expect(content, why('capabilities.schema.json §content', 'the content block MUST be declared')).toBeDefined();
-    expect(content?.required, why('localized-content.md §A', 'supported + baseLocale + supportedLocales MUST be required')).toEqual(
+    expect(content, req('openwop.it.localized-content-delivery.capabilities-schema-declares-content-with-its-required-fields', 'capabilities.schema.json §content', 'the content block MUST be declared')).toBeDefined();
+    expect(content?.required, req('openwop.it.localized-content-delivery.capabilities-schema-declares-content-with-its-required-fields', 'localized-content.md §A', 'supported + baseLocale + supportedLocales MUST be required')).toEqual(
       expect.arrayContaining(['supported', 'baseLocale', 'supportedLocales']),
     );
     for (const f of ['supported', 'baseLocale', 'supportedLocales']) {
-      expect(content?.properties?.[f], why('localized-content.md §A', `content.${f} MUST be declared`)).toBeDefined();
+      expect(content?.properties?.[f], req('openwop.it.localized-content-delivery.capabilities-schema-declares-content-with-its-required-fields', 'localized-content.md §A', `content.${f} MUST be declared`)).toBeDefined();
     }
   });
 });
@@ -119,29 +117,29 @@ describe('localized-content: schema shapes (localized-content.md §B, server-fre
   };
 
   it('a conforming section validates', () => {
-    expect(section(goodSection), why('RFC 0103 §B', `a conforming section MUST validate. Errors: ${JSON.stringify(section.errors)}`)).toBe(true);
+    expect(section(goodSection), req('openwop.it.localized-content-delivery.a-conforming-section-validates', 'RFC 0103 §B', `a conforming section MUST validate. Errors: ${JSON.stringify(section.errors)}`)).toBe(true);
   });
   it('a localizations key with wrong case/underscore is rejected', () => {
-    expect(section({ ...goodSection, localizations: { EN: { heading: 'x' } } }), why('RFC 0103 §B', 'a non-BCP-47-subset key MUST be rejected')).toBe(false);
-    expect(section({ ...goodSection, localizations: { en_US: { heading: 'x' } } }), why('RFC 0103 §B', 'an underscore locale key MUST be rejected')).toBe(false);
+    expect(section({ ...goodSection, localizations: { EN: { heading: 'x' } } }), req('openwop.it.localized-content-delivery.a-localizations-key-with-wrong-case-underscore-is-rejected', 'RFC 0103 §B', 'a non-BCP-47-subset key MUST be rejected')).toBe(false);
+    expect(section({ ...goodSection, localizations: { en_US: { heading: 'x' } } }), req('openwop.it.localized-content-delivery.a-localizations-key-with-wrong-case-underscore-is-rejected', 'RFC 0103 §B', 'an underscore locale key MUST be rejected')).toBe(false);
   });
   it('a section missing a required field is rejected', () => {
     const { status: _omit, ...noStatus } = goodSection;
-    expect(section(noStatus), why('RFC 0103 §B', 'status is REQUIRED')).toBe(false);
+    expect(section(noStatus), req('openwop.it.localized-content-delivery.a-section-missing-a-required-field-is-rejected', 'RFC 0103 §B', 'status is REQUIRED')).toBe(false);
   });
   it('a status outside the enum is rejected', () => {
-    expect(section({ ...goodSection, status: 'archived' }), why('RFC 0103 §B', 'status MUST be draft|published')).toBe(false);
+    expect(section({ ...goodSection, status: 'archived' }), req('openwop.it.localized-content-delivery.a-status-outside-the-enum-is-rejected', 'RFC 0103 §B', 'status MUST be draft|published')).toBe(false);
   });
 
   it('a conforming page validates; a bad slug is rejected', () => {
     const goodPage = { pageId: 'home', slug: 'home', name: 'Home', status: 'published', sectionOrder: ['hero'] };
-    expect(page(goodPage), why('RFC 0103 §B', `a conforming page MUST validate. Errors: ${JSON.stringify(page.errors)}`)).toBe(true);
-    expect(page({ ...goodPage, slug: 'Home Page' }), why('RFC 0103 §B', 'slug MUST match ^[a-z][a-z0-9-]*$')).toBe(false);
+    expect(page(goodPage), req('openwop.it.localized-content-delivery.a-conforming-page-validates-a-bad-slug-is-rejected', 'RFC 0103 §B', `a conforming page MUST validate. Errors: ${JSON.stringify(page.errors)}`)).toBe(true);
+    expect(page({ ...goodPage, slug: 'Home Page' }), req('openwop.it.localized-content-delivery.a-conforming-page-validates-a-bad-slug-is-rejected', 'RFC 0103 §B', 'slug MUST match ^[a-z][a-z0-9-]*$')).toBe(false);
   });
 
   it('a conforming language-settings validates', () => {
     const good = { baseLocale: 'en', supportedLocales: ['es', 'pt-BR', 'fr'], autoTranslateOnPublish: false };
-    expect(settings(good), why('RFC 0103 §B', `settings MUST validate. Errors: ${JSON.stringify(settings.errors)}`)).toBe(true);
+    expect(settings(good), req('openwop.it.localized-content-delivery.a-conforming-language-settings-validates', 'RFC 0103 §B', `settings MUST validate. Errors: ${JSON.stringify(settings.errors)}`)).toBe(true);
   });
 
   it('a conforming page-response validates', () => {
@@ -153,7 +151,7 @@ describe('localized-content: schema shapes (localized-content.md §B, server-fre
       page: { pageId: 'home', slug: 'home', name: 'Home' },
       sections: [{ sectionId: 'hero', sectionType: 'hero', data: { heading: 'Bem-vindo', cta: 'Get started' } }],
     };
-    expect(response(good), why('RFC 0103 §D', `a resolved response MUST validate. Errors: ${JSON.stringify(response.errors)}`)).toBe(true);
+    expect(response(good), req('openwop.it.localized-content-delivery.a-conforming-page-response-validates', 'RFC 0103 §D', `a resolved response MUST validate. Errors: ${JSON.stringify(response.errors)}`)).toBe(true);
   });
 });
 
@@ -164,43 +162,43 @@ describe('localized-content: per-section field merge (localized-content.md §C,
   };
 
   it('exact-locale hit overrides matching fields', () => {
-    expect(resolveSection(section, 'es', 'en'), why('RFC 0103 §C', 'exact hit MUST overlay locale fields onto data')).toEqual({
+    expect(resolveSection(section, 'es', 'en'), req('openwop.it.localized-content-delivery.exact-locale-hit-overrides-matching-fields', 'RFC 0103 §C', 'exact hit MUST overlay locale fields onto data')).toEqual({
       heading: 'Bienvenido',
       cta: 'Empezar',
     });
   });
   it('partial translation falls through to base for missing fields', () => {
-    expect(resolveSection(section, 'pt-BR', 'en'), why('RFC 0103 §C', 'missing locale fields MUST fall through to data')).toEqual({
+    expect(resolveSection(section, 'pt-BR', 'en'), req('openwop.it.localized-content-delivery.partial-translation-falls-through-to-base-for-missing-fields', 'RFC 0103 §C', 'missing locale fields MUST fall through to data')).toEqual({
       heading: 'Bem-vindo',
       cta: 'Get started',
     });
   });
   it('language-family fallback applies when exact tag is absent', () => {
     const s: Section = { data: { h: 'Hi' }, localizations: { pt: { h: 'Oi' } } };
-    expect(resolveSection(s, 'pt-BR', 'en'), why('RFC 0103 §C', 'pt-BR MUST fall back to the pt family override')).toEqual({ h: 'Oi' });
+    expect(resolveSection(s, 'pt-BR', 'en'), req('openwop.it.localized-content-delivery.language-family-fallback-applies-when-exact-tag-is-absent', 'RFC 0103 §C', 'pt-BR MUST fall back to the pt family override')).toEqual({ h: 'Oi' });
   });
   it('unsupported/base locale returns base data unchanged', () => {
-    expect(resolveSection(section, 'de', 'en'), why('RFC 0103 §C', 'no match MUST return base data')).toEqual(section.data);
-    expect(resolveSection(section, 'en', 'en'), why('RFC 0103 §C', 'base locale MUST return base data')).toEqual(section.data);
+    expect(resolveSection(section, 'de', 'en'), req('openwop.it.localized-content-delivery.unsupported-base-locale-returns-base-data-unchanged', 'RFC 0103 §C', 'no match MUST return base data')).toEqual(section.data);
+    expect(resolveSection(section, 'en', 'en'), req('openwop.it.localized-content-delivery.unsupported-base-locale-returns-base-data-unchanged', 'RFC 0103 §C', 'base locale MUST return base data')).toEqual(section.data);
   });
 });
 
 describe('localized-content: §A capability coherence predicate (server-free)', () => {
   const i18n: I18nCap = { supported: true, defaultLocale: 'en', supportedLocales: ['en', 'es', 'pt-BR', 'fr'] };
   it('a coherent advertisement passes', () => {
-    expect(contentCoherent({ supported: true, baseLocale: 'en', supportedLocales: ['es', 'pt-BR', 'fr'] }, i18n), why('RFC 0103 §A', 'a coherent content block MUST pass')).toBe(true);
+    expect(contentCoherent({ supported: true, baseLocale: 'en', supportedLocales: ['es', 'pt-BR', 'fr'] }, i18n), req('openwop.it.localized-content-delivery.a-coherent-advertisement-passes', 'RFC 0103 §A', 'a coherent content block MUST pass')).toBe(true);
   });
   it('content without i18n is incoherent', () => {
-    expect(contentCoherent({ supported: true, baseLocale: 'en', supportedLocales: ['es'] }, { supported: false }), why('RFC 0103 §A.1', 'content requires i18n.supported')).toBe(false);
+    expect(contentCoherent({ supported: true, baseLocale: 'en', supportedLocales: ['es'] }, { supported: false }), req('openwop.it.localized-content-delivery.content-without-i18n-is-incoherent', 'RFC 0103 §A.1', 'content requires i18n.supported')).toBe(false);
   });
   it('baseLocale != i18n.defaultLocale is incoherent', () => {
-    expect(contentCoherent({ supported: true, baseLocale: 'es', supportedLocales: ['fr'] }, i18n), why('RFC 0103 §A.2', 'baseLocale MUST equal i18n.defaultLocale')).toBe(false);
+    expect(contentCoherent({ supported: true, baseLocale: 'es', supportedLocales: ['fr'] }, i18n), req('openwop.it.localized-content-delivery.baselocale-i18n-defaultlocale-is-incoherent', 'RFC 0103 §A.2', 'baseLocale MUST equal i18n.defaultLocale')).toBe(false);
   });
   it('a supportedLocales not ⊆ i18n.supportedLocales is incoherent', () => {
-    expect(contentCoherent({ supported: true, baseLocale: 'en', supportedLocales: ['de'] }, i18n), why('RFC 0103 §A.3', 'content locales MUST be a subset of i18n locales')).toBe(false);
+    expect(contentCoherent({ supported: true, baseLocale: 'en', supportedLocales: ['de'] }, i18n), req('openwop.it.localized-content-delivery.a-supportedlocales-not-i18n-supportedlocales-is-incoherent', 'RFC 0103 §A.3', 'content locales MUST be a subset of i18n locales')).toBe(false);
   });
   it('baseLocale appearing in supportedLocales is incoherent', () => {
-    expect(contentCoherent({ supported: true, baseLocale: 'en', supportedLocales: ['en', 'es'] }, i18n), why('RFC 0103 §A.4', 'baseLocale MUST NOT appear in supportedLocales')).toBe(false);
+    expect(contentCoherent({ supported: true, baseLocale: 'en', supportedLocales: ['en', 'es'] }, i18n), req('openwop.it.localized-content-delivery.baselocale-appearing-in-supportedlocales-is-incoherent', 'RFC 0103 §A.4', 'baseLocale MUST NOT appear in supportedLocales')).toBe(false);
   });
 });
 
@@ -215,7 +213,7 @@ describe.skipIf(HTTP_SKIP)('localized-content: live advertisement coherence (loc
     const i18n = (await readCapabilityFamily<I18nCap>('i18n')) ?? {};
     expect(
       contentCoherent(content!, i18n),
-      driver.describe('localized-content.md §A', 'the advertised content block MUST satisfy the i18n-subset + baseLocale invariants'),
+      req('openwop.it.localized-content-delivery.advertised-content-block-is-coherent-with-the-advertised-i18n-block', 'localized-content.md §A', 'the advertised content block MUST satisfy the i18n-subset + baseLocale invariants'),
     ).toBe(true);
   });
 });

package/src/scenarios/maliciousManifest.test.ts

@@ -35,6 +35,8 @@
 
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 interface RegistryProbe {
   available: boolean;
@@ -57,7 +59,7 @@ async function probeRegistry(): Promise<RegistryProbe> {
 describe('malicious-manifest: pack-name validation per spec/v1/node-packs.md §Naming', () => {
   it('GET /v1/packs/{bad-name}/-/{version}.json returns 400 invalid_pack_name', async () => {
     const probe = await probeRegistry();
-    if (!probe.available) return; // host doesn't claim openwop-node-packs
+    if (!probe.available) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!probe.available` returned early (host doesn\'t claim openwop-node-packs)'); // host doesn't claim openwop-node-packs
 
     // Bad name shapes the registry SHOULD reject:
     //   - Reserved scope without authorization (`core.foo`)
@@ -71,7 +73,7 @@ describe('malicious-manifest: pack-name validation per spec/v1/node-packs.md §N
       );
       expect(
         [400, 404].includes(res.status),
-        driver.describe(
+        req('openwop.it.maliciousManifest.get-v1-packs-bad-name-version-json-returns-400-invalid-pack-name', 
           'spec/v1/node-packs.md §Registry HTTP API',
           `bad pack name "${badName}" MUST yield 400 (invalid_pack_name) or 404 (treated as unknown)`,
         ),
@@ -83,7 +85,7 @@ describe('malicious-manifest: pack-name validation per spec/v1/node-packs.md §N
 describe('malicious-manifest: version validation', () => {
   it('GET /v1/packs/{name}/-/{bad-version}.json returns 400 invalid_version', async () => {
     const probe = await probeRegistry();
-    if (!probe.available) return;
+    if (!probe.available) return softSkip('blocked', 'precondition not met — `!probe.available` returned early (seam, prior step, or fixture unavailable)');
 
     const badVersions = ['not-semver', '1', '1.0.0', 'v1.0'];
 
@@ -93,7 +95,7 @@ describe('malicious-manifest: version validation', () => {
       );
       expect(
         [400, 404].includes(res.status),
-        driver.describe(
+        req('openwop.it.maliciousManifest.get-v1-packs-name-bad-version-json-returns-400-invalid-version', 
           'spec/v1/node-packs.md §Registry HTTP API',
           `bad version "${bad}" MUST yield 400 (invalid_version) or 404`,
         ),
@@ -105,10 +107,10 @@ describe('malicious-manifest: version validation', () => {
 describe('malicious-manifest: signature endpoint contract per openwop/openwop@434c8f2', () => {
   it('GET /v1/packs/{name}/-/{version}.sig of a non-existent pack returns 404 signature_not_available', async () => {
     const probe = await probeRegistry();
-    if (!probe.available) return;
+    if (!probe.available) return softSkip('blocked', 'precondition not met — `!probe.available` returned early (seam, prior step, or fixture unavailable)');
 
     const res = await driver.get('/v1/packs/community.no-such-pack/-/1.0.sig');
-    expect(res.status, driver.describe(
+    expect(res.status, req('openwop.it.maliciousManifest.get-v1-packs-name-version-sig-of-a-non-existent-pack-returns-404-signature-not-a', 
       'spec/v1/node-packs.md §`GET .sig`',
       'missing/yanked/unsigned signature MUST return 404',
     )).toBe(404);
@@ -120,7 +122,7 @@ describe('malicious-manifest: signature endpoint contract per openwop/openwop@43
       // shape; the assertion is permissive on the error code itself
       // but strict on the status.
       if (typeof body.error === 'string') {
-        expect(body.error.length, driver.describe(
+        expect(body.error.length, req('openwop.it.maliciousManifest.get-v1-packs-name-version-sig-of-a-non-existent-pack-returns-404-signature-not-a', 
           'spec/v1/node-packs.md',
           '404 response MUST carry a structured error envelope with a non-empty error code',
         )).toBeGreaterThan(0);
@@ -146,7 +148,7 @@ describe('malicious-manifest: documented error catalog (per openwop/openwop@434c
       'tarball_path_traversal',
       'tarball_tar_parse_failed',
     ] as const;
-    expect(TARBALL_ERRORS.length, driver.describe(
+    expect(TARBALL_ERRORS.length, req('openwop.it.maliciousManifest.lists-are-non-empty-sanity-check-on-doc-drift', 
       'spec/v1/node-packs.md',
       'documented tarball-error catalog is non-empty',
     )).toBe(9);

package/src/scenarios/mcp-2026-07-28-discover.test.ts

@@ -30,6 +30,7 @@ import { mcpServerMount } from '../lib/mcp-mount.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 import { McpFakeServer, MCP_ERR } from '../lib/mcp-fake-server.js';
+import { req } from '../lib/requirement-ids.js';
 
 // The first describe drives the in-process McpFakeServer itself; the second (gated) describe
 // talks to the host's own MCP server mount and hands it nothing harness-hosted.
@@ -58,7 +59,7 @@ describe('RFC 0153 §B — the suite MCP server speaks 2026-07-28 (dual-era McpF
 
   it('server/discover: resultType complete, supportedVersions, capabilities, cache hints, _meta.serverInfo', async () => {
     const r = await call(server.endpoint(), 'server/discover', {}, { version: '2026-07-28', mcpMethod: 'server/discover' });
-    expect(r.error).toBeUndefined();
+    expect(r.error, req('openwop.it.mcp-2026-07-28-discover.server-discover-resulttype-complete-supportedversions-capabilities-cache-hints-m', 'RFC 0153 §B', 'server/discover: resultType complete, supportedVersions, capabilities, cache hints, _meta.serverInfo')).toBeUndefined();
     expect(r.result?.['resultType']).toBe('complete');
     expect(r.result?.['supportedVersions']).toEqual(['2026-07-28', '2025-06-18']);
     expect(typeof r.result?.['ttlMs']).toBe('number');
@@ -68,13 +69,13 @@ describe('RFC 0153 §B — the suite MCP server speaks 2026-07-28 (dual-era McpF
 
   it('a request without _meta.protocolVersion under the current revision is refused -32020', async () => {
     const r = await call(server.endpoint(), 'tools/list', {}, { version: '2026-07-28', withMeta: false });
-    expect(r.status).toBe(400);
+    expect(r.status, req('openwop.it.mcp-2026-07-28-discover.a-request-without-meta-protocolversion-under-the-current-revision-is-refused-320', 'RFC 0153 §B', 'a request without _meta.protocolVersion under the current revision is refused -32020')).toBe(400);
     expect(r.error?.code).toBe(MCP_ERR.HEADER_MISMATCH);
   });
 
   it('header ≠ body revision ⇒ -32020 HeaderMismatch (400); Mcp-Method ≠ method ⇒ -32020', async () => {
     const r1 = await call(server.endpoint(), 'tools/list', { _meta: { [META_V]: '2025-11-25', [META_C]: {} } }, { version: '2026-07-28', withMeta: false });
-    expect(r1.status).toBe(400);
+    expect(r1.status, req('openwop.it.mcp-2026-07-28-discover.header-body-revision-32020-headermismatch-400-mcp-method-method-32020', 'RFC 0153 §B', 'header ≠ body revision ⇒ -32020 HeaderMismatch (400); Mcp-Method ≠ method ⇒ -32020')).toBe(400);
     expect(r1.error?.code).toBe(MCP_ERR.HEADER_MISMATCH);
     const r2 = await call(server.endpoint(), 'tools/list', {}, { version: '2026-07-28', mcpMethod: 'tools/call' });
     expect(r2.error?.code).toBe(MCP_ERR.HEADER_MISMATCH);
@@ -82,7 +83,7 @@ describe('RFC 0153 §B — the suite MCP server speaks 2026-07-28 (dual-era McpF
 
   it('an unsupported revision ⇒ -32022 UnsupportedProtocolVersion with data.supported[] (400)', async () => {
     const r = await call(server.endpoint(), 'tools/list', {}, { version: '1999-01-01' });
-    expect(r.status).toBe(400);
+    expect(r.status, req('openwop.it.mcp-2026-07-28-discover.an-unsupported-revision-32022-unsupportedprotocolversion-with-data-supported-400', 'RFC 0153 §B', 'an unsupported revision ⇒ -32022 UnsupportedProtocolVersion with data.supported[] (400)')).toBe(400);
     expect(r.error?.code).toBe(MCP_ERR.UNSUPPORTED_PROTOCOL_VERSION);
     expect(r.error?.data?.['supported']).toEqual(['2026-07-28', '2025-06-18']);
     expect(r.error?.data?.['requested']).toBe('1999-01-01');
@@ -90,7 +91,7 @@ describe('RFC 0153 §B — the suite MCP server speaks 2026-07-28 (dual-era McpF
 
   it('header-less ⇒ legacy semantics on a dual-era server (initialize works); ⇒ -32022 on a current-only server', async () => {
     const legacy = await call(server.endpoint(), 'initialize', { protocolVersion: '2025-06-18', capabilities: {}, clientInfo: { name: 'x', version: '0' } });
-    expect(legacy.error).toBeUndefined();
+    expect(legacy.error, req('openwop.it.mcp-2026-07-28-discover.header-less-legacy-semantics-on-a-dual-era-server-initialize-works-32022-on-a-cu', 'RFC 0153 §B', 'header-less ⇒ legacy semantics on a dual-era server (initialize works); ⇒ -32022 on a current-only server')).toBeUndefined();
     expect(typeof legacy.result?.['protocolVersion']).toBe('string');
     const only = new McpFakeServer({ protocolVersions: ['2026-07-28'] });
     await only.start(0);
@@ -105,13 +106,13 @@ describe('RFC 0153 §B — the suite MCP server speaks 2026-07-28 (dual-era McpF
 
   it('initialize under 2026-07-28 is method-not-found — the handshake does not exist in this revision', async () => {
     const r = await call(server.endpoint(), 'initialize', {}, { version: '2026-07-28' });
-    expect(r.status).toBe(404);
+    expect(r.status, req('openwop.it.mcp-2026-07-28-discover.initialize-under-2026-07-28-is-method-not-found-the-handshake-does-not-exist-in', 'RFC 0153 §B', 'initialize under 2026-07-28 is method-not-found — the handshake does not exist in this revision')).toBe(404);
     expect(r.error?.code).toBe(-32601);
   });
 
   it('tools/list @2026-07-28 carries resultType + CacheableResult hints and lists the MRTR tool', async () => {
     const r = await call(server.endpoint(), 'tools/list', {}, { version: '2026-07-28', mcpMethod: 'tools/list' });
-    expect(r.result?.['resultType']).toBe('complete');
+    expect(r.result?.['resultType'], req('openwop.it.mcp-2026-07-28-discover.tools-list-2026-07-28-carries-resulttype-cacheableresult-hints-and-lists-the-mrt', 'RFC 0153 §B', 'tools/list @2026-07-28 carries resultType + CacheableResult hints and lists the MRTR tool')).toBe('complete');
     expect(typeof r.result?.['ttlMs']).toBe('number');
     expect(r.result?.['cacheScope']).toBe('public');
     const names = (r.result?.['tools'] as Array<{ name: string }>).map((t) => t.name);
@@ -124,7 +125,7 @@ describe('RFC 0153 §B — the suite MCP server speaks 2026-07-28 (dual-era McpF
   it('MRTR: needs_input answers input_required (elicitation + opaque requestState) and completes on the retry; missing capability ⇒ -32021', async () => {
     server.reset();
     const noCap = await call(server.endpoint(), 'tools/call', { name: 'needs_input', arguments: {} }, { version: '2026-07-28', mcpMethod: 'tools/call', mcpName: 'needs_input' });
-    expect(noCap.error?.code).toBe(MCP_ERR.MISSING_REQUIRED_CLIENT_CAPABILITY);
+    expect(noCap.error?.code, req('openwop.it.mcp-2026-07-28-discover.mrtr-needs-input-answers-input-required-elicitation-opaque-requeststate-and-comp', 'RFC 0153 §B', 'MRTR: needs_input answers input_required (elicitation + opaque requestState) and completes on the retry; missing capability ⇒ -32021')).toBe(MCP_ERR.MISSING_REQUIRED_CLIENT_CAPABILITY);
     expect(noCap.error?.data?.['requiredCapabilities']).toEqual(['elicitation']);
 
     const first = await call(server.endpoint(), 'tools/call', { name: 'needs_input', arguments: {}, _meta: { [META_C]: { elicitation: {} } } }, { version: '2026-07-28', mcpMethod: 'tools/call', mcpName: 'needs_input' });
@@ -182,10 +183,10 @@ describe.skipIf(!process.env.OPENWOP_BASE_URL)('RFC 0153 §B — host as MCP ser
     const caps = (await mcp())!;
     const r = await hostRpc('server/discover', { _meta: { [META_V]: '2026-07-28', [META_C]: {} } }, { 'MCP-Protocol-Version': '2026-07-28', 'Mcp-Method': 'server/discover' });
     if (r.status === 404 || r.status === 403) 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, driver.describe('mcp-integration.md §B', 'server/discover is a server MUST under 2026-07-28')).toBe(200);
+    expect(r.status, req('openwop.it.mcp-2026-07-28-discover.server-discover-reports-supportedversions-equal-to-capabilities-mcp-protocolvers', 'mcp-integration.md §B', 'server/discover is a server MUST under 2026-07-28')).toBe(200);
     expect(r.body.result?.['resultType']).toBe('complete');
-    expect([...((r.body.result?.['supportedVersions'] as string[] | undefined) ?? [])].sort(), driver.describe('mcp-integration.md §B', 'server/discover.supportedVersions MUST equal capabilities.mcp.protocolVersions — two documents, one fact')).toEqual([...(caps.protocolVersions ?? [])].sort());
-    expect(typeof r.body.result?.['ttlMs'], driver.describe('mcp-integration.md §D', 'server/discover is cacheable: ttlMs REQUIRED')).toBe('number');
+    expect([...((r.body.result?.['supportedVersions'] as string[] | undefined) ?? [])].sort(), req('openwop.it.mcp-2026-07-28-discover.server-discover-reports-supportedversions-equal-to-capabilities-mcp-protocolvers', 'mcp-integration.md §B', 'server/discover.supportedVersions MUST equal capabilities.mcp.protocolVersions — two documents, one fact')).toEqual([...(caps.protocolVersions ?? [])].sort());
+    expect(typeof r.body.result?.['ttlMs'], req('openwop.it.mcp-2026-07-28-discover.server-discover-reports-supportedversions-equal-to-capabilities-mcp-protocolvers', 'mcp-integration.md §D', 'server/discover is cacheable: ttlMs REQUIRED')).toBe('number');
     expect(['public', 'private']).toContain(r.body.result?.['cacheScope']);
   });
 
@@ -199,11 +200,11 @@ describe.skipIf(!process.env.OPENWOP_BASE_URL)('RFC 0153 §B — host as MCP ser
     // (mcp-integration.md §B: agreement is checked before selection).
     const mismatch = await hostRpc('tools/list', { _meta: { [META_V]: '2025-06-18', [META_C]: {} } }, { 'MCP-Protocol-Version': '2026-07-28', 'Mcp-Method': 'tools/list' });
     if (mismatch.status === 404 || mismatch.status === 403) return seamAbsent(`host advertises an MCP server mount but the mount (capabilities.mcp.serverUrls[0], else /v1/host/sample/mcp) answered ${mismatch.status} — RFC 0153 §B is unobservable at the path the host itself advertised`);
-    expect(mismatch.status, driver.describe('mcp-integration.md §B', 'header ≠ body MUST be refused 400 (HeaderMismatchError -32020) — fail closed')).toBe(400);
+    expect(mismatch.status, req('openwop.it.mcp-2026-07-28-discover.a-header-body-revision-mismatch-is-refused-400-32020-an-unsupported-revision-400', 'mcp-integration.md §B', 'header ≠ body MUST be refused 400 (HeaderMismatchError -32020) — fail closed')).toBe(400);
     expect(mismatch.body.error?.code).toBe(MCP_ERR.HEADER_MISMATCH);
     const unsupported = await hostRpc('tools/list', { _meta: { [META_V]: '1999-01-01', [META_C]: {} } }, { 'MCP-Protocol-Version': '1999-01-01', 'Mcp-Method': 'tools/list' });
-    expect(unsupported.status, driver.describe('mcp-integration.md §B', 'an unsupported revision MUST be refused 400 (UnsupportedProtocolVersionError -32022)')).toBe(400);
+    expect(unsupported.status, req('openwop.it.mcp-2026-07-28-discover.a-header-body-revision-mismatch-is-refused-400-32020-an-unsupported-revision-400', 'mcp-integration.md §B', 'an unsupported revision MUST be refused 400 (UnsupportedProtocolVersionError -32022)')).toBe(400);
     expect(unsupported.body.error?.code).toBe(MCP_ERR.UNSUPPORTED_PROTOCOL_VERSION);
-    expect(Array.isArray(unsupported.body.error?.data?.['supported']), driver.describe('mcp-integration.md §B', 'the refusal MUST list data.supported[]')).toBe(true);
+    expect(Array.isArray(unsupported.body.error?.data?.['supported']), req('openwop.it.mcp-2026-07-28-discover.a-header-body-revision-mismatch-is-refused-400-32020-an-unsupported-revision-400', 'mcp-integration.md §B', 'the refusal MUST list data.supported[]')).toBe(true);
   });
 });

package/src/scenarios/mcp-cache-tenant-scope.test.ts

@@ -22,10 +22,11 @@
 
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
-import { seamAbsent } from '../lib/soft-skip.js';
+import { seamAbsent, softSkip } from '../lib/soft-skip.js';
 import { mcpServerMount } from '../lib/mcp-mount.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const PROFILE = 'mcp-2026-07-28';
 const META_V = 'io.modelcontextprotocol/protocolVersion';
@@ -49,19 +50,19 @@ describe.skipIf(!process.env.OPENWOP_BASE_URL)('RFC 0153 §D — mcp-cache-tenan
     if (!behaviorGate(PROFILE, await claimsCurrent())) return;
     const mine = await listAs();
     if (mine.status === 404 || mine.status === 403) return seamAbsent(`host advertises an MCP server mount but the mount (capabilities.mcp.serverUrls[0], else /v1/host/sample/mcp) answered ${mine.status} — RFC 0153 §B is unobservable at the path the host itself advertised`);
-    expect(['public', 'private'], driver.describe('mcp-integration.md §D', 'cacheScope MUST be present on tools/list')).toContain(mine.body.result?.cacheScope);
+    expect(['public', 'private'], req('openwop.it.mcp-cache-tenant-scope.a-per-caller-list-is-cachescope-private-a-public-list-is-byte-identical-across-c', 'mcp-integration.md §D', 'cacheScope MUST be present on tools/list')).toContain(mine.body.result?.cacheScope);
     const other = process.env.OPENWOP_TEST_SECONDARY_API_KEY;
     if (!other) {
       // Shape only; the cross-caller half is unobservable without a second credential.
       // eslint-disable-next-line no-console
       console.warn('[mcp-cache-tenant-scope] OPENWOP_TEST_SECONDARY_API_KEY not set — cross-caller half not exercised (blocked)');
-      return;
+      return softSkip('blocked', 'precondition not met — `!other` returned early ([mcp-cache-tenant-scope] OPENWOP_TEST_SECONDARY_API_KEY not set — cross-caller half not exercised (blocked)) (seam, prior step, or fixture unavailable)');
     }
     const theirs = await listAs(other);
-    if (theirs.status !== 200) return;
+    if (theirs.status !== 200) return softSkip('blocked', 'precondition not met — `theirs.status !== 200` returned early (seam, prior step, or fixture unavailable)');
     const same = JSON.stringify(mine.body.result?.tools) === JSON.stringify(theirs.body.result?.tools);
     if (!same) {
-      expect(mine.body.result?.cacheScope, driver.describe('mcp-integration.md §D', 'a list that differs per caller MUST be cacheScope private — a public list that differs is cross-context cache poisoning (mcp-cache-tenant-scoped)')).toBe('private');
+      expect(mine.body.result?.cacheScope, req('openwop.it.mcp-cache-tenant-scope.a-per-caller-list-is-cachescope-private-a-public-list-is-byte-identical-across-c', 'mcp-integration.md §D', 'a list that differs per caller MUST be cacheScope private — a public list that differs is cross-context cache poisoning (mcp-cache-tenant-scoped)')).toBe('private');
       expect(theirs.body.result?.cacheScope).toBe('private');
     }
   });

package/src/scenarios/mcp-current-auth-boundary.test.ts

@@ -18,10 +18,11 @@
 
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
-import { seamAbsent } from '../lib/soft-skip.js';
+import { seamAbsent, softSkip } from '../lib/soft-skip.js';
 import { mcpServerMount } from '../lib/mcp-mount.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const PROFILE = 'mcp-2026-07-28';
 const META_V = 'io.modelcontextprotocol/protocolVersion';
@@ -50,16 +51,16 @@ describe.skipIf(!process.env.OPENWOP_BASE_URL)('RFC 0153 §E — mcp-current-aut
     if (!behaviorGate(PROFILE, claims)) return;
     const authed = await driver.post(await mcpServerMount(), REQ, { headers: HDR });
     if (authed.status === 404 || authed.status === 403) return seamAbsent(`host advertises an MCP server mount but the mount (capabilities.mcp.serverUrls[0], else /v1/host/sample/mcp) answered ${authed.status} — RFC 0153 §B is unobservable at the path the host itself advertised`);
-    expect(authed.status, driver.describe('mcp-integration.md §E', 'the authenticated call MUST succeed at the same path, so a refusal below is not a wrong path')).toBe(200);
+    expect(authed.status, req('openwop.it.mcp-current-auth-boundary.an-unauthenticated-current-profile-request-is-refused-unless-anonymousactor-is-a', 'mcp-integration.md §E', 'the authenticated call MUST succeed at the same path, so a refusal below is not a wrong path')).toBe(200);
     const anonymous = await driver.post(await mcpServerMount(), REQ, { headers: HDR, authenticated: false });
     if (anon?.supported === true) {
       // Anonymous is permitted only through the RFC 0132 surface; a 200 here is that surface answering.
       expect([200, 401, 403]).toContain(anonymous.status);
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `anon?.supported === true` returned early');
     }
     expect(
       [401, 403],
-      driver.describe('mcp-integration.md §E', 'an anonymous MCP principal MUST NOT be the production default for an advertised current profile — refuse (401/403) or advertise anonymousActor'),
+      req('openwop.it.mcp-current-auth-boundary.an-unauthenticated-current-profile-request-is-refused-unless-anonymousactor-is-a', 'mcp-integration.md §E', 'an anonymous MCP principal MUST NOT be the production default for an advertised current profile — refuse (401/403) or advertise anonymousActor'),
     ).toContain(anonymous.status);
 
     // S30 (2026-08-17, openwop-app H43): a cookie-posture host may MINT an anonymous
@@ -72,12 +73,12 @@ describe.skipIf(!process.env.OPENWOP_BASE_URL)('RFC 0153 §E — mcp-current-aut
       ...setCookies(anonymous.headers),
       ...setCookies((await driver.get('/.well-known/openwop', { authenticated: false })).headers),
     ];
-    if (minted.length === 0) return; // host mints no anonymous session; the bare probe was the whole observation
+    if (minted.length === 0) return softSkip('blocked', 'precondition not met — `minted.length === 0` returned early (host mints no anonymous session; the bare probe was the whole observation) (seam, prior step, or fixture unavailable)'); // host mints no anonymous session; the bare probe was the whole observation
     const cookie = minted.map((c) => c.split(';')[0]).join('; ');
     const withSession = await driver.post(await mcpServerMount(), REQ, { headers: { ...HDR, Cookie: cookie }, authenticated: false });
     expect(
       [401, 403],
-      driver.describe('mcp-integration.md §E', 'a caller holding only a host-minted anonymous session cookie is still an anonymous principal — refuse (401/403) unless anonymousActor is advertised (S30)'),
+      req('openwop.it.mcp-current-auth-boundary.an-unauthenticated-current-profile-request-is-refused-unless-anonymousactor-is-a', 'mcp-integration.md §E', 'a caller holding only a host-minted anonymous session cookie is still an anonymous principal — refuse (401/403) unless anonymousActor is advertised (S30)'),
     ).toContain(withSession.status);
   });
 });

package/src/scenarios/mcp-discoverability.test.ts

@@ -29,6 +29,8 @@
 
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 interface McpAdvertisement {
   supported?: unknown;
@@ -75,28 +77,28 @@ async function fetchMcpAdvertisements(): Promise<DiscoveredMcp[]> {
 describe('mcp: discoverability shape', () => {
   it('any advertised MCP capability has well-formed shape ({supported, serverUrls})', async () => {
     const advertisements = await fetchMcpAdvertisements();
-    if (advertisements.length === 0) return; // skip-equivalent: host does not advertise MCP
+    if (advertisements.length === 0) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `advertisements.length === 0` returned early (skip-equivalent: host does not advertise MCP)'); // skip-equivalent: host does not advertise MCP
 
     for (const { path, ad } of advertisements) {
-      expect(typeof ad.supported, driver.describe(
+      expect(typeof ad.supported, req('openwop.it.mcp-discoverability.any-advertised-mcp-capability-has-well-formed-shape-supported-serverurls', 
         'spec/v1/mcp-integration.md §"Conformance + interop"',
         `${path}.supported MUST be boolean when advertised`,
       )).toBe('boolean');
 
       if (ad.supported === true) {
-        expect(Array.isArray(ad.serverUrls), driver.describe(
+        expect(Array.isArray(ad.serverUrls), req('openwop.it.mcp-discoverability.any-advertised-mcp-capability-has-well-formed-shape-supported-serverurls', 
           'spec/v1/mcp-integration.md',
           `${path}.serverUrls MUST be an array when supported:true`,
         )).toBe(true);
 
         if (Array.isArray(ad.serverUrls)) {
-          expect(ad.serverUrls.length, driver.describe(
+          expect(ad.serverUrls.length, req('openwop.it.mcp-discoverability.any-advertised-mcp-capability-has-well-formed-shape-supported-serverurls', 
             'spec/v1/mcp-integration.md',
             `${path}.serverUrls MUST be non-empty when supported:true`,
           )).toBeGreaterThan(0);
 
           for (const url of ad.serverUrls) {
-            expect(typeof url, driver.describe(
+            expect(typeof url, req('openwop.it.mcp-discoverability.any-advertised-mcp-capability-has-well-formed-shape-supported-serverurls', 
               'spec/v1/mcp-integration.md',
               `${path}.serverUrls entries MUST be strings`,
             )).toBe('string');
@@ -108,7 +110,7 @@ describe('mcp: discoverability shape', () => {
 
   it('serverUrls are valid URL paths or absolute URLs', async () => {
     const advertisements = await fetchMcpAdvertisements();
-    if (advertisements.length === 0) return; // skip-equivalent
+    if (advertisements.length === 0) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `advertisements.length === 0` returned early (skip-equivalent)'); // skip-equivalent
 
     for (const { path, ad } of advertisements) {
       if (ad.supported !== true || !Array.isArray(ad.serverUrls)) continue;
@@ -119,7 +121,7 @@ describe('mcp: discoverability shape', () => {
         // ambiguous to a client trying to connect.
         const isHostRelative = url.startsWith('/');
         const isAbsoluteHttp = url.startsWith('http://') || url.startsWith('https://');
-        expect(isHostRelative || isAbsoluteHttp, driver.describe(
+        expect(isHostRelative || isAbsoluteHttp, req('openwop.it.mcp-discoverability.serverurls-are-valid-url-paths-or-absolute-urls', 
           'spec/v1/mcp-integration.md',
           `${path}.serverUrls entry "${url}" MUST be a leading-slash path or absolute http(s) URL`,
         )).toBe(true);

package/src/scenarios/mcp-extension-opacity.test.ts

@@ -27,6 +27,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 to the suite's fake server via /v1/host/sample/mcp/invoke (serverUrl), which the server records";
 
@@ -53,14 +54,14 @@ describe.skipIf(!process.env.OPENWOP_BASE_URL)('RFC 0153 §D — mcp-extension-o
       // an advertised-missing seam (RFC 0148 §B). A 403 is NOT a pass.
       return seamAbsent(`host advertises mcp-2026-07-28 but the invoke seam /v1/host/sample/mcp/invoke answered ${drive.status}`);
     }
-    expect(server.invocations().some((i) => i.method === 'tools/call'), 'the host MUST have called the tool').toBe(true);
+    expect(server.invocations().some((i) => i.method === 'tools/call'), req('openwop.it.mcp-extension-opacity.client-half-an-extension-meta-asserting-authority-in-a-tool-result-changes-nothi', 'host-sample-test-seams.md §23', 'the host MUST have called the tool')).toBe(true);
     const rep = (drive.json as { extensionAuthority?: { scopesWidened?: boolean; approvalAdvanced?: boolean } }).extensionAuthority;
     if (rep === undefined) {
-      expect(rep, driver.describe('host-sample-test-seams.md §23', 'the seam SHOULD report `extensionAuthority: { scopesWidened, approvalAdvanced }` for scenario "extension-asserts-authority"; until it does the requirement is `blocked`, not passed')).toBeDefined();
-      return;
+      expect(rep, req('openwop.it.mcp-extension-opacity.client-half-an-extension-meta-asserting-authority-in-a-tool-result-changes-nothi', 'host-sample-test-seams.md §23', 'the seam SHOULD report `extensionAuthority: { scopesWidened, approvalAdvanced }` for scenario "extension-asserts-authority"; until it does the requirement is `blocked`, not passed')).toBeDefined();
+      return softSkip('blocked', 'precondition not met — `rep === undefined` returned early (seam, prior step, or fixture unavailable)');
     }
-    expect(rep.scopesWidened, driver.describe('mcp-integration.md §D', 'an extension MUST NOT gain tool authority or scope by appearing in _meta (mcp-extension-no-authority)')).toBe(false);
-    expect(rep.approvalAdvanced, driver.describe('mcp-integration.md §D/§E', 'MCP content MUST NOT advance approval gates')).toBe(false);
+    expect(rep.scopesWidened, req('openwop.it.mcp-extension-opacity.client-half-an-extension-meta-asserting-authority-in-a-tool-result-changes-nothi', 'mcp-integration.md §D', 'an extension MUST NOT gain tool authority or scope by appearing in _meta (mcp-extension-no-authority)')).toBe(false);
+    expect(rep.approvalAdvanced, req('openwop.it.mcp-extension-opacity.client-half-an-extension-meta-asserting-authority-in-a-tool-result-changes-nothi', 'mcp-integration.md §D/§E', 'MCP content MUST NOT advance approval gates')).toBe(false);
   });
 
   it('server half: unknown _meta extension keys on a request are ignored, not refused and not honoured', async () => {
@@ -73,7 +74,7 @@ describe.skipIf(!process.env.OPENWOP_BASE_URL)('RFC 0153 §D — mcp-extension-o
     }, { headers: { 'MCP-Protocol-Version': '2026-07-28', 'Mcp-Method': 'tools/list' } });
     if (res.status === 404 || res.status === 403) return seamAbsent(`host advertises mcp-2026-07-28 but the MCP server mount /v1/host/sample/mcp answered ${res.status}`);
     const body = res.json as { result?: { resultType?: string }; error?: { code: number } };
-    expect(res.status, driver.describe('mcp-integration.md §D', 'an unknown extension is opaque: the request MUST be processed normally, neither refused nor granted anything')).toBe(200);
+    expect(res.status, req('openwop.it.mcp-extension-opacity.server-half-unknown-meta-extension-keys-on-a-request-are-ignored-not-refused-and', 'mcp-integration.md §D', 'an unknown extension is opaque: the request MUST be processed normally, neither refused nor granted anything')).toBe(200);
     expect(body.error).toBeUndefined();
     expect(body.result?.resultType).toBe('complete');
   });