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

package/src/scenarios/aiEnvelope.contractRefusal.test.ts

@@ -35,10 +35,10 @@ describe('aiEnvelope.contractRefusal: advertisement shape (FINAL v1.1)', () => {
     const body = res.json as DiscoveryDoc | undefined;
     const top = discoveryFamilies(body);
     const block = top && typeof top === 'object' ? top['envelopeContracts'] : undefined;
-    if (block === undefined) return; // absent — skip
+    if (block === undefined) return softSkip('blocked', 'precondition not met — `block === undefined` returned early (absent — skip) (seam, prior step, or fixture unavailable)'); // absent — skip
     expect(
       typeof (block as Record<string, unknown>)['advertised'],
-      driver.describe(
+      req('openwop.it.aiEnvelope.contractRefusal.opted-in-hosts-advertise-envelopecontracts-advertised-as-a-boolean', 
         'ai-envelope.md §"Capability handshake integration"',
         'envelopeContracts.advertised MUST be a boolean when present',
       ),
@@ -69,10 +69,10 @@ describe('aiEnvelope.contractRefusal: behavioral accept-gate (FINAL v1.1)', () =
         nodeAllowedKinds: ['vendor.x.foo.create'],
       },
     );
-    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,
-      driver.describe('ai-envelope.md §"Envelope Contract"', 'envelope outside node accepts[] MUST be refused'),
+      req('openwop.it.aiEnvelope.contractRefusal.node-with-nodeallowedkinds-vendor-x-foo-create-emits-vendor-x-bar-create-status', 'ai-envelope.md §"Envelope Contract"', 'envelope outside node accepts[] MUST be refused'),
     ).toBe('gated');
   });
 
@@ -91,9 +91,9 @@ describe('aiEnvelope.contractRefusal: behavioral accept-gate (FINAL v1.1)', () =
         nodeAllowedKinds: ['vendor.x.foo.create'],
       },
     );
-    if (r.status === 404) return;
-    expect(Array.isArray(r.body.allowedKinds), 'allowedKinds MUST be an array').toBe(true);
-    expect(r.body.allowedKinds, 'allowedKinds MUST include universals + declared accepts').toEqual(
+    if (r.status === 404) return softSkip('blocked', 'precondition not met — `r.status === 404` returned early (seam, prior step, or fixture unavailable)');
+    expect(Array.isArray(r.body.allowedKinds), req('openwop.it.aiEnvelope.contractRefusal.gated-outcome-carries-the-union-of-universals-node-declared-accepts-as-allowedki', 'spec/v1/ai-envelope.md', 'allowedKinds MUST be an array')).toBe(true);
+    expect(r.body.allowedKinds, req('openwop.it.aiEnvelope.contractRefusal.gated-outcome-carries-the-union-of-universals-node-declared-accepts-as-allowedki', 'spec/v1/ai-envelope.md', 'allowedKinds MUST include universals + declared accepts')).toEqual(
       expect.arrayContaining(['clarification.request', 'schema.request', 'schema.response', 'error', 'vendor.x.foo.create']),
     );
   });
@@ -110,10 +110,10 @@ describe('aiEnvelope.contractRefusal: behavioral accept-gate (FINAL v1.1)', () =
       },
       { nodeAllowedKinds: ['vendor.x.foo.create'] }, // doesn't include clarification.request
     );
-    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,
-      driver.describe('ai-envelope.md §"Universal kinds"', 'universal kinds MUST be accepted regardless of node accepts[]'),
+      req('openwop.it.aiEnvelope.contractRefusal.universals-are-accepted-regardless-of-nodeallowedkinds-always-allowed', 'ai-envelope.md §"Universal kinds"', 'universal kinds MUST be accepted regardless of node accepts[]'),
     ).toBe('accepted');
   });
 
@@ -132,20 +132,22 @@ describe('aiEnvelope.contractRefusal: behavioral accept-gate (FINAL v1.1)', () =
         nodeAllowedKinds: ['vendor.unadvertised.kind'], // node would allow but host doesn't
       },
     );
