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

package/src/scenarios/envelope-reasoning-secret-redaction.test.ts

@@ -36,6 +36,8 @@
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.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;
 
@@ -97,13 +99,13 @@ const CANONICAL_MARKER = `[REDACTED:${CANARY_SECRET_ID}]`;
 describe.skipIf(HTTP_SKIP)('envelope-reasoning-secret-redaction: advertisement shape (RFC 0030 §E)', () => {
   it('hosts advertising envelope reasoning + BYOK honor SR-1 carry-forward for the reasoning field', 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 reasoning = capabilityFamily<{ reasoning?: Record<string, unknown>; tierOneSubsetCompliance?: unknown; reliability?: { completion?: Record<string, unknown> } & Record<string, unknown> }>(d, 'envelopes')?.reasoning?.supported;
     const secrets = capabilityFamily<{ supported?: unknown }>(d, 'secrets')?.supported;
-    if (reasoning !== true || secrets !== true) return; // soft-skip when either is absent
+    if (reasoning !== true || secrets !== true) return softSkip('blocked', 'precondition not met — `reasoning !== true || secrets !== true` returned early (soft-skip when either is absent) (seam, prior step, or fixture unavailable)'); // soft-skip when either is absent
     // The contract is invariant-based, not capability-flag-based — the
     // advertisement-shape check here just confirms both surfaces are claimed.
-    expect(true).toBe(true);
+    expect(true, req('openwop.it.envelope-reasoning-secret-redaction.hosts-advertising-envelope-reasoning-byok-honor-sr-1-carry-forward-for-the-reaso', 'RFC 0030 §E', 'hosts advertising envelope reasoning + BYOK honor SR-1 carry-forward for the reasoning field')).toBe(true);
   });
 });
 
@@ -124,22 +126,22 @@ describe.skipIf(HTTP_SKIP)('envelope-reasoning-secret-redaction: BYOK redaction
       },
       { byokCanaries: CANARIES },
     );
-    if (r.status === 404) return; // host doesn't expose the seam
-    expect(r.body.status, 'envelope MUST be accepted; redaction is a post-validation pass').toBe('accepted');
+    if (r.status === 404) return softSkip('blocked', 'precondition not met — `r.status === 404` returned early (host doesn\'t expose the seam) (seam, prior step, or fixture unavailable)'); // host doesn't expose the seam
+    expect(r.body.status, req('openwop.it.envelope-reasoning-secret-redaction.canary-in-reasoning-substituted-with-canonical-redacted-secretid-marker-per-agen', 'ai-envelope.md §"Redaction (SR-1 carry-forward)"', 'envelope MUST be accepted; redaction is a post-validation pass')).toBe('accepted');
     expect(
       r.body.redactionCount,
-      'RFC 0030 §E: redactionCount MUST be > 0 when a canary appears in `reasoning`',
+      req('openwop.it.envelope-reasoning-secret-redaction.canary-in-reasoning-substituted-with-canonical-redacted-secretid-marker-per-agen', 'ai-envelope.md §"Redaction (SR-1 carry-forward)"', 'RFC 0030 §E: redactionCount MUST be > 0 when a canary appears in `reasoning`'),
     ).toBeGreaterThan(0);
     expect(
       JSON.stringify(r.body.redactedPayload).includes(CANARY_VALUE),
-      driver.describe(
+      req('openwop.it.envelope-reasoning-secret-redaction.canary-in-reasoning-substituted-with-canonical-redacted-secretid-marker-per-agen', 
         'ai-envelope.md §"Redaction (SR-1 carry-forward)"',
         'canary plaintext MUST NOT remain anywhere in the redacted view — `reasoning` field included',
       ),
     ).toBe(false);
     expect(
       JSON.stringify(r.body.redactedPayload),
-      driver.describe(
+      req('openwop.it.envelope-reasoning-secret-redaction.canary-in-reasoning-substituted-with-canonical-redacted-secretid-marker-per-agen', 
         'agent-memory.md §SR-1 line 66',
         'persisted entry MUST carry [REDACTED:<secretId>] in place of the plaintext',
       ),
@@ -162,15 +164,15 @@ describe.skipIf(HTTP_SKIP)('envelope-reasoning-secret-redaction: BYOK redaction
       },
       { byokCanaries: CANARIES },
     );
-    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.body.status).toBe('accepted');
     expect(
       JSON.stringify(r.body.redactedPayload).includes(CANARY_VALUE),
-      'no canary plaintext remnant anywhere — `reasoning` + `message` both walked recursively',
+      req('openwop.it.envelope-reasoning-secret-redaction.canary-in-reasoning-and-another-payload-field-both-occurrences-scrubbed-with-sin', 'RFC 0030 §E', 'no canary plaintext remnant anywhere — `reasoning` + `message` both walked recursively'),
     ).toBe(false);
     expect(
       r.body.redactionCount,
-      'recursive walk substitutes once per occurrence; 2 occurrences = redactionCount: 2',
+      req('openwop.it.envelope-reasoning-secret-redaction.canary-in-reasoning-and-another-payload-field-both-occurrences-scrubbed-with-sin', 'RFC 0030 §E', 'recursive walk substitutes once per occurrence; 2 occurrences = redactionCount: 2'),
     ).toBe(2);
   });
 
