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

package/src/scenarios/export-bundle-portability.test.ts

@@ -30,8 +30,8 @@ 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';
+import { softSkip } from '../lib/soft-skip.js';
 function loadSchema(name: string): Record<string, unknown> {
   return JSON.parse(readFileSync(join(SCHEMAS_DIR, name), 'utf8')) as Record<string, unknown>;
 }
@@ -43,12 +43,12 @@ describe('export-bundle-portability: capability advertisement (RFC 0098 §A, ser
   const portability = (caps.properties as Record<string, { properties?: Record<string, unknown>; if?: unknown; then?: unknown }>).portability;
 
   it('capabilities schema declares portability with its sub-flags + the import⇒dryRun if/then', () => {
-    expect(portability, why('capabilities.md §portability', 'portability MUST be declared')).toBeDefined();
+    expect(portability, req('openwop.it.export-bundle-portability.capabilities-schema-declares-portability-with-its-sub-flags-the-import-dryrun-if', 'capabilities.md §portability', 'portability MUST be declared')).toBeDefined();
     for (const flag of ['export', 'import', 'kinds', 'dryRun']) {
-      expect(portability?.properties?.[flag], why('RFC 0098 §A', `portability.${flag} MUST be declared`)).toBeDefined();
+      expect(portability?.properties?.[flag], req('openwop.it.export-bundle-portability.capabilities-schema-declares-portability-with-its-sub-flags-the-import-dryrun-if', 'RFC 0098 §A', `portability.${flag} MUST be declared`)).toBeDefined();
     }
-    expect(portability?.if, why('RFC 0098 §A', 'a JSON-Schema if/then MUST enforce dryRun:true when import:true')).toBeDefined();
-    expect(portability?.then, why('RFC 0098 §A', 'the then-branch MUST require dryRun')).toBeDefined();
+    expect(portability?.if, req('openwop.it.export-bundle-portability.capabilities-schema-declares-portability-with-its-sub-flags-the-import-dryrun-if', 'RFC 0098 §A', 'a JSON-Schema if/then MUST enforce dryRun:true when import:true')).toBeDefined();
+    expect(portability?.then, req('openwop.it.export-bundle-portability.capabilities-schema-declares-portability-with-its-sub-flags-the-import-dryrun-if', 'RFC 0098 §A', 'the then-branch MUST require dryRun')).toBeDefined();
   });
 });
 
@@ -67,19 +67,19 @@ describe('export-bundle-portability: ExportBundle shape (RFC 0098 §B, server-fr
   };
 
   it('validates a conforming bundle with refs only', () => {
-    expect(validate(good), why('RFC 0098 §B', `a conforming bundle MUST validate. Errors: ${JSON.stringify(validate.errors)}`)).toBe(true);
+    expect(validate(good), req('openwop.it.export-bundle-portability.validates-a-conforming-bundle-with-refs-only', 'RFC 0098 §B', `a conforming bundle MUST validate. Errors: ${JSON.stringify(validate.errors)}`)).toBe(true);
   });
 
   it('rejects a wrong bundleVersion, an unknown kind, and a missing item ref', () => {
-    expect(validate({ ...good, bundleVersion: '2' }), why('RFC 0098 §B', 'an unsupported bundleVersion MUST be rejected')).toBe(false);
-    expect(validate({ ...good, items: [{ kind: 'mystery', ref: 'x', payload: {} }] }), why('RFC 0098 §B', 'an unknown item kind MUST be rejected')).toBe(false);
-    expect(validate({ ...good, items: [{ kind: 'agent', payload: {} }] }), why('RFC 0098 §B', 'an item without a ref MUST be rejected')).toBe(false);
+    expect(validate({ ...good, bundleVersion: '2' }), req('openwop.it.export-bundle-portability.rejects-a-wrong-bundleversion-an-unknown-kind-and-a-missing-item-ref', 'RFC 0098 §B', 'an unsupported bundleVersion MUST be rejected')).toBe(false);
+    expect(validate({ ...good, items: [{ kind: 'mystery', ref: 'x', payload: {} }] }), req('openwop.it.export-bundle-portability.rejects-a-wrong-bundleversion-an-unknown-kind-and-a-missing-item-ref', 'RFC 0098 §B', 'an unknown item kind MUST be rejected')).toBe(false);
+    expect(validate({ ...good, items: [{ kind: 'agent', payload: {} }] }), req('openwop.it.export-bundle-portability.rejects-a-wrong-bundleversion-an-unknown-kind-and-a-missing-item-ref', 'RFC 0098 §B', 'an item without a ref MUST be rejected')).toBe(false);
   });
 
   it('the bundle envelope admits no credential-named field at the root or source level (additionalProperties:false)', () => {
     for (const name of CRED_NAMES) {
-      expect(validate({ ...good, [name]: 'xxx' }), why('SECURITY invariant export-bundle-no-credential-material', `a "${name}" field at the bundle root MUST NOT validate`)).toBe(false);
-      expect(validate({ ...good, source: { ...good.source, [name]: 'xxx' } }), why('SECURITY invariant export-bundle-no-credential-material', `a "${name}" field under source MUST NOT validate`)).toBe(false);
+      expect(validate({ ...good, [name]: 'xxx' }), req('openwop.it.export-bundle-portability.the-bundle-envelope-admits-no-credential-named-field-at-the-root-or-source-level', 'SECURITY invariant export-bundle-no-credential-material', `a "${name}" field at the bundle root MUST NOT validate`)).toBe(false);
+      expect(validate({ ...good, source: { ...good.source, [name]: 'xxx' } }), req('openwop.it.export-bundle-portability.the-bundle-envelope-admits-no-credential-named-field-at-the-root-or-source-level', 'SECURITY invariant export-bundle-no-credential-material', `a "${name}" field under source MUST NOT validate`)).toBe(false);
     }
   });
 });
