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

package/src/scenarios/auth-subject-link.test.ts

@@ -27,6 +27,7 @@ import { describe, it, expect } from 'vitest';
 import { softSkip, seamAbsent } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const SAML_PROFILE = 'openwop-auth-saml';
 const SCIM_PROFILE = 'openwop-auth-scim';
@@ -65,7 +66,7 @@ describe('auth-subject-link: advertisement shape (RFC 0159 §B + RFC 0164 §A.3)
     const profiles = auth.profiles ?? [];
     expect(
       profiles.includes(SAML_PROFILE) && profiles.includes(SCIM_PROFILE),
-      driver.describe(
+      req('openwop.it.auth-subject-link.subjectlinking-true-is-only-claimed-alongside-both-saml-and-scim-profiles', 
         'auth-profiles.md §Subject linking',
         'a host MUST NOT set capabilities.auth.subjectLinking:true unless BOTH openwop-auth-saml and openwop-auth-scim are advertised',
       ),
@@ -83,14 +84,14 @@ describe('auth-subject-link: advertisement shape (RFC 0159 §B + RFC 0164 §A.3)
     // absence alongside both profiles is a conformance FAILURE.
     expect(
       auth.subjectLinking,
-      driver.describe(
+      req('openwop.it.auth-subject-link.advertising-both-profiles-requires-subjectlinking-true-a-subjectlinkkey-rfc-0164', 
         'auth-profiles.md §Subject linking (RFC 0164)',
         'RFC 0164 §A.3: a host advertising BOTH openwop-auth-saml and openwop-auth-scim MUST advertise capabilities.auth.subjectLinking:true — the leaver contract follows the profile pair; omitting the flag is the vulnerable pre-0164 shape',
       ),
     ).toBe(true);
     expect(
       typeof auth.subjectLinkKey === 'string' && SUBJECT_LINK_KEY_CLASSES.includes(auth.subjectLinkKey),
-      driver.describe(
+      req('openwop.it.auth-subject-link.advertising-both-profiles-requires-subjectlinking-true-a-subjectlinkkey-rfc-0164', 
         'auth-profiles.md §Subject linking (RFC 0164)',
         `RFC 0164 §A.3 / RFC 0163 §A.1: a host advertising both profiles MUST advertise subjectLinkKey ∈ {${SUBJECT_LINK_KEY_CLASSES.join(', ')}}`,
       ),
@@ -116,7 +117,7 @@ describe('auth-subject-link: cross-lane deactivation (RFC 0159 §A.3 — opt-in)
       userName: 'r.smith',
     });
     if (provision.status === 404) return softSkip('blocked', 'seam unwired');
-    expect(provision.status, driver.describe('auth-profiles.md §Subject linking', 'SCIM provisioning MUST succeed')).toBeLessThan(400);
+    expect(provision.status, req('openwop.it.auth-subject-link.a-scim-deactivation-fail-closes-the-linked-saml-identity', 'auth-profiles.md §Subject linking', 'SCIM provisioning MUST succeed')).toBeLessThan(400);
 
     // 2. A valid SAML assertion whose persistent NameID equals the externalId
     //    links to the same subject and authenticates.
@@ -124,19 +125,19 @@ describe('auth-subject-link: cross-lane deactivation (RFC 0159 §A.3 — opt-in)
     if (before.status === 404) return softSkip('blocked', 'seam unwired');
     expect(
       (before.json as { authenticated?: boolean } | undefined)?.authenticated,
-      driver.describe('auth-profiles.md §Subject linking', 'a valid linked SAML assertion authenticates before deactivation'),
+      req('openwop.it.auth-subject-link.a-scim-deactivation-fail-closes-the-linked-saml-identity', 'auth-profiles.md §Subject linking', 'a valid linked SAML assertion authenticates before deactivation'),
     ).toBe(true);
 
     // 3. SCIM-deactivate the provisioned user.
     const deactivate = await driver.post('/v1/host/sample/auth/scim/provision', { scimUrl, op: 'deactivate-user', externalId });
-    expect(deactivate.status, driver.describe('auth-profiles.md §Subject linking', 'SCIM deactivation MUST succeed')).toBeLessThan(400);
+    expect(deactivate.status, req('openwop.it.auth-subject-link.a-scim-deactivation-fail-closes-the-linked-saml-identity', 'auth-profiles.md §Subject linking', 'SCIM deactivation MUST succeed')).toBeLessThan(400);
 
     // 4. THE CONTRACT: a subsequent SAML assertion for the linked subject MUST
     //    NOT yield an authorized decision (fail-closed across the link).
     const after = await driver.post('/v1/host/sample/auth/saml/validate', { idpUrl, variant: 'valid', nameId: externalId });
     expect(
       (after.json as { authenticated?: boolean } | undefined)?.authenticated === true,
-      driver.describe(
+      req('openwop.it.auth-subject-link.a-scim-deactivation-fail-closes-the-linked-saml-identity', 
         'auth-profiles.md §Subject linking',
         'RFC 0159 §A.3: after a SCIM deactivation the LINKED SAML identity MUST be denied (a provisioned leaver cannot still SSO in)',
       ),
@@ -169,9 +170,9 @@ describe('auth-subject-link: link-key hygiene (RFC 0159 §A.2 — opt-in)', () =
       // Conforming: the host rejected a mutable-key link outright.
       expect(
         link.status,
-        driver.describe('auth-profiles.md §Subject linking', 'RFC 0159 §A.2: a link on a mutable/PII key (email) MUST be rejected'),
+        req('openwop.it.auth-subject-link.a-mutable-pii-link-key-email-never-produces-a-cross-lane-pass', 'auth-profiles.md §Subject linking', 'RFC 0159 §A.2: a link on a mutable/PII key (email) MUST be rejected'),
       ).toBeGreaterThanOrEqual(400);
-      return;
+      return softSkip('blocked', 'precondition not met — `link.status >= 400` returned early (seam, prior step, or fixture unavailable)');
     }
 
     // If the host accepted the request, it MUST NOT have formed a cross-lane
@@ -183,7 +184,7 @@ describe('auth-subject-link: link-key hygiene (RFC 0159 §A.2 — opt-in)', () =
     const other = await driver.post('/v1/host/sample/auth/saml/validate', { idpUrl, variant: 'valid', nameId: 'idp-op-DIFFERENT' });
     expect(
       (other.json as { linkedDenied?: boolean } | undefined)?.linkedDenied === true,
-      driver.describe(
+      req('openwop.it.auth-subject-link.a-mutable-pii-link-key-email-never-produces-a-cross-lane-pass', 
         'auth-profiles.md §Subject linking',
         'RFC 0159 §A.2: a mutable-key (email) operation MUST NOT drive a cross-lane deny on any opaque subject',
       ),

package/src/scenarios/auth.test.ts

@@ -8,6 +8,7 @@
 
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
+import { req } from '../lib/requirement-ids.js';
 
 const KNOWN_AUTHED_PATH = '/v1/runs';
 
@@ -19,17 +20,17 @@ describe('auth: missing credential', () => {
       { authenticated: false },
     );
 
-    expect(res.status, driver.describe(
+    expect(res.status, req('openwop.it.auth.returns-401-with-canonical-error-envelope-per-auth-md-3', 
       'auth.md §3',
       'request without Authorization header MUST return 401',
     )).toBe(401);
 
     const body = res.json as { error?: unknown; message?: unknown } | undefined;
-    expect(typeof body?.error, driver.describe(
+    expect(typeof body?.error, req('openwop.it.auth.returns-401-with-canonical-error-envelope-per-auth-md-3', 
       'auth.md §3 + rest-endpoints.md error envelope',
       'response body MUST include `error` (machine code) string',
     )).toBe('string');
-    expect(typeof body?.message, driver.describe(
+    expect(typeof body?.message, req('openwop.it.auth.returns-401-with-canonical-error-envelope-per-auth-md-3', 
       'auth.md §3 + rest-endpoints.md error envelope',
       'response body MUST include `message` (human description) string',
     )).toBe('string');
@@ -47,7 +48,7 @@ describe('auth: invalid credential', () => {
       },
     );
 
-    expect(res.status, driver.describe(
+    expect(res.status, req('openwop.it.auth.returns-401-not-200-not-403-per-auth-md-3', 
       'auth.md §3',
       'request with invalid Authorization MUST return 401, not 403',
     )).toBe(401);

package/src/scenarios/authorization-fail-closed.test.ts

@@ -26,6 +26,7 @@ import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 interface DiscoveryAuthorization {
   supported?: boolean;
@@ -50,7 +51,7 @@ describe('authorization-fail-closed: advertisement shape (RFC 0049 §C)', () =>
     if (!authz?.supported || authz.failClosed === undefined) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!authz?.supported || authz.failClosed === undefined` returned early');
     expect(
       authz.failClosed,
-      driver.describe('RFC 0049 §C', 'capabilities.authorization.failClosed MUST be `true`'),
+      req('openwop.it.authorization-fail-closed.failclosed-is-exactly-true-when-authorization-is-supported', 'RFC 0049 §C', 'capabilities.authorization.failClosed MUST be `true`'),
     ).toBe(true);
   });
 });
@@ -73,7 +74,7 @@ describe('authorization-fail-closed: absent/unseeded role MUST deny (RFC 0049 §
     const decision = res.json as { allowed?: boolean } | undefined;
     expect(
       decision?.allowed,
-      driver.describe(
+      req('openwop.it.authorization-fail-closed.a-decision-for-an-unseeded-role-principal-resolves-allowed-false', 
         'SECURITY/invariants.yaml authorization-fail-closed',
         'an absent/unseeded role MUST deny (allowed=false); the host MUST NOT default-allow',
       ),

package/src/scenarios/authorization-roles-shape.test.ts

@@ -21,6 +21,8 @@
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 interface DiscoveryRole {
   role?: string;
@@ -48,10 +50,10 @@ async function readAuthorization(): Promise<DiscoveryAuthorization | null> {
 describe('authorization-roles-shape: advertisement shape (RFC 0049 §A)', () => {
   it('capabilities.authorization is either absent or well-formed', async () => {
     const authz = await readAuthorization();
-    if (authz === null) return; // host doesn't advertise authorization at all
+    if (authz === null) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `authz === null` returned early (host doesn\'t advertise authorization at all)'); // host doesn't advertise authorization at all
     expect(
       typeof authz.supported,
-      driver.describe(
+      req('openwop.it.authorization-roles-shape.capabilities-authorization-is-either-absent-or-well-formed', 
         'capabilities.schema.json §authorization',
         'capabilities.authorization.supported MUST be a boolean when authorization is advertised',
       ),
@@ -60,24 +62,24 @@ describe('authorization-roles-shape: advertisement shape (RFC 0049 §A)', () =>
 
   it('failClosed, when present, is exactly true (RFC 0049 §C)', async () => {
     const authz = await readAuthorization();
-    if (!authz?.supported || authz.failClosed === undefined) return;
+    if (!authz?.supported || authz.failClosed === undefined) return softSkip('blocked', 'precondition not met — `!authz?.supported || authz.failClosed === undefined` returned early (seam, prior step, or fixture unavailable)');
     expect(
       authz.failClosed,
-      driver.describe('RFC 0049 §C', 'capabilities.authorization.failClosed MUST be `true` (fail-closed)'),
+      req('openwop.it.authorization-roles-shape.failclosed-when-present-is-exactly-true-rfc-0049-c', 'RFC 0049 §C', 'capabilities.authorization.failClosed MUST be `true` (fail-closed)'),
     ).toBe(true);
   });
 
   it('every advertised role has a non-empty role name + a scopes array', async () => {
     const authz = await readAuthorization();
-    if (!authz?.supported || authz.roles === undefined) return;
+    if (!authz?.supported || authz.roles === undefined) return softSkip('blocked', 'precondition not met — `!authz?.supported || authz.roles === undefined` returned early (seam, prior step, or fixture unavailable)');
     for (const entry of authz.roles) {
       expect(
         typeof entry.role === 'string' && entry.role.length > 0,
-        driver.describe('RFC 0049 §A', 'each capabilities.authorization.roles[] entry MUST declare a non-empty role'),
+        req('openwop.it.authorization-roles-shape.every-advertised-role-has-a-non-empty-role-name-a-scopes-array', 'RFC 0049 §A', 'each capabilities.authorization.roles[] entry MUST declare a non-empty role'),
       ).toBe(true);
       expect(
         Array.isArray(entry.scopes),
-        driver.describe('RFC 0049 §A', 'each role MUST declare a scopes array'),
+        req('openwop.it.authorization-roles-shape.every-advertised-role-has-a-non-empty-role-name-a-scopes-array', 'RFC 0049 §A', 'each role MUST declare a scopes array'),
       ).toBe(true);
     }
   });

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

@@ -10,6 +10,8 @@
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { discoveryFamilies } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 interface DiscoveryDoc {
   capabilities?: Record<string, unknown>;
@@ -30,10 +32,10 @@ async function call(tenantId: string, op: string, args: Record<string, unknown>)
 describe('blob-cross-tenant-isolation: advertisement shape (RFC 0019)', () => {
   it('capabilities.blobStorage is either absent or a well-formed object', async () => {
     const cap = await readCap();
-    if (cap === null) return;
+    if (cap === null) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `cap === null` returned early');
     expect(
       typeof cap.supported,
-      driver.describe(
+      req('openwop.it.blob-cross-tenant-isolation.capabilities-blobstorage-is-either-absent-or-a-well-formed-object', 
         'capabilities.schema.json §blobStorage',
         'capabilities.blobStorage.supported MUST be a boolean when present',
       ),
@@ -44,7 +46,7 @@ describe('blob-cross-tenant-isolation: advertisement shape (RFC 0019)', () => {
 describe('blob-cross-tenant-isolation: behavioral (RFC 0019 §B point 1)', () => {
   it('put under tenant A → get under tenant B with same key returns found:false', async () => {
     const cap = await readCap();
-    if (!cap || cap.supported !== true) return;
+    if (!cap || cap.supported !== true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!cap || cap.supported !== true` returned early');
     const key = `xtenant-blob-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
 
     const putRes = await call('tenant-a', 'put', {
@@ -53,15 +55,15 @@ describe('blob-cross-tenant-isolation: behavioral (RFC 0019 §B point 1)', () =>
       contentBase64: Buffer.from('from-A').toString('base64'),
       contentType: 'text/plain',
     });
-    if (putRes.status === 404) return;
-    expect(putRes.status, 'put MUST succeed').toBe(200);
+    if (putRes.status === 404) return softSkip('blocked', 'precondition not met — `putRes.status === 404` returned early (seam, prior step, or fixture unavailable)');
+    expect(putRes.status, req('openwop.it.blob-cross-tenant-isolation.put-under-tenant-a-get-under-tenant-b-with-same-key-returns-found-false', 'RFC 0019 §B point 1', 'put MUST succeed')).toBe(200);
 
     const getRes = await call('tenant-b', 'get', { bucket: 'default', key });
     expect(getRes.status).toBe(200);
     const body = getRes.json as { found?: boolean };
     expect(
       body.found,
-      driver.describe('RFC 0019 §B point 1', 'tenant B MUST NOT retrieve tenant A blob at same key'),
+      req('openwop.it.blob-cross-tenant-isolation.put-under-tenant-a-get-under-tenant-b-with-same-key-returns-found-false', 'RFC 0019 §B point 1', 'tenant B MUST NOT retrieve tenant A blob at same key'),
     ).toBe(false);
   });
 });

package/src/scenarios/blob-presign-expiry.test.ts

@@ -16,6 +16,8 @@
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { discoveryFamilies } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 interface DiscoveryDoc {
   capabilities?: Record<string, unknown>;
@@ -32,10 +34,10 @@ async function readCap(): Promise<Record<string, unknown> | null> {
 describe('blob-presign-expiry: advertisement shape (RFC 0019)', () => {
   it('capabilities.blobStorage is either absent or a well-formed object', async () => {
     const cap = await readCap();
-    if (cap === null) return; // host doesn't advertise — skip
+    if (cap === null) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `cap === null` returned early (host doesn\'t advertise — skip)'); // host doesn't advertise — skip
     expect(
       typeof cap.supported,
-      driver.describe(
+      req('openwop.it.blob-presign-expiry.capabilities-blobstorage-is-either-absent-or-a-well-formed-object', 
         'capabilities.schema.json §blobStorage',
         'capabilities.blobStorage.supported MUST be a boolean when present',
       ),
@@ -44,17 +46,17 @@ describe('blob-presign-expiry: advertisement shape (RFC 0019)', () => {
 
   it('presignSupported is a boolean when set', async () => {
     const cap = await readCap();
-    if (!cap || cap.supported !== true) return;
+    if (!cap || cap.supported !== true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!cap || cap.supported !== true` returned early');
     const subParts = ["presignSupported"];
     let sub: unknown = cap;
     for (const p of subParts) {
       if (sub && typeof sub === 'object') sub = (sub as Record<string, unknown>)[p];
       else { sub = undefined; break; }
     }
-    if (sub === undefined) return; // optional sub-field
+    if (sub === undefined) return softSkip('blocked', 'precondition not met — `sub === undefined` returned early (optional sub-field) (seam, prior step, or fixture unavailable)'); // optional sub-field
     expect(
       typeof sub,
-      driver.describe(
+      req('openwop.it.blob-presign-expiry.presignsupported-is-a-boolean-when-set', 
         'RFC 0019 §A',
         'blobStorage.presignSupported MUST be boolean when present',
       ),
@@ -69,7 +71,7 @@ async function call(op: string, args: Record<string, unknown>) {
 describe('blob-presign-expiry: behavioral (RFC 0019 §B point 1)', () => {
   it('presigned URL MUST resolve to the blob inside its TTL window and return 403 after expiry', async () => {
     const probe = await call('get', { key: '__probe__' });
-    if (probe.status === 404) return; // seam not exposed
+    if (probe.status === 404) return softSkip('blocked', 'precondition not met — `probe.status === 404` returned early (seam not exposed) (seam, prior step, or fixture unavailable)'); // seam not exposed
     const key = `pre-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     const contentBase64 = Buffer.from('presigned-payload').toString('base64');
     await call('put', { key, contentBase64, contentType: 'text/plain' });
@@ -78,14 +80,14 @@ describe('blob-presign-expiry: behavioral (RFC 0019 §B point 1)', () => {
     const presign = await call('presign', { key, expiresInSeconds: 2 });
     expect(presign.status).toBe(200);
     const body = presign.json as { url?: string; expiresAtMs?: number };
-    expect(typeof body.url, 'presign MUST return a URL').toBe('string');
+    expect(typeof body.url, req('openwop.it.blob-presign-expiry.presigned-url-must-resolve-to-the-blob-inside-its-ttl-window-and-return-403-afte', 'RFC 0019 §B point 1', 'presign MUST return a URL')).toBe('string');
 
     // Fetch within the window — MUST return 200 + the bytes
     const within = await driver.get(body.url!);
-    if (within.status === 404) return; // host doesn't expose the resolver route — soft-skip the expiry side too
+    if (within.status === 404) return softSkip('blocked', 'precondition not met — `within.status === 404` returned early (host doesn\'t expose the resolver route — soft-skip the expiry side too) (seam, prior step, or fixture unavailable)'); // host doesn't expose the resolver route — soft-skip the expiry side too
     expect(
       within.status,
-      driver.describe('RFC 0019 §B point 1', 'presigned URL MUST resolve to 200 within its TTL window'),
+      req('openwop.it.blob-presign-expiry.presigned-url-must-resolve-to-the-blob-inside-its-ttl-window-and-return-403-afte', 'RFC 0019 §B point 1', 'presigned URL MUST resolve to 200 within its TTL window'),
     ).toBe(200);
 
     // Wait past expiry (TTL=2s + 1s buffer)
@@ -94,7 +96,7 @@ describe('blob-presign-expiry: behavioral (RFC 0019 §B point 1)', () => {
     const after = await driver.get(body.url!);
     expect(
       after.status,
-      driver.describe('RFC 0019 §B point 1', 'presigned URL MUST return 403 after TTL expiry'),
+      req('openwop.it.blob-presign-expiry.presigned-url-must-resolve-to-the-blob-inside-its-ttl-window-and-return-403-afte', 'RFC 0019 §B point 1', 'presigned URL MUST return 403 after TTL expiry'),
     ).toBe(403);
   });
 });

package/src/scenarios/budget-enforcement.test.ts

@@ -29,11 +29,12 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { readBudgetCap, driveBudgetRun, BUDGET_CAP_KINDS, BUDGET_CONTENT_FORBIDDEN } from '../lib/budgetPolicy.js';
 import { queryTestEvents, isEventLogSeamAvailable, resetTestSeam } from '../lib/event-log-query.js';
 import type { TestEvent } from '../lib/event-log-query.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 function seq(events: TestEvent[], type: string): number {
   const e = events.find((x) => x.type === type);
@@ -45,7 +46,7 @@ function expectContentFree(events: TestEvent[]): void {
     for (const f of BUDGET_CONTENT_FORBIDDEN) {
       expect(
         !(f in e.payload),
-        driver.describe('RFC 0084 §F (SR-1) / budget-no-pricing-leak', `budget.* MUST be content-free (no ${f})`),
+        req('openwop.it.budget-enforcement.runs-the-reserved-consumed-threshold-exhausted-cap-breached-run-failed-chain-ref', 'RFC 0084 §F (SR-1) / budget-no-pricing-leak', `budget.* MUST be content-free (no ${f})`),
       ).toBe(true);
     }
   }
@@ -55,11 +56,11 @@ describe('budget-enforcement (RFC 0084 §C/§D)', () => {
   it('runs the reserved→consumed→threshold→exhausted→cap.breached→run.failed chain, refuses denied models, and honors advisory mode', async () => {
     const cap = await readBudgetCap();
     if (!behaviorGate('openwop-budget-enforcement', cap?.supported === true)) return;
-    if (!(await isEventLogSeamAvailable())) return; // event-log seam absent — soft-skip
+    if (!(await isEventLogSeamAvailable())) return softSkip('blocked', 'precondition not met — `!(await isEventLogSeamAvailable())` returned early (event-log seam absent — soft-skip) (seam, prior step, or fixture unavailable)'); // event-log seam absent — soft-skip
 
     // ---- Leg 1: hard cost exhaust (§C/§D) -------------------------------
     const hard = await driveBudgetRun({ scenario: 'hard-cost-exhaust' });
-    if (hard === null) return; // budget seam absent — soft-skip the whole behavior
+    if (hard === null) return softSkip('blocked', 'precondition not met — `hard === null` returned early (budget seam absent — soft-skip the whole behavior) (seam, prior step, or fixture unavailable)'); // budget seam absent — soft-skip the whole behavior
     if (hard.runId) {
       const q = await queryTestEvents(hard.runId);
       if (q.ok) {
@@ -72,39 +73,39 @@ describe('budget-enforcement (RFC 0084 §C/§D)', () => {
 
         expect(
           reserved >= 0 && exhausted >= 0,
-          driver.describe('budget-policy.md §C', 'a hard budget run MUST emit budget.reserved + budget.exhausted'),
+          req('openwop.it.budget-enforcement.runs-the-reserved-consumed-threshold-exhausted-cap-breached-run-failed-chain-ref', 'budget-policy.md §C', 'a hard budget run MUST emit budget.reserved + budget.exhausted'),
         ).toBe(true);
         // §C ordering: reserved < threshold.crossed < exhausted < run.failed.
         if (threshold >= 0) {
           expect(
             reserved < threshold && threshold < exhausted,
-            driver.describe('RFC 0084 §C', 'ordering MUST be reserved < threshold.crossed < exhausted'),
+            req('openwop.it.budget-enforcement.runs-the-reserved-consumed-threshold-exhausted-cap-breached-run-failed-chain-ref', 'RFC 0084 §C', 'ordering MUST be reserved < threshold.crossed < exhausted'),
           ).toBe(true);
           const tc = ev.find((e) => e.type === 'budget.threshold.crossed');
           expect(
             typeof tc?.payload.percent === 'number',
-            driver.describe('run-event-payloads.schema.json#budgetThresholdCrossed', 'threshold.crossed MUST carry a numeric percent'),
+            req('openwop.it.budget-enforcement.runs-the-reserved-consumed-threshold-exhausted-cap-breached-run-failed-chain-ref', 'run-event-payloads.schema.json#budgetThresholdCrossed', 'threshold.crossed MUST carry a numeric percent'),
           ).toBe(true);
         }
         // §D hard-stop: exhausted → cap.breached{budget-*} → run.failed{budget_exhausted}.
         expect(
           capBreached !== undefined,
-          driver.describe('RFC 0084 §D', 'exhaustion MUST emit cap.breached with a budget-* kind'),
+          req('openwop.it.budget-enforcement.runs-the-reserved-consumed-threshold-exhausted-cap-breached-run-failed-chain-ref', 'RFC 0084 §D', 'exhaustion MUST emit cap.breached with a budget-* kind'),
         ).toBe(true);
         if (capBreached) {
           expect(
             BUDGET_CAP_KINDS.includes(capBreached.payload.kind as string),
-            driver.describe('RFC 0084 §D', 'cap.breached.kind MUST be in the closed budget vocabulary'),
+            req('openwop.it.budget-enforcement.runs-the-reserved-consumed-threshold-exhausted-cap-breached-run-failed-chain-ref', 'RFC 0084 §D', 'cap.breached.kind MUST be in the closed budget vocabulary'),
           ).toBe(true);
           expect(
             exhausted <= capBreached.sequence && capBreached.sequence <= failed,
-            driver.describe('RFC 0084 §D', 'ordering MUST be exhausted ≤ cap.breached ≤ run.failed'),
+            req('openwop.it.budget-enforcement.runs-the-reserved-consumed-threshold-exhausted-cap-breached-run-failed-chain-ref', 'RFC 0084 §D', 'ordering MUST be exhausted ≤ cap.breached ≤ run.failed'),
           ).toBe(true);
         }
         const failedEvt = ev.find((e) => e.type === 'run.failed');
         expect(
           failedEvt?.payload.error === 'budget_exhausted',
-          driver.describe('RFC 0084 §D', 'a hard-budget overrun MUST fail the run with error budget_exhausted'),
+          req('openwop.it.budget-enforcement.runs-the-reserved-consumed-threshold-exhausted-cap-breached-run-failed-chain-ref', 'RFC 0084 §D', 'a hard-budget overrun MUST fail the run with error budget_exhausted'),
         ).toBe(true);
         expectContentFree(ev);
       }
@@ -115,11 +116,11 @@ describe('budget-enforcement (RFC 0084 §C/§D)', () => {
     if (denied !== null) {
       expect(
         denied.error === 'budget_model_denied',
-        driver.describe('RFC 0084 §D', 'a model violating the budget allow/deny list MUST be refused with budget_model_denied'),
+        req('openwop.it.budget-enforcement.runs-the-reserved-consumed-threshold-exhausted-cap-breached-run-failed-chain-ref', 'RFC 0084 §D', 'a model violating the budget allow/deny list MUST be refused with budget_model_denied'),
       ).toBe(true);
       expect(
         denied.modelCalled !== true,
-        driver.describe('RFC 0084 §D', 'a denied model MUST be refused BEFORE the provider call (fail-closed)'),
+        req('openwop.it.budget-enforcement.runs-the-reserved-consumed-threshold-exhausted-cap-breached-run-failed-chain-ref', 'RFC 0084 §D', 'a denied model MUST be refused BEFORE the provider call (fail-closed)'),
       ).toBe(true);
     }
 
@@ -139,7 +140,7 @@ describe('budget-enforcement (RFC 0084 §C/§D)', () => {
           if (hasBudgetEvents) {
             expect(
               !stopped,
-              driver.describe('RFC 0084 §D', 'advisory enforcement MUST emit budget.* events without stopping the run'),
+              req('openwop.it.budget-enforcement.runs-the-reserved-consumed-threshold-exhausted-cap-breached-run-failed-chain-ref', 'RFC 0084 §D', 'advisory enforcement MUST emit budget.* events without stopping the run'),
             ).toBe(true);
           }
           expectContentFree(ev);

package/src/scenarios/budget-policy-shape.test.ts

@@ -35,8 +35,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';
-
-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>;
@@ -52,17 +51,17 @@ describe('budget-policy-shape: BudgetPolicy (RFC 0084 §A, server-free)', () =>
   it('a conforming budget policy validates', () => {
     expect(
       validate({ maxTokens: 200000, maxCostUsd: 1.0, maxToolCalls: 50, maxRetries: 10, modelAllow: ['claude-*'], modelDeny: ['gpt-4-32k'], thresholdPercent: 80, onExhaustion: 'fail' }),
-      why('budget-policy.md §A', 'a conforming BudgetPolicy MUST validate'),
+      req('openwop.it.budget-policy-shape.a-conforming-budget-policy-validates', 'budget-policy.md §A', 'a conforming BudgetPolicy MUST validate'),
     ).toBe(true);
   });
 
   it('the orthogonality guard: a wall-time field is rejected (it is RFC 0058 runTimeoutMs)', () => {
-    expect(validate({ maxCostUsd: 1.0, maxWallTimeMs: 60000 }), why('budget-policy.md §A/§E', 'wall-time is NOT a budget dimension')).toBe(false);
+    expect(validate({ maxCostUsd: 1.0, maxWallTimeMs: 60000 }), req('openwop.it.budget-policy-shape.the-orthogonality-guard-a-wall-time-field-is-rejected-it-is-rfc-0058-runtimeoutm', 'budget-policy.md §A/§E', 'wall-time is NOT a budget dimension')).toBe(false);
   });
 
   it('rejects an out-of-range thresholdPercent and an out-of-enum onExhaustion', () => {
-    expect(validate({ thresholdPercent: 120 }), why('budget-policy.md §A', 'thresholdPercent MUST be 0..100')).toBe(false);
-    expect(validate({ onExhaustion: 'explode' }), why('budget-policy.md §A', 'onExhaustion is a closed enum')).toBe(false);
+    expect(validate({ thresholdPercent: 120 }), req('openwop.it.budget-policy-shape.rejects-an-out-of-range-thresholdpercent-and-an-out-of-enum-onexhaustion', 'budget-policy.md §A', 'thresholdPercent MUST be 0..100')).toBe(false);
+    expect(validate({ onExhaustion: 'explode' }), req('openwop.it.budget-policy-shape.rejects-an-out-of-range-thresholdpercent-and-an-out-of-enum-onexhaustion', 'budget-policy.md §A', 'onExhaustion is a closed enum')).toBe(false);
   });
 });
 
@@ -76,21 +75,21 @@ describe('budget-policy-shape: budget.* events + cap.breached kinds (RFC 0084 §
   } as Record<string, unknown>);
 
   it('the four budget.* payloads validate conforming content-free records', () => {
-    expect(compile('budgetReserved')({ effectiveBudget: { maxCostUsd: 1.0 }, scope: 'run' }), why('budget-policy.md §C', 'budget.reserved MUST validate')).toBe(true);
-    expect(compile('budgetConsumed')({ dimension: 'cost', consumed: 0.7, limit: 1.0, remaining: 0.3 }), why('budget-policy.md §C', 'budget.consumed MUST validate')).toBe(true);
-    expect(compile('budgetThresholdCrossed')({ dimension: 'cost', consumed: 0.8, limit: 1.0, percent: 80 }), why('budget-policy.md §C', 'budget.threshold.crossed MUST validate')).toBe(true);
-    expect(compile('budgetExhausted')({ dimension: 'cost', consumed: 1.02, limit: 1.0 }), why('budget-policy.md §C', 'budget.exhausted MUST validate')).toBe(true);
+    expect(compile('budgetReserved')({ effectiveBudget: { maxCostUsd: 1.0 }, scope: 'run' }), req('openwop.it.budget-policy-shape.the-four-budget-payloads-validate-conforming-content-free-records', 'budget-policy.md §C', 'budget.reserved MUST validate')).toBe(true);
+    expect(compile('budgetConsumed')({ dimension: 'cost', consumed: 0.7, limit: 1.0, remaining: 0.3 }), req('openwop.it.budget-policy-shape.the-four-budget-payloads-validate-conforming-content-free-records', 'budget-policy.md §C', 'budget.consumed MUST validate')).toBe(true);
+    expect(compile('budgetThresholdCrossed')({ dimension: 'cost', consumed: 0.8, limit: 1.0, percent: 80 }), req('openwop.it.budget-policy-shape.the-four-budget-payloads-validate-conforming-content-free-records', 'budget-policy.md §C', 'budget.threshold.crossed MUST validate')).toBe(true);
+    expect(compile('budgetExhausted')({ dimension: 'cost', consumed: 1.02, limit: 1.0 }), req('openwop.it.budget-policy-shape.the-four-budget-payloads-validate-conforming-content-free-records', 'budget-policy.md §C', 'budget.exhausted MUST validate')).toBe(true);
   });
 
   it('rejects an out-of-enum dimension and a missing required field', () => {
-    expect(compile('budgetConsumed')({ dimension: 'vibes', consumed: 1, limit: 2 }), why('budget-policy.md §C', 'dimension is a closed enum')).toBe(false);
-    expect(compile('budgetExhausted')({ dimension: 'cost', consumed: 1.0 }), why('budget-policy.md §C', 'limit is REQUIRED')).toBe(false);
+    expect(compile('budgetConsumed')({ dimension: 'vibes', consumed: 1, limit: 2 }), req('openwop.it.budget-policy-shape.rejects-an-out-of-enum-dimension-and-a-missing-required-field', 'budget-policy.md §C', 'dimension is a closed enum')).toBe(false);
+    expect(compile('budgetExhausted')({ dimension: 'cost', consumed: 1.0 }), req('openwop.it.budget-policy-shape.rejects-an-out-of-enum-dimension-and-a-missing-required-field', 'budget-policy.md §C', 'limit is REQUIRED')).toBe(false);
   });
 
   it('the cap.breached kind enum carries the four budget-* values', () => {
     const kinds = ((payloads.$defs as Record<string, { properties?: Record<string, { enum?: string[] }> }>).capBreached.properties?.kind?.enum) ?? [];
     for (const k of ['budget-tokens', 'budget-cost', 'budget-tool-calls', 'budget-retries']) {
-      expect(kinds.includes(k), why('budget-policy.md §D', `cap.breached.kind MUST include ${k}`)).toBe(true);
+      expect(kinds.includes(k), req('openwop.it.budget-policy-shape.the-cap-breached-kind-enum-carries-the-four-budget-values', 'budget-policy.md §D', `cap.breached.kind MUST include ${k}`)).toBe(true);
     }
   });
 
@@ -98,7 +97,7 @@ describe('budget-policy-shape: budget.* events + cap.breached kinds (RFC 0084 §
     const runEvent = loadSchema('run-event.schema.json');
     const enumVals = ((runEvent.$defs as Record<string, { enum?: string[] }>).RunEventType?.enum) ?? [];
     for (const name of ['budget.reserved', 'budget.consumed', 'budget.threshold.crossed', 'budget.exhausted']) {
-      expect(enumVals.includes(name), why('run-event.schema.json', `${name} MUST be in the RunEventType enum`)).toBe(true);
+      expect(enumVals.includes(name), req('openwop.it.budget-policy-shape.all-four-budget-event-names-appear-in-the-runeventtype-enum', 'run-event.schema.json', `${name} MUST be in the RunEventType enum`)).toBe(true);
     }
   });
 
@@ -106,7 +105,7 @@ describe('budget-policy-shape: budget.* events + cap.breached kinds (RFC 0084 §
     const defs = payloads.$defs as Record<string, { properties?: Record<string, unknown> }>;
     for (const def of ['budgetReserved', 'budgetConsumed', 'budgetThresholdCrossed', 'budgetExhausted']) {
       for (const p of Object.keys(defs[def].properties ?? {})) {
-        expect(PRICING_PROP_NAMES.includes(p.toLowerCase()), why('budget-no-pricing-leak', `${def} MUST NOT declare a pricing-bearing property (${p})`)).toBe(false);
+        expect(PRICING_PROP_NAMES.includes(p.toLowerCase()), req('openwop.it.budget-policy-shape.the-budget-payloads-declare-no-pricing-credential-property-budget-no-pricing-lea', 'budget-no-pricing-leak', `${def} MUST NOT declare a pricing-bearing property (${p})`)).toBe(false);
       }
     }
   });
@@ -114,10 +113,10 @@ describe('budget-policy-shape: budget.* events + cap.breached kinds (RFC 0084 §
   it('the budget.* payloads are additionalProperties:false — a rate-card field on an INSTANCE is rejected', () => {
     // The aggregate cost total (the user's own budget) is permitted; the host's per-unit rate card is not.
     // additionalProperties:false makes the rejection structural, not just a declared-property check.
-    expect(compile('budgetConsumed')({ dimension: 'cost', consumed: 0.8, limit: 1.0 }), why('budget-policy.md §F', 'an aggregate cost total (the user budget) MUST validate')).toBe(true);
+    expect(compile('budgetConsumed')({ dimension: 'cost', consumed: 0.8, limit: 1.0 }), req('openwop.it.budget-policy-shape.the-budget-payloads-are-additionalproperties-false-a-rate-card-field-on-an-insta', 'budget-policy.md §F', 'an aggregate cost total (the user budget) MUST validate')).toBe(true);
     expect(
       compile('budgetConsumed')({ dimension: 'cost', consumed: 0.8, limit: 1.0, ratePerToken: 0.000003 }),
-      why('budget-no-pricing-leak', 'a rate-card / per-token-price field MUST be rejected (additionalProperties:false)'),
+      req('openwop.it.budget-policy-shape.the-budget-payloads-are-additionalproperties-false-a-rate-card-field-on-an-insta', 'budget-no-pricing-leak', 'a rate-card / per-token-price field MUST be rejected (additionalProperties:false)'),
     ).toBe(false);
   });
 });
@@ -127,10 +126,10 @@ describe('budget-policy-shape: capability advertisement (RFC 0084 §E, server-fr
     const caps = loadSchema('capabilities.schema.json');
     const props = caps.properties as Record<string, { properties?: Record<string, unknown> }>;
     for (const flag of ['supported', 'dimensions', 'enforce', 'scopes']) {
-      expect(props.budget?.properties?.[flag], why('budget-policy.md §E', `capabilities.budget.${flag} MUST be declared`)).toBeDefined();
+      expect(props.budget?.properties?.[flag], req('openwop.it.budget-policy-shape.capabilities-budget-limits-maxbudget-tokens-costusd-are-declared', 'budget-policy.md §E', `capabilities.budget.${flag} MUST be declared`)).toBeDefined();
     }
     for (const ceiling of ['maxBudgetTokens', 'maxBudgetCostUsd']) {
-      expect(props.limits?.properties?.[ceiling], why('budget-policy.md §E', `limits.${ceiling} MUST be declared`)).toBeDefined();
+      expect(props.limits?.properties?.[ceiling], req('openwop.it.budget-policy-shape.capabilities-budget-limits-maxbudget-tokens-costusd-are-declared', 'budget-policy.md §E', `limits.${ceiling} MUST be declared`)).toBeDefined();
     }
   });
 });

package/src/scenarios/bulk-cancel.test.ts

@@ -20,6 +20,7 @@
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { req } from '../lib/requirement-ids.js';
 
 const CANCELLABLE = 'conformance-cancellable';
 const NOOP = 'conformance-noop';
@@ -48,22 +49,22 @@ describe.skipIf(SKIP)('bulk-cancel: POST /v1/runs:bulk-cancel', () => {
       runIds: [inflightRunId, 'run-does-not-exist-xxxxxxxx'],
       reason: 'conformance bulk-cancel test',
     });
-    expect(res.status, driver.describe(
+    expect(res.status, req('openwop.it.bulk-cancel.mixed-outcome-request-returns-per-id-results-in-order', 
       'rest-endpoints.md §"POST /v1/runs:bulk-cancel"',
       'top-level operation MUST return 200 when the request reached the host (per-id outcomes carry partial failure)',
     )).toBe(200);
 
     const body = res.json as { results: BulkResult[] };
     expect(Array.isArray(body.results)).toBe(true);
-    expect(body.results.length, 'results MUST have one entry per request runId').toBe(2);
+    expect(body.results.length, req('openwop.it.bulk-cancel.mixed-outcome-request-returns-per-id-results-in-order', 'rest-endpoints.md §"POST /v1/runs:bulk-cancel"', 'results MUST have one entry per request runId')).toBe(2);
 
-    expect(body.results[0]!.runId, 'results order MUST mirror the request order').toBe(inflightRunId);
+    expect(body.results[0]!.runId, req('openwop.it.bulk-cancel.mixed-outcome-request-returns-per-id-results-in-order', 'rest-endpoints.md §"POST /v1/runs:bulk-cancel"', 'results order MUST mirror the request order')).toBe(inflightRunId);
     expect(body.results[0]!.ok).toBe(true);
     expect(['cancelling', 'cancelled']).toContain(body.results[0]!.status);
 
     expect(body.results[1]!.runId).toBe('run-does-not-exist-xxxxxxxx');
-    expect(body.results[1]!.ok, 'unknown runId entry MUST have ok=false').toBe(false);
-    expect(body.results[1]!.error?.code, driver.describe(
+    expect(body.results[1]!.ok, req('openwop.it.bulk-cancel.mixed-outcome-request-returns-per-id-results-in-order', 'rest-endpoints.md §"POST /v1/runs:bulk-cancel"', 'unknown runId entry MUST have ok=false')).toBe(false);
+    expect(body.results[1]!.error?.code, req('openwop.it.bulk-cancel.mixed-outcome-request-returns-per-id-results-in-order', 
       'rest-endpoints.md §"POST /v1/runs:bulk-cancel"',
       'unknown runId outcomes carry `error.code === "not_found"`',
     )).toBe('not_found');
@@ -71,7 +72,7 @@ describe.skipIf(SKIP)('bulk-cancel: POST /v1/runs:bulk-cancel', () => {
 
   it('empty runIds array returns 400 validation_error', async () => {
     const res = await driver.post('/v1/runs:bulk-cancel', { runIds: [] });
-    expect(res.status).toBe(400);
+    expect(res.status, req('openwop.it.bulk-cancel.empty-runids-array-returns-400-validation-error', 'rest-endpoints.md §Open', 'empty runIds array returns 400 validation_error')).toBe(400);
     const body = res.json as { error?: string };
     expect(body.error).toBe('validation_error');
   });
@@ -83,7 +84,7 @@ describe.skipIf(SKIP)('bulk-cancel: POST /v1/runs:bulk-cancel', () => {
     expect(res.status).toBe(400);
     const body = res.json as { error?: string; details?: { maxRunIds?: number } };
     expect(body.error).toBe('validation_error');
-    expect(typeof body.details?.maxRunIds, driver.describe(
+    expect(typeof body.details?.maxRunIds, req('openwop.it.bulk-cancel.oversized-runids-array-returns-400-with-details-maxrunids', 
       'rest-endpoints.md §"POST /v1/runs:bulk-cancel"',
       'over-cap request MUST carry details.maxRunIds disclosing the configured ceiling',
     )).toBe('number');
@@ -103,7 +104,7 @@ describe.skipIf(SKIP)('bulk-cancel: POST /v1/runs:bulk-cancel', () => {
     const second = await driver.post('/v1/runs:bulk-cancel', { runIds: [runId] });
     expect(second.status).toBe(200);
     const body = second.json as { results: BulkResult[] };
-    expect(body.results[0]!.ok, driver.describe(
+    expect(body.results[0]!.ok, req('openwop.it.bulk-cancel.re-bulk-cancel-after-first-cancel-is-idempotent', 
       'rest-endpoints.md §"POST /v1/runs:bulk-cancel" §Idempotency',
       're-cancelling an already-cancelling/cancelled run MUST be ok: true (idempotent)',
     )).toBe(true);