@@ -190,13 +192,13 @@ describe.skipIf(HTTP_SKIP)('envelope-reasoning-secret-redaction: BYOK redaction
       },
       { byokCanaries: CANARIES }, // canary in fixture, but NOT in payload
     );
-    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.body.status).toBe('accepted');
-    expect(r.body.redactionCount, 'no canary occurrence → redactionCount: 0').toBe(0);
+    expect(r.body.redactionCount, req('openwop.it.envelope-reasoning-secret-redaction.absent-canary-in-reasoning-reasoning-passes-through-unchanged-no-false-positive', 'RFC 0030 §E', 'no canary occurrence → redactionCount: 0')).toBe(0);
     const payload = (r.body.redactedPayload ?? {}) as { reasoning?: string };
     expect(
       payload.reasoning,
-      'reasoning field MUST pass through unchanged when no canary substring matches',
+      req('openwop.it.envelope-reasoning-secret-redaction.absent-canary-in-reasoning-reasoning-passes-through-unchanged-no-false-positive', 'RFC 0030 §E', 'reasoning field MUST pass through unchanged when no canary substring matches'),
     ).toBe('The input was empty; I declined to fabricate a response.');
   });
 
@@ -215,8 +217,8 @@ describe.skipIf(HTTP_SKIP)('envelope-reasoning-secret-redaction: BYOK redaction
       },
       { byokCanaries: CANARIES },
     );
-    if (r.status === 404) return;
-    expect(r.body.status).toBe('accepted');
+    if (r.status === 404) return softSkip('blocked', 'precondition not met — `r.status === 404` returned early (seam, prior step, or fixture unavailable)');
+    expect(r.body.status, req('openwop.it.envelope-reasoning-secret-redaction.canary-in-clarification-request-reasoning-universal-kind-with-reasoning-property', 'RFC 0030 §E', 'canary in `clarification.request.reasoning` (universal kind with reasoning property)')).toBe('accepted');
     expect(JSON.stringify(r.body.redactedPayload).includes(CANARY_VALUE)).toBe(false);
     expect(JSON.stringify(r.body.redactedPayload)).toContain(CANONICAL_MARKER);
   });
