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

package/src/scenarios/distillation-token-budget.test.ts

@@ -12,8 +12,8 @@
 
 import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
-import { driver } from '../lib/driver.js';
 import { readDistillationCap, invokeDistill } from '../lib/distillation.js';
+import { req } from '../lib/requirement-ids.js';
 
 describe('distillation-token-budget (RFC 0062 §B)', () => {
   it('within budget tokensUsed ≤ tokenBudget; an un-meetable budget fails atomically', async () => {
@@ -24,11 +24,11 @@ describe('distillation-token-budget (RFC 0062 §B)', () => {
     const dist = ok.body.event?.distillation ?? {};
     expect(
       typeof dist.tokenBudget === 'number' && typeof dist.tokensUsed === 'number',
-      driver.describe('RFC 0062 §B', 'memory.compacted MUST carry distillation.tokenBudget + tokensUsed on a budgeted run'),
+      req('openwop.it.distillation-token-budget.within-budget-tokensused-tokenbudget-an-un-meetable-budget-fails-atomically', 'RFC 0062 §B', 'memory.compacted MUST carry distillation.tokenBudget + tokensUsed on a budgeted run'),
     ).toBe(true);
     expect(
       (dist.tokensUsed as number) <= (dist.tokenBudget as number),
-      driver.describe('RFC 0062 §B', 'a successful distillation MUST consume ≤ its tokenBudget'),
+      req('openwop.it.distillation-token-budget.within-budget-tokensused-tokenbudget-an-un-meetable-budget-fails-atomically', 'RFC 0062 §B', 'a successful distillation MUST consume ≤ its tokenBudget'),
     ).toBe(true);
 
     // A budget too small to distill the corpus MUST fail closed, no partial archive.
@@ -36,11 +36,11 @@ describe('distillation-token-budget (RFC 0062 §B)', () => {
     if (tooSmall === null) return softSkip('blocked', 'precondition not met — `tooSmall === null` returned early (seam, prior step, or fixture unavailable)');
     expect(
       tooSmall.status >= 400 && tooSmall.body.error === 'token_budget_exceeded',
-      driver.describe('RFC 0062 §B', 'an un-meetable budget MUST fail with token_budget_exceeded'),
+      req('openwop.it.distillation-token-budget.within-budget-tokensused-tokenbudget-an-un-meetable-budget-fails-atomically', 'RFC 0062 §B', 'an un-meetable budget MUST fail with token_budget_exceeded'),
     ).toBe(true);
     expect(
       tooSmall.body.archiveChecksum,
-      driver.describe('RFC 0062 §B', 'a token_budget_exceeded run MUST write no partial archive (atomic)'),
+      req('openwop.it.distillation-token-budget.within-budget-tokensused-tokenbudget-an-un-meetable-budget-fails-atomically', 'RFC 0062 §B', 'a token_budget_exceeded run MUST write no partial archive (atomic)'),
     ).toBeUndefined();
   });
 });

package/src/scenarios/durability-poison-exhaustion.test.ts

@@ -51,6 +51,7 @@ import { softSkip } from '../lib/soft-skip.js';
 import { queryTestEvents, requireEvents } from '../lib/event-log-query.js';
 import { recordRequirement } from '../lib/requirement-ledger.js';
 import { requirementIdForFile } from '../lib/scenario-disposition.js';
+import { req } from '../lib/requirement-ids.js';
 
 const WORKFLOW_ID = 'conformance-failure';
 const FILE = 'durability-poison-exhaustion.test.ts';
@@ -90,7 +91,7 @@ if (SKIP_NO_FIXTURE) {
 describe.skipIf(SKIP_NO_FIXTURE)('RFC 0158 §C.8 — poison work terminates within a bounded number of attempts', () => {
   it('reaches terminal AND stops being retried, asserted on the log rather than on the status alone', async () => {
     const create = await driver.post('/v1/runs', { workflowId: WORKFLOW_ID });
-    expect(create.status, driver.describe(
+    expect(create.status, req('openwop.it.durability-poison-exhaustion.reaches-terminal-and-stops-being-retried-asserted-on-the-log-rather-than-on-the', 
       'rest-endpoints.md',
       'POST /v1/runs MUST return 201 even for work that fails at runtime',
     )).toBe(201);
@@ -98,7 +99,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('RFC 0158 §C.8 — poison work terminates with
 
     // ── First clause: a terminal, OPERATOR-VISIBLE state ─────────────────────
     const terminal = await pollUntilTerminal(runId);
-    expect(terminal.status, driver.describe(
+    expect(terminal.status, req('openwop.it.durability-poison-exhaustion.reaches-terminal-and-stops-being-retried-asserted-on-the-log-rather-than-on-the', 
       'RFC 0158 §C.8',
       'deterministically failing work MUST reach a terminal, operator-visible state',
     )).toBe('failed');
@@ -118,13 +119,13 @@ describe.skipIf(SKIP_NO_FIXTURE)('RFC 0158 §C.8 — poison work terminates with
     // Non-vacuity: the failure must actually be ON the log. Without this, a host
     // returning an empty array would sail through every count comparison below,
     // since 0 === 0 after any wait.
-    expect(events.some((e) => e.type === 'node.failed'), driver.describe(
+    expect(events.some((e) => e.type === 'node.failed'), req('openwop.it.durability-poison-exhaustion.reaches-terminal-and-stops-being-retried-asserted-on-the-log-rather-than-on-the', 
       'RFC 0158 §C.8',
       'the run log MUST record the deterministic failure — an empty log makes every attempt count vacuous',
     )).toBe(true);
 
     const attemptsBefore = events.filter((e) => ATTEMPT_TYPES.has(e.type)).length;
-    expect(attemptsBefore, driver.describe(
+    expect(attemptsBefore, req('openwop.it.durability-poison-exhaustion.reaches-terminal-and-stops-being-retried-asserted-on-the-log-rather-than-on-the', 
       'RFC 0158 §C.8',
       'at least one attempt MUST be recorded — zero attempts means nothing was delivered',
     )).toBeGreaterThan(0);
@@ -135,7 +136,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('RFC 0158 §C.8 — poison work terminates with
     const after = requireEvents(second, 'RFC 0158 §C.8 attempt counting (post-terminal)');
     const attemptsAfter = after.filter((e) => ATTEMPT_TYPES.has(e.type)).length;
 
-    expect(attemptsAfter, driver.describe(
+    expect(attemptsAfter, req('openwop.it.durability-poison-exhaustion.reaches-terminal-and-stops-being-retried-asserted-on-the-log-rather-than-on-the', 
       'RFC 0158 §C.8',
       'attempts MUST NOT continue after the run reports terminal — a host still redelivering records more',
     )).toBe(attemptsBefore);
@@ -143,7 +144,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('RFC 0158 §C.8 — poison work terminates with
     // ── Optional ceiling, only when the operator supplies the declared bound ─
     const bound = declaredAttemptBound();
     if (bound !== null) {
-      expect(attemptsAfter, driver.describe(
+      expect(attemptsAfter, req('openwop.it.durability-poison-exhaustion.reaches-terminal-and-stops-being-retried-asserted-on-the-log-rather-than-on-the', 
         'RFC 0158 §C.8 + §B.5',
         'total attempts MUST NOT exceed the operator-declared attempt bound',
       )).toBeLessThanOrEqual(bound);

package/src/scenarios/egress-audience-binding.test.ts

@@ -28,9 +28,10 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { readEgressPolicyCap, driveEgress, EGRESS_DECISIONS, EGRESS_REASONS } from '../lib/egressPolicy.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 describe('egress-audience-binding (RFC 0079 §C)', () => {
   it('denies/downgrades an out-of-audience egress without attaching the credential, and fails closed on unevaluable provenance', async () => {
@@ -39,22 +40,22 @@ describe('egress-audience-binding (RFC 0079 §C)', () => {
 
     // ---- Leg 1: out-of-audience — deny|downgrade + credential NOT attached --
     const oob = await driveEgress({ scenario: 'out-of-audience' });
-    if (oob === null) return; // egress seam absent — soft-skip the whole behavior
+    if (oob === null) return softSkip('blocked', 'precondition not met — `oob === null` returned early (egress seam absent — soft-skip the whole behavior) (seam, prior step, or fixture unavailable)'); // egress seam absent — soft-skip the whole behavior
     expect(
       oob.decision === 'denied' || oob.decision === 'downgraded',
-      driver.describe('host-capabilities.md §"Credential provenance + egress policy"', 'an out-of-audience egress MUST be denied or downgraded'),
+      req('openwop.it.egress-audience-binding.denies-downgrades-an-out-of-audience-egress-without-attaching-the-credential-and', 'host-capabilities.md §"Credential provenance + egress policy"', 'an out-of-audience egress MUST be denied or downgraded'),
     ).toBe(true);
     expect(
       typeof oob.decision === 'string' && EGRESS_DECISIONS.includes(oob.decision),
-      driver.describe('run-event-payloads.schema.json#egressDecided', 'decision MUST be in the closed enum'),
+      req('openwop.it.egress-audience-binding.denies-downgrades-an-out-of-audience-egress-without-attaching-the-credential-and', 'run-event-payloads.schema.json#egressDecided', 'decision MUST be in the closed enum'),
     ).toBe(true);
     expect(
       oob.reason === 'out-of-audience',
-      driver.describe('RFC 0079 §C', 'an out-of-audience denial MUST carry reason "out-of-audience"'),
+      req('openwop.it.egress-audience-binding.denies-downgrades-an-out-of-audience-egress-without-attaching-the-credential-and', 'RFC 0079 §C', 'an out-of-audience denial MUST carry reason "out-of-audience"'),
     ).toBe(true);
     expect(
       oob.credentialAttached !== true,
-      driver.describe('SECURITY/invariants.yaml egress-credential-audience-bound', 'the host MUST NOT attach a credential whose audience excludes the destination (confused-deputy)'),
+      req('openwop.it.egress-audience-binding.denies-downgrades-an-out-of-audience-egress-without-attaching-the-credential-and', 'SECURITY/invariants.yaml egress-credential-audience-bound', 'the host MUST NOT attach a credential whose audience excludes the destination (confused-deputy)'),
     ).toBe(true);
 
     // ---- Leg 2: provenance-unevaluable — fail closed (deny) ----------------
@@ -62,19 +63,19 @@ describe('egress-audience-binding (RFC 0079 §C)', () => {
     if (uneval !== null) {
       expect(
         uneval.decision === 'denied',
-        driver.describe('RFC 0079 §C', 'an egress with unevaluable provenance MUST fail closed (denied)'),
+        req('openwop.it.egress-audience-binding.denies-downgrades-an-out-of-audience-egress-without-attaching-the-credential-and', 'RFC 0079 §C', 'an egress with unevaluable provenance MUST fail closed (denied)'),
       ).toBe(true);
       expect(
         uneval.reason === 'provenance-unevaluable',
-        driver.describe('RFC 0079 §C', 'a provenance-unevaluable denial MUST carry reason "provenance-unevaluable"'),
+        req('openwop.it.egress-audience-binding.denies-downgrades-an-out-of-audience-egress-without-attaching-the-credential-and', 'RFC 0079 §C', 'a provenance-unevaluable denial MUST carry reason "provenance-unevaluable"'),
       ).toBe(true);
       expect(
         typeof uneval.reason === 'string' && EGRESS_REASONS.includes(uneval.reason),
-        driver.describe('run-event-payloads.schema.json#egressDecided', 'reason MUST be in the closed enum'),
+        req('openwop.it.egress-audience-binding.denies-downgrades-an-out-of-audience-egress-without-attaching-the-credential-and', 'run-event-payloads.schema.json#egressDecided', 'reason MUST be in the closed enum'),
       ).toBe(true);
       expect(
         uneval.credentialAttached !== true,
-        driver.describe('SECURITY/invariants.yaml egress-credential-audience-bound', 'a fail-closed egress MUST NOT attach the credential'),
+        req('openwop.it.egress-audience-binding.denies-downgrades-an-out-of-audience-egress-without-attaching-the-credential-and', 'SECURITY/invariants.yaml egress-credential-audience-bound', 'a fail-closed egress MUST NOT attach the credential'),
       ).toBe(true);
     }
   });

package/src/scenarios/egress-decision-content-free.test.ts

@@ -20,9 +20,10 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { readEgressPolicyCap, driveEgress, EGRESS_REASONS, EGRESS_CONTENT_FORBIDDEN } from '../lib/egressPolicy.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 describe('egress-decision-content-free (RFC 0079 §F / SR-1)', () => {
   it('never leaks the credential value or the blocked destination into the egress.decided payload', async () => {
@@ -30,19 +31,19 @@ describe('egress-decision-content-free (RFC 0079 §F / SR-1)', () => {
     if (!behaviorGate('openwop-egress-decision-content-free', cap?.supported === true)) return;
 
     const res = await driveEgress({ scenario: 'canary' });
-    if (res === null) return; // seam absent — soft-skip
+    if (res === null) return softSkip('blocked', 'precondition not met — `res === null` returned early (seam absent — soft-skip) (seam, prior step, or fixture unavailable)'); // seam absent — soft-skip
 
     // The canary sentinel MUST NOT appear anywhere observable.
     expect(
       res.canaryLeaked !== true,
-      driver.describe('RFC 0079 §F (SR-1)', 'the credential value (canary) MUST NOT leak into any observable surface'),
+      req('openwop.it.egress-decision-content-free.never-leaks-the-credential-value-or-the-blocked-destination-into-the-egress-deci', 'RFC 0079 §F (SR-1)', 'the credential value (canary) MUST NOT leak into any observable surface'),
     ).toBe(true);
 
     // No forbidden content keys on the decision payload.
     for (const forbidden of EGRESS_CONTENT_FORBIDDEN) {
       expect(
         !(forbidden in res),
-        driver.describe('RFC 0079 §F (SR-1)', `egress.decided MUST be content-free (no ${forbidden})`),
+        req('openwop.it.egress-decision-content-free.never-leaks-the-credential-value-or-the-blocked-destination-into-the-egress-deci', 'RFC 0079 §F (SR-1)', `egress.decided MUST be content-free (no ${forbidden})`),
       ).toBe(true);
     }
 
@@ -50,7 +51,7 @@ describe('egress-decision-content-free (RFC 0079 §F / SR-1)', () => {
     if (res.reason !== undefined) {
       expect(
         typeof res.reason === 'string' && EGRESS_REASONS.includes(res.reason),
-        driver.describe('run-event-payloads.schema.json#egressDecided', 'reason MUST be in the closed enum (no free-form spill)'),
+        req('openwop.it.egress-decision-content-free.never-leaks-the-credential-value-or-the-blocked-destination-into-the-egress-deci', 'run-event-payloads.schema.json#egressDecided', 'reason MUST be in the closed enum (no free-form spill)'),
       ).toBe(true);
     }
   });

package/src/scenarios/egress-provenance-shape.test.ts

@@ -40,8 +40,7 @@ import { join } from 'node:path';
 import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
 import { SCHEMAS_DIR } from '../lib/paths.js';
-
-const why = (specRef: string, requirement: string): string => `${specRef} — ${requirement}`;
+import { req } from '../lib/requirement-ids.js';
 
 function loadSchema(name: string): Record<string, unknown> {
   return JSON.parse(readFileSync(join(SCHEMAS_DIR, name), 'utf8')) as Record<string, unknown>;
@@ -58,20 +57,20 @@ describe('egress-provenance-shape: CredentialProvenance (RFC 0079 §A, server-fr
   it('a conforming descriptor validates', () => {
     expect(
       validate({ credentialId: 'cred-stripe-1', issuer: 'host', audiences: ['api.stripe.com'], expiresAt: '2026-12-01T00:00:00Z', scopes: ['egress:stripe:charge'], redactionPolicy: 'always' }),
-      why('host-capabilities.md §"Credential provenance + egress policy"', 'a conforming CredentialProvenance MUST validate'),
+      req('openwop.it.egress-provenance-shape.a-conforming-descriptor-validates', 'host-capabilities.md §"Credential provenance + egress policy"', 'a conforming CredentialProvenance MUST validate'),
     ).toBe(true);
   });
 
   it('audiences: [] is rejected (minItems:1 — a credential needs ≥1 audience to bind)', () => {
-    expect(validate({ credentialId: 'c', issuer: 'host', audiences: [] }), why('RFC 0079 §A', 'audiences MUST have ≥1 entry')).toBe(false);
+    expect(validate({ credentialId: 'c', issuer: 'host', audiences: [] }), req('openwop.it.egress-provenance-shape.audiences-is-rejected-minitems-1-a-credential-needs-1-audience-to-bind', 'RFC 0079 §A', 'audiences MUST have ≥1 entry')).toBe(false);
   });
 
   it('a missing REQUIRED credentialId is rejected', () => {
-    expect(validate({ issuer: 'host', audiences: ['a'] }), why('RFC 0079 §A', 'credentialId is REQUIRED')).toBe(false);
+    expect(validate({ issuer: 'host', audiences: ['a'] }), req('openwop.it.egress-provenance-shape.a-missing-required-credentialid-is-rejected', 'RFC 0079 §A', 'credentialId is REQUIRED')).toBe(false);
   });
 
   it('an unknown property is rejected (additionalProperties:false)', () => {
-    expect(validate({ credentialId: 'c', issuer: 'host', audiences: ['a'], secretValue: 'sk-live-xxx' }), why('RFC 0079 §A', 'CredentialProvenance MUST be additionalProperties:false')).toBe(false);
+    expect(validate({ credentialId: 'c', issuer: 'host', audiences: ['a'], secretValue: 'sk-live-xxx' }), req('openwop.it.egress-provenance-shape.an-unknown-property-is-rejected-additionalproperties-false', 'RFC 0079 §A', 'CredentialProvenance MUST be additionalProperties:false')).toBe(false);
   });
 
   it('declares no secret-value property (egress-decision-no-secret-leak)', () => {
@@ -79,7 +78,7 @@ describe('egress-provenance-shape: CredentialProvenance (RFC 0079 §A, server-fr
     for (const p of props) {
       expect(
         SECRET_PROP_NAMES.includes(p.toLowerCase()),
-        why('SECURITY invariant egress-decision-no-secret-leak', `CredentialProvenance MUST NOT declare a secret-bearing property (${p})`),
+        req('openwop.it.egress-provenance-shape.declares-no-secret-value-property-egress-decision-no-secret-leak', 'SECURITY invariant egress-decision-no-secret-leak', `CredentialProvenance MUST NOT declare a secret-bearing property (${p})`),
       ).toBe(false);
     }
   });
@@ -95,32 +94,32 @@ describe('egress-provenance-shape: egress.decided event (RFC 0079 §B, server-fr
   } as Record<string, unknown>);
 
   it('validates a content-free decision and enforces the decision enum + required fields', () => {
-    expect(validate({ decision: 'allowed', destination: 'api.stripe.com', credentialId: 'cred-stripe-1', reason: 'ok' }), why('RFC 0079 §B', 'a conforming egress.decided MUST validate')).toBe(true);
-    expect(validate({ decision: 'denied', destination: 'attacker.example', credentialId: 'cred-stripe-1', reason: 'out-of-audience' }), why('RFC 0079 §B', 'a denied decision MUST validate')).toBe(true);
-    expect(validate({ decision: 'ok', destination: 'a' }), why('RFC 0079 §B', 'the canonical allow value is "allowed", not "ok"')).toBe(false);
-    expect(validate({ destination: 'a' }), why('RFC 0079 §B', 'decision is REQUIRED')).toBe(false);
-    expect(validate({ decision: 'allowed' }), why('RFC 0079 §B', 'destination is REQUIRED')).toBe(false);
+    expect(validate({ decision: 'allowed', destination: 'api.stripe.com', credentialId: 'cred-stripe-1', reason: 'ok' }), req('openwop.it.egress-provenance-shape.validates-a-content-free-decision-and-enforces-the-decision-enum-required-fields', 'RFC 0079 §B', 'a conforming egress.decided MUST validate')).toBe(true);
+    expect(validate({ decision: 'denied', destination: 'attacker.example', credentialId: 'cred-stripe-1', reason: 'out-of-audience' }), req('openwop.it.egress-provenance-shape.validates-a-content-free-decision-and-enforces-the-decision-enum-required-fields', 'RFC 0079 §B', 'a denied decision MUST validate')).toBe(true);
+    expect(validate({ decision: 'ok', destination: 'a' }), req('openwop.it.egress-provenance-shape.validates-a-content-free-decision-and-enforces-the-decision-enum-required-fields', 'RFC 0079 §B', 'the canonical allow value is "allowed", not "ok"')).toBe(false);
+    expect(validate({ destination: 'a' }), req('openwop.it.egress-provenance-shape.validates-a-content-free-decision-and-enforces-the-decision-enum-required-fields', 'RFC 0079 §B', 'decision is REQUIRED')).toBe(false);
+    expect(validate({ decision: 'allowed' }), req('openwop.it.egress-provenance-shape.validates-a-content-free-decision-and-enforces-the-decision-enum-required-fields', 'RFC 0079 §B', 'destination is REQUIRED')).toBe(false);
   });
 
   it('reason is a CLOSED enum — a free-form / URL-bearing reason is rejected (egress-decision-no-secret-leak)', () => {
-    expect(validate({ decision: 'denied', destination: 'attacker.example', reason: 'out-of-audience' }), why('egress-decision-no-secret-leak', 'a conventional reason code MUST validate')).toBe(true);
+    expect(validate({ decision: 'denied', destination: 'attacker.example', reason: 'out-of-audience' }), req('openwop.it.egress-provenance-shape.reason-is-a-closed-enum-a-free-form-url-bearing-reason-is-rejected-egress-decisi', 'egress-decision-no-secret-leak', 'a conventional reason code MUST validate')).toBe(true);
     expect(
       validate({ decision: 'denied', destination: 'attacker.example', reason: 'https://attacker.example/leak?token=sk-live-xxx' }),
-      why('egress-decision-no-secret-leak', 'a free-form / URL-bearing reason MUST be rejected (it would defeat the content-free guarantee)'),
+      req('openwop.it.egress-provenance-shape.reason-is-a-closed-enum-a-free-form-url-bearing-reason-is-rejected-egress-decisi', 'egress-decision-no-secret-leak', 'a free-form / URL-bearing reason MUST be rejected (it would defeat the content-free guarantee)'),
     ).toBe(false);
   });
 
   it('the egressDecided $def declares no secret-value property', () => {
     const def = ((payloads.$defs as Record<string, { properties?: Record<string, unknown> }>).egressDecided.properties) ?? {};
     for (const p of Object.keys(def)) {
-      expect(SECRET_PROP_NAMES.includes(p.toLowerCase()), why('egress-decision-no-secret-leak', `egress.decided MUST NOT declare a secret-bearing property (${p})`)).toBe(false);
+      expect(SECRET_PROP_NAMES.includes(p.toLowerCase()), req('openwop.it.egress-provenance-shape.the-egressdecided-def-declares-no-secret-value-property', 'egress-decision-no-secret-leak', `egress.decided MUST NOT declare a secret-bearing property (${p})`)).toBe(false);
     }
   });
 
   it('egress.decided is in the RunEventType enum', () => {
     const runEvent = loadSchema('run-event.schema.json');
     const enumVals = ((runEvent.$defs as Record<string, { enum?: string[] }>).RunEventType?.enum) ?? [];
-    expect(enumVals.includes('egress.decided'), why('run-event.schema.json', 'egress.decided MUST be in the RunEventType enum')).toBe(true);
+    expect(enumVals.includes('egress.decided'), req('openwop.it.egress-provenance-shape.egress-decided-is-in-the-runeventtype-enum', 'run-event.schema.json', 'egress.decided MUST be in the RunEventType enum')).toBe(true);
   });
 });
 
@@ -129,9 +128,9 @@ describe('egress-provenance-shape: capability advertisement (RFC 0079 §D, serve
     const caps = loadSchema('capabilities.schema.json');
     const httpClient = (caps.properties as Record<string, { properties?: Record<string, { properties?: Record<string, unknown> }> }>).httpClient;
     const egressPolicy = httpClient?.properties?.egressPolicy;
-    expect(egressPolicy, why('capabilities.md §httpClient', 'httpClient.egressPolicy MUST be declared')).toBeDefined();
+    expect(egressPolicy, req('openwop.it.egress-provenance-shape.capabilities-httpclient-egresspolicy-is-declared-with-its-sub-flags', 'capabilities.md §httpClient', 'httpClient.egressPolicy MUST be declared')).toBeDefined();
     for (const flag of ['supported', 'decisions']) {
-      expect(egressPolicy?.properties?.[flag], why('host-capabilities.md §"Credential provenance + egress policy"', `egressPolicy.${flag} MUST be declared`)).toBeDefined();
+      expect(egressPolicy?.properties?.[flag], req('openwop.it.egress-provenance-shape.capabilities-httpclient-egresspolicy-is-declared-with-its-sub-flags', 'host-capabilities.md §"Credential provenance + egress policy"', `egressPolicy.${flag} MUST be declared`)).toBeDefined();
     }
   });
 });

package/src/scenarios/envelope-completion-distinguishes-truncation.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';
 
 const HTTP_SKIP = !process.env.OPENWOP_BASE_URL;
 const NODE_ID = 'structured-call';
@@ -91,18 +93,18 @@ async function lastBudget(): Promise<number | null> {
 describe.skipIf(HTTP_SKIP)('envelope-completion-distinguishes-truncation: advertisement shape (RFC 0033 §E)', () => {
   it('capabilities.envelopes.reliability.completion (when present) conforms to RFC 0033 §E', 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 completion = capabilityFamily<{ reasoning?: Record<string, unknown>; tierOneSubsetCompliance?: unknown; reliability?: { completion?: Record<string, unknown> } & Record<string, unknown> }>(d, 'envelopes')?.reliability?.completion;
-    if (completion === undefined) return;
+    if (completion === undefined) return softSkip('blocked', 'precondition not met — `completion === undefined` returned early (seam, prior step, or fixture unavailable)');
     expect(
       typeof completion.distinguishesTruncation,
-      driver.describe('RFCS/0033-envelope-completion-contract.md §E', 'completion.distinguishesTruncation MUST be boolean when block is advertised'),
+      req('openwop.it.envelope-completion-distinguishes-truncation.capabilities-envelopes-reliability-completion-when-present-conforms-to-rfc-0033', 'RFCS/0033-envelope-completion-contract.md §E', 'completion.distinguishesTruncation MUST be boolean when block is advertised'),
     ).toBe('boolean');
     if (completion.truncationBudgetMultiplier !== undefined) {
       const n = completion.truncationBudgetMultiplier as number;
       expect(
         typeof n === 'number' && n >= 1 && n <= 8,
-        driver.describe('RFCS/0033-envelope-completion-contract.md §E', 'truncationBudgetMultiplier MUST be a number in [1, 8] (default 2)'),
+        req('openwop.it.envelope-completion-distinguishes-truncation.capabilities-envelopes-reliability-completion-when-present-conforms-to-rfc-0033', 'RFCS/0033-envelope-completion-contract.md §E', 'truncationBudgetMultiplier MUST be a number in [1, 8] (default 2)'),
       ).toBe(true);
     }
   });
@@ -113,24 +115,24 @@ const SCHEMA_VIOLATION_FIXTURE = 'conformance-envelope-retry-attempted';
 
 describe.skipIf(HTTP_SKIP)('envelope-completion-distinguishes-truncation: truncation path (RFC 0033 §B)', () => {
   it('truncation: emits envelope.truncated + envelope.retry.attempted with reason: "truncation"', async () => {
-    if (!isFixtureAdvertised(TRUNCATED_FIXTURE)) return;
+    if (!isFixtureAdvertised(TRUNCATED_FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(TRUNCATED_FIXTURE)` returned early');
     const d = await readDiscovery();
-    if (capabilityFamily<{ reasoning?: Record<string, unknown>; tierOneSubsetCompliance?: unknown; reliability?: { completion?: Record<string, unknown> } & Record<string, unknown> }>(d, 'envelopes')?.reliability?.completion?.distinguishesTruncation !== true) return;
+    if (capabilityFamily<{ reasoning?: Record<string, unknown>; tierOneSubsetCompliance?: unknown; reliability?: { completion?: Record<string, unknown> } & Record<string, unknown> }>(d, 'envelopes')?.reliability?.completion?.distinguishesTruncation !== true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `capabilityFamily<{ reasoning?: Record<string, unknown>; tierOneSubsetCompliance?: unknown; reliability?: { completion?: Record<string, unknown> } & Record<stri…');
     const seed = await programMock([
       { stopReason: 'max_tokens', content: '{"partial' },
       { stopReason: 'end_turn', 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 result = await startRunAndRead(TRUNCATED_FIXTURE);
-    if (result === null) return;
+    if (result === null) return softSkip('blocked', 'precondition not met — `result === null` returned early (seam, prior step, or fixture unavailable)');
     const truncated = result.events.find((e) => e.type === 'envelope.truncated');
-    expect(truncated, 'envelope.truncated MUST fire on the truncation path').toBeDefined();
+    expect(truncated, req('openwop.it.envelope-completion-distinguishes-truncation.truncation-emits-envelope-truncated-envelope-retry-attempted-with-reason-truncat', 'RFCS/0033-envelope-completion-contract.md §B', 'envelope.truncated MUST fire on the truncation path')).toBeDefined();
     const retry = result.events.find((e) => e.type === 'envelope.retry.attempted');
-    expect(retry, 'envelope.retry.attempted MUST fire between attempts').toBeDefined();
+    expect(retry, req('openwop.it.envelope-completion-distinguishes-truncation.truncation-emits-envelope-truncated-envelope-retry-attempted-with-reason-truncat', 'RFCS/0033-envelope-completion-contract.md §B', 'envelope.retry.attempted MUST fire between attempts')).toBeDefined();
     expect(
       retry!.payload?.reason,
-      driver.describe(
+      req('openwop.it.envelope-completion-distinguishes-truncation.truncation-emits-envelope-truncated-envelope-retry-attempted-with-reason-truncat', 
         'RFCS/0033-envelope-completion-contract.md §B',
         'truncation-routed retry MUST carry reason: "truncation" (distinct from schema-violation per RFC 0033 §A precedence rule)',
       ),
@@ -138,21 +140,21 @@ describe.skipIf(HTTP_SKIP)('envelope-completion-distinguishes-truncation: trunca
   });
 
   it('truncation: retry budget strictly greater than initial (RFC 0033 §B truncationBudgetMultiplier)', async () => {
-    if (!isFixtureAdvertised(TRUNCATED_FIXTURE)) return;
+    if (!isFixtureAdvertised(TRUNCATED_FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(TRUNCATED_FIXTURE)` returned early');
     const d = await readDiscovery();
-    if (capabilityFamily<{ reasoning?: Record<string, unknown>; tierOneSubsetCompliance?: unknown; reliability?: { completion?: Record<string, unknown> } & Record<string, unknown> }>(d, 'envelopes')?.reliability?.completion?.distinguishesTruncation !== true) return;
+    if (capabilityFamily<{ reasoning?: Record<string, unknown>; tierOneSubsetCompliance?: unknown; reliability?: { completion?: Record<string, unknown> } & Record<string, unknown> }>(d, 'envelopes')?.reliability?.completion?.distinguishesTruncation !== true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `capabilityFamily<{ reasoning?: Record<string, unknown>; tierOneSubsetCompliance?: unknown; reliability?: { completion?: Record<string, unknown> } & Record<stri…');
     const seed = await programMock([
       { stopReason: 'max_tokens', content: '{"partial' },
       { stopReason: 'end_turn', 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)');
 
     await startRunAndRead(TRUNCATED_FIXTURE);
     const budget = await lastBudget();
-    if (budget === null) return;
+    if (budget === null) return softSkip('blocked', 'precondition not met — `budget === null` returned early (seam, prior step, or fixture unavailable)');
     expect(
       budget,
-      driver.describe(
+      req('openwop.it.envelope-completion-distinguishes-truncation.truncation-retry-budget-strictly-greater-than-initial-rfc-0033-b-truncationbudge', 
         'RFCS/0033-envelope-completion-contract.md §B',
         'truncation retry MUST multiply maxTokens by truncationBudgetMultiplier — final budget > initial 50 fixture value',
       ),
@@ -162,19 +164,19 @@ describe.skipIf(HTTP_SKIP)('envelope-completion-distinguishes-truncation: trunca
 
 describe.skipIf(HTTP_SKIP)('envelope-completion-distinguishes-truncation: schema-violation path (RFC 0033 §C)', () => {
   it('schema-violation: NO envelope.truncated; envelope.retry.attempted reason ∈ {schema-violation, parse-error}', async () => {
-    if (!isFixtureAdvertised(SCHEMA_VIOLATION_FIXTURE)) return;
+    if (!isFixtureAdvertised(SCHEMA_VIOLATION_FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(SCHEMA_VIOLATION_FIXTURE)` returned early');
     const seed = await programMock([
       { content: 'not valid json' },
       { 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 result = await startRunAndRead(SCHEMA_VIOLATION_FIXTURE);
-    if (result === null) return;
+    if (result === null) return softSkip('blocked', 'precondition not met — `result === null` returned early (seam, prior step, or fixture unavailable)');
     const truncated = result.events.find((e) => e.type === 'envelope.truncated');
     expect(
       truncated,
-      driver.describe(
+      req('openwop.it.envelope-completion-distinguishes-truncation.schema-violation-no-envelope-truncated-envelope-retry-attempted-reason-schema-vi', 
         'RFCS/0033-envelope-completion-contract.md §C',
         'schema-violation path MUST NOT emit envelope.truncated (truncation and schema-violation are distinct paths per RFC 0033 §A)',
       ),
@@ -184,7 +186,7 @@ describe.skipIf(HTTP_SKIP)('envelope-completion-distinguishes-truncation: schema
     const reason = retry!.payload?.reason as string | undefined;
     expect(
       reason === 'schema-violation' || reason === 'parse-error',
-      driver.describe(
+      req('openwop.it.envelope-completion-distinguishes-truncation.schema-violation-no-envelope-truncated-envelope-retry-attempted-reason-schema-vi', 
         'RFCS/0033-envelope-completion-contract.md §C',
         'schema-violation-routed retry MUST carry reason ∈ {schema-violation, parse-error}; truncation reason is reserved for the budget-doubling path',
       ),
@@ -192,16 +194,16 @@ describe.skipIf(HTTP_SKIP)('envelope-completion-distinguishes-truncation: schema
   });
 
   it('schema-violation: retry budget UNCHANGED from initial (no budget multiplication on this path)', async () => {
-    if (!isFixtureAdvertised(SCHEMA_VIOLATION_FIXTURE)) return;
+    if (!isFixtureAdvertised(SCHEMA_VIOLATION_FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(SCHEMA_VIOLATION_FIXTURE)` returned early');
     const seed = await programMock([
       { content: 'not valid json' },
       { 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)');
 
     await startRunAndRead(SCHEMA_VIOLATION_FIXTURE);
     const budget = await lastBudget();
-    if (budget === null) return;
+    if (budget === null) return softSkip('blocked', 'precondition not met — `budget === null` returned early (seam, prior step, or fixture unavailable)');
     // The schema-violation fixture doesn't set maxTokens explicitly →
     // budget snapshots whatever the host's default is on each call.
     // The KEY invariant: the retry call's budget MUST NOT be multiplied
@@ -214,7 +216,7 @@ describe.skipIf(HTTP_SKIP)('envelope-completion-distinguishes-truncation: schema
     if (budget !== null) {
       expect(
         budget,
-        driver.describe(
+        req('openwop.it.envelope-completion-distinguishes-truncation.schema-violation-retry-budget-unchanged-from-initial-no-budget-multiplication-on', 
           'RFCS/0033-envelope-completion-contract.md §C',
           'schema-violation retry MUST NOT multiply maxTokens — budget stays at the original value (host default)',
         ),

package/src/scenarios/envelope-nl-to-format-engaged.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-nl-to-format-engaged';
@@ -69,17 +71,17 @@ const NL_THEN_COERCED_PROGRAM = [
 
 describe.skipIf(HTTP_SKIP)('envelope-nl-to-format-engaged: runtime behavior (RFC 0032 §B.5 MAY)', () => {
   it('when retry exhaustion triggers the NL-to-Format fallback, exactly one `envelope.nlToFormat.engaged` event fires', 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(NL_THEN_COERCED_PROGRAM);
-    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 events = await runAndReadEvents();
-    if (events === null) return;
+    if (events === null) return softSkip('blocked', 'precondition not met — `events === null` returned early (seam, prior step, or fixture unavailable)');
     const engagements = events.filter((e) => e.type === 'envelope.nlToFormat.engaged');
     expect(
       engagements.length,
-      driver.describe(
+      req('openwop.it.envelope-nl-to-format-engaged.when-retry-exhaustion-triggers-the-nl-to-format-fallback-exactly-one-envelope-nl', 
         'RFCS/0032-envelope-reliability-events.md §B.5',
         'exactly one envelope.nlToFormat.engaged event MUST fire when the host detects NL-shape responses after retry exhaustion',
       ),
@@ -87,17 +89,17 @@ describe.skipIf(HTTP_SKIP)('envelope-nl-to-format-engaged: runtime behavior (RFC
   });
 
   it('`originalEnvelopeType` carries the envelope kind the original attempt targeted', 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(NL_THEN_COERCED_PROGRAM);
-    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 runAndReadEvents();
-    if (events === null) return;
+    if (events === null) return softSkip('blocked', 'precondition not met — `events === null` returned early (seam, prior step, or fixture unavailable)');
     const engagement = events.find((e) => e.type === 'envelope.nlToFormat.engaged');
     expect(engagement).toBeDefined();
     expect(
       typeof engagement!.payload?.originalEnvelopeType,
-      driver.describe(
+      req('openwop.it.envelope-nl-to-format-engaged.originalenvelopetype-carries-the-envelope-kind-the-original-attempt-targeted', 
         'RFCS/0032-envelope-reliability-events.md §B.5',
         'originalEnvelopeType MUST be present and string-typed — derived from the response-schema or wrapping metadata',
       ),
@@ -106,19 +108,19 @@ describe.skipIf(HTTP_SKIP)('envelope-nl-to-format-engaged: runtime behavior (RFC
   });
 
   it('`fallbackCalls >= 1` reports the number of secondary LLM calls used to reformat free-form output into the envelope schema', 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(NL_THEN_COERCED_PROGRAM);
-    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 runAndReadEvents();
-    if (events === null) return;
+    if (events === null) return softSkip('blocked', 'precondition not met — `events === null` returned early (seam, prior step, or fixture unavailable)');
     const engagement = events.find((e) => e.type === 'envelope.nlToFormat.engaged');
     expect(engagement).toBeDefined();
     const fallbackCalls = engagement!.payload?.fallbackCalls;
     expect(typeof fallbackCalls).toBe('number');
     expect(
       fallbackCalls as number,
-      driver.describe(
+      req('openwop.it.envelope-nl-to-format-engaged.fallbackcalls-1-reports-the-number-of-secondary-llm-calls-used-to-reformat-free', 
         'RFCS/0032-envelope-reliability-events.md §B.5',
         'fallbackCalls MUST be >= 1 — the fallback fired at least one secondary call to reformat the free-form output',
       ),
@@ -126,16 +128,16 @@ describe.skipIf(HTTP_SKIP)('envelope-nl-to-format-engaged: runtime behavior (RFC
   });
 
   it('the eventual envelope acceptance (when fallback succeeds) records normally via 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(NL_THEN_COERCED_PROGRAM);
-    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 runAndReadEvents();
-    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);
     expect(
       nodeCompleted,
-      driver.describe(
+      req('openwop.it.envelope-nl-to-format-engaged.the-eventual-envelope-acceptance-when-fallback-succeeds-records-normally-via-dow', 
         'RFCS/0032-envelope-reliability-events.md §B.5',
         'NL-to-Format fallback success MUST reach node.completed — the coerced envelope flows downstream like any other accepted envelope',
       ),
@@ -143,7 +145,7 @@ describe.skipIf(HTTP_SKIP)('envelope-nl-to-format-engaged: runtime behavior (RFC
     const completedPayload = JSON.stringify(nodeCompleted?.payload ?? {});
     expect(
       completedPayload.includes('coerced-ok'),
-      driver.describe(
+      req('openwop.it.envelope-nl-to-format-engaged.the-eventual-envelope-acceptance-when-fallback-succeeds-records-normally-via-dow', 
         'RFCS/0032-envelope-reliability-events.md §B.5',
         'the coerced structured data from the secondary call MUST flow to the downstream RunEventDoc',
       ),