@openwop/openwop-conformance 1.163.0 → 2.0.0-rc.1

package/src/scenarios/aiEnvelope.universalKinds.test.ts

@@ -47,10 +47,10 @@ async function readSupportedEnvelopes(): Promise<string[] | null> {
 describe('aiEnvelope.universalKinds: advertisement shape (FINAL v1.1)', () => {
   it('capabilities.envelopeContracts is either absent or a well-formed object', async () => {
     const block = await readEnvelopeContracts();
-    if (block === null) return; // host doesn't opt in — skip
+    if (block === null) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `block === null` returned early (host doesn\'t opt in — skip)'); // host doesn't opt in — skip
     expect(
       typeof block.advertised,
-      driver.describe(
+      req('openwop.it.aiEnvelope.universalKinds.capabilities-envelopecontracts-is-either-absent-or-a-well-formed-object', 
         'ai-envelope.md §"Capability handshake integration"',
         'capabilities.envelopeContracts.advertised MUST be a boolean when present',
       ),
@@ -59,11 +59,11 @@ describe('aiEnvelope.universalKinds: advertisement shape (FINAL v1.1)', () => {
 
   it('opted-in hosts advertise every universal kind in supportedEnvelopes', async () => {
     const block = await readEnvelopeContracts();
-    if (block === null || !block.advertised) return; // not opted in — skip
+    if (block === null || !block.advertised) return softSkip('blocked', 'precondition not met — `block === null || !block.advertised` returned early (not opted in — skip) (seam, prior step, or fixture unavailable)'); // not opted in — skip
     const advertised = await readSupportedEnvelopes();
     expect(
       Array.isArray(advertised),
-      driver.describe(
+      req('openwop.it.aiEnvelope.universalKinds.opted-in-hosts-advertise-every-universal-kind-in-supportedenvelopes', 
         'capabilities.schema.json §supportedEnvelopes',
         'supportedEnvelopes MUST be present as an array on hosts that advertise envelopeContracts',
       ),
@@ -71,7 +71,7 @@ describe('aiEnvelope.universalKinds: advertisement shape (FINAL v1.1)', () => {
     for (const kind of UNIVERSALS) {
       expect(
         advertised!.includes(kind),
-        driver.describe(
+        req('openwop.it.aiEnvelope.universalKinds.opted-in-hosts-advertise-every-universal-kind-in-supportedenvelopes', 
           'ai-envelope.md §"Universal kinds"',
           `supportedEnvelopes MUST include "${kind}" — universals are always-allowed`,
         ),
@@ -103,8 +103,8 @@ describe('aiEnvelope.universalKinds: behavioral accept via /v1/host/sample/envel
       payload: { questions: [{ id: 'q1', question: 'Which provider?' }] },
       meta: baseMeta,
     });
-    if (r.status === 404) return;
-    expect(r.body.status, driver.describe('ai-envelope.md §"Universal kinds"', 'valid clarification.request MUST be accepted')).toBe('accepted');
+    if (r.status === 404) return softSkip('blocked', 'precondition not met — `r.status === 404` returned early (seam, prior step, or fixture unavailable)');
+    expect(r.body.status, req('openwop.it.aiEnvelope.universalKinds.accept-clarification-request-with-valid-payload-status-accepted', 'ai-envelope.md §"Universal kinds"', 'valid clarification.request MUST be accepted')).toBe('accepted');
   });
 
   it('accept schema.request → status: accepted', async () => {
@@ -116,8 +116,8 @@ describe('aiEnvelope.universalKinds: behavioral accept via /v1/host/sample/envel
       payload: { envelopeType: 'vendor.acme.prd.create' },
       meta: baseMeta,
     });
-    if (r.status === 404) return;
-    expect(r.body.status).toBe('accepted');
+    if (r.status === 404) return softSkip('blocked', 'precondition not met — `r.status === 404` returned early (seam, prior step, or fixture unavailable)');
+    expect(r.body.status, req('openwop.it.aiEnvelope.universalKinds.accept-schema-request-status-accepted', 'spec/v1/ai-envelope.md', 'accept schema.request → status: accepted')).toBe('accepted');
   });
 
   it('accept schema.response (ack:true) → status: accepted', async () => {
@@ -129,8 +129,8 @@ describe('aiEnvelope.universalKinds: behavioral accept via /v1/host/sample/envel
       payload: { envelopeType: 'vendor.acme.prd.create', ack: true },
       meta: baseMeta,
     });
-    if (r.status === 404) return;
-    expect(r.body.status).toBe('accepted');
+    if (r.status === 404) return softSkip('blocked', 'precondition not met — `r.status === 404` returned early (seam, prior step, or fixture unavailable)');
+    expect(r.body.status, req('openwop.it.aiEnvelope.universalKinds.accept-schema-response-ack-true-status-accepted', 'spec/v1/ai-envelope.md', 'accept schema.response (ack:true) → status: accepted')).toBe('accepted');
   });
 
   it('accept error envelope (LLM-emitted) → status: accepted (distinct from host-level ErrorEnvelope)', async () => {
@@ -142,8 +142,8 @@ describe('aiEnvelope.universalKinds: behavioral accept via /v1/host/sample/envel
       payload: { code: 'validation_failed', message: 'I cannot produce JSON matching that schema' },
       meta: baseMeta,
     });
-    if (r.status === 404) return;
-    expect(r.body.status, driver.describe('ai-envelope.md §error', 'LLM-emitted error envelope MUST be accepted (NOT the host HTTP ErrorEnvelope)')).toBe('accepted');
+    if (r.status === 404) return softSkip('blocked', 'precondition not met — `r.status === 404` returned early (seam, prior step, or fixture unavailable)');
+    expect(r.body.status, req('openwop.it.aiEnvelope.universalKinds.accept-error-envelope-llm-emitted-status-accepted-distinct-from-host-level-error', 'ai-envelope.md §error', 'LLM-emitted error envelope MUST be accepted (NOT the host HTTP ErrorEnvelope)')).toBe('accepted');
   });
 
   it('refuse invalid clarification.request (missing questions[]) → status: invalid', async () => {
@@ -155,22 +155,24 @@ describe('aiEnvelope.universalKinds: behavioral accept via /v1/host/sample/envel
       payload: { contextType: 'form-field' }, // missing required `questions`
       meta: baseMeta,
     });
-    if (r.status === 404) return;
+    if (r.status === 404) return softSkip('blocked', 'precondition not met — `r.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(
       r.body.status,
-      driver.describe('ai-envelope.md §"Schema discipline"', 'malformed payload MUST be rejected with invalid'),
+      req('openwop.it.aiEnvelope.universalKinds.refuse-invalid-clarification-request-missing-questions-status-invalid', 'ai-envelope.md §"Schema discipline"', 'malformed payload MUST be rejected with invalid'),
     ).toBe('invalid');
-    expect(Array.isArray(r.body.details), 'invalid outcome MUST carry validation details').toBe(true);
+    expect(Array.isArray(r.body.details), req('openwop.it.aiEnvelope.universalKinds.refuse-invalid-clarification-request-missing-questions-status-invalid', 'ai-envelope.md §"Schema discipline"', 'invalid outcome MUST carry validation details')).toBe(true);
   });
 });
 
 // E.1 engine-projection via the test-only event-log seam.
 import { queryTestEvents, isEventLogSeamAvailable, resetTestSeam } from '../lib/event-log-query.js';
 import { capabilityFamily, discoveryFamilies } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 describe('aiEnvelope.universalKinds: engine projection via event-log seam', () => {
   it('clarification.request MUST be lifted to interrupt.requested { kind: "clarification" } per interrupt.md', async () => {
-    if (!(await isEventLogSeamAvailable())) return;
+    if (!(await isEventLogSeamAvailable())) return softSkip('blocked', 'precondition not met — `!(await isEventLogSeamAvailable())` returned early (seam, prior step, or fixture unavailable)');
     const runId = `r-uk-clar-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     const r = await accept(
       {
@@ -183,20 +185,20 @@ describe('aiEnvelope.universalKinds: engine projection via event-log seam', () =
       },
       { projectTo: { runId, nodeId: 'n' } },
     );
-    if (r.status === 404) return;
+    if (r.status === 404) return softSkip('blocked', 'precondition not met — `r.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(r.body.status).toBe('accepted');
     const events = await queryTestEvents(runId, { type: 'interrupt.requested' });
-    if (!events.ok) return;
+    if (!events.ok) return softSkip('blocked', 'precondition not met — `!events.ok` returned early (seam, prior step, or fixture unavailable)');
     expect(
       events.events.length,
-      driver.describe('ai-envelope.md §"Universal kinds"', 'accepted clarification.request MUST project to interrupt.requested per interrupt.md'),
+      req('openwop.it.aiEnvelope.universalKinds.clarification-request-must-be-lifted-to-interrupt-requested-kind-clarification-p', 'ai-envelope.md §"Universal kinds"', 'accepted clarification.request MUST project to interrupt.requested per interrupt.md'),
     ).toBe(1);
     expect((events.events[0]!.payload as { kind?: string }).kind).toBe('clarification');
     await resetTestSeam();
   });
 
   it('error envelope MUST project to log.appended { level: "error" } — NOT node.failed', async () => {
-    if (!(await isEventLogSeamAvailable())) return;
+    if (!(await isEventLogSeamAvailable())) return softSkip('blocked', 'precondition not met — `!(await isEventLogSeamAvailable())` returned early (seam, prior step, or fixture unavailable)');
     const runId = `r-uk-err-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     await accept(
       {
@@ -211,20 +213,20 @@ describe('aiEnvelope.universalKinds: engine projection via event-log seam', () =
     );
     const logs = await queryTestEvents(runId, { type: 'log.appended' });
     const fails = await queryTestEvents(runId, { type: 'node.failed' });
-    if (!logs.ok || !fails.ok) return;
+    if (!logs.ok || !fails.ok) return softSkip('blocked', 'precondition not met — `!logs.ok || !fails.ok` returned early (seam, prior step, or fixture unavailable)');
     expect(
       logs.events.some((e) => (e.payload as { level?: string }).level === 'error'),
-      driver.describe('ai-envelope.md §"Universal kinds"', 'LLM-emitted error envelope MUST project to log.appended at error level'),
+      req('openwop.it.aiEnvelope.universalKinds.error-envelope-must-project-to-log-appended-level-error-not-node-failed', 'ai-envelope.md §"Universal kinds"', 'LLM-emitted error envelope MUST project to log.appended at error level'),
     ).toBe(true);
     expect(
       fails.events.length,
-      driver.describe('ai-envelope.md §"Universal kinds"', 'LLM-emitted error envelope MUST NOT project to node.failed (distinct from terminal node failure)'),
+      req('openwop.it.aiEnvelope.universalKinds.error-envelope-must-project-to-log-appended-level-error-not-node-failed', 'ai-envelope.md §"Universal kinds"', 'LLM-emitted error envelope MUST NOT project to node.failed (distinct from terminal node failure)'),
     ).toBe(0);
     await resetTestSeam();
   });
 
   it('schema.request projects to log.appended (host implements next-turn injection out-of-band)', async () => {
-    if (!(await isEventLogSeamAvailable())) return;
+    if (!(await isEventLogSeamAvailable())) return softSkip('blocked', 'precondition not met — `!(await isEventLogSeamAvailable())` returned early (seam, prior step, or fixture unavailable)');
     const runId = `r-uk-sr-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     await accept(
       {
@@ -238,10 +240,10 @@ describe('aiEnvelope.universalKinds: engine projection via event-log seam', () =
       { projectTo: { runId, nodeId: 'n' } },
     );
     const events = await queryTestEvents(runId, { type: 'log.appended' });
-    if (!events.ok) return;
+    if (!events.ok) return softSkip('blocked', 'precondition not met — `!events.ok` returned early (seam, prior step, or fixture unavailable)');
     expect(
       events.events.length,
-      driver.describe('ai-envelope.md §"Universal kinds"', 'schema.request MUST project to log.appended (the schema delivery itself happens out-of-band via the host\'s next-turn system prompt)'),
+      req('openwop.it.aiEnvelope.universalKinds.schema-request-projects-to-log-appended-host-implements-next-turn-injection-out', 'ai-envelope.md §"Universal kinds"', 'schema.request MUST project to log.appended (the schema delivery itself happens out-of-band via the host\'s next-turn system prompt)'),
     ).toBeGreaterThan(0);
     await resetTestSeam();
   });
@@ -256,10 +258,10 @@ describe('aiEnvelope.universalKinds: schema.response counter-policy advertisemen
     const res = await driver.get('/.well-known/openwop');
     const body = res.json as { capabilities?: { aiEnvelope?: { schemaResponseCounterPolicy?: string } } } | undefined;
     const policy = capabilityFamily<{ schemaResponseCounterPolicy?: string }>(body, 'aiEnvelope')?.schemaResponseCounterPolicy;
-    if (policy === undefined) return; // no policy advertised — host MAY omit
+    if (policy === undefined) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `policy === undefined` returned early (no policy advertised — host MAY omit)'); // no policy advertised — host MAY omit
     expect(
       ['counted', 'exempt'].includes(policy),
-      driver.describe(
+      req('openwop.it.aiEnvelope.universalKinds.host-may-count-or-exempt-schema-response-against-envelopesperturn-when-advertise', 
         'ai-envelope.md §"Universal kinds"',
         'when advertised, schemaResponseCounterPolicy MUST be either "counted" or "exempt"',
       ),

package/src/scenarios/aiproviders-input-shape.test.ts

@@ -21,9 +21,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 { req } from '../lib/requirement-ids.js';
 
 const BASE = 'https://openwop.dev/spec/v1/';
-const why = (specRef: string, requirement: string): string => `${specRef} — ${requirement}`;
 function loadSchema(name: string): Record<string, unknown> {
   return JSON.parse(readFileSync(join(SCHEMAS_DIR, name), 'utf8')) as Record<string, unknown>;
 }
@@ -43,27 +43,27 @@ describe('aiproviders-input-shape: callAI perception input (RFC 0091 §B, server
   const input = ajv.getSchema(`${BASE}capabilities.schema.json#/properties/aiProviders/properties/input`);
 
   it('the aiProviders.input sub-schema exists', () => {
-    expect(input, 'capabilities.aiProviders.input MUST be declared').toBeTruthy();
+    expect(input, req('openwop.it.aiproviders-input-shape.the-aiproviders-input-sub-schema-exists', 'RFC 0091', 'capabilities.aiProviders.input MUST be declared')).toBeTruthy();
   });
 
   it('accepts a conforming modalities advertisement', () => {
     expect(
       input!({ modalities: ['text', 'image', 'document'], maxBytesPerPart: 1048576 }),
-      why('RFC 0091 §B', 'a conforming input advertisement MUST validate'),
+      req('openwop.it.aiproviders-input-shape.accepts-a-conforming-modalities-advertisement', 'RFC 0091 §B', 'a conforming input advertisement MUST validate'),
     ).toBe(true);
   });
 
   it('rejects an out-of-enum modality', () => {
     expect(
       input!({ modalities: ['text', 'video'] }),
-      why('RFC 0091 §B', 'modalities is a closed enum (text/image/audio/document)'),
+      req('openwop.it.aiproviders-input-shape.rejects-an-out-of-enum-modality', 'RFC 0091 §B', 'modalities is a closed enum (text/image/audio/document)'),
     ).toBe(false);
   });
 
   it('rejects a non-positive maxBytesPerPart', () => {
     expect(
       input!({ modalities: ['text'], maxBytesPerPart: 0 }),
-      why('RFC 0091 §B', 'maxBytesPerPart MUST be a positive integer'),
+      req('openwop.it.aiproviders-input-shape.rejects-a-non-positive-maxbytesperpart', 'RFC 0091 §B', 'maxBytesPerPart MUST be a positive integer'),
     ).toBe(false);
   });
 });

package/src/scenarios/aiproviders-realtimevoice-shape.test.ts

@@ -30,9 +30,7 @@ import { join } from 'node:path';
 import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
 import { SCHEMAS_DIR } from '../lib/paths.js';
-
-/** Server-free assertion-message helper. */
-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>;
@@ -49,14 +47,14 @@ describe('aiproviders-realtimevoice-shape: capability advertisement (RFC 0106 §
       .realtimeVoice;
     expect(
       realtimeVoice,
-      why('host-capabilities.md §host.aiProviders', 'aiProviders.realtimeVoice MUST be declared'),
+      req('openwop.it.aiproviders-realtimevoice-shape.aiproviders-realtimevoice-is-an-object-with-the-four-sub-flags', 'host-capabilities.md §host.aiProviders', 'aiProviders.realtimeVoice MUST be declared'),
     ).toBeDefined();
-    expect(realtimeVoice?.type, why('RFC 0106 §A', 'realtimeVoice MUST be an object')).toBe('object');
+    expect(realtimeVoice?.type, req('openwop.it.aiproviders-realtimevoice-shape.aiproviders-realtimevoice-is-an-object-with-the-four-sub-flags', 'RFC 0106 §A', 'realtimeVoice MUST be an object')).toBe('object');
     const props = realtimeVoice?.properties ?? {};
     for (const flag of ['transcription', 'synthesis', 'turnDetection', 'bargeIn']) {
       expect(
         Object.prototype.hasOwnProperty.call(props, flag),
-        why('RFC 0106 §A', `realtimeVoice.${flag} MUST be declared`),
+        req('openwop.it.aiproviders-realtimevoice-shape.aiproviders-realtimevoice-is-an-object-with-the-four-sub-flags', 'RFC 0106 §A', `realtimeVoice.${flag} MUST be declared`),
       ).toBe(true);
     }
   });
@@ -66,7 +64,7 @@ describe('aiproviders-realtimevoice-shape: capability advertisement (RFC 0106 §
     const required = Array.isArray(aiProviders.required) ? (aiProviders.required as string[]) : [];
     expect(
       required.includes('realtimeVoice'),
-      why('RFC 0106 §A', 'aiProviders.realtimeVoice MUST be optional (a host without live voice is valid)'),
+      req('openwop.it.aiproviders-realtimevoice-shape.realtimevoice-is-not-in-aiproviders-required-absence-no-live-voice-is-a-valid-de', 'RFC 0106 §A', 'aiProviders.realtimeVoice MUST be optional (a host without live voice is valid)'),
     ).toBe(false);
   });
 
@@ -78,24 +76,24 @@ describe('aiproviders-realtimevoice-shape: capability advertisement (RFC 0106 §
 
     expect(
       validate({ transcription: 'streaming', turnDetection: 'semantic', bargeIn: 'supported' }),
-      why('RFC 0106 §A', 'a full transcription advertisement MUST validate'),
+      req('openwop.it.aiproviders-realtimevoice-shape.ajv-the-realtimevoice-subschema-accepts-the-floor-and-enforces-the-turndetection', 'RFC 0106 §A', 'a full transcription advertisement MUST validate'),
     ).toBe(true);
-    expect(validate({}), why('RFC 0106 §A', 'an empty realtimeVoice object MUST validate')).toBe(true);
+    expect(validate({}), req('openwop.it.aiproviders-realtimevoice-shape.ajv-the-realtimevoice-subschema-accepts-the-floor-and-enforces-the-turndetection', 'RFC 0106 §A', 'an empty realtimeVoice object MUST validate')).toBe(true);
     expect(
       validate({ turnDetection: 'semantic' }),
-      why('RFC 0106 §A', 'turnDetection without transcription MUST be rejected (dependentRequired)'),
+      req('openwop.it.aiproviders-realtimevoice-shape.ajv-the-realtimevoice-subschema-accepts-the-floor-and-enforces-the-turndetection', 'RFC 0106 §A', 'turnDetection without transcription MUST be rejected (dependentRequired)'),
     ).toBe(false);
     expect(
       validate({ bargeIn: 'supported' }),
-      why('RFC 0106 §A', 'bargeIn without transcription MUST be rejected (dependentRequired)'),
+      req('openwop.it.aiproviders-realtimevoice-shape.ajv-the-realtimevoice-subschema-accepts-the-floor-and-enforces-the-turndetection', 'RFC 0106 §A', 'bargeIn without transcription MUST be rejected (dependentRequired)'),
     ).toBe(false);
     expect(
       validate({ transcription: 'streaming', turnDetection: 'aggressive' }),
-      why('RFC 0106 §A', 'an out-of-enum turnDetection MUST be rejected'),
+      req('openwop.it.aiproviders-realtimevoice-shape.ajv-the-realtimevoice-subschema-accepts-the-floor-and-enforces-the-turndetection', 'RFC 0106 §A', 'an out-of-enum turnDetection MUST be rejected'),
     ).toBe(false);
     expect(
       validate({ transcription: true }),
-      why('RFC 0106 §A', 'transcription MUST be the string const "streaming", not a boolean'),
+      req('openwop.it.aiproviders-realtimevoice-shape.ajv-the-realtimevoice-subschema-accepts-the-floor-and-enforces-the-turndetection', 'RFC 0106 §A', 'transcription MUST be the string const "streaming", not a boolean'),
     ).toBe(false);
   });
 
@@ -106,15 +104,15 @@ describe('aiproviders-realtimevoice-shape: capability advertisement (RFC 0106 §
 
     expect(
       validate({ realtimeVoice: { transcription: 'streaming', synthesis: 'streaming' } }),
-      why('RFC 0106 §A', 'streaming synthesis without speechSynthesis: "supported" MUST be rejected'),
+      req('openwop.it.aiproviders-realtimevoice-shape.ajv-the-aiproviders-subschema-enforces-realtimevoice-synthesis-speechsynthesis', 'RFC 0106 §A', 'streaming synthesis without speechSynthesis: "supported" MUST be rejected'),
     ).toBe(false);
     expect(
       validate({ speechSynthesis: 'supported', realtimeVoice: { transcription: 'streaming', synthesis: 'streaming' } }),
-      why('RFC 0106 §A', 'streaming synthesis WITH speechSynthesis: "supported" MUST validate'),
+      req('openwop.it.aiproviders-realtimevoice-shape.ajv-the-aiproviders-subschema-enforces-realtimevoice-synthesis-speechsynthesis', 'RFC 0106 §A', 'streaming synthesis WITH speechSynthesis: "supported" MUST validate'),
     ).toBe(true);
     expect(
       validate({ realtimeVoice: { transcription: 'streaming' } }),
-      why('RFC 0106 §A', 'transcription-only (no synthesis) MUST validate without speechSynthesis'),
+      req('openwop.it.aiproviders-realtimevoice-shape.ajv-the-aiproviders-subschema-enforces-realtimevoice-synthesis-speechsynthesis', 'RFC 0106 §A', 'transcription-only (no synthesis) MUST validate without speechSynthesis'),
     ).toBe(true);
   });
 });

package/src/scenarios/aiproviders-selfhosted-honesty.test.ts

@@ -39,6 +39,8 @@ import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const SEAM = '/v1/host/sample/ai/call';
 
@@ -91,7 +93,7 @@ describe('aiproviders-selfhosted-honesty (RFC 0108 §A.2/§D)', () => {
       provider: providerId,
       messages: [{ role: 'user', content: 'ping' }],
     });
-    if (res.status === 404) return; // seam unwired — soft-skip the behavioral suite
+    if (res.status === 404) return softSkip('blocked', 'precondition not met — `res.status === 404` returned early (seam unwired — soft-skip the behavioral suite) (seam, prior step, or fixture unavailable)'); // seam unwired — soft-skip the behavioral suite
 
     // §A.2 — the advertisement must be backed by a real endpoint. A success or a
     // transport-class failure both prove a real endpoint was reached; a
@@ -100,7 +102,7 @@ describe('aiproviders-selfhosted-honesty (RFC 0108 §A.2/§D)', () => {
     const code = errCode(res.json);
     expect(
       code === undefined || !NO_ENDPOINT_CODES.has(code),
-      driver.describe(
+      req('openwop.it.aiproviders-selfhosted-honesty.a-selfhosted-dispatch-reaches-a-real-endpoint-a-2-and-never-discloses-the-endpoi', 
         'RFC 0108 §A.2',
         `an advertised selfHosted id (${providerId}) MUST be backed by a configured, reachable endpoint ` +
           `(dispatch succeeds or fails with a transport error) — MUST NOT refuse "${code}" (no endpoint configured)`,
@@ -116,14 +118,14 @@ describe('aiproviders-selfhosted-honesty (RFC 0108 §A.2/§D)', () => {
         '[openwop-selfhosted-providers] §D disclosure check skipped — set OPENWOP_TEST_COMPAT_ENDPOINT ' +
           "to the host's configured compat endpoint to assert non-disclosure on the wire.",
       );
-      return;
+      return softSkip('blocked', 'precondition not met — `!endpoint` returned early (seam, prior step, or fixture unavailable)');
     }
 
     const serialized = JSON.stringify(res.json ?? {});
     for (const needle of endpointNeedles(endpoint)) {
       expect(
         !serialized.includes(needle),
-        driver.describe(
+        req('openwop.it.aiproviders-selfhosted-honesty.a-selfhosted-dispatch-reaches-a-real-endpoint-a-2-and-never-discloses-the-endpoi', 
           'RFC 0108 §D (self-hosted-endpoint-no-disclosure)',
           `the endpoint location ("${needle}") MUST NOT appear in any selfHosted dispatch response or error payload`,
         ),

package/src/scenarios/aiproviders-selfhosted-shape.test.ts

@@ -32,9 +32,7 @@ import { join } from 'node:path';
 import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
 import { SCHEMAS_DIR } from '../lib/paths.js';
-
-/** Server-free assertion-message helper. */
-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>;
@@ -87,19 +85,19 @@ describe('aiproviders-selfhosted-shape: self-hosted provider-class advertisement
       | undefined;
     expect(
       selfHosted,
-      why('capabilities.md §aiProviders.selfHosted', 'aiProviders.selfHosted MUST be declared'),
+      req('openwop.it.aiproviders-selfhosted-shape.aiproviders-selfhosted-is-declared-as-a-string-with-uniqueitems', 'capabilities.md §aiProviders.selfHosted', 'aiProviders.selfHosted MUST be declared'),
     ).toBeDefined();
-    expect(selfHosted?.type, why('RFC 0108 §A', 'selfHosted MUST be an array')).toBe('array');
+    expect(selfHosted?.type, req('openwop.it.aiproviders-selfhosted-shape.aiproviders-selfhosted-is-declared-as-a-string-with-uniqueitems', 'RFC 0108 §A', 'selfHosted MUST be an array')).toBe('array');
     expect(
       selfHosted?.uniqueItems,
-      why('RFC 0108 §A', 'selfHosted entries MUST be unique'),
+      req('openwop.it.aiproviders-selfhosted-shape.aiproviders-selfhosted-is-declared-as-a-string-with-uniqueitems', 'RFC 0108 §A', 'selfHosted entries MUST be unique'),
     ).toBe(true);
-    expect(selfHosted?.items?.type, why('RFC 0108 §A', 'selfHosted entries MUST be strings')).toBe(
+    expect(selfHosted?.items?.type, req('openwop.it.aiproviders-selfhosted-shape.aiproviders-selfhosted-is-declared-as-a-string-with-uniqueitems', 'RFC 0108 §A', 'selfHosted entries MUST be strings')).toBe(
       'string',
     );
     expect(
       selfHosted?.items?.minLength,
-      why('RFC 0108 §A', 'a selfHosted id MUST be non-empty'),
+      req('openwop.it.aiproviders-selfhosted-shape.aiproviders-selfhosted-is-declared-as-a-string-with-uniqueitems', 'RFC 0108 §A', 'a selfHosted id MUST be non-empty'),
     ).toBe(1);
   });
 
@@ -109,7 +107,7 @@ describe('aiproviders-selfhosted-shape: self-hosted provider-class advertisement
     const required = Array.isArray(aiProviders?.required) ? (aiProviders!.required as string[]) : [];
     expect(
       required.includes('selfHosted'),
-      why('RFC 0108 §A.1', 'aiProviders.selfHosted MUST be optional'),
+      req('openwop.it.aiproviders-selfhosted-shape.selfhosted-is-not-in-aiproviders-required-absence-no-self-hosted-endpoint-is-a-v', 'RFC 0108 §A.1', 'aiProviders.selfHosted MUST be optional'),
     ).toBe(false);
   });
 
@@ -125,19 +123,19 @@ describe('aiproviders-selfhosted-shape: self-hosted provider-class advertisement
 
     expect(
       validate(['ollama', 'compat']),
-      why('RFC 0108 §A', 'a conforming selfHosted array MUST validate'),
+      req('openwop.it.aiproviders-selfhosted-shape.ajv-accepts-a-conforming-selfhosted-array-and-rejects-non-array-duplicate-empty', 'RFC 0108 §A', 'a conforming selfHosted array MUST validate'),
     ).toBe(true);
     expect(
       validate('ollama'),
-      why('RFC 0108 §A', 'a non-array selfHosted MUST be rejected'),
+      req('openwop.it.aiproviders-selfhosted-shape.ajv-accepts-a-conforming-selfhosted-array-and-rejects-non-array-duplicate-empty', 'RFC 0108 §A', 'a non-array selfHosted MUST be rejected'),
     ).toBe(false);
     expect(
       validate(['ollama', 'ollama']),
-      why('RFC 0108 §A', 'duplicate selfHosted entries MUST be rejected (uniqueItems)'),
+      req('openwop.it.aiproviders-selfhosted-shape.ajv-accepts-a-conforming-selfhosted-array-and-rejects-non-array-duplicate-empty', 'RFC 0108 §A', 'duplicate selfHosted entries MUST be rejected (uniqueItems)'),
     ).toBe(false);
     expect(
       validate(['']),
-      why('RFC 0108 §A', 'an empty-string selfHosted id MUST be rejected (minLength 1)'),
+      req('openwop.it.aiproviders-selfhosted-shape.ajv-accepts-a-conforming-selfhosted-array-and-rejects-non-array-duplicate-empty', 'RFC 0108 §A', 'an empty-string selfHosted id MUST be rejected (minLength 1)'),
     ).toBe(false);
   });
 
@@ -149,13 +147,13 @@ describe('aiproviders-selfhosted-shape: self-hosted provider-class advertisement
         byok: ['anthropic', 'openai', 'compat'],
         selfHosted: ['ollama', 'compat'],
       }),
-      why('RFC 0108 §A.1/§A.3', 'a conforming advertisement MUST have no violations'),
+      req('openwop.it.aiproviders-selfhosted-shape.a-1-subset-a-3-non-disclosure-a-conforming-doc-has-no-violations-an-out-of-subse', 'RFC 0108 §A.1/§A.3', 'a conforming advertisement MUST have no violations'),
     ).toEqual([]);
 
     // §A.1 violation: `vllm` not in supported.
     expect(
       validateSelfHosted({ supported: ['anthropic', 'ollama'], selfHosted: ['ollama', 'vllm'] }),
-      why('RFC 0108 §A.1', 'a selfHosted id absent from supported MUST be flagged'),
+      req('openwop.it.aiproviders-selfhosted-shape.a-1-subset-a-3-non-disclosure-a-conforming-doc-has-no-violations-an-out-of-subse', 'RFC 0108 §A.1', 'a selfHosted id absent from supported MUST be flagged'),
     ).not.toEqual([]);
 
     // §A.3 violations: URL-shaped ids leak the endpoint location.
@@ -166,14 +164,14 @@ describe('aiproviders-selfhosted-shape: self-hosted provider-class advertisement
     ]) {
       expect(
         isUrlShaped(leaky),
-        why('RFC 0108 §A.3', `the URL-shaped id "${leaky}" MUST be detected as non-conformant`),
+        req('openwop.it.aiproviders-selfhosted-shape.a-1-subset-a-3-non-disclosure-a-conforming-doc-has-no-violations-an-out-of-subse', 'RFC 0108 §A.3', `the URL-shaped id "${leaky}" MUST be detected as non-conformant`),
       ).toBe(true);
     }
 
     // A label with a non-numeric suffix (`compat:label`) is NOT URL-shaped — it is a permitted opaque id.
     expect(
       isUrlShaped('compat:local-ollama'),
-      why('RFC 0108 §A.3', 'an opaque `compat:<label>` id (no host:port) MUST be permitted'),
+      req('openwop.it.aiproviders-selfhosted-shape.a-1-subset-a-3-non-disclosure-a-conforming-doc-has-no-violations-an-out-of-subse', 'RFC 0108 §A.3', 'an opaque `compat:<label>` id (no host:port) MUST be permitted'),
     ).toBe(false);
   });
 });

package/src/scenarios/aiproviders-speechsynth-shape.test.ts

@@ -31,9 +31,7 @@ import { join } from 'node:path';
 import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
 import { SCHEMAS_DIR } from '../lib/paths.js';
-
-/** Server-free assertion-message helper. */
-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>;
@@ -49,11 +47,11 @@ describe('aiproviders-speechsynth-shape: capability advertisement (RFC 0105 §B,
       | undefined;
     expect(
       speechSynthesis,
-      why('host-capabilities.md §host.aiProviders', 'aiProviders.speechSynthesis MUST be declared'),
+      req('openwop.it.aiproviders-speechsynth-shape.aiproviders-speechsynthesis-is-declared-as-the-string-const-supported', 'host-capabilities.md §host.aiProviders', 'aiProviders.speechSynthesis MUST be declared'),
     ).toBeDefined();
     expect(
       speechSynthesis?.const,
-      why('RFC 0105 §B', 'aiProviders.speechSynthesis MUST be the string const "supported" (not an object)'),
+      req('openwop.it.aiproviders-speechsynth-shape.aiproviders-speechsynthesis-is-declared-as-the-string-const-supported', 'RFC 0105 §B', 'aiProviders.speechSynthesis MUST be the string const "supported" (not an object)'),
     ).toBe('supported');
   });
 
@@ -63,7 +61,7 @@ describe('aiproviders-speechsynth-shape: capability advertisement (RFC 0105 §B,
     const required = Array.isArray(aiProviders?.required) ? (aiProviders!.required as string[]) : [];
     expect(
       required.includes('speechSynthesis'),
-      why('RFC 0105 §B', 'aiProviders.speechSynthesis MUST be optional (a host without TTS is valid)'),
+      req('openwop.it.aiproviders-speechsynth-shape.speechsynthesis-is-not-in-aiproviders-required-absence-no-tts-is-a-valid-default', 'RFC 0105 §B', 'aiProviders.speechSynthesis MUST be optional (a host without TTS is valid)'),
     ).toBe(false);
   });
 
@@ -81,12 +79,12 @@ describe('aiproviders-speechsynth-shape: capability advertisement (RFC 0105 §B,
 
     expect(
       validate('supported'),
-      why('RFC 0105 §B', 'aiProviders.speechSynthesis === "supported" MUST validate'),
+      req('openwop.it.aiproviders-speechsynth-shape.ajv-accepts-the-string-const-form-and-rejects-the-object-form', 'RFC 0105 §B', 'aiProviders.speechSynthesis === "supported" MUST validate'),
     ).toBe(true);
 
     expect(
       validate({ supported: true }),
-      why('RFC 0105 §B', 'the object form { supported: true } MUST be rejected by the const'),
+      req('openwop.it.aiproviders-speechsynth-shape.ajv-accepts-the-string-const-form-and-rejects-the-object-form', 'RFC 0105 §B', 'the object form { supported: true } MUST be rejected by the const'),
     ).toBe(false);
   });
 });

package/src/scenarios/aiproviders-subscription-scope.test.ts

@@ -38,9 +38,8 @@ import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
 import { SCHEMAS_DIR } from '../lib/paths.js';
-
-/** Server-free assertion-message helper. */
-const why = (specRef: string, requirement: string): string => `${specRef} — ${requirement}`;
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 /** Read the canonical error code from a response body (tolerant of
  *  `{error}` / `{code}` / `{error:{code}}` shapes). */
@@ -73,7 +72,7 @@ describe('aiproviders-subscription-scope: schema shape (RFC 0121, server-free)',
       | undefined;
     expect(
       authModes?.additionalProperties?.items?.enum,
-      why('capabilities.md §aiProviders.authModes', 'the authModes enum MUST include "subscription" (RFC 0121)'),
+      req('openwop.it.aiproviders-subscription-scope.the-aiproviders-authmodes-enum-includes-subscription', 'capabilities.md §aiProviders.authModes', 'the authModes enum MUST include "subscription" (RFC 0121)'),
     ).toContain('subscription');
   });
 });