@@ -259,13 +261,13 @@ describe.skipIf(HTTP_SKIP)('envelope-reasoning-secret-redaction: downstream-proj
     // Hosts that don't advertise it soft-skip; hosts that DO advertise MUST serve a valid response.
     const d = await readDiscovery();
     const otelScrapeAdvertised = capabilityFamily<{ testSeams?: Record<string, unknown> }>(d, 'observability')?.testSeams?.otelScrape === true;
-    if (!otelScrapeAdvertised) return; // soft-skip — host honest about not implementing per RFC 0034 §A
+    if (!otelScrapeAdvertised) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!otelScrapeAdvertised` returned early (soft-skip — host honest about not implementing per RFC 0034 §A)'); // soft-skip — host honest about not implementing per RFC 0034 §A
 
     const r = await acceptForRun(
       `Reasoning trace mentioning ${CANARY_VALUE} verbatim.`,
       'env-otel-redact-1',
     );
-    if (r.status === 404) return; // envelope-accept seam itself not exposed — separate gate
+    if (r.status === 404) return softSkip('blocked', 'precondition not met — `r.status === 404` returned early (envelope-accept seam itself not exposed — separate gate) (seam, prior step, or fixture unavailable)'); // envelope-accept seam itself not exposed — separate gate
     expect(r.body.status).toBe('accepted');
 
     const spansRes = await driver.get(
@@ -273,7 +275,7 @@ describe.skipIf(HTTP_SKIP)('envelope-reasoning-secret-redaction: downstream-proj
     );
     expect(
       spansRes.status,
-      driver.describe(
+      req('openwop.it.envelope-reasoning-secret-redaction.otel-span-attributes-for-the-envelope-emitting-node-must-not-include-plaintext-s', 
         'RFCS/0034-otel-collector-test-seam.md §B',
         'host advertising capabilities.observability.testSeams.otelScrape MUST serve the seam (200) — 404 is non-conformant',
       ),
@@ -282,7 +284,7 @@ describe.skipIf(HTTP_SKIP)('envelope-reasoning-secret-redaction: downstream-proj
     const serialized = JSON.stringify(spans);
     expect(
       serialized.includes(CANARY_VALUE),
-      driver.describe(
+      req('openwop.it.envelope-reasoning-secret-redaction.otel-span-attributes-for-the-envelope-emitting-node-must-not-include-plaintext-s', 
         'SECURITY/invariants.yaml secret-leakage-otel-attribute',
         'no canary plaintext from the envelope `reasoning` field may appear in any OTel span attribute',
       ),
@@ -293,19 +295,19 @@ describe.skipIf(HTTP_SKIP)('envelope-reasoning-secret-redaction: downstream-proj
     // RFC 0034 §B: gate on capabilities.observability.testSeams.debugBundleExport.
     const d = await readDiscovery();
     const debugBundleAdvertised = capabilityFamily<{ testSeams?: Record<string, unknown> }>(d, 'observability')?.testSeams?.debugBundleExport === true;
-    if (!debugBundleAdvertised) return; // soft-skip — host honest about not implementing per RFC 0034 §A
+    if (!debugBundleAdvertised) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!debugBundleAdvertised` returned early (soft-skip — host honest about not implementing per RFC 0034 §A)'); // soft-skip — host honest about not implementing per RFC 0034 §A
 
     const r = await acceptForRun(
       `Step-by-step reasoning that surfaces ${CANARY_VALUE} from a prior tool result.`,
       'env-bundle-redact-1',
     );
-    if (r.status === 404) return; // envelope-accept seam itself not exposed — separate gate
+    if (r.status === 404) return softSkip('blocked', 'precondition not met — `r.status === 404` returned early (envelope-accept seam itself not exposed — separate gate) (seam, prior step, or fixture unavailable)'); // envelope-accept seam itself not exposed — separate gate
     expect(r.body.status).toBe('accepted');
 
     const bundleRes = await driver.post('/v1/host/sample/test/debug-bundle/export', { runId: RUN_ID });
     expect(
       bundleRes.status,
-      driver.describe(
+      req('openwop.it.envelope-reasoning-secret-redaction.debug-bundle-export-must-not-include-plaintext-secret-prefixed-substrings-from-e', 
         'RFCS/0034-otel-collector-test-seam.md §B',
         'host advertising capabilities.observability.testSeams.debugBundleExport MUST serve the seam (200) — 404 is non-conformant',
       ),
@@ -313,7 +315,7 @@ describe.skipIf(HTTP_SKIP)('envelope-reasoning-secret-redaction: downstream-proj
     const serialized = JSON.stringify(bundleRes.json);
     expect(
       serialized.includes(CANARY_VALUE),
-      driver.describe(
+      req('openwop.it.envelope-reasoning-secret-redaction.debug-bundle-export-must-not-include-plaintext-secret-prefixed-substrings-from-e', 
         'SECURITY/invariants.yaml secret-leakage-debug-bundle-otel',
         'no canary plaintext from envelope.reasoning may appear in the debug-bundle export',
       ),
@@ -330,12 +332,12 @@ describe.skipIf(HTTP_SKIP)('envelope-reasoning-secret-redaction: downstream-proj
       `reasoning-variant-B with embedded ${CANARY_VALUE} canary — host MUST NOT route differently.`,
       'env-route-B',
     );
-    if (aResp.status === 404 || bResp.status === 404) return;
+    if (aResp.status === 404 || bResp.status === 404) return softSkip('blocked', 'precondition not met — `aResp.status === 404 || bResp.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(aResp.body.status).toBe('accepted');
     expect(bResp.body.status).toBe('accepted');
     expect(
       aResp.body.status,
-      driver.describe(
+      req('openwop.it.envelope-reasoning-secret-redaction.envelope-acceptance-must-not-route-on-reasoning-contents-rfc-0030-a-normative-mu', 
         'RFCS/0030-envelope-reasoning-and-tier-one-subset.md §A',
         'reasoning is informational only; routing decision MUST NOT depend on its contents',
       ),

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

@@ -33,6 +33,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;
 
@@ -78,15 +80,15 @@ describe('envelope-reasoning-shape: universal-kind schemas (RFC 0030 §A)', () =
       const required = (schema.required as string[] | undefined) ?? [];
       expect(
         properties?.reasoning,
-        `RFC 0030 §A: ${kind}.schema.json MUST declare a \`reasoning\` property`,
+        req('openwop.it.envelope-reasoning-shape.schema-json-declares-optional-reasoning-string-per-rfc-0030-a', 'RFC 0030 §A', `RFC 0030 §A: ${kind}.schema.json MUST declare a \`reasoning\` property`),
       ).toBeDefined();
       expect(
         properties?.reasoning?.type,
-        'RFC 0030 §A: `reasoning` MUST be type: string on universal-kind schemas',
+        req('openwop.it.envelope-reasoning-shape.schema-json-declares-optional-reasoning-string-per-rfc-0030-a', 'RFC 0030 §A', 'RFC 0030 §A: `reasoning` MUST be type: string on universal-kind schemas'),
       ).toBe('string');
       expect(
         required.includes('reasoning'),
-        `RFC 0030 §A: ${kind}.schema.json MUST NOT list \`reasoning\` in required (OPTIONAL field; absence is a valid envelope shape)`,
+        req('openwop.it.envelope-reasoning-shape.schema-json-declares-optional-reasoning-string-per-rfc-0030-a', 'RFC 0030 §A', `RFC 0030 §A: ${kind}.schema.json MUST NOT list \`reasoning\` in required (OPTIONAL field; absence is a valid envelope shape)`),
       ).toBe(false);
     });
   }
@@ -96,7 +98,7 @@ describe('envelope-reasoning-shape: universal-kind schemas (RFC 0030 §A)', () =
     const properties = schema.properties as Record<string, Record<string, unknown>> | undefined;
     expect(
       properties?.reasoning,
-      'RFC 0030 §A: `schema.response` is a side-channel ack envelope; it MUST NOT declare `reasoning`',
+      req('openwop.it.envelope-reasoning-shape.schema-response-schema-json-deliberately-omits-reasoning-side-channel-ack-per-rf', 'RFC 0030 §A', 'RFC 0030 §A: `schema.response` is a side-channel ack envelope; it MUST NOT declare `reasoning`'),
     ).toBeUndefined();
   });
 });
@@ -115,7 +117,7 @@ describe('envelope-reasoning-shape: backward-compat round-trip (RFC 0030 §A)',
     const payload = { questions: [{ id: 'q1', question: 'What do you mean by X?' }] };
     expect(
       validateClarification(payload),
-      'RFC 0030 §A: existing v1.1 envelope without `reasoning` MUST remain valid',
+      req('openwop.it.envelope-reasoning-shape.clarification-request-validates-a-payload-without-reasoning-backward-compat', 'RFC 0030 §A', 'RFC 0030 §A: existing v1.1 envelope without `reasoning` MUST remain valid'),
     ).toBe(true);
   });
 
@@ -126,13 +128,13 @@ describe('envelope-reasoning-shape: backward-compat round-trip (RFC 0030 §A)',
     };
     expect(
       validateClarification(payload),
-      'RFC 0030 §A: envelope with optional `reasoning` populated MUST be accepted',
+      req('openwop.it.envelope-reasoning-shape.clarification-request-validates-a-payload-with-reasoning', 'RFC 0030 §A', 'RFC 0030 §A: envelope with optional `reasoning` populated MUST be accepted'),
     ).toBe(true);
   });
 
   it('error envelope validates without reasoning (backward compat)', () => {
     const payload = { code: 'validation_failed', message: 'Could not match the schema.' };
-    expect(validateError(payload)).toBe(true);
+    expect(validateError(payload), req('openwop.it.envelope-reasoning-shape.error-envelope-validates-without-reasoning-backward-compat', 'RFC 0030 §A', 'error envelope validates without reasoning (backward compat)')).toBe(true);
   });
 
   it('error envelope validates with reasoning', () => {
@@ -141,11 +143,11 @@ describe('envelope-reasoning-shape: backward-compat round-trip (RFC 0030 §A)',
       code: 'validation_failed',
       message: 'Could not match the schema.',
     };
-    expect(validateError(payload)).toBe(true);
+    expect(validateError(payload), req('openwop.it.envelope-reasoning-shape.error-envelope-validates-with-reasoning', 'RFC 0030 §A', 'error envelope validates with reasoning')).toBe(true);
   });
 
   it('schema.request validates without reasoning', () => {
-    expect(validateSchemaRequest({ envelopeType: 'vendor.acme.prd.create' })).toBe(true);
+    expect(validateSchemaRequest({ envelopeType: 'vendor.acme.prd.create' }), req('openwop.it.envelope-reasoning-shape.schema-request-validates-without-reasoning', 'RFC 0030 §A', 'schema.request validates without reasoning')).toBe(true);
   });
 
   it('rejects reasoning of non-string type (universal kinds use plain string, not string|null union)', () => {
@@ -155,7 +157,7 @@ describe('envelope-reasoning-shape: backward-compat round-trip (RFC 0030 §A)',
     };
     expect(
       validateClarification(payload),
-      'RFC 0030 §A: universal-kind `reasoning` MUST be type: string; numbers reject',
+      req('openwop.it.envelope-reasoning-shape.rejects-reasoning-of-non-string-type-universal-kinds-use-plain-string-not-string', 'RFC 0030 §A', 'RFC 0030 §A: universal-kind `reasoning` MUST be type: string; numbers reject'),
     ).toBe(false);
   });
 });
