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

package/src/scenarios/replay-llm-cache-key-portable.test.ts

@@ -60,6 +60,8 @@ import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { semanticRequestDigestV2, callCacheKeySeam as callSeam } from '../lib/llm-cache-key-recipe.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const HTTP_SKIP = !process.env.OPENWOP_BASE_URL;
 
@@ -99,12 +101,12 @@ describe.skipIf(HTTP_SKIP)('replay-llm-cache-key-portable: intra-host reproducib
     const result = await callSeam(input);
     if (result.status === 404) {
       ctx.skip(); // host doesn't expose the test seam
-      return;
+      return softSkip('blocked', 'precondition not met — `result.status === 404` returned early (seam, prior step, or fixture unavailable)');
     }
     expect(result.status).toBe(200);
     expect(
       result.cacheKey,
-      driver.describe(
+      req('openwop.it.replay-llm-cache-key-portable.host-cache-key-must-equal-locally-recomputed-sha-256-over-canonical-json-reprodu', 
         'SECURITY/invariants.yaml §replay-llm-cache-key-portable + replay.md §B',
         'host cache key MUST be reproducible offline from the recipe alone — no host-internal state',
       ),
@@ -121,12 +123,12 @@ describe.skipIf(HTTP_SKIP)('replay-llm-cache-key-portable: intra-host reproducib
     const a = await callSeam(input);
     if (a.status === 404) {
       ctx.skip(); // host doesn't expose the test seam
-      return;
+      return softSkip('blocked', 'precondition not met — `a.status === 404` returned early (seam, prior step, or fixture unavailable)');
     }
     const b = await callSeam(input);
     expect(
       a.cacheKey,
-      driver.describe(
+      req('openwop.it.replay-llm-cache-key-portable.two-identical-probes-must-yield-byte-identical-keys-intra-host-determinism', 
         'SECURITY/invariants.yaml §replay-llm-cache-key-portable',
         'two byte-identical recipe inputs MUST yield byte-identical keys (no per-request entropy)',
       ),
@@ -145,7 +147,7 @@ describe.skipIf(HTTP_SKIP)('replay-llm-cache-key-portable: non-recipe-field inva
     const baseResult = await callSeam(base);
     if (baseResult.status === 404) {
       ctx.skip(); // host doesn't expose the test seam
-      return;
+      return softSkip('blocked', 'precondition not met — `baseResult.status === 404` returned early (seam, prior step, or fixture unavailable)');
     }
 
     // The security boundary: ANY of these fields leaking into the key
@@ -163,7 +165,7 @@ describe.skipIf(HTTP_SKIP)('replay-llm-cache-key-portable: non-recipe-field inva
     const pollutedResult = await callSeam(polluted);
     expect(
       pollutedResult.cacheKey,
-      driver.describe(
+      req('openwop.it.replay-llm-cache-key-portable.transport-only-fields-request-id-trace-context-tenant-id-must-not-influence-the', 
         'SECURITY/invariants.yaml §replay-llm-cache-key-portable + replay.md §A',
         'transport-only fields (request id, trace context, tenant id, run id, timeout) MUST NOT influence the cache key — leaking them defeats the portability invariant',
       ),
@@ -178,13 +180,13 @@ describe.skipIf(HTTP_SKIP)('replay-llm-cache-key-portable: Phase 4 advertisement
     const version = em?.version;
     if (typeof version !== 'number' || version < 4) {
       ctx.skip(); // pre-Phase-4 or no multiAgent advertisement
-      return;
+      return softSkip('blocked', 'precondition not met — `typeof version !== \'number\' || version < 4` returned early (seam, prior step, or fixture unavailable)');
     }
 
     const recipe = em?.replayDeterminism?.llmCacheKeyRecipe;
     expect(
       typeof recipe === 'string',
-      driver.describe(
+      req('openwop.it.replay-llm-cache-key-portable.hosts-advertising-version-4-must-advertise-replaydeterminism-llmcachekeyrecipe', 
         'RFCS/0041-multi-agent-replay-under-nondeterminism.md §D',
         'Phase 4 host MUST advertise replayDeterminism.llmCacheKeyRecipe (`spec-rfc-0041` or `x-host-<host>-<recipe>`)',
       ),
@@ -195,7 +197,7 @@ describe.skipIf(HTTP_SKIP)('replay-llm-cache-key-portable: Phase 4 advertisement
     const vendor = /^x-host-[a-z][a-z0-9-]*-[a-z][a-z0-9-]*$/.test(r);
     expect(
       canonical || vendor,
-      driver.describe(
+      req('openwop.it.replay-llm-cache-key-portable.hosts-advertising-version-4-must-advertise-replaydeterminism-llmcachekeyrecipe', 
         'schemas/capabilities.schema.json §replayDeterminism.llmCacheKeyRecipe',
         'llmCacheKeyRecipe MUST be `spec-rfc-0041` OR match `^x-host-<host>-<recipe>$` per host-extensions.md',
       ),

package/src/scenarios/replay-llm-cache-key.test.ts

@@ -28,8 +28,9 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { driver } from '../lib/driver.js';
 import { semanticRequestDigestV2, callCacheKeySeam as callSeam } from '../lib/llm-cache-key-recipe.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 describe('replay-llm-cache-key: SHA-256-over-JCS recipe, v2 (replay.md §B, RFC 0150 §C)', () => {
   it('host cache key MUST equal the locally-recomputed v2 semantic-request digest', async () => {
@@ -43,11 +44,11 @@ describe('replay-llm-cache-key: SHA-256-over-JCS recipe, v2 (replay.md §B, RFC
       temperature: 0.7,
     };
     const result = await callSeam(input);
-    if (result.status === 404) return; // seam not exposed
+    if (result.status === 404) return softSkip('blocked', 'precondition not met — `result.status === 404` returned early (seam not exposed) (seam, prior step, or fixture unavailable)'); // seam not exposed
     expect(result.status).toBe(200);
     expect(
       result.cacheKey,
-      driver.describe(
+      req('openwop.it.replay-llm-cache-key.host-cache-key-must-equal-the-locally-recomputed-v2-semantic-request-digest', 
         'replay.md §B (RFC 0150 §C)',
         'host cache key MUST be lowercase-hex SHA-256 of the JCS-canonical v2 semantic request ' +
           '(stamped `recipe: "openwop-semantic-request-v2"`); a v1 key here is a host that has ' +
@@ -62,8 +63,8 @@ describe('replay-llm-cache-key: SHA-256-over-JCS recipe, v2 (replay.md §B, RFC
       model: 'gpt-4',
       messages: [{ role: 'user', content: 'hi' }],
     });
-    if (result.status === 404) return;
-    expect(result.cacheKey).toMatch(/^[0-9a-f]{64}$/);
+    if (result.status === 404) return softSkip('blocked', 'precondition not met — `result.status === 404` returned early (seam, prior step, or fixture unavailable)');
+    expect(result.cacheKey, req('openwop.it.replay-llm-cache-key.cache-key-must-be-64-lowercase-hex-characters-sha-256-output-shape', 'replay.md §"LLM cache-key recipe', 'cache key MUST be 64 lowercase-hex characters (SHA-256 output shape)')).toMatch(/^[0-9a-f]{64}$/);
   });
 });
 
@@ -76,7 +77,7 @@ describe('replay-llm-cache-key: transport-only fields are EXCLUDED (replay.md §
       temperature: 0.5,
     };
     const baseResult = await callSeam(base);
-    if (baseResult.status === 404) return;
+    if (baseResult.status === 404) return softSkip('blocked', 'precondition not met — `baseResult.status === 404` returned early (seam, prior step, or fixture unavailable)');
 
     // Transport / bookkeeping only. None of these can change what the model
     // returns, so none may change the key. (`max_tokens`, `stop`, and `seed`
@@ -95,7 +96,7 @@ describe('replay-llm-cache-key: transport-only fields are EXCLUDED (replay.md §
     const noisyResult = await callSeam(noisy);
     expect(
       noisyResult.cacheKey,
-      driver.describe(
+      req('openwop.it.replay-llm-cache-key.stream-metadata-user-request-ids-trace-context-must-not-influence-the-cache-key', 
         'replay.md §A (v2)',
         'cache key MUST be invariant under transport-only fields (stream, metadata, user, request ids, trace context, tenant, timeout)',
       ),
@@ -111,11 +112,11 @@ describe('replay-llm-cache-key: transport-only fields are EXCLUDED (replay.md §
     };
     const hotInput = { ...baseInput, temperature: 1.0 };
     const baseResult = await callSeam(baseInput);
-    if (baseResult.status === 404) return;
+    if (baseResult.status === 404) return softSkip('blocked', 'precondition not met — `baseResult.status === 404` returned early (seam, prior step, or fixture unavailable)');
     const hotResult = await callSeam(hotInput);
     expect(
       baseResult.cacheKey === hotResult.cacheKey,
-      driver.describe('replay.md §A', 'changing a recipe field MUST yield a different cache key (no false collisions)'),
+      req('openwop.it.replay-llm-cache-key.changing-a-recipe-field-temperature-must-yield-a-different-cache-key', 'replay.md §A', 'changing a recipe field MUST yield a different cache key (no false collisions)'),
     ).toBe(false);
   });
 });
@@ -139,11 +140,11 @@ describe('replay-llm-cache-key: outcome-affecting fields are INCLUDED (RFC 0150
     ['maxOutputTokens', { maxOutputTokens: 100 }, { maxOutputTokens: 1000 }],
   ])('%s DOES change the cache key', async (_field, a, b) => {
     const ra = await callSeam({ ...base, ...a });
-    if (ra.status === 404) return;
+    if (ra.status === 404) return softSkip('blocked', 'precondition not met — `ra.status === 404` returned early (seam, prior step, or fixture unavailable)');
     const rb = await callSeam({ ...base, ...b });
     expect(
       ra.cacheKey === rb.cacheKey,
-      driver.describe(
+      req('openwop.it.replay-llm-cache-key.s-does-change-the-cache-key', 
         'replay.md §A (RFC 0150 §C)',
         `\`${_field}\` decides the completion, so two requests differing only in it MUST NOT share a cache key — ` +
           'sharing one returns a response the caller never asked for, deterministically',
@@ -151,10 +152,10 @@ describe('replay-llm-cache-key: outcome-affecting fields are INCLUDED (RFC 0150
     ).toBe(false);
     // And each side MUST equal the locally-recomputed v2 digest, so a host cannot
     // pass this leg by salting the key with something arbitrary.
-    expect(ra.cacheKey, driver.describe('replay.md §B (v2)', 'key MUST equal the v2 digest')).toBe(
+    expect(ra.cacheKey, req('openwop.it.replay-llm-cache-key.s-does-change-the-cache-key', 'replay.md §B (v2)', 'key MUST equal the v2 digest')).toBe(
       semanticRequestDigestV2({ ...base, ...a }),
     );
-    expect(rb.cacheKey, driver.describe('replay.md §B (v2)', 'key MUST equal the v2 digest')).toBe(
+    expect(rb.cacheKey, req('openwop.it.replay-llm-cache-key.s-does-change-the-cache-key', 'replay.md §B (v2)', 'key MUST equal the v2 digest')).toBe(
       semanticRequestDigestV2({ ...base, ...b }),
     );
   });
@@ -163,17 +164,17 @@ describe('replay-llm-cache-key: outcome-affecting fields are INCLUDED (RFC 0150
     const withOpts = { ...base, providerOptions: { 'vendor.openai.logitBias': { '50256': -100 } } };
     const withOtherOpts = { ...base, providerOptions: { 'vendor.openai.logitBias': { '50256': 100 } } };
     const r1 = await callSeam(withOpts);
-    if (r1.status === 404) return;
+    if (r1.status === 404) return softSkip('blocked', 'precondition not met — `r1.status === 404` returned early (seam, prior step, or fixture unavailable)');
     const r2 = await callSeam(withOtherOpts);
     expect(
       r1.cacheKey === r2.cacheKey,
-      driver.describe(
+      req('openwop.it.replay-llm-cache-key.provideroptions-are-carried-into-the-key-not-dropped', 
         'replay.md §B step 1 (RFC 0150 §C)',
         'an unknown provider option MUST be carried into `providerOptions` before hashing — a dropped option ' +
           'that alters output is indistinguishable from one that was never set',
       ),
     ).toBe(false);
-    expect(r1.cacheKey, driver.describe('replay.md §B (v2)', 'key MUST equal the v2 digest')).toBe(
+    expect(r1.cacheKey, req('openwop.it.replay-llm-cache-key.provideroptions-are-carried-into-the-key-not-dropped', 'replay.md §B (v2)', 'key MUST equal the v2 digest')).toBe(
       semanticRequestDigestV2(withOpts),
     );
   });
@@ -182,7 +183,7 @@ describe('replay-llm-cache-key: outcome-affecting fields are INCLUDED (RFC 0150
 describe('replay-llm-cache-key: cross-host parity (replay.md §D)', () => {
   it('two hosts compute the same cache key for the same input (when OPENWOP_BASE_URL_B is configured)', async () => {
     const otherBaseUrl = process.env['OPENWOP_BASE_URL_B'];
-    if (!otherBaseUrl) return; // operator-supplied second host not configured
+    if (!otherBaseUrl) return softSkip('blocked', 'precondition not met — `!otherBaseUrl` returned early (operator-supplied second host not configured) (seam, prior step, or fixture unavailable)'); // operator-supplied second host not configured
     const input = {
       provider: 'openai',
       model: 'gpt-4',
@@ -191,19 +192,19 @@ describe('replay-llm-cache-key: cross-host parity (replay.md §D)', () => {
       seed: 7,
     };
     const resA = await callSeam(input);
-    if (resA.status === 404) return;
+    if (resA.status === 404) return softSkip('blocked', 'precondition not met — `resA.status === 404` returned early (seam, prior step, or fixture unavailable)');
     const resB = await fetch(`${otherBaseUrl.replace(/\/$/, '')}/v1/host/sample/test/llm-cache-key`, {
       method: 'POST',
       headers: { 'content-type': 'application/json' },
       body: JSON.stringify(input),
     });
-    if (resB.status === 404) return;
+    if (resB.status === 404) return softSkip('blocked', 'precondition not met — `resB.status === 404` returned early (seam, prior step, or fixture unavailable)');
     const jsonB = (await resB.json()) as { cacheKey?: string };
     expect(
       jsonB.cacheKey,
-      driver.describe('replay.md §D', 'two compliant hosts MUST compute byte-identical cache keys for the same recipe input'),
+      req('openwop.it.replay-llm-cache-key.two-hosts-compute-the-same-cache-key-for-the-same-input-when-openwop-base-url-b', 'replay.md §D', 'two compliant hosts MUST compute byte-identical cache keys for the same recipe input'),
     ).toBe(resA.cacheKey);
-    expect(resA.cacheKey, driver.describe('replay.md §B (v2)', 'and both MUST equal the v2 digest')).toBe(
+    expect(resA.cacheKey, req('openwop.it.replay-llm-cache-key.two-hosts-compute-the-same-cache-key-for-the-same-input-when-openwop-base-url-b', 'replay.md §B (v2)', 'and both MUST equal the v2 digest')).toBe(
       semanticRequestDigestV2(input),
     );
   });

package/src/scenarios/replay-observable-sequence-determinism.test.ts

@@ -44,6 +44,7 @@ import { describe, it, expect } from 'vitest';
 import { softSkip, seamAbsent } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const HTTP_SKIP = !process.env.OPENWOP_BASE_URL;
 const FIXTURE = 'conformance-phase4-nondet-tool';
@@ -186,7 +187,7 @@ describe.skipIf(HTTP_SKIP)(
       const replayNorm = replayEvents.map(stripVolatile);
       expect(
         replayNorm,
-        driver.describe(
+        req('openwop.it.replay-observable-sequence-determinism.original-and-replay-event-log-prefixes-must-be-byte-equivalent-modulo-per-event', 
           'RFCS/0041-multi-agent-replay-under-nondeterminism.md §C',
           'a mode:replay fork MUST reproduce the original observable event-log sequence byte-for-byte modulo volatile per-event fields (eventId/ULID entropy, per-region observedAt clock)',
         ),
@@ -211,7 +212,7 @@ describe.skipIf(HTTP_SKIP)(
       const sourceNodeEvents = sourceEvents.filter((e) => e.nodeId === NONDET_NODE_ID).map(stripVolatile);
       expect(
         sourceNodeEvents.length,
-        driver.describe(
+        req('openwop.it.replay-observable-sequence-determinism.replay-of-a-nondeterministic-tool-node-reproduces-the-original-observable-result', 
           'RFCS/0041-multi-agent-replay-under-nondeterminism.md §C',
           `the fixture's nondeterministic node \`${NONDET_NODE_ID}\` MUST emit at least one observable event`,
         ),
@@ -229,7 +230,7 @@ describe.skipIf(HTTP_SKIP)(
 
       expect(
         replayNodeEvents,
-        driver.describe(
+        req('openwop.it.replay-observable-sequence-determinism.replay-of-a-nondeterministic-tool-node-reproduces-the-original-observable-result', 
           'RFCS/0041-multi-agent-replay-under-nondeterminism.md §C',
           'the nondeterministic tool node MUST replay its ORIGINAL observable result (cached event-log entry) rather than re-executing — bit-equivalent re-execution would require unbounded caching, rejected per RFC 0041 §"Alternatives considered" #2',
         ),

package/src/scenarios/replay-retention-expiry.test.ts

@@ -33,6 +33,8 @@
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 interface ReplayRetentionCaps {
   windowSeconds?: number;
@@ -66,14 +68,14 @@ describe('replay-retention-expiry: capability shape', () => {
       return;
     }
 
-    expect(replay?.supported, driver.describe(
+    expect(replay?.supported, req('openwop.it.replay-retention-expiry.host-advertising-replay-surfaces-well-formed-retention-metadata-when-present', 
       'replay.md §"Retention and garbage collection"',
       'replay.supported MUST be true when the host claims the openwop-replay-fork profile',
     )).toBe(true);
 
     expect(
       Array.isArray(replay?.modes) && (replay?.modes?.length ?? 0) > 0,
-      driver.describe(
+      req('openwop.it.replay-retention-expiry.host-advertising-replay-surfaces-well-formed-retention-metadata-when-present', 
         'profiles.md §`openwop-replay-fork`',
         'replay.modes MUST be a non-empty array',
       ),
@@ -86,7 +88,7 @@ describe('replay-retention-expiry: capability shape', () => {
       expect(
         Number.isInteger(replay.retention.windowSeconds) &&
           replay.retention.windowSeconds >= 0,
-        driver.describe(
+        req('openwop.it.replay-retention-expiry.host-advertising-replay-surfaces-well-formed-retention-metadata-when-present', 
           'replay.md §"Retention and garbage collection"',
           'replay.retention.windowSeconds MUST be a non-negative integer when advertised',
         ),
@@ -109,7 +111,7 @@ describe('replay-retention-expiry: 410/422 on expired-range fork', () => {
       console.warn(
         '[replay-retention-expiry] OPENWOP_TEST_EXPIRED_REPLAY_RUN_ID not supplied; skipping envelope assertion (operator must produce a known-expired run id and pass it via env)',
       );
-      return;
+      return softSkip('blocked', 'precondition not met — `!expiredRunId` returned early ([replay-retention-expiry] OPENWOP_TEST_EXPIRED_REPLAY_RUN_ID not supplied; skipping envelope assertion (operator must produce a known-expired run id and pass it v…');
     }
 
     const fromSeqEnv = process.env.OPENWOP_TEST_EXPIRED_REPLAY_FROM_SEQ;
@@ -119,7 +121,7 @@ describe('replay-retention-expiry: 410/422 on expired-range fork', () => {
       console.warn(
         `[replay-retention-expiry] OPENWOP_TEST_EXPIRED_REPLAY_FROM_SEQ=${String(fromSeqEnv)} is not a non-negative integer; skipping`,
       );
-      return;
+      return softSkip('blocked', 'precondition not met — `!Number.isFinite(fromSeq) || fromSeq < 0` returned early ([replay-retention-expiry] OPENWOP_TEST_EXPIRED_REPLAY_FROM_SEQ=… is not a non-negative integer; skipping) (seam, prior step, or fixture…');
     }
 
     // Pick a mode the host advertises. Per replay.md the envelope
@@ -134,7 +136,7 @@ describe('replay-retention-expiry: 410/422 on expired-range fork', () => {
 
     expect(
       res.status === 410 || res.status === 422,
-      driver.describe(
+      req('openwop.it.replay-retention-expiry.post-v1-runs-expiredrunid-fork-returns-410-or-422-with-canonical-envelope', 
         'replay.md §"Retention and garbage collection"',
         'fork against expired event range MUST return 410 Gone or 422 Unprocessable Entity',
       ),
@@ -150,7 +152,7 @@ describe('replay-retention-expiry: 410/422 on expired-range fork', () => {
       };
     };
 
-    expect(typeof body.error, driver.describe(
+    expect(typeof body.error, req('openwop.it.replay-retention-expiry.post-v1-runs-expiredrunid-fork-returns-410-or-422-with-canonical-envelope', 
       'replay.md §"Retention and garbage collection"',
       'expired-fork response MUST use the canonical error envelope ({error, message, details?})',
     )).toBe('string');
@@ -162,14 +164,14 @@ describe('replay-retention-expiry: 410/422 on expired-range fork', () => {
     // details.{sourceRunId, fromSeq, retentionBoundary} are SHOULD —
     // soft-check when present, MUST NOT mismatch when present.
     if (body.details?.sourceRunId !== undefined) {
-      expect(body.details.sourceRunId, driver.describe(
+      expect(body.details.sourceRunId, req('openwop.it.replay-retention-expiry.post-v1-runs-expiredrunid-fork-returns-410-or-422-with-canonical-envelope', 
         'replay.md §"Retention and garbage collection"',
         'details.sourceRunId (when present) MUST match the runId in the request path',
       )).toBe(expiredRunId);
     }
 
     if (body.details?.fromSeq !== undefined) {
-      expect(body.details.fromSeq, driver.describe(
+      expect(body.details.fromSeq, req('openwop.it.replay-retention-expiry.post-v1-runs-expiredrunid-fork-returns-410-or-422-with-canonical-envelope', 
         'replay.md §"Retention and garbage collection"',
         'details.fromSeq (when present) MUST match the fromSeq supplied in the request body',
       )).toBe(fromSeq);

package/src/scenarios/replay-side-effect-suppression.test.ts

@@ -54,6 +54,8 @@ import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { V1_DIR } from '../lib/paths.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const WORKFLOW_ID = 'conformance-replay-side-effect';
 const EFFECT_NODE = 'effect';
@@ -98,10 +100,10 @@ function errorCode(e: RawEvent): string | undefined {
 describe('replay-side-effect-suppression: capability shape (RFC 0140 §A)', () => {
   it('sideEffectSuppression, when present, is one of the two defined values', async () => {
     const replay = await fetchReplay();
-    if (replay?.sideEffectSuppression === undefined) return; // absent ⇒ "none"; nothing to check
+    if (replay?.sideEffectSuppression === undefined) return softSkip('blocked', 'precondition not met — `replay?.sideEffectSuppression === undefined` returned early (absent ⇒ "none"; nothing to check) (seam, prior step, or fixture unavailable)'); // absent ⇒ "none"; nothing to check
     expect(
       replay.sideEffectSuppression,
-      driver.describe(
+      req('openwop.it.replay-side-effect-suppression.sideeffectsuppression-when-present-is-one-of-the-two-defined-values', 
         'capabilities.schema.json §replay.sideEffectSuppression',
         'sideEffectSuppression MUST be "recorded-outcome" or "none" when advertised',
       ),
@@ -132,11 +134,11 @@ describe.skipIf(SKIP_NO_FIXTURE)('replay-side-effect-suppression: a replay does
         /* already recorded */
       }
       ctx.skip();
-      return;
+      return softSkip('blocked', 'precondition not met — `replay?.sideEffectSuppression !== \'recorded-outcome\'` returned early (seam, prior step, or fixture unavailable)');
     }
     if (!replay.modes?.includes('replay')) {
       ctx.skip(); // suppression is scoped to replay mode
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!replay.modes?.includes(\'replay\')` returned early');
     }
 
     // 1. Start the run with a delay long enough to cancel mid-flight, so the
@@ -151,13 +153,13 @@ describe.skipIf(SKIP_NO_FIXTURE)('replay-side-effect-suppression: a replay does
       workflowId: WORKFLOW_ID,
       inputs: { delayMs: 5_000 },
     });
-    expect(create.status, `Failed to start ${WORKFLOW_ID}`).toBe(201);
+    expect(create.status, req('openwop.it.replay-side-effect-suppression.fails-a-side-effecting-node-closed-with-replay-source-missing-when-the-source-ne', 'replay.md §"Side-effect suppression in replay" requirement 1', `Failed to start ${WORKFLOW_ID}`)).toBe(201);
     const sourceRunId = (create.json as { runId: string }).runId;
 
     const cancel = await driver.post(`/v1/runs/${encodeURIComponent(sourceRunId)}/cancel`, {});
     expect(
       [200, 202, 204].includes(cancel.status),
-      `cancel returned ${cancel.status}`,
+      req('openwop.it.replay-side-effect-suppression.fails-a-side-effecting-node-closed-with-replay-source-missing-when-the-source-ne', 'replay.md §"Side-effect suppression in replay" requirement 1', `cancel returned ${cancel.status}`),
     ).toBe(true);
     await pollUntilTerminal(sourceRunId, { timeoutMs: 15_000 });
 
@@ -167,7 +169,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('replay-side-effect-suppression: a replay does
     const sourceEvents = await readEvents(sourceRunId);
     expect(
       sourceEvents.some((e) => e.type === 'node.completed' && e.nodeId === EFFECT_NODE),
-      'precondition: the cancelled source run must NOT have completed the effect node',
+      req('openwop.it.replay-side-effect-suppression.fails-a-side-effecting-node-closed-with-replay-source-missing-when-the-source-ne', 'replay.md §"Side-effect suppression in replay" requirement 1', 'precondition: the cancelled source run must NOT have completed the effect node'),
     ).toBe(false);
 
     // 2. Fork it in replay mode.
@@ -176,9 +178,9 @@ describe.skipIf(SKIP_NO_FIXTURE)('replay-side-effect-suppression: a replay does
     });
     if (forkDeclined(fork.status, 'side-effect-suppression replay fork')) {
       ctx.skip();
-      return;
+      return softSkip('blocked', 'precondition not met — `forkDeclined(fork.status, \'side-effect-suppression replay fork\')` returned early (seam, prior step, or fixture unavailable)');
     }
-    expect(fork.status, 'fork should be accepted').toBe(201);
+    expect(fork.status, req('openwop.it.replay-side-effect-suppression.fails-a-side-effecting-node-closed-with-replay-source-missing-when-the-source-ne', 'replay.md §"Side-effect suppression in replay" requirement 1', 'fork should be accepted')).toBe(201);
     const forkRunId = (fork.json as { runId: string }).runId;
     await pollUntilTerminal(forkRunId, { timeoutMs: 45_000 }); // re-runs the 5s delay before reaching `effect`
 
@@ -190,7 +192,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('replay-side-effect-suppression: a replay does
 
     expect(
       effectEvents.some((e) => e.type === 'node.completed'),
-      driver.describe(
+      req('openwop.it.replay-side-effect-suppression.fails-a-side-effecting-node-closed-with-replay-source-missing-when-the-source-ne', 
         'replay.md §"Side-effect suppression in replay" requirement 1',
         'the side-effecting node MUST NOT complete during a replay — completing it means the effect was performed',
       ),
@@ -198,7 +200,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('replay-side-effect-suppression: a replay does
 
     expect(
       effectEvents.some((e) => e.type === 'node.failed' && errorCode(e) === 'replay_source_missing'),
-      driver.describe(
+      req('openwop.it.replay-side-effect-suppression.fails-a-side-effecting-node-closed-with-replay-source-missing-when-the-source-ne', 
         'replay.md §"Side-effect suppression in replay" requirement 3',
         'a side-effecting node with no recorded source outcome MUST fail closed with replay_source_missing',
       ),
@@ -240,9 +242,9 @@ describe.skipIf(V1_DIR === null)('replay.md req 4 — the manifest role is a cla
     // binds a value nothing can declare — a rule with no reachable trigger.
     expect(
       manifest().includes('side-effect'),
-      'node-pack-manifest.schema.json §role MUST still describe the `side-effect` value that ' +
+      req('openwop.it.replay-side-effect-suppression.the-manifest-still-offers-the-role-value-the-requirement-binds', 'RFC 0140', 'node-pack-manifest.schema.json §role MUST still describe the `side-effect` value that ' +
         'replay.md requirement 4 makes binding. A requirement whose trigger no longer exists is ' +
-        'not enforcement, it is decoration.',
+        'not enforcement, it is decoration.'),
     ).toBe(true);
   });
 
@@ -250,9 +252,9 @@ describe.skipIf(V1_DIR === null)('replay.md req 4 — the manifest role is a cla
     const doc = replay();
     expect(
       /MUST\*{0,2} be treated as side-effecting/.test(doc) && doc.includes('node-pack-manifest.schema.json'),
-      'replay.md §"Requirements when a host declares `sideEffectSuppression: \\"recorded-outcome\\"`" ' +
+      req('openwop.it.replay-side-effect-suppression.replay-md-binds-that-declaration-naming-the-schema-it-comes-from', 'replay.md', 'replay.md §"Requirements when a host declares `sideEffectSuppression: \\"recorded-outcome\\"`" ' +
         'MUST bind a manifest-declared `role: "side-effect"` to the suppression obligation, and MUST ' +
-        'name the schema the declaration comes from so a reader can find it.',
+        'name the schema the declaration comes from so a reader can find it.'),
     ).toBe(true);
   });
 
@@ -267,10 +269,10 @@ describe.skipIf(V1_DIR === null)('replay.md req 4 — the manifest role is a cla
     const doc = replay();
     expect(
       doc.includes('backstop, not a discharge'),
-      'replay.md requirement 4 MUST state that a guarded-seam throw is a backstop rather than a ' +
+      req('openwop.it.replay-side-effect-suppression.a-throw-is-named-a-backstop-not-a-discharge', 'RFC 0140', 'replay.md requirement 4 MUST state that a guarded-seam throw is a backstop rather than a ' +
         'discharge. It satisfies requirement 1 (no effect) and not requirement 2 (resolve the ' +
         'recorded outcome), and a host reading the floor as "make it throw" ships a replay that ' +
-        'fails where this section says it must succeed.',
+        'fails where this section says it must succeed.'),
     ).toBe(true);
     expect(
       /safe and\s+non-conformant/.test(doc),
@@ -285,9 +287,9 @@ describe.skipIf(V1_DIR === null)('replay.md req 4 — the manifest role is a cla
     // manifest is wrong." The requirement is one-directional and says so.
     expect(
       replay().includes('MUST NOT classify fewer'),
-      'replay.md requirement 4 MUST state the direction: a host classifier may treat MORE nodes as ' +
+      req('openwop.it.replay-side-effect-suppression.the-floor-direction-is-stated-not-left-to-inference', 'RFC 0140', 'replay.md requirement 4 MUST state the direction: a host classifier may treat MORE nodes as ' +
         'side-effecting and never fewer. Without the direction, a host that trusts its own list over ' +
-        'the manifest can read the clause as permission to disagree.',
+        'the manifest can read the clause as permission to disagree.'),
     ).toBe(true);
   });
 });

package/src/scenarios/replayDeterminism.test.ts

@@ -22,6 +22,7 @@ import { softSkip } from '../lib/soft-skip.js';
 import { forkDeclined } from '../lib/fork-availability.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { req } from '../lib/requirement-ids.js';
 
 const NOOP_WORKFLOW_ID = 'conformance-noop';
 const SKIP_NO_NOOP = !isFixtureAdvertised(NOOP_WORKFLOW_ID);
@@ -73,13 +74,13 @@ describe('replay-determinism: openwop-replay-fork profile gate', () => {
     const replay = await fetchReplayCapability();
     if (replay === null || replay.supported !== true) return softSkip('inapplicable', 'host does not advertise `replay.supported: true` — the replay contract does not apply to it');
 
-    expect(Array.isArray(replay.modes), driver.describe(
+    expect(Array.isArray(replay.modes), req('openwop.it.replayDeterminism.host-advertising-replay-supported-must-also-advertise-replay-modes', 
       'spec/v1/replay.md',
       'host advertising replay.supported MUST advertise replay.modes as an array',
     )).toBe(true);
     if (Array.isArray(replay.modes)) {
       for (const m of replay.modes) {
-        expect(typeof m, driver.describe(
+        expect(typeof m, req('openwop.it.replayDeterminism.host-advertising-replay-supported-must-also-advertise-replay-modes', 
           'spec/v1/replay.md',
           'each replay.modes entry MUST be a string',
         )).toBe('string');
@@ -98,7 +99,7 @@ describe.skipIf(SKIP_NO_NOOP)('replay-determinism: same fromSeq + same workflow
 
       // Phase 1: complete an original run.
       const create = await driver.post('/v1/runs', { workflowId: NOOP_WORKFLOW_ID });
-      if (create.status !== 201) return;
+      if (create.status !== 201) return softSkip('blocked', 'precondition not met — `create.status !== 201` returned early (seam, prior step, or fixture unavailable)');
       const originalRunId = (create.json as { runId: string }).runId;
       await pollUntilTerminal(originalRunId, { timeoutMs: 10_000 });
 
@@ -107,8 +108,8 @@ describe.skipIf(SKIP_NO_NOOP)('replay-determinism: same fromSeq + same workflow
         mode: 'replay',
         fromSeq: 0,
       });
-      if (forkDeclined(fork1.status, 'determinism fork 1')) return;
-      expect(fork1.status, driver.describe(
+      if (forkDeclined(fork1.status, 'determinism fork 1')) return softSkip('blocked', 'precondition not met — `forkDeclined(fork1.status, \'determinism fork 1\')` returned early (seam, prior step, or fixture unavailable)');
+      expect(fork1.status, req('openwop.it.replayDeterminism.two-replay-forks-of-the-same-point-produce-structurally-identical-event-lists', 
         'spec/v1/replay.md',
         'POST /v1/runs/{runId}:fork with mode=replay MUST return 201',
       )).toBe(201);
@@ -120,7 +121,7 @@ describe.skipIf(SKIP_NO_NOOP)('replay-determinism: same fromSeq + same workflow
         mode: 'replay',
         fromSeq: 0,
       });
-      if (forkDeclined(fork2.status, 'determinism fork 2')) return;
+      if (forkDeclined(fork2.status, 'determinism fork 2')) return softSkip('blocked', 'precondition not met — `forkDeclined(fork2.status, \'determinism fork 2\')` returned early (seam, prior step, or fixture unavailable)');
       expect(fork2.status).toBe(201);
       const fork2Id = (fork2.json as { runId: string }).runId;
       await pollUntilTerminal(fork2Id, { timeoutMs: 10_000 });
@@ -128,21 +129,21 @@ describe.skipIf(SKIP_NO_NOOP)('replay-determinism: same fromSeq + same workflow
       // Phase 4: fetch both fork event streams.
       const fork1Events = await driver.get(`/v1/runs/${encodeURIComponent(fork1Id)}/events/poll`);
       const fork2Events = await driver.get(`/v1/runs/${encodeURIComponent(fork2Id)}/events/poll`);
-      if (fork1Events.status !== 200 || fork2Events.status !== 200) return;
+      if (fork1Events.status !== 200 || fork2Events.status !== 200) return softSkip('blocked', 'precondition not met — `fork1Events.status !== 200 || fork2Events.status !== 200` returned early (seam, prior step, or fixture unavailable)');
 
       const fork1Body = fork1Events.json as { events?: RawEvent[] };
       const fork2Body = fork2Events.json as { events?: RawEvent[] };
-      if (!fork1Body.events || !fork2Body.events) return;
+      if (!fork1Body.events || !fork2Body.events) return softSkip('blocked', 'precondition not met — `!fork1Body.events || !fork2Body.events` returned early (seam, prior step, or fixture unavailable)');
 
       // Phase 5: assert structural identity (modulo timestamps + IDs).
-      expect(fork1Body.events.length, driver.describe(
+      expect(fork1Body.events.length, req('openwop.it.replayDeterminism.two-replay-forks-of-the-same-point-produce-structurally-identical-event-lists', 
         'spec/v1/replay.md §"Replay determinism"',
         'two replay forks MUST produce the same number of events',
       )).toBe(fork2Body.events.length);
 
       const shape1 = structuralShape(fork1Body.events);
       const shape2 = structuralShape(fork2Body.events);
-      expect(shape1, driver.describe(
+      expect(shape1, req('openwop.it.replayDeterminism.two-replay-forks-of-the-same-point-produce-structurally-identical-event-lists', 
         'spec/v1/replay.md §"Replay determinism"',
         'event sequence (type/nodeId/data) MUST be identical across two replay forks of the same point',
       )).toEqual(shape2);
@@ -155,14 +156,14 @@ describe.skipIf(SKIP_NO_NOOP)('replay-determinism: branch-mode is permitted to d
   it('branch mode does NOT need to produce identical event sequences (negative-control)', async () => {
     const replay = await fetchReplayCapability();
     if (replay === null || replay.supported !== true) return softSkip('inapplicable', 'host does not advertise `replay.supported: true` — the replay contract does not apply to it');
-    if (!Array.isArray(replay.modes) || !replay.modes.includes('branch')) return;
+    if (!Array.isArray(replay.modes) || !replay.modes.includes('branch')) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!Array.isArray(replay.modes) || !replay.modes.includes(\'branch\')` returned early');
 
     // Self-test on the spec interpretation: branch and replay are
     // SEMANTICALLY DIFFERENT modes per spec/v1/replay.md. Branch may
     // diverge by design (variable overlay, runOptionsOverlay). This
     // assertion just pins the interpretation; no actual round-trip
     // needed.
-    expect((replay.modes as string[]).includes('branch'), driver.describe(
+    expect((replay.modes as string[]).includes('branch'), req('openwop.it.replayDeterminism.branch-mode-does-not-need-to-produce-identical-event-sequences-negative-control', 
       'spec/v1/replay.md',
       'branch mode is documented; this self-test ensures the suite does not assume branch determinism',
     )).toBe(true);