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

package/src/scenarios/envelope-refusal-shape.test.ts

@@ -64,10 +64,10 @@ async function emit(input: Record<string, unknown>): Promise<{ status: number; b
 describe.skipIf(HTTP_SKIP)('envelope-refusal-shape: seam emission (RFC 0032 §B.3 MUST)', () => {
   it('accepts a well-formed `envelope.refusal` payload + writes it to the test event log', async () => {
     const d = await readDiscovery();
-    if (d === null) return;
+    if (d === null) return softSkip('blocked', 'precondition not met — `d === null` returned early (seam, prior step, or fixture unavailable)');
     const reliability = capabilityFamily<{ reasoning?: Record<string, unknown>; tierOneSubsetCompliance?: unknown; reliability?: { completion?: Record<string, unknown> } & Record<string, unknown> }>(d, 'envelopes')?.reliability;
-    if (!reliability || reliability.supported !== true) return;
-    if (!Array.isArray(reliability.events) || !(reliability.events as unknown[]).includes('envelope.refusal')) return;
+    if (!reliability || reliability.supported !== true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!reliability || reliability.supported !== true` returned early');
+    if (!Array.isArray(reliability.events) || !(reliability.events as unknown[]).includes('envelope.refusal')) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!Array.isArray(reliability.events) || !(reliability.events as unknown[]).includes(\'envelope.refusal\')` returned early');
 
     const r = await emit({
       runId: 'conformance-refusal-1',
@@ -81,10 +81,10 @@ describe.skipIf(HTTP_SKIP)('envelope-refusal-shape: seam emission (RFC 0032 §B.
       },
       nodeId: 'writer',
     });
-    if (r.status === 404) return;
+    if (r.status === 404) return softSkip('blocked', 'precondition not met — `r.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(
       r.status,
-      driver.describe(
+      req('openwop.it.envelope-refusal-shape.accepts-a-well-formed-envelope-refusal-payload-writes-it-to-the-test-event-log', 
         'schemas/run-event-payloads.schema.json §envelopeRefusal',
         'a payload with the required {nodeId, provider, model} fields MUST be accepted by the seam',
       ),
@@ -108,10 +108,10 @@ describe.skipIf(HTTP_SKIP)('envelope-refusal-shape: seam emission (RFC 0032 §B.
         safetyCategory: 'harmful-content',
       },
     });
-    if (r.status === 404) return;
+    if (r.status === 404) return softSkip('blocked', 'precondition not met — `r.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(
       r.status,
-      driver.describe(
+      req('openwop.it.envelope-refusal-shape.rejects-payloads-with-refusaltext-containing-a-secret-canary-substring-byok-leak', 
         'SECURITY/invariants.yaml §envelope-refusal-no-prompt-leak',
         'envelope.refusal.refusalText MUST be passed through the host BYOK redaction harness; seam refuses payloads carrying secret-canary-* substrings (defense-in-depth CI gate per RFC 0032 §B.3 + §G)',
       ),
@@ -130,8 +130,8 @@ describe.skipIf(HTTP_SKIP)('envelope-refusal-shape: seam emission (RFC 0032 §B.
         credentialRef: 'secret-byok-abc123', // forbidden
       },
     });
-    if (r.status === 404) return;
-    expect(r.status).toBe(400);
+    if (r.status === 404) return softSkip('blocked', 'precondition not met — `r.status === 404` returned early (seam, prior step, or fixture unavailable)');
+    expect(r.status, req('openwop.it.envelope-refusal-shape.rejects-payloads-with-a-top-level-credentialref-field', 'RFC 0032 §B.3', 'rejects payloads with a top-level `credentialRef` field')).toBe(400);
     expect(readErrorCode(r.body)).toBe('envelope_reliability_credential_leak');
   });
 
@@ -145,8 +145,8 @@ describe.skipIf(HTTP_SKIP)('envelope-refusal-shape: seam emission (RFC 0032 §B.
         model: 'claude-3-5-sonnet',
       },
     });
-    if (r.status === 404) return;
-    expect(r.status).toBe(400);
+    if (r.status === 404) return softSkip('blocked', 'precondition not met — `r.status === 404` returned early (seam, prior step, or fixture unavailable)');
+    expect(r.status, req('openwop.it.envelope-refusal-shape.rejects-payloads-missing-required-provider-field', 'RFC 0032 §B.3', 'rejects payloads missing required `provider` field')).toBe(400);
     expect(readErrorCode(r.body)).toBe('invalid_argument');
   });
 });