@@ -163,29 +165,29 @@ describe('envelope-reasoning-shape: backward-compat round-trip (RFC 0030 §A)',
 describe.skipIf(HTTP_SKIP)('envelope-reasoning-shape: capabilities.envelopes advertisement (RFC 0030 §C)', () => {
   it('capabilities.envelopes.reasoning (when present) conforms to RFC 0030 §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 reasoning = capabilityFamily<{ reasoning?: Record<string, unknown>; tierOneSubsetCompliance?: unknown; reliability?: { completion?: Record<string, unknown> } & Record<string, unknown> }>(d, 'envelopes')?.reasoning;
-    if (reasoning === undefined) return; // optional block; host MAY omit
+    if (reasoning === undefined) return softSkip('blocked', 'precondition not met — `reasoning === undefined` returned early (optional block; host MAY omit) (seam, prior step, or fixture unavailable)'); // optional block; host MAY omit
     expect(
       typeof reasoning.supported,
-      'RFC 0030 §C: capabilities.envelopes.reasoning.supported MUST be boolean when block is advertised',
+      req('openwop.it.envelope-reasoning-shape.capabilities-envelopes-reasoning-when-present-conforms-to-rfc-0030-c', 'RFC 0030 §C', 'RFC 0030 §C: capabilities.envelopes.reasoning.supported MUST be boolean when block is advertised'),
     ).toBe('boolean');
     if (reasoning.promptDirective !== undefined) {
       expect(
         ['mandatory', 'advisory', 'off'],
-        'RFC 0030 §C: promptDirective MUST be one of the three documented values',
+        req('openwop.it.envelope-reasoning-shape.capabilities-envelopes-reasoning-when-present-conforms-to-rfc-0030-c', 'RFC 0030 §C', 'RFC 0030 §C: promptDirective MUST be one of the three documented values'),
       ).toContain(String(reasoning.promptDirective));
     }
   });
 
   it('capabilities.envelopes.tierOneSubsetCompliance (when present) conforms to RFC 0030 §B', 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 compliance = capabilityFamily<{ reasoning?: Record<string, unknown>; tierOneSubsetCompliance?: unknown; reliability?: { completion?: Record<string, unknown> } & Record<string, unknown> }>(d, 'envelopes')?.tierOneSubsetCompliance;
-    if (compliance === undefined) return; // optional; host MAY omit
+    if (compliance === undefined) return softSkip('blocked', 'precondition not met — `compliance === undefined` returned early (optional; host MAY omit) (seam, prior step, or fixture unavailable)'); // optional; host MAY omit
     expect(
       ['strict', 'warn', 'off'],
-      'RFC 0030 §B: tierOneSubsetCompliance MUST be one of strict|warn|off',
+      req('openwop.it.envelope-reasoning-shape.capabilities-envelopes-tieronesubsetcompliance-when-present-conforms-to-rfc-0030', 'RFC 0030 §B', 'RFC 0030 §B: tierOneSubsetCompliance MUST be one of strict|warn|off'),
     ).toContain(String(compliance));
   });
 });

