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

package/src/scenarios/sandbox-memory-cap.test.ts

@@ -17,6 +17,7 @@ import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const HTTP_SKIP = !process.env.OPENWOP_BASE_URL;
 
@@ -45,7 +46,7 @@ describe.skipIf(HTTP_SKIP)('sandbox-memory-cap: capability shape + behavioral (R
 
     expect(
       Number.isInteger(sb.memoryLimitBytes) && sb.memoryLimitBytes >= 1048576,
-      driver.describe(
+      req('openwop.it.sandbox-memory-cap.memorylimitbytes-must-be-integer-1-mib-when-present-per-schema', 
         'RFCS/0035-sandbox-execution-contract.md §A',
         'memoryLimitBytes MUST be integer ≥ 1 MiB (1048576)',
       ),

package/src/scenarios/sandbox-mvp-behavior.test.ts

@@ -39,6 +39,7 @@ import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const HTTP_SKIP = !process.env.OPENWOP_BASE_URL;
 
@@ -84,20 +85,20 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
     if (!(await isSandboxAdvertised())) {
       softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
     }
     const probe = await invoke('misbehave.fs-escape-read');
     expect(probe.status).toBe(200);
     expect(
       probe.body.error?.code,
-      driver.describe(
+      req('openwop.it.sandbox-mvp-behavior.host-fs-escape-fs-access-from-sandboxed-code-fails-closed', 
         'RFCS/0035-sandbox-execution-contract.md §B node-pack-sandbox-fs-gated',
         'sandboxed `require("fs")` MUST fail closed with `sandbox_escape_attempt`',
       ),
     ).toBe('sandbox_escape_attempt');
     expect(
       probe.body.error?.details?.escapeKind,
-      driver.describe(
+      req('openwop.it.sandbox-mvp-behavior.host-fs-escape-fs-access-from-sandboxed-code-fails-closed', 
         'RFCS/0035-sandbox-execution-contract.md §B',
         'escapeKind MUST be host-fs-escape',
       ),
@@ -108,13 +109,13 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
     if (!(await isSandboxAdvertised())) {
       softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
     }
     const probe = await invoke('misbehave.env-leak');
     expect(probe.status).toBe(200);
     expect(
       probe.body.error?.code,
-      driver.describe(
+      req('openwop.it.sandbox-mvp-behavior.host-env-leak-process-env-access-from-sandboxed-code-fails-closed', 
         'RFCS/0035-sandbox-execution-contract.md §B node-pack-sandbox-no-env',
         'sandboxed `process.env` access MUST fail closed with `sandbox_escape_attempt`',
       ),
@@ -126,13 +127,13 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
     if (!(await isSandboxAdvertised())) {
       softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
     }
     const probe = await invoke('misbehave.network-escape');
     expect(probe.status).toBe(200);
     expect(
       probe.body.error?.code,
-      driver.describe(
+      req('openwop.it.sandbox-mvp-behavior.network-escape-http-net-access-from-sandboxed-code-fails-closed', 
         'RFCS/0035-sandbox-execution-contract.md §B node-pack-sandbox-network-gated',
         'sandboxed `require("http")` MUST fail closed with `sandbox_escape_attempt`',
       ),
@@ -144,10 +145,10 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
     if (!(await isSandboxAdvertised())) {
       softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
     }
     const probe = await invoke('misbehave.process-escape');
-    expect(probe.status).toBe(200);
+    expect(probe.status, req('openwop.it.sandbox-mvp-behavior.host-process-escape-child-process-access-from-sandboxed-code-fails-closed', 'RFC 0035 §B', 'host-process-escape — child_process access from sandboxed code fails closed')).toBe(200);
     expect(probe.body.error?.code).toBe('sandbox_escape_attempt');
     // The heuristic may catch this as host-fs-escape (via "require") if
     // network/process patterns don't match first. Accept either as long
@@ -159,7 +160,7 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
     if (!(await isSandboxAdvertised())) {
       softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
     }
     const start = Date.now();
     const probe = await invoke('misbehave.timeout');
@@ -167,7 +168,7 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
     expect(probe.status).toBe(200);
     expect(
       probe.body.error?.code,
-      driver.describe(
+      req('openwop.it.sandbox-mvp-behavior.sandbox-timeout-runaway-loop-terminated-by-wallclocklimitms', 
         'RFCS/0035-sandbox-execution-contract.md §B node-pack-sandbox-timeout',
         'sandboxed infinite-loop MUST be terminated with `sandbox_timeout`',
       ),
@@ -175,7 +176,7 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
     // Should terminate within ~2× wallClockLimitMs (1000ms config + overhead).
     expect(
       elapsed < 5000,
-      driver.describe(
+      req('openwop.it.sandbox-mvp-behavior.sandbox-timeout-runaway-loop-terminated-by-wallclocklimitms', 
         'RFCS/0035-sandbox-execution-contract.md §A wallClockLimitMs',
         `timeout MUST terminate within reasonable bound (got ${elapsed}ms; cap is 1000ms)`,
       ),
@@ -186,7 +187,7 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
     if (!(await isSandboxAdvertised())) {
       softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
     }
     const r1 = await invoke('misbehave.cross-pack-mutate');
     const r2 = await invoke('misbehave.cross-pack-mutate');
@@ -202,7 +203,7 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
     const shared3 = (r3.body.result as { shared?: number })?.shared;
     expect(
       shared1 === 1 && shared2 === 1 && shared3 === 1,
-      driver.describe(
+      req('openwop.it.sandbox-mvp-behavior.cross-pack-mutation-fresh-vm-context-per-invocation-no-state-leaks', 
         'RFCS/0035-sandbox-execution-contract.md §B node-pack-sandbox-isolated-context',
         `each invocation MUST see fresh state (got shared=[${shared1}, ${shared2}, ${shared3}]; expected all 1)`,
       ),
@@ -213,20 +214,20 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
     if (!(await isSandboxAdvertised())) {
       softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
     }
     const probe = await invoke('misbehave.capability-gate-violation', {}, []);
     expect(probe.status).toBe(200);
     expect(
       probe.body.error?.code,
-      driver.describe(
+      req('openwop.it.sandbox-mvp-behavior.capability-gate-respected-host-call-not-in-allowedhostcalls-fails-with-sandbox-c', 
         'spec/v1/host-capabilities.md §"Error codes" + §B node-pack-sandbox-capability-gate-respected',
         'capability-gate violation MUST fail closed with `sandbox_capability_denied` — distinct from `sandbox_escape_attempt` which covers forbidden-syscall escapes per the spec\'s 4-code catalog',
       ),
     ).toBe('sandbox_capability_denied');
     expect(
       probe.body.error?.details?.requestedCapability,
-      driver.describe(
+      req('openwop.it.sandbox-mvp-behavior.capability-gate-respected-host-call-not-in-allowedhostcalls-fails-with-sandbox-c', 
         'spec/v1/host-capabilities.md §"Error codes"',
         '`sandbox_capability_denied` MUST carry `details.requestedCapability` identifying the host method the sandboxed code attempted to call',
       ),
@@ -237,7 +238,7 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
     if (!(await isSandboxAdvertised())) {
       softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
     }
     const probe = await invoke('misbehave.memory-bomb');
     expect(probe.status).toBe(200);
@@ -254,7 +255,7 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
     // legacy code.
     expect(
       ['sandbox_memory_exceeded', 'sandbox_timeout'].includes(probe.body.error?.code ?? ''),
-      driver.describe(
+      req('openwop.it.sandbox-mvp-behavior.memory-exceeded-runaway-allocation-fails-with-sandbox-memory-exceeded', 
         'spec/v1/host-capabilities.md §"Error codes" + §B node-pack-sandbox-memory-cap',
         `memory-bomb MUST surface either \`sandbox_memory_exceeded\` (when memoryLimitBytes caught it) or \`sandbox_timeout\` (when wallClockLimitMs caught it first) — got code: ${probe.body.error?.code}`,
       ),
@@ -265,13 +266,13 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
     if (!(await isSandboxAdvertised())) {
       softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
     }
     const probe = await invoke('well-behaved.host-fetch', {}, ['fetch']);
     expect(probe.status).toBe(200);
     expect(
       probe.body.error,
-      driver.describe(
+      req('openwop.it.sandbox-mvp-behavior.well-behaved-host-fetch-allowedhostcalls-fetch-permits-the-host-call', 
         'RFCS/0035-sandbox-execution-contract.md §A allowedHostCalls',
         'host call IN allowedHostCalls MUST succeed (no error envelope)',
       ),
@@ -282,10 +283,10 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
     if (!(await isSandboxAdvertised())) {
       softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
     }
     const probe = await invoke('well-behaved.echo', { input: 'hello-sandbox' });
-    expect(probe.status).toBe(200);
+    expect(probe.status, req('openwop.it.sandbox-mvp-behavior.well-behaved-echo-sandboxed-code-returns-args-round-trip-when-no-escape-attempt', 'RFC 0035 §B', 'well-behaved.echo — sandboxed code returns args round-trip when no escape attempt')).toBe(200);
     expect(probe.body.error).toBeUndefined();
     expect((probe.body.result as { echoed?: string })?.echoed).toBe('hello-sandbox');
   });

package/src/scenarios/sandbox-no-host-fs-escape.test.ts

@@ -28,6 +28,7 @@ import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const HTTP_SKIP = !process.env.OPENWOP_BASE_URL;
 
@@ -58,7 +59,7 @@ describe.skipIf(HTTP_SKIP)('sandbox-no-host-fs-escape: capability shape (RFC 003
     const sb = await readSandboxCaps();
     if (sb === null) return softSkip('inapplicable', 'host omits the block — soft-skip cleanly (sb === null)');
 
-    expect(typeof sb.supported, 'capabilities.sandbox.supported MUST be boolean when present').toBe('boolean');
+    expect(typeof sb.supported, req('openwop.it.sandbox-no-host-fs-escape.capabilities-sandbox-when-present-conforms-to-rfc-0035-a', 'RFCS/0035-sandbox-execution-contract.md §A', 'capabilities.sandbox.supported MUST be boolean when present')).toBe('boolean');
 
     if (sb.supported === true) {
       const m = sb.isolationModel as string;
@@ -66,7 +67,7 @@ describe.skipIf(HTTP_SKIP)('sandbox-no-host-fs-escape: capability shape (RFC 003
       const isExtension = /^x-host-[a-z][a-z0-9-]*-[a-z][a-z0-9-]*$/.test(m);
       expect(
         isCategorical || isExtension,
-        driver.describe(
+        req('openwop.it.sandbox-no-host-fs-escape.capabilities-sandbox-when-present-conforms-to-rfc-0035-a', 
           'RFCS/0035-sandbox-execution-contract.md §A',
           'isolationModel MUST be one of {wasm, process, container, vm} OR match ^x-host-<host>-<key>$ pattern',
         ),

package/src/scenarios/sandbox-timeout-cap.test.ts

@@ -17,6 +17,7 @@ import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const HTTP_SKIP = !process.env.OPENWOP_BASE_URL;
 
@@ -45,7 +46,7 @@ describe.skipIf(HTTP_SKIP)('sandbox-timeout-cap: capability shape + behavioral (
 
     expect(
       Number.isInteger(sb.wallClockLimitMs) && sb.wallClockLimitMs >= 100,
-      driver.describe(
+      req('openwop.it.sandbox-timeout-cap.wallclocklimitms-must-be-integer-100-ms-when-present-per-schema', 
         'RFCS/0035-sandbox-execution-contract.md §A',
         'wallClockLimitMs MUST be integer ≥ 100 ms',
       ),

package/src/scenarios/sandbox-wasm-isolation.test.ts

@@ -31,8 +31,7 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { FIXTURES_DIR } from '../lib/paths.js';
 import { probeSandboxed } from '../lib/wasm-sandbox-probe.js';
-
-const why = (specRef: string, requirement: string): string => `${specRef} — ${requirement}`;
+import { req } from '../lib/requirement-ids.js';
 const dir = join(FIXTURES_DIR, 'wasm-sandbox');
 const fix = (name: string): Uint8Array => new Uint8Array(readFileSync(join(dir, `${name}.wasm`)));
 const BASE = { allowedHostCalls: [] as string[], memoryLimitBytes: 2 * 1024 * 1024 };
@@ -40,14 +39,14 @@ const BASE = { allowedHostCalls: [] as string[], memoryLimitBytes: 2 * 1024 * 10
 describe('sandbox-wasm-isolation: positive controls (RFC 0035 §B, server-free)', () => {
   it('a well-behaved pure module runs and returns its input', () => {
     const r = probeSandboxed(fix('well-behaved-echo'), BASE, 'invoke', 42);
-    expect(r.ok, why('RFC 0035 §B', 'a pure-compute module runs')).toBe(true);
-    expect(r.result).toBe(42);
+    expect(r.ok, req('openwop.it.sandbox-wasm-isolation.a-well-behaved-pure-module-runs-and-returns-its-input', 'RFC 0035 §B', 'a pure-compute module runs')).toBe(true);
+    expect(r.result, req('openwop.it.sandbox-wasm-isolation.a-well-behaved-pure-module-runs-and-returns-its-input', 'RFC 0035 §B', 'a well-behaved pure module runs and returns its input')).toBe(42);
   });
 
   it('a granted host capability is callable when in allowedHostCalls', () => {
     const r = probeSandboxed(fix('well-behaved-host-fetch'), { ...BASE, allowedHostCalls: ['fetch'] }, 'invoke', 7);
-    expect(r.ok, why('RFC 0035 §B invariant 7', 'a granted openwop.* capability is callable')).toBe(true);
-    expect(r.result).toBe(7);
+    expect(r.ok, req('openwop.it.sandbox-wasm-isolation.a-granted-host-capability-is-callable-when-in-allowedhostcalls', 'RFC 0035 §B invariant 7', 'a granted openwop.* capability is callable')).toBe(true);
+    expect(r.result, req('openwop.it.sandbox-wasm-isolation.a-granted-host-capability-is-callable-when-in-allowedhostcalls', 'RFC 0035 §B', 'a granted host capability is callable when in allowedHostCalls')).toBe(7);
   });
 });
 
@@ -61,8 +60,8 @@ describe('sandbox-wasm-isolation: escape attempts fail closed (RFC 0035 §B 1–
   for (const [fixture, escapeKind, invariant] of cases) {
     it(`${invariant}: ${fixture} → sandbox_escape_attempt (${escapeKind})`, () => {
       const r = probeSandboxed(fix(fixture), BASE);
-      expect(r.code, why('RFC 0035 §B', `${invariant} fails closed before instantiation`)).toBe('sandbox_escape_attempt');
-      expect(r.escapeKind).toBe(escapeKind);
+      expect(r.code, req('openwop.it.sandbox-wasm-isolation.sandbox-escape-attempt', 'RFC 0035 §B', `${invariant} fails closed before instantiation`)).toBe('sandbox_escape_attempt');
+      expect(r.escapeKind, req('openwop.it.sandbox-wasm-isolation.sandbox-escape-attempt', 'RFC 0035 §B', ': → sandbox_escape_attempt ( )')).toBe(escapeKind);
     });
   }
 });
@@ -70,13 +69,13 @@ describe('sandbox-wasm-isolation: escape attempts fail closed (RFC 0035 §B 1–
 describe('sandbox-wasm-isolation: capability gate (RFC 0035 §B 7, server-free)', () => {
   it('an un-granted openwop capability is denied with its name', () => {
     const r = probeSandboxed(fix('misbehaving-capability-gate'), BASE);
-    expect(r.code, why('RFC 0035 §B invariant 7', 'undeclared host capability fails closed')).toBe('sandbox_capability_denied');
-    expect(r.requestedCapability).toBe('privileged');
+    expect(r.code, req('openwop.it.sandbox-wasm-isolation.an-un-granted-openwop-capability-is-denied-with-its-name', 'RFC 0035 §B invariant 7', 'undeclared host capability fails closed')).toBe('sandbox_capability_denied');
+    expect(r.requestedCapability, req('openwop.it.sandbox-wasm-isolation.an-un-granted-openwop-capability-is-denied-with-its-name', 'RFC 0035 §B', 'an un-granted openwop capability is denied with its name')).toBe('privileged');
   });
 
   it('host-fetch WITHOUT the grant is denied (the gate works both directions)', () => {
     const r = probeSandboxed(fix('well-behaved-host-fetch'), BASE);
-    expect(r.code).toBe('sandbox_capability_denied');
+    expect(r.code, req('openwop.it.sandbox-wasm-isolation.host-fetch-without-the-grant-is-denied-the-gate-works-both-directions', 'RFC 0035 §B', 'host-fetch WITHOUT the grant is denied (the gate works both directions)')).toBe('sandbox_capability_denied');
     expect(r.requestedCapability).toBe('fetch');
   });
 });
@@ -84,15 +83,15 @@ describe('sandbox-wasm-isolation: capability gate (RFC 0035 §B 7, server-free)'
 describe('sandbox-wasm-isolation: memory cap (RFC 0035 §B 5, server-free)', () => {
   it('node-pack-sandbox-memory-cap: access beyond the host memory bound is sandbox_memory_exceeded', () => {
     const r = probeSandboxed(fix('misbehaving-memory'), BASE);
-    expect(r.ok, why('RFC 0035 §B invariant 5', 'memory bound is engine-enforced')).toBe(false);
-    expect(r.code).toBe('sandbox_memory_exceeded');
+    expect(r.ok, req('openwop.it.sandbox-wasm-isolation.node-pack-sandbox-memory-cap-access-beyond-the-host-memory-bound-is-sandbox-memo', 'RFC 0035 §B invariant 5', 'memory bound is engine-enforced')).toBe(false);
+    expect(r.code, req('openwop.it.sandbox-wasm-isolation.node-pack-sandbox-memory-cap-access-beyond-the-host-memory-bound-is-sandbox-memo', 'RFC 0035 §B', 'node-pack-sandbox-memory-cap: access beyond the host memory bound is sandbox_memory_exceeded')).toBe('sandbox_memory_exceeded');
   });
 });
 
 describe('sandbox-wasm-isolation: isolated context (RFC 0035 §B 8, server-free)', () => {
   it('node-pack-sandbox-isolated-context: each invocation gets a fresh instance (no cross-pack state)', () => {
     const iso = fix('isolation-global');
-    expect(probeSandboxed(iso, BASE, 'bump').result, why('RFC 0035 §B invariant 8', 'a fresh instance starts at 0')).toBe(1);
-    expect(probeSandboxed(iso, BASE, 'read').result, why('RFC 0035 §B invariant 8', 'no state leaks across invocations')).toBe(0);
+    expect(probeSandboxed(iso, BASE, 'bump').result, req('openwop.it.sandbox-wasm-isolation.node-pack-sandbox-isolated-context-each-invocation-gets-a-fresh-instance-no-cros', 'RFC 0035 §B invariant 8', 'a fresh instance starts at 0')).toBe(1);
+    expect(probeSandboxed(iso, BASE, 'read').result, req('openwop.it.sandbox-wasm-isolation.node-pack-sandbox-isolated-context-each-invocation-gets-a-fresh-instance-no-cros', 'RFC 0035 §B invariant 8', 'no state leaks across invocations')).toBe(0);
   });
 });

package/src/scenarios/sandbox-wasm-timeout.test.ts

@@ -20,21 +20,20 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { FIXTURES_DIR } from '../lib/paths.js';
 import { probeTimeout } from '../lib/wasm-sandbox-probe.js';
-
-const why = (specRef: string, requirement: string): string => `${specRef} — ${requirement}`;
+import { req } from '../lib/requirement-ids.js';
 const dir = join(FIXTURES_DIR, 'wasm-sandbox');
 const fix = (name: string): Uint8Array => new Uint8Array(readFileSync(join(dir, `${name}.wasm`)));
 
 describe('sandbox-wasm-timeout: wall-clock cap is engine/worker-enforced (RFC 0035 §B 6, server-free)', () => {
   it('node-pack-sandbox-timeout: a non-terminating module is killed with sandbox_timeout', async () => {
     const r = await probeTimeout(fix('misbehaving-timeout'), { memoryLimitBytes: 2 * 1024 * 1024, wallClockLimitMs: 300 });
-    expect(r.ok, why('RFC 0035 §B invariant 6', 'an over-budget invocation MUST fail')).toBe(false);
-    expect(r.code, why('RFC 0035 §C', 'the failure code MUST be sandbox_timeout')).toBe('sandbox_timeout');
+    expect(r.ok, req('openwop.it.sandbox-wasm-timeout.node-pack-sandbox-timeout-a-non-terminating-module-is-killed-with-sandbox-timeou', 'RFC 0035 §B invariant 6', 'an over-budget invocation MUST fail')).toBe(false);
+    expect(r.code, req('openwop.it.sandbox-wasm-timeout.node-pack-sandbox-timeout-a-non-terminating-module-is-killed-with-sandbox-timeou', 'RFC 0035 §C', 'the failure code MUST be sandbox_timeout')).toBe('sandbox_timeout');
   });
 
   it('positive control: a well-behaved module completes within the budget (the kill-timer does not false-positive)', async () => {
     const r = await probeTimeout(fix('well-behaved-echo'), { memoryLimitBytes: 2 * 1024 * 1024, wallClockLimitMs: 1000 }, 'invoke', 7);
-    expect(r.ok, why('RFC 0035 §B', 'a within-budget invocation completes before the kill-timer')).toBe(true);
-    expect(r.result).toBe(7);
+    expect(r.ok, req('openwop.it.sandbox-wasm-timeout.positive-control-a-well-behaved-module-completes-within-the-budget-the-kill-time', 'RFC 0035 §B', 'a within-budget invocation completes before the kill-timer')).toBe(true);
+    expect(r.result, req('openwop.it.sandbox-wasm-timeout.positive-control-a-well-behaved-module-completes-within-the-budget-the-kill-time', 'RFC 0035 §B', 'positive control: a well-behaved module completes within the budget (the kill-timer does not false-positive)')).toBe(7);
   });
 });

package/src/scenarios/scheduling-capability-shape.test.ts

@@ -21,6 +21,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';
 
 interface DiscoveryScheduling {
   supported?: boolean;
@@ -46,10 +48,10 @@ async function readScheduling(): Promise<DiscoveryScheduling | null> {
 describe('scheduling-capability-shape: advertisement shape (RFC 0052 §A)', () => {
   it('capabilities.scheduling is either absent or well-formed', async () => {
     const sched = await readScheduling();
-    if (sched === null) return; // host doesn't advertise scheduling at all
+    if (sched === null) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `sched === null` returned early (host doesn\'t advertise scheduling at all)'); // host doesn't advertise scheduling at all
     expect(
       typeof sched.supported,
-      driver.describe(
+      req('openwop.it.scheduling-capability-shape.capabilities-scheduling-is-either-absent-or-well-formed', 
         'capabilities.schema.json §scheduling',
         'capabilities.scheduling.supported MUST be a boolean when scheduling is advertised',
       ),
@@ -58,22 +60,22 @@ describe('scheduling-capability-shape: advertisement shape (RFC 0052 §A)', () =
 
   it('cron/delayed/calendar are booleans when present + supported', async () => {
     const sched = await readScheduling();
-    if (!sched?.supported) return;
+    if (!sched?.supported) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!sched?.supported` returned early');
     for (const k of ['cron', 'delayed', 'calendar'] as const) {
       if (sched[k] === undefined) continue;
       expect(
         typeof sched[k],
-        driver.describe('RFC 0052 §A', `capabilities.scheduling.${k} MUST be a boolean when present`),
+        req('openwop.it.scheduling-capability-shape.cron-delayed-calendar-are-booleans-when-present-supported', 'RFC 0052 §A', `capabilities.scheduling.${k} MUST be a boolean when present`),
       ).toBe('boolean');
     }
   });
 
   it('maxFutureHorizon is an ISO-8601 duration when present', async () => {
     const sched = await readScheduling();
-    if (!sched?.supported || sched.maxFutureHorizon === undefined) return;
+    if (!sched?.supported || sched.maxFutureHorizon === undefined) return softSkip('blocked', 'precondition not met — `!sched?.supported || sched.maxFutureHorizon === undefined` returned early (seam, prior step, or fixture unavailable)');
     expect(
       ISO_DURATION.test(sched.maxFutureHorizon),
-      driver.describe(
+      req('openwop.it.scheduling-capability-shape.maxfuturehorizon-is-an-iso-8601-duration-when-present', 
         'RFC 0052 §A',
         `capabilities.scheduling.maxFutureHorizon MUST be an ISO-8601 duration, got: ${sched.maxFutureHorizon}`,
       ),

package/src/scenarios/scheduling-cron-fires-once.test.ts

@@ -27,6 +27,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';
 
 interface DiscoveryDoc {
   capabilities?: { scheduling?: { supported?: boolean; cron?: boolean } };
@@ -40,25 +42,25 @@ async function readScheduling(): Promise<{ supported?: boolean; cron?: boolean }
 describe('scheduling-cron-fires-once: once-per-tick + missed-tick (RFC 0052 §B)', () => {
   it('a single cron tick produces exactly one run', async () => {
     const sched = await readScheduling();
-    if (!sched?.supported || sched.cron !== true) return; // capability-gated
+    if (!sched?.supported || sched.cron !== true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!sched?.supported || sched.cron !== true` returned early (capability-gated)'); // capability-gated
     const res = await driver.post('/v1/host/sample/scheduling/tick', { scenario: 'single-tick' });
-    if (res.status === 404) return; // seam unwired — soft-skip
+    if (res.status === 404) return softSkip('blocked', 'precondition not met — `res.status === 404` returned early (seam unwired — soft-skip) (seam, prior step, or fixture unavailable)'); // seam unwired — soft-skip
     const body = res.json as { runsFired?: number } | undefined;
     expect(
       body?.runsFired,
-      driver.describe('RFC 0052 §B.2', 'a single cron tick MUST fire exactly one run (no duplicate concurrent firing)'),
+      req('openwop.it.scheduling-cron-fires-once.a-single-cron-tick-produces-exactly-one-run', 'RFC 0052 §B.2', 'a single cron tick MUST fire exactly one run (no duplicate concurrent firing)'),
     ).toBe(1);
   });
 
   it('a missed-tick window does not produce a backlog flood', async () => {
     const sched = await readScheduling();
-    if (!sched?.supported || sched.cron !== true) return; // capability-gated
+    if (!sched?.supported || sched.cron !== true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!sched?.supported || sched.cron !== true` returned early (capability-gated)'); // capability-gated
     const res = await driver.post('/v1/host/sample/scheduling/tick', { scenario: 'missed-window', missedTicks: 5 });
-    if (res.status === 404) return; // seam unwired — soft-skip
+    if (res.status === 404) return softSkip('blocked', 'precondition not met — `res.status === 404` returned early (seam unwired — soft-skip) (seam, prior step, or fixture unavailable)'); // seam unwired — soft-skip
     const body = res.json as { runsFired?: number } | undefined;
     expect(
       typeof body?.runsFired === 'number' && body.runsFired <= 1,
-      driver.describe(
+      req('openwop.it.scheduling-cron-fires-once.a-missed-tick-window-does-not-produce-a-backlog-flood', 
         'RFC 0052 §B.4',
         `a missed-tick window MUST apply the advertised policy (fire-once-on-recovery or skip), never N backlogged runs; got runsFired=${body?.runsFired}`,
       ),

package/src/scenarios/search-bm25-roundtrip.test.ts

@@ -16,6 +16,8 @@
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { discoveryFamilies } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 interface DiscoveryDoc {
   capabilities?: Record<string, unknown>;
@@ -32,10 +34,10 @@ async function readCap(): Promise<Record<string, unknown> | null> {
 describe('search-bm25-roundtrip: advertisement shape (RFC 0018)', () => {
   it('capabilities.searchIndex is either absent or a well-formed object', async () => {
     const cap = await readCap();
-    if (cap === null) return; // host doesn't advertise — skip
+    if (cap === null) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `cap === null` returned early (host doesn\'t advertise — skip)'); // host doesn't advertise — skip
     expect(
       typeof cap.supported,
-      driver.describe(
+      req('openwop.it.search-bm25-roundtrip.capabilities-searchindex-is-either-absent-or-a-well-formed-object', 
         'capabilities.schema.json §searchIndex',
         'capabilities.searchIndex.supported MUST be a boolean when present',
       ),
@@ -50,7 +52,7 @@ async function call(op: string, args: Record<string, unknown>) {
 describe('search-bm25-roundtrip: behavioral (RFC 0018 §A.searchIndex)', () => {
   it('index 3 docs → query for a distinguishing keyword returns the matching doc as top hit', async () => {
     const probe = await call('query', { index: '__probe__', q: 'hello' });
-    if (probe.status === 404) return; // seam not exposed
+    if (probe.status === 404) return softSkip('blocked', 'precondition not met — `probe.status === 404` returned early (seam not exposed) (seam, prior step, or fixture unavailable)'); // seam not exposed
     const index = `idx-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     const idx = await call('index', {
       index,
@@ -69,7 +71,7 @@ describe('search-bm25-roundtrip: behavioral (RFC 0018 §A.searchIndex)', () => {
     expect(Array.isArray(body.hits) && body.hits.length > 0).toBe(true);
     expect(
       body.hits![0]!.id,
-      driver.describe('RFC 0018 §A.searchIndex', 'query for the doc\'s distinguishing tokens MUST return that doc as top-1'),
+      req('openwop.it.search-bm25-roundtrip.index-3-docs-query-for-a-distinguishing-keyword-returns-the-matching-doc-as-top', 'RFC 0018 §A.searchIndex', 'query for the doc\'s distinguishing tokens MUST return that doc as top-1'),
     ).toBe('doc-2');
     // Top hit's score MUST be strictly greater than any tied below-rank.
     if (body.hits!.length > 1) {
@@ -79,7 +81,7 @@ describe('search-bm25-roundtrip: behavioral (RFC 0018 §A.searchIndex)', () => {
 
   it('k limit caps the result set', async () => {
     const probe = await call('query', { index: '__probe__', q: 'hello' });
-    if (probe.status === 404) return;
+    if (probe.status === 404) return softSkip('blocked', 'precondition not met — `probe.status === 404` returned early (seam, prior step, or fixture unavailable)');
     const index = `idx-k-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     const docs = Array.from({ length: 5 }, (_, i) => ({ id: `d-${i}`, fields: { body: 'apple orange banana' } }));
     await call('index', { index, docs });
@@ -87,7 +89,7 @@ describe('search-bm25-roundtrip: behavioral (RFC 0018 §A.searchIndex)', () => {
     const body = q.json as { hits?: unknown[] };
     expect(
       Array.isArray(body.hits) && body.hits.length <= 2,
-      driver.describe('RFC 0018 §A.searchIndex', 'query MUST return at most k hits'),
+      req('openwop.it.search-bm25-roundtrip.k-limit-caps-the-result-set', 'RFC 0018 §A.searchIndex', 'query MUST return at most k hits'),
     ).toBe(true);
   });
 });