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

package/src/scenarios/tool-descriptor-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>;
@@ -54,32 +53,32 @@ describe('tool-descriptor-shape: ToolDescriptor (RFC 0078 §C, server-free)', ()
         egress: 'none', approval: 'never', replayPolicy: 'idempotent',
         safetyTier: 'read', costHint: 'low', latencyHint: 'low',
       }),
-      why('tool-catalog.md §C', 'a conforming ToolDescriptor MUST validate'),
+      req('openwop.it.tool-descriptor-shape.a-conforming-descriptor-validates', 'tool-catalog.md §C', 'a conforming ToolDescriptor MUST validate'),
     ).toBe(true);
   });
 
   it('a descriptor missing the REQUIRED safetyTier is rejected', () => {
     expect(
       validate({ toolId: 'x', source: 'mcp' }),
-      why('tool-catalog.md §C', 'safetyTier is REQUIRED'),
+      req('openwop.it.tool-descriptor-shape.a-descriptor-missing-the-required-safetytier-is-rejected', 'tool-catalog.md §C', 'safetyTier is REQUIRED'),
     ).toBe(false);
   });
 
   it('enforces exec ⇒ host-extension (RFC 0069; §C-1/§F-4)', () => {
     expect(
       validate({ toolId: 'x-host-acme-shell', source: 'host-extension', safetyTier: 'exec', approval: 'always', egress: 'host-owned' }),
-      why('tool-catalog.md §C-1', 'an exec tool sourced from host-extension MUST validate'),
+      req('openwop.it.tool-descriptor-shape.enforces-exec-host-extension-rfc-0069-c-1-f-4', 'tool-catalog.md §C-1', 'an exec tool sourced from host-extension MUST validate'),
     ).toBe(true);
     expect(
       validate({ toolId: 'openwop:run-shell', source: 'node-pack', safetyTier: 'exec' }),
-      why('tool-catalog.md §C-1 / RFC 0069', 'an exec tool MUST NOT be protocol-tier (node-pack)'),
+      req('openwop.it.tool-descriptor-shape.enforces-exec-host-extension-rfc-0069-c-1-f-4', 'tool-catalog.md §C-1 / RFC 0069', 'an exec tool MUST NOT be protocol-tier (node-pack)'),
     ).toBe(false);
   });
 
   it('rejects an unknown property (additionalProperties:false)', () => {
     expect(
       validate({ toolId: 'x', source: 'mcp', safetyTier: 'read', danger: true }),
-      why('tool-catalog.md §C', 'ToolDescriptor MUST be additionalProperties:false'),
+      req('openwop.it.tool-descriptor-shape.rejects-an-unknown-property-additionalproperties-false', 'tool-catalog.md §C', 'ToolDescriptor MUST be additionalProperties:false'),
     ).toBe(false);
   });
 });
@@ -90,12 +89,12 @@ describe('tool-descriptor-shape: capability advertisement (RFC 0078 §A, server-
     const toolCatalog = (caps.properties as Record<string, { properties?: Record<string, unknown> }>).toolCatalog;
     expect(
       toolCatalog,
-      why('capabilities.md §toolCatalog', 'capabilities.toolCatalog MUST be declared'),
+      req('openwop.it.tool-descriptor-shape.capabilities-toolcatalog-is-declared-with-its-sub-flags', 'capabilities.md §toolCatalog', 'capabilities.toolCatalog MUST be declared'),
     ).toBeDefined();
     for (const flag of ['supported', 'sources', 'sessionLifecycle']) {
       expect(
         toolCatalog?.properties?.[flag],
-        why('tool-catalog.md §A', `capabilities.toolCatalog.${flag} MUST be declared`),
+        req('openwop.it.tool-descriptor-shape.capabilities-toolcatalog-is-declared-with-its-sub-flags', 'tool-catalog.md §A', `capabilities.toolCatalog.${flag} MUST be declared`),
       ).toBeDefined();
     }
   });
@@ -112,22 +111,22 @@ describe('tool-descriptor-shape: session lifecycle events (RFC 0078 §D, server-
 
   it('tool.session.opened validates a content-free record', () => {
     const v = compile('toolSessionOpened');
-    expect(v({ sessionId: 's1', toolId: 'mcp:fs.read' }), why('tool-catalog.md §D', 'opened MUST validate')).toBe(true);
-    expect(v({ toolId: 'mcp:fs.read' }), why('tool-catalog.md §D', 'opened requires sessionId')).toBe(false);
+    expect(v({ sessionId: 's1', toolId: 'mcp:fs.read' }), req('openwop.it.tool-descriptor-shape.tool-session-opened-validates-a-content-free-record', 'tool-catalog.md §D', 'opened MUST validate')).toBe(true);
+    expect(v({ toolId: 'mcp:fs.read' }), req('openwop.it.tool-descriptor-shape.tool-session-opened-validates-a-content-free-record', 'tool-catalog.md §D', 'opened requires sessionId')).toBe(false);
   });
 
   it('tool.session.closed validates + enforces the closed outcome enum', () => {
     const v = compile('toolSessionClosed');
-    expect(v({ sessionId: 's1', toolId: 'mcp:fs.read', outcome: 'completed' }), why('tool-catalog.md §D', 'closed MUST validate')).toBe(true);
-    expect(v({ sessionId: 's1', toolId: 'mcp:fs.read' }), why('tool-catalog.md §D', 'closed requires outcome')).toBe(false);
-    expect(v({ sessionId: 's1', toolId: 'mcp:fs.read', outcome: 'exploded' }), why('tool-catalog.md §D', 'outcome is a closed enum')).toBe(false);
+    expect(v({ sessionId: 's1', toolId: 'mcp:fs.read', outcome: 'completed' }), req('openwop.it.tool-descriptor-shape.tool-session-closed-validates-enforces-the-closed-outcome-enum', 'tool-catalog.md §D', 'closed MUST validate')).toBe(true);
+    expect(v({ sessionId: 's1', toolId: 'mcp:fs.read' }), req('openwop.it.tool-descriptor-shape.tool-session-closed-validates-enforces-the-closed-outcome-enum', 'tool-catalog.md §D', 'closed requires outcome')).toBe(false);
+    expect(v({ sessionId: 's1', toolId: 'mcp:fs.read', outcome: 'exploded' }), req('openwop.it.tool-descriptor-shape.tool-session-closed-validates-enforces-the-closed-outcome-enum', 'tool-catalog.md §D', 'outcome is a closed enum')).toBe(false);
   });
 
   it('both session event names appear in the RunEventType enum', () => {
     const runEvent = loadSchema('run-event.schema.json');
     const enumVals = ((runEvent.$defs as Record<string, { enum?: string[] }>).RunEventType?.enum) ?? [];
     for (const name of ['tool.session.opened', 'tool.session.closed']) {
-      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.tool-descriptor-shape.both-session-event-names-appear-in-the-runeventtype-enum', 'run-event.schema.json', `${name} MUST be in the RunEventType enum`)).toBe(true);
     }
   });
 });

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