@@ -154,25 +154,25 @@ describe.skipIf(HTTP_SKIP)('envelope-refusal-shape: seam emission (RFC 0032 §B.
 describe.skipIf(HTTP_SKIP)('envelope-refusal-shape: advertisement contract (RFC 0032 §C)', () => {
   it('capabilities.envelopes.reliability (when supported: true with non-empty events[]) MUST list both MUST-tier events', async () => {
     const d = await readDiscovery();
-    if (d === null) return;
+    if (d === null) return softSkip('blocked', 'precondition not met — `d === null` returned early (seam, prior step, or fixture unavailable)');
     const reliability = capabilityFamily<{ reasoning?: Record<string, unknown>; tierOneSubsetCompliance?: unknown; reliability?: { completion?: Record<string, unknown> } & Record<string, unknown> }>(d, 'envelopes')?.reliability;
-    if (!reliability || reliability.supported !== true) return;
+    if (!reliability || reliability.supported !== true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!reliability || reliability.supported !== true` returned early');
     // Hosts running the legacy undifferentiated retry loop advertise
     // `events: []` (per the OPENWOP_ENVELOPE_RELIABILITY_END_TO_END=false
     // operator override). The two MUST-tier events still surface through
     // the test seam in that case; the advertisement-shape MUST applies
     // only when events[] is non-empty.
-    if (!Array.isArray(reliability.events) || (reliability.events as unknown[]).length === 0) return;
+    if (!Array.isArray(reliability.events) || (reliability.events as unknown[]).length === 0) return softSkip('blocked', 'precondition not met — `!Array.isArray(reliability.events) || (reliability.events as unknown[]).length === 0` returned early (Hosts running the legacy undifferentiated retry loop advertise `events: []` (per the OPENWO…');
     expect(
       (reliability.events as unknown[]).includes('envelope.refusal'),
-      driver.describe(
+      req('openwop.it.envelope-refusal-shape.capabilities-envelopes-reliability-when-supported-true-with-non-empty-events-mus', 
         'RFCS/0032-envelope-reliability-events.md §C',
         'hosts that advertise reliability.supported: true with non-empty events[] MUST include envelope.refusal (one of the two MUST-tier events per RFC 0032 §C normative text)',
       ),
     ).toBe(true);
     expect(
       (reliability.events as unknown[]).includes('envelope.retry.exhausted'),
-      driver.describe(
+      req('openwop.it.envelope-refusal-shape.capabilities-envelopes-reliability-when-supported-true-with-non-empty-events-mus', 
         'RFCS/0032-envelope-reliability-events.md §C',
         'hosts that advertise reliability.supported: true with non-empty events[] MUST also include envelope.retry.exhausted (the other MUST-tier event; both MUSTs land together)',
       ),
@@ -192,6 +192,8 @@ describe.skipIf(HTTP_SKIP)('envelope-refusal-shape: advertisement contract (RFC
 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';
 
 const E2E_FIXTURE = 'conformance-envelope-refusal';
 const E2E_NODE_ID = 'structured-call';
@@ -224,17 +226,17 @@ async function runE2eAndRead(): Promise<{ events: E2eEvent[]; terminal: unknown
 
 describe.skipIf(HTTP_SKIP)('envelope-refusal-shape: end-to-end refusal through dispatchStructured', () => {
   it('when mock provider returns stopReason: "safety" with refusalText, host emits exactly one envelope.refusal event AND does NOT retry', async () => {
-    if (!isFixtureAdvertised(E2E_FIXTURE)) return;
+    if (!isFixtureAdvertised(E2E_FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(E2E_FIXTURE)` returned early');
     const seed = await programMockRefusal('I cannot help with that — safety filter triggered.');
-    if (seed.status === 404) return;
+    if (seed.status === 404) return softSkip('blocked', 'precondition not met — `seed.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(seed.status).toBe(200);
 
     const result = await runE2eAndRead();
-    if (result === null) return;
+    if (result === null) return softSkip('blocked', 'precondition not met — `result === null` returned early (seam, prior step, or fixture unavailable)');
     const refusals = result.events.filter((e) => e.type === 'envelope.refusal');
     expect(
       refusals.length,
-      driver.describe(
+      req('openwop.it.envelope-refusal-shape.when-mock-provider-returns-stopreason-safety-with-refusaltext-host-emits-exactly', 
         'RFCS/0032-envelope-reliability-events.md §B.3',
         'exactly one envelope.refusal event MUST fire on provider safety-stop',
       ),
@@ -243,7 +245,7 @@ describe.skipIf(HTTP_SKIP)('envelope-refusal-shape: end-to-end refusal through d
     const retries = result.events.filter((e) => e.type === 'envelope.retry.attempted');
     expect(
       retries.length,
-      driver.describe(
+      req('openwop.it.envelope-refusal-shape.when-mock-provider-returns-stopreason-safety-with-refusaltext-host-emits-exactly', 
         'RFCS/0033-envelope-completion-contract.md §D',
         'host MUST NOT retry after envelope.refusal (refusal is terminal — retrying with prompt mutation creates a circumvention concern)',
       ),
@@ -251,16 +253,16 @@ describe.skipIf(HTTP_SKIP)('envelope-refusal-shape: end-to-end refusal through d
   });
 
   it('node fails with RunSnapshot.error.code = "envelope_refusal" per RFC 0033 §F', async () => {
-    if (!isFixtureAdvertised(E2E_FIXTURE)) return;
+    if (!isFixtureAdvertised(E2E_FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(E2E_FIXTURE)` returned early');
     const seed = await programMockRefusal('Refusal text for terminal-error-code assertion.');
-    if (seed.status === 404) return;
+    if (seed.status === 404) return softSkip('blocked', 'precondition not met — `seed.status === 404` returned early (seam, prior step, or fixture unavailable)');
 
     const result = await runE2eAndRead();
-    if (result === null) return;
+    if (result === null) return softSkip('blocked', 'precondition not met — `result === null` returned early (seam, prior step, or fixture unavailable)');
     const code = (result.terminal as { error?: { code?: string } }).error?.code;
     expect(
       code,
-      driver.describe(
+      req('openwop.it.envelope-refusal-shape.node-fails-with-runsnapshot-error-code-envelope-refusal-per-rfc-0033-f', 
         'RFCS/0033-envelope-completion-contract.md §F',
         'refusal-driven failure MUST surface as RunSnapshot.error.code = envelope_refusal (renamed 2026-05-21 from envelope_refused_by_provider per the MyndHyve adoption-feedback amendment)',
       ),
@@ -268,21 +270,21 @@ describe.skipIf(HTTP_SKIP)('envelope-refusal-shape: end-to-end refusal through d
   });
 
   it('RunSnapshot.error.message MUST NOT echo the providers refusal text (SECURITY invariant envelope-refusal-no-prompt-leak)', async () => {
-    if (!isFixtureAdvertised(E2E_FIXTURE)) return;
+    if (!isFixtureAdvertised(E2E_FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(E2E_FIXTURE)` returned early');
     // A distinctive refusal text so the message-no-echo assertion has
     // a unique substring to scan for. Production refusal texts may
     // contain prompt content; the host MUST keep it off the error
     // message surface (event log only, scrubbed via SR-1).
     const REFUSAL_TEXT = 'REFUSAL-CANARY-A8F3-do-not-echo-this-substring-into-RunSnapshot.error.message';
     const seed = await programMockRefusal(REFUSAL_TEXT);
-    if (seed.status === 404) return;
+    if (seed.status === 404) return softSkip('blocked', 'precondition not met — `seed.status === 404` returned early (seam, prior step, or fixture unavailable)');
 
     const result = await runE2eAndRead();
-    if (result === null) return;
+    if (result === null) return softSkip('blocked', 'precondition not met — `result === null` returned early (seam, prior step, or fixture unavailable)');
     const message = (result.terminal as { error?: { message?: string } }).error?.message ?? '';
     expect(
       message.includes(REFUSAL_TEXT),
-      driver.describe(
+      req('openwop.it.envelope-refusal-shape.runsnapshot-error-message-must-not-echo-the-providers-refusal-text-security-inva', 
         'SECURITY/invariants.yaml §envelope-refusal-no-prompt-leak',
         'RunSnapshot.error.message MUST NOT echo refusalText — the safety-filter text may contain prompt content; spec-compliant emission carries it only on the envelope.refusal event payload (subject to SR-1 redaction at the eventLog.append boundary)',
       ),

package/src/scenarios/envelope-rendering-hint.test.ts

@@ -24,6 +24,7 @@ import addFormats from 'ajv-formats';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { SCHEMAS_DIR } from '../lib/paths.js';
+import { req } from '../lib/requirement-ids.js';
 
 function compileEnvelope(): ReturnType<Ajv2020['compile']> {
   const ajv = new Ajv2020({ strict: false, allErrors: true });
@@ -57,7 +58,7 @@ describe('envelope-rendering-hint: meta.rendering shape (RFC 0055 §B)', () => {
     const ok = validate(env);
     expect(
       ok,
-      'ai-envelope.md §"Rendering hints": ' + `meta.rendering MUST validate; errors: ${JSON.stringify(validate.errors)}`,
+      req('openwop.it.envelope-rendering-hint.accepts-an-envelope-carrying-a-well-formed-meta-rendering-hint', 'RFC 0055 §B', 'ai-envelope.md §"Rendering hints": ' + `meta.rendering MUST validate; errors: ${JSON.stringify(validate.errors)}`),
     ).toBe(true);
   });
 
@@ -65,7 +66,7 @@ describe('envelope-rendering-hint: meta.rendering shape (RFC 0055 §B)', () => {
     const ok = validate(baseEnvelope);
     expect(
       ok,
-      'ai-envelope.md §"Rendering hints": ' + 'meta.rendering MUST be optional — envelopes omitting it still validate',
+      req('openwop.it.envelope-rendering-hint.accepts-an-envelope-with-no-meta-rendering-proves-the-property-is-optional', 'RFC 0055 §B', 'ai-envelope.md §"Rendering hints": ' + 'meta.rendering MUST be optional — envelopes omitting it still validate'),
     ).toBe(true);
   });
 
@@ -77,7 +78,7 @@ describe('envelope-rendering-hint: meta.rendering shape (RFC 0055 §B)', () => {
     const ok = validate(env);
     expect(
       ok,
-      'ai-envelope.md §"Rendering hints": ' + 'display is a closed enum — unknown families MUST be rejected',
+      req('openwop.it.envelope-rendering-hint.rejects-an-unknown-display-value-closed-enum', 'RFC 0055 §B', 'ai-envelope.md §"Rendering hints": ' + 'display is a closed enum — unknown families MUST be rejected'),
     ).toBe(false);
   });
 
@@ -89,7 +90,7 @@ describe('envelope-rendering-hint: meta.rendering shape (RFC 0055 §B)', () => {
     const ok = validate(env);
     expect(
       ok,
-      'ai-envelope.md §"Rendering hints": ' + 'rendering is additionalProperties:false',
+      req('openwop.it.envelope-rendering-hint.rejects-an-unknown-property-under-rendering-additionalproperties-false', 'RFC 0055 §B', 'ai-envelope.md §"Rendering hints": ' + 'rendering is additionalProperties:false'),
     ).toBe(false);
   });
 });

package/src/scenarios/envelope-retry-attempted.test.ts

@@ -58,12 +58,12 @@ async function readDiscovery(): Promise<DiscoveryDoc | null> {
 describe.skipIf(HTTP_SKIP)('envelope-retry-attempted: advertisement shape (RFC 0032 §C)', () => {
   it('capabilities.envelopes.reliability (when present) conforms to RFC 0032 §C', async () => {
     const d = await readDiscovery();
-    if (d === null) return;
+    if (d === null) return softSkip('blocked', 'precondition not met — `d === null` returned early (seam, prior step, or fixture unavailable)');
     const reliability = capabilityFamily<{ reasoning?: Record<string, unknown>; tierOneSubsetCompliance?: unknown; reliability?: { completion?: Record<string, unknown> } & Record<string, unknown> }>(d, 'envelopes')?.reliability;
-    if (reliability === undefined) return;
-    expect(typeof reliability.supported, 'reliability.supported MUST be boolean').toBe('boolean');
+    if (reliability === undefined) return softSkip('blocked', 'precondition not met — `reliability === undefined` returned early (seam, prior step, or fixture unavailable)');
+    expect(typeof reliability.supported, req('openwop.it.envelope-retry-attempted.capabilities-envelopes-reliability-when-present-conforms-to-rfc-0032-c', 'RFC 0032 §C', 'reliability.supported MUST be boolean')).toBe('boolean');
     if (reliability.events !== undefined) {
-      expect(Array.isArray(reliability.events), 'reliability.events MUST be an array').toBe(true);
+      expect(Array.isArray(reliability.events), req('openwop.it.envelope-retry-attempted.capabilities-envelopes-reliability-when-present-conforms-to-rfc-0032-c', 'RFC 0032 §C', 'reliability.events MUST be an array')).toBe(true);
       const RFC_0032_EVENTS = [
         'envelope.retry.attempted',
         'envelope.retry.exhausted',
@@ -73,7 +73,7 @@ describe.skipIf(HTTP_SKIP)('envelope-retry-attempted: advertisement shape (RFC 0
         'envelope.recovery.applied',
       ];
       for (const e of reliability.events as unknown[]) {
-        expect(RFC_0032_EVENTS, `event "${String(e)}" MUST be one of the six RFC 0032 names`).toContain(String(e));
+        expect(RFC_0032_EVENTS, req('openwop.it.envelope-retry-attempted.capabilities-envelopes-reliability-when-present-conforms-to-rfc-0032-c', 'RFC 0032 §C', `event "${String(e)}" MUST be one of the six RFC 0032 names`)).toContain(String(e));
       }
       // When supported: true, MUST include the two MUST-tier events (per
       // RFC 0032 §C). Hosts that have wired end-to-end emission from
@@ -87,17 +87,17 @@ describe.skipIf(HTTP_SKIP)('envelope-retry-attempted: advertisement shape (RFC 0
         const evts = reliability.events as string[];
         expect(
           evts.includes('envelope.retry.exhausted'),
-          'RFC 0032 §C: hosts that advertise `supported: true` with non-empty `events[]` MUST include `envelope.retry.exhausted`',
+          req('openwop.it.envelope-retry-attempted.capabilities-envelopes-reliability-when-present-conforms-to-rfc-0032-c', 'RFC 0032 §C', 'RFC 0032 §C: hosts that advertise `supported: true` with non-empty `events[]` MUST include `envelope.retry.exhausted`'),
         ).toBe(true);
         expect(
           evts.includes('envelope.refusal'),
-          'RFC 0032 §C: hosts that advertise `supported: true` with non-empty `events[]` MUST include `envelope.refusal`',
+          req('openwop.it.envelope-retry-attempted.capabilities-envelopes-reliability-when-present-conforms-to-rfc-0032-c', 'RFC 0032 §C', 'RFC 0032 §C: hosts that advertise `supported: true` with non-empty `events[]` MUST include `envelope.refusal`'),
         ).toBe(true);
       }
     }
     if (reliability.maxRetryAttempts !== undefined) {
       const n = reliability.maxRetryAttempts as number;
-      expect(typeof n === 'number' && n >= 1 && n <= 16, 'maxRetryAttempts MUST be integer in [1, 16]').toBe(true);
+      expect(typeof n === 'number' && n >= 1 && n <= 16, req('openwop.it.envelope-retry-attempted.capabilities-envelopes-reliability-when-present-conforms-to-rfc-0032-c', 'RFC 0032 §C', 'maxRetryAttempts MUST be integer in [1, 16]')).toBe(true);
     }
   });
 });
@@ -115,6 +115,8 @@ describe.skipIf(HTTP_SKIP)('envelope-retry-attempted: advertisement shape (RFC 0
 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';
 
 const FIXTURE = 'conformance-envelope-retry-attempted';
 const NODE_ID = 'structured-call';
@@ -154,20 +156,20 @@ async function startRunAndRead(): Promise<RunEvent[] | null> {
 
 describe.skipIf(HTTP_SKIP)('envelope-retry-attempted: runtime behavior (RFC 0032 §B.1)', () => {
   it('when mock LLM emits invalid envelope on attempt 1 then valid on attempt 2, exactly one `envelope.retry.attempted` event fires before the second attempt', async () => {
-    if (!isFixtureAdvertised(FIXTURE)) return;
+    if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(FIXTURE)` returned early');
     const seed = await programMock([
       { content: 'not valid json — provoke parse-error retry' },
       { content: '{"valid":true}' },
     ]);
-    if (seed.status === 404) return; // host doesn't expose the seam
+    if (seed.status === 404) return softSkip('blocked', 'precondition not met — `seed.status === 404` returned early (host doesn\'t expose the seam) (seam, prior step, or fixture unavailable)'); // host doesn't expose the seam
     expect(seed.status).toBe(200);
 
     const events = await startRunAndRead();
-    if (events === null) return;
+    if (events === null) return softSkip('blocked', 'precondition not met — `events === null` returned early (seam, prior step, or fixture unavailable)');
     const retries = events.filter((e) => e.type === 'envelope.retry.attempted');
     expect(
       retries.length,
-      driver.describe(
+      req('openwop.it.envelope-retry-attempted.when-mock-llm-emits-invalid-envelope-on-attempt-1-then-valid-on-attempt-2-exactl', 
         'RFCS/0032-envelope-reliability-events.md §B.1',
         'exactly one envelope.retry.attempted event MUST fire between attempts 1 and 2',
       ),
@@ -175,17 +177,17 @@ describe.skipIf(HTTP_SKIP)('envelope-retry-attempted: runtime behavior (RFC 0032
   });
 
   it('event payload carries `attempt: 2` (1-indexed; first attempt does not emit)', async () => {
-    if (!isFixtureAdvertised(FIXTURE)) return;
+    if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(FIXTURE)` returned early');
     const seed = await programMock([{ content: 'invalid' }, { content: '{"valid":true}' }]);
-    if (seed.status === 404) return;
+    if (seed.status === 404) return softSkip('blocked', 'precondition not met — `seed.status === 404` returned early (seam, prior step, or fixture unavailable)');
 
     const events = await startRunAndRead();
-    if (events === null) return;
+    if (events === null) return softSkip('blocked', 'precondition not met — `events === null` returned early (seam, prior step, or fixture unavailable)');
     const retry = events.find((e) => e.type === 'envelope.retry.attempted');
-    expect(retry, 'envelope.retry.attempted MUST appear in the event log').toBeDefined();
+    expect(retry, req('openwop.it.envelope-retry-attempted.event-payload-carries-attempt-2-1-indexed-first-attempt-does-not-emit', 'RFCS/0032-envelope-reliability-events.md §B.1', 'envelope.retry.attempted MUST appear in the event log')).toBeDefined();
     expect(
       retry!.payload?.attempt,
-      driver.describe(
+      req('openwop.it.envelope-retry-attempted.event-payload-carries-attempt-2-1-indexed-first-attempt-does-not-emit', 
         'RFCS/0032-envelope-reliability-events.md §B.1',
         'attempt field MUST be 2 (1-indexed; first attempt does not emit)',
       ),
@@ -193,19 +195,19 @@ describe.skipIf(HTTP_SKIP)('envelope-retry-attempted: runtime behavior (RFC 0032
   });
 
   it('`reason` is one of the spec-reserved closed-enum values OR matches the `x-host-<host>-<key>` extension pattern', async () => {
-    if (!isFixtureAdvertised(FIXTURE)) return;
+    if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(FIXTURE)` returned early');
     const seed = await programMock([{ content: 'invalid' }, { content: '{"valid":true}' }]);
-    if (seed.status === 404) return;
+    if (seed.status === 404) return softSkip('blocked', 'precondition not met — `seed.status === 404` returned early (seam, prior step, or fixture unavailable)');
 
     const events = await startRunAndRead();
-    if (events === null) return;
+    if (events === null) return softSkip('blocked', 'precondition not met — `events === null` returned early (seam, prior step, or fixture unavailable)');
     const retry = events.find((e) => e.type === 'envelope.retry.attempted');
     expect(retry).toBeDefined();
     const reason = retry!.payload?.reason;
     expect(typeof reason).toBe('string');
     expect(
       RFC_0032_REASONS.has(reason as string) || HOST_REASON_EXT_RE.test(reason as string),
-      driver.describe(
+      req('openwop.it.envelope-retry-attempted.reason-is-one-of-the-spec-reserved-closed-enum-values-or-matches-the-x-host-host', 
         'RFCS/0032-envelope-reliability-events.md §B.1',
         'reason MUST be in the spec-reserved set OR match x-host-<host>-<key>',
       ),
@@ -213,17 +215,17 @@ describe.skipIf(HTTP_SKIP)('envelope-retry-attempted: runtime behavior (RFC 0032
   });
 
   it('eventual success records normally via envelope acceptance + downstream RunEventDoc', async () => {
-    if (!isFixtureAdvertised(FIXTURE)) return;
+    if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(FIXTURE)` returned early');
     const seed = await programMock([{ content: 'invalid' }, { content: '{"valid":true}' }]);
-    if (seed.status === 404) return;
+    if (seed.status === 404) return softSkip('blocked', 'precondition not met — `seed.status === 404` returned early (seam, prior step, or fixture unavailable)');
 
     const events = await startRunAndRead();
-    if (events === null) return;
+    if (events === null) return softSkip('blocked', 'precondition not met — `events === null` returned early (seam, prior step, or fixture unavailable)');
     const nodeCompleted = events.find((e) => e.type === 'node.completed' && e.nodeId === NODE_ID);
     const runCompleted = events.find((e) => e.type === 'run.completed');
     expect(
       nodeCompleted,
-      driver.describe(
+      req('openwop.it.envelope-retry-attempted.eventual-success-records-normally-via-envelope-acceptance-downstream-runeventdoc', 
         'RFCS/0032-envelope-reliability-events.md §B.1',
         'eventual success MUST produce a node.completed for the dispatching node',
       ),
@@ -232,25 +234,25 @@ describe.skipIf(HTTP_SKIP)('envelope-retry-attempted: runtime behavior (RFC 0032
   });
 
   it('`previousError` (when populated) MUST NOT contain prompt or response substring excerpts — limit to validator output', async () => {
-    if (!isFixtureAdvertised(FIXTURE)) return;
+    if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(FIXTURE)` returned early');
     const PROMPT_CANARY = 'PROMPT-CANARY-RETRY-ATTEMPTED-DO-NOT-LEAK-' + Math.random().toString(36).slice(2, 10);
     const RESPONSE_CANARY = 'RESPONSE-CANARY-' + PROMPT_CANARY;
     const seed = await programMock([
       { content: `not valid json mentioning ${RESPONSE_CANARY}` },
       { content: '{"valid":true}' },
     ]);
-    if (seed.status === 404) return;
+    if (seed.status === 404) return softSkip('blocked', 'precondition not met — `seed.status === 404` returned early (seam, prior step, or fixture unavailable)');
 
     const events = await startRunAndRead();
-    if (events === null) return;
+    if (events === null) return softSkip('blocked', 'precondition not met — `events === null` returned early (seam, prior step, or fixture unavailable)');
     const retry = events.find((e) => e.type === 'envelope.retry.attempted');
-    if (!retry) return;
+    if (!retry) return softSkip('blocked', 'precondition not met — `!retry` returned early (seam, prior step, or fixture unavailable)');
     const previousError = retry.payload?.previousError;
-    if (previousError === undefined || previousError === null) return; // field is optional
+    if (previousError === undefined || previousError === null) return softSkip('blocked', 'precondition not met — `previousError === undefined || previousError === null` returned early (field is optional) (seam, prior step, or fixture unavailable)'); // field is optional
     const serialized = typeof previousError === 'string' ? previousError : JSON.stringify(previousError);
     expect(
       serialized.includes(RESPONSE_CANARY),
-      driver.describe(
+      req('openwop.it.envelope-retry-attempted.previouserror-when-populated-must-not-contain-prompt-or-response-substring-excer', 
         'RFCS/0032-envelope-reliability-events.md §G',
         'previousError MUST NOT echo provider response substrings — validator output only',
       ),

package/src/scenarios/envelope-retry-exhausted.test.ts

@@ -28,6 +28,8 @@ import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const HTTP_SKIP = !process.env.OPENWOP_BASE_URL;
 const FIXTURE = 'conformance-envelope-retry-exhausted';
@@ -69,7 +71,7 @@ async function startRunAndRead(): Promise<{ events: RunEvent[]; terminal: unknow
 
 describe.skipIf(HTTP_SKIP)('envelope-retry-exhausted: runtime behavior (RFC 0032 §B.2 MUST)', () => {
   it('host exhausts retries with all-invalid program → exactly one envelope.retry.exhausted event', async () => {
-    if (!isFixtureAdvertised(FIXTURE)) return;
+    if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(FIXTURE)` returned early');
     // Seed maxRetryAttempts entries of invalid JSON so dispatchStructured
     // hits every retry and then exhausts. The mock returns empty-stop
     // after program exhaustion, but dispatchStructured short-circuits
@@ -80,16 +82,16 @@ describe.skipIf(HTTP_SKIP)('envelope-retry-exhausted: runtime behavior (RFC 0032
       { content: 'not json c' },
       { content: 'not json d' },
     ]);
-    if (seed.status === 404) return;
+    if (seed.status === 404) return softSkip('blocked', 'precondition not met — `seed.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(seed.status).toBe(200);
 
     const result = await startRunAndRead();
-    if (result === null) return;
+    if (result === null) return softSkip('blocked', 'precondition not met — `result === null` returned early (seam, prior step, or fixture unavailable)');
     const { events } = result;
     const exhausted = events.filter((e) => e.type === 'envelope.retry.exhausted');
     expect(
       exhausted.length,
-      driver.describe(
+      req('openwop.it.envelope-retry-exhausted.host-exhausts-retries-with-all-invalid-program-exactly-one-envelope-retry-exhaus', 
         'RFCS/0032-envelope-reliability-events.md §B.2',
         'exactly one envelope.retry.exhausted event MUST fire on retry-budget exhaustion',
       ),
@@ -97,32 +99,32 @@ describe.skipIf(HTTP_SKIP)('envelope-retry-exhausted: runtime behavior (RFC 0032
   });
 
   it('totalAttempts in payload matches the host advertised maxRetryAttempts', async () => {
-    if (!isFixtureAdvertised(FIXTURE)) return;
+    if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(FIXTURE)` returned early');
     const seed = await programMock([{ content: 'x' }, { content: 'y' }, { content: 'z' }, { content: 'w' }]);
-    if (seed.status === 404) return;
+    if (seed.status === 404) return softSkip('blocked', 'precondition not met — `seed.status === 404` returned early (seam, prior step, or fixture unavailable)');
 
     const result = await startRunAndRead();
-    if (result === null) return;
+    if (result === null) return softSkip('blocked', 'precondition not met — `result === null` returned early (seam, prior step, or fixture unavailable)');
     const exhausted = result.events.find((e) => e.type === 'envelope.retry.exhausted');
-    expect(exhausted).toBeDefined();
+    expect(exhausted, req('openwop.it.envelope-retry-exhausted.totalattempts-in-payload-matches-the-host-advertised-maxretryattempts', 'RFC 0032 §B.2', 'totalAttempts in payload matches the host advertised maxRetryAttempts')).toBeDefined();
     const total = exhausted!.payload?.totalAttempts;
     expect(typeof total === 'number' && (total as number) >= 1).toBe(true);
   });
 
   it('finalReason is in the spec-reserved enum OR matches x-host-<host>-<key>', async () => {
-    if (!isFixtureAdvertised(FIXTURE)) return;
+    if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(FIXTURE)` returned early');
     const seed = await programMock([{ content: 'x' }, { content: 'y' }, { content: 'z' }, { content: 'w' }]);
-    if (seed.status === 404) return;
+    if (seed.status === 404) return softSkip('blocked', 'precondition not met — `seed.status === 404` returned early (seam, prior step, or fixture unavailable)');
 
     const result = await startRunAndRead();
-    if (result === null) return;
+    if (result === null) return softSkip('blocked', 'precondition not met — `result === null` returned early (seam, prior step, or fixture unavailable)');
     const exhausted = result.events.find((e) => e.type === 'envelope.retry.exhausted');
     expect(exhausted).toBeDefined();
     const reason = exhausted!.payload?.finalReason;
     expect(typeof reason).toBe('string');
     expect(
       RFC_0032_REASONS.has(reason as string) || HOST_REASON_EXT_RE.test(reason as string),
-      driver.describe(
+      req('openwop.it.envelope-retry-exhausted.finalreason-is-in-the-spec-reserved-enum-or-matches-x-host-host-key', 
         'RFCS/0032-envelope-reliability-events.md §B.2',
         'finalReason MUST be in the spec-reserved set OR match x-host-<host>-<key>',
       ),
@@ -130,16 +132,16 @@ describe.skipIf(HTTP_SKIP)('envelope-retry-exhausted: runtime behavior (RFC 0032
   });
 
   it('RunSnapshot.error.code is envelope_invalid for schema-violation exhaustion (RFC 0033 §C)', async () => {
-    if (!isFixtureAdvertised(FIXTURE)) return;
+    if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(FIXTURE)` returned early');
     const seed = await programMock([{ content: 'x' }, { content: 'y' }, { content: 'z' }, { content: 'w' }]);
-    if (seed.status === 404) return;
+    if (seed.status === 404) return softSkip('blocked', 'precondition not met — `seed.status === 404` returned early (seam, prior step, or fixture unavailable)');
 
     const result = await startRunAndRead();
-    if (result === null) return;
+    if (result === null) return softSkip('blocked', 'precondition not met — `result === null` returned early (seam, prior step, or fixture unavailable)');
     const code = (result.terminal as { error?: { code?: string } }).error?.code;
     expect(
       code,
-      driver.describe(
+      req('openwop.it.envelope-retry-exhausted.runsnapshot-error-code-is-envelope-invalid-for-schema-violation-exhaustion-rfc-0', 
         'RFCS/0033-envelope-completion-contract.md §C',
         'schema-violation-exhaustion MUST surface as RunSnapshot.error.code = envelope_invalid',
       ),
@@ -147,19 +149,19 @@ describe.skipIf(HTTP_SKIP)('envelope-retry-exhausted: runtime behavior (RFC 0032
   });
 
   it('envelope.retry.exhausted is emitted BEFORE node.failed (cause precedes effect)', async () => {
-    if (!isFixtureAdvertised(FIXTURE)) return;
+    if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(FIXTURE)` returned early');
     const seed = await programMock([{ content: 'x' }, { content: 'y' }, { content: 'z' }, { content: 'w' }]);
-    if (seed.status === 404) return;
+    if (seed.status === 404) return softSkip('blocked', 'precondition not met — `seed.status === 404` returned early (seam, prior step, or fixture unavailable)');
 
     const result = await startRunAndRead();
-    if (result === null) return;
+    if (result === null) return softSkip('blocked', 'precondition not met — `result === null` returned early (seam, prior step, or fixture unavailable)');
     const exhaustedIdx = result.events.findIndex((e) => e.type === 'envelope.retry.exhausted');
     const failedIdx = result.events.findIndex((e) => e.type === 'node.failed');
     expect(exhaustedIdx).toBeGreaterThanOrEqual(0);
     expect(failedIdx).toBeGreaterThanOrEqual(0);
     expect(
       exhaustedIdx < failedIdx,
-      driver.describe(
+      req('openwop.it.envelope-retry-exhausted.envelope-retry-exhausted-is-emitted-before-node-failed-cause-precedes-effect', 
         'RFCS/0032-envelope-reliability-events.md §B.2',
         'envelope.retry.exhausted MUST be emitted BEFORE node.failed (the event signals the host is about to surface the terminal failure)',
       ),

package/src/scenarios/envelope-tier-one-subset-static.test.ts

@@ -35,6 +35,8 @@ import { join } from 'node:path';
 import { driver } from '../lib/driver.js';
 import { SCHEMAS_DIR } from '../lib/paths.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;
 
@@ -179,11 +181,11 @@ function walkSchema(
 describe.skipIf(HTTP_SKIP)('envelope-tier-one-subset-static (RFC 0030 §B)', () => {
   it('hosts advertising tierOneSubsetCompliance: "strict" have payload schemas that satisfy the Tier-1 intersection', async () => {
     const d = await readDiscovery();
-    if (d === null) return; // host unreachable; soft-skip
+    if (d === null) return softSkip('blocked', 'precondition not met — `d === null` returned early (host unreachable; soft-skip) (seam, prior step, or fixture unavailable)'); // host unreachable; soft-skip
     const compliance = capabilityFamily(d, 'envelopes')?.tierOneSubsetCompliance;
-    if (compliance !== 'strict') return; // gated on "strict" only
+    if (compliance !== 'strict') return softSkip('blocked', 'precondition not met — `compliance !== \'strict\'` returned early (gated on "strict" only) (seam, prior step, or fixture unavailable)'); // gated on "strict" only
     const advertised = (capabilityFamily(d, 'supportedEnvelopes') ?? []) as string[];
-    if (advertised.length === 0) return;
+    if (advertised.length === 0) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `advertised.length === 0` returned early');
 
     const violationsByKind: Record<string, Violation[]> = {};
     for (const kind of advertised) {
@@ -202,7 +204,7 @@ describe.skipIf(HTTP_SKIP)('envelope-tier-one-subset-static (RFC 0030 §B)', ()
 
     expect(
       violationsByKind,
-      `RFC 0030 §B: schemas violating the Tier-1 subset under strict-mode advertisement: ${JSON.stringify(violationsByKind, null, 2)}`,
+      req('openwop.it.envelope-tier-one-subset-static.hosts-advertising-tieronesubsetcompliance-strict-have-payload-schemas-that-satis', 'RFC 0030 §B', `RFC 0030 §B: schemas violating the Tier-1 subset under strict-mode advertisement: ${JSON.stringify(violationsByKind, null, 2)}`),
     ).toEqual({});
   });
 });
@@ -216,14 +218,14 @@ describe('envelope-tier-one-subset-static: universal-kind schemas satisfy load-b
   for (const kind of UNIVERSAL_KINDS) {
     it(`${kind}.schema.json satisfies load-bearing Tier-1 rules (no oneOf/allOf/not/prefixItems/propertyNames anywhere)`, () => {
       const schema = loadLocalSchema(kind);
-      expect(schema, `schemas/envelopes/${kind}.schema.json MUST exist`).not.toBeNull();
-      if (schema === null) return;
+      expect(schema, req('openwop.it.envelope-tier-one-subset-static.schema-json-satisfies-load-bearing-tier-1-rules-no-oneof-allof-not-prefixitems-p', 'RFC 0030 §B', `schemas/envelopes/${kind}.schema.json MUST exist`)).not.toBeNull();
+      if (schema === null) return softSkip('blocked', 'precondition not met — `schema === null` returned early (seam, prior step, or fixture unavailable)');
       const violations: Violation[] = [];
       const propCount = { n: 0 };
       walkSchema(schema, `#`, 0, propCount, violations, 'load-bearing');
       expect(
         violations,
-        `${kind}.schema.json load-bearing Tier-1 violations (these fail across multiple vendors): ${JSON.stringify(violations, null, 2)}`,
+        req('openwop.it.envelope-tier-one-subset-static.schema-json-satisfies-load-bearing-tier-1-rules-no-oneof-allof-not-prefixitems-p', 'RFC 0030 §B', `${kind}.schema.json load-bearing Tier-1 violations (these fail across multiple vendors): ${JSON.stringify(violations, null, 2)}`),
       ).toEqual([]);
     });
   }