-    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,
-      driver.describe('ai-envelope.md §"Capability handshake integration"', 'host gate MUST fire before node gate'),
+      req('openwop.it.aiEnvelope.contractRefusal.host-supportedenvelopes-gate-fires-before-node-accepts-gate-kind-unadvertised-ga', 'ai-envelope.md §"Capability handshake integration"', 'host gate MUST fire before node gate'),
     ).toBe('gated');
   });
 });
 
 // E.1 engine-projection via the test-only event-log seam.
 import { queryTestEvents, isEventLogSeamAvailable, resetTestSeam } from '../lib/event-log-query.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 describe('aiEnvelope.contractRefusal: engine projection via event-log seam', () => {
   it('gated (fail-node) → node.failed { error.code: "envelope_contract_violation" }', async () => {
-    if (!(await isEventLogSeamAvailable())) return;
+    if (!(await isEventLogSeamAvailable())) return softSkip('blocked', 'precondition not met — `!(await isEventLogSeamAvailable())` returned early (seam, prior step, or fixture unavailable)');
     const runId = `r-cr-fail-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     const r = await accept(
       {
@@ -162,19 +164,19 @@ describe('aiEnvelope.contractRefusal: engine projection via event-log seam', ()
         projectTo: { runId, nodeId: 'n', refusalMode: 'fail-node' },
       },
     );
-    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('gated');
     const events = await queryTestEvents(runId, { type: 'node.failed' });
-    if (!events.ok || events.events.length === 0) return;
+    if (!events.ok || events.events.length === 0) return softSkip('blocked', 'precondition not met — `!events.ok || events.events.length === 0` returned early (seam, prior step, or fixture unavailable)');
     const err = events.events[0]!.payload.error as { code?: string; details?: { refusedType?: string; acceptedTypes?: string[] } };
     expect(
       err.code,
-      driver.describe('ai-envelope.md §"Envelope Contract"', 'gated outcome MUST project to node.failed with error.code = envelope_contract_violation'),
+      req('openwop.it.aiEnvelope.contractRefusal.gated-fail-node-node-failed-error-code-envelope-contract-violation', 'ai-envelope.md §"Envelope Contract"', 'gated outcome MUST project to node.failed with error.code = envelope_contract_violation'),
     ).toBe('envelope_contract_violation');
   });
 
   it('refused envelope: error.details.refusedType names emitted kind; acceptedTypes lists allowed kinds', async () => {
-    if (!(await isEventLogSeamAvailable())) return;
+    if (!(await isEventLogSeamAvailable())) return softSkip('blocked', 'precondition not met — `!(await isEventLogSeamAvailable())` returned early (seam, prior step, or fixture unavailable)');
     const runId = `r-cr-details-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     await accept(
       {
@@ -192,17 +194,17 @@ describe('aiEnvelope.contractRefusal: engine projection via event-log seam', ()
       },
     );
     const events = await queryTestEvents(runId, { type: 'node.failed' });
-    if (!events.ok || events.events.length === 0) return;
+    if (!events.ok || events.events.length === 0) return softSkip('blocked', 'precondition not met — `!events.ok || events.events.length === 0` returned early (seam, prior step, or fixture unavailable)');
     const details = (events.events[0]!.payload.error as { details?: { refusedType?: string; acceptedTypes?: string[] } }).details;
     expect(details?.refusedType).toBe('vendor.x.bar.create');
     expect(
       Array.isArray(details?.acceptedTypes) && details!.acceptedTypes!.includes('vendor.x.foo.create'),
-      driver.describe('ai-envelope.md §"Envelope Contract"', 'error.details.acceptedTypes MUST list the node\'s declared accepts[] (plus universals)'),
+      req('openwop.it.aiEnvelope.contractRefusal.refused-envelope-error-details-refusedtype-names-emitted-kind-acceptedtypes-list', 'ai-envelope.md §"Envelope Contract"', 'error.details.acceptedTypes MUST list the node\'s declared accepts[] (plus universals)'),
     ).toBe(true);
   });
 
   it('refusalMode:"discard-and-warn" → log.appended { level: "warn" } instead of node.failed', async () => {
-    if (!(await isEventLogSeamAvailable())) return;
+    if (!(await isEventLogSeamAvailable())) return softSkip('blocked', 'precondition not met — `!(await isEventLogSeamAvailable())` returned early (seam, prior step, or fixture unavailable)');
     const runId = `r-cr-warn-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     await accept(
       {
@@ -221,20 +223,20 @@ describe('aiEnvelope.contractRefusal: engine projection via event-log seam', ()
     );
     const warnEvents = await queryTestEvents(runId, { type: 'log.appended' });
     const failEvents = await queryTestEvents(runId, { type: 'node.failed' });
-    if (!warnEvents.ok || !failEvents.ok) return;
+    if (!warnEvents.ok || !failEvents.ok) return softSkip('blocked', 'precondition not met — `!warnEvents.ok || !failEvents.ok` returned early (seam, prior step, or fixture unavailable)');
     expect(
       warnEvents.events.some((e) => (e.payload as { level?: string }).level === 'warn'),
-      driver.describe('ai-envelope.md §"Envelope Contract"', 'discard-and-warn MUST emit log.appended at warn level'),
+      req('openwop.it.aiEnvelope.contractRefusal.refusalmode-discard-and-warn-log-appended-level-warn-instead-of-node-failed', 'ai-envelope.md §"Envelope Contract"', 'discard-and-warn MUST emit log.appended at warn level'),
     ).toBe(true);
     expect(
       failEvents.events.length,
-      driver.describe('ai-envelope.md §"Envelope Contract"', 'discard-and-warn MUST NOT emit node.failed'),
+      req('openwop.it.aiEnvelope.contractRefusal.refusalmode-discard-and-warn-log-appended-level-warn-instead-of-node-failed', 'ai-envelope.md §"Envelope Contract"', 'discard-and-warn MUST NOT emit node.failed'),
     ).toBe(0);
     await resetTestSeam();
   });
 
   it('host-gate refusal (hostSupportedEnvelopes) projects to node.failed with envelope_contract_violation', async () => {
-    if (!(await isEventLogSeamAvailable())) return;
+    if (!(await isEventLogSeamAvailable())) return softSkip('blocked', 'precondition not met — `!(await isEventLogSeamAvailable())` returned early (seam, prior step, or fixture unavailable)');
     const runId = `r-cr-host-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     await accept(
       {
@@ -252,10 +254,10 @@ describe('aiEnvelope.contractRefusal: engine projection via event-log seam', ()
       },
     );
     const events = await queryTestEvents(runId, { type: 'node.failed' });
-    if (!events.ok || events.events.length === 0) return;
+    if (!events.ok || events.events.length === 0) return softSkip('blocked', 'precondition not met — `!events.ok || events.events.length === 0` returned early (seam, prior step, or fixture unavailable)');
     expect(
       (events.events[0]!.payload.error as { code?: string }).code,
-      driver.describe('ai-envelope.md §"Capability handshake integration"', 'host-gate refusal MUST project to node.failed envelope_contract_violation (stacks above node-gate)'),
+      req('openwop.it.aiEnvelope.contractRefusal.host-gate-refusal-hostsupportedenvelopes-projects-to-node-failed-with-envelope-c', 'ai-envelope.md §"Capability handshake integration"', 'host-gate refusal MUST project to node.failed envelope_contract_violation (stacks above node-gate)'),
     ).toBe('envelope_contract_violation');
   });
 });