@@ -13,8 +13,8 @@
 
 import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
-import { driver } from '../lib/driver.js';
 import { readToolHooksCap, invokeToolHook } from '../lib/toolHooks.js';
+import { req } from '../lib/requirement-ids.js';
 
 describe('tool-hooks-authorization-fail-closed (RFC 0064 §C)', () => {
   it('a principal lacking a tool scope is denied and the tool is not invoked', async () => {
@@ -30,11 +30,11 @@ describe('tool-hooks-authorization-fail-closed (RFC 0064 §C)', () => {
     if (res === null) return softSkip('blocked', 'seam absent — soft-skip');
     expect(
       (res.toolReturned ?? {}).status,
-      driver.describe('RFC 0064 §C', 'a missing/unevaluable tool scope MUST fail closed → status:"forbidden"'),
+      req('openwop.it.tool-hooks-authorization-fail-closed.a-principal-lacking-a-tool-scope-is-denied-and-the-tool-is-not-invoked', 'RFC 0064 §C', 'a missing/unevaluable tool scope MUST fail closed → status:"forbidden"'),
     ).toBe('forbidden');
     expect(
       (res.toolReturned ?? {}).durationMs,
-      driver.describe('RFC 0064 §C', 'a forbidden call never starts, so durationMs MUST be absent'),
+      req('openwop.it.tool-hooks-authorization-fail-closed.a-principal-lacking-a-tool-scope-is-denied-and-the-tool-is-not-invoked', 'RFC 0064 §C', 'a forbidden call never starts, so durationMs MUST be absent'),
     ).toBeUndefined();
   });
 });

package/src/scenarios/tool-hooks-content-free.test.ts

@@ -12,8 +12,8 @@
 
 import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
-import { driver } from '../lib/driver.js';
 import { readToolHooksCap, invokeToolHook } from '../lib/toolHooks.js';
+import { req } from '../lib/requirement-ids.js';
 
 describe('tool-hooks-content-free (RFC 0064 §B)', () => {
   it('toolCalled carries argsHash; toolReturned carries status + durationMs', async () => {
@@ -25,16 +25,16 @@ describe('tool-hooks-content-free (RFC 0064 §B)', () => {
     const returned = res.toolReturned ?? {};
     expect(
       typeof called.argsHash === 'string' && (called.argsHash as string).length > 0,
-      driver.describe('RFC 0064 §B', 'agent.toolCalled MUST carry a non-empty argsHash when prePostEvents'),
+      req('openwop.it.tool-hooks-content-free.toolcalled-carries-argshash-toolreturned-carries-status-durationms', 'RFC 0064 §B', 'agent.toolCalled MUST carry a non-empty argsHash when prePostEvents'),
     ).toBe(true);
     expect(
       ['ok', 'error', 'forbidden', 'rate_limited'].includes(returned.status as string),
-      driver.describe('RFC 0064 §B', 'agent.toolReturned MUST carry a tool-hooks status'),
+      req('openwop.it.tool-hooks-content-free.toolcalled-carries-argshash-toolreturned-carries-status-durationms', 'RFC 0064 §B', 'agent.toolReturned MUST carry a tool-hooks status'),
     ).toBe(true);
     if (returned.status === 'ok') {
       expect(
         typeof returned.durationMs === 'number' && (returned.durationMs as number) >= 0,
-        driver.describe('RFC 0064 §B', 'a completed tool call MUST record a non-negative durationMs'),
+        req('openwop.it.tool-hooks-content-free.toolcalled-carries-argshash-toolreturned-carries-status-durationms', 'RFC 0064 §B', 'a completed tool call MUST record a non-negative durationMs'),
       ).toBe(true);
     }
   });

package/src/scenarios/tool-hooks-failure-honesty.test.ts

@@ -17,8 +17,8 @@
 
 import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
-import { driver } from '../lib/driver.js';
 import { readToolHooksCap, invokeToolHook } from '../lib/toolHooks.js';
+import { req } from '../lib/requirement-ids.js';
 
 describe('tool-hooks-failure-honesty (RFC 0064 §F)', () => {
   it('a failing tool yields a populated error, never a bare success', async () => {
@@ -42,20 +42,20 @@ describe('tool-hooks-failure-honesty (RFC 0064 §F)', () => {
     // §F: the failure carries a populated `_errorObject { code, message }`.
     expect(
       err !== undefined && typeof err['code'] === 'string' && (err['code'] as string).length > 0 && typeof err['message'] === 'string',
-      driver.describe('RFC 0064 §F', 'a failed tool MUST populate error {code, message} on agent.toolReturned'),
+      req('openwop.it.tool-hooks-failure-honesty.a-failing-tool-yields-a-populated-error-never-a-bare-success', 'RFC 0064 §F', 'a failed tool MUST populate error {code, message} on agent.toolReturned'),
     ).toBe(true);
 
     // §F: `error` and `outcome` are mutually exclusive.
     expect(
       returned['outcome'] === undefined,
-      driver.describe('RFC 0064 §F', 'error and outcome are mutually exclusive on a failed tool-return'),
+      req('openwop.it.tool-hooks-failure-honesty.a-failing-tool-yields-a-populated-error-never-a-bare-success', 'RFC 0064 §F', 'error and outcome are mutually exclusive on a failed tool-return'),
     ).toBe(true);
 
     // §F: a host advertising `prePostEvents` MUST also set `status: 'error'`.
     if (cap['prePostEvents'] === true) {
       expect(
         returned['status'] === 'error',
-        driver.describe('RFC 0064 §F', 'a host advertising prePostEvents MUST set status:"error" on a tool failure'),
+        req('openwop.it.tool-hooks-failure-honesty.a-failing-tool-yields-a-populated-error-never-a-bare-success', 'RFC 0064 §F', 'a host advertising prePostEvents MUST set status:"error" on a tool failure'),
       ).toBe(true);
     }
   });

package/src/scenarios/tool-hooks-rate-limit.test.ts

@@ -11,8 +11,8 @@
 
 import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
-import { driver } from '../lib/driver.js';
 import { readToolHooksCap, invokeToolHook } from '../lib/toolHooks.js';
+import { req } from '../lib/requirement-ids.js';
 
 describe('tool-hooks-rate-limit (RFC 0064 §D)', () => {
   it('an exhausted (principal, tool) bucket yields status:"rate_limited"', async () => {
@@ -27,7 +27,7 @@ describe('tool-hooks-rate-limit (RFC 0064 §D)', () => {
     if (res === null) return softSkip('blocked', 'seam absent — soft-skip');
     expect(
       (res.toolReturned ?? {}).status,
-      driver.describe('RFC 0064 §D', 'an exhausted token bucket MUST yield status:"rate_limited" without invoking the tool'),
+      req('openwop.it.tool-hooks-rate-limit.an-exhausted-principal-tool-bucket-yields-status-rate-limited', 'RFC 0064 §D', 'an exhausted token bucket MUST yield status:"rate_limited" without invoking the tool'),
     ).toBe('rate_limited');
   });
 });

package/src/scenarios/tool-hooks-secret-redaction.test.ts

@@ -12,8 +12,8 @@
 
 import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
-import { driver } from '../lib/driver.js';
 import { readToolHooksCap, invokeToolHook } from '../lib/toolHooks.js';
+import { req } from '../lib/requirement-ids.js';
 
 const CANARY = 'sk-canary-rfc0064-do-not-leak-xyz789';
 
@@ -29,7 +29,7 @@ describe('tool-hooks-secret-redaction (RFC 0064 §E)', () => {
     if (res === null) return softSkip('blocked', 'seam absent — soft-skip');
     expect(
       JSON.stringify(res).includes(CANARY),
-      driver.describe('RFC 0064 §B', 'a resolved secret MUST be redacted before hashing; the raw value MUST NOT appear in argsHash or any emitted field (SR-1)'),
+      req('openwop.it.tool-hooks-secret-redaction.a-secret-shaped-tool-arg-never-appears-in-the-emitted-events', 'RFC 0064 §B', 'a resolved secret MUST be redacted before hashing; the raw value MUST NOT appear in argsHash or any emitted field (SR-1)'),
     ).toBe(false);
   });
 });

package/src/scenarios/tool-hooks-shape.test.ts

@@ -12,8 +12,8 @@
 
 import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
-import { driver } from '../lib/driver.js';
 import { readToolHooksCap } from '../lib/toolHooks.js';
+import { req } from '../lib/requirement-ids.js';
 
 describe('tool-hooks-shape: advertisement (RFC 0064 §A)', () => {
   it('capabilities.toolHooks is absent or a well-formed object', async () => {
@@ -21,13 +21,13 @@ describe('tool-hooks-shape: advertisement (RFC 0064 §A)', () => {
     if (cap === null) return softSkip('inapplicable', 'not advertised — valid');
     expect(
       typeof cap.supported,
-      driver.describe('capabilities.schema.json §toolHooks', 'toolHooks.supported MUST be a boolean when the block is present'),
+      req('openwop.it.tool-hooks-shape.capabilities-toolhooks-is-absent-or-a-well-formed-object', 'capabilities.schema.json §toolHooks', 'toolHooks.supported MUST be a boolean when the block is present'),
     ).toBe('boolean');
     for (const k of ['prePostEvents', 'perToolAuthorization', 'perToolRateLimit'] as const) {
       if (cap[k] !== undefined) {
         expect(
           typeof cap[k],
-          driver.describe('capabilities.schema.json §toolHooks', `toolHooks.${k} MUST be a boolean when present`),
+          req('openwop.it.tool-hooks-shape.capabilities-toolhooks-is-absent-or-a-well-formed-object', 'capabilities.schema.json §toolHooks', `toolHooks.${k} MUST be a boolean when present`),
         ).toBe('boolean');
       }
     }

package/src/scenarios/tool-session-lifecycle.test.ts

@@ -19,10 +19,11 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { readToolCatalogCap, driveToolSession, TOOL_CONTENT_FORBIDDEN } from '../lib/toolCatalog.js';
 import { queryTestEvents, isEventLogSeamAvailable, resetTestSeam } from '../lib/event-log-query.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const SESSION_OUTCOMES = ['completed', 'failed', 'aborted', 'expired'];
 /** RFC 0064 tool-call event family bracketed by a tool session. */
@@ -35,21 +36,21 @@ describe('tool-session-lifecycle (RFC 0078 §D)', () => {
     const lifecycle = cap?.sessionLifecycle === true || (typeof cap?.sessionLifecycle === 'object' && cap?.sessionLifecycle !== null);
     if (!behaviorGate('openwop-tool-session-lifecycle', lifecycle)) 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
     const res = await driveToolSession({});
-    if (res === null || !res.runId) return; // session seam absent — soft-skip
+    if (res === null || !res.runId) return softSkip('blocked', 'precondition not met — `res === null || !res.runId` returned early (session seam absent — soft-skip) (seam, prior step, or fixture unavailable)'); // session seam absent — soft-skip
 
     const q = await queryTestEvents(res.runId);
-    if (!q.ok) return;
+    if (!q.ok) return softSkip('blocked', 'precondition not met — `!q.ok` returned early (seam, prior step, or fixture unavailable)');
     const events = q.events.slice().sort((a, b) => a.sequence - b.sequence);
 
     const opened = events.filter((e) => e.type === 'tool.session.opened');
     const closed = events.filter((e) => e.type === 'tool.session.closed');
     expect(
       opened.length >= 1 && closed.length >= 1,
-      driver.describe('tool-catalog.md §D', 'a tool session MUST emit tool.session.opened + tool.session.closed'),
+      req('openwop.it.tool-session-lifecycle.brackets-the-call-events-with-tool-session-opened-first-closed-last-one-sessioni', 'tool-catalog.md §D', 'a tool session MUST emit tool.session.opened + tool.session.closed'),
     ).toBe(true);
-    if (opened.length === 0 || closed.length === 0) return;
+    if (opened.length === 0 || closed.length === 0) return softSkip('blocked', 'precondition not met — `opened.length === 0 || closed.length === 0` returned early (seam, prior step, or fixture unavailable)');
 
     const open = opened[0]!;
     const close = closed[closed.length - 1]!;
@@ -59,16 +60,16 @@ describe('tool-session-lifecycle (RFC 0078 §D)', () => {
     if (calls.length > 0) {
       expect(
         open.sequence < calls[0]!.sequence,
-        driver.describe('RFC 0078 §D', 'tool.session.opened MUST precede the first call event'),
+        req('openwop.it.tool-session-lifecycle.brackets-the-call-events-with-tool-session-opened-first-closed-last-one-sessioni', 'RFC 0078 §D', 'tool.session.opened MUST precede the first call event'),
       ).toBe(true);
       expect(
         close.sequence > calls[calls.length - 1]!.sequence,
-        driver.describe('RFC 0078 §D', 'tool.session.closed MUST follow the last call event'),
+        req('openwop.it.tool-session-lifecycle.brackets-the-call-events-with-tool-session-opened-first-closed-last-one-sessioni', 'RFC 0078 §D', 'tool.session.closed MUST follow the last call event'),
       ).toBe(true);
     } else {
       expect(
         open.sequence < close.sequence,
-        driver.describe('RFC 0078 §D', 'tool.session.opened MUST precede tool.session.closed'),
+        req('openwop.it.tool-session-lifecycle.brackets-the-call-events-with-tool-session-opened-first-closed-last-one-sessioni', 'RFC 0078 §D', 'tool.session.opened MUST precede tool.session.closed'),
       ).toBe(true);
     }
 
@@ -77,17 +78,17 @@ describe('tool-session-lifecycle (RFC 0078 §D)', () => {
     const closeSid = close.payload.sessionId;
     expect(
       typeof openSid === 'string' && openSid === closeSid,
-      driver.describe('run-event-payloads.schema.json#toolSession*', 'the bracket MUST share one sessionId'),
+      req('openwop.it.tool-session-lifecycle.brackets-the-call-events-with-tool-session-opened-first-closed-last-one-sessioni', 'run-event-payloads.schema.json#toolSession*', 'the bracket MUST share one sessionId'),
     ).toBe(true);
     expect(
       typeof open.payload.toolId === 'string' && typeof close.payload.toolId === 'string',
-      driver.describe('run-event-payloads.schema.json#toolSession*', 'tool.session.* MUST carry a toolId'),
+      req('openwop.it.tool-session-lifecycle.brackets-the-call-events-with-tool-session-opened-first-closed-last-one-sessioni', 'run-event-payloads.schema.json#toolSession*', 'tool.session.* MUST carry a toolId'),
     ).toBe(true);
 
     // Closed outcome enum discipline.
     expect(
       typeof close.payload.outcome === 'string' && SESSION_OUTCOMES.includes(close.payload.outcome as string),
-      driver.describe('run-event-payloads.schema.json#toolSessionClosed', 'outcome MUST be in the closed enum'),
+      req('openwop.it.tool-session-lifecycle.brackets-the-call-events-with-tool-session-opened-first-closed-last-one-sessioni', 'run-event-payloads.schema.json#toolSessionClosed', 'outcome MUST be in the closed enum'),
     ).toBe(true);
 
     // Content-free: identifiers + metadata only.
@@ -95,7 +96,7 @@ describe('tool-session-lifecycle (RFC 0078 §D)', () => {
       for (const forbidden of TOOL_CONTENT_FORBIDDEN) {
         expect(
           !(forbidden in evt.payload),
-          driver.describe('RFC 0078 §F (SR-1)', `tool.session.* MUST be content-free (no ${forbidden})`),
+          req('openwop.it.tool-session-lifecycle.brackets-the-call-events-with-tool-session-opened-first-closed-last-one-sessioni', 'RFC 0078 §F (SR-1)', `tool.session.* MUST be content-free (no ${forbidden})`),
         ).toBe(true);
       }
     }

package/src/scenarios/trigger-bridge-delivery.test.ts

@@ -29,7 +29,6 @@
 
 import { describe, it, expect } from 'vitest';
 import { seamAbsent } from '../lib/soft-skip.js';
-import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import {
   isTriggerBridgeProfileAdvertised,
@@ -38,6 +37,7 @@ import {
   SUBSCRIPTION_STATES,
 } from '../lib/triggerBridge.js';
 import { queryTestEvents, requireEvents, isEventLogSeamAvailable, resetTestSeam } from '../lib/event-log-query.js';
+import { req } from '../lib/requirement-ids.js';
 
 const CONTENT_FREE_FORBIDDEN = ['body', 'headers', 'payload', 'secret', 'credentials', 'token', 'apiKey'];
 
@@ -45,7 +45,7 @@ function expectContentFree(payload: Record<string, unknown>, where: string): voi
   for (const f of CONTENT_FREE_FORBIDDEN) {
     expect(
       !(f in payload),
-      driver.describe('RFC 0083 §C (SR-1)', `${where} MUST be content-free (no ${f})`),
+      req('openwop.it.trigger-bridge-delivery.de-dups-by-dedupkey-retries-to-dead-letter-and-links-delivery-run-causation', 'RFC 0083 §C (SR-1)', `${where} MUST be content-free (no ${f})`),
     ).toBe(true);
   }
 }
@@ -72,12 +72,12 @@ describe('trigger-bridge-delivery (RFC 0083 §C)', () => {
     );
     expect(
       deliveredForKey.length === 1,
-      driver.describe('trigger-bridge.md §C-1', 'a repeated dedupKey MUST be effectively-once — EXACTLY one delivered attempt (not zero, not two)'),
+      req('openwop.it.trigger-bridge-delivery.de-dups-by-dedupkey-retries-to-dead-letter-and-links-delivery-run-causation', 'trigger-bridge.md §C-1', 'a repeated dedupKey MUST be effectively-once — EXACTLY one delivered attempt (not zero, not two)'),
     ).toBe(true);
     for (const e of dedupEvents) {
       expect(
         typeof e.payload.outcome === 'string' && DELIVERY_OUTCOMES.includes(e.payload.outcome as string),
-        driver.describe('run-event-payloads.schema.json#triggerDeliveryAttempted', 'outcome MUST be delivered|retrying|dead-lettered'),
+        req('openwop.it.trigger-bridge-delivery.de-dups-by-dedupkey-retries-to-dead-letter-and-links-delivery-run-causation', 'run-event-payloads.schema.json#triggerDeliveryAttempted', 'outcome MUST be delivered|retrying|dead-lettered'),
       ).toBe(true);
       expectContentFree(e.payload, 'trigger.delivery.attempted');
     }
@@ -86,7 +86,7 @@ describe('trigger-bridge-delivery (RFC 0083 §C)', () => {
     const exhaust = await driveDelivery({ scenario: 'exhaust', source: 'webhook' });
     expect(
       exhaust !== null,
-      driver.describe('trigger-bridge.md §C-2', 'the exhaust scenario MUST be wired when the delivery seam is'),
+      req('openwop.it.trigger-bridge-delivery.de-dups-by-dedupkey-retries-to-dead-letter-and-links-delivery-run-causation', 'trigger-bridge.md §C-2', 'the exhaust scenario MUST be wired when the delivery seam is'),
     ).toBe(true);
     const exKey = exhaust!.runId ?? '__exhaust__';
     const exhaustEvents = requireEvents(
@@ -95,12 +95,12 @@ describe('trigger-bridge-delivery (RFC 0083 §C)', () => {
     );
     expect(
       exhaustEvents.length >= 1,
-      driver.describe('trigger-bridge.md §C-2', 'an exhausted delivery MUST emit ≥1 trigger.delivery.attempted'),
+      req('openwop.it.trigger-bridge-delivery.de-dups-by-dedupkey-retries-to-dead-letter-and-links-delivery-run-causation', 'trigger-bridge.md §C-2', 'an exhausted delivery MUST emit ≥1 trigger.delivery.attempted'),
     ).toBe(true);
     const terminal = exhaustEvents.sort((a, b) => a.sequence - b.sequence)[exhaustEvents.length - 1]!;
     expect(
       terminal.payload.outcome === 'dead-lettered',
-      driver.describe('trigger-bridge.md §C-2', 'an exhausted retry policy MUST terminate in a dead-lettered delivery'),
+      req('openwop.it.trigger-bridge-delivery.de-dups-by-dedupkey-retries-to-dead-letter-and-links-delivery-run-causation', 'trigger-bridge.md §C-2', 'an exhausted retry policy MUST terminate in a dead-lettered delivery'),
     ).toBe(true);
     const stateEvents = requireEvents(
       await queryTestEvents(exKey, { type: 'trigger.subscription.state.changed' }),
@@ -108,16 +108,16 @@ describe('trigger-bridge-delivery (RFC 0083 §C)', () => {
     );
     expect(
       stateEvents.length >= 1,
-      driver.describe('trigger-bridge.md §B', 'exhaustion MUST emit ≥1 trigger.subscription.state.changed'),
+      req('openwop.it.trigger-bridge-delivery.de-dups-by-dedupkey-retries-to-dead-letter-and-links-delivery-run-causation', 'trigger-bridge.md §B', 'exhaustion MUST emit ≥1 trigger.subscription.state.changed'),
     ).toBe(true);
     expect(
       stateEvents.some((e) => e.payload.toState === 'dead-lettered'),
-      driver.describe('trigger-bridge.md §B', 'the subscription MUST transition to dead-lettered on exhaustion'),
+      req('openwop.it.trigger-bridge-delivery.de-dups-by-dedupkey-retries-to-dead-letter-and-links-delivery-run-causation', 'trigger-bridge.md §B', 'the subscription MUST transition to dead-lettered on exhaustion'),
     ).toBe(true);
     for (const e of stateEvents) {
       expect(
         typeof e.payload.toState === 'string' && SUBSCRIPTION_STATES.includes(e.payload.toState as string),
-        driver.describe('trigger-bridge.md §B', 'toState MUST be in the four-state vocabulary'),
+        req('openwop.it.trigger-bridge-delivery.de-dups-by-dedupkey-retries-to-dead-letter-and-links-delivery-run-causation', 'trigger-bridge.md §B', 'toState MUST be in the four-state vocabulary'),
       ).toBe(true);
       expectContentFree(e.payload, 'trigger.subscription.state.changed');
     }
@@ -130,7 +130,7 @@ describe('trigger-bridge-delivery (RFC 0083 §C)', () => {
     const delivered = await driveDelivery({ scenario: 'deliver', source: 'schedule' });
     expect(
       delivered !== null && typeof delivered.runId === 'string' && (delivered.runId as string).length > 0,
-      driver.describe('trigger-bridge.md §C', 'a successful delivery MUST create a run'),
+      req('openwop.it.trigger-bridge-delivery.de-dups-by-dedupkey-retries-to-dead-letter-and-links-delivery-run-causation', 'trigger-bridge.md §C', 'a successful delivery MUST create a run'),
     ).toBe(true);
     const deliveredRunId = delivered!.runId as string;
     const attemptEvents = requireEvents(
@@ -140,7 +140,7 @@ describe('trigger-bridge-delivery (RFC 0083 §C)', () => {
     const deliveredEvent = attemptEvents.find((e) => e.payload.outcome === 'delivered');
     expect(
       deliveredEvent !== undefined,
-      driver.describe('trigger-bridge.md §C-1', 'a successful delivery MUST emit a trigger.delivery.attempted{outcome:delivered}'),
+      req('openwop.it.trigger-bridge-delivery.de-dups-by-dedupkey-retries-to-dead-letter-and-links-delivery-run-causation', 'trigger-bridge.md §C-1', 'a successful delivery MUST emit a trigger.delivery.attempted{outcome:delivered}'),
     ).toBe(true);
     const runStartedEvents = requireEvents(
       await queryTestEvents(deliveredRunId, { type: 'run.started' }),
@@ -148,14 +148,14 @@ describe('trigger-bridge-delivery (RFC 0083 §C)', () => {
     );
     expect(
       runStartedEvents.length >= 1,
-      driver.describe('trigger-bridge.md §C', 'a delivered run MUST emit run.started'),
+      req('openwop.it.trigger-bridge-delivery.de-dups-by-dedupkey-retries-to-dead-letter-and-links-delivery-run-causation', 'trigger-bridge.md §C', 'a delivered run MUST emit run.started'),
     ).toBe(true);
     const runStarted = runStartedEvents.sort((a, b) => a.sequence - b.sequence)[0]!;
     expect(
       typeof runStarted.causationId === 'string' &&
         (runStarted.causationId as string).length > 0 &&
         runStarted.causationId === deliveredEvent!.eventId,
-      driver.describe('trigger-bridge.md §C / RFC 0040', 'run.started.causationId MUST EQUAL the delivery id (the trigger.delivery.attempted{delivered} eventId) — resolvable via /ancestry'),
+      req('openwop.it.trigger-bridge-delivery.de-dups-by-dedupkey-retries-to-dead-letter-and-links-delivery-run-causation', 'trigger-bridge.md §C / RFC 0040', 'run.started.causationId MUST EQUAL the delivery id (the trigger.delivery.attempted{delivered} eventId) — resolvable via /ancestry'),
     ).toBe(true);
 
     await resetTestSeam();

package/src/scenarios/trigger-bridge-shape.test.ts

@@ -36,8 +36,7 @@ import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
 import { SCHEMAS_DIR } from '../lib/paths.js';
 import { deriveProfiles } from '../lib/profiles.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>;
@@ -53,26 +52,26 @@ describe('trigger-bridge-shape: TriggerSubscription (RFC 0083 §B, server-free)'
   it('a conforming subscription validates', () => {
     expect(
       validate({ subscriptionId: 'sub-1', source: 'webhook', state: 'active', dedupEnabled: true, retryPolicy: { maxAttempts: 8, backoff: 'exponential' }, webhookId: 'wh-1', secretFingerprint: 'fp-abc' }),
-      why('trigger-bridge.md §B', 'a conforming TriggerSubscription MUST validate'),
+      req('openwop.it.trigger-bridge-shape.a-conforming-subscription-validates', 'trigger-bridge.md §B', 'a conforming TriggerSubscription MUST validate'),
     ).toBe(true);
   });
 
   it('rejects a missing REQUIRED state, an out-of-enum source, and an unknown property', () => {
-    expect(validate({ subscriptionId: 's', source: 'webhook' }), why('trigger-bridge.md §B', 'state is REQUIRED')).toBe(false);
-    expect(validate({ subscriptionId: 's', source: 'carrier-pigeon', state: 'active' }), why('trigger-bridge.md §B', 'source is a closed enum')).toBe(false);
-    expect(validate({ subscriptionId: 's', source: 'webhook', state: 'active', body: 'inbound' }), why('trigger-bridge.md §B', 'TriggerSubscription MUST be additionalProperties:false')).toBe(false);
+    expect(validate({ subscriptionId: 's', source: 'webhook' }), req('openwop.it.trigger-bridge-shape.rejects-a-missing-required-state-an-out-of-enum-source-and-an-unknown-property', 'trigger-bridge.md §B', 'state is REQUIRED')).toBe(false);
+    expect(validate({ subscriptionId: 's', source: 'carrier-pigeon', state: 'active' }), req('openwop.it.trigger-bridge-shape.rejects-a-missing-required-state-an-out-of-enum-source-and-an-unknown-property', 'trigger-bridge.md §B', 'source is a closed enum')).toBe(false);
+    expect(validate({ subscriptionId: 's', source: 'webhook', state: 'active', body: 'inbound' }), req('openwop.it.trigger-bridge-shape.rejects-a-missing-required-state-an-out-of-enum-source-and-an-unknown-property', 'trigger-bridge.md §B', 'TriggerSubscription MUST be additionalProperties:false')).toBe(false);
   });
 
   it('secretFingerprint MUST be bounded — a full 64-hex (unsalted-hash-smelling) digest is rejected', () => {
     const truncated = 'a1b2c3d4e5f6a7b8';      // 16 hex — a truncated host-keyed fingerprint
     const fullDigest = 'a'.repeat(64);          // 64 hex — smells like an unsalted SHA256(secret)
-    expect(validate({ subscriptionId: 's', source: 'webhook', state: 'active', secretFingerprint: truncated }), why('trigger-bridge.md §B', 'a truncated fingerprint MUST validate')).toBe(true);
-    expect(validate({ subscriptionId: 's', source: 'webhook', state: 'active', secretFingerprint: fullDigest }), why('SR-1', 'a full 64-hex digest MUST be rejected (brute-force oracle)')).toBe(false);
+    expect(validate({ subscriptionId: 's', source: 'webhook', state: 'active', secretFingerprint: truncated }), req('openwop.it.trigger-bridge-shape.secretfingerprint-must-be-bounded-a-full-64-hex-unsalted-hash-smelling-digest-is', 'trigger-bridge.md §B', 'a truncated fingerprint MUST validate')).toBe(true);
+    expect(validate({ subscriptionId: 's', source: 'webhook', state: 'active', secretFingerprint: fullDigest }), req('openwop.it.trigger-bridge-shape.secretfingerprint-must-be-bounded-a-full-64-hex-unsalted-hash-smelling-digest-is', 'SR-1', 'a full 64-hex digest MUST be rejected (brute-force oracle)')).toBe(false);
   });
 
   it('the state enum is exactly the four §B states', () => {
     const stateEnum = ((sub.properties as Record<string, { enum?: string[] }>).state?.enum) ?? [];
-    expect([...stateEnum].sort(), why('trigger-bridge.md §B', 'the four-state vocabulary MUST be stable')).toEqual([...STATES].sort());
+    expect([...stateEnum].sort(), req('openwop.it.trigger-bridge-shape.the-state-enum-is-exactly-the-four-b-states', 'trigger-bridge.md §B', 'the four-state vocabulary MUST be stable')).toEqual([...STATES].sort());
   });
 });
 
@@ -87,23 +86,23 @@ describe('trigger-bridge-shape: trigger.* events (RFC 0083 §C, server-free)', (
 
   it('trigger.subscription.state.changed validates + reason is a CLOSED enum (no URL-bearing free text)', () => {
     const v = compile('triggerSubscriptionStateChanged');
-    expect(v({ subscriptionId: 's', source: 'webhook', fromState: 'active', toState: 'dead-lettered', reason: 'retry-exhausted' }), why('trigger-bridge.md §C', 'state-changed MUST validate')).toBe(true);
-    expect(v({ subscriptionId: 's', source: 'webhook', fromState: 'active' }), why('trigger-bridge.md §C', 'toState is REQUIRED')).toBe(false);
-    expect(v({ subscriptionId: 's', source: 'webhook', fromState: 'active', toState: 'failed', reason: 'https://attacker.example/leak?token=sk' }), why('SR-1', 'a free-form / URL-bearing reason MUST be rejected')).toBe(false);
+    expect(v({ subscriptionId: 's', source: 'webhook', fromState: 'active', toState: 'dead-lettered', reason: 'retry-exhausted' }), req('openwop.it.trigger-bridge-shape.trigger-subscription-state-changed-validates-reason-is-a-closed-enum-no-url-bear', 'trigger-bridge.md §C', 'state-changed MUST validate')).toBe(true);
+    expect(v({ subscriptionId: 's', source: 'webhook', fromState: 'active' }), req('openwop.it.trigger-bridge-shape.trigger-subscription-state-changed-validates-reason-is-a-closed-enum-no-url-bear', 'trigger-bridge.md §C', 'toState is REQUIRED')).toBe(false);
+    expect(v({ subscriptionId: 's', source: 'webhook', fromState: 'active', toState: 'failed', reason: 'https://attacker.example/leak?token=sk' }), req('openwop.it.trigger-bridge-shape.trigger-subscription-state-changed-validates-reason-is-a-closed-enum-no-url-bear', 'SR-1', 'a free-form / URL-bearing reason MUST be rejected')).toBe(false);
   });
 
   it('trigger.delivery.attempted validates + enforces the outcome enum', () => {
     const v = compile('triggerDeliveryAttempted');
-    expect(v({ subscriptionId: 's', dedupKey: 'evt-9f3', attempt: 1, outcome: 'delivered', runId: 'run_x' }), why('trigger-bridge.md §C', 'delivery-attempted MUST validate')).toBe(true);
-    expect(v({ subscriptionId: 's', dedupKey: 'evt-9f3', attempt: 1 }), why('trigger-bridge.md §C', 'outcome is REQUIRED')).toBe(false);
-    expect(v({ subscriptionId: 's', dedupKey: 'evt-9f3', attempt: 1, outcome: 'exploded' }), why('trigger-bridge.md §C', 'outcome is a closed enum')).toBe(false);
+    expect(v({ subscriptionId: 's', dedupKey: 'evt-9f3', attempt: 1, outcome: 'delivered', runId: 'run_x' }), req('openwop.it.trigger-bridge-shape.trigger-delivery-attempted-validates-enforces-the-outcome-enum', 'trigger-bridge.md §C', 'delivery-attempted MUST validate')).toBe(true);
+    expect(v({ subscriptionId: 's', dedupKey: 'evt-9f3', attempt: 1 }), req('openwop.it.trigger-bridge-shape.trigger-delivery-attempted-validates-enforces-the-outcome-enum', 'trigger-bridge.md §C', 'outcome is REQUIRED')).toBe(false);
+    expect(v({ subscriptionId: 's', dedupKey: 'evt-9f3', attempt: 1, outcome: 'exploded' }), req('openwop.it.trigger-bridge-shape.trigger-delivery-attempted-validates-enforces-the-outcome-enum', 'trigger-bridge.md §C', 'outcome is a closed enum')).toBe(false);
   });
 
   it('both trigger event names appear in the RunEventType enum', () => {
     const runEvent = loadSchema('run-event.schema.json');
     const enumVals = ((runEvent.$defs as Record<string, { enum?: string[] }>).RunEventType?.enum) ?? [];
     for (const name of ['trigger.subscription.state.changed', 'trigger.delivery.attempted']) {
-      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.trigger-bridge-shape.both-trigger-event-names-appear-in-the-runeventtype-enum', 'run-event.schema.json', `${name} MUST be in the RunEventType enum`)).toBe(true);
     }
   });
 });
@@ -112,8 +111,8 @@ describe('trigger-bridge-shape: capability + profile derivation (RFC 0083 §A/§
   it('capabilities.triggerBridge + webhooks.durable are declared', () => {
     const caps = loadSchema('capabilities.schema.json');
     const props = caps.properties as Record<string, { properties?: Record<string, unknown> }>;
-    expect(props.triggerBridge?.properties?.supported, why('trigger-bridge.md §A', 'triggerBridge.supported MUST be declared')).toBeDefined();
-    expect(props.webhooks?.properties?.durable, why('trigger-bridge.md §A', 'webhooks.durable MUST be declared')).toBeDefined();
+    expect(props.triggerBridge?.properties?.supported, req('openwop.it.trigger-bridge-shape.capabilities-triggerbridge-webhooks-durable-are-declared', 'trigger-bridge.md §A', 'triggerBridge.supported MUST be declared')).toBeDefined();
+    expect(props.webhooks?.properties?.durable, req('openwop.it.trigger-bridge-shape.capabilities-triggerbridge-webhooks-durable-are-declared', 'trigger-bridge.md §A', 'webhooks.durable MUST be declared')).toBeDefined();
   });
 
   const coreBase = {
@@ -125,11 +124,11 @@ describe('trigger-bridge-shape: capability + profile derivation (RFC 0083 §A/§
 
   it('deriveProfiles surfaces openwop-trigger-bridge for bridge + deadLetter + a durable source', () => {
     const c = { ...coreBase, triggerBridge: { supported: true }, deadLetter: { supported: true }, queueBus: { supported: true } } as Record<string, unknown>;
-    expect(deriveProfiles(c).includes('openwop-trigger-bridge'), why('profiles.md §openwop-trigger-bridge', 'bridge + sink + durable source MUST derive the profile')).toBe(true);
+    expect(deriveProfiles(c).includes('openwop-trigger-bridge'), req('openwop.it.trigger-bridge-shape.deriveprofiles-surfaces-openwop-trigger-bridge-for-bridge-deadletter-a-durable-s', 'profiles.md §openwop-trigger-bridge', 'bridge + sink + durable source MUST derive the profile')).toBe(true);
   });
 
   it('deriveProfiles withholds openwop-trigger-bridge when the dead-letter sink is absent', () => {
     const c = { ...coreBase, triggerBridge: { supported: true }, webhooks: { durable: true } } as Record<string, unknown>;
-    expect(deriveProfiles(c).includes('openwop-trigger-bridge'), why('profiles.md §openwop-trigger-bridge', 'no deadLetter sink ⇒ MUST NOT derive the profile')).toBe(false);
+    expect(deriveProfiles(c).includes('openwop-trigger-bridge'), req('openwop.it.trigger-bridge-shape.deriveprofiles-withholds-openwop-trigger-bridge-when-the-dead-letter-sink-is-abs', 'profiles.md §openwop-trigger-bridge', 'no deadLetter sink ⇒ MUST NOT derive the profile')).toBe(false);
   });
 });