@@ -93,10 +93,10 @@ describe('export-bundle-portability: content-free event (RFC 0098 §D, server-fr
 
   it('import.applied is in the RunEventType enum and is content-free (counts + refs only)', () => {
     const en = (runEvent.$defs as Record<string, { enum?: string[] }>).RunEventType?.enum ?? [];
-    expect(en).toContain('import.applied');
+    expect(en, req('openwop.it.export-bundle-portability.import-applied-is-in-the-runeventtype-enum-and-is-content-free-counts-refs-only', 'export-bundle-portability.test.ts (no spec citation in file)', 'import.applied is in the RunEventType enum and is content-free (counts + refs only)')).toContain('import.applied');
     const applied = ajv.getSchema('payloads#/$defs/importApplied')!;
-    expect(applied({ bundleOrigin: 'https://host-a.example', counts: { created: 2, skipped: 1 }, secretsToRebind: ['anthropic'] }), why('RFC 0098 §D', 'a content-free import.applied MUST validate')).toBe(true);
-    expect(applied({ bundleOrigin: 'h', counts: { created: 1 }, items: [{ payload: {} }] }), why('SECURITY invariant export-bundle-no-credential-material', 'import.applied MUST NOT carry item payloads')).toBe(false);
+    expect(applied({ bundleOrigin: 'https://host-a.example', counts: { created: 2, skipped: 1 }, secretsToRebind: ['anthropic'] }), req('openwop.it.export-bundle-portability.import-applied-is-in-the-runeventtype-enum-and-is-content-free-counts-refs-only', 'RFC 0098 §D', 'a content-free import.applied MUST validate')).toBe(true);
+    expect(applied({ bundleOrigin: 'h', counts: { created: 1 }, items: [{ payload: {} }] }), req('openwop.it.export-bundle-portability.import-applied-is-in-the-runeventtype-enum-and-is-content-free-counts-refs-only', 'SECURITY invariant export-bundle-no-credential-material', 'import.applied MUST NOT carry item payloads')).toBe(false);
   });
 });
 
@@ -111,10 +111,10 @@ describe('export-bundle-portability: behavioral (RFC 0098 §E, capability-gated)
       items: [{ kind: 'connection-ref', ref: 'c1', payload: { provider: 'anthropic', apiKey: 'sk-conformance-canary' } }],
     };
     const res = await driver.post('/v1/host/sample/import?dryRun=true', { bundle: leaky });
-    if (res.status === 404 || res.status === 403) return; // seam unwired — soft-skip
+    if (res.status === 404 || res.status === 403) return softSkip('blocked', 'precondition not met — `res.status === 404 || res.status === 403` returned early (seam unwired — soft-skip) (seam, prior step, or fixture unavailable)'); // seam unwired — soft-skip
     expect(
       res.status,
-      driver.describe('portability.md §Invariants clause 1', 'a bundle carrying a literal credential value MUST be rejected (422)'),
+      req('openwop.it.export-bundle-portability.importing-a-bundle-with-a-literal-credential-value-is-rejected-422', 'portability.md §Invariants clause 1', 'a bundle carrying a literal credential value MUST be rejected (422)'),
     ).toBe(422);
   });
 });

package/src/scenarios/failure-path.test.ts

@@ -8,6 +8,7 @@ import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { req } from '../lib/requirement-ids.js';
 
 const WORKFLOW_ID = 'conformance-failure';
 const SKIP_NO_FIXTURE = !isFixtureAdvertised(WORKFLOW_ID);