@@ -277,10 +279,10 @@ describe('aiEnvelope.contractRefusal: capability-stacking (FINAL v1.1)', () => {
   });
 
   it('host.aiEnvelope.supported = false → envelope/accept refuses with capability_required BEFORE envelope contract gates', async () => {
-    if (!(await isToggleAvailable())) return; // seam not exposed — soft-skip
+    if (!(await isToggleAvailable())) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isToggleAvailable())` returned early (seam not exposed — soft-skip)'); // seam not exposed — soft-skip
 
     const toggle = await setHostCapability('host.aiEnvelope.supported', false);
-    if (!toggle.ok) return;
+    if (!toggle.ok) return softSkip('blocked', 'precondition not met — `!toggle.ok` returned early (seam, prior step, or fixture unavailable)');
 
     // Same envelope shape that the existing host-gate scenario uses
     // (line 233-257 above) — the type IS in hostSupportedEnvelopes AND
@@ -301,17 +303,17 @@ describe('aiEnvelope.contractRefusal: capability-stacking (FINAL v1.1)', () => {
         nodeAllowedKinds: ['vendor.advertised.kind'],
       },
     );
-    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,
-      driver.describe(
+      req('openwop.it.aiEnvelope.contractRefusal.host-aienvelope-supported-false-envelope-accept-refuses-with-capability-required', 
         'ai-envelope.md §"Capability handshake integration"',
         'capability-absent host MUST refuse envelope acceptance regardless of host-gate / node-gate match',
       ),
     ).toBe('invalid');
     expect(
       r.body.reason,
-      driver.describe(
+      req('openwop.it.aiEnvelope.contractRefusal.host-aienvelope-supported-false-envelope-accept-refuses-with-capability-required', 
         'capabilities.md §"Unsupported capability — refusal contract"',
         'refusal reason MUST be capability_required (NOT envelope_contract_violation) — capability gate stacks above the envelope-contract gate',
       ),
@@ -319,9 +321,9 @@ describe('aiEnvelope.contractRefusal: capability-stacking (FINAL v1.1)', () => {
   });
 
   it('host.aiEnvelope.supported = true → envelope/accept falls through to envelope-contract gates', async () => {
-    if (!(await isToggleAvailable())) return;
+    if (!(await isToggleAvailable())) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isToggleAvailable())` returned early');
     const toggle = await setHostCapability('host.aiEnvelope.supported', true);
-    if (!toggle.ok) return;
+    if (!toggle.ok) return softSkip('blocked', 'precondition not met — `!toggle.ok` returned early (seam, prior step, or fixture unavailable)');
 
     // With capability advertised, a normally-rejected envelope (type
     // not in hostSupportedEnvelopes) reaches the envelope-contract
@@ -343,10 +345,10 @@ describe('aiEnvelope.contractRefusal: capability-stacking (FINAL v1.1)', () => {
         nodeAllowedKinds: ['vendor.unadvertised.kind'],
       },
     );
-    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,
-      driver.describe(
+      req('openwop.it.aiEnvelope.contractRefusal.host-aienvelope-supported-true-envelope-accept-falls-through-to-envelope-contrac', 
         'ai-envelope.md §"Capability handshake integration"',
         'when capability IS advertised, envelope-contract gates run normally',
       ),

package/src/scenarios/aiEnvelope.correlationReplay.test.ts

@@ -38,13 +38,13 @@ async function isEnvelopeContractsAdvertised(): Promise<boolean> {
 
 describe('aiEnvelope.correlationReplay: advertisement shape (FINAL v1.1)', () => {
   it('host that advertises envelopeContracts.advertised:true claims the replay-determinism contract', async () => {
-    if (!(await isEnvelopeContractsAdvertised())) return; // not opted in — skip
+    if (!(await isEnvelopeContractsAdvertised())) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isEnvelopeContractsAdvertised())` returned early (not opted in — skip)'); // not opted in — skip
     // The contract has no separate capability flag — advertising
     // envelopeContracts is the claim. The behavioral assertions below
     // exercise the contract; this advertisement-shape test exists so
     // a "no envelope contracts at all" host doesn't appear in failure
     // reports for this scenario.
-    expect(true).toBe(true);
+    expect(true, req('openwop.it.aiEnvelope.correlationReplay.host-that-advertises-envelopecontracts-advertised-true-claims-the-replay-determi', 'spec/v1/ai-envelope.md', 'host that advertises envelopeContracts.advertised:true claims the replay-determinism contract')).toBe(true);
   });
 });
 
@@ -75,7 +75,7 @@ describe('aiEnvelope.correlationReplay: behavioral in-process dedup (FINAL v1.1)
       meta: baseMeta,
     };
     const first = await accept(envelope);
-    if (first.status === 404) return;
+    if (first.status === 404) return softSkip('blocked', 'precondition not met — `first.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(first.body.status).toBe('accepted');
     const cachedOutcome = first.body;
 
@@ -90,7 +90,7 @@ describe('aiEnvelope.correlationReplay: behavioral in-process dedup (FINAL v1.1)
     });
     expect(
       second.body.status,
-      driver.describe(
+      req('openwop.it.aiEnvelope.correlationReplay.same-correlationid-re-emission-returns-the-cached-outcome-unchanged', 
         'ai-envelope.md §"Replay determinism"',
         'second emission with same correlationId MUST return the cached outcome (handler runs at most once per correlationId)',
       ),
@@ -118,10 +118,10 @@ describe('aiEnvelope.correlationReplay: behavioral in-process dedup (FINAL v1.1)
         ],
       },
     );
-    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,
-      driver.describe(
+      req('openwop.it.aiEnvelope.correlationReplay.same-correlationid-different-envelope-type-invalid-envelope-correlation-conflict', 
         'ai-envelope.md §"Replay determinism"',
         'same correlationId with different type MUST refuse envelope_correlation_conflict',
       ),
@@ -157,10 +157,10 @@ describe('aiEnvelope.correlationReplay: behavioral in-process dedup (FINAL v1.1)
         ],
       },
     );
-    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,
-      driver.describe(
+      req('openwop.it.aiEnvelope.correlationReplay.cached-outcome-of-any-status-invalid-gated-breached-replays-identically', 
         'ai-envelope.md §"Replay determinism"',
         'cached non-accepted outcome MUST replay identically (handler at most once per correlationId)',
       ),
@@ -170,10 +170,12 @@ describe('aiEnvelope.correlationReplay: behavioral in-process dedup (FINAL v1.1)
 
 // E.1 engine-projection via the test-only event-log seam.
 import { queryTestEvents, isEventLogSeamAvailable, resetTestSeam } from '../lib/event-log-query.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 describe('aiEnvelope.correlationReplay: causationId projection via event-log seam', () => {
   it('resulting RunEventDoc.causationId MUST equal the envelope.correlationId (causal chain preserved)', async () => {
-    if (!(await isEventLogSeamAvailable())) return;
+    if (!(await isEventLogSeamAvailable())) return softSkip('blocked', 'precondition not met — `!(await isEventLogSeamAvailable())` returned early (seam, prior step, or fixture unavailable)');
     const runId = `r-cr-cause-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     const correlationId = `${runId}:n:0:causationId-link`;
     await accept(
@@ -188,11 +190,11 @@ describe('aiEnvelope.correlationReplay: causationId projection via event-log sea
       { projectTo: { runId, nodeId: 'n' } },
     );
     const events = await queryTestEvents(runId);
-    if (!events.ok || events.events.length === 0) return;
+    if (!events.ok || events.events.length === 0) return softSkip('blocked', 'precondition not met — `!events.ok || events.events.length === 0` returned early (seam, prior step, or fixture unavailable)');
     for (const e of events.events) {
       expect(
         e.causationId,
-        driver.describe('ai-envelope.md §"Replay determinism"', 'every event projected from an envelope MUST carry causationId === envelope.correlationId'),
+        req('openwop.it.aiEnvelope.correlationReplay.resulting-runeventdoc-causationid-must-equal-the-envelope-correlationid-causal-c', 'ai-envelope.md §"Replay determinism"', 'every event projected from an envelope MUST carry causationId === envelope.correlationId'),
       ).toBe(correlationId);
     }
     await resetTestSeam();
@@ -238,7 +240,7 @@ describe('aiEnvelope.correlationReplay: cross-process replay via persisted dedup
     };
     // First accept persists the outcome under (runId, correlationId).
     const first = await accept(env1, { persistedDedup: { runId } });
-    if (first.status === 404) return; // seam not exposed — soft-skip
+    if (first.status === 404) return softSkip('blocked', 'precondition not met — `first.status === 404` returned early (seam not exposed — soft-skip) (seam, prior step, or fixture unavailable)'); // seam not exposed — soft-skip
     expect(first.body.status).toBe('accepted');
     expect(first.body.envelopeId).toBe('env-cr-persist-1');
 
@@ -250,7 +252,7 @@ describe('aiEnvelope.correlationReplay: cross-process replay via persisted dedup
     const second = await accept(env2, { persistedDedup: { runId } });
     expect(
       second.body.envelopeId,
-      driver.describe(
+      req('openwop.it.aiEnvelope.correlationReplay.persisted-outcome-replays-for-the-same-correlationid-even-with-no-in-memory-prio', 
         'ai-envelope.md §"Replay determinism"',
         'persisted outcome MUST replay across calls without an in-memory priorCorrelations map (cross-process recovery: cached envelopeId surfaces even when the inbound envelope carries a different envelopeId)',
       ),
@@ -273,7 +275,7 @@ describe('aiEnvelope.correlationReplay: cross-process replay via persisted dedup
       },
       { persistedDedup: { runId } },
     );
-    if (first.status === 404) return;
+    if (first.status === 404) return softSkip('blocked', 'precondition not met — `first.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(first.body.status).toBe('accepted');
 
     // Second accept: same correlationId, different envelope type, NO
@@ -292,7 +294,7 @@ describe('aiEnvelope.correlationReplay: cross-process replay via persisted dedup
     );
     expect(
       second.body.status,
-      driver.describe(
+      req('openwop.it.aiEnvelope.correlationReplay.persisted-store-enforces-envelope-correlation-conflict-across-calls', 
         'ai-envelope.md §"Replay determinism"',
         'persisted store MUST surface envelope_correlation_conflict on type mismatch without an in-memory priorCorrelations map',
       ),

package/src/scenarios/aiEnvelope.redaction.test.ts

@@ -40,11 +40,11 @@ async function isBYOKAdvertised(): Promise<boolean> {
 
 describe('aiEnvelope.redaction: advertisement shape (FINAL v1.1)', () => {
   it('hosts advertising envelopeContracts AND secrets honor SR-1 carry-forward', async () => {
-    if (!(await isBYOKAdvertised())) return; // BYOK not advertised — skip
+    if (!(await isBYOKAdvertised())) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isBYOKAdvertised())` returned early (BYOK not advertised — skip)'); // BYOK not advertised — skip
     // The contract is invariant-based, not capability-flag-based. The
     // advertisement-shape check is just "the host claims a BYOK surface";
     // behavioral assertions below exercise the redaction invariant.
-    expect(true).toBe(true);
+    expect(true, req('openwop.it.aiEnvelope.redaction.hosts-advertising-envelopecontracts-and-secrets-honor-sr-1-carry-forward', 'spec/v1/ai-envelope.md', 'hosts advertising envelopeContracts AND secrets honor SR-1 carry-forward')).toBe(true);
   });
 });
 
@@ -78,16 +78,16 @@ describe('aiEnvelope.redaction: behavioral acceptor-level scrub (FINAL v1.1)', (
       },
       { 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(r.body.redactionCount, 'redactionCount MUST be > 0 when canary appears').toBeGreaterThan(0);
+    expect(r.body.redactionCount, req('openwop.it.aiEnvelope.redaction.canary-in-payload-substituted-with-canonical-sr-1-redacted-secretid-marker-per-a', 'ai-envelope.md §"Redaction (SR-1 carry-forward)"', 'redactionCount MUST be > 0 when canary appears')).toBeGreaterThan(0);
     expect(
       JSON.stringify(r.body.redactedPayload).includes(CANARY_VALUE),
-      driver.describe('ai-envelope.md §"Redaction (SR-1 carry-forward)"', 'canary plaintext MUST be absent from the redacted view'),
+      req('openwop.it.aiEnvelope.redaction.canary-in-payload-substituted-with-canonical-sr-1-redacted-secretid-marker-per-a', 'ai-envelope.md §"Redaction (SR-1 carry-forward)"', 'canary plaintext MUST be absent from the redacted view'),
     ).toBe(false);
     expect(
       JSON.stringify(r.body.redactedPayload),
-      driver.describe('agent-memory.md §SR-1 line 66', 'persisted entry MUST carry [REDACTED:<secretId>] in place of the plaintext'),
+      req('openwop.it.aiEnvelope.redaction.canary-in-payload-substituted-with-canonical-sr-1-redacted-secretid-marker-per-a', 'agent-memory.md §SR-1 line 66', 'persisted entry MUST carry [REDACTED:<secretId>] in place of the plaintext'),
     ).toContain(CANONICAL_MARKER);
   });
 
@@ -108,11 +108,11 @@ describe('aiEnvelope.redaction: behavioral acceptor-level scrub (FINAL v1.1)', (
       },
       { 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 in the redacted view (recursive scrub)',
+      req('openwop.it.aiEnvelope.redaction.canary-across-nested-object-fields-all-occurrences-scrubbed-with-canonical-marke', 'spec/v1/ai-envelope.md', 'no canary plaintext remnant anywhere in the redacted view (recursive scrub)'),
     ).toBe(false);
     // q1's question (1 occurrence), q2's context.trace (2 occurrences) = total 3
     expect(r.body.redactionCount).toBe(3);
@@ -132,14 +132,14 @@ describe('aiEnvelope.redaction: behavioral acceptor-level scrub (FINAL v1.1)', (
       },
       { byokCanaries: [C1, C2] },
     );
-    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');
     const view = JSON.stringify(r.body.redactedPayload);
     expect(view.includes(C1.value)).toBe(false);
     expect(view.includes(C2.value)).toBe(false);
     expect(
       view.includes(`[REDACTED:${C1.secretId}]`) && view.includes(`[REDACTED:${C2.secretId}]`),
-      driver.describe('agent-memory.md §SR-1', 'each canary MUST be substituted with its OWN [REDACTED:<secretId>] marker'),
+      req('openwop.it.aiEnvelope.redaction.multiple-canaries-each-substituted-with-its-own-secretid-marker', 'agent-memory.md §SR-1', 'each canary MUST be substituted with its OWN [REDACTED:<secretId>] marker'),
     ).toBe(true);
   });
 
@@ -157,10 +157,10 @@ describe('aiEnvelope.redaction: behavioral acceptor-level scrub (FINAL v1.1)', (
       },
       { byokCanaries: CANARIES }, // canary NOT in payload; substitution count expected 0
     );
-    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,
-      driver.describe('ai-envelope.md §"Redaction (SR-1 carry-forward)"', 'redaction MUST run AFTER schema validation; pre-existing markers do not affect validation'),
+      req('openwop.it.aiEnvelope.redaction.redaction-runs-after-schema-validation-payload-with-redacted-shaped-substrings-s', 'ai-envelope.md §"Redaction (SR-1 carry-forward)"', 'redaction MUST run AFTER schema validation; pre-existing markers do not affect validation'),
     ).toBe('accepted');
     // No canary present → redactionCount absent or 0
     expect(r.body.redactionCount ?? 0).toBe(0);
@@ -181,12 +181,12 @@ describe('aiEnvelope.redaction: behavioral acceptor-level scrub (FINAL v1.1)', (
       },
       { 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('invalid');
     const bodyString = JSON.stringify(r.body);
     expect(
       bodyString.includes(CANARY_VALUE),
-      driver.describe(
+      req('openwop.it.aiEnvelope.redaction.canary-in-invalid-envelope-validation-refusal-error-response-must-not-echo-the-c', 
         'SECURITY/threat-model-secret-leakage.md §SR-1',
         'error response on validation refusal MUST NOT echo BYOK canary plaintext',
       ),
@@ -197,10 +197,12 @@ describe('aiEnvelope.redaction: behavioral acceptor-level scrub (FINAL v1.1)', (
 // E.2 OTel scrape + E.3 debug-bundle seams.
 import { queryTestSpans, exportDebugBundle, isOtelSeamAvailable } from '../lib/otel-scrape.js';
 import { resetTestSeam } from '../lib/event-log-query.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 describe('aiEnvelope.redaction: OTel + debug-bundle scrape (E.2 + E.3)', () => {
   it('redacted canary plaintext MUST be absent from OTel envelope_* span attributes', async () => {
-    if (!(await isOtelSeamAvailable())) return;
+    if (!(await isOtelSeamAvailable())) return softSkip('blocked', 'precondition not met — `!(await isOtelSeamAvailable())` returned early (seam, prior step, or fixture unavailable)');
     const runId = `r-red-otel-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     await accept(
       {
@@ -214,11 +216,11 @@ describe('aiEnvelope.redaction: OTel + debug-bundle scrape (E.2 + E.3)', () => {
       { byokCanaries: CANARIES, projectTo: { runId, nodeId: 'n' } },
     );
     const spans = await queryTestSpans({ runId });
-    if (!spans.ok) return;
+    if (!spans.ok) return softSkip('blocked', 'precondition not met — `!spans.ok` returned early (seam, prior step, or fixture unavailable)');
     const allAttrs = spans.data.flatMap((s) => Object.values(s.attributes).map((v) => String(v)));
     expect(
       allAttrs.some((v) => v.includes(CANARY_VALUE)),
-      driver.describe(
+      req('openwop.it.aiEnvelope.redaction.redacted-canary-plaintext-must-be-absent-from-otel-envelope-span-attributes', 
         'SECURITY/threat-model-secret-leakage.md §SR-1',
         'BYOK canary plaintext MUST NOT appear in any OTel envelope_* span attribute',
       ),
@@ -227,7 +229,7 @@ describe('aiEnvelope.redaction: OTel + debug-bundle scrape (E.2 + E.3)', () => {
   });
 
   it('redacted canary plaintext MUST be absent from debug-bundle export', async () => {
-    if (!(await isOtelSeamAvailable())) return;
+    if (!(await isOtelSeamAvailable())) return softSkip('blocked', 'precondition not met — `!(await isOtelSeamAvailable())` returned early (seam, prior step, or fixture unavailable)');
     const runId = `r-red-bundle-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     await accept(
       {
@@ -241,11 +243,11 @@ describe('aiEnvelope.redaction: OTel + debug-bundle scrape (E.2 + E.3)', () => {
       { byokCanaries: CANARIES, projectTo: { runId, nodeId: 'n' } },
     );
     const bundle = await exportDebugBundle(runId);
-    if (!bundle.ok) return;
+    if (!bundle.ok) return softSkip('blocked', 'precondition not met — `!bundle.ok` returned early (seam, prior step, or fixture unavailable)');
     const serialized = JSON.stringify(bundle.data);
     expect(
       serialized.includes(CANARY_VALUE),
-      driver.describe(
+      req('openwop.it.aiEnvelope.redaction.redacted-canary-plaintext-must-be-absent-from-debug-bundle-export', 
         'SECURITY/threat-model-secret-leakage.md §SR-1',
         'BYOK canary plaintext MUST NOT appear in the debug-bundle export (events + spans)',
       ),

package/src/scenarios/aiEnvelope.schemaDrift.test.ts

@@ -40,10 +40,10 @@ describe('aiEnvelope.schemaDrift: advertisement shape (FINAL v1.1)', () => {
     const body = res.json as DiscoveryDoc | undefined;
     const top = discoveryFamilies(body);
     const val = top && typeof top === 'object' ? top['envelopeStrictness'] : undefined;
-    if (val === undefined) return; // absent → treated as 'warn'; skip
+    if (val === undefined) return softSkip('blocked', 'precondition not met — `val === undefined` returned early (absent → treated as \'warn\'; skip) (seam, prior step, or fixture unavailable)'); // absent → treated as 'warn'; skip
     expect(
       val === 'warn' || val === 'strict',
-      driver.describe(
+      req('openwop.it.aiEnvelope.schemaDrift.capabilities-envelopestrictness-is-either-absent-treated-as-warn-or-warn-strict', 
         'ai-envelope.md §"Capability handshake integration"',
         'envelopeStrictness MUST be the literal string "warn" or "strict" when present',
       ),
@@ -51,13 +51,13 @@ describe('aiEnvelope.schemaDrift: advertisement shape (FINAL v1.1)', () => {
   });
 
   it('schemaVersions is non-empty when envelopeContracts.advertised: true', async () => {
-    if (!(await isEnvelopeContractsAdvertised())) return; // not opted in — skip
+    if (!(await isEnvelopeContractsAdvertised())) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isEnvelopeContractsAdvertised())` returned early (not opted in — skip)'); // not opted in — skip
     const res = await driver.get('/.well-known/openwop');
     const body = res.json as { schemaVersions?: Record<string, number>; capabilities?: { schemaVersions?: Record<string, number> } } | undefined;
     const versions = body?.schemaVersions ?? capabilityFamily(body, 'schemaVersions') ?? {};
     expect(
       Object.keys(versions).length > 0,
-      driver.describe(
+      req('openwop.it.aiEnvelope.schemaDrift.schemaversions-is-non-empty-when-envelopecontracts-advertised-true', 
         'ai-envelope.md §"Schema version advertisement"',
         'schemaVersions MUST be non-empty when envelopeContracts.advertised is true',
       ),
@@ -93,10 +93,10 @@ describe('aiEnvelope.schemaDrift: behavioral strictness gate (FINAL v1.1)', () =
         envelopeStrictness: 'warn',
       },
     );
-    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,
-      driver.describe(
+      req('openwop.it.aiEnvelope.schemaDrift.schemaversion-below-advertised-floor-under-strictness-warn-accepted-warn-and-con', 
         'ai-envelope.md §"Schema discipline"',
         'below-floor schemaVersion under strictness:warn MUST be accepted (drift projected at engine level)',
       ),
@@ -118,10 +118,10 @@ describe('aiEnvelope.schemaDrift: behavioral strictness gate (FINAL v1.1)', () =
         envelopeStrictness: 'strict',
       },
     );
-    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,
-      driver.describe(
+      req('openwop.it.aiEnvelope.schemaDrift.schemaversion-below-advertised-floor-under-strictness-strict-invalid-unknown-sch', 
         'ai-envelope.md §"Schema discipline"',
         'below-floor schemaVersion under strictness:strict MUST refuse with unknown_schema_version',
       ),
@@ -145,10 +145,10 @@ describe('aiEnvelope.schemaDrift: behavioral strictness gate (FINAL v1.1)', () =
           envelopeStrictness: strictness,
         },
       );
-      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,
-        driver.describe(
+        req('openwop.it.aiEnvelope.schemaDrift.schemaversion-above-advertised-floor-invalid-regardless-of-strictness-host-doesn', 
           'ai-envelope.md §"Schema discipline"',
           `above-floor schemaVersion MUST refuse regardless of strictness (got ${strictness})`,
         ),
@@ -172,13 +172,13 @@ describe('aiEnvelope.schemaDrift: behavioral strictness gate (FINAL v1.1)', () =
         envelopeStrictness: 'warn', // above-floor → invalid regardless
       },
     );
-    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('invalid');
     expect(Array.isArray(r.body.details)).toBe(true);
     const paths = (r.body.details ?? []).map((d: unknown) => (d as { instancePath?: string }).instancePath);
     expect(
       paths.includes('/schemaVersion'),
-      driver.describe(
+      req('openwop.it.aiEnvelope.schemaDrift.refused-above-floor-envelope-carries-instancepath-schemaversion-in-details', 
         'ai-envelope.md §"Schema discipline"',
         'schema-drift refusal MUST cite /schemaVersion as the violating field',
       ),
@@ -190,10 +190,12 @@ describe('aiEnvelope.schemaDrift: behavioral strictness gate (FINAL v1.1)', () =
 import { queryTestSpans, isOtelSeamAvailable } from '../lib/otel-scrape.js';
 import { resetTestSeam } from '../lib/event-log-query.js';
 import { capabilityFamily, discoveryFamilies } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 describe('aiEnvelope.schemaDrift: OTel drift attribute projection (E.2)', () => {
   it('below-floor + strictness:warn → OTel span MUST carry envelope_schema_version_drift attribute', async () => {
-    if (!(await isOtelSeamAvailable())) return;
+    if (!(await isOtelSeamAvailable())) return softSkip('blocked', 'precondition not met — `!(await isOtelSeamAvailable())` returned early (seam, prior step, or fixture unavailable)');
     const runId = `r-drift-otel-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     const r = await accept(
       {
@@ -210,14 +212,14 @@ describe('aiEnvelope.schemaDrift: OTel drift attribute projection (E.2)', () =>
         projectTo: { runId, nodeId: 'n' },
       },
     );
-    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');
 
     const spans = await queryTestSpans({ runId });
-    if (!spans.ok) return;
+    if (!spans.ok) return softSkip('blocked', 'precondition not met — `!spans.ok` returned early (seam, prior step, or fixture unavailable)');
     expect(
       spans.data.some((s) => s.attributes.envelope_schema_version_drift === true),
-      driver.describe(
+      req('openwop.it.aiEnvelope.schemaDrift.below-floor-strictness-warn-otel-span-must-carry-envelope-schema-version-drift-a', 
         'ai-envelope.md §"Schema discipline"',
         'below-floor accept under strictness:warn MUST project envelope_schema_version_drift attribute on the OTel span',
       ),