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

package/src/scenarios/replay-divergence-at-refusal.test.ts

@@ -48,6 +48,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';
 
 const HTTP_SKIP = !process.env.OPENWOP_BASE_URL;
 
@@ -80,18 +81,18 @@ describe.skipIf(HTTP_SKIP)('replay-divergence-at-refusal: advertisement shape (R
     if (d === null) {
       softSkip('blocked', 'precondition not met — `d === null` returned early (seam, prior step, or fixture unavailable)');
       ctx.skip();
-      return;
+      return softSkip('blocked', 'precondition not met — `d === null` returned early (seam, prior step, or fixture unavailable)');
     }
     const rd = capabilityFamily<{ executionModel?: { [k: string]: unknown; crossHostCausation?: Record<string, unknown>; replayDeterminism?: Record<string, unknown> } }>(d, 'multiAgent')?.executionModel?.replayDeterminism;
     if (rd === undefined) {
       softSkip('inapplicable', 'optional advertisement — `multiAgent.executionModel.replayDeterminism` not advertised by this host (RFC 0041 §D)');
       ctx.skip(); // optional advertisement — host hasn't opted in
-      return;
+      return softSkip('blocked', 'precondition not met — `rd === undefined` returned early (seam, prior step, or fixture unavailable)');
     }
 
     expect(
       typeof rd.supported,
-      driver.describe(
+      req('openwop.it.replay-divergence-at-refusal.replaydeterminism-when-present-conforms-to-rfc-0041-d', 
         'RFCS/0041-multi-agent-replay-under-nondeterminism.md §D',
         'replayDeterminism.supported MUST be boolean when present',
       ),
@@ -101,7 +102,7 @@ describe.skipIf(HTTP_SKIP)('replay-divergence-at-refusal: advertisement shape (R
       const version = capabilityFamily<{ executionModel?: { [k: string]: unknown; crossHostCausation?: Record<string, unknown>; replayDeterminism?: Record<string, unknown> } }>(d, 'multiAgent')?.executionModel?.version as number | undefined;
       expect(
         typeof version === 'number' && version >= 4,
-        driver.describe(
+        req('openwop.it.replay-divergence-at-refusal.replaydeterminism-when-present-conforms-to-rfc-0041-d', 
           'RFCS/0041-multi-agent-replay-under-nondeterminism.md §D',
           'when replayDeterminism.supported: true, multiAgent.executionModel.version MUST be >= 4',
         ),
@@ -114,7 +115,7 @@ describe.skipIf(HTTP_SKIP)('replay-divergence-at-refusal: advertisement shape (R
       // assertion closes the conformance-enforcement gap.
       expect(
         rd.refusalDivergenceEmission,
-        driver.describe(
+        req('openwop.it.replay-divergence-at-refusal.replaydeterminism-when-present-conforms-to-rfc-0041-d', 
           'schemas/capabilities.schema.json §replayDeterminism.refusalDivergenceEmission',
           'hosts advertising version: 4 MUST set replayDeterminism.refusalDivergenceEmission to true',
         ),
@@ -196,7 +197,7 @@ describe.skipIf(HTTP_SKIP)('replay-divergence-at-refusal: behavioral (RFC 0041
     if (programStatus === 404) {
       softSkip('blocked', 'precondition not met — `programStatus === 404` returned early (seam, prior step, or fixture unavailable)');
       ctx.skip(); // mock-AI program seam not exposed — soft-skip
-      return;
+      return softSkip('blocked', 'precondition not met — `programStatus === 404` returned early (seam, prior step, or fixture unavailable)');
     }
     expect(programStatus).toBe(200);
 
@@ -206,7 +207,7 @@ describe.skipIf(HTTP_SKIP)('replay-divergence-at-refusal: behavioral (RFC 0041
     if (createRes.status === 404 || createRes.status === 422) {
       softSkip('blocked', 'precondition not met — `createRes.status === 404 || createRes.status === 422` returned early (seam, prior step, or fixture unavailable)');
       ctx.skip(); // fixture not advertised
-      return;
+      return softSkip('blocked', 'precondition not met — `createRes.status === 404 || createRes.status === 422` returned early (seam, prior step, or fixture unavailable)');
     }
     expect(createRes.status).toBe(201);
     const sourceRunId = (createRes.json as { runId: string }).runId;
@@ -228,14 +229,14 @@ describe.skipIf(HTTP_SKIP)('replay-divergence-at-refusal: behavioral (RFC 0041
 
     expect(
       replayTerminal.status,
-      driver.describe(
+      req('openwop.it.replay-divergence-at-refusal.phase-4-host-must-emit-replay-divergedatrefusal-fail-with-replay-diverged-at-ref', 
         'RFCS/0041-multi-agent-replay-under-nondeterminism.md §B + spec/v1/rest-endpoints.md §"Common error codes"',
         'replay MUST terminate `failed` when refusal-divergence is detected (silent substitution is non-conformant)',
       ),
     ).toBe('failed');
     expect(
       replayTerminal.error?.code,
-      driver.describe(
+      req('openwop.it.replay-divergence-at-refusal.phase-4-host-must-emit-replay-divergedatrefusal-fail-with-replay-diverged-at-ref', 
         'spec/v1/rest-endpoints.md §"Common error codes" — replay_diverged_at_refusal',
         'error.code MUST be `replay_diverged_at_refusal` per the canonical catalog',
       ),
@@ -245,7 +246,7 @@ describe.skipIf(HTTP_SKIP)('replay-divergence-at-refusal: behavioral (RFC 0041
     const divergenceEvent = replayEvents.find((e) => e.type === 'replay.divergedAtRefusal');
     expect(
       divergenceEvent,
-      driver.describe(
+      req('openwop.it.replay-divergence-at-refusal.phase-4-host-must-emit-replay-divergedatrefusal-fail-with-replay-diverged-at-ref', 
         'schemas/run-event-payloads.schema.json §replayDivergedAtRefusal',
         'replay event log MUST contain exactly one `replay.divergedAtRefusal` event identifying the divergence',
       ),
@@ -254,14 +255,14 @@ describe.skipIf(HTTP_SKIP)('replay-divergence-at-refusal: behavioral (RFC 0041
     expect(divergenceEvent?.payload?.nodeId).toBe(NODE_ID);
     expect(
       divergenceEvent?.payload?.originalEnvelopeKind,
-      driver.describe(
+      req('openwop.it.replay-divergence-at-refusal.phase-4-host-must-emit-replay-divergedatrefusal-fail-with-replay-diverged-at-ref', 
         'schemas/run-event-payloads.schema.json §replayDivergedAtRefusal.originalEnvelopeKind',
         'originalEnvelopeKind MUST be `valid` (source run completed normally)',
       ),
     ).toBe('valid');
     expect(
       divergenceEvent?.payload?.replayEnvelopeKind,
-      driver.describe(
+      req('openwop.it.replay-divergence-at-refusal.phase-4-host-must-emit-replay-divergedatrefusal-fail-with-replay-diverged-at-ref', 
         'schemas/run-event-payloads.schema.json §replayDivergedAtRefusal.replayEnvelopeKind',
         'replayEnvelopeKind MUST be `refusal` (replay hit the refusal entry of the mock program)',
       ),
@@ -279,9 +280,9 @@ describe.skipIf(HTTP_SKIP)('replay-divergence-at-refusal: behavioral (RFC 0041
     if (programStatus === 404) {
       softSkip('blocked', 'precondition not met — `programStatus === 404` returned early (seam, prior step, or fixture unavailable)');
       ctx.skip();
-      return;
+      return softSkip('blocked', 'precondition not met — `programStatus === 404` returned early (seam, prior step, or fixture unavailable)');
     }
-    expect(programStatus).toBe(200);
+    expect(programStatus, req('openwop.it.replay-divergence-at-refusal.phase-4-host-must-emit-replay-divergedatrefusal-fail-with-replay-diverged-at-ref~2', 'RFC 0041 §B', 'Phase 4 host MUST emit replay.divergedAtRefusal + fail with replay_diverged_at_refusal when original=refusal + replay=valid (symmetric case)')).toBe(200);
 
     const createRes = await driver.post('/v1/runs', {
       workflowId: 'conformance-phase4-replay-divergence',
@@ -289,7 +290,7 @@ describe.skipIf(HTTP_SKIP)('replay-divergence-at-refusal: behavioral (RFC 0041
     if (createRes.status === 404 || createRes.status === 422) {
       softSkip('blocked', 'precondition not met — `createRes.status === 404 || createRes.status === 422` returned early (seam, prior step, or fixture unavailable)');
       ctx.skip();
-      return;
+      return softSkip('blocked', 'precondition not met — `createRes.status === 404 || createRes.status === 422` returned early (seam, prior step, or fixture unavailable)');
     }
     expect(createRes.status).toBe(201);
     const sourceRunId = (createRes.json as { runId: string }).runId;

package/src/scenarios/replay-fanout-suppression.test.ts

@@ -79,6 +79,7 @@ import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { discoverOwnedTenant } from '../lib/webhook-receiver.js';
 import { recordRequirement } from '../lib/requirement-ledger.js';
 import { requirementIdForFile } from '../lib/scenario-disposition.js';
+import { req } from '../lib/requirement-ids.js';
 
 /**
  * RFC 0148 §A — the MUST NOT gets its OWN disposition, separate from the file's.
@@ -108,10 +109,10 @@ interface Delivered {
 
 async function startReceiver(): Promise<{ server: Server; url: string; received: Delivered[] }> {
   const received: Delivered[] = [];
-  const server = createServer((req: IncomingMessage, res: ServerResponse) => {
+  const server = createServer((reqBody: IncomingMessage, res: ServerResponse) => {
     const chunks: Buffer[] = [];
-    req.on('data', (c: Buffer) => chunks.push(c));
-    req.on('end', () => {
+    reqBody.on('data', (c: Buffer) => chunks.push(c));
+    reqBody.on('end', () => {
       received.push({ body: Buffer.concat(chunks).toString('utf8') });
       res.writeHead(204);
       res.end();
@@ -193,21 +194,21 @@ describe('replay-fanout-suppression: a replay fork MUST NOT fan out re-emitted e
           + 'set OPENWOP_WEBHOOK_ALLOW_PRIVATE=true on the host (or equivalent) to run',
       );
     }
-    expect(reg.status, driver.describe(
+    expect(reg.status, req('openwop.it.replay-fanout-suppression.delivers-for-a-live-run-suppresses-for-a-replay-fork-and-delivers-again-for-a-br', 
       'webhooks.md §"Register"',
       'POST /v1/webhooks MUST return 201 on success',
     )).toBe(201);
 
     // ── LEG 1 — POSITIVE CONTROL. Prove this wiring delivers at all. ─────────
     const create = await driver.post('/v1/runs', { workflowId: 'conformance-noop' });
-    expect(create.status, 'failed to start conformance-noop').toBe(201);
+    expect(create.status, req('openwop.it.replay-fanout-suppression.delivers-for-a-live-run-suppresses-for-a-replay-fork-and-delivers-again-for-a-br', 'webhooks.md §"Register"', 'failed to start conformance-noop')).toBe(201);
     const sourceRunId = (create.json as { runId: string }).runId;
     await pollUntilTerminal(sourceRunId, { timeoutMs: 10_000 });
     await quietWindow(DELIVERY_GRACE_MS);
 
     expect(
       forRun(receiver.received, sourceRunId).length,
-      driver.describe(
+      req('openwop.it.replay-fanout-suppression.delivers-for-a-live-run-suppresses-for-a-replay-fork-and-delivers-again-for-a-br', 
         'webhooks.md §"Register"',
         'POSITIVE CONTROL: the host must deliver the source run\'s events to this receiver — '
           + 'without this, every "no delivery" assertion below is vacuous',
@@ -236,7 +237,7 @@ describe('replay-fanout-suppression: a replay fork MUST NOT fan out re-emitted e
           + 'has nothing to constrain on this host',
       );
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `replayCap?.supported !== true` returned early');
     }
 
     // ── LEG 2 — THE MUST NOT. A replay fork re-emits; it must not deliver. ───
@@ -261,16 +262,16 @@ describe('replay-fanout-suppression: a replay fork MUST NOT fan out re-emitted e
           + 'so the absence of deliveries below would prove nothing',
       );
       ctx.skip();
-      return;
+      return softSkip('blocked', 'precondition not met — `forkDeclined(replay.status, \'fanout-suppression replay fork\')` returned early (seam, prior step, or fixture unavailable)');
     }
-    expect(replay.status, 'replay fork should be accepted').toBe(201);
+    expect(replay.status, req('openwop.it.replay-fanout-suppression.delivers-for-a-live-run-suppresses-for-a-replay-fork-and-delivers-again-for-a-br', 'webhooks.md §"Register"', 'replay fork should be accepted')).toBe(201);
     const replayRunId = (replay.json as { runId: string }).runId;
     await pollUntilTerminal(replayRunId, { timeoutMs: 30_000 });
     await quietWindow(SUPPRESSION_WINDOW_MS);
 
     expect(
       forRun(receiver.received, replayRunId).map((d) => d.body.slice(0, 200)),
-      driver.describe(
+      req('openwop.it.replay-fanout-suppression.delivers-for-a-live-run-suppresses-for-a-replay-fork-and-delivers-again-for-a-br', 
         'replay.md §"Host-initiated fan-out is an external effect"',
         'a mode:"replay" fork MUST NOT emit outbound deliveries for the events it re-emits as fixed history — '
           + 'delivering one asserts to a subscriber that something happened in this run which did not',
@@ -283,11 +284,11 @@ describe('replay-fanout-suppression: a replay fork MUST NOT fan out re-emitted e
     // still carries them). Without this, a host that simply failed the fork
     // would pass leg 2.
     const forkEvents = await driver.get(`/v1/runs/${encodeURIComponent(replayRunId)}/events`);
-    expect(forkEvents.status, 'fork events must be readable').toBe(200);
+    expect(forkEvents.status, req('openwop.it.replay-fanout-suppression.delivers-for-a-live-run-suppresses-for-a-replay-fork-and-delivers-again-for-a-br', 'replay.md §"Host-initiated fan-out is an external effect"', 'fork events must be readable')).toBe(200);
     const forkEventList = (forkEvents.json as { events?: { type?: string }[] }).events ?? [];
     expect(
       forkEventList.length,
-      driver.describe(
+      req('openwop.it.replay-fanout-suppression.delivers-for-a-live-run-suppresses-for-a-replay-fork-and-delivers-again-for-a-br', 
         'replay.md §"Host-initiated fan-out is an external effect"',
         'suppression is OUTBOUND ONLY — the fork\'s own event log MUST still carry the re-emitted events, '
           + 'so an empty fork log means leg 2 proved nothing',
@@ -309,16 +310,16 @@ describe('replay-fanout-suppression: a replay fork MUST NOT fan out re-emitted e
     });
     if (branch.status === 501 || branch.status === 400) {
       // branch not offered on this range — leg 2 still stands on its own.
-      return;
+      return softSkip('blocked', 'precondition not met — `branch.status === 501 || branch.status === 400` returned early (branch not offered on this range — leg 2 still stands on its own.) (seam, prior step, or fixture unavailable)');
     }
-    expect(branch.status, 'branch fork should be accepted').toBe(201);
+    expect(branch.status, req('openwop.it.replay-fanout-suppression.delivers-for-a-live-run-suppresses-for-a-replay-fork-and-delivers-again-for-a-br', 'replay.md §"Host-initiated fan-out is an external effect"', 'branch fork should be accepted')).toBe(201);
     const branchRunId = (branch.json as { runId: string }).runId;
     await pollUntilTerminal(branchRunId, { timeoutMs: 30_000 });
     await quietWindow(DELIVERY_GRACE_MS);
 
     expect(
       forRun(receiver.received, branchRunId).length,
-      driver.describe(
+      req('openwop.it.replay-fanout-suppression.delivers-for-a-live-run-suppresses-for-a-replay-fork-and-delivers-again-for-a-br', 
         'replay.md §"Host-initiated fan-out is an external effect"',
         'a branch fork is deliberately OUT of scope — its events are new facts, so suppressing them '
           + 'means the host keyed on "is a fork" rather than on replay-ness read from the run',

package/src/scenarios/replay-fork-arbitrary.test.ts

@@ -34,6 +34,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 MULTI_NODE_WORKFLOW_ID = 'conformance-multi-node';
 const SKIP_NO_MULTI = !isFixtureAdvertised(MULTI_NODE_WORKFLOW_ID);
@@ -126,7 +127,7 @@ describe.skipIf(SKIP_NO_MULTI)(
       if (replay?.supported !== true) {
         softSkip('inapplicable', "host does not advertise `replay.supported: true` — the replay contract does not apply to it");
         ctx.skip();
-        return;
+        return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `replay?.supported !== true` returned early');
       }
       const modes = Array.isArray(replay.modes)
         ? replay.modes.filter((m): m is string => typeof m === 'string')
@@ -134,7 +135,7 @@ describe.skipIf(SKIP_NO_MULTI)(
       if (!modes.includes('replay')) {
         softSkip('inapplicable', "host does not advertise the `replay` fork mode — this leg's rule has no path to apply");
         ctx.skip();
-        return;
+        return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!modes.includes(\'replay\')` returned early');
       }
 
       const sourceRunId = await startAndFinishMultiNode();
@@ -146,7 +147,7 @@ describe.skipIf(SKIP_NO_MULTI)(
         // with the standard event shape will hit the assertions below.
         softSkip('blocked', "the advertised fixture's wire shape exposes no numeric sequence for node.completed(b), so there is no mid-run point to fork from");
         ctx.skip();
-        return;
+        return softSkip('blocked', 'precondition not met — `fromSeq === null` returned early (seam, prior step, or fixture unavailable)');
       }
 
       const fork = await driver.post(
@@ -156,11 +157,11 @@ describe.skipIf(SKIP_NO_MULTI)(
 
       if (forkDeclined(fork.status, 'arbitrary-event fork')) {
         ctx.skip();
-        return;
+        return softSkip('blocked', 'precondition not met — `forkDeclined(fork.status, \'arbitrary-event fork\')` returned early (seam, prior step, or fixture unavailable)');
       }
       expect(
         fork.status,
-        driver.describe(
+        req('openwop.it.replay-fork-arbitrary.mid-fromseq-replay-fork-produces-a-new-run-that-reaches-completed', 
           'spec/v1/replay.md §"Replay-from-event-log internals"',
           `mid-range fromSeq=${fromSeq} replay fork MUST return 201`,
         ),
@@ -171,23 +172,23 @@ describe.skipIf(SKIP_NO_MULTI)(
         sourceRunId?: unknown;
         mode?: unknown;
       };
-      expect(typeof body.runId, 'fork response MUST include a new runId').toBe(
+      expect(typeof body.runId, req('openwop.it.replay-fork-arbitrary.mid-fromseq-replay-fork-produces-a-new-run-that-reaches-completed', 'spec/v1/replay.md §"Replay-from-event-log internals"', 'fork response MUST include a new runId')).toBe(
         'string',
       );
       expect(
         body.runId,
-        'forked runId MUST differ from source',
+        req('openwop.it.replay-fork-arbitrary.mid-fromseq-replay-fork-produces-a-new-run-that-reaches-completed', 'spec/v1/replay.md §"Replay-from-event-log internals"', 'forked runId MUST differ from source'),
       ).not.toBe(sourceRunId);
-      expect(body.sourceRunId, 'fork response MUST echo sourceRunId').toBe(
+      expect(body.sourceRunId, req('openwop.it.replay-fork-arbitrary.mid-fromseq-replay-fork-produces-a-new-run-that-reaches-completed', 'spec/v1/replay.md §"Replay-from-event-log internals"', 'fork response MUST echo sourceRunId')).toBe(
         sourceRunId,
       );
-      expect(body.mode, 'fork response MUST echo mode').toBe('replay');
+      expect(body.mode, req('openwop.it.replay-fork-arbitrary.mid-fromseq-replay-fork-produces-a-new-run-that-reaches-completed', 'spec/v1/replay.md §"Replay-from-event-log internals"', 'fork response MUST echo mode')).toBe('replay');
 
       const newRunId = body.runId as string;
       const terminal = await pollUntilTerminal(newRunId, { timeoutMs: 15_000 });
       expect(
         terminal.status,
-        driver.describe(
+        req('openwop.it.replay-fork-arbitrary.mid-fromseq-replay-fork-produces-a-new-run-that-reaches-completed', 
           'spec/v1/replay.md §"Replay determinism"',
           `replay fork from mid-range fromSeq=${fromSeq} MUST reach the same terminal status as the source`,
         ),
@@ -205,14 +206,14 @@ describe.skipIf(SKIP_NO_MULTI)(
         const replay = await fetchReplayCapability();
         if (replay?.supported !== true) {
           ctx.skip();
-          return;
+          return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `replay?.supported !== true` returned early');
         }
         const modes = Array.isArray(replay.modes)
           ? replay.modes.filter((m): m is string => typeof m === 'string')
           : [];
         if (!modes.includes('replay')) {
           ctx.skip();
-          return;
+          return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!modes.includes(\'replay\')` returned early');
         }
 
         const sourceRunId = await startAndFinishMultiNode();
@@ -220,7 +221,7 @@ describe.skipIf(SKIP_NO_MULTI)(
         const fromSeq = pickMidRangeFromSeq(sourceEvents);
         if (fromSeq === null) {
           ctx.skip();
-          return;
+          return softSkip('blocked', 'precondition not met — `fromSeq === null` returned early (seam, prior step, or fixture unavailable)');
         }
 
         // Fork twice at the same mid-range point. Per replay.md, both
@@ -233,7 +234,7 @@ describe.skipIf(SKIP_NO_MULTI)(
         );
         if (forkDeclined(fork1.status, 'arbitrary-event fork 1')) {
           ctx.skip();
-          return;
+          return softSkip('blocked', 'precondition not met — `forkDeclined(fork1.status, \'arbitrary-event fork 1\')` returned early (seam, prior step, or fixture unavailable)');
         }
         expect(fork1.status).toBe(201);
         const fork1Id = (fork1.json as { runId: string }).runId;
@@ -245,7 +246,7 @@ describe.skipIf(SKIP_NO_MULTI)(
         );
         if (forkDeclined(fork2.status, 'arbitrary-event fork 2')) {
           ctx.skip();
-          return;
+          return softSkip('blocked', 'precondition not met — `forkDeclined(fork2.status, \'arbitrary-event fork 2\')` returned early (seam, prior step, or fixture unavailable)');
         }
         expect(fork2.status).toBe(201);
         const fork2Id = (fork2.json as { runId: string }).runId;
@@ -274,7 +275,7 @@ describe.skipIf(SKIP_NO_MULTI)(
 
         expect(
           tail1.length,
-          driver.describe(
+          req('openwop.it.replay-fork-arbitrary.mid-fromseq-determinism-same-source-same-fromseq-identical-post-fork-events-modu', 
             'spec/v1/replay.md §"Replay determinism"',
             `two replay forks at fromSeq=${fromSeq} MUST produce the same number of re-executed events`,
           ),
@@ -282,7 +283,7 @@ describe.skipIf(SKIP_NO_MULTI)(
 
         expect(
           structuralShape(tail1),
-          driver.describe(
+          req('openwop.it.replay-fork-arbitrary.mid-fromseq-determinism-same-source-same-fromseq-identical-post-fork-events-modu', 
             'spec/v1/replay.md §"Replay determinism"',
             `event sequence (type/nodeId/data) post-fromSeq=${fromSeq} MUST be identical across two replay forks`,
           ),
@@ -301,14 +302,14 @@ describe.skipIf(SKIP_NO_MULTI)(
       if (replay?.supported !== true) {
         softSkip('inapplicable', "host does not advertise `replay.supported: true` — the replay contract does not apply to it");
         ctx.skip();
-        return;
+        return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `replay?.supported !== true` returned early');
       }
       const modes = Array.isArray(replay.modes)
         ? replay.modes.filter((m): m is string => typeof m === 'string')
         : [];
       if (!modes.includes('branch')) {
         ctx.skip();
-        return;
+        return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!modes.includes(\'branch\')` returned early');
       }
 
       const sourceRunId = await startAndFinishMultiNode();
@@ -316,7 +317,7 @@ describe.skipIf(SKIP_NO_MULTI)(
       const fromSeq = pickMidRangeFromSeq(sourceEvents);
       if (fromSeq === null) {
         ctx.skip();
-        return;
+        return softSkip('blocked', 'precondition not met — `fromSeq === null` returned early (seam, prior step, or fixture unavailable)');
       }
 
       // Branch mode with an empty overlay is the boundary case: the
@@ -331,11 +332,11 @@ describe.skipIf(SKIP_NO_MULTI)(
 
       if (fork.status === 501) {
         ctx.skip();
-        return;
+        return softSkip('blocked', 'precondition not met — `fork.status === 501` returned early (seam, prior step, or fixture unavailable)');
       }
       expect(
         fork.status,
-        driver.describe(
+        req('openwop.it.replay-fork-arbitrary.mid-fromseq-branch-fork-with-empty-overlay-produces-a-new-run-that-reaches-compl', 
           'spec/v1/replay.md §"branch mode"',
           `mid-range fromSeq=${fromSeq} branch fork with empty overlay MUST return 201`,
         ),
@@ -345,7 +346,7 @@ describe.skipIf(SKIP_NO_MULTI)(
       const terminal = await pollUntilTerminal(newRunId, { timeoutMs: 15_000 });
       expect(
         terminal.status,
-        driver.describe(
+        req('openwop.it.replay-fork-arbitrary.mid-fromseq-branch-fork-with-empty-overlay-produces-a-new-run-that-reaches-compl', 
           'spec/v1/replay.md',
           `branch fork from mid-range fromSeq=${fromSeq} MUST reach terminal status`,
         ),

package/src/scenarios/replay-fork.test.ts

@@ -29,6 +29,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 SOURCE_WORKFLOW_ID = 'conformance-noop';
 const SKIP_NO_NOOP = !isFixtureAdvertised(SOURCE_WORKFLOW_ID);
@@ -64,7 +65,7 @@ describe.skipIf(SKIP_NO_NOOP)('replay: fork from fromSeq=0 in replay mode', () =
       // unexercised tests apart from honest passes.
       softSkip('inapplicable', "host does not advertise the `replay` fork mode — this leg's rule has no path to apply");
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!modes.includes(\'replay\')` returned early');
     }
     const sourceRunId = await startAndFinishNoop();
 
@@ -73,27 +74,27 @@ describe.skipIf(SKIP_NO_NOOP)('replay: fork from fromSeq=0 in replay mode', () =
       { fromSeq: 0, mode: 'replay' },
     );
 
-    if (forkDeclined(fork.status, 'replay fork')) return;
-    expect(fork.status, driver.describe(
+    if (forkDeclined(fork.status, 'replay fork')) return softSkip('blocked', 'precondition not met — `forkDeclined(fork.status, \'replay fork\')` returned early (seam, prior step, or fixture unavailable)');
+    expect(fork.status, req('openwop.it.replay-fork.produces-a-new-run-that-reaches-terminal-completed', 
       'rest-endpoints.md POST /v1/runs/{runId}:fork',
       'fork MUST return 201 on accepted replay',
     )).toBe(201);
 
     const body = fork.json as { runId?: unknown; sourceRunId?: unknown; mode?: unknown };
-    expect(typeof body.runId, driver.describe(
+    expect(typeof body.runId, req('openwop.it.replay-fork.produces-a-new-run-that-reaches-terminal-completed', 
       'replay.md',
       'fork response MUST include a new runId',
     )).toBe('string');
-    expect(body.runId, 'forked runId MUST differ from source').not.toBe(sourceRunId);
-    expect(body.sourceRunId, driver.describe(
+    expect(body.runId, req('openwop.it.replay-fork.produces-a-new-run-that-reaches-terminal-completed', 'replay.md', 'forked runId MUST differ from source')).not.toBe(sourceRunId);
+    expect(body.sourceRunId, req('openwop.it.replay-fork.produces-a-new-run-that-reaches-terminal-completed', 
       'replay.md',
       'fork response MUST echo sourceRunId',
     )).toBe(sourceRunId);
-    expect(body.mode, 'fork response MUST echo mode').toBe('replay');
+    expect(body.mode, req('openwop.it.replay-fork.produces-a-new-run-that-reaches-terminal-completed', 'replay.md', 'fork response MUST echo mode')).toBe('replay');
 
     const newRunId = body.runId as string;
     const terminal = await pollUntilTerminal(newRunId, { timeoutMs: 15_000 });
-    expect(terminal.status, driver.describe(
+    expect(terminal.status, req('openwop.it.replay-fork.produces-a-new-run-that-reaches-terminal-completed', 
       'replay.md',
       'replay of a successful run MUST reach the same terminal status',
     )).toBe('completed');
@@ -106,7 +107,7 @@ describe.skipIf(SKIP_NO_NOOP)('replay: fork from fromSeq=0 in branch mode with e
     if (!modes.includes('branch')) {
       softSkip('inapplicable', "host does not advertise the `branch` fork mode — this leg's rule has no path to apply");
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!modes.includes(\'branch\')` returned early');
     }
     const sourceRunId = await startAndFinishNoop();
 
@@ -115,8 +116,8 @@ describe.skipIf(SKIP_NO_NOOP)('replay: fork from fromSeq=0 in branch mode with e
       { fromSeq: 0, mode: 'branch', runOptionsOverlay: {} },
     );
 
-    if (forkDeclined(fork.status, 'branch fork')) return;
-    expect(fork.status, driver.describe(
+    if (forkDeclined(fork.status, 'branch fork')) return softSkip('blocked', 'precondition not met — `forkDeclined(fork.status, \'branch fork\')` returned early (seam, prior step, or fixture unavailable)');
+    expect(fork.status, req('openwop.it.replay-fork.produces-a-new-run-that-reaches-terminal-completed~2', 
       'rest-endpoints.md POST /v1/runs/{runId}:fork',
       'branch fork MUST return 201',
     )).toBe(201);
@@ -143,7 +144,7 @@ describe.skipIf(SKIP_NO_NOOP)('replay: validation errors', () => {
     if (modes.length === 0) {
       softSkip('inapplicable', "host advertises no usable fork mode for this leg");
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `modes.length === 0` returned early');
     }
     const mode = modes.includes('branch') ? 'branch' : 'replay';
     const sourceRunId = await startAndFinishNoop();
@@ -151,7 +152,7 @@ describe.skipIf(SKIP_NO_NOOP)('replay: validation errors', () => {
       `/v1/runs/${encodeURIComponent(sourceRunId)}:fork`,
       { fromSeq: -1, mode },
     );
-    expect(res.status, driver.describe(
+    expect(res.status, req('openwop.it.replay-fork.rejects-negative-fromseq-with-400', 
       'rest-endpoints.md',
       'negative fromSeq MUST return 400',
     )).toBe(400);
@@ -162,7 +163,7 @@ describe.skipIf(SKIP_NO_NOOP)('replay: validation errors', () => {
     if (modes.length === 0) {
       softSkip('inapplicable', "host advertises no usable fork mode for this leg");
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `modes.length === 0` returned early');
     }
     const mode = modes.includes('branch') ? 'branch' : 'replay';
     const sourceRunId = await startAndFinishNoop();
@@ -172,7 +173,7 @@ describe.skipIf(SKIP_NO_NOOP)('replay: validation errors', () => {
       `/v1/runs/${encodeURIComponent(sourceRunId)}:fork`,
       { fromSeq: 99999, mode },
     );
-    expect(res.status, driver.describe(
+    expect(res.status, req('openwop.it.replay-fork.rejects-fromseq-beyond-source-event-log-length-with-422', 
       'rest-endpoints.md POST /v1/runs/{runId}:fork',
       'fromSeq beyond source event log MUST return 422',
     )).toBe(422);
@@ -187,7 +188,7 @@ describe.skipIf(SKIP_NO_NOOP)('replay: validation errors', () => {
       // Visible skip rather than silent vacuous pass.
       softSkip('inapplicable', "host does not advertise the `replay` fork mode — the runOptionsOverlay rejection rule only applies to hosts that do");
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!modes.includes(\'replay\')` returned early');
     }
     const sourceRunId = await startAndFinishNoop();
     const res = await driver.post(
@@ -198,7 +199,7 @@ describe.skipIf(SKIP_NO_NOOP)('replay: validation errors', () => {
         runOptionsOverlay: { configurable: { recursionLimit: 50 } },
       },
     );
-    expect(res.status, driver.describe(
+    expect(res.status, req('openwop.it.replay-fork.rejects-replay-mode-with-non-empty-runoptionsoverlay-overlay-is-branch-only', 
       'rest-endpoints.md POST /v1/runs/{runId}:fork',
       'replay mode + non-empty overlay MUST return 400 (overlay is branch-only)',
     )).toBe(400);
@@ -209,7 +210,7 @@ describe.skipIf(SKIP_NO_NOOP)('replay: validation errors', () => {
     if (modes.length === 0) {
       softSkip('inapplicable', "host advertises no usable fork mode for this leg");
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `modes.length === 0` returned early');
     }
     const mode = modes.includes('branch') ? 'branch' : 'replay';
     const res = await driver.post(
@@ -218,7 +219,7 @@ describe.skipIf(SKIP_NO_NOOP)('replay: validation errors', () => {
     );
     expect(
       [403, 404].includes(res.status),
-      driver.describe('rest-endpoints.md', 'fork on unknown run MUST return 404 or 403'),
+      req('openwop.it.replay-fork.rejects-fork-on-a-non-existent-run-with-404', 'rest-endpoints.md', 'fork on unknown run MUST return 404 or 403'),
     ).toBe(true);
   });
 });