@@ -15,7 +16,7 @@ const SKIP_NO_FIXTURE = !isFixtureAdvertised(WORKFLOW_ID);
 describe.skipIf(SKIP_NO_FIXTURE)('failure: conformance-failure fixture reaches terminal `failed`', () => {
   it('POST /v1/runs accepts the run and run terminates as failed with structured error', async () => {
     const create = await driver.post('/v1/runs', { workflowId: WORKFLOW_ID });
-    expect(create.status, driver.describe(
+    expect(create.status, req('openwop.it.failure-path.post-v1-runs-accepts-the-run-and-run-terminates-as-failed-with-structured-error', 
       'rest-endpoints.md',
       'POST /v1/runs MUST return 201 even for fixtures that fail at runtime',
     )).toBe(201);
@@ -23,22 +24,22 @@ describe.skipIf(SKIP_NO_FIXTURE)('failure: conformance-failure fixture reaches t
 
     const terminal = await pollUntilTerminal(runId);
 
-    expect(terminal.status, driver.describe(
+    expect(terminal.status, req('openwop.it.failure-path.post-v1-runs-accepts-the-run-and-run-terminates-as-failed-with-structured-error', 
       'fixtures.md conformance-failure §Terminal status',
       'fixture MUST reach terminal `failed`',
     )).toBe('failed');
 
-    expect(typeof terminal.error, driver.describe(
+    expect(typeof terminal.error, req('openwop.it.failure-path.post-v1-runs-accepts-the-run-and-run-terminates-as-failed-with-structured-error', 
       'rest-endpoints.md RunSnapshot.error',
       'RunSnapshot.error MUST be a structured object on terminal `failed`',
     )).toBe('object');
-    expect(terminal.error, 'RunSnapshot.error MUST be non-null').not.toBeNull();
+    expect(terminal.error, req('openwop.it.failure-path.post-v1-runs-accepts-the-run-and-run-terminates-as-failed-with-structured-error', 'rest-endpoints.md RunSnapshot.error', 'RunSnapshot.error MUST be non-null')).not.toBeNull();
 
-    expect(typeof terminal.error?.code, driver.describe(
+    expect(typeof terminal.error?.code, req('openwop.it.failure-path.post-v1-runs-accepts-the-run-and-run-terminates-as-failed-with-structured-error', 
       'rest-endpoints.md RunSnapshot.error.code',
       'RunSnapshot.error.code MUST be a string',
     )).toBe('string');
-    expect(typeof terminal.error?.message, driver.describe(
+    expect(typeof terminal.error?.message, req('openwop.it.failure-path.post-v1-runs-accepts-the-run-and-run-terminates-as-failed-with-structured-error', 
       'rest-endpoints.md RunSnapshot.error.message',
       'RunSnapshot.error.message MUST be a string',
     )).toBe('string');

package/src/scenarios/feedback-capability-shape.test.ts

@@ -10,16 +10,17 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { driver } from '../lib/driver.js';
 import { readFeedbackCap } from '../lib/feedback.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 describe('feedback-capability-shape: advertisement (RFC 0056 §A)', () => {
   it('capabilities.feedback is absent or a well-formed object', async () => {
     const cap = await readFeedbackCap();
-    if (cap === null) return; // not advertised — valid
+    if (cap === null) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `cap === null` returned early (not advertised — valid)'); // not advertised — valid
     expect(
       typeof cap.supported,
-      driver.describe('capabilities.schema.json §feedback', 'capabilities.feedback.supported MUST be a boolean when present'),
+      req('openwop.it.feedback-capability-shape.capabilities-feedback-is-absent-or-a-well-formed-object', 'capabilities.schema.json §feedback', 'capabilities.feedback.supported MUST be a boolean when present'),
     ).toBe('boolean');
     if (Array.isArray(cap.targets)) {
       for (const t of cap.targets) {

package/src/scenarios/feedback-correction-redaction.test.ts

@@ -12,6 +12,7 @@ import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { readFeedbackCap, seedRun } from '../lib/feedback.js';
+import { req } from '../lib/requirement-ids.js';
 
 const CANARY = 'sk-canary-rfc0056-do-not-leak-abc123';
 
@@ -30,7 +31,7 @@ describe('feedback-correction-redaction (RFC 0056 §E)', () => {
     const list = await driver.get(`/v1/runs/${runId}/annotations`);
     expect(
       JSON.stringify(list.json ?? {}).includes(CANARY),
-      driver.describe('RFC 0056 §E', 'secret-shaped material MUST be redacted before persistence/listing (SR-1)'),
+      req('openwop.it.feedback-correction-redaction.secret-shaped-material-in-correction-note-is-redacted-in-the-annotation-list', 'RFC 0056 §E', 'secret-shaped material MUST be redacted before persistence/listing (SR-1)'),
     ).toBe(false);
   });
 });

package/src/scenarios/feedback-cross-tenant-isolation.test.ts

@@ -16,6 +16,7 @@ import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { readFeedbackCap, seedRun } from '../lib/feedback.js';
+import { req } from '../lib/requirement-ids.js';
 
 describe('feedback-cross-tenant-isolation (RFC 0056 §E)', () => {
   it('a run\'s annotation list contains only that run\'s annotations', async () => {
@@ -31,7 +32,7 @@ describe('feedback-cross-tenant-isolation (RFC 0056 §E)', () => {
     for (const a of ann) {
       expect(
         a.target?.runId,
-        driver.describe('RFC 0056 §E', 'an annotation list MUST contain only this run\'s annotations (CTI-1)'),
+        req('openwop.it.feedback-cross-tenant-isolation.a-run-s-annotation-list-contains-only-that-run-s-annotations', 'RFC 0056 §E', 'an annotation list MUST contain only this run\'s annotations (CTI-1)'),
       ).toBe(runId);
     }
   });

package/src/scenarios/feedback-fork-not-copied.test.ts

@@ -12,6 +12,7 @@ import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { readFeedbackCap, seedRun } from '../lib/feedback.js';
+import { req } from '../lib/requirement-ids.js';
 
 describe('feedback-fork-not-copied (RFC 0056 §D)', () => {
   it('a fork of an annotated run starts with zero annotations', async () => {
@@ -25,7 +26,7 @@ describe('feedback-fork-not-copied (RFC 0056 §D)', () => {
     try {
       await pollUntilTerminal(runId, { timeoutMs: 10_000 });
     } catch {
-      return;
+      return softSkip('blocked', 'precondition not met — an earlier step threw (seam, prior step, or fixture unavailable)');
     }
     const fork = await driver.post(`/v1/runs/${runId}:fork`, { fromSeq: 0, mode: 'branch' });
     if (fork.status !== 200 && fork.status !== 201) return softSkip('inapplicable', 'fork unsupported — soft-skip (fork.status !== 200 && fork.status !== 201)');
@@ -35,7 +36,7 @@ describe('feedback-fork-not-copied (RFC 0056 §D)', () => {
     const ann = (list.json as { annotations?: unknown[] } | undefined)?.annotations ?? [];
     expect(
       ann.length,
-      driver.describe('RFC 0056 §D', 'annotations are a side-store and MUST NOT be copied into a fork'),
+      req('openwop.it.feedback-fork-not-copied.a-fork-of-an-annotated-run-starts-with-zero-annotations', 'RFC 0056 §D', 'annotations are a side-store and MUST NOT be copied into a fork'),
     ).toBe(0);
   });
 });

package/src/scenarios/feedback-on-terminal-run.test.ts

@@ -11,6 +11,7 @@ import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { readFeedbackCap, seedRun } from '../lib/feedback.js';
+import { req } from '../lib/requirement-ids.js';
 
 describe('feedback-on-terminal-run (RFC 0056 §C)', () => {
   it('annotating a terminal run is accepted', async () => {
@@ -21,13 +22,13 @@ describe('feedback-on-terminal-run (RFC 0056 §C)', () => {
     try {
       await pollUntilTerminal(runId, { timeoutMs: 10_000 });
     } catch {
-      return; // run didn't reach terminal in time — soft-skip
+      return softSkip('blocked', 'precondition not met — an earlier step threw (run didn\'t reach terminal in time — soft-skip) (seam, prior step, or fixture unavailable)'); // run didn't reach terminal in time — soft-skip
     }
     const post = await driver.post(`/v1/runs/${runId}/annotations`, { signal: { kind: 'flag' }, note: 'post-hoc review' });
     if (post.status === 501 || post.status === 404) return softSkip('blocked', 'precondition not met — `post.status === 501 || post.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(
       post.status,
-      driver.describe('RFC 0056 §C', 'a host MUST accept an annotation on a terminal run'),
+      req('openwop.it.feedback-on-terminal-run.annotating-a-terminal-run-is-accepted', 'RFC 0056 §C', 'a host MUST accept an annotation on a terminal run'),
     ).toBe(201);
   });
 });

package/src/scenarios/feedback-record-and-list.test.ts

@@ -10,6 +10,7 @@ import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { readFeedbackCap, seedRun } from '../lib/feedback.js';
+import { req } from '../lib/requirement-ids.js';
 
 describe('feedback-record-and-list (RFC 0056 §C)', () => {
   it('POST an annotation then GET returns it', async () => {
@@ -21,7 +22,7 @@ describe('feedback-record-and-list (RFC 0056 §C)', () => {
     if (post.status === 501 || post.status === 404) return softSkip('blocked', 'precondition not met — `post.status === 501 || post.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(
       post.status,
-      driver.describe('RFC 0056 §C', 'POST annotation returns 201 with the persisted annotation'),
+      req('openwop.it.feedback-record-and-list.post-an-annotation-then-get-returns-it', 'RFC 0056 §C', 'POST annotation returns 201 with the persisted annotation'),
     ).toBe(201);
     const created = post.json as { annotationId?: string };
     expect(typeof created.annotationId).toBe('string');

package/src/scenarios/feedback-unsupported-501.test.ts

@@ -14,6 +14,7 @@ import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { readFeedbackCap } from '../lib/feedback.js';
+import { req } from '../lib/requirement-ids.js';
 
 describe('feedback-unsupported-501 (RFC 0056 §C)', () => {
   it('POST annotations returns 501 capability_not_provided when feedback is unadvertised', async () => {
@@ -25,7 +26,7 @@ describe('feedback-unsupported-501 (RFC 0056 §C)', () => {
     if (res.status === 404 || res.status === 405) return softSkip('blocked', 'route absent — host predates RFC 0056');
     expect(
       res.status,
-      driver.describe('rest-endpoints.md / RFC 0056 §C', 'unadvertised feedback MUST return 501, not 404'),
+      req('openwop.it.feedback-unsupported-501.post-annotations-returns-501-capability-not-provided-when-feedback-is-unadvertis', 'rest-endpoints.md / RFC 0056 §C', 'unadvertised feedback MUST return 501, not 404'),
     ).toBe(501);
     const code = (res.json as { error?: string } | undefined)?.error;
     expect(code).toBe('capability_not_provided');

package/src/scenarios/fixtures-gating.test.ts

@@ -27,6 +27,7 @@ import {
   __resetForTests,
 } from '../lib/fixtures.js';
 import { isScenarioOptedOut } from '../lib/env.js';
+import { req } from '../lib/requirement-ids.js';
 
 beforeEach(() => {
   __resetForTests();
@@ -34,54 +35,54 @@ beforeEach(() => {
 
 describe('fixtures: cache lifecycle', () => {
   it('returns false from isFixtureAdvertised before cache is populated', () => {
-    expect(isFixtureCacheReady()).toBe(false);
+    expect(isFixtureCacheReady(), req('openwop.it.fixtures-gating.returns-false-from-isfixtureadvertised-before-cache-is-populated', 'RFC 0003', 'returns false from isFixtureAdvertised before cache is populated')).toBe(false);
     expect(isFixtureAdvertised('conformance-noop')).toBe(false);
   });
 
   it('returns null from getAdvertisedFixtures before cache is populated', () => {
-    expect(getAdvertisedFixtures()).toBe(null);
+    expect(getAdvertisedFixtures(), req('openwop.it.fixtures-gating.returns-null-from-getadvertisedfixtures-before-cache-is-populated', 'RFC 0003', 'returns null from getAdvertisedFixtures before cache is populated')).toBe(null);
   });
 
   it('isFixtureCacheReady becomes true after setAdvertisedFixtures', () => {
     setAdvertisedFixtures({ fixtures: [] });
-    expect(isFixtureCacheReady()).toBe(true);
+    expect(isFixtureCacheReady(), req('openwop.it.fixtures-gating.isfixturecacheready-becomes-true-after-setadvertisedfixtures', 'RFC 0003', 'isFixtureCacheReady becomes true after setAdvertisedFixtures')).toBe(true);
   });
 
   it('returns empty set when called with null', () => {
     setAdvertisedFixtures(null);
-    expect(getAdvertisedFixtures()?.size).toBe(0);
+    expect(getAdvertisedFixtures()?.size, req('openwop.it.fixtures-gating.returns-empty-set-when-called-with-null', 'RFC 0003', 'returns empty set when called with null')).toBe(0);
     expect(isFixtureAdvertised('conformance-noop')).toBe(false);
   });
 
   it('returns empty set when called with undefined', () => {
     setAdvertisedFixtures(undefined);
-    expect(getAdvertisedFixtures()?.size).toBe(0);
+    expect(getAdvertisedFixtures()?.size, req('openwop.it.fixtures-gating.returns-empty-set-when-called-with-undefined', 'RFC 0003', 'returns empty set when called with undefined')).toBe(0);
   });
 });
 
 describe('fixtures: discovery-payload parsing', () => {
   it('populates cache from a well-formed payload', () => {
     setAdvertisedFixtures({ fixtures: ['conformance-noop', 'conformance-delay'] });
-    expect(isFixtureAdvertised('conformance-noop')).toBe(true);
+    expect(isFixtureAdvertised('conformance-noop'), req('openwop.it.fixtures-gating.populates-cache-from-a-well-formed-payload', 'RFC 0003', 'populates cache from a well-formed payload')).toBe(true);
     expect(isFixtureAdvertised('conformance-delay')).toBe(true);
     expect(isFixtureAdvertised('conformance-not-advertised')).toBe(false);
   });
 
   it('treats absent fixtures field as "advertises none"', () => {
     setAdvertisedFixtures({ protocolVersion: '1.0' });
-    expect(getAdvertisedFixtures()?.size).toBe(0);
+    expect(getAdvertisedFixtures()?.size, req('openwop.it.fixtures-gating.treats-absent-fixtures-field-as-advertises-none', 'RFC 0003', 'treats absent fixtures field as "advertises none"')).toBe(0);
     expect(isFixtureAdvertised('conformance-noop')).toBe(false);
   });
 
   it('treats non-array fixtures field as "advertises none"', () => {
     setAdvertisedFixtures({ fixtures: 'conformance-noop' as unknown as string[] });
-    expect(getAdvertisedFixtures()?.size).toBe(0);
+    expect(getAdvertisedFixtures()?.size, req('openwop.it.fixtures-gating.treats-non-array-fixtures-field-as-advertises-none', 'RFC 0003', 'treats non-array fixtures field as "advertises none"')).toBe(0);
   });
 
   it('filters out empty-string entries', () => {
     setAdvertisedFixtures({ fixtures: ['', 'conformance-noop', ''] });
     const set = getAdvertisedFixtures();
-    expect(set?.size).toBe(1);
+    expect(set?.size, req('openwop.it.fixtures-gating.filters-out-empty-string-entries', 'RFC 0003', 'filters out empty-string entries')).toBe(1);
     expect(isFixtureAdvertised('conformance-noop')).toBe(true);
   });
 
@@ -89,7 +90,7 @@ describe('fixtures: discovery-payload parsing', () => {
     setAdvertisedFixtures({
       fixtures: ['conformance-noop', 42, null, undefined] as unknown as string[],
     });
-    expect(getAdvertisedFixtures()?.size).toBe(1);
+    expect(getAdvertisedFixtures()?.size, req('openwop.it.fixtures-gating.filters-out-non-string-entries', 'RFC 0003', 'filters out non-string entries')).toBe(1);
     expect(isFixtureAdvertised('conformance-noop')).toBe(true);
   });
 
@@ -97,7 +98,7 @@ describe('fixtures: discovery-payload parsing', () => {
     setAdvertisedFixtures({
       fixtures: ['conformance-noop', 'openwop.smoke.byok', 'acme.fixture.foo'],
     });
-    expect(isFixtureAdvertised('openwop.smoke.byok')).toBe(true);
+    expect(isFixtureAdvertised('openwop.smoke.byok'), req('openwop.it.fixtures-gating.passes-vendor-prefixed-ids-through-unchanged', 'RFC 0003', 'passes vendor-prefixed ids through unchanged')).toBe(true);
     expect(isFixtureAdvertised('acme.fixture.foo')).toBe(true);
   });
 
@@ -105,14 +106,14 @@ describe('fixtures: discovery-payload parsing', () => {
     setAdvertisedFixtures({
       fixtures: ['conformance-noop', 'conformance-noop', 'conformance-noop'],
     });
-    expect(getAdvertisedFixtures()?.size).toBe(1);
+    expect(getAdvertisedFixtures()?.size, req('openwop.it.fixtures-gating.deduplicates-entries-via-set-semantics', 'RFC 0003', 'deduplicates entries via Set semantics')).toBe(1);
   });
 });
 
 describe('fixtures: cache replacement (not merge)', () => {
   it('a second setAdvertisedFixtures call replaces the cache, not merges', () => {
     setAdvertisedFixtures({ fixtures: ['conformance-noop'] });
-    expect(isFixtureAdvertised('conformance-noop')).toBe(true);
+    expect(isFixtureAdvertised('conformance-noop'), req('openwop.it.fixtures-gating.a-second-setadvertisedfixtures-call-replaces-the-cache-not-merges', 'RFC 0003', 'a second setAdvertisedFixtures call replaces the cache, not merges')).toBe(true);
 
     setAdvertisedFixtures({ fixtures: ['conformance-delay'] });
     expect(isFixtureAdvertised('conformance-noop')).toBe(false);
@@ -122,7 +123,7 @@ describe('fixtures: cache replacement (not merge)', () => {
   it('replacing with empty array means no fixtures advertised', () => {
     setAdvertisedFixtures({ fixtures: ['conformance-noop'] });
     setAdvertisedFixtures({ fixtures: [] });
-    expect(getAdvertisedFixtures()?.size).toBe(0);
+    expect(getAdvertisedFixtures()?.size, req('openwop.it.fixtures-gating.replacing-with-empty-array-means-no-fixtures-advertised', 'RFC 0003', 'replacing with empty array means no fixtures advertised')).toBe(0);
     expect(isFixtureAdvertised('conformance-noop')).toBe(false);
   });
 });
@@ -130,7 +131,7 @@ describe('fixtures: cache replacement (not merge)', () => {
 describe('fixtures: __resetForTests', () => {
   it('returns the cache to the pre-populated state', () => {
     setAdvertisedFixtures({ fixtures: ['conformance-noop'] });
-    expect(isFixtureCacheReady()).toBe(true);
+    expect(isFixtureCacheReady(), req('openwop.it.fixtures-gating.returns-the-cache-to-the-pre-populated-state', 'RFC 0003', 'returns the cache to the pre-populated state')).toBe(true);
     __resetForTests();
     expect(isFixtureCacheReady()).toBe(false);
     expect(getAdvertisedFixtures()).toBe(null);
@@ -153,7 +154,7 @@ describe('fixtures: OPENWOP_OPTED_OUT_FIXTURES env filtering', () => {
     setAdvertisedFixtures({
       fixtures: ['conformance-noop', 'conformance-dispatch-input-mapping'],
     });
-    expect(isFixtureAdvertised('conformance-noop')).toBe(true);
+    expect(isFixtureAdvertised('conformance-noop'), req('openwop.it.fixtures-gating.exact-id-is-filtered-out-of-the-advertised-set', 'RFC 0003', 'exact id is filtered out of the advertised set')).toBe(true);
     expect(isFixtureAdvertised('conformance-dispatch-input-mapping')).toBe(false);
   });
 
@@ -167,7 +168,7 @@ describe('fixtures: OPENWOP_OPTED_OUT_FIXTURES env filtering', () => {
         'conformance-dispatch-cross-worker-handoff',
       ],
     });
-    expect(isFixtureAdvertised('conformance-noop')).toBe(true);
+    expect(isFixtureAdvertised('conformance-noop'), req('openwop.it.fixtures-gating.trailing-glob-filters-every-matching-id', 'RFC 0003', 'trailing-* glob filters every matching id')).toBe(true);
     expect(isFixtureAdvertised('conformance-dispatch-input-mapping')).toBe(false);
     expect(isFixtureAdvertised('conformance-dispatch-output-mapping')).toBe(false);
     expect(isFixtureAdvertised('conformance-dispatch-cross-worker-handoff')).toBe(false);
@@ -184,7 +185,7 @@ describe('fixtures: OPENWOP_OPTED_OUT_FIXTURES env filtering', () => {
         'conformance-subworkflow-parent',
       ],
     });
-    expect(isFixtureAdvertised('conformance-noop')).toBe(true);
+    expect(isFixtureAdvertised('conformance-noop'), req('openwop.it.fixtures-gating.exact-glob-entries-mix-in-one-env-value', 'RFC 0003', 'exact + glob entries mix in one env value')).toBe(true);
     expect(isFixtureAdvertised('conformance-dispatch-input-mapping')).toBe(false);
     expect(isFixtureAdvertised('conformance-subworkflow-input-mapping')).toBe(false);
     // subworkflow-parent is NOT subworkflow-input-mapping — exact match required.
@@ -194,33 +195,33 @@ describe('fixtures: OPENWOP_OPTED_OUT_FIXTURES env filtering', () => {
   it('non-matching opt-out entries leave the advertised set intact', () => {
     process.env.OPENWOP_OPTED_OUT_FIXTURES = 'conformance-nonexistent';
     setAdvertisedFixtures({ fixtures: ['conformance-noop'] });
-    expect(isFixtureAdvertised('conformance-noop')).toBe(true);
+    expect(isFixtureAdvertised('conformance-noop'), req('openwop.it.fixtures-gating.non-matching-opt-out-entries-leave-the-advertised-set-intact', 'RFC 0003', 'non-matching opt-out entries leave the advertised set intact')).toBe(true);
     expect(getAdvertisedFixtures()?.size).toBe(1);
   });
 
   it('empty / whitespace-only entries are ignored', () => {
     process.env.OPENWOP_OPTED_OUT_FIXTURES = ', ,conformance-noop, ,';
     setAdvertisedFixtures({ fixtures: ['conformance-noop', 'conformance-delay'] });
-    expect(isFixtureAdvertised('conformance-noop')).toBe(false);
+    expect(isFixtureAdvertised('conformance-noop'), req('openwop.it.fixtures-gating.empty-whitespace-only-entries-are-ignored', 'RFC 0003', 'empty / whitespace-only entries are ignored')).toBe(false);
     expect(isFixtureAdvertised('conformance-delay')).toBe(true);
   });
 
   it('unset env behaves identically to no filtering', () => {
     delete process.env.OPENWOP_OPTED_OUT_FIXTURES;
     setAdvertisedFixtures({ fixtures: ['conformance-noop', 'conformance-delay'] });
-    expect(getAdvertisedFixtures()?.size).toBe(2);
+    expect(getAdvertisedFixtures()?.size, req('openwop.it.fixtures-gating.unset-env-behaves-identically-to-no-filtering', 'RFC 0003', 'unset env behaves identically to no filtering')).toBe(2);
   });
 
   it('whitespace-only env behaves identically to unset', () => {
     process.env.OPENWOP_OPTED_OUT_FIXTURES = '   ';
     setAdvertisedFixtures({ fixtures: ['conformance-noop'] });
-    expect(isFixtureAdvertised('conformance-noop')).toBe(true);
+    expect(isFixtureAdvertised('conformance-noop'), req('openwop.it.fixtures-gating.whitespace-only-env-behaves-identically-to-unset', 'RFC 0003', 'whitespace-only env behaves identically to unset')).toBe(true);
   });
 
   it('env is re-read on each setAdvertisedFixtures call (no memoization)', () => {
     process.env.OPENWOP_OPTED_OUT_FIXTURES = 'conformance-noop';
     setAdvertisedFixtures({ fixtures: ['conformance-noop', 'conformance-delay'] });
-    expect(isFixtureAdvertised('conformance-noop')).toBe(false);
+    expect(isFixtureAdvertised('conformance-noop'), req('openwop.it.fixtures-gating.env-is-re-read-on-each-setadvertisedfixtures-call-no-memoization', 'RFC 0003', 'env is re-read on each setAdvertisedFixtures call (no memoization)')).toBe(false);
 
     // Mutate env and re-set — the new env value MUST take effect.
     process.env.OPENWOP_OPTED_OUT_FIXTURES = 'conformance-delay';
@@ -239,19 +240,19 @@ describe('env: OPENWOP_OPTED_OUT_SCENARIOS predicate', () => {
 
   it('unset env → every scenario id returns false', () => {
     delete process.env.OPENWOP_OPTED_OUT_SCENARIOS;
-    expect(isScenarioOptedOut('otel-trace-propagation-subworkflow')).toBe(false);
+    expect(isScenarioOptedOut('otel-trace-propagation-subworkflow'), req('openwop.it.fixtures-gating.unset-env-every-scenario-id-returns-false', 'RFC 0003', 'unset env → every scenario id returns false')).toBe(false);
     expect(isScenarioOptedOut('any-scenario')).toBe(false);
   });
 
   it('exact scenario id match returns true', () => {
     process.env.OPENWOP_OPTED_OUT_SCENARIOS = 'otel-trace-propagation-subworkflow';
-    expect(isScenarioOptedOut('otel-trace-propagation-subworkflow')).toBe(true);
+    expect(isScenarioOptedOut('otel-trace-propagation-subworkflow'), req('openwop.it.fixtures-gating.exact-scenario-id-match-returns-true', 'RFC 0003', 'exact scenario id match returns true')).toBe(true);
     expect(isScenarioOptedOut('otel-trace-propagation')).toBe(false);
   });
 
   it('CSV with multiple ids matches each entry exactly', () => {
     process.env.OPENWOP_OPTED_OUT_SCENARIOS = 'scenario-a,scenario-b,scenario-c';
-    expect(isScenarioOptedOut('scenario-a')).toBe(true);
+    expect(isScenarioOptedOut('scenario-a'), req('openwop.it.fixtures-gating.csv-with-multiple-ids-matches-each-entry-exactly', 'RFC 0003', 'CSV with multiple ids matches each entry exactly')).toBe(true);
     expect(isScenarioOptedOut('scenario-b')).toBe(true);
     expect(isScenarioOptedOut('scenario-c')).toBe(true);
     expect(isScenarioOptedOut('scenario-d')).toBe(false);
@@ -259,13 +260,13 @@ describe('env: OPENWOP_OPTED_OUT_SCENARIOS predicate', () => {
 
   it('whitespace around entries is tolerated', () => {
     process.env.OPENWOP_OPTED_OUT_SCENARIOS = '  scenario-a , scenario-b  ';
-    expect(isScenarioOptedOut('scenario-a')).toBe(true);
+    expect(isScenarioOptedOut('scenario-a'), req('openwop.it.fixtures-gating.whitespace-around-entries-is-tolerated', 'RFC 0003', 'whitespace around entries is tolerated')).toBe(true);
     expect(isScenarioOptedOut('scenario-b')).toBe(true);
   });
 
   it('env is re-read on each call (no memoization)', () => {
     process.env.OPENWOP_OPTED_OUT_SCENARIOS = 'scenario-a';
-    expect(isScenarioOptedOut('scenario-a')).toBe(true);
+    expect(isScenarioOptedOut('scenario-a'), req('openwop.it.fixtures-gating.env-is-re-read-on-each-call-no-memoization', 'RFC 0003', 'env is re-read on each call (no memoization)')).toBe(true);
     expect(isScenarioOptedOut('scenario-b')).toBe(false);
 
     process.env.OPENWOP_OPTED_OUT_SCENARIOS = 'scenario-b';