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

package/src/scenarios/agentReasoningStreaming.test.ts

@@ -29,6 +29,7 @@ import {
   isReasoningStreamingSupported,
   getReasoningVerbosity,
 } from '../lib/multi-agent-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const FIXTURE = 'conformance-agent-reasoning-streaming';
 /** Expected concatenation of the fixture's `streamChunks` — kept in sync
@@ -64,14 +65,14 @@ describe.skipIf(SKIP)('agentReasoningStreaming: RFC 0024 incremental + closing e
 
     expect(
       deltas.length,
-      driver.describe(
+      req('openwop.it.agentReasoningStreaming.emits-n-agent-reasoning-delta-events-followed-by-exactly-one-closing-agent-reaso', 
         'RFCS/0024-agent-reasoning-streaming.md §Proposal',
         'streaming host MUST emit one agent.reasoning.delta per streamChunks entry',
       ),
     ).toBe(EXPECTED_CHUNKS.length);
     expect(
       finals.length,
-      driver.describe(
+      req('openwop.it.agentReasoningStreaming.emits-n-agent-reasoning-delta-events-followed-by-exactly-one-closing-agent-reaso', 
         'RFCS/0024-agent-reasoning-streaming.md §Proposal',
         'streaming host MUST emit exactly one closing agent.reasoned event after the deltas',
       ),
@@ -95,7 +96,7 @@ describe.skipIf(SKIP)('agentReasoningStreaming: RFC 0024 incremental + closing e
 
     expect(
       sequences,
-      driver.describe(
+      req('openwop.it.agentReasoningStreaming.agent-reasoning-delta-sequence-starts-at-0-and-increments-by-1-within-the-block', 
         'RFCS/0024-agent-reasoning-streaming.md §Proposal',
         '`sequence` MUST start at 0 and increment by 1 per delta within a block',
       ),
@@ -113,15 +114,15 @@ describe.skipIf(SKIP)('agentReasoningStreaming: RFC 0024 incremental + closing e
     const list = (events.json as { events: Array<{ type: string; payload?: Record<string, unknown> }> }).events;
 
     const finalEvent = list.find((e) => e.type === 'agent.reasoned');
-    expect(finalEvent, 'closing agent.reasoned must be present').toBeDefined();
+    expect(finalEvent, req('openwop.it.agentReasoningStreaming.closing-agent-reasoned-reasoning-is-the-concatenation-of-the-deltas-authoritativ', 'RFCS/0024-agent-reasoning-streaming.md §Proposal', 'closing agent.reasoned must be present')).toBeDefined();
     const reasoning = finalEvent?.payload?.reasoning;
-    expect(typeof reasoning, 'closing event MUST carry a reasoning string').toBe('string');
+    expect(typeof reasoning, req('openwop.it.agentReasoningStreaming.closing-agent-reasoned-reasoning-is-the-concatenation-of-the-deltas-authoritativ', 'RFCS/0024-agent-reasoning-streaming.md §Proposal', 'closing event MUST carry a reasoning string')).toBe('string');
     // The mock-agent's contract: closing reasoning equals concat(streamChunks).
     // Real hosts MAY transform at finalize (summary truncation, redaction);
     // for the mock-agent fixture, no transform applies — exact equality.
     expect(
       reasoning,
-      driver.describe(
+      req('openwop.it.agentReasoningStreaming.closing-agent-reasoned-reasoning-is-the-concatenation-of-the-deltas-authoritativ', 
         'RFCS/0024-agent-reasoning-streaming.md §Proposal',
         'closing agent.reasoned.reasoning is authoritative; for the mock-agent fixture, equals delta concatenation',
       ),
@@ -149,7 +150,7 @@ describe.skipIf(SKIP)('agentReasoningStreaming: RFC 0024 incremental + closing e
 
     expect(
       agentIds.size,
-      driver.describe(
+      req('openwop.it.agentReasoningStreaming.agentid-is-consistent-across-all-streaming-closing-events-in-a-block', 
         'RFCS/0024-agent-reasoning-streaming.md §Proposal',
         'agentId MUST be consistent across all `agent.reasoning.delta` events AND the closing `agent.reasoned` for a given block',
       ),
@@ -168,7 +169,7 @@ describe.skipIf(SKIP)('agentReasoningStreaming: RFC 0024 incremental + closing e
     const arr = Array.isArray(list) ? list : list.events;
 
     const closingIdx = arr.findIndex((e) => e.type === 'agent.reasoned');
-    expect(closingIdx, 'closing event present').toBeGreaterThan(-1);
+    expect(closingIdx, req('openwop.it.agentReasoningStreaming.all-agent-reasoning-delta-events-arrive-before-the-closing-agent-reasoned', 'RFCS/0024-agent-reasoning-streaming.md §Proposal', 'closing event present')).toBeGreaterThan(-1);
     const lastDeltaIdx = arr.map((e) => e.type).lastIndexOf('agent.reasoning.delta');
 
     // Guard against vacuous pass: a host advertising streaming but
@@ -177,14 +178,14 @@ describe.skipIf(SKIP)('agentReasoningStreaming: RFC 0024 incremental + closing e
     // one delta MUST appear in the event log.
     expect(
       lastDeltaIdx,
-      driver.describe(
+      req('openwop.it.agentReasoningStreaming.all-agent-reasoning-delta-events-arrive-before-the-closing-agent-reasoned', 
         'RFCS/0024-agent-reasoning-streaming.md §Proposal',
         'streaming host MUST emit at least one `agent.reasoning.delta` for a fixture with non-empty `streamChunks`',
       ),
     ).toBeGreaterThan(-1);
     expect(
       lastDeltaIdx,
-      driver.describe(
+      req('openwop.it.agentReasoningStreaming.all-agent-reasoning-delta-events-arrive-before-the-closing-agent-reasoned', 
         'RFCS/0024-agent-reasoning-streaming.md §Proposal',
         'every `agent.reasoning.delta` MUST precede the closing `agent.reasoned` for the same block',
       ),

package/src/scenarios/agents-run-tool-allowlist.test.ts

@@ -36,6 +36,8 @@ import { describe, it, expect, beforeAll } from 'vitest';
 import { existsSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PACK_PATH = resolve(__dirname, '../../../packs/core.openwop.agents/index.mjs');
@@ -83,14 +85,14 @@ describe('category: core.openwop.agents.run — tool-allowlist enforcement (OPEN
   it('skips cleanly when pack source is not bundled', () => {
     if (!packAvailable) {
       console.warn('[agents-run-tool-allowlist] pack source not present; skipping');
-      expect(packAvailable).toBe(false);
-      return;
+      expect(packAvailable, req('openwop.it.agents-run-tool-allowlist.skips-cleanly-when-pack-source-is-not-bundled', 'threat-model-prompt-injection.md', 'skips cleanly when pack source is not bundled')).toBe(false);
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early ([agents-run-tool-allowlist] pack source not present; skipping)');
     }
     expect(packAvailable).toBe(true);
   });
 
   it('rejects function-typed tool.handler (the defect path)', async () => {
-    if (!packAvailable) return;
+    if (!packAvailable) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early');
     // The 1.0.0 defect: a workflow author could supply executable JS via
     // tools[].handler and the pack would await it directly with ctx. Closed
     // in 1.0.1 — the validator throws INVALID_TOOL_DECLARATION at the run
@@ -109,7 +111,7 @@ describe('category: core.openwop.agents.run — tool-allowlist enforcement (OPEN
   });
 
   it('rejects tool declaration missing a name', async () => {
-    if (!packAvailable) return;
+    if (!packAvailable) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early');
     await expectRejection(
       () => agentRun({ config: {}, inputs: { userPrompt: 'x', tools: [{ kind: 'workflow' }] } }),
       'INVALID_TOOL_DECLARATION',
@@ -118,7 +120,7 @@ describe('category: core.openwop.agents.run — tool-allowlist enforcement (OPEN
   });
 
   it('rejects tool declaration missing a kind discriminator', async () => {
-    if (!packAvailable) return;
+    if (!packAvailable) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early');
     await expectRejection(
       () => agentRun({ config: {}, inputs: { userPrompt: 'x', tools: [{ name: 't1' }] } }),
       'INVALID_TOOL_DECLARATION',
@@ -127,7 +129,7 @@ describe('category: core.openwop.agents.run — tool-allowlist enforcement (OPEN
   });
 
   it('rejects tool-driven runs when host does not provide agentRuntime', async () => {
-    if (!packAvailable) return;
+    if (!packAvailable) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early');
     // Tool dispatch MUST go through a host-resolved runtime — the 1.0.0
     // inline-handler fallback is gone.
     await expectRejection(
@@ -141,7 +143,7 @@ describe('category: core.openwop.agents.run — tool-allowlist enforcement (OPEN
   });
 
   it('tool-less run succeeds via callAIWithTools (safe fallback preserved)', async () => {
-    if (!packAvailable) return;
+    if (!packAvailable) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early');
     let toolsSeen: unknown = 'never-called';
     const ctx: AgentRunCtx = {
       config: {},
@@ -154,11 +156,11 @@ describe('category: core.openwop.agents.run — tool-allowlist enforcement (OPEN
     const result = await agentRun(ctx);
     expect(result.outputs.result).toBe('hello back');
     expect(result.outputs.finishReason).toBe('complete');
-    expect(toolsSeen, 'tool-less fallback MUST pass an empty tools array — no LLM-driven dispatch').toEqual([]);
+    expect(toolsSeen, req('openwop.it.agents-run-tool-allowlist.tool-less-run-succeeds-via-callaiwithtools-safe-fallback-preserved', 'threat-model-prompt-injection.md', 'tool-less fallback MUST pass an empty tools array — no LLM-driven dispatch')).toEqual([]);
   });
 
   it('agentRuntime.run path threads through unchanged when host provides it', async () => {
-    if (!packAvailable) return;
+    if (!packAvailable) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early');
     let receivedTools: unknown;
     const ctx: AgentRunCtx = {
       config: {},
@@ -167,15 +169,15 @@ describe('category: core.openwop.agents.run — tool-allowlist enforcement (OPEN
         tools: [{ name: 't1', kind: 'workflow', ref: 'vendor.acme.demo' }],
       },
       agentRuntime: {
-        run: async (req: unknown) => {
-          receivedTools = (req as { tools?: unknown[] }).tools;
+        run: async (reqBody: unknown) => {
+          receivedTools = (reqBody as { tools?: unknown[] }).tools;
           return { result: 'from-runtime', toolCalls: [{ name: 't1' }] };
         },
       },
     };
     const result = await agentRun(ctx);
     expect(result.outputs.result).toBe('from-runtime');
-    expect(receivedTools, 'host MUST receive the validated tools array').toEqual([
+    expect(receivedTools, req('openwop.it.agents-run-tool-allowlist.agentruntime-run-path-threads-through-unchanged-when-host-provides-it', 'threat-model-prompt-injection.md', 'host MUST receive the validated tools array')).toEqual([
       { name: 't1', kind: 'workflow', ref: 'vendor.acme.demo' },
     ]);
   });

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

@@ -25,6 +25,8 @@ import { join } from 'node:path';
 import { driver } from '../lib/driver.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 import { SCHEMAS_DIR } from '../lib/paths.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 type DiscoveryDoc = Record<string, unknown>;
 
@@ -65,16 +67,16 @@ const HTTP_SKIP = !process.env.OPENWOP_BASE_URL;
 describe.skipIf(HTTP_SKIP)('ai-envelope-shape: advertisement contract (RFC 0021 §C)', () => {
   it('capabilities.supportedEnvelopes is an array of strings (when present)', 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 env = supportedEnvelopes(d);
     // No assertion if absent — the field is optional. When present, each entry MUST be a string.
     for (const k of env) {
-      expect(typeof k, driver.describe('capabilities.md §supportedEnvelopes', 'each entry MUST be a string')).toBe('string');
+      expect(typeof k, req('openwop.it.ai-envelope-shape.capabilities-supportedenvelopes-is-an-array-of-strings-when-present', 'capabilities.md §supportedEnvelopes', 'each entry MUST be a string')).toBe('string');
     }
     // Re-affirm shape: array if present (root-first per RFC 0073).
     const advertised = capabilityFamily<unknown>(d, 'supportedEnvelopes');
     if (advertised !== undefined) {
-      expect(Array.isArray(advertised), 'supportedEnvelopes MUST be an array').toBe(true);
+      expect(Array.isArray(advertised), req('openwop.it.ai-envelope-shape.capabilities-supportedenvelopes-is-an-array-of-strings-when-present', 'capabilities.md §supportedEnvelopes', 'supportedEnvelopes MUST be an array')).toBe(true);
     }
   });
 });
@@ -88,7 +90,7 @@ describe('ai-envelope-shape: schema compile (RFC 0021 §A + §B)', () => {
   it('top-level ai-envelope.schema.json compiles under Ajv2020', () => {
     const schema = load('ai-envelope.schema.json');
     const validate = ajv.compile(schema);
-    expect(validate, 'RFC 0021 §A: ai-envelope.schema.json MUST compile').toBeTypeOf('function');
+    expect(validate, req('openwop.it.ai-envelope-shape.top-level-ai-envelope-schema-json-compiles-under-ajv2020', 'RFC 0021 §D', 'RFC 0021 §A: ai-envelope.schema.json MUST compile')).toBeTypeOf('function');
   });
 
   for (const kind of UNIVERSAL_KINDS) {
@@ -97,7 +99,7 @@ describe('ai-envelope-shape: schema compile (RFC 0021 §A + §B)', () => {
       const validate = ajv.compile(schema);
       expect(
         validate,
-        `RFC 0021 §B: envelopes/${kind}.schema.json MUST compile`,
+        req('openwop.it.ai-envelope-shape.universal-kind-schema-envelopes-schema-json-compiles-under-ajv2020', 'RFC 0021 §D', `RFC 0021 §B: envelopes/${kind}.schema.json MUST compile`),
       ).toBeTypeOf('function');
     });
   }
@@ -124,7 +126,7 @@ describe('ai-envelope-shape: round-trip validation (RFC 0021 §A)', () => {
       },
     };
     const ok = validate(positive);
-    expect(ok, `positive fixture MUST validate; errors: ${JSON.stringify(validate.errors)}`).toBe(true);
+    expect(ok, req('openwop.it.ai-envelope-shape.accepts-a-positive-aienvelope-fixture', 'RFC 0021 §D', `positive fixture MUST validate; errors: ${JSON.stringify(validate.errors)}`)).toBe(true);
   });
 
   it('rejects a negative AIEnvelope fixture missing required `meta`', () => {
@@ -137,7 +139,7 @@ describe('ai-envelope-shape: round-trip validation (RFC 0021 §A)', () => {
       // meta omitted on purpose
     };
     const ok = validate(negative);
-    expect(ok, 'RFC 0021 §A: envelope MUST require meta block').toBe(false);
+    expect(ok, req('openwop.it.ai-envelope-shape.rejects-a-negative-aienvelope-fixture-missing-required-meta', 'RFC 0021 §D', 'RFC 0021 §A: envelope MUST require meta block')).toBe(false);
   });
 
   it('rejects an envelope with unknown top-level property (additionalProperties:false)', () => {
@@ -151,7 +153,7 @@ describe('ai-envelope-shape: round-trip validation (RFC 0021 §A)', () => {
       unknownTopLevel: 'should reject',
     };
     const ok = validate(negative);
-    expect(ok, 'RFC 0021 §A: top-level additionalProperties:false MUST reject unknown fields').toBe(false);
+    expect(ok, req('openwop.it.ai-envelope-shape.rejects-an-envelope-with-unknown-top-level-property-additionalproperties-false', 'RFC 0021 §D', 'RFC 0021 §A: top-level additionalProperties:false MUST reject unknown fields')).toBe(false);
   });
 });
 
@@ -167,12 +169,12 @@ describe.skipIf(HTTP_SKIP)('ai-envelope-shape: behavioral acceptEnvelope round-t
         meta: { source: 'ai-generation', ts: '2026-05-18T10:00:00Z' },
       },
     });
-    if (res.status === 404) return; // host doesn't expose the seam
+    if (res.status === 404) return softSkip('blocked', 'precondition not met — `res.status === 404` returned early (host doesn\'t expose the seam) (seam, prior step, or fixture unavailable)'); // host doesn't expose the seam
     expect(res.status).toBe(200);
     const body = res.json as { status?: string };
     expect(
       body.status,
-      driver.describe('RFC 0021 §A point 1-3', 'valid envelope MUST be accepted'),
+      req('openwop.it.ai-envelope-shape.valid-clarification-request-envelope-status-accepted', 'RFC 0021 §A point 1-3', 'valid envelope MUST be accepted'),
     ).toBe('accepted');
   });
 
@@ -187,14 +189,14 @@ describe.skipIf(HTTP_SKIP)('ai-envelope-shape: behavioral acceptEnvelope round-t
         // meta omitted
       },
     });
-    if (res.status === 404) return;
+    if (res.status === 404) return softSkip('blocked', 'precondition not met — `res.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(res.status).toBe(200);
     const body = res.json as { status?: string; details?: unknown[] };
     expect(
       body.status,
-      driver.describe('RFC 0021 §A point 1', 'envelope missing required field MUST be invalid'),
+      req('openwop.it.ai-envelope-shape.envelope-missing-required-meta-block-status-invalid', 'RFC 0021 §A point 1', 'envelope missing required field MUST be invalid'),
     ).toBe('invalid');
-    expect(Array.isArray(body.details), 'invalid outcome MUST carry validation details').toBe(true);
+    expect(Array.isArray(body.details), req('openwop.it.ai-envelope-shape.envelope-missing-required-meta-block-status-invalid', 'RFC 0021 §A point 1', 'invalid outcome MUST carry validation details')).toBe(true);
   });
 
   it('vendor-namespaced kind not in supportedEnvelopes → status: gated', async () => {
@@ -209,14 +211,14 @@ describe.skipIf(HTTP_SKIP)('ai-envelope-shape: behavioral acceptEnvelope round-t
       },
       hostSupportedEnvelopes: ['vendor.acme.prd.create'], // does not include the gated kind
     });
-    if (res.status === 404) return;
+    if (res.status === 404) return softSkip('blocked', 'precondition not met — `res.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(res.status).toBe(200);
     const body = res.json as { status?: string; allowedKinds?: string[] };
     expect(
       body.status,
-      driver.describe('RFC 0021 §A point 2', 'unadvertised kind MUST be gated'),
+      req('openwop.it.ai-envelope-shape.vendor-namespaced-kind-not-in-supportedenvelopes-status-gated', 'RFC 0021 §A point 2', 'unadvertised kind MUST be gated'),
     ).toBe('gated');
-    expect(Array.isArray(body.allowedKinds), 'gated outcome MUST list the allowed kinds').toBe(true);
+    expect(Array.isArray(body.allowedKinds), req('openwop.it.ai-envelope-shape.vendor-namespaced-kind-not-in-supportedenvelopes-status-gated', 'RFC 0021 §A point 2', 'gated outcome MUST list the allowed kinds')).toBe(true);
   });
 
   it('counter at cap → status: breached', async () => {
@@ -231,12 +233,12 @@ describe.skipIf(HTTP_SKIP)('ai-envelope-shape: behavioral acceptEnvelope round-t
       },
       counters: { envelopesPerTurn: { current: 32, cap: 32 } },
     });
-    if (res.status === 404) return;
+    if (res.status === 404) return softSkip('blocked', 'precondition not met — `res.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(res.status).toBe(200);
     const body = res.json as { status?: string; capKind?: string };
     expect(
       body.status,
-      driver.describe('RFC 0021 §"Universal kinds"', 'envelope at cap MUST be breached'),
+      req('openwop.it.ai-envelope-shape.counter-at-cap-status-breached', 'RFC 0021 §"Universal kinds"', 'envelope at cap MUST be breached'),
     ).toBe('breached');
     expect(body.capKind).toBe('envelopes');
   });
@@ -255,13 +257,13 @@ describe.skipIf(HTTP_SKIP)('ai-envelope-shape: behavioral acceptEnvelope round-t
       },
       runTrustBoundary: 'untrusted',
     });
-    if (res.status === 404) return;
+    if (res.status === 404) return softSkip('blocked', 'precondition not met — `res.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(res.status).toBe(200);
     const body = res.json as { status?: string; normalizedMeta?: { contentTrust?: string } };
     expect(body.status).toBe('accepted');
     expect(
       body.normalizedMeta?.contentTrust,
-      driver.describe(
+      req('openwop.it.ai-envelope-shape.accepted-outcome-carries-normalizedmeta-contenttrust-per-rfc-0021-a-point-6', 
         'RFC 0021 §A point 6',
         'host MUST propagate runTrustBoundary onto normalizedMeta.contentTrust when envelope meta.contentTrust is absent',
       ),
@@ -280,12 +282,12 @@ describe.skipIf(HTTP_SKIP)('ai-envelope-shape: behavioral acceptEnvelope round-t
       },
       runTrustBoundary: 'untrusted', // explicitly conflicts; envelope wins
     });
-    if (res.status === 404) return;
+    if (res.status === 404) return softSkip('blocked', 'precondition not met — `res.status === 404` returned early (seam, prior step, or fixture unavailable)');
     const body = res.json as { status?: string; normalizedMeta?: { contentTrust?: string } };
     expect(body.status).toBe('accepted');
     expect(
       body.normalizedMeta?.contentTrust,
-      driver.describe(
+      req('openwop.it.ai-envelope-shape.envelope-supplied-meta-contenttrust-takes-precedence-over-runtrustboundary', 
         'RFC 0021 §A point 6',
         'envelope meta.contentTrust MUST take precedence over runTrustBoundary',
       ),
@@ -303,9 +305,9 @@ describe.skipIf(HTTP_SKIP)('ai-envelope-shape: behavioral acceptEnvelope round-t
         meta: { source: 'ai-generation', ts: 'tomorrow' },
       },
     });
-    if (res.status === 404) return;
+    if (res.status === 404) return softSkip('blocked', 'precondition not met — `res.status === 404` returned early (seam, prior step, or fixture unavailable)');
     const body = res.json as { status?: string; reason?: string };
-    expect(body.status, 'malformed timestamp MUST be rejected').toBe('invalid');
+    expect(body.status, req('openwop.it.ai-envelope-shape.non-iso-8601-meta-ts-status-invalid-format-defense-in-depth', 'RFC 0021 §D', 'malformed timestamp MUST be rejected')).toBe('invalid');
     expect(body.reason).toContain('ISO 8601');
   });
 
@@ -321,12 +323,12 @@ describe.skipIf(HTTP_SKIP)('ai-envelope-shape: behavioral acceptEnvelope round-t
       },
       nodeAllowedKinds: ['vendor.acme.prd.create'], // doesn't include clarification.request
     });
-    if (res.status === 404) return;
+    if (res.status === 404) return softSkip('blocked', 'precondition not met — `res.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(res.status).toBe(200);
     const body = res.json as { status?: string };
     expect(
       body.status,
-      driver.describe(
+      req('openwop.it.ai-envelope-shape.universal-kind-allowed-regardless-of-nodeallowedkinds-always-allowed-per-univers', 
         'RFC 0021 §"Universal kinds (normative)"',
         'universal kinds MUST be allowed even when node allowlist excludes them',
       ),
@@ -337,12 +339,12 @@ describe.skipIf(HTTP_SKIP)('ai-envelope-shape: behavioral acceptEnvelope round-t
 describe.skipIf(HTTP_SKIP)('ai-envelope-shape: universal-kind advertisement (RFC 0021 §C)', () => {
   it('host advertising any universal kind has a matching schema on disk', async () => {
     const d = await readDiscovery();
-    if (d === null || !aiProvidersSupported(d)) return; // capability-gated
+    if (d === null || !aiProvidersSupported(d)) return softSkip('blocked', 'precondition not met — `d === null || !aiProvidersSupported(d)` returned early (capability-gated) (seam, prior step, or fixture unavailable)'); // capability-gated
     const env = supportedEnvelopes(d);
     const advertisedUniversals = env.filter((k): k is (typeof UNIVERSAL_KINDS)[number] =>
       (UNIVERSAL_KINDS as readonly string[]).includes(k),
     );
-    if (advertisedUniversals.length === 0) return; // host doesn't claim any universal
+    if (advertisedUniversals.length === 0) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `advertisedUniversals.length === 0` returned early (host doesn\'t claim any universal)'); // host doesn't claim any universal
     // Each advertised universal MUST have its schema compileable (already
     // covered by the per-kind compile test above; this assertion just makes
     // the linkage between advertisement + schema explicit).
@@ -351,7 +353,7 @@ describe.skipIf(HTTP_SKIP)('ai-envelope-shape: universal-kind advertisement (RFC
       const schema = JSON.parse(readFileSync(join(SCHEMAS_DIR, `envelopes/${k}.schema.json`), 'utf8')) as Record<string, unknown>;
       expect(
         ajv.compile(schema),
-        `RFC 0021 §B: advertised universal ${k} MUST resolve to a compileable schema`,
+        req('openwop.it.ai-envelope-shape.host-advertising-any-universal-kind-has-a-matching-schema-on-disk', 'RFC 0021 §D', `RFC 0021 §B: advertised universal ${k} MUST resolve to a compileable schema`),
       ).toBeTypeOf('function');
     }
   });

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

@@ -42,14 +42,14 @@ describe('aiEnvelope.capBreached: advertisement shape (already required v1)', ()
     const limits = await readLimits();
     expect(
       limits,
-      driver.describe(
+      req('openwop.it.aiEnvelope.capBreached.limits-envelopesperturn-is-a-non-negative-integer', 
         'capabilities.schema.json §limits',
         'limits MUST be present on /.well-known/openwop (required v1)',
       ),
     ).not.toBeNull();
     expect(
       Number.isInteger(limits!.envelopesPerTurn) && limits!.envelopesPerTurn >= 0,
-      driver.describe(
+      req('openwop.it.aiEnvelope.capBreached.limits-envelopesperturn-is-a-non-negative-integer', 
         'capabilities.schema.json §limits.envelopesPerTurn',
         'envelopesPerTurn MUST be a non-negative integer (required v1)',
       ),
@@ -58,10 +58,10 @@ describe('aiEnvelope.capBreached: advertisement shape (already required v1)', ()
 
   it('limits.schemaRounds is a non-negative integer', async () => {
     const limits = await readLimits();
-    if (limits === null) return;
+    if (limits === null) return softSkip('blocked', 'precondition not met — `limits === null` returned early (seam, prior step, or fixture unavailable)');
     expect(
       Number.isInteger(limits.schemaRounds) && limits.schemaRounds >= 0,
-      driver.describe(
+      req('openwop.it.aiEnvelope.capBreached.limits-schemarounds-is-a-non-negative-integer', 
         'capabilities.schema.json §limits.schemaRounds',
         'schemaRounds MUST be a non-negative integer (required v1)',
       ),
@@ -70,10 +70,10 @@ describe('aiEnvelope.capBreached: advertisement shape (already required v1)', ()
 
   it('limits.clarificationRounds is a non-negative integer', async () => {
     const limits = await readLimits();
-    if (limits === null) return;
+    if (limits === null) return softSkip('blocked', 'precondition not met — `limits === null` returned early (seam, prior step, or fixture unavailable)');
     expect(
       Number.isInteger(limits.clarificationRounds) && limits.clarificationRounds >= 0,
-      driver.describe(
+      req('openwop.it.aiEnvelope.capBreached.limits-clarificationrounds-is-a-non-negative-integer', 
         'capabilities.schema.json §limits.clarificationRounds',
         'clarificationRounds MUST be a non-negative integer (required v1)',
       ),
@@ -101,10 +101,10 @@ describe('aiEnvelope.capBreached: behavioral cap enforcement (FINAL v1.1)', () =
       },
       { counters: { envelopesPerTurn: { current: 32, cap: 32 } } },
     );
-    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 §"Engine-enforced limits"', 'over-cap envelope MUST be breached'),
+      req('openwop.it.aiEnvelope.capBreached.envelopesperturn-at-cap-status-breached-capkind-envelopes', 'ai-envelope.md §"Engine-enforced limits"', 'over-cap envelope MUST be breached'),
     ).toBe('breached');
     expect(r.body.capKind).toBe('envelopes');
   });
@@ -121,8 +121,8 @@ describe('aiEnvelope.capBreached: behavioral cap enforcement (FINAL v1.1)', () =
       },
       { counters: { clarificationRounds: { current: 5, cap: 5 } } },
     );
-    if (r.status === 404) return;
-    expect(r.body.status).toBe('breached');
+    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.aiEnvelope.capBreached.clarificationrounds-at-cap-status-breached-capkind-clarification', 'spec/v1/ai-envelope.md', 'clarificationRounds at cap → status: breached { capKind: "clarification" }')).toBe('breached');
     expect(r.body.capKind).toBe('clarification');
   });
 
@@ -138,8 +138,8 @@ describe('aiEnvelope.capBreached: behavioral cap enforcement (FINAL v1.1)', () =
       },
       { counters: { schemaRounds: { current: 3, cap: 3 } } },
     );
-    if (r.status === 404) return;
-    expect(r.body.status).toBe('breached');
+    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.aiEnvelope.capBreached.schemarounds-at-cap-status-breached-capkind-schema', 'spec/v1/ai-envelope.md', 'schemaRounds at cap → status: breached { capKind: "schema" }')).toBe('breached');
     expect(r.body.capKind).toBe('schema');
   });
 
@@ -155,8 +155,8 @@ describe('aiEnvelope.capBreached: behavioral cap enforcement (FINAL v1.1)', () =
       },
       { counters: { envelopesPerTurn: { current: 32, cap: 32 } } },
     );
-    if (r.status === 404) return;
-    expect(r.body.reason).toContain('envelopesPerTurn');
+    if (r.status === 404) return softSkip('blocked', 'precondition not met — `r.status === 404` returned early (seam, prior step, or fixture unavailable)');
+    expect(r.body.reason, req('openwop.it.aiEnvelope.capBreached.breached-reason-cites-the-limit-and-cap-value', 'spec/v1/ai-envelope.md', 'breached reason cites the limit and cap value')).toContain('envelopesPerTurn');
     expect(r.body.reason).toContain('32');
   });
 });
@@ -167,10 +167,12 @@ describe('aiEnvelope.capBreached: behavioral cap enforcement (FINAL v1.1)', () =
 // soft-skip on HTTP 404 when the seam isn't exposed.
 import { queryTestEvents, isEventLogSeamAvailable, resetTestSeam } from '../lib/event-log-query.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 describe('aiEnvelope.capBreached: engine projection via event-log seam (capabilities.md §"cap.breached")', () => {
   it('breached outcome projects to cap.breached { kind: "envelopes" } event with causationId chain', 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-cap-env-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     const correlationId = `${runId}:node-1:turn-0:cap-env`;
     const r = await accept(
@@ -187,14 +189,14 @@ describe('aiEnvelope.capBreached: engine projection via event-log seam (capabili
         projectTo: { runId, nodeId: 'node-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).toBe('breached');
 
     const events = await queryTestEvents(runId, { type: 'cap.breached' });
-    if (!events.ok) return;
+    if (!events.ok) return softSkip('blocked', 'precondition not met — `!events.ok` returned early (seam, prior step, or fixture unavailable)');
     expect(
       events.events.length,
-      driver.describe('capabilities.md §"Engine-enforced limits and the cap.breached event"', 'breached outcome MUST project to exactly one cap.breached event'),
+      req('openwop.it.aiEnvelope.capBreached.breached-outcome-projects-to-cap-breached-kind-envelopes-event-with-causationid', 'capabilities.md §"Engine-enforced limits and the cap.breached event"', 'breached outcome MUST project to exactly one cap.breached event'),
     ).toBe(1);
     const evt = events.events[0]!;
     expect(evt.payload.kind).toBe('envelopes');
@@ -203,7 +205,7 @@ describe('aiEnvelope.capBreached: engine projection via event-log seam (capabili
   });
 
   it('cap.breached payload includes limit, observed, and nodeId per capabilities.md', 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-cap-payload-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     await accept(
       {
@@ -220,19 +222,19 @@ describe('aiEnvelope.capBreached: engine projection via event-log seam (capabili
       },
     );
     const events = await queryTestEvents(runId, { type: 'cap.breached' });
-    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 evt = events.events[0]!;
     expect(evt.payload.kind).toBe('clarification');
     expect(
       typeof evt.payload.limit,
-      driver.describe('capabilities.md §"cap.breached"', 'payload.limit MUST be present as a number'),
+      req('openwop.it.aiEnvelope.capBreached.cap-breached-payload-includes-limit-observed-and-nodeid-per-capabilities-md', 'capabilities.md §"cap.breached"', 'payload.limit MUST be present as a number'),
     ).toBe('number');
     expect(evt.payload.nodeId).toBe('node-2');
     await resetTestSeam();
   });
 
   it('cap.breached MUST be paired with a terminal node.failed transition', 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-cap-fail-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     await accept(
       {
@@ -250,11 +252,11 @@ describe('aiEnvelope.capBreached: engine projection via event-log seam (capabili
     );
     const breached = await queryTestEvents(runId, { type: 'cap.breached' });
     const failed = await queryTestEvents(runId, { type: 'node.failed' });
-    if (!breached.ok || !failed.ok) return;
+    if (!breached.ok || !failed.ok) return softSkip('blocked', 'precondition not met — `!breached.ok || !failed.ok` returned early (seam, prior step, or fixture unavailable)');
     expect(breached.events.length).toBe(1);
     expect(
       failed.events.length,
-      driver.describe('capabilities.md §"cap.breached"', 'cap.breached MUST be paired with a terminal node.failed event'),
+      req('openwop.it.aiEnvelope.capBreached.cap-breached-must-be-paired-with-a-terminal-node-failed-transition', 'capabilities.md §"cap.breached"', 'cap.breached MUST be paired with a terminal node.failed event'),
     ).toBe(1);
     expect((failed.events[0]!.payload.error as { code?: string }).code).toBe('cap_breached');
     await resetTestSeam();