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

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

@@ -20,6 +20,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 DiscoveryDeadLetter {
   supported?: boolean;
@@ -39,10 +41,10 @@ async function readDeadLetter(): Promise<DiscoveryDeadLetter | null> {
 describe('deadletter-capability-shape: advertisement shape (RFC 0053 §A)', () => {
   it('capabilities.deadLetter is either absent or well-formed', async () => {
     const dl = await readDeadLetter();
-    if (dl === null) return; // host doesn't advertise deadLetter at all
+    if (dl === null) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `dl === null` returned early (host doesn\'t advertise deadLetter at all)'); // host doesn't advertise deadLetter at all
     expect(
       typeof dl.supported,
-      driver.describe(
+      req('openwop.it.deadletter-capability-shape.capabilities-deadletter-is-either-absent-or-well-formed', 
         'capabilities.schema.json §deadLetter',
         'capabilities.deadLetter.supported MUST be a boolean when deadLetter is advertised',
       ),
@@ -51,10 +53,10 @@ describe('deadletter-capability-shape: advertisement shape (RFC 0053 §A)', () =
 
   it('retentionDays is an integer >= 1 when present + supported', async () => {
     const dl = await readDeadLetter();
-    if (!dl?.supported || dl.retentionDays === undefined) return;
+    if (!dl?.supported || dl.retentionDays === undefined) return softSkip('blocked', 'precondition not met — `!dl?.supported || dl.retentionDays === undefined` returned early (seam, prior step, or fixture unavailable)');
     expect(
       Number.isInteger(dl.retentionDays) && dl.retentionDays >= 1,
-      driver.describe('RFC 0053 §A', `capabilities.deadLetter.retentionDays MUST be an integer >= 1, got: ${dl.retentionDays}`),
+      req('openwop.it.deadletter-capability-shape.retentiondays-is-an-integer-1-when-present-supported', 'RFC 0053 §A', `capabilities.deadLetter.retentionDays MUST be an integer >= 1, got: ${dl.retentionDays}`),
     ).toBe(true);
   });
 });

package/src/scenarios/deadletter-retry-exhaustion.test.ts

@@ -25,6 +25,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 DiscoveryDoc {
   capabilities?: { deadLetter?: { supported?: boolean } };
@@ -43,11 +44,11 @@ describe('deadletter-retry-exhaustion: retry exhaustion → dead-lettered + fork
     const body = res.json as { event?: { type?: string; payload?: { attempts?: number; runId?: string } } } | undefined;
     expect(
       body?.event?.type,
-      driver.describe('RFC 0053 §C.1', 'retry exhaustion MUST emit a run.dead_lettered event'),
+      req('openwop.it.deadletter-retry-exhaustion.a-retry-exhausted-run-emits-run-dead-lettered-with-attempts', 'RFC 0053 §C.1', 'retry exhaustion MUST emit a run.dead_lettered event'),
     ).toBe('run.dead_lettered');
     expect(
       typeof body?.event?.payload?.attempts === 'number' && body.event.payload.attempts >= 1,
-      driver.describe('RFC 0053 §C.1', 'run.dead_lettered MUST carry the total attempts (>= 1)'),
+      req('openwop.it.deadletter-retry-exhaustion.a-retry-exhausted-run-emits-run-dead-lettered-with-attempts', 'RFC 0053 §C.1', 'run.dead_lettered MUST carry the total attempts (>= 1)'),
     ).toBe(true);
   });
 
@@ -58,7 +59,7 @@ describe('deadletter-retry-exhaustion: retry exhaustion → dead-lettered + fork
     const body = res.json as { forkEligible?: boolean } | undefined;
     expect(
       body?.forkEligible,
-      driver.describe('RFC 0053 §C.2', 'a dead-lettered run MUST remain fork-eligible within the retention window'),
+      req('openwop.it.deadletter-retry-exhaustion.the-dead-lettered-run-is-fork-eligible-rfc-0011', 'RFC 0053 §C.2', 'a dead-lettered run MUST remain fork-eligible within the retention window'),
     ).toBe(true);
   });
 });

package/src/scenarios/debug-bundle-truncation.test.ts

@@ -23,6 +23,8 @@ 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';
+import { softSkip } from '../lib/soft-skip.js';
 
 // `conformance-multi-node` produces enough events (run.started, three
 // node.started/completed pairs, run.completed = ~8 events) that
@@ -36,7 +38,7 @@ describe('debug-bundle-truncation: truncated: true contract', () => {
       console.warn(
         `[debug-bundle-truncation] ${FIXTURE} not advertised; skipping (host doesn't seed a multi-event fixture)`,
       );
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(FIXTURE)` returned early ([debug-bundle-truncation] … not advertised; skipping (host doesn\'t seed a multi-event fixture))');
     }
 
     const create = await driver.post('/v1/runs', { workflowId: FIXTURE });
@@ -49,8 +51,8 @@ describe('debug-bundle-truncation: truncated: true contract', () => {
     expect(full.status).toBe(200);
     const fullBody = full.json as { events?: unknown[]; truncated?: boolean };
     const fullEventCount = (fullBody.events ?? []).length;
-    expect(fullEventCount, 'multi-node fixture MUST emit ≥ 3 events').toBeGreaterThanOrEqual(3);
-    expect(fullBody.truncated ?? false, 'baseline bundle MUST NOT be truncated').toBe(false);
+    expect(fullEventCount, req('openwop.it.debug-bundle-truncation.host-that-supports-maxevents-n-or-otherwise-caps-surfaces-truncated-truncatedrea', 'debug-bundle.md §"Bundle size limits"', 'multi-node fixture MUST emit ≥ 3 events')).toBeGreaterThanOrEqual(3);
+    expect(fullBody.truncated ?? false, req('openwop.it.debug-bundle-truncation.host-that-supports-maxevents-n-or-otherwise-caps-surfaces-truncated-truncatedrea', 'debug-bundle.md §"Bundle size limits"', 'baseline bundle MUST NOT be truncated')).toBe(false);
 
     // Force truncation via the host's optional maxEvents override.
     const truncated = await driver.get(
@@ -73,21 +75,21 @@ describe('debug-bundle-truncation: truncated: true contract', () => {
       console.warn(
         '[debug-bundle-truncation] host does not honor ?maxEvents=; skipping truncated-shape assertions',
       );
-      return;
+      return softSkip('blocked', 'precondition not met — `body.truncated !== true` returned early ([debug-bundle-truncation] host does not honor ?maxEvents=; skipping truncated-shape assertions) (seam, prior step, or fixture unavailable)');
     }
 
-    expect(typeof body.truncatedReason, driver.describe(
+    expect(typeof body.truncatedReason, req('openwop.it.debug-bundle-truncation.host-that-supports-maxevents-n-or-otherwise-caps-surfaces-truncated-truncatedrea', 
       'debug-bundle.md §"Bundle size limits"',
       'truncated: true MUST be accompanied by a non-empty truncatedReason string',
     )).toBe('string');
     expect((body.truncatedReason ?? '').length).toBeGreaterThan(0);
 
-    expect((body.events ?? []).length, driver.describe(
+    expect((body.events ?? []).length, req('openwop.it.debug-bundle-truncation.host-that-supports-maxevents-n-or-otherwise-caps-surfaces-truncated-truncatedrea', 
       'debug-bundle.md §"Bundle size limits"',
       'truncated events array MUST be a prefix (≤ maxEvents)',
     )).toBeLessThanOrEqual(2);
 
-    expect(body.metrics?.eventCount, driver.describe(
+    expect(body.metrics?.eventCount, req('openwop.it.debug-bundle-truncation.host-that-supports-maxevents-n-or-otherwise-caps-surfaces-truncated-truncatedrea', 
       'debug-bundle.md §"Bundle size limits"',
       'metrics.eventCount MUST reflect the TOTAL event count, not the truncated length',
     )).toBe(fullEventCount);

package/src/scenarios/debugBundle.test.ts

@@ -35,6 +35,8 @@ import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { CANARY_MARKER, getCanary } from '../lib/canaries.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const NOOP_WORKFLOW_ID = 'conformance-noop';
 const SKIP_NO_NOOP = !isFixtureAdvertised(NOOP_WORKFLOW_ID);
@@ -61,7 +63,7 @@ async function isAdvertised(): Promise<boolean> {
 
 describe.skipIf(SKIP_NO_NOOP)('debug-bundle: GET /v1/runs/{runId}/debug-bundle response shape', () => {
   it('host advertising capabilities.debugBundle.supported returns 200 with valid bundle', async () => {
-    if (!(await isAdvertised())) return; // skip-equivalent
+    if (!(await isAdvertised())) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isAdvertised())` returned early (skip-equivalent)'); // skip-equivalent
 
     const create = await driver.post('/v1/runs', { workflowId: NOOP_WORKFLOW_ID });
     expect(create.status).toBe(201);
@@ -69,58 +71,58 @@ describe.skipIf(SKIP_NO_NOOP)('debug-bundle: GET /v1/runs/{runId}/debug-bundle r
     await pollUntilTerminal(runId);
 
     const res = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/debug-bundle`);
-    expect(res.status, driver.describe(
+    expect(res.status, req('openwop.it.debugBundle.host-advertising-capabilities-debugbundle-supported-returns-200-with-valid-bundl', 
       'spec/v1/debug-bundle.md §Endpoint',
       'host advertising debugBundle.supported MUST return 200 on /debug-bundle',
     )).toBe(200);
 
     const bundle = res.json as DebugBundleShape | undefined;
-    expect(bundle, driver.describe(
+    expect(bundle, req('openwop.it.debugBundle.host-advertising-capabilities-debugbundle-supported-returns-200-with-valid-bundl', 
       'spec/v1/debug-bundle.md',
       'response MUST be JSON',
     )).toBeDefined();
 
-    expect(typeof bundle?.bundleVersion, driver.describe(
+    expect(typeof bundle?.bundleVersion, req('openwop.it.debugBundle.host-advertising-capabilities-debugbundle-supported-returns-200-with-valid-bundl', 
       'debug-bundle.md §Field reference',
       'bundleVersion MUST be a string',
     )).toBe('string');
-    expect(typeof bundle?.generatedAt, driver.describe(
+    expect(typeof bundle?.generatedAt, req('openwop.it.debugBundle.host-advertising-capabilities-debugbundle-supported-returns-200-with-valid-bundl', 
       'debug-bundle.md',
       'generatedAt MUST be a string',
     )).toBe('string');
-    expect(typeof bundle?.host?.name, driver.describe(
+    expect(typeof bundle?.host?.name, req('openwop.it.debugBundle.host-advertising-capabilities-debugbundle-supported-returns-200-with-valid-bundl', 
       'debug-bundle.md',
       'host.name MUST be a string',
     )).toBe('string');
-    expect(typeof bundle?.host?.version, driver.describe(
+    expect(typeof bundle?.host?.version, req('openwop.it.debugBundle.host-advertising-capabilities-debugbundle-supported-returns-200-with-valid-bundl', 
       'debug-bundle.md',
       'host.version MUST be a string',
     )).toBe('string');
-    expect(typeof bundle?.run?.runId, driver.describe(
+    expect(typeof bundle?.run?.runId, req('openwop.it.debugBundle.host-advertising-capabilities-debugbundle-supported-returns-200-with-valid-bundl', 
       'debug-bundle.md',
       'run.runId MUST be a string',
     )).toBe('string');
-    expect(Array.isArray(bundle?.events), driver.describe(
+    expect(Array.isArray(bundle?.events), req('openwop.it.debugBundle.host-advertising-capabilities-debugbundle-supported-returns-200-with-valid-bundl', 
       'debug-bundle.md',
       'events MUST be an array',
     )).toBe(true);
-    expect(typeof bundle?.redactionApplied, driver.describe(
+    expect(typeof bundle?.redactionApplied, req('openwop.it.debugBundle.host-advertising-capabilities-debugbundle-supported-returns-200-with-valid-bundl', 
       'debug-bundle.md',
       'redactionApplied MUST be a boolean',
     )).toBe('boolean');
-    expect(typeof bundle?.redactionMode, driver.describe(
+    expect(typeof bundle?.redactionMode, req('openwop.it.debugBundle.host-advertising-capabilities-debugbundle-supported-returns-200-with-valid-bundl', 
       'debug-bundle.md',
       'redactionMode MUST be a string',
     )).toBe('string');
   });
 
   it('hosts not advertising debugBundle return 404 on the endpoint', async () => {
-    if (await isAdvertised()) return; // skip-equivalent for hosts that DO advertise
+    if (await isAdvertised()) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `await isAdvertised()` returned early (skip-equivalent for hosts that DO advertise)'); // skip-equivalent for hosts that DO advertise
 
     // Use any runId — even a synthetic one — since the host should 404
     // on the endpoint regardless of run existence.
     const res = await driver.get('/v1/runs/openwop-conformance-no-such-run/debug-bundle');
-    expect(res.status, driver.describe(
+    expect(res.status, req('openwop.it.debugBundle.hosts-not-advertising-debugbundle-return-404-on-the-endpoint', 
       'debug-bundle.md §Endpoint',
       'host NOT advertising debugBundle.supported MUST return 404',
     )).toBe(404);
@@ -129,7 +131,7 @@ describe.skipIf(SKIP_NO_NOOP)('debug-bundle: GET /v1/runs/{runId}/debug-bundle r
 
 describe.skipIf(SKIP_NO_NOOP)('debug-bundle: invariants per debug-bundle.md', () => {
   it('metrics.eventCount equals events.length', async () => {
-    if (!(await isAdvertised())) return;
+    if (!(await isAdvertised())) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isAdvertised())` returned early');
 
     const create = await driver.post('/v1/runs', { workflowId: NOOP_WORKFLOW_ID });
     expect(create.status).toBe(201);
@@ -141,7 +143,7 @@ describe.skipIf(SKIP_NO_NOOP)('debug-bundle: invariants per debug-bundle.md', ()
     const bundle = res.json as DebugBundleShape;
 
     if (bundle.metrics?.eventCount !== undefined) {
-      expect(bundle.metrics.eventCount, driver.describe(
+      expect(bundle.metrics.eventCount, req('openwop.it.debugBundle.metrics-eventcount-equals-events-length', 
         'debug-bundle.md §"Field reference"',
         'metrics.eventCount MUST equal events.length',
       )).toBe(bundle.events?.length ?? 0);
@@ -149,7 +151,7 @@ describe.skipIf(SKIP_NO_NOOP)('debug-bundle: invariants per debug-bundle.md', ()
   });
 
   it('redactionApplied=true is incompatible with redactionMode=passthrough', async () => {
-    if (!(await isAdvertised())) return;
+    if (!(await isAdvertised())) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isAdvertised())` returned early');
 
     const create = await driver.post('/v1/runs', { workflowId: NOOP_WORKFLOW_ID });
     expect(create.status).toBe(201);
@@ -161,7 +163,7 @@ describe.skipIf(SKIP_NO_NOOP)('debug-bundle: invariants per debug-bundle.md', ()
     const bundle = res.json as DebugBundleShape;
 
     if (bundle.redactionApplied === true) {
-      expect(bundle.redactionMode, driver.describe(
+      expect(bundle.redactionMode, req('openwop.it.debugBundle.redactionapplied-true-is-incompatible-with-redactionmode-passthrough', 
         'debug-bundle.md §"Redaction guarantees"',
         'redactionApplied=true MUST NOT coexist with redactionMode=passthrough — that combination is malformed',
       )).not.toBe('passthrough');
@@ -169,7 +171,7 @@ describe.skipIf(SKIP_NO_NOOP)('debug-bundle: invariants per debug-bundle.md', ()
   });
 
   it('bundle events agree with /events/poll for the same run', async () => {
-    if (!(await isAdvertised())) return;
+    if (!(await isAdvertised())) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isAdvertised())` returned early');
 
     const create = await driver.post('/v1/runs', { workflowId: NOOP_WORKFLOW_ID });
     expect(create.status).toBe(201);
@@ -178,12 +180,12 @@ describe.skipIf(SKIP_NO_NOOP)('debug-bundle: invariants per debug-bundle.md', ()
 
     const bundleRes = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/debug-bundle`);
     const eventsRes = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/events/poll`);
-    if (eventsRes.status !== 200) return; // host without polling
+    if (eventsRes.status !== 200) return softSkip('blocked', 'precondition not met — `eventsRes.status !== 200` returned early (host without polling) (seam, prior step, or fixture unavailable)'); // host without polling
 
     const bundle = bundleRes.json as DebugBundleShape;
     const polledEvents = (eventsRes.json as { events?: unknown[] }).events ?? [];
 
-    expect(bundle.events?.length, driver.describe(
+    expect(bundle.events?.length, req('openwop.it.debugBundle.bundle-events-agree-with-events-poll-for-the-same-run', 
       'debug-bundle.md',
       'bundle event count MUST agree with /events/poll for the same run',
     )).toBe(polledEvents.length);
@@ -192,7 +194,7 @@ describe.skipIf(SKIP_NO_NOOP)('debug-bundle: invariants per debug-bundle.md', ()
 
 describe.skipIf(SKIP_NO_NOOP)('debug-bundle: redaction inheritance per SECURITY/invariants.yaml secret-leakage-debug-bundle', () => {
   it('canary in workflow inputs MUST NOT appear verbatim in the bundle response', async () => {
-    if (!(await isAdvertised())) return;
+    if (!(await isAdvertised())) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isAdvertised())` returned early');
 
     const canary = getCanary('byok-credential-ref').value;
 
@@ -210,11 +212,11 @@ describe.skipIf(SKIP_NO_NOOP)('debug-bundle: redaction inheritance per SECURITY/
     expect(res.status).toBe(200);
 
     const bundleText = res.text;
-    expect(bundleText.includes(canary), driver.describe(
+    expect(bundleText.includes(canary), req('openwop.it.debugBundle.canary-in-workflow-inputs-must-not-appear-verbatim-in-the-bundle-response', 
       'SECURITY/invariants.yaml secret-leakage-debug-bundle',
       'BYOK-shaped canary submitted as workflow input MUST NOT appear verbatim in the debug bundle',
     )).toBe(false);
-    expect(bundleText.includes(CANARY_MARKER), driver.describe(
+    expect(bundleText.includes(CANARY_MARKER), req('openwop.it.debugBundle.canary-in-workflow-inputs-must-not-appear-verbatim-in-the-bundle-response', 
       'SECURITY/invariants.yaml secret-leakage-debug-bundle',
       'canary marker MUST NOT appear in the debug bundle',
     )).toBe(false);

package/src/scenarios/discovery-families-view.test.ts

@@ -13,25 +13,26 @@
 
 import { describe, it, expect } from 'vitest';
 import { discoveryFamilies } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 describe('RFC 0073 — discoveryFamilies is root-first with the deprecated wrapper as fallback', () => {
   it('a root-only document is read as-is (the RFC 0073 shape)', () => {
-    expect(discoveryFamilies({ protocolVersion: '1.0', kvStorage: { supported: true } })).toEqual({ protocolVersion: '1.0', kvStorage: { supported: true } });
+    expect(discoveryFamilies({ protocolVersion: '1.0', kvStorage: { supported: true } }), req('openwop.it.discovery-families-view.a-root-only-document-is-read-as-is-the-rfc-0073-shape', 'RFC 0073', 'a root-only document is read as-is (the RFC 0073 shape)')).toEqual({ protocolVersion: '1.0', kvStorage: { supported: true } });
   });
 
   it('a wrapper-only family is still visible, and the wrapper key itself is not a family', () => {
     const v = discoveryFamilies({ protocolVersion: '1.0', capabilities: { heartbeat: { supported: true } } });
-    expect(v['heartbeat']).toEqual({ supported: true });
+    expect(v['heartbeat'], req('openwop.it.discovery-families-view.a-wrapper-only-family-is-still-visible-and-the-wrapper-key-itself-is-not-a-famil', 'RFC 0073', 'a wrapper-only family is still visible, and the wrapper key itself is not a family')).toEqual({ supported: true });
     expect('capabilities' in v).toBe(false);
   });
 
   it('when both carry a family, the root wins', () => {
     const v = discoveryFamilies({ feedback: { supported: true, root: true }, capabilities: { feedback: { supported: false, root: false } } });
-    expect(v['feedback']).toEqual({ supported: true, root: true });
+    expect(v['feedback'], req('openwop.it.discovery-families-view.when-both-carry-a-family-the-root-wins', 'RFC 0073', 'when both carry a family, the root wins')).toEqual({ supported: true, root: true });
   });
 
   it('a non-object document reads as empty', () => {
-    expect(discoveryFamilies(null)).toEqual({});
+    expect(discoveryFamilies(null), req('openwop.it.discovery-families-view.a-non-object-document-reads-as-empty', 'RFC 0073', 'a non-object document reads as empty')).toEqual({});
     expect(discoveryFamilies('nope')).toEqual({});
     expect(discoveryFamilies({ capabilities: ['not', 'an', 'object'] })).toEqual({});
   });

package/src/scenarios/discovery.test.ts

@@ -11,22 +11,23 @@ import { driver } from '../lib/driver.js';
 import { discoveryFamilies } from '../lib/discovery-capabilities.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
 
 describe('discovery: /.well-known/openwop', () => {
   it('returns 200 with required Capabilities fields per capabilities.md §2', async () => {
     const res = await driver.get('/.well-known/openwop', { authenticated: false });
 
-    expect(res.status, driver.describe(
+    expect(res.status, req('openwop.it.discovery.returns-200-with-required-capabilities-fields-per-capabilities-md-2', 
       'capabilities.md §2',
       'discovery endpoint MUST be reachable without auth and return 200',
     )).toBe(200);
 
     const body = res.json as Record<string, unknown> | undefined;
-    expect(body, driver.describe('capabilities.md §2', 'response MUST be JSON')).toBeDefined();
+    expect(body, req('openwop.it.discovery.returns-200-with-required-capabilities-fields-per-capabilities-md-2', 'capabilities.md §2', 'response MUST be JSON')).toBeDefined();
 
     // Per capabilities.md §3 (in-package shape), these 4 fields are REQUIRED.
     for (const required of ['protocolVersion', 'supportedEnvelopes', 'schemaVersions', 'limits']) {
-      expect(body?.[required], driver.describe(
+      expect(body?.[required], req('openwop.it.discovery.returns-200-with-required-capabilities-fields-per-capabilities-md-2', 
         'capabilities.md §3',
         `Capabilities.${required} MUST be present`,
       )).toBeDefined();
@@ -37,7 +38,7 @@ describe('discovery: /.well-known/openwop', () => {
     const res = await driver.get('/.well-known/openwop', { authenticated: false });
     const cacheControl = res.headers.get('cache-control');
 
-    expect(cacheControl, driver.describe(
+    expect(cacheControl, req('openwop.it.discovery.serves-cache-control-per-capabilities-md-4-caching-guidance', 
       'capabilities.md §4',
       'response SHOULD carry a Cache-Control header to allow client caching',
     )).toBeTruthy();
@@ -49,9 +50,9 @@ describe('discovery: /.well-known/openwop', () => {
     if (etag === null) {
       return softSkip('inapplicable', 'host does not send a standard ETag on the discovery document (RFC 0165 §C.2 — SHOULD, presence-gated)');
     }
-    expect(etag.trim().length, driver.describe('RFC 0165 §C.2', 'ETag, when present, MUST be a non-empty validator')).toBeGreaterThan(0);
+    expect(etag.trim().length, req('openwop.it.discovery.if-a-standard-etag-is-present-a-matching-if-none-match-yields-304-rfc-0165-c-2-p', 'RFC 0165 §C.2', 'ETag, when present, MUST be a non-empty validator')).toBeGreaterThan(0);
     const second = await driver.get('/.well-known/openwop', { authenticated: false, headers: { 'If-None-Match': etag } });
-    expect(second.status, driver.describe('capabilities-change-detection.md §"Cache validators"', 'a matching If-None-Match SHOULD yield 304 Not Modified')).toBe(304);
+    expect(second.status, req('openwop.it.discovery.if-a-standard-etag-is-present-a-matching-if-none-match-yields-304-rfc-0165-c-2-p', 'capabilities-change-detection.md §"Cache validators"', 'a matching If-None-Match SHOULD yield 304 Not Modified')).toBe(304);
   });
 
   it('IF Capabilities-Etag is present, it is non-empty and stable within the cache window', async () => {
@@ -59,14 +60,14 @@ describe('discovery: /.well-known/openwop', () => {
     const firstEtag = first.headers.get('capabilities-etag');
 
     if (firstEtag === null) {
-      expect(firstEtag, driver.describe(
+      expect(firstEtag, req('openwop.it.discovery.if-capabilities-etag-is-present-it-is-non-empty-and-stable-within-the-cache-wind', 
         'capabilities-change-detection.md §Capabilities-Etag',
         'Capabilities-Etag is optional; hosts that omit it remain conformant',
       )).toBeNull();
-      return;
+      return softSkip('blocked', 'precondition not met — `firstEtag === null` returned early (seam, prior step, or fixture unavailable)');
     }
 
-    expect(firstEtag.trim().length, driver.describe(
+    expect(firstEtag.trim().length, req('openwop.it.discovery.if-capabilities-etag-is-present-it-is-non-empty-and-stable-within-the-cache-wind', 
       'capabilities-change-detection.md §Capabilities-Etag',
       'Capabilities-Etag, when present, MUST be a non-empty opaque string',
     )).toBeGreaterThan(0);
@@ -74,7 +75,7 @@ describe('discovery: /.well-known/openwop', () => {
     const second = await driver.get('/.well-known/openwop', { authenticated: false });
     const secondEtag = second.headers.get('capabilities-etag');
 
-    expect(secondEtag, driver.describe(
+    expect(secondEtag, req('openwop.it.discovery.if-capabilities-etag-is-present-it-is-non-empty-and-stable-within-the-cache-wind', 
       'capabilities-change-detection.md §Conformance expectations',
       'repeated discovery calls without host changes SHOULD return the same Capabilities-Etag within the cache window',
     )).toBe(firstEtag);
@@ -84,18 +85,18 @@ describe('discovery: /.well-known/openwop', () => {
     const res = await driver.get('/.well-known/openwop', { authenticated: false });
     const limits = (res.json as { limits?: Record<string, number> } | undefined)?.limits;
 
-    expect(limits, driver.describe(
+    expect(limits, req('openwop.it.discovery.declares-non-zero-limits-per-capabilities-md-3-capabilitylimiter-shape', 
       'capabilities.md §3',
       'Capabilities.limits MUST be present',
     )).toBeDefined();
 
     for (const k of ['clarificationRounds', 'schemaRounds', 'envelopesPerTurn']) {
       const v = limits?.[k];
-      expect(typeof v, driver.describe(
+      expect(typeof v, req('openwop.it.discovery.declares-non-zero-limits-per-capabilities-md-3-capabilitylimiter-shape', 
         'capabilities.md §3',
         `limits.${k} MUST be a non-negative integer`,
       )).toBe('number');
-      expect(v ?? -1, driver.describe(
+      expect(v ?? -1, req('openwop.it.discovery.declares-non-zero-limits-per-capabilities-md-3-capabilitylimiter-shape', 
         'capabilities.md §3',
         `limits.${k} MUST be >= 0`,
       )).toBeGreaterThanOrEqual(0);
@@ -115,28 +116,28 @@ describe('discovery: /.well-known/openwop fixtures field shape per RFC 0003', ()
       // RFC 0003 makes the field OPTIONAL — pre-RFC hosts and hosts
       // that opt out advertise nothing. Assertion passes trivially.
       expect(fixtures).toBeUndefined();
-      return;
+      return softSkip('blocked', 'precondition not met — `fixtures === undefined` returned early (seam, prior step, or fixture unavailable)');
     }
 
-    expect(Array.isArray(fixtures), driver.describe(
+    expect(Array.isArray(fixtures), req('openwop.it.discovery.if-fixtures-is-present-it-must-be-a-string-of-unique-non-empty-entries', 
       'capabilities.md §`fixtures` (RFC 0003)',
       'fixtures MUST be an array when present',
     )).toBe(true);
 
     const arr = fixtures as unknown[];
     for (const entry of arr) {
-      expect(typeof entry, driver.describe(
+      expect(typeof entry, req('openwop.it.discovery.if-fixtures-is-present-it-must-be-a-string-of-unique-non-empty-entries', 
         'capabilities.md §`fixtures` (RFC 0003)',
         'every fixtures entry MUST be a string',
       )).toBe('string');
-      expect((entry as string).length, driver.describe(
+      expect((entry as string).length, req('openwop.it.discovery.if-fixtures-is-present-it-must-be-a-string-of-unique-non-empty-entries', 
         'capabilities.md §`fixtures` (RFC 0003)',
         'every fixtures entry MUST be non-empty',
       )).toBeGreaterThan(0);
     }
 
     const unique = new Set(arr as string[]);
-    expect(unique.size, driver.describe(
+    expect(unique.size, req('openwop.it.discovery.if-fixtures-is-present-it-must-be-a-string-of-unique-non-empty-entries', 
       'capabilities.md §`fixtures` (RFC 0003)',
       'fixtures entries SHOULD be unique (consumers MUST tolerate duplicates by deduplicating)',
     )).toBe(arr.length);
@@ -147,13 +148,13 @@ describe('discovery: /v1/openapi.json', () => {
   it('returns 200 with a parseable OpenAPI 3.1 document', async () => {
     const res = await driver.get('/v1/openapi.json', { authenticated: false });
 
-    expect(res.status, driver.describe(
+    expect(res.status, req('openwop.it.discovery.returns-200-with-a-parseable-openapi-3-1-document', 
       'rest-endpoints.md',
       'self-describing OpenAPI endpoint MUST return 200',
     )).toBe(200);
 
     const body = res.json as { openapi?: string } | undefined;
-    expect(body?.openapi, driver.describe(
+    expect(body?.openapi, req('openwop.it.discovery.returns-200-with-a-parseable-openapi-3-1-document', 
       'rest-endpoints.md',
       'response MUST declare openapi >= 3.1',
     )).toMatch(/^3\.[1-9]/);
@@ -210,7 +211,7 @@ describe('discovery: auth-scoped capability shape', () => {
       return;
     }
 
-    expect(disc?.authScoped?.supported, driver.describe(
+    expect(disc?.authScoped?.supported, req('openwop.it.discovery.host-claiming-auth-scoped-discovery-advertises-required-fields', 
       'capabilities-change-detection.md §"Scoped capability views"',
       'capabilities.discovery.authScoped.supported MUST be true when the profile is claimed',
     )).toBe(true);
@@ -218,7 +219,7 @@ describe('discovery: auth-scoped capability shape', () => {
     if (disc?.authScoped?.mode !== undefined) {
       expect(
         ['same-endpoint', 'extension-endpoint'].includes(disc.authScoped.mode),
-        driver.describe(
+        req('openwop.it.discovery.host-claiming-auth-scoped-discovery-advertises-required-fields', 
           'capabilities.schema.json discovery.authScoped.mode',
           'mode MUST be one of same-endpoint / extension-endpoint when advertised',
         ),
@@ -229,7 +230,7 @@ describe('discovery: auth-scoped capability shape', () => {
       expect(
         typeof disc.authScoped.endpointPath === 'string' &&
           disc.authScoped.endpointPath.startsWith('/'),
-        driver.describe(
+        req('openwop.it.discovery.host-claiming-auth-scoped-discovery-advertises-required-fields', 
           'RFCS/0011-auth-scoped-discovery.md §A',
           'extension-endpoint mode MUST advertise endpointPath as a leading-slash relative path',
         ),
@@ -254,13 +255,13 @@ describe('discovery: auth-scoped view satisfies base schema', () => {
 
     const res = await driver.get(path);
 
-    expect(res.status, driver.describe(
+    expect(res.status, req('openwop.it.discovery.authenticated-discovery-preserves-required-capabilities-fields', 
       'capabilities-change-detection.md §"Scoped capability views"',
       'authenticated discovery MUST return 200',
     )).toBe(200);
 
     const body = res.json as Record<string, unknown> | undefined;
-    expect(body, 'authenticated discovery body MUST be JSON').toBeDefined();
+    expect(body, req('openwop.it.discovery.authenticated-discovery-preserves-required-capabilities-fields', 'capabilities-change-detection.md §"Scoped capability views"', 'authenticated discovery body MUST be JSON')).toBeDefined();
 
     // Required fields per capabilities.md §3 preserved in the
     // authenticated view (per spec annex: "MUST still satisfy the
@@ -271,7 +272,7 @@ describe('discovery: auth-scoped view satisfies base schema', () => {
       'schemaVersions',
       'limits',
     ]) {
-      expect(body?.[required], driver.describe(
+      expect(body?.[required], req('openwop.it.discovery.authenticated-discovery-preserves-required-capabilities-fields', 
         'capabilities-change-detection.md §"Scoped capability views"',
         `auth-scoped view MUST preserve required field "${required}" from capabilities.md §3`,
       )).toBeDefined();
@@ -293,7 +294,7 @@ describe('discovery: auth-scoped is not an authorization oracle', () => {
       console.warn(
         '[discovery: auth-scoped] OPENWOP_TEST_UNAUTHORIZED_API_KEY not supplied; skipping authorization-oracle probe',
       );
-      return;
+      return softSkip('blocked', 'precondition not met — `!unauthorizedKey` returned early ([discovery: auth-scoped] OPENWOP_TEST_UNAUTHORIZED_API_KEY not supplied; skipping authorization-oracle probe) (seam, prior step, or fixture unavailable)');
     }
 
     const mode = disc?.authScoped?.mode ?? 'same-endpoint';
@@ -314,7 +315,7 @@ describe('discovery: auth-scoped is not an authorization oracle', () => {
     if (unauthorized.status === 401 || unauthorized.status === 403) {
       // Host rejected the unauthorized key outright — that's fine.
       // The oracle probe is moot when the host refuses the bearer.
-      return;
+      return softSkip('blocked', 'precondition not met — `unauthorized.status === 401 || unauthorized.status === 403` returned early (Host rejected the unauthorized key outright — that\'s fine. The oracle probe is moot when the host refuses the bearer.…');
     }
     expect(unauthorized.status).toBe(200);
 
@@ -330,7 +331,7 @@ describe('discovery: auth-scoped is not an authorization oracle', () => {
     // primary view's keys (no capabilities the unauthorized caller
     // can use that the primary cannot).
     const extras = unauthorizedCaps.filter((c) => !primaryCaps.includes(c));
-    expect(extras.length, driver.describe(
+    expect(extras.length, req('openwop.it.discovery.unauthorized-key-must-not-reveal-capabilities-outside-its-authorization', 
       'capabilities-change-detection.md §"Scoped capability views"',
       'unauthorized view MUST NOT expose capability keys absent from the primary (authorized) view',
     )).toBe(0);

package/src/scenarios/dispatch-cross-worker-handoff.test.ts

@@ -25,6 +25,8 @@ 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';
+import { softSkip } from '../lib/soft-skip.js';
 
 const PARENT = 'conformance-dispatch-cross-worker-handoff';
 const CHILD_A = 'conformance-dispatch-cross-worker-handoff-child-a';
@@ -53,14 +55,14 @@ describe.skipIf(SKIP)('dispatch-cross-worker-handoff: sequential child→parent
     const parentRunId = (create.json as { runId: string }).runId;
 
     const parentTerminal = (await pollUntilTerminal(parentRunId)) as RunSnapshot;
-    expect(parentTerminal.status, driver.describe(
+    expect(parentTerminal.status, req('openwop.it.dispatch-cross-worker-handoff.hvmap-1c-child-a-writes-via-perworkeroutputmappings-child-b-reads-via-perworkeri', 
       'RFCS/0022-dispatch-input-output-mapping.md §D',
       'parent run MUST reach terminal `completed` once both children finish sequentially',
     )).toBe('completed');
 
     // Parent's sharedVar MUST be 'hello' — set by child-a's outputMapping.
     const parentVars = parentTerminal.variables ?? {};
-    expect(parentVars.sharedVar, driver.describe(
+    expect(parentVars.sharedVar, req('openwop.it.dispatch-cross-worker-handoff.hvmap-1c-child-a-writes-via-perworkeroutputmappings-child-b-reads-via-perworkeri', 
       'RFCS/0022-dispatch-input-output-mapping.md §A',
       'parent `sharedVar` MUST be child-a\'s `output` projection ("hello") via perWorkerOutputMappings',
     )).toBe('hello');
@@ -72,7 +74,7 @@ describe.skipIf(SKIP)('dispatch-cross-worker-handoff: sequential child→parent
     const dispatchedB = events.find(
       (e) => e.type === 'node.dispatched' && e.payload?.childWorkflowId === CHILD_B,
     );
-    expect(dispatchedB, driver.describe(
+    expect(dispatchedB, req('openwop.it.dispatch-cross-worker-handoff.hvmap-1c-child-a-writes-via-perworkeroutputmappings-child-b-reads-via-perworkeri', 
       'RFCS/0022-dispatch-input-output-mapping.md §D',
       'parent event log MUST contain a `node.dispatched` event for child-b after child-a completes (sequential fan-out)',
     )).toBeDefined();
@@ -86,7 +88,7 @@ describe.skipIf(SKIP)('dispatch-cross-worker-handoff: sequential child→parent
     const childBSnapshot = childBSnapshotRes.json as RunSnapshot;
     expect(childBSnapshot.status).toBe('completed');
     const childBInputs = childBSnapshot.inputs ?? {};
-    expect(childBInputs.input, driver.describe(
+    expect(childBInputs.input, req('openwop.it.dispatch-cross-worker-handoff.hvmap-1c-child-a-writes-via-perworkeroutputmappings-child-b-reads-via-perworkeri', 
       'RFCS/0022-dispatch-input-output-mapping.md §A + §D',
       'child-b `inputs.input` MUST be parent\'s `sharedVar` ("hello") — written by child-a, read by child-b via shared parent variable bag',
     )).toBe('hello');
@@ -94,7 +96,7 @@ describe.skipIf(SKIP)('dispatch-cross-worker-handoff: sequential child→parent
 
   it('HVMAP-1c-override: per-worker mapping overrides default mapping per §A effectiveInputMapping precedence', async () => {
     const PARENT_OVERRIDE = 'conformance-dispatch-per-worker-override';
-    if (!isFixtureAdvertised(PARENT_OVERRIDE)) return; // fixture not seeded — soft-skip
+    if (!isFixtureAdvertised(PARENT_OVERRIDE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(PARENT_OVERRIDE)` returned early (fixture not seeded — soft-skip)'); // fixture not seeded — soft-skip
     const create = await driver.post('/v1/runs', { workflowId: PARENT_OVERRIDE });
     expect(create.status).toBe(201);
     const parentRunId = (create.json as { runId: string }).runId;
@@ -104,7 +106,7 @@ describe.skipIf(SKIP)('dispatch-cross-worker-handoff: sequential child→parent
     const events = ((eventsRes.json as { events?: RunEvent[] } | undefined)?.events ?? []);
     const dispatchedA = events.find((e) => e.type === 'node.dispatched' && e.payload?.childWorkflowId === CHILD_A);
     const dispatchedB = events.find((e) => e.type === 'node.dispatched' && e.payload?.childWorkflowId === CHILD_B);
-    if (!dispatchedA || !dispatchedB) return;
+    if (!dispatchedA || !dispatchedB) return softSkip('blocked', 'precondition not met — `!dispatchedA || !dispatchedB` returned early (seam, prior step, or fixture unavailable)');
 
     const childARes = await driver.get(`/v1/runs/${encodeURIComponent(dispatchedA.payload!.childRunId!)}`);
     const childBRes = await driver.get(`/v1/runs/${encodeURIComponent(dispatchedB.payload!.childRunId!)}`);
@@ -113,14 +115,14 @@ describe.skipIf(SKIP)('dispatch-cross-worker-handoff: sequential child→parent
 
     expect(
       childAInputs.input,
-      driver.describe(
+      req('openwop.it.dispatch-cross-worker-handoff.hvmap-1c-override-per-worker-mapping-overrides-default-mapping-per-a-effectivein', 
         'RFCS/0022-dispatch-input-output-mapping.md §A',
         'child-a uses the DEFAULT inputMapping; input MUST come from parent.defaultX',
       ),
     ).toBe('default-x-value');
     expect(
       childBInputs.input,
-      driver.describe(
+      req('openwop.it.dispatch-cross-worker-handoff.hvmap-1c-override-per-worker-mapping-overrides-default-mapping-per-a-effectivein', 
         'RFCS/0022-dispatch-input-output-mapping.md §A',
         'child-b uses the per-worker OVERRIDE; input MUST come from parent.sharedVar (NOT defaultX)',
       ),