package/src/scenarios/envelope-recovery-applied.test.ts

@@ -44,8 +44,8 @@ describe.skipIf(HTTP_SKIP)('envelope-recovery-applied: seam emission (RFC 0032
         byteOffset: 42,
       },
     });
-    if (r.status === 404) return;
-    expect(r.status).toBe(200);
+    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-recovery-applied.accepts-a-well-formed-envelope-recovery-applied-payload-with-markdown-fence-path', 'RFC 0032 §B.6', 'accepts a well-formed `envelope.recovery.applied` payload with markdown-fence path')).toBe(200);
     expect(r.body.event?.type).toBe('envelope.recovery.applied');
     expect(r.body.event?.payload?.path).toBe('markdown-fence');
     expect(r.body.event?.payload?.byteOffset).toBe(42);
@@ -58,8 +58,8 @@ describe.skipIf(HTTP_SKIP)('envelope-recovery-applied: seam emission (RFC 0032
         type: 'envelope.recovery.applied',
         payload: { nodeId: 'writer', path },
       });
-      if (r.status === 404) return;
-      expect(r.status, `path: ${path} MUST be accepted`).toBe(200);
+      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-recovery-applied.accepts-each-spec-reserved-path-enum-value', 'RFC 0032 §B.6', `path: ${path} MUST be accepted`)).toBe(200);
       expect(r.body.event?.payload?.path).toBe(path);
     }
   });
