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

package/src/scenarios/idempotency-concurrent-claim.test.ts

@@ -53,6 +53,7 @@
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
 
 const SEAM = '/v1/host/sample/test/idempotency/concurrent-claim';
 
@@ -64,12 +65,12 @@ type ClaimResult = {
 };
 
 /** Is the §25 seam mounted? 404/403/501 mean not mounted — anything else is a real answer. */
-async function seamPresent(): Promise<ClaimResult | null> {
+async function seamPresent(requirementId: string): Promise<ClaimResult | null> {
   const res = await driver.post(SEAM, { executors: 2 });
   if (res.status === 404 || res.status === 403 || res.status === 501) return null;
   expect(
     res.status,
-    driver.describe(
+    req(requirementId, 
       'host-sample-test-seams.md §25',
       'a mounted concurrent-claim seam MUST answer 200; a non-200 that is not 404/403/501 is a broken seam, not an absent one',
     ),
@@ -79,28 +80,28 @@ async function seamPresent(): Promise<ClaimResult | null> {
 
 describe('idempotency-concurrent-claim: two executors of one run, one effect (RFC 0150 §B, G17)', () => {
   it('every executor mints the SAME logicalInvocationId — without this, one delivery proves nothing', async () => {
-    const out = await seamPresent();
+    const out = await seamPresent('openwop.it.idempotency-concurrent-claim.every-executor-mints-the-same-logicalinvocationid-without-this-one-delivery-prov');
     if (out === null) return softSkip('blocked', `${SEAM} not mounted (host-sample-test-seams.md §25)`);
 
     const minted = out.mintedIds;
     expect(
       Array.isArray(minted),
-      driver.describe('host-sample-test-seams.md §25', 'the seam MUST report mintedIds, one per executor'),
+      req('openwop.it.idempotency-concurrent-claim.every-executor-mints-the-same-logicalinvocationid-without-this-one-delivery-prov', 'host-sample-test-seams.md §25', 'the seam MUST report mintedIds, one per executor'),
     ).toBe(true);
     const ids = minted as unknown[];
     expect(
       ids.length,
-      driver.describe('host-sample-test-seams.md §25', 'mintedIds length MUST equal the executors that reached the chokepoint'),
+      req('openwop.it.idempotency-concurrent-claim.every-executor-mints-the-same-logicalinvocationid-without-this-one-delivery-prov', 'host-sample-test-seams.md §25', 'mintedIds length MUST equal the executors that reached the chokepoint'),
     ).toBe(out.attempted);
     expect(
       ids.length >= 2,
-      driver.describe('host-sample-test-seams.md §25', 'fewer than two executors is not a race and cannot witness the rule'),
+      req('openwop.it.idempotency-concurrent-claim.every-executor-mints-the-same-logicalinvocationid-without-this-one-delivery-prov', 'host-sample-test-seams.md §25', 'fewer than two executors is not a race and cannot witness the rule'),
     ).toBe(true);
 
     const unique = new Set(ids.map((x) => JSON.stringify(x)));
     expect(
       unique.size,
-      driver.describe(
+      req('openwop.it.idempotency-concurrent-claim.every-executor-mints-the-same-logicalinvocationid-without-this-one-delivery-prov', 
         'idempotency.md §"Idempotency key composition" (Across a recovery boundary)',
         'all executors MUST mint one identity — differing ids mean they never collided, so a single delivery is a vacuous pass rather than a working claim',
       ),
@@ -108,16 +109,16 @@ describe('idempotency-concurrent-claim: two executors of one run, one effect (RF
   });
 
   it('exactly one effect escapes, however many executors attempt it', async () => {
-    const out = await seamPresent();
+    const out = await seamPresent('openwop.it.idempotency-concurrent-claim.exactly-one-effect-escapes-however-many-executors-attempt-it');
     if (out === null) return softSkip('blocked', `${SEAM} not mounted (host-sample-test-seams.md §25)`);
 
     expect(
       typeof out.attempted === 'number' && (out.attempted as number) >= 2,
-      driver.describe('host-sample-test-seams.md §25', 'the seam MUST report how many executors attempted the effect'),
+      req('openwop.it.idempotency-concurrent-claim.exactly-one-effect-escapes-however-many-executors-attempt-it', 'host-sample-test-seams.md §25', 'the seam MUST report how many executors attempted the effect'),
     ).toBe(true);
     expect(
       out.delivered,
-      driver.describe(
+      req('openwop.it.idempotency-concurrent-claim.exactly-one-effect-escapes-however-many-executors-attempt-it', 
         'idempotency.md §"Concurrent duplicates (Layer 2)"',
         'the engine MUST ensure at most one concurrent executor performs the external effect — the guarding persist MUST be an atomic claim, not a read-then-write',
       ),
@@ -125,7 +126,7 @@ describe('idempotency-concurrent-claim: two executors of one run, one effect (RF
   });
 
   it('the race is real at higher concurrency too — a claim that only holds at 2 is not a claim', async () => {
-    const probe = await seamPresent();
+    const probe = await seamPresent('openwop.it.idempotency-concurrent-claim.the-race-is-real-at-higher-concurrency-too-a-claim-that-only-holds-at-2-is-not-a');
     if (probe === null) return softSkip('blocked', `${SEAM} not mounted (host-sample-test-seams.md §25)`);
 
     const res = await driver.post(SEAM, { executors: 5 });
@@ -138,7 +139,7 @@ describe('idempotency-concurrent-claim: two executors of one run, one effect (RF
     const out = res.json as ClaimResult;
     expect(
       out.delivered,
-      driver.describe(
+      req('openwop.it.idempotency-concurrent-claim.the-race-is-real-at-higher-concurrency-too-a-claim-that-only-holds-at-2-is-not-a', 
         'idempotency.md §"Concurrent duplicates (Layer 2)"',
         'exactly one effect regardless of how many executors race — at most one wins the compare-and-set, the rest observe the hit',
       ),
@@ -147,7 +148,7 @@ describe('idempotency-concurrent-claim: two executors of one run, one effect (RF
     if (ids.length >= 2) {
       expect(
         new Set(ids.map((x) => JSON.stringify(x))).size,
-        driver.describe('idempotency.md §"Idempotency key composition"', 'one identity across all executors at any concurrency'),
+        req('openwop.it.idempotency-concurrent-claim.the-race-is-real-at-higher-concurrency-too-a-claim-that-only-holds-at-2-is-not-a', 'idempotency.md §"Idempotency key composition"', 'one identity across all executors at any concurrency'),
       ).toBe(1);
     }
   });

package/src/scenarios/idempotency-key-determinism.test.ts

@@ -44,6 +44,8 @@ import { createHash } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PACK_PATH = resolve(__dirname, '../../../packs/core.openwop.http/index.mjs');
@@ -114,14 +116,14 @@ describe('category: core.openwop.http.idempotency-key — determinism contract',
     // — the scenario soft-skips rather than failing.
     if (!packAvailable) {
       console.warn(`[idempotency-key-determinism] packs/core.openwop.http/index.mjs not present; skipping`);
-      expect(packAvailable).toBe(false);
-      return;
+      expect(packAvailable, req('openwop.it.idempotency-key-determinism.skips-cleanly-when-packs-is-not-bundled', 'idempotency.md §"Idempotency-Key', 'skips cleanly when packs/ is not bundled')).toBe(false);
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early ([idempotency-key-determinism] packs/core.openwop.http/index.mjs not present; skipping)');
     }
     expect(packAvailable).toBe(true);
   });
 
   it('default mode (composite) — identical (runId, nodeId, payload) produces identical keys', async () => {
-    if (!packAvailable) return;
+    if (!packAvailable) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early');
     const ctx: IdempotencyKeyCtx = {
       runId: 'run-1',
       nodeId: 'node-1',
@@ -129,45 +131,45 @@ describe('category: core.openwop.http.idempotency-key — determinism contract',
     };
     const a = await idempotencyKey(ctx);
     const b = await idempotencyKey(ctx);
-    expect(a.outputs.key, 'idempotency.md §Idempotency-Key: same logical request MUST produce same key').toBe(b.outputs.key);
+    expect(a.outputs.key, req('openwop.it.idempotency-key-determinism.default-mode-composite-identical-runid-nodeid-payload-produces-identical-keys', 'idempotency.md §"Idempotency-Key', 'idempotency.md §Idempotency-Key: same logical request MUST produce same key')).toBe(b.outputs.key);
     expect(a.outputs.key).toMatch(KEY_PATTERN);
   });
 
   it('payload sensitivity — different payload produces different key', async () => {
-    if (!packAvailable) return;
+    if (!packAvailable) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early');
     const baseCtx = { runId: 'run-1', nodeId: 'node-1' };
     const a = await idempotencyKey({ ...baseCtx, inputs: { payload: { hello: 'world' } } });
     const b = await idempotencyKey({ ...baseCtx, inputs: { payload: { hello: 'CHANGED' } } });
-    expect(a.outputs.key).not.toBe(b.outputs.key);
+    expect(a.outputs.key, req('openwop.it.idempotency-key-determinism.payload-sensitivity-different-payload-produces-different-key', 'idempotency.md §"Idempotency-Key', 'payload sensitivity — different payload produces different key')).not.toBe(b.outputs.key);
   });
 
   it('run isolation — different runId produces different key', async () => {
-    if (!packAvailable) return;
+    if (!packAvailable) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early');
     const payload = { hello: 'world' };
     const a = await idempotencyKey({ runId: 'run-1', nodeId: 'node-1', inputs: { payload } });
     const b = await idempotencyKey({ runId: 'run-2', nodeId: 'node-1', inputs: { payload } });
-    expect(a.outputs.key).not.toBe(b.outputs.key);
+    expect(a.outputs.key, req('openwop.it.idempotency-key-determinism.run-isolation-different-runid-produces-different-key', 'idempotency.md §"Idempotency-Key', 'run isolation — different runId produces different key')).not.toBe(b.outputs.key);
   });
 
   it('node isolation — different nodeId produces different key', async () => {
-    if (!packAvailable) return;
+    if (!packAvailable) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early');
     const payload = { hello: 'world' };
     const a = await idempotencyKey({ runId: 'run-1', nodeId: 'node-A', inputs: { payload } });
     const b = await idempotencyKey({ runId: 'run-1', nodeId: 'node-B', inputs: { payload } });
-    expect(a.outputs.key).not.toBe(b.outputs.key);
+    expect(a.outputs.key, req('openwop.it.idempotency-key-determinism.node-isolation-different-nodeid-produces-different-key', 'idempotency.md §"Idempotency-Key', 'node isolation — different nodeId produces different key')).not.toBe(b.outputs.key);
   });
 
   it('hash mode is deterministic in the payload alone (run/node ignored)', async () => {
-    if (!packAvailable) return;
+    if (!packAvailable) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early');
     const payload = { request: 'payload-here', id: 42 };
     const a = await idempotencyKey({ config: { mode: 'hash' }, runId: 'run-1', nodeId: 'node-1', inputs: { payload } });
     const b = await idempotencyKey({ config: { mode: 'hash' }, runId: 'run-2', nodeId: 'node-2', inputs: { payload } });
-    expect(a.outputs.key, 'hash mode MUST ignore run/node — useful for global remote-dedup caches').toBe(b.outputs.key);
+    expect(a.outputs.key, req('openwop.it.idempotency-key-determinism.hash-mode-is-deterministic-in-the-payload-alone-run-node-ignored', 'idempotency.md §"Idempotency-Key', 'hash mode MUST ignore run/node — useful for global remote-dedup caches')).toBe(b.outputs.key);
     expect(a.outputs.key).toMatch(KEY_PATTERN);
   });
 
   it('output shape — every emitted key matches openwop-<sha256-prefix-16>', async () => {
-    if (!packAvailable) return;
+    if (!packAvailable) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early');
     const samples: IdempotencyKeyCtx[] = [
       { runId: 'r', nodeId: 'n', inputs: { payload: null } },
       { runId: 'r', nodeId: 'n', inputs: { payload: 'string-payload' } },
@@ -177,12 +179,12 @@ describe('category: core.openwop.http.idempotency-key — determinism contract',
     ];
     for (const ctx of samples) {
       const result = await idempotencyKey(ctx);
-      expect(result.outputs.key, `key shape for ctx=${JSON.stringify(ctx)}`).toMatch(KEY_PATTERN);
+      expect(result.outputs.key, req('openwop.it.idempotency-key-determinism.output-shape-every-emitted-key-matches-openwop-sha256-prefix-16', 'idempotency.md §"Idempotency-Key', `key shape for ctx=${JSON.stringify(ctx)}`)).toMatch(KEY_PATTERN);
     }
   });
 
   it('uuid mode rejects with CONFIG_INVALID (safety-fix per 1.1.2)', async () => {
-    if (!packAvailable) return;
+    if (!packAvailable) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early');
     // The removed mode names the safety-fix in its error message so
     // pinned-version callers diagnosing a regression find the fix.
     let caught: unknown;
@@ -191,13 +193,13 @@ describe('category: core.openwop.http.idempotency-key — determinism contract',
     } catch (err) {
       caught = err;
     }
-    expect(caught, 'mode: uuid MUST be rejected — the 1.1.0/1.1.1 non-deterministic default was removed').toBeInstanceOf(Error);
+    expect(caught, req('openwop.it.idempotency-key-determinism.uuid-mode-rejects-with-config-invalid-safety-fix-per-1-1-2', 'idempotency.md §"Idempotency-Key', 'mode: uuid MUST be rejected — the 1.1.0/1.1.1 non-deterministic default was removed')).toBeInstanceOf(Error);
     expect((caught as Error & { code?: string }).code).toBe('CONFIG_INVALID');
     expect((caught as Error).message).toMatch(/uuid.*removed|safety-fix/i);
   });
 
   it('cross-impl invariant — pack output equals canonical SHA-256 formula', async () => {
-    if (!packAvailable) return;
+    if (!packAvailable) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early');
     // Five fixed vectors. A third-party core.openwop.http reimplementation
     // can run the same scenario against its runtime — agreement on these
     // vectors proves wire-level interop on the Idempotency-Key shape.
@@ -217,7 +219,7 @@ describe('category: core.openwop.http.idempotency-key — determinism contract',
       const expected = canonicalCompositeKey(v.runId, v.nodeId, v.payload);
       expect(
         packed.outputs.key,
-        `vector ${JSON.stringify(v)} — pack output MUST match canonical sha256(runId\\0nodeId\\0JSON(payload))`,
+        req('openwop.it.idempotency-key-determinism.cross-impl-invariant-pack-output-equals-canonical-sha-256-formula', 'idempotency.md §"Idempotency-Key', `vector ${JSON.stringify(v)} — pack output MUST match canonical sha256(runId\\0nodeId\\0JSON(payload))`),
       ).toBe(expected);
     }
 

package/src/scenarios/idempotency.test.ts

@@ -18,6 +18,7 @@ import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { readErrorCode } from '../lib/error-envelope.js';
+import { req } from '../lib/requirement-ids.js';
 
 const WORKFLOW_ID = 'conformance-idempotent';
 const SKIP_NO_FIXTURE = !isFixtureAdvertised(WORKFLOW_ID);
@@ -34,7 +35,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('idempotency: same key + same body replays per
     const first = await driver.post('/v1/runs', body, {
       headers: { 'Idempotency-Key': key },
     });
-    expect(first.status, driver.describe(
+    expect(first.status, req('openwop.it.idempotency.returns-same-runid-twice-and-sets-openwop-idempotent-replay-on-the-replay', 
       'rest-endpoints.md',
       'first POST /v1/runs MUST return 201',
     )).toBe(201);
@@ -45,20 +46,20 @@ describe.skipIf(SKIP_NO_FIXTURE)('idempotency: same key + same body replays per
     });
     expect(
       [200, 201].includes(replay.status),
-      driver.describe(
+      req('openwop.it.idempotency.returns-same-runid-twice-and-sets-openwop-idempotent-replay-on-the-replay', 
         'idempotency.md §Layer 1',
         'replay request with same key + same body MUST return success status (200/201)',
       ),
     ).toBe(true);
 
     const replayRunId = (replay.json as { runId: string }).runId;
-    expect(replayRunId, driver.describe(
+    expect(replayRunId, req('openwop.it.idempotency.returns-same-runid-twice-and-sets-openwop-idempotent-replay-on-the-replay', 
       'idempotency.md §Layer 1',
       'replay MUST return the SAME runId (no new run created)',
     )).toBe(firstRunId);
 
     const replayHeader = replay.headers.get('openwop-idempotent-replay');
-    expect(replayHeader, driver.describe(
+    expect(replayHeader, req('openwop.it.idempotency.returns-same-runid-twice-and-sets-openwop-idempotent-replay-on-the-replay', 
       'rest-endpoints.md POST /v1/runs response headers',
       'openwop-Idempotent-Replay header MUST be set on cache-served responses',
     )).toBeTruthy();
@@ -82,7 +83,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('idempotency: same key + different body conflic
       { headers: { 'Idempotency-Key': key } },
     );
 
-    expect(conflict.status, driver.describe(
+    expect(conflict.status, req('openwop.it.idempotency.returns-409-when-the-body-changes-under-the-same-key', 
       'idempotency.md §Layer 1',
       'same Idempotency-Key with a different body MUST return 409',
     )).toBe(409);
@@ -107,7 +108,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('idempotency: same key + different body conflic
     const LEGACY = ['idempotency_key_conflict', 'idempotency_key_replay_mismatch'];
     expect(
       code === 'idempotency_key_mismatch' || LEGACY.includes(code ?? ''),
-      driver.describe(
+      req('openwop.it.idempotency.returns-409-when-the-body-changes-under-the-same-key', 
         'idempotency.md §"Record shape, digest, and lease"',
         `a different request digest under the same scoped key MUST fail with the canonical ` +
           `\`idempotency_key_mismatch\` (legacy \`${LEGACY.join('` / `')}\` tolerated through the ` +
@@ -120,7 +121,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('idempotency: same key + different body conflic
     const conflictRunId = (conflict.json as { runId?: unknown } | undefined)?.runId;
     expect(
       conflictRunId,
-      driver.describe(
+      req('openwop.it.idempotency.returns-409-when-the-body-changes-under-the-same-key', 
         'idempotency.md §"Record shape, digest, and lease"',
         'a digest mismatch MUST NOT return the cached body (no runId on the 409)',
       ),

package/src/scenarios/idempotencyRetry.test.ts

@@ -26,6 +26,8 @@
 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';
+import { softSkip } from '../lib/soft-skip.js';
 
 const WORKFLOW_ID = 'conformance-idempotent';
 const SKIP_NO_FIXTURE = !isFixtureAdvertised(WORKFLOW_ID);
@@ -40,7 +42,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('idempotency-retry: openwop-Idempotent-Replay h
     const body = { workflowId: WORKFLOW_ID, inputs: { nonce: 'replay-test' } };
 
     const first = await driver.post('/v1/runs', body, { headers: { 'Idempotency-Key': key } });
-    expect(first.status, driver.describe(
+    expect(first.status, req('openwop.it.idempotencyRetry.first-request-with-new-key-returns-false-or-absent-should-per-current-spec-repla', 
       'rest-endpoints.md',
       'first POST /v1/runs returns 201',
     )).toBe(201);
@@ -50,7 +52,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('idempotency-retry: openwop-Idempotent-Replay h
     // set to "false". Pre-RFC spec only requires it on the replay.
     // Permissive assertion: if present, MUST be "false" or "true".
     if (firstReplay !== null) {
-      expect(['false', 'true'].includes(firstReplay), driver.describe(
+      expect(['false', 'true'].includes(firstReplay), req('openwop.it.idempotencyRetry.first-request-with-new-key-returns-false-or-absent-should-per-current-spec-repla', 
         'idempotency.md §Server responsibilities',
         'openwop-Idempotent-Replay value MUST be "true" or "false"',
       )).toBe(true);
@@ -59,18 +61,18 @@ describe.skipIf(SKIP_NO_FIXTURE)('idempotency-retry: openwop-Idempotent-Replay h
     const replay = await driver.post('/v1/runs', body, { headers: { 'Idempotency-Key': key } });
     expect(
       [200, 201].includes(replay.status),
-      driver.describe('idempotency.md §Layer 1', 'replay returns 200 or 201'),
+      req('openwop.it.idempotencyRetry.first-request-with-new-key-returns-false-or-absent-should-per-current-spec-repla', 'idempotency.md §Layer 1', 'replay returns 200 or 201'),
     ).toBe(true);
 
     const replayHeader = replay.headers.get('openwop-idempotent-replay');
     // Per idempotency.md §Server responsibilities #2: SHOULD be set.
     // RFC 0002 §1 promotes to MUST. Today's strictness: present on replay.
-    expect(replayHeader, driver.describe(
+    expect(replayHeader, req('openwop.it.idempotencyRetry.first-request-with-new-key-returns-false-or-absent-should-per-current-spec-repla', 
       'idempotency.md §Server responsibilities #2',
       'openwop-Idempotent-Replay SHOULD be set on idempotent replay responses',
     )).not.toBeNull();
     if (replayHeader !== null) {
-      expect(replayHeader, driver.describe(
+      expect(replayHeader, req('openwop.it.idempotencyRetry.first-request-with-new-key-returns-false-or-absent-should-per-current-spec-repla', 
         'idempotency.md §Server responsibilities #2',
         'openwop-Idempotent-Replay on replay MUST be "true"',
       )).toBe('true');
@@ -93,7 +95,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('idempotency-retry: 5-retry budget per scale-pr
     for (const res of responses) {
       expect(
         [200, 201].includes(res.status),
-        driver.describe(
+        req('openwop.it.idempotencyRetry.5-retries-100ms-apart-with-same-key-all-return-the-same-runid', 
           'scale-profiles.md §Retry semantics',
           'host MUST handle ≥5 retries 100ms apart without losing the cached response',
         ),
@@ -101,7 +103,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('idempotency-retry: 5-retry budget per scale-pr
     }
 
     const runIds = new Set(responses.map((r) => (r.json as { runId?: string })?.runId));
-    expect(runIds.size, driver.describe(
+    expect(runIds.size, req('openwop.it.idempotencyRetry.5-retries-100ms-apart-with-same-key-all-return-the-same-runid', 
       'idempotency.md §Layer 1',
       '5 retries with same key MUST collapse to exactly one runId',
     )).toBe(1);
@@ -114,18 +116,18 @@ describe('idempotency-retry: limits.idempotencyAckTimeoutSec contract per idempo
     expect(res.status).toBe(200);
 
     const limits = (res.json as { limits?: Record<string, unknown> })?.limits;
-    if (!limits) return; // limits required per capabilities.md §3 — covered elsewhere
+    if (!limits) return softSkip('blocked', 'precondition not met — `!limits` returned early (limits required per capabilities.md §3 — covered elsewhere) (seam, prior step, or fixture unavailable)'); // limits required per capabilities.md §3 — covered elsewhere
     const ack = limits.idempotencyAckTimeoutSec;
     if (ack === undefined) {
       // Per idempotency.md, the field is optional; absence implies the
       // 5-second floor. Nothing to assert.
-      return;
+      return softSkip('blocked', 'precondition not met — `ack === undefined` returned early (Per idempotency.md, the field is optional; absence implies the 5-second floor. Nothing to assert.) (seam, prior step, or fixture unavailable)');
     }
-    expect(typeof ack === 'number' && Number.isInteger(ack), driver.describe(
+    expect(typeof ack === 'number' && Number.isInteger(ack), req('openwop.it.idempotencyRetry.host-advertising-idempotencyacktimeoutsec-sets-integer-5', 
       'idempotency.md',
       'limits.idempotencyAckTimeoutSec MUST be an integer when advertised',
     )).toBe(true);
-    expect(ack as number, driver.describe(
+    expect(ack as number, req('openwop.it.idempotencyRetry.host-advertising-idempotencyacktimeoutsec-sets-integer-5', 
       'idempotency.md',
       'limits.idempotencyAckTimeoutSec MUST be ≥ 5',
     )).toBeGreaterThanOrEqual(5);

package/src/scenarios/identity-owner-shape.test.ts

@@ -22,6 +22,7 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import Ajv2020 from 'ajv/dist/2020.js';
 import { SCHEMAS_DIR } from '../lib/paths.js';
+import { req } from '../lib/requirement-ids.js';
 
 interface SnapshotSchema {
   $schema: string;
@@ -37,7 +38,7 @@ describe('category: identity owner-triple shape (RFC 0048 §C)', () => {
   it('run-snapshot.schema.json defines an optional owner triple', () => {
     expect(
       snapshot.properties.owner,
-      'RFC 0048 §C: RunSnapshot MUST define an optional `owner` object',
+      req('openwop.it.identity-owner-shape.run-snapshot-schema-json-defines-an-optional-owner-triple', 'RFC 0048 §C', 'RFC 0048 §C: RunSnapshot MUST define an optional `owner` object'),
     ).toBeDefined();
   });
 
@@ -48,21 +49,21 @@ describe('category: identity owner-triple shape (RFC 0048 §C)', () => {
   const validate = ajv.compile(ownerSchema);
 
   it('positive: tenant-only owner validates', () => {
-    expect(validate({ tenant: 'acme' }), JSON.stringify(validate.errors)).toBe(true);
+    expect(validate({ tenant: 'acme' }), req('openwop.it.identity-owner-shape.positive-tenant-only-owner-validates', 'RFC 0048 §C', JSON.stringify(validate.errors))).toBe(true);
   });
 
   it('positive: full triple validates', () => {
     expect(
       validate({ tenant: 'acme', workspace: 'ws-eng', principal: 'user_42' }),
-      JSON.stringify(validate.errors),
+      req('openwop.it.identity-owner-shape.positive-full-triple-validates', 'RFC 0048 §C', JSON.stringify(validate.errors)),
     ).toBe(true);
   });
 
   it('negative: owner missing tenant is rejected (tenant is required)', () => {
-    expect(validate({ workspace: 'ws-eng' })).toBe(false);
+    expect(validate({ workspace: 'ws-eng' }), req('openwop.it.identity-owner-shape.negative-owner-missing-tenant-is-rejected-tenant-is-required', 'RFC 0048 §C', 'negative: owner missing tenant is rejected (tenant is required)')).toBe(false);
   });
 
   it('negative: unknown owner property is rejected (additionalProperties:false)', () => {
-    expect(validate({ tenant: 'acme', role: 'admin' })).toBe(false);
+    expect(validate({ tenant: 'acme', role: 'admin' }), req('openwop.it.identity-owner-shape.negative-unknown-owner-property-is-rejected-additionalproperties-false', 'RFC 0048 §C', 'negative: unknown owner property is rejected (additionalProperties:false)')).toBe(false);
   });
 });

package/src/scenarios/identity-passthrough.test.ts

@@ -13,6 +13,7 @@ import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { req } from '../lib/requirement-ids.js';
 
 const WORKFLOW_ID = 'conformance-identity';
 const SKIP_NO_FIXTURE = !isFixtureAdvertised(WORKFLOW_ID);
@@ -33,7 +34,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('identity: conformance-identity fixture echoes
       workflowId: WORKFLOW_ID,
       inputs: { payload },
     });
-    expect(create.status, driver.describe(
+    expect(create.status, req('openwop.it.identity-passthrough.arbitrary-nested-json-payload-round-trips-through-inputs-variables', 
       'rest-endpoints.md',
       'POST /v1/runs MUST return 201',
     )).toBe(201);
@@ -41,12 +42,12 @@ describe.skipIf(SKIP_NO_FIXTURE)('identity: conformance-identity fixture echoes
 
     const terminal = await pollUntilTerminal(runId);
 
-    expect(terminal.status, driver.describe(
+    expect(terminal.status, req('openwop.it.identity-passthrough.arbitrary-nested-json-payload-round-trips-through-inputs-variables', 
       'fixtures.md conformance-identity',
       'identity fixture MUST reach terminal `completed`',
     )).toBe('completed');
 
-    expect(terminal.variables?.payload, driver.describe(
+    expect(terminal.variables?.payload, req('openwop.it.identity-passthrough.arbitrary-nested-json-payload-round-trips-through-inputs-variables', 
       'fixtures.md conformance-identity §Expected behavior',
       'RunSnapshot.variables.payload MUST deep-equal the input payload',
     )).toEqual(payload);

package/src/scenarios/interrupt-approval.test.ts

@@ -11,6 +11,7 @@ import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { pollUntilStatus, pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { req } from '../lib/requirement-ids.js';
 
 const WORKFLOW_ID = 'conformance-approval';
 const NODE_ID = 'gate';
@@ -23,7 +24,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('interrupt: approval accept resumes to `complet
     const runId = (create.json as { runId: string }).runId;
 
     const suspended = await pollUntilStatus(runId, 'waiting-approval', { timeoutMs: 10_000 });
-    expect(suspended.currentNodeId, driver.describe(
+    expect(suspended.currentNodeId, req('openwop.it.interrupt-approval.run-suspends-at-gate-accept-resolution-drives-terminal-completed', 
       'fixtures.md conformance-approval',
       'suspended run MUST report currentNodeId === "gate"',
     )).toBe(NODE_ID);
@@ -32,13 +33,13 @@ describe.skipIf(SKIP_NO_FIXTURE)('interrupt: approval accept resumes to `complet
       `/v1/runs/${encodeURIComponent(runId)}/interrupts/${encodeURIComponent(NODE_ID)}`,
       { resumeValue: { action: 'accept' } },
     );
-    expect(resolve.status, driver.describe(
+    expect(resolve.status, req('openwop.it.interrupt-approval.run-suspends-at-gate-accept-resolution-drives-terminal-completed', 
       'rest-endpoints.md POST /v1/runs/{runId}/interrupts/{nodeId}',
       'valid approval resolve MUST return 200',
     )).toBe(200);
 
     const terminal = await pollUntilTerminal(runId, { timeoutMs: 10_000 });
-    expect(terminal.status, driver.describe(
+    expect(terminal.status, req('openwop.it.interrupt-approval.run-suspends-at-gate-accept-resolution-drives-terminal-completed', 
       'fixtures.md conformance-approval §Terminal status',
       'fixture after accept MUST reach terminal `completed`',
     )).toBe('completed');
@@ -59,7 +60,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('interrupt: invalid resolve payload rejected pe
     );
     expect(
       [400, 422].includes(resolve.status),
-      driver.describe(
+      req('openwop.it.interrupt-approval.400-or-422-when-action-is-not-in-accept-reject', 
         'interrupt.md + resumeSchema validation',
         'resolve payload that violates resumeSchema MUST return 400 or 422',
       ),
@@ -85,7 +86,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('interrupt: resolving an unknown interrupt retu
       `/v1/runs/${encodeURIComponent(runId)}/interrupts/no-such-node`,
       { resumeValue: { action: 'accept' } },
     );
-    expect(resolve.status, driver.describe(
+    expect(resolve.status, req('openwop.it.interrupt-approval.400-404-when-nodeid-does-not-match-an-active-interrupt', 
       'rest-endpoints.md POST /v1/runs/{runId}/interrupts/{nodeId}',
       'resolving an unknown nodeId MUST return 404',
     )).toBe(404);

package/src/scenarios/interrupt-approver-routing.test.ts

@@ -35,8 +35,8 @@ import addFormats from 'ajv-formats';
 import { SCHEMAS_DIR } from '../lib/paths.js';
 import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
-
-const why = (specRef: string, requirement: string): string => `${specRef} — ${requirement}`;
+import { softSkip } from '../lib/soft-skip.js';
+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>;
 }
@@ -81,12 +81,12 @@ describe('interrupt-approver-routing: capability advertisement shape (capabiliti
   const interrupt = (caps.properties as Record<string, { properties?: Record<string, { required?: string[]; properties?: Record<string, unknown> }> }>).interrupt;
 
   it('capabilities schema declares interrupt.approverRouting', () => {
-    expect(interrupt, why('capabilities.schema.json §interrupt', 'the interrupt block MUST be declared')).toBeDefined();
+    expect(interrupt, req('openwop.it.interrupt-approver-routing.capabilities-schema-declares-interrupt-approverrouting', 'capabilities.schema.json §interrupt', 'the interrupt block MUST be declared')).toBeDefined();
     const ar = interrupt?.properties?.approverRouting;
-    expect(ar, why('RFC 0104', 'interrupt.approverRouting MUST be declared')).toBeDefined();
-    expect(ar?.required, why('RFC 0104', 'approverRouting.supported MUST be required')).toEqual(expect.arrayContaining(['supported']));
+    expect(ar, req('openwop.it.interrupt-approver-routing.capabilities-schema-declares-interrupt-approverrouting', 'RFC 0104', 'interrupt.approverRouting MUST be declared')).toBeDefined();
+    expect(ar?.required, req('openwop.it.interrupt-approver-routing.capabilities-schema-declares-interrupt-approverrouting', 'RFC 0104', 'approverRouting.supported MUST be required')).toEqual(expect.arrayContaining(['supported']));
     for (const f of ['supported', 'refKinds', 'audience']) {
-      expect(ar?.properties?.[f], why('RFC 0104', `approverRouting.${f} MUST be declared`)).toBeDefined();
+      expect(ar?.properties?.[f], req('openwop.it.interrupt-approver-routing.capabilities-schema-declares-interrupt-approverrouting', 'RFC 0104', `approverRouting.${f} MUST be declared`)).toBeDefined();
     }
   });
 });
@@ -104,7 +104,7 @@ describe('interrupt-approver-routing: ApprovalData additive optionality (interru
   };
 
   it('an approval payload WITHOUT the routing fields still validates (additive, optional)', () => {
-    expect(validate(baseApproval), why('RFC 0104 Compatibility', `the fields are optional — Errors: ${JSON.stringify(validate.errors)}`)).toBe(true);
+    expect(validate(baseApproval), req('openwop.it.interrupt-approver-routing.an-approval-payload-without-the-routing-fields-still-validates-additive-optional', 'RFC 0104 Compatibility', `the fields are optional — Errors: ${JSON.stringify(validate.errors)}`)).toBe(true);
   });
   it('an approval payload WITH group/role refs + audience validates', () => {
     const withRouting = {
@@ -116,11 +116,11 @@ describe('interrupt-approver-routing: ApprovalData additive optionality (interru
         audience: { groups: ['grp:finance-approvers'], roles: ['role:controller'], subjects: ['user:cfo'] },
       },
     };
-    expect(validate(withRouting), why('RFC 0104 §Proposal', `routing fields MUST validate — Errors: ${JSON.stringify(validate.errors)}`)).toBe(true);
+    expect(validate(withRouting), req('openwop.it.interrupt-approver-routing.an-approval-payload-with-group-role-refs-audience-validates', 'RFC 0104 §Proposal', `routing fields MUST validate — Errors: ${JSON.stringify(validate.errors)}`)).toBe(true);
   });
   it('an audience with an unknown key is rejected (audience object is closed)', () => {
     const badAudience = { ...baseApproval, data: { ...baseApproval.data, audience: { teams: ['grp:x'] } } };
-    expect(validate(badAudience), why('RFC 0104', 'audience MUST be additionalProperties:false')).toBe(false);
+    expect(validate(badAudience), req('openwop.it.interrupt-approver-routing.an-audience-with-an-unknown-key-is-rejected-audience-object-is-closed', 'RFC 0104', 'audience MUST be additionalProperties:false')).toBe(false);
   });
 });
 
@@ -128,17 +128,17 @@ describe('interrupt-approver-routing: audience default/override rule (interrupt.
   it('omitted audience ⇒ notify the resolved eligibility union', () => {
     expect(
       notifyTargets({ approversList: ['user:a'], approverGroupRefs: ['grp:fin'], approverRoleRefs: ['role:ctrl'] }),
-      why('RFC 0104', 'omitted audience MUST default to the eligibility union'),
+      req('openwop.it.interrupt-approver-routing.omitted-audience-notify-the-resolved-eligibility-union', 'RFC 0104', 'omitted audience MUST default to the eligibility union'),
     ).toEqual(['user:a', 'grp:fin', 'role:ctrl']);
   });
   it('present audience ⇒ overrides the eligibility union', () => {
     expect(
       notifyTargets({ approverGroupRefs: ['grp:fin'], audience: { subjects: ['user:cfo'], groups: ['grp:audit'] } }),
-      why('RFC 0104', 'present audience MUST override the default'),
+      req('openwop.it.interrupt-approver-routing.present-audience-overrides-the-eligibility-union', 'RFC 0104', 'present audience MUST override the default'),
     ).toEqual(['user:cfo', 'grp:audit']);
   });
   it('no eligibility refs and no audience ⇒ empty target set', () => {
-    expect(notifyTargets({}), why('RFC 0104', 'nothing to route when no refs')).toEqual([]);
+    expect(notifyTargets({}), req('openwop.it.interrupt-approver-routing.no-eligibility-refs-and-no-audience-empty-target-set', 'RFC 0104', 'nothing to route when no refs')).toEqual([]);
   });
 });
 
@@ -148,7 +148,7 @@ describe('interrupt-approver-routing: audience default/override rule (interrupt.
 
 describe('interrupt-approver-routing: advertised shape is honest (capability-gated)', () => {
   it('an advertising host advertises a coherent approverRouting block', async () => {
-    if (!process.env.OPENWOP_BASE_URL) return; // no live host → nothing to read
+    if (!process.env.OPENWOP_BASE_URL) return softSkip('blocked', 'precondition not met — `!process.env.OPENWOP_BASE_URL` returned early (no live host → nothing to read) (seam, prior step, or fixture unavailable)'); // no live host → nothing to read
     const interrupt = await readCapabilityFamily<InterruptCap>('interrupt');
     const ar = interrupt?.approverRouting;
     // Soft-skip: host does not advertise the capability (fields ignored; still conformant).
@@ -157,10 +157,10 @@ describe('interrupt-approver-routing: advertised shape is honest (capability-gat
     // Opt-in established (supported === true): the advertised shape MUST be honest.
     const allowed = new Set(['group', 'role']);
     for (const k of ar?.refKinds ?? []) {
-      expect(allowed.has(k), why('RFC 0104 capabilities.md', `refKinds MUST be a subset of {group, role} — saw ${k}`)).toBe(true);
+      expect(allowed.has(k), req('openwop.it.interrupt-approver-routing.an-advertising-host-advertises-a-coherent-approverrouting-block', 'RFC 0104 capabilities.md', `refKinds MUST be a subset of {group, role} — saw ${k}`)).toBe(true);
     }
     if (ar?.audience !== undefined) {
-      expect(typeof ar.audience, why('RFC 0104 capabilities.md', 'approverRouting.audience MUST be boolean')).toBe('boolean');
+      expect(typeof ar.audience, req('openwop.it.interrupt-approver-routing.an-advertising-host-advertises-a-coherent-approverrouting-block', 'RFC 0104 capabilities.md', 'approverRouting.audience MUST be boolean')).toBe('boolean');
     }
   });
 });