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

package/src/scenarios/requirement-ledger.test.ts

@@ -34,6 +34,7 @@ import {
   verifyProfileRequirements,
 } from '../lib/requirement-ledger.js';
 import { allRequirements, requirementsFor } from '../lib/requirement-registry.js';
+import { req } from '../lib/requirement-ids.js';
 
 // This file records REAL requirement ids as fixtures; keep them out of a live
 // --certify ledger sink (they would out-vote genuine dispositions).
@@ -47,7 +48,7 @@ describe('RFC 0148 §A — requirement execution ledger', () => {
   beforeEach(() => resetLedger());
 
   it('the disposition vocabulary is exactly the five §A names', () => {
-    expect([...DISPOSITIONS].sort()).toEqual(
+    expect([...DISPOSITIONS].sort(), req('openwop.it.requirement-ledger.the-disposition-vocabulary-is-exactly-the-five-a-names', 'RFC 0148 §A', 'the disposition vocabulary is exactly the five §A names')).toEqual(
       ['blocked', 'executed-fail', 'executed-pass', 'inapplicable', 'skipped'].sort(),
     );
   });
@@ -58,7 +59,7 @@ describe('RFC 0148 §A — requirement execution ledger', () => {
     // is "not exercised". Every vacuity in this corpus reached `pass` this way.
     expect(
       dispositionOf('openwop.never.recorded'),
-      'RFC 0148 §A: silence is evidence of nothing. An absent disposition MUST NOT read as executed-pass.',
+      req('openwop.it.requirement-ledger.an-unrecorded-requirement-resolves-to-blocked-not-to-a-pass', 'RFC 0148 §A', 'RFC 0148 §A: silence is evidence of nothing. An absent disposition MUST NOT read as executed-pass.'),
     ).toBe('blocked');
     expect(entryOf('openwop.never.recorded').detail).toMatch(/not exercised/);
   });
@@ -66,7 +67,7 @@ describe('RFC 0148 §A — requirement execution ledger', () => {
   it('blocked is not certifiable, while skipped and inapplicable are', () => {
     // "We could not check" and "we checked and it holds" are the two states this
     // whole program exists to stop conflating.
-    expect(CERTIFIABLE).not.toContain('blocked');
+    expect(CERTIFIABLE, req('openwop.it.requirement-ledger.blocked-is-not-certifiable-while-skipped-and-inapplicable-are', 'RFC 0148 §A', 'blocked is not certifiable, while skipped and inapplicable are')).not.toContain('blocked');
     expect(CERTIFIABLE).not.toContain('executed-fail');
     expect([...CERTIFIABLE].sort()).toEqual(['executed-pass', 'inapplicable', 'skipped']);
   });
@@ -78,7 +79,7 @@ describe('RFC 0148 §A — requirement execution ledger', () => {
     const verdict = verifyProfileRequirements('openwop-example', []);
     expect(
       verdict.certifiable,
-      'RFC 0148 §C / gap G6: an empty requirement set is exactly the vacuity that started this program.',
+      req('openwop.it.requirement-ledger.a-profile-with-no-requirements-is-not-certifiable', 'RFC 0148 §A', 'RFC 0148 §C / gap G6: an empty requirement set is exactly the vacuity that started this program.'),
     ).toBe(false);
   });
 
@@ -86,20 +87,20 @@ describe('RFC 0148 §A — requirement execution ledger', () => {
     recordRequirement('openwop.a', 'executed-pass');
     recordRequirement('openwop.b', 'skipped', 'profile not advertised; operator opted out');
     const verdict = verifyProfileRequirements('openwop-example', ['openwop.a', 'openwop.b', 'openwop.c']);
-    expect(verdict.certifiable, 'RFC 0148 §A: a blocked requirement invalidates the claim').toBe(false);
+    expect(verdict.certifiable, req('openwop.it.requirement-ledger.one-blocked-requirement-invalidates-the-whole-profile', 'RFC 0148 §A', 'RFC 0148 §A: a blocked requirement invalidates the claim')).toBe(false);
     expect(verdict.blocking.map((b) => b.requirementId)).toEqual(['openwop.c']);
   });
 
   it('a fully-exercised profile certifies', () => {
     recordRequirement('openwop.a', 'executed-pass');
     recordRequirement('openwop.b', 'inapplicable', 'host advertises no streaming surface');
-    expect(verifyProfileRequirements('openwop-example', ['openwop.a', 'openwop.b']).certifiable).toBe(true);
+    expect(verifyProfileRequirements('openwop-example', ['openwop.a', 'openwop.b']).certifiable, req('openwop.it.requirement-ledger.a-fully-exercised-profile-certifies', 'RFC 0148 §A', 'a fully-exercised profile certifies')).toBe(true);
   });
 
   it('a non-pass disposition without a reason is rejected', () => {
     // A `blocked` with no explanation is an outcome nobody can act on, and it is
     // the shape a lazily-instrumented scenario would emit by default.
-    expect(() => recordRequirement('openwop.a', 'blocked')).toThrow(/without a reason/);
+    expect(() => recordRequirement('openwop.a', 'blocked'), req('openwop.it.requirement-ledger.a-non-pass-disposition-without-a-reason-is-rejected', 'RFC 0148 §A', 'a non-pass disposition without a reason is rejected')).toThrow(/without a reason/);
     expect(() => recordRequirement('openwop.b', 'skipped', '   ')).toThrow(/without a reason/);
     // A pass needs no prose — the assertion itself is the evidence.
     expect(() => recordRequirement('openwop.c', 'executed-pass')).not.toThrow();
@@ -109,14 +110,14 @@ describe('RFC 0148 §A — requirement execution ledger', () => {
     // Silent overwrite would let a later soft-skip bury an earlier real failure
     // — the same conflation running the other direction.
     recordRequirement('openwop.a', 'executed-fail', 'assertion failed against target');
-    expect(() => recordRequirement('openwop.a', 'executed-pass')).toThrow(/already recorded/);
+    expect(() => recordRequirement('openwop.a', 'executed-pass'), req('openwop.it.requirement-ledger.contradictory-dispositions-for-one-requirement-throw-rather-than-last-write-wins', 'RFC 0148 §A', 'contradictory dispositions for one requirement throw rather than last-write-wins')).toThrow(/already recorded/);
     expect(dispositionOf('openwop.a')).toBe('executed-fail');
   });
 
   it('re-recording the same disposition is idempotent', () => {
     recordRequirement('openwop.a', 'executed-pass');
     recordRequirement('openwop.a', 'executed-pass');
-    expect(snapshot()).toHaveLength(1);
+    expect(snapshot(), req('openwop.it.requirement-ledger.re-recording-the-same-disposition-is-idempotent', 'RFC 0148 §A', 're-recording the same disposition is idempotent')).toHaveLength(1);
   });
 });
 
@@ -125,7 +126,7 @@ describe('RFC 0148 §A — the registry binds to the certification floor', () =>
 
   it('every profile with a runtime floor yields requirement IDs', () => {
     // Guard: an empty registry would make the legs below vacuous.
-    expect(allRequirements().length, 'the floor MUST produce requirement IDs').toBeGreaterThan(10);
+    expect(allRequirements().length, req('openwop.it.requirement-ledger.every-profile-with-a-runtime-floor-yields-requirement-ids', 'RFC 0148 §A', 'the floor MUST produce requirement IDs')).toBeGreaterThan(10);
     expect(allRequirements()).toContain('openwop.floor.runs-lifecycle');
     expect(allRequirements()).toContain('openwop.floor.any.interrupt-');
   });
@@ -137,7 +138,7 @@ describe('RFC 0148 §A — the registry binds to the certification floor', () =>
     // the caller to decide; an empty array would silently certify.
     expect(
       requirementsFor('openwop-replay-fork'),
-      'RFC 0148 §C: unevaluable MUST be distinguishable from empty-by-design',
+      req('openwop.it.requirement-ledger.an-unwritten-floor-returns-null-not-an-empty-list-and-so-does-a-conditional-floo', 'RFC 0148 §A', 'RFC 0148 §C: unevaluable MUST be distinguishable from empty-by-design'),
     ).toBeNull();
     expect(requirementsFor('openwop-does-not-exist')).toBeNull();
     // With the document, the advertised branch is required
@@ -151,7 +152,7 @@ describe('RFC 0148 §A — the registry binds to the certification floor', () =>
     expect(allRequirements()).toContain('openwop.floor.replay-fork');
     // the six formerly-unprovable profiles now have floors
     for (const p of ['openwop-interrupts', 'openwop-secrets', 'openwop-provider-policy', 'openwop-memory', 'openwop-trigger-bridge']) {
-      expect((requirementsFor(p) ?? []).length, `${p} floor MUST be non-empty`).toBeGreaterThan(0);
+      expect((requirementsFor(p) ?? []).length, req('openwop.it.requirement-ledger.an-unwritten-floor-returns-null-not-an-empty-list-and-so-does-a-conditional-floo', 'RFC 0148 §A', `${p} floor MUST be non-empty`)).toBeGreaterThan(0);
     }
   });
 
@@ -161,13 +162,13 @@ describe('RFC 0148 §A — the registry binds to the certification floor', () =>
     expect(requirementsFor('openwop-core')).toEqual([]);
     expect(
       verifyProfileRequirements('openwop-core', requirementsFor('openwop-core') ?? []).certifiable,
-      'RFC 0155 §A: an `openwop-core` badge is a statement about a document, not a running system',
+      req('openwop.it.requirement-ledger.a-discovery-only-profile-returns-an-empty-list-which-does-not-certify', 'RFC 0148 §A', 'RFC 0155 §A: an `openwop-core` badge is a statement about a document, not a running system'),
     ).toBe(false);
   });
 
   it('the real core-standard floor does not certify until every requirement is exercised', () => {
     const ids = requirementsFor('openwop-core-standard');
-    expect(ids).not.toBeNull();
+    expect(ids, req('openwop.it.requirement-ledger.the-real-core-standard-floor-does-not-certify-until-every-requirement-is-exercis', 'RFC 0148 §A', 'the real core-standard floor does not certify until every requirement is exercised')).not.toBeNull();
     const requirements = ids as readonly string[];
     // Nothing recorded yet: every requirement is blocked, so the profile fails.
     expect(verifyProfileRequirements('openwop-core-standard', requirements).blocking).toHaveLength(

package/src/scenarios/restart-during-run.test.ts

@@ -36,6 +36,7 @@ import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { spawnHost, type SpawnedHost } from '../lib/multiProcess.js';
+import { req } from '../lib/requirement-ids.js';
 
 const HOST_PACKAGE_DIR =
   process.env.OPENWOP_RESTART_DURING_RUN_HOST_DIR ?? 'examples/hosts/sqlite';
@@ -160,11 +161,11 @@ describe.skipIf(!RUN_THIS_SCENARIO)(
 
         expect(
           terminal,
-          'run MUST reach terminal status on the restarted host within 30s',
+          req('openwop.it.restart-during-run.mid-run-sigkill-on-the-host-process-restart-at-the-same-port-db-resumes-to-termi', 'spec/v1/scale-profiles.md', 'run MUST reach terminal status on the restarted host within 30s'),
         ).not.toBeNull();
         expect(
           terminal?.status,
-          'restart-recovery MUST drive the run to a non-pending terminal status',
+          req('openwop.it.restart-during-run.mid-run-sigkill-on-the-host-process-restart-at-the-same-port-db-resumes-to-termi', 'spec/v1/scale-profiles.md', 'restart-recovery MUST drive the run to a non-pending terminal status'),
         ).toMatch(/^(completed|failed|cancelled)$/);
         // For the cancellable fixture, completed is the expected
         // outcome — the workflow just exits the delay node and finishes.

package/src/scenarios/route-coverage.test.ts

@@ -10,6 +10,7 @@
 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';
 
 interface ErrorEnvelope {
   error?: unknown;
@@ -21,28 +22,28 @@ interface ErrorEnvelope {
 const NOOP_WORKFLOW_ID = 'conformance-noop';
 const SKIP_NO_NOOP = !isFixtureAdvertised(NOOP_WORKFLOW_ID);
 
-function assertCanonicalErrorEnvelope(body: unknown, specSection: string): void {
-  expect(typeof body, driver.describe(specSection, 'error response MUST be a JSON object')).toBe(
+function assertCanonicalErrorEnvelope(requirementId: string, body: unknown, specSection: string): void {
+  expect(typeof body, req(requirementId, specSection, 'error response MUST be a JSON object')).toBe(
     'object',
   );
-  expect(body, driver.describe(specSection, 'error response MUST NOT be null')).not.toBeNull();
+  expect(body, req(requirementId, specSection, 'error response MUST NOT be null')).not.toBeNull();
 
   const env = body as ErrorEnvelope;
-  expect(typeof env.error, driver.describe(
+  expect(typeof env.error, req(requirementId, 
     specSection,
     'error envelope MUST include machine-readable string `error`',
   )).toBe('string');
-  expect(typeof env.message, driver.describe(
+  expect(typeof env.message, req(requirementId, 
     specSection,
     'error envelope MUST include human-readable string `message`',
   )).toBe('string');
 
   if (env.details !== undefined) {
-    expect(typeof env.details, driver.describe(
+    expect(typeof env.details, req(requirementId, 
       specSection,
       'error envelope `details`, when present, MUST be an object',
     )).toBe('object');
-    expect(env.details, driver.describe(
+    expect(env.details, req(requirementId, 
       specSection,
       'error envelope `details`, when present, MUST NOT be null',
     )).not.toBeNull();
@@ -50,7 +51,7 @@ function assertCanonicalErrorEnvelope(body: unknown, specSection: string): void
 
   const allowedKeys = new Set(['error', 'message', 'details']);
   const extras = Object.keys(env).filter((key) => !allowedKeys.has(key));
-  expect(extras, driver.describe(
+  expect(extras, req(requirementId, 
     'schemas/error-envelope.schema.json',
     'error envelope MUST NOT contain top-level keys outside {error,message,details}',
   )).toEqual([]);
@@ -60,17 +61,17 @@ describe.skipIf(SKIP_NO_NOOP)('route coverage: GET /v1/workflows/{workflowId}',
   it('returns the seeded workflow definition for an advertised fixture workflow', async () => {
     const res = await driver.get(`/v1/workflows/${encodeURIComponent(NOOP_WORKFLOW_ID)}`);
 
-    expect(res.status, driver.describe(
+    expect(res.status, req('openwop.it.route-coverage.returns-the-seeded-workflow-definition-for-an-advertised-fixture-workflow', 
       'api/openapi.yaml operationId=getWorkflow',
       'GET /v1/workflows/{workflowId} MUST return 200 for a known workflow',
     )).toBe(200);
 
     const body = res.json as { id?: unknown; nodes?: unknown } | undefined;
-    expect(body?.id, driver.describe(
+    expect(body?.id, req('openwop.it.route-coverage.returns-the-seeded-workflow-definition-for-an-advertised-fixture-workflow', 
       'schemas/workflow-definition.schema.json',
       'workflow definition MUST echo its id',
     )).toBe(NOOP_WORKFLOW_ID);
-    expect(Array.isArray(body?.nodes), driver.describe(
+    expect(Array.isArray(body?.nodes), req('openwop.it.route-coverage.returns-the-seeded-workflow-definition-for-an-advertised-fixture-workflow', 
       'schemas/workflow-definition.schema.json',
       'workflow definition MUST include a nodes array',
     )).toBe(true);
@@ -81,11 +82,11 @@ describe('route coverage: negative operation probes', () => {
   it('GET /v1/workflows/{unknownWorkflowId} returns a canonical 404 or 403 envelope', async () => {
     const res = await driver.get('/v1/workflows/openwop-conformance-missing-workflow');
 
-    expect([403, 404].includes(res.status), driver.describe(
+    expect([403, 404].includes(res.status), req('openwop.it.route-coverage.get-v1-workflows-unknownworkflowid-returns-a-canonical-404-or-403-envelope', 
       'api/openapi.yaml operationId=getWorkflow',
       'unknown workflow MUST return 404 or 403 if existence is protected',
     )).toBe(true);
-    assertCanonicalErrorEnvelope(res.json, 'rest-endpoints.md error envelope');
+    assertCanonicalErrorEnvelope('openwop.it.route-coverage.get-v1-workflows-unknownworkflowid-returns-a-canonical-404-or-403-envelope', res.json, 'rest-endpoints.md error envelope');
   });
 
   it('GET /v1/runs/{runId}/artifacts/{artifactId} for an unknown artifact returns a canonical 404 or 403 envelope', async () => {
@@ -93,11 +94,11 @@ describe('route coverage: negative operation probes', () => {
       '/v1/runs/openwop-conformance-missing-run/artifacts/openwop-conformance-missing-artifact',
     );
 
-    expect([403, 404].includes(res.status), driver.describe(
+    expect([403, 404].includes(res.status), req('openwop.it.route-coverage.get-v1-runs-runid-artifacts-artifactid-for-an-unknown-artifact-returns-a-canonic', 
       'api/openapi.yaml operationId=getArtifact',
       'unknown artifact MUST return 404 or 403 if existence is protected',
     )).toBe(true);
-    assertCanonicalErrorEnvelope(res.json, 'rest-endpoints.md error envelope');
+    assertCanonicalErrorEnvelope('openwop.it.route-coverage.get-v1-runs-runid-artifacts-artifactid-for-an-unknown-artifact-returns-a-canonic', res.json, 'rest-endpoints.md error envelope');
   });
 
   it('POST /v1/webhooks with an invalid URL returns a canonical validation envelope', async () => {
@@ -106,24 +107,24 @@ describe('route coverage: negative operation probes', () => {
       events: ['run.completed'],
     });
 
-    expect(res.status, driver.describe(
+    expect(res.status, req('openwop.it.route-coverage.post-v1-webhooks-with-an-invalid-url-returns-a-canonical-validation-envelope', 
       'api/openapi.yaml operationId=registerWebhook',
       'invalid webhook registration MUST return a 4xx validation response',
     )).toBeGreaterThanOrEqual(400);
     expect(res.status).toBeLessThan(500);
-    assertCanonicalErrorEnvelope(res.json, 'rest-endpoints.md error envelope');
+    assertCanonicalErrorEnvelope('openwop.it.route-coverage.post-v1-webhooks-with-an-invalid-url-returns-a-canonical-validation-envelope', res.json, 'rest-endpoints.md error envelope');
   });
 
   it('DELETE /v1/webhooks/{webhookId} for an unknown subscription returns 204, 404, or 403', async () => {
     const res = await driver.delete('/v1/webhooks/openwop-conformance-missing-webhook');
 
-    expect([204, 403, 404].includes(res.status), driver.describe(
+    expect([204, 403, 404].includes(res.status), req('openwop.it.route-coverage.delete-v1-webhooks-webhookid-for-an-unknown-subscription-returns-204-404-or-403', 
       'api/openapi.yaml operationId=unregisterWebhook',
       'unknown webhook unregister MUST be idempotent 204 or return 404/403',
     )).toBe(true);
 
     if (res.status !== 204) {
-      assertCanonicalErrorEnvelope(res.json, 'rest-endpoints.md error envelope');
+      assertCanonicalErrorEnvelope('openwop.it.route-coverage.delete-v1-webhooks-webhookid-for-an-unknown-subscription-returns-204-404-or-403', res.json, 'rest-endpoints.md error envelope');
     }
   });
 });

package/src/scenarios/run-diff.test.ts

@@ -23,6 +23,8 @@
 
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const HTTP_SKIP = !process.env.OPENWOP_BASE_URL;
 
@@ -59,41 +61,41 @@ async function settle(runId: string): Promise<void> {
 describe.skipIf(HTTP_SKIP)('run-diff: GET /v1/runs/{runId}:diff (RFC 0054)', () => {
   it('diffing a run against itself ⇒ divergedAtSeq null + empty eventDiffs', async (ctx) => {
     const runId = await createRun(FIXTURE_A);
-    if (!runId) { ctx.skip(); return; }
+    if (!runId) { ctx.skip(); return softSkip('blocked', 'precondition not met — `!runId` returned early (seam, prior step, or fixture unavailable)'); }
     await settle(runId);
 
     const res = await driver.get(`/v1/runs/${encodeURIComponent(runId)}:diff?against=${encodeURIComponent(runId)}`);
-    if (res.status === 404) { ctx.skip(); return; } // endpoint not implemented
-    expect(res.status, driver.describe('spec/v1/rest-endpoints.md §:diff', 'self-diff MUST return 200')).toBe(200);
+    if (res.status === 404) { ctx.skip(); return softSkip('blocked', 'precondition not met — `res.status === 404` returned early (endpoint not implemented) (seam, prior step, or fixture unavailable)'); } // endpoint not implemented
+    expect(res.status, req('openwop.it.run-diff.diffing-a-run-against-itself-divergedatseq-null-empty-eventdiffs', 'spec/v1/rest-endpoints.md §:diff', 'self-diff MUST return 200')).toBe(200);
 
     const body = res.json as DiffResponse;
     expect(body.a).toBe(runId);
     expect(body.b).toBe(runId);
     expect(
       body.divergedAtSeq,
-      driver.describe('RFCS/0054 §C', 'identical logs MUST yield divergedAtSeq: null'),
+      req('openwop.it.run-diff.diffing-a-run-against-itself-divergedatseq-null-empty-eventdiffs', 'RFCS/0054 §C', 'identical logs MUST yield divergedAtSeq: null'),
     ).toBeNull();
-    expect(body.eventDiffs, 'identical logs MUST yield an empty eventDiffs array').toEqual([]);
+    expect(body.eventDiffs, req('openwop.it.run-diff.diffing-a-run-against-itself-divergedatseq-null-empty-eventdiffs', 'RFCS/0054 §C', 'identical logs MUST yield an empty eventDiffs array')).toEqual([]);
   });
 
   it('diffing two structurally-different runs ⇒ non-null divergedAtSeq aligned to eventDiffs[0]', async (ctx) => {
     const [ra, rb] = await Promise.all([createRun(FIXTURE_A), createRun(FIXTURE_B)]);
-    if (!ra || !rb) { ctx.skip(); return; }
+    if (!ra || !rb) { ctx.skip(); return softSkip('blocked', 'precondition not met — `!ra || !rb` returned early (seam, prior step, or fixture unavailable)'); }
     await Promise.all([settle(ra), settle(rb)]);
 
     const res = await driver.get(`/v1/runs/${encodeURIComponent(ra)}:diff?against=${encodeURIComponent(rb)}`);
-    if (res.status === 404) { ctx.skip(); return; }
+    if (res.status === 404) { ctx.skip(); return softSkip('blocked', 'precondition not met — `res.status === 404` returned early (seam, prior step, or fixture unavailable)'); }
     expect(res.status).toBe(200);
 
     const body = res.json as DiffResponse;
     expect(
       typeof body.divergedAtSeq === 'number' && body.divergedAtSeq >= 0,
-      driver.describe('RFCS/0054 §C', 'structurally-different runs MUST report a non-null integer divergedAtSeq'),
+      req('openwop.it.run-diff.diffing-two-structurally-different-runs-non-null-divergedatseq-aligned-to-eventd', 'RFCS/0054 §C', 'structurally-different runs MUST report a non-null integer divergedAtSeq'),
     ).toBe(true);
-    expect(body.eventDiffs.length, 'divergent runs MUST report at least one eventDiff').toBeGreaterThan(0);
+    expect(body.eventDiffs.length, req('openwop.it.run-diff.diffing-two-structurally-different-runs-non-null-divergedatseq-aligned-to-eventd', 'RFCS/0054 §C', 'divergent runs MUST report at least one eventDiff')).toBeGreaterThan(0);
     expect(
       body.eventDiffs[0]?.seq,
-      driver.describe('RFCS/0054 §C', 'eventDiffs MUST begin at divergedAtSeq'),
+      req('openwop.it.run-diff.diffing-two-structurally-different-runs-non-null-divergedatseq-aligned-to-eventd', 'RFCS/0054 §C', 'eventDiffs MUST begin at divergedAtSeq'),
     ).toBe(body.divergedAtSeq);
     for (const d of body.eventDiffs) {
       expect(['added', 'removed', 'changed']).toContain(d.op);
@@ -102,42 +104,42 @@ describe.skipIf(HTTP_SKIP)('run-diff: GET /v1/runs/{runId}:diff (RFC 0054)', ()
 
   it('response conforms to run-diff-response.schema.json and stateDiff is redaction-safe', async (ctx) => {
     const [ra, rb] = await Promise.all([createRun(FIXTURE_A), createRun(FIXTURE_B)]);
-    if (!ra || !rb) { ctx.skip(); return; }
+    if (!ra || !rb) { ctx.skip(); return softSkip('blocked', 'precondition not met — `!ra || !rb` returned early (seam, prior step, or fixture unavailable)'); }
     await Promise.all([settle(ra), settle(rb)]);
 
     const res = await driver.get(`/v1/runs/${encodeURIComponent(ra)}:diff?against=${encodeURIComponent(rb)}`);
-    if (res.status === 404) { ctx.skip(); return; }
+    if (res.status === 404) { ctx.skip(); return softSkip('blocked', 'precondition not met — `res.status === 404` returned early (seam, prior step, or fixture unavailable)'); }
     expect(res.status).toBe(200);
 
     const body = res.json as DiffResponse;
-    expect(typeof body.a === 'string' && typeof body.b === 'string', 'a + b MUST be strings').toBe(true);
-    expect(Array.isArray(body.eventDiffs), 'eventDiffs MUST be an array').toBe(true);
-    expect(body.stateDiff !== null && typeof body.stateDiff === 'object', 'stateDiff MUST be an object').toBe(true);
+    expect(typeof body.a === 'string' && typeof body.b === 'string', req('openwop.it.run-diff.response-conforms-to-run-diff-response-schema-json-and-statediff-is-redaction-sa', 'RFCS/0054 §B', 'a + b MUST be strings')).toBe(true);
+    expect(Array.isArray(body.eventDiffs), req('openwop.it.run-diff.response-conforms-to-run-diff-response-schema-json-and-statediff-is-redaction-sa', 'RFCS/0054 §B', 'eventDiffs MUST be an array')).toBe(true);
+    expect(body.stateDiff !== null && typeof body.stateDiff === 'object', req('openwop.it.run-diff.response-conforms-to-run-diff-response-schema-json-and-statediff-is-redaction-sa', 'RFCS/0054 §B', 'stateDiff MUST be an object')).toBe(true);
     // Redaction-safe: no credential-shaped material leaks into the diff.
     const serialized = JSON.stringify(body.stateDiff);
     expect(
       /sk-|api[_-]?key|secret|bearer\s/i.test(serialized),
-      driver.describe('RFCS/0054 §B', 'stateDiff MUST be redaction-safe — no credential material'),
+      req('openwop.it.run-diff.response-conforms-to-run-diff-response-schema-json-and-statediff-is-redaction-sa', 'RFCS/0054 §B', 'stateDiff MUST be redaction-safe — no credential material'),
     ).toBe(false);
   });
 
   it('missing `against` ⇒ 400; nonexistent `against` ⇒ 404 (access boundary)', async (ctx) => {
     const runId = await createRun(FIXTURE_A);
-    if (!runId) { ctx.skip(); return; }
+    if (!runId) { ctx.skip(); return softSkip('blocked', 'precondition not met — `!runId` returned early (seam, prior step, or fixture unavailable)'); }
 
     const probe = await driver.get(`/v1/runs/${encodeURIComponent(runId)}:diff?against=${encodeURIComponent(runId)}`);
-    if (probe.status === 404) { ctx.skip(); return; } // endpoint not implemented at all
+    if (probe.status === 404) { ctx.skip(); return softSkip('blocked', 'precondition not met — `probe.status === 404` returned early (endpoint not implemented at all) (seam, prior step, or fixture unavailable)'); } // endpoint not implemented at all
 
     const missing = await driver.get(`/v1/runs/${encodeURIComponent(runId)}:diff`);
     expect(
       missing.status,
-      driver.describe('api/openapi.yaml §diffRun', 'missing required `against` query param MUST return 400'),
+      req('openwop.it.run-diff.missing-against-400-nonexistent-against-404-access-boundary', 'api/openapi.yaml §diffRun', 'missing required `against` query param MUST return 400'),
     ).toBe(400);
 
     const nonexistent = await driver.get(`/v1/runs/${encodeURIComponent(runId)}:diff?against=does-not-exist-${Date.now()}`);
     expect(
       nonexistent.status,
-      driver.describe('RFCS/0054 §A', 'diffing against a run the caller cannot read/that does not exist MUST NOT return 200'),
+      req('openwop.it.run-diff.missing-against-400-nonexistent-against-404-access-boundary', 'RFCS/0054 §A', 'diffing against a run the caller cannot read/that does not exist MUST NOT return 200'),
     ).toBe(404);
   });
 });

package/src/scenarios/run-execution-bounds-shape.test.ts

@@ -32,6 +32,8 @@ import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 interface DiscoveryLimits {
   maxRunDurationMs?: number;
@@ -59,10 +61,10 @@ async function readLimits(): Promise<DiscoveryLimits | null> {
 describe('run-execution-bounds-shape: advertisement shape (RFC 0058)', () => {
   it('maxRunDurationMs is an integer >= 1000 when present', async () => {
     const limits = await readLimits();
-    if (limits?.maxRunDurationMs === undefined) return; // not advertised
+    if (limits?.maxRunDurationMs === undefined) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `limits?.maxRunDurationMs === undefined` returned early (not advertised)'); // not advertised
     expect(
       Number.isInteger(limits.maxRunDurationMs) && limits.maxRunDurationMs >= 1000,
-      driver.describe(
+      req('openwop.it.run-execution-bounds-shape.maxrundurationms-is-an-integer-1000-when-present', 
         'capabilities.schema.json §limits.maxRunDurationMs',
         `capabilities.limits.maxRunDurationMs MUST be an integer >= 1000, got: ${limits.maxRunDurationMs}`,
       ),
@@ -71,10 +73,10 @@ describe('run-execution-bounds-shape: advertisement shape (RFC 0058)', () => {
 
   it('maxLoopIterations is an integer >= 1 when present', async () => {
     const limits = await readLimits();
-    if (limits?.maxLoopIterations === undefined) return; // not advertised
+    if (limits?.maxLoopIterations === undefined) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `limits?.maxLoopIterations === undefined` returned early (not advertised)'); // not advertised
     expect(
       Number.isInteger(limits.maxLoopIterations) && limits.maxLoopIterations >= 1,
-      driver.describe(
+      req('openwop.it.run-execution-bounds-shape.maxloopiterations-is-an-integer-1-when-present', 
         'capabilities.schema.json §limits.maxLoopIterations',
         `capabilities.limits.maxLoopIterations MUST be an integer >= 1, got: ${limits.maxLoopIterations}`,
       ),
@@ -92,18 +94,18 @@ describe.skipIf(SKIP_TIMEOUT)('run-execution-bounds: run-duration breach (RFC 00
       workflowId: TIMEOUT_FIXTURE,
       configurable: { runTimeoutMs: 1000 },
     });
-    expect(create.status, driver.describe(
+    expect(create.status, req('openwop.it.run-execution-bounds-shape.a-run-with-runtimeoutms-below-its-real-duration-fails-with-run-timeout-cap-breac', 
       'rest-endpoints.md POST /v1/runs',
       'run creation MUST accept a runTimeoutMs override',
     )).toBe(201);
     const runId = (create.json as { runId: string }).runId;
 
     const terminal = await pollUntilTerminal(runId);
-    expect(terminal.status, driver.describe(
+    expect(terminal.status, req('openwop.it.run-execution-bounds-shape.a-run-with-runtimeoutms-below-its-real-duration-fails-with-run-timeout-cap-breac', 
       'run-options.md §runTimeoutMs',
       'a run exceeding its runTimeoutMs MUST reach terminal `failed`',
     )).toBe('failed');
-    expect(terminal.error?.code, driver.describe(
+    expect(terminal.error?.code, req('openwop.it.run-execution-bounds-shape.a-run-with-runtimeoutms-below-its-real-duration-fails-with-run-timeout-cap-breac', 
       'rest-endpoints.md §run_timeout',
       'RunSnapshot.error.code MUST equal "run_timeout" on wall-clock timeout',
     )).toBe('run_timeout');
@@ -113,12 +115,12 @@ describe.skipIf(SKIP_TIMEOUT)('run-execution-bounds: run-duration breach (RFC 00
     );
     const events = (eventsRes.json as { events?: RunEvent[] } | undefined)?.events ?? [];
     const breach = events.find((e) => e.type === 'cap.breached');
-    expect(breach, driver.describe(
+    expect(breach, req('openwop.it.run-execution-bounds-shape.a-run-with-runtimeoutms-below-its-real-duration-fails-with-run-timeout-cap-breac', 
       'capabilities.md §Engine-enforced limits',
       'a cap.breached event MUST be emitted on run-duration breach',
     )).toBeDefined();
     const payload = breach!.payload as { kind?: string; limit?: number; observed?: number } | undefined;
-    expect(payload?.kind, driver.describe(
+    expect(payload?.kind, req('openwop.it.run-execution-bounds-shape.a-run-with-runtimeoutms-below-its-real-duration-fails-with-run-timeout-cap-breac', 
       'run-event-payloads.schema.json §capBreached.kind',
       'cap.breached payload MUST carry kind="run-duration"',
     )).toBe('run-duration');
@@ -132,14 +134,14 @@ describe.skipIf(SKIP_TIMEOUT)('run-execution-bounds: run-duration breach (RFC 00
     // not report the observed values.
     expect(
       typeof payload?.observed,
-      driver.describe(
+      req('openwop.it.run-execution-bounds-shape.a-run-with-runtimeoutms-below-its-real-duration-fails-with-run-timeout-cap-breac', 
         'run-event-payloads.schema.json §capBreached.observed',
         `cap.breached MUST carry a numeric \`observed\`; got ${JSON.stringify(payload?.observed)}`,
       ),
     ).toBe('number');
     expect(
       typeof payload?.limit,
-      driver.describe(
+      req('openwop.it.run-execution-bounds-shape.a-run-with-runtimeoutms-below-its-real-duration-fails-with-run-timeout-cap-breac', 
         'run-event-payloads.schema.json §capBreached.limit',
         `cap.breached MUST carry a numeric \`limit\`; got ${JSON.stringify(payload?.limit)}`,
       ),
@@ -159,7 +161,7 @@ describe.skipIf(SKIP_TIMEOUT)('run-execution-bounds: run-duration breach (RFC 00
     const { observed = NaN, limit = NaN } = payload ?? {};
     expect(
       observed > limit,
-      driver.describe(
+      req('openwop.it.run-execution-bounds-shape.a-run-with-runtimeoutms-below-its-real-duration-fails-with-run-timeout-cap-breac', 
         'run-event-payloads.schema.json §capBreached.observed',
         `observed (elapsedMs) MUST be strictly greater than limit (resolved timeout). ` +
           `Got observed=${observed}, limit=${limit}` +

package/src/scenarios/run-transport-economy.test.ts

@@ -40,6 +40,8 @@ import { driver } from '../lib/driver.js';
 import { loadEnv } from '../lib/env.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 import { pollUntilStatus, pollUntilTerminal } from '../lib/polling.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const HTTP_SKIP = !process.env.OPENWOP_BASE_URL;
 const APPROVAL_FIXTURE = 'conformance-approval';
@@ -80,7 +82,7 @@ describe.skipIf(HTTP_SKIP)('run-transport-economy: conditional GET on run reads
     const caps = await readRestTransport();
     if (caps?.conditionalRunGet !== true) {
       ctx.skip(); // host does not advertise restTransport.conditionalRunGet
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `caps?.conditionalRunGet !== true` returned early');
     }
 
     // Use the approval fixture: it parks at a stable `waiting-approval` state,
@@ -88,7 +90,7 @@ describe.skipIf(HTTP_SKIP)('run-transport-economy: conditional GET on run reads
     const create = await driver.post('/v1/runs', { workflowId: APPROVAL_FIXTURE });
     if (create.status === 404 || create.status === 422) {
       ctx.skip(); // fixture not advertised by this host
-      return;
+      return softSkip('blocked', 'precondition not met — `create.status === 404 || create.status === 422` returned early (seam, prior step, or fixture unavailable)');
     }
     expect(create.status).toBe(201);
     const runId = (create.json as { runId: string }).runId;
@@ -100,7 +102,7 @@ describe.skipIf(HTTP_SKIP)('run-transport-economy: conditional GET on run reads
     const etagSuspended = etagOf(suspendedRead);
     expect(
       etagSuspended,
-      driver.describe(
+      req('openwop.it.run-transport-economy.emits-a-sequence-derived-strong-etag-honors-if-none-match-with-304-and-rotates-t', 
         'rest-endpoints.md §GET /v1/runs/{runId} conditional read (RFC 0115)',
         'a host advertising restTransport.conditionalRunGet MUST return a strong ETag on the 200',
       ),
@@ -112,14 +114,14 @@ describe.skipIf(HTTP_SKIP)('run-transport-economy: conditional GET on run reads
     });
     expect(
       revalidate.status,
-      driver.describe(
+      req('openwop.it.run-transport-economy.emits-a-sequence-derived-strong-etag-honors-if-none-match-with-304-and-rotates-t', 
         'rest-endpoints.md §GET /v1/runs/{runId} conditional read (RFC 0115)',
         'If-None-Match matching the current ETag MUST return 304 Not Modified',
       ),
     ).toBe(304);
     expect(
       revalidate.text,
-      driver.describe(
+      req('openwop.it.run-transport-economy.emits-a-sequence-derived-strong-etag-honors-if-none-match-with-304-and-rotates-t', 
         'rest-endpoints.md §GET /v1/runs/{runId} conditional read (RFC 0115)',
         '304 Not Modified MUST carry no body',
       ),
@@ -141,7 +143,7 @@ describe.skipIf(HTTP_SKIP)('run-transport-economy: conditional GET on run reads
     expect(etagCompleted).toBeTruthy();
     expect(
       etagCompleted,
-      driver.describe(
+      req('openwop.it.run-transport-economy.emits-a-sequence-derived-strong-etag-honors-if-none-match-with-304-and-rotates-t', 
         'rest-endpoints.md §GET /v1/runs/{runId} conditional read (RFC 0115)',
         'the ETag MUST change once the run advances (it is derived from the latest event-log sequence); a stable ETag across an observable transition would leave a 304 stale',
       ),
@@ -153,7 +155,7 @@ describe.skipIf(HTTP_SKIP)('run-transport-economy: conditional GET on run reads
     });
     expect(
       revalidateTerminal.status,
-      driver.describe(
+      req('openwop.it.run-transport-economy.emits-a-sequence-derived-strong-etag-honors-if-none-match-with-304-and-rotates-t', 
         'rest-endpoints.md §GET /v1/runs/{runId} conditional read (RFC 0115)',
         'the terminal ETag MUST be stable — If-None-Match against it returns 304',
       ),
@@ -167,14 +169,14 @@ describe.skipIf(HTTP_SKIP)('run-transport-economy: Content-Encoding round-trips
     const encodings = advertisedEncodings(caps);
     if (encodings.length === 0) {
       ctx.skip(); // host advertises no run-read content encodings
-      return;
+      return softSkip('blocked', 'precondition not met — `encodings.length === 0` returned early (seam, prior step, or fixture unavailable)');
     }
 
     // A terminal run gives a stable body to compare encodings against.
     const create = await driver.post('/v1/runs', { workflowId: NOOP_FIXTURE });
     if (create.status === 404 || create.status === 422) {
       ctx.skip();
-      return;
+      return softSkip('blocked', 'precondition not met — `create.status === 404 || create.status === 422` returned early (seam, prior step, or fixture unavailable)');
     }
     expect(create.status).toBe(201);
     const runId = (create.json as { runId: string }).runId;
@@ -219,7 +221,7 @@ describe.skipIf(HTTP_SKIP)('run-transport-economy: Content-Encoding round-trips
       const contentEncoding = res.headers.get('content-encoding');
       expect(
         contentEncoding,
-        driver.describe(
+        req('openwop.it.run-transport-economy.each-advertised-contentencodings-value-decodes-to-the-identity-body-byte-for-byt', 
           'rest-endpoints.md §GET /v1/runs/{runId} conditional read + Content-Encoding (RFC 0115)',
           `a host advertising restTransport.contentEncodings:["...","${enc}"] MUST set Content-Encoding: ${enc} when that encoding is requested`,
         ),
@@ -249,7 +251,7 @@ describe.skipIf(HTTP_SKIP)('run-transport-economy: Content-Encoding round-trips
       }
       expect(
         decoded.equals(identityBytes),
-        driver.describe(
+        req('openwop.it.run-transport-economy.each-advertised-contentencodings-value-decodes-to-the-identity-body-byte-for-byt', 
           'rest-endpoints.md §GET /v1/runs/{runId} conditional read + Content-Encoding (RFC 0115)',
           `the ${enc}-decoded body MUST be byte-identical to the identity body (Content-Encoding MUST NOT alter decoded bytes or semantics)`,
         ),