@@ -76,10 +76,10 @@ describe.skipIf(HTTP_SKIP)('envelope-recovery-applied: SECURITY invariant envelo
         recoveredContent: 'this is the pre-recovery output that should NOT be in the event', // forbidden per §G
       },
     });
-    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-recovery-applied.rejects-payloads-carrying-a-recoveredcontent-field-pre-recovery-output-must-not', 
         'SECURITY/invariants.yaml §envelope-recovery-no-content-leak',
         'envelope.recovery.applied payload MUST NOT carry pre-recovery output substrings; only the canonical {nodeId, path, byteOffset?} keys per RFC 0032 §B.6 + §G — the recovered content rides on downstream RunEventDoc, not on the recovery event',
       ),
@@ -97,10 +97,10 @@ describe.skipIf(HTTP_SKIP)('envelope-recovery-applied: SECURITY invariant envelo
         sourceSnippet: 'arbitrary extra key', // forbidden by additionalProperties: false in the schema
       },
     });
-    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-recovery-applied.rejects-payloads-carrying-any-extra-field-outside-nodeid-path-byteoffset', 
         'schemas/run-event-payloads.schema.json §envelopeRecoveryApplied',
         'envelope.recovery.applied has additionalProperties: false on the payload — any extra field MUST be rejected to prevent regression carriers for pre-recovery output (defense-in-depth on top of envelope-recovery-no-content-leak)',
       ),