@@ -94,7 +93,7 @@ describe('aiproviders-subscription-scope: §B.7 in-byok (advertisement-gated)',
     for (const provider of subProviders) {
       expect(
         byok.has(provider),
-        driver.describe('RFC 0121 §B.7', `subscription provider '${provider}' MUST appear in aiProviders.byok`),
+        req('openwop.it.aiproviders-subscription-scope.every-advertised-subscription-provider-appears-in-aiproviders-byok', 'RFC 0121 §B.7', `subscription provider '${provider}' MUST appear in aiProviders.byok`),
       ).toBe(true);
     }
   });
@@ -110,18 +109,18 @@ describe('aiproviders-subscription-scope: §B.8 user-scope-only (bind-seam-gated
     // multi-instance deploy with no durable per-user login) can still prove the
     // safety rail here. Soft-skips on 404 when the seam is unwired.
     const res = await driver.post(SEAM, { provider: 'anthropic', mode: 'subscription', scope: 'tenant' });
-    if (res.status === 404) return; // seam unwired — soft-skip
+    if (res.status === 404) return softSkip('blocked', 'precondition not met — `res.status === 404` returned early (seam unwired — soft-skip) (seam, prior step, or fixture unavailable)'); // seam unwired — soft-skip
 
     expect(
       res.status >= 400,
-      driver.describe(
+      req('openwop.it.aiproviders-subscription-scope.a-tenant-scope-subscription-binding-is-rejected-with-credential-scope-forbidden', 
         'RFC 0121 §B.8',
         `binding a subscription credential at tenant scope MUST be rejected (got HTTP ${res.status})`,
       ),
     ).toBe(true);
     expect(
       errCode(res.json),
-      driver.describe(
+      req('openwop.it.aiproviders-subscription-scope.a-tenant-scope-subscription-binding-is-rejected-with-credential-scope-forbidden', 
         'RFC 0121 §B.8',
         'a rejected tenant-scope subscription binding MUST carry the canonical `credential_scope_forbidden` error code',
       ),

package/src/scenarios/anonymous-actor-audit-opaque.test.ts

@@ -18,8 +18,9 @@
 
 import { describe, it, expect } from 'vitest';
 import { behaviorGate } from '../lib/behavior-gate.js';
-import { driver } from '../lib/driver.js';
 import { isAnonymousActorAdvertised, anonDispatch } from '../lib/anonymousActor.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const PROFILE = 'openwop-anonymous-actor';
 
@@ -33,19 +34,19 @@ describe('anonymous-actor-audit-opaque (RFC 0132 §D)', () => {
   it('the authorization.decided principal is opaque, non-PII, and the record carries no credential', async () => {
     if (!behaviorGate(PROFILE, await isAnonymousActorAdvertised())) return;
     const res = await anonDispatch({ tool: 'catalog.read' });
-    if (res.status === 404 || res.status === 405) return; // seam unwired — soft-skip
+    if (res.status === 404 || res.status === 405) return softSkip('blocked', 'precondition not met — `res.status === 404 || res.status === 405` returned early (seam unwired — soft-skip) (seam, prior step, or fixture unavailable)'); // seam unwired — soft-skip
 
     const decided = res.json?.authorizationDecided?.payload;
     expect(
       decided?.principal,
-      driver.describe('RFC 0132 §D', 'an anon tool call MUST emit authorization.decided with a principal'),
+      req('openwop.it.anonymous-actor-audit-opaque.the-authorization-decided-principal-is-opaque-non-pii-and-the-record-carries-no', 'RFC 0132 §D', 'an anon tool call MUST emit authorization.decided with a principal'),
     ).toBeTruthy();
 
     const principal = decided?.principal ?? '';
     for (const [pattern, label] of PII_PATTERNS) {
       expect(
         pattern.test(principal),
-        driver.describe('SECURITY anon-actor-audit-opaque', `the anon principal MUST NOT embed ${label}`),
+        req('openwop.it.anonymous-actor-audit-opaque.the-authorization-decided-principal-is-opaque-non-pii-and-the-record-carries-no', 'SECURITY anon-actor-audit-opaque', `the anon principal MUST NOT embed ${label}`),
       ).toBe(false);
     }
     // The record MUST NOT carry credential material (reason is redaction-safe).
@@ -53,7 +54,7 @@ describe('anonymous-actor-audit-opaque (RFC 0132 §D)', () => {
     for (const [pattern, label] of PII_PATTERNS) {
       expect(
         pattern.test(serialized),
-        driver.describe('SECURITY anon-actor-audit-opaque', `the audit record MUST NOT carry ${label}`),
+        req('openwop.it.anonymous-actor-audit-opaque.the-authorization-decided-principal-is-opaque-non-pii-and-the-record-carries-no', 'SECURITY anon-actor-audit-opaque', `the audit record MUST NOT carry ${label}`),
       ).toBe(false);
     }
   });
@@ -61,11 +62,11 @@ describe('anonymous-actor-audit-opaque (RFC 0132 §D)', () => {
   it('the run snapshot echoes owner.principalKind "anonymous"', async () => {
     if (!behaviorGate(PROFILE, await isAnonymousActorAdvertised())) return;
     const res = await anonDispatch({ tool: 'catalog.read' });
-    if (res.status === 404 || res.status === 405) return; // seam unwired — soft-skip
-    if (!res.json?.owner) return; // seam does not echo an owner triple — nothing to assert
+    if (res.status === 404 || res.status === 405) return softSkip('blocked', 'precondition not met — `res.status === 404 || res.status === 405` returned early (seam unwired — soft-skip) (seam, prior step, or fixture unavailable)'); // seam unwired — soft-skip
+    if (!res.json?.owner) return softSkip('blocked', 'precondition not met — `!res.json?.owner` returned early (seam does not echo an owner triple — nothing to assert) (seam, prior step, or fixture unavailable)'); // seam does not echo an owner triple — nothing to assert
     expect(
       res.json.owner.principalKind,
-      driver.describe('RFC 0132 §A', 'an anon-authorized run MUST set owner.principalKind "anonymous"'),
+      req('openwop.it.anonymous-actor-audit-opaque.the-run-snapshot-echoes-owner-principalkind-anonymous', 'RFC 0132 §A', 'an anon-authorized run MUST set owner.principalKind "anonymous"'),
     ).toBe('anonymous');
   });
 });