@@ -122,6 +122,8 @@ describe.skipIf(HTTP_SKIP)('envelope-recovery-applied: SECURITY invariant envelo
 
 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 RECOVERY_FIXTURE = 'conformance-envelope-recovery-applied';
 const RECOVERY_NODE_ID = 'structured-call';
@@ -150,29 +152,29 @@ async function runAndReadEvents(): Promise<ProgrammedRunEvent[] | null> {
 
 describe.skipIf(HTTP_SKIP)('envelope-recovery-applied: end-to-end through the envelope-validation pipeline', () => {
   it('when mock LLM emits envelope wrapped in markdown fence, exactly one `envelope.recovery.applied` event fires with `path: "markdown-fence"`', async () => {
-    if (!isFixtureAdvertised(RECOVERY_FIXTURE)) return;
+    if (!isFixtureAdvertised(RECOVERY_FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(RECOVERY_FIXTURE)` returned early');
     const seed = await programRecovery([
       // Markdown-fenced JSON — dispatchStructured's strict parse fails,
       // tryLenientParse() strips the fence + succeeds via the
       // 'markdown-fence' path.
       { content: '```json\n{"result":"ok"}\n```' },
     ]);
-    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 recoveries = events.filter((e) => e.type === 'envelope.recovery.applied');
     expect(
       recoveries.length,
-      driver.describe(
+      req('openwop.it.envelope-recovery-applied.when-mock-llm-emits-envelope-wrapped-in-markdown-fence-exactly-one-envelope-reco', 
         'RFCS/0032-envelope-reliability-events.md §B.6',
         'exactly one envelope.recovery.applied event MUST fire when lenient parsing strips a markdown fence',
       ),
     ).toBe(1);
     expect(
       recoveries[0]?.payload?.path,
-      driver.describe(
+      req('openwop.it.envelope-recovery-applied.when-mock-llm-emits-envelope-wrapped-in-markdown-fence-exactly-one-envelope-reco', 
         'RFCS/0032-envelope-reliability-events.md §B.6',
         'path MUST identify the recovery strategy that engaged (markdown-fence here)',
       ),
@@ -180,18 +182,18 @@ describe.skipIf(HTTP_SKIP)('envelope-recovery-applied: end-to-end through the en
   });
 
   it('recovery does NOT consume a retry attempt — `envelope.retry.attempted` does NOT fire as a consequence of recovery (RFC 0033 §D)', async () => {
-    if (!isFixtureAdvertised(RECOVERY_FIXTURE)) return;
+    if (!isFixtureAdvertised(RECOVERY_FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(RECOVERY_FIXTURE)` returned early');
     const seed = await programRecovery([
       { content: '```json\n{"result":"ok"}\n```' },
     ]);
-    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 retries = events.filter((e) => e.type === 'envelope.retry.attempted');
     expect(
       retries.length,
-      driver.describe(
+      req('openwop.it.envelope-recovery-applied.recovery-does-not-consume-a-retry-attempt-envelope-retry-attempted-does-not-fire', 
         'RFCS/0033-envelope-completion-contract.md §D',
         'recovery (parse fix-up) MUST NOT count against the retry budget — no envelope.retry.attempted may fire',
       ),
@@ -199,18 +201,18 @@ describe.skipIf(HTTP_SKIP)('envelope-recovery-applied: end-to-end through the en
   });
 
   it('recovered envelope is subsequently accepted normally; downstream RunEventDoc carries the recovered content', async () => {
-    if (!isFixtureAdvertised(RECOVERY_FIXTURE)) return;
+    if (!isFixtureAdvertised(RECOVERY_FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(RECOVERY_FIXTURE)` returned early');
     const seed = await programRecovery([
       { content: '```json\n{"result":"recovered-ok"}\n```' },
     ]);
-    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 === RECOVERY_NODE_ID);
     expect(
       nodeCompleted,
-      driver.describe(
+      req('openwop.it.envelope-recovery-applied.recovered-envelope-is-subsequently-accepted-normally-downstream-runeventdoc-carr', 
         'RFCS/0032-envelope-reliability-events.md §B.6',
         'recovered envelope MUST reach node.completed — recovery does not block downstream acceptance',
       ),
@@ -221,7 +223,7 @@ describe.skipIf(HTTP_SKIP)('envelope-recovery-applied: end-to-end through the en
     const completedPayload = JSON.stringify(nodeCompleted?.payload ?? {});
     expect(
       completedPayload.includes('recovered-ok'),
-      driver.describe(
+      req('openwop.it.envelope-recovery-applied.recovered-envelope-is-subsequently-accepted-normally-downstream-runeventdoc-carr', 
         'RFCS/0032-envelope-reliability-events.md §B.6',
         'recovered structured data MUST flow to the downstream RunEventDoc unchanged',
       ),