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

package/src/scenarios/secret-leakage-otel-attribute.test.ts

@@ -57,6 +57,8 @@ import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 import { getCollector, waitForRunSpans } from '../lib/otel-collector.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 /**
  * Callback-shaped: the host exports OTLP spans to the suite's collector, which scans them for the BYOK canary.
@@ -106,25 +108,25 @@ describe.skipIf(HTTP_SKIP || FIXTURE_SKIP)(
     it('NO OTel span attribute MUST contain the BYOK canary plaintext for a run that resolved it', async (ctx) => {
       if (!CANARY_VALUE) {
         ctx.skip();
-        return;
+        return softSkip('blocked', 'precondition not met — `!CANARY_VALUE` returned early (seam, prior step, or fixture unavailable)');
       }
       const d = await readDiscovery();
       const secretsOk = capabilityFamily<{ supported?: unknown }>(d, 'secrets')?.supported === true;
       const seamOk = capabilityFamily<{ testSeams?: Record<string, unknown> }>(d, 'observability')?.testSeams?.otelScrape === true;
       if (!secretsOk || !seamOk) {
         ctx.skip();
-        return;
+        return softSkip('blocked', 'precondition not met — `!secretsOk || !seamOk` returned early (seam, prior step, or fixture unavailable)');
       }
 
       const runId = await startByokRun();
       if (runId === null) {
         ctx.skip();
-        return;
+        return softSkip('blocked', 'precondition not met — `runId === null` returned early (seam, prior step, or fixture unavailable)');
       }
       const terminal = await pollUntilTerminal(runId);
       expect(
         terminal.status,
-        driver.describe(
+        req('openwop.it.secret-leakage-otel-attribute.no-otel-span-attribute-must-contain-the-byok-canary-plaintext-for-a-run-that-res', 
           'auth.md §"Secret resolution"',
           'BYOK fixture run MUST terminate `completed` when the canary is provisioned',
         ),
@@ -135,7 +137,7 @@ describe.skipIf(HTTP_SKIP || FIXTURE_SKIP)(
       );
       expect(
         spansRes.status,
-        driver.describe(
+        req('openwop.it.secret-leakage-otel-attribute.no-otel-span-attribute-must-contain-the-byok-canary-plaintext-for-a-run-that-res', 
           'RFCS/0034-otel-collector-test-seam.md §B',
           'host advertising capabilities.observability.testSeams.otelScrape MUST serve GET /v1/host/sample/test/otel/spans (200) — 404 is non-conformant',
         ),
@@ -145,7 +147,7 @@ describe.skipIf(HTTP_SKIP || FIXTURE_SKIP)(
       const spans = body.spans ?? [];
       expect(
         Array.isArray(spans),
-        driver.describe(
+        req('openwop.it.secret-leakage-otel-attribute.no-otel-span-attribute-must-contain-the-byok-canary-plaintext-for-a-run-that-res', 
           'RFCS/0034-otel-collector-test-seam.md §B',
           'response body MUST have a `spans` array',
         ),
@@ -160,7 +162,7 @@ describe.skipIf(HTTP_SKIP || FIXTURE_SKIP)(
 
       expect(
         serialized.includes(CANARY_VALUE),
-        driver.describe(
+        req('openwop.it.secret-leakage-otel-attribute.no-otel-span-attribute-must-contain-the-byok-canary-plaintext-for-a-run-that-res', 
           'SECURITY/invariants.yaml secret-leakage-otel-attribute',
           'no OTel span attribute may contain the BYOK canary plaintext — host instrumentation MUST redact or omit secret material before any span emission. Per `agent-memory.md` §SR-1, the canonical redaction marker is `[REDACTED:<secretId>]`.',
         ),
@@ -175,20 +177,20 @@ describe.skipIf(HTTP_SKIP || FIXTURE_SKIP)(
     it('NO debug-bundle field MUST contain the BYOK canary plaintext for a run that resolved it', async (ctx) => {
       if (!CANARY_VALUE) {
         ctx.skip();
-        return;
+        return softSkip('blocked', 'precondition not met — `!CANARY_VALUE` returned early (seam, prior step, or fixture unavailable)');
       }
       const d = await readDiscovery();
       const secretsOk = capabilityFamily<{ supported?: unknown }>(d, 'secrets')?.supported === true;
       const seamOk = capabilityFamily<{ testSeams?: Record<string, unknown> }>(d, 'observability')?.testSeams?.debugBundleExport === true;
       if (!secretsOk || !seamOk) {
         ctx.skip();
-        return;
+        return softSkip('blocked', 'precondition not met — `!secretsOk || !seamOk` returned early (seam, prior step, or fixture unavailable)');
       }
 
       const runId = await startByokRun();
       if (runId === null) {
         ctx.skip();
-        return;
+        return softSkip('blocked', 'precondition not met — `runId === null` returned early (seam, prior step, or fixture unavailable)');
       }
       const terminal = await pollUntilTerminal(runId);
       expect(terminal.status).toBe('completed');
@@ -196,7 +198,7 @@ describe.skipIf(HTTP_SKIP || FIXTURE_SKIP)(
       const bundleRes = await driver.post('/v1/host/sample/test/debug-bundle/export', { runId });
       expect(
         bundleRes.status,
-        driver.describe(
+        req('openwop.it.secret-leakage-otel-attribute.no-debug-bundle-field-must-contain-the-byok-canary-plaintext-for-a-run-that-reso', 
           'RFCS/0034-otel-collector-test-seam.md §B',
           'host advertising capabilities.observability.testSeams.debugBundleExport MUST serve POST /v1/host/sample/test/debug-bundle/export (200) — 404 is non-conformant',
         ),
@@ -205,7 +207,7 @@ describe.skipIf(HTTP_SKIP || FIXTURE_SKIP)(
       const serialized = JSON.stringify(bundleRes.json ?? {});
       expect(
         serialized.includes(CANARY_VALUE),
-        driver.describe(
+        req('openwop.it.secret-leakage-otel-attribute.no-debug-bundle-field-must-contain-the-byok-canary-plaintext-for-a-run-that-reso', 
           'SECURITY/invariants.yaml secret-leakage-debug-bundle-otel',
           'no debug-bundle field may contain the BYOK canary plaintext — debug-bundle export MUST redact or omit secret material. Per `debug-bundle.md` §"Redaction", the canonical marker is `[REDACTED:<secretId>]`.',
         ),
@@ -229,21 +231,21 @@ describe.skipIf(HTTP_SKIP || FIXTURE_SKIP)(
       const collector = getCollector();
       if (!collector || !CANARY_VALUE) {
         ctx.skip();
-        return;
+        return softSkip('blocked', 'precondition not met — `!collector || !CANARY_VALUE` returned early (seam, prior step, or fixture unavailable)');
       }
       const d = await readDiscovery();
       const secretsOk = capabilityFamily<{ supported?: unknown }>(d, 'secrets')?.supported === true;
       const obsOk = capabilityFamily<unknown>(d, 'observability') !== undefined;
       if (!secretsOk || !obsOk) {
         ctx.skip();
-        return;
+        return softSkip('blocked', 'precondition not met — `!secretsOk || !obsOk` returned early (seam, prior step, or fixture unavailable)');
       }
 
       collector.reset();
       const runId = await startByokRun();
       if (runId === null) {
         ctx.skip();
-        return;
+        return softSkip('blocked', 'precondition not met — `runId === null` returned early (seam, prior step, or fixture unavailable)');
       }
       const terminal = await pollUntilTerminal(runId);
       expect(terminal.status).toBe('completed');
@@ -256,7 +258,7 @@ describe.skipIf(HTTP_SKIP || FIXTURE_SKIP)(
       const leaks = collector.findCanaryLeakage(CANARY_VALUE);
       expect(
         leaks,
-        driver.describe(
+        req('openwop.it.secret-leakage-otel-attribute.no-real-exported-otel-span-metric-attribute-must-contain-the-byok-canary-plainte', 
           'SECURITY/invariants.yaml secret-leakage-otel-attribute',
           `no real-exported OTel span/metric attribute may contain the BYOK canary plaintext. Leaking surfaces: ${JSON.stringify(leaks)}`,
         ),
@@ -272,17 +274,17 @@ describe.skipIf(HTTP_SKIP || FIXTURE_SKIP)(
       const d = await readDiscovery();
       if (capabilityFamily<{ supported?: unknown }>(d, 'secrets')?.supported !== true) {
         ctx.skip();
-        return;
+        return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `capabilityFamily<{ supported?: unknown }>(d, \'secrets\')?.supported !== true` returned early');
       }
       const seams = capabilityFamily<{ testSeams?: Record<string, unknown> }>(d, 'observability')?.testSeams;
       if (seams === undefined) {
         ctx.skip(); // host honest about not exposing the seams — Drift #17 path
-        return;
+        return softSkip('blocked', 'precondition not met — `seams === undefined` returned early (seam, prior step, or fixture unavailable)');
       }
       if ('otelScrape' in seams && seams.otelScrape !== undefined) {
         expect(
           typeof seams.otelScrape,
-          driver.describe(
+          req('openwop.it.secret-leakage-otel-attribute.when-secrets-supported-is-true-observability-testseams-advertisements-must-be-bo', 
             'RFCS/0034-otel-collector-test-seam.md §A',
             'capabilities.observability.testSeams.otelScrape MUST be boolean when present',
           ),
@@ -291,7 +293,7 @@ describe.skipIf(HTTP_SKIP || FIXTURE_SKIP)(
       if ('debugBundleExport' in seams && seams.debugBundleExport !== undefined) {
         expect(
           typeof seams.debugBundleExport,
-          driver.describe(
+          req('openwop.it.secret-leakage-otel-attribute.when-secrets-supported-is-true-observability-testseams-advertisements-must-be-bo', 
             'RFCS/0034-otel-collector-test-seam.md §A',
             'capabilities.observability.testSeams.debugBundleExport MUST be boolean when present',
           ),

package/src/scenarios/self-hosted-runner.test.ts

@@ -37,6 +37,8 @@ import { behaviorGate } from '../lib/behavior-gate.js';
 import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
 import { SCHEMAS_DIR } from '../lib/paths.js';
 import { readErrorCode, readRetriable } from '../lib/error-envelope.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const GATE = 'openwop-self-hosted-runner';
 
@@ -85,32 +87,32 @@ describe('self-hosted-runner: schema shape (RFC 0122, server-free)', () => {
   it('capabilities.schema.json declares selfHostedRunner {supported} with required supported', () => {
     const caps = readSchema('capabilities.schema.json');
     const shr = caps.properties?.selfHostedRunner;
-    expect(shr, 'capabilities.md §selfHostedRunner — the block MUST be declared').toBeDefined();
+    expect(shr, req('openwop.it.self-hosted-runner.capabilities-schema-json-declares-selfhostedrunner-supported-with-required-suppo', 'RFC 0122', 'capabilities.md §selfHostedRunner — the block MUST be declared')).toBeDefined();
     expect(
       shr?.required,
-      'RFC 0122 — selfHostedRunner.supported is REQUIRED when the block is present',
+      req('openwop.it.self-hosted-runner.capabilities-schema-json-declares-selfhostedrunner-supported-with-required-suppo', 'RFC 0122', 'RFC 0122 — selfHostedRunner.supported is REQUIRED when the block is present'),
     ).toContain('supported');
     expect(
       shr?.properties?.supported?.type,
-      'selfHostedRunner.supported MUST be a boolean',
+      req('openwop.it.self-hosted-runner.capabilities-schema-json-declares-selfhostedrunner-supported-with-required-suppo', 'RFC 0122', 'selfHostedRunner.supported MUST be a boolean'),
     ).toBe('boolean');
     expect(
       shr?.additionalProperties,
-      'selfHostedRunner MUST be a closed object',
+      req('openwop.it.self-hosted-runner.capabilities-schema-json-declares-selfhostedrunner-supported-with-required-suppo', 'RFC 0122', 'selfHostedRunner MUST be a closed object'),
     ).toBe(false);
   });
 
   it('the dispatch frame schema pins {runId, stepId, seq, kind, inputs} with an integer cursor', () => {
     const s = readSchema('self-hosted-runner-dispatch-frame.schema.json');
     for (const f of ['runId', 'stepId', 'seq', 'kind', 'inputs']) {
-      expect(s.required, `dispatch frame MUST require '${f}'`).toContain(f);
+      expect(s.required, req('openwop.it.self-hosted-runner.the-dispatch-frame-schema-pins-runid-stepid-seq-kind-inputs-with-an-integer-curs', 'RFC 0122', `dispatch frame MUST require '${f}'`)).toContain(f);
     }
-    expect(s.additionalProperties, 'dispatch frame MUST be a closed object').toBe(false);
+    expect(s.additionalProperties, req('openwop.it.self-hosted-runner.the-dispatch-frame-schema-pins-runid-stepid-seq-kind-inputs-with-an-integer-curs', 'RFC 0122', 'dispatch frame MUST be a closed object')).toBe(false);
     expect(
       s.properties?.seq?.type,
-      'RFC 0122 §Channel — the dispatch cursor `seq` MUST be an integer (distinct from the event-log sequence)',
+      req('openwop.it.self-hosted-runner.the-dispatch-frame-schema-pins-runid-stepid-seq-kind-inputs-with-an-integer-curs', 'RFC 0122', 'RFC 0122 §Channel — the dispatch cursor `seq` MUST be an integer (distinct from the event-log sequence)'),
     ).toBe('integer');
-    expect(s.properties?.kind?.enum, "dispatch kind MUST be one of {model, tool}").toEqual(
+    expect(s.properties?.kind?.enum, req('openwop.it.self-hosted-runner.the-dispatch-frame-schema-pins-runid-stepid-seq-kind-inputs-with-an-integer-curs', 'RFC 0122', "dispatch kind MUST be one of {model, tool}")).toEqual(
       expect.arrayContaining(['model', 'tool']),
     );
   });
@@ -118,25 +120,25 @@ describe('self-hosted-runner: schema shape (RFC 0122, server-free)', () => {
   it('the result frame schema pins {runId, stepId, seq, output} and is closed', () => {
     const s = readSchema('self-hosted-runner-result-frame.schema.json');
     for (const f of ['runId', 'stepId', 'seq', 'output']) {
-      expect(s.required, `result frame MUST require '${f}'`).toContain(f);
+      expect(s.required, req('openwop.it.self-hosted-runner.the-result-frame-schema-pins-runid-stepid-seq-output-and-is-closed', 'RFC 0122', `result frame MUST require '${f}'`)).toContain(f);
     }
     // additionalProperties:false is the schema-level runner-credential-non-transit rail —
     // a runner cannot smuggle a credential field onto a result frame.
     expect(
       s.additionalProperties,
-      'result frame MUST be a closed object (runner-credential-non-transit)',
+      req('openwop.it.self-hosted-runner.the-result-frame-schema-pins-runid-stepid-seq-output-and-is-closed', 'RFC 0122', 'result frame MUST be a closed object (runner-credential-non-transit)'),
     ).toBe(false);
   });
 
   it('the registration schema pins {runnerId, subject, capabilities} and is closed', () => {
     const s = readSchema('self-hosted-runner-registration.schema.json');
     for (const f of ['runnerId', 'subject', 'capabilities']) {
-      expect(s.required, `registration MUST require '${f}'`).toContain(f);
+      expect(s.required, req('openwop.it.self-hosted-runner.the-registration-schema-pins-runnerid-subject-capabilities-and-is-closed', 'RFC 0122', `registration MUST require '${f}'`)).toContain(f);
     }
-    expect(s.additionalProperties, 'registration MUST be a closed object').toBe(false);
+    expect(s.additionalProperties, req('openwop.it.self-hosted-runner.the-registration-schema-pins-runnerid-subject-capabilities-and-is-closed', 'RFC 0122', 'registration MUST be a closed object')).toBe(false);
     expect(
       s.properties?.capabilities?.additionalProperties,
-      'registration.capabilities MUST be a closed object',
+      req('openwop.it.self-hosted-runner.the-registration-schema-pins-runnerid-subject-capabilities-and-is-closed', 'RFC 0122', 'registration.capabilities MUST be a closed object'),
     ).toBe(false);
   });
 });
@@ -148,13 +150,13 @@ describe('self-hosted-runner: advertisement shape (gated)', () => {
 
     expect(
       typeof shr?.supported,
-      driver.describe('capabilities.md §selfHostedRunner', 'supported MUST be a boolean'),
+      req('openwop.it.self-hosted-runner.an-advertised-selfhostedrunner-block-is-well-formed', 'capabilities.md §selfHostedRunner', 'supported MUST be a boolean'),
     ).toBe('boolean');
     if (shr?.dispatchKinds !== undefined) {
       for (const k of shr.dispatchKinds) {
         expect(
           ['model', 'tool'],
-          driver.describe('capabilities.md §selfHostedRunner', `dispatchKinds entry '${k}' MUST be model|tool`),
+          req('openwop.it.self-hosted-runner.an-advertised-selfhostedrunner-block-is-well-formed', 'capabilities.md §selfHostedRunner', `dispatchKinds entry '${k}' MUST be model|tool`),
         ).toContain(k);
       }
     }
@@ -171,7 +173,7 @@ describe('self-hosted-runner: behavioral (seam-gated, soft-skip 404)', () => {
       subject: SUBJECT_B,
       capabilities: { providers: ['anthropic'] },
     });
-    if (reg.status === 404) return; // seam unwired — soft-skip
+    if (reg.status === 404) return softSkip('blocked', 'precondition not met — `reg.status === 404` returned early (seam unwired — soft-skip) (seam, prior step, or fixture unavailable)'); // seam unwired — soft-skip
 
     const res = await driver.post(DISPATCH, {
       subject: SUBJECT_A,
@@ -183,19 +185,19 @@ describe('self-hosted-runner: behavioral (seam-gated, soft-skip 404)', () => {
       model: 'claude-opus-4-8',
       inputs: { messages: [] },
     });
-    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 >= 400,
-      driver.describe('self-hosted-runner.md §Behavior#1', 'a subject-A dispatch MUST NOT route to a subject-B runner'),
+      req('openwop.it.self-hosted-runner.a-dispatch-for-a-subject-with-no-runner-fails-retriably-with-runner-unavailable', 'self-hosted-runner.md §Behavior#1', 'a subject-A dispatch MUST NOT route to a subject-B runner'),
     ).toBe(true);
     expect(
       errCode(res.json),
-      driver.describe('RFC 0122 §Behavior#5', 'a dispatch with no owning-subject runner MUST fail `runner_unavailable`'),
+      req('openwop.it.self-hosted-runner.a-dispatch-for-a-subject-with-no-runner-fails-retriably-with-runner-unavailable', 'RFC 0122 §Behavior#5', 'a dispatch with no owning-subject runner MUST fail `runner_unavailable`'),
     ).toBe('runner_unavailable');
     expect(
       retriable(res.json),
-      driver.describe('RFC 0122 §Behavior#5', '`runner_unavailable` MUST be retriable'),
+      req('openwop.it.self-hosted-runner.a-dispatch-for-a-subject-with-no-runner-fails-retriably-with-runner-unavailable', 'RFC 0122 §Behavior#5', '`runner_unavailable` MUST be retriable'),
     ).toBe(true);
   });
 
@@ -205,7 +207,7 @@ describe('self-hosted-runner: behavioral (seam-gated, soft-skip 404)', () => {
       subject: SUBJECT_A,
       capabilities: { providers: ['anthropic'] },
     });
-    if (reg.status === 404) return;
+    if (reg.status === 404) return softSkip('blocked', 'precondition not met — `reg.status === 404` returned early (seam, prior step, or fixture unavailable)');
 
     const frame = {
       subject: SUBJECT_A,
@@ -218,16 +220,16 @@ describe('self-hosted-runner: behavioral (seam-gated, soft-skip 404)', () => {
       inputs: { messages: [] },
     };
     const first = await driver.post(DISPATCH, frame);
-    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)');
     // A host without a live runner backing the seam MAY answer runner_unavailable;
     // the at-most-once property is only observable when the first dispatch resolved.
-    if (errCode(first.json) === 'runner_unavailable') return;
+    if (errCode(first.json) === 'runner_unavailable') return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `errCode(first.json) === \'runner_unavailable\'` returned early (A host without a live runner backing the seam MAY answer runner_unavailable; the at-most-once pro…');
 
     const second = await driver.post(DISPATCH, frame);
     const body = second.json as { deduped?: unknown };
     expect(
       body?.deduped,
-      driver.describe(
+      req('openwop.it.self-hosted-runner.a-redelivered-runid-stepid-dispatch-is-dropped-not-re-executed-at-most-once', 
         'self-hosted-runner.md §At-most-once dispatch',
         'a redelivered {runId, stepId} with a persisted result MUST be dropped (deduped:true), not re-dispatched',
       ),

package/src/scenarios/semantic-digest-vectors.test.ts

@@ -35,6 +35,7 @@ import {
   canonicalize,
   SEMANTIC_REQUEST_RECIPE_V2,
 } from '../lib/llm-cache-key-recipe.js';
+import { req } from '../lib/requirement-ids.js';
 
 interface Vector {
   readonly id: string;
@@ -87,10 +88,10 @@ describe('RFC 0150 §C — semantic request digest golden vectors', () => {
     // Guard: an empty or truncated file would make every leg below vacuous, and
     // this gate's whole value is that it fails when an implementation drifts.
     expect(doc.recipe).toBe(SEMANTIC_REQUEST_RECIPE_V2);
-    expect(doc.vectors.length, 'the golden set MUST cover the recipe').toBeGreaterThanOrEqual(10);
+    expect(doc.vectors.length, req('openwop.it.semantic-digest-vectors.the-vector-set-is-present-and-non-trivial', 'RFC 0150 §C', 'the golden set MUST cover the recipe')).toBeGreaterThanOrEqual(10);
     expect(new Set(doc.vectors.map((v) => v.id)).size).toBe(doc.vectors.length);
     for (const v of doc.vectors) {
-      expect(v.why.length, `vector '${v.id}' MUST say what it pins`).toBeGreaterThan(20);
+      expect(v.why.length, req('openwop.it.semantic-digest-vectors.the-vector-set-is-present-and-non-trivial', 'RFC 0150 §C', `vector '${v.id}' MUST say what it pins`)).toBeGreaterThan(20);
     }
   });
 
@@ -100,19 +101,19 @@ describe('RFC 0150 §C — semantic request digest golden vectors', () => {
       // The preimage is asserted as well as the hash: a mismatch on `canonical`
       // tells an implementer WHICH field they got wrong, where a hash mismatch
       // tells them only that something is.
-      expect(canonicalize(projectSemanticRequestV2(v.input)), v.why).toBe(v.canonical);
+      expect(canonicalize(projectSemanticRequestV2(v.input)), req('openwop.it.semantic-digest-vectors.the-implementation-reproduces-s', 'RFC 0150 §C', v.why)).toBe(v.canonical);
       expect(semanticRequestDigestV2(v.input), v.why).toBe(v.digest);
     },
   );
 
   it('tool order is not semantic — sorted and reversed agree', () => {
-    expect(digest('tools-sorted-by-name')).toBe(digest('tools-reversed-same-digest'));
+    expect(digest('tools-sorted-by-name'), req('openwop.it.semantic-digest-vectors.tool-order-is-not-semantic-sorted-and-reversed-agree', 'RFC 0150 §C', 'tool order is not semantic — sorted and reversed agree')).toBe(digest('tools-reversed-same-digest'));
   });
 
   it('message order IS semantic — reversing changes the digest', () => {
     expect(
       digest('message-order-is-semantic'),
-      'messages carry conversational sequence; sorting them would make two different conversations collide',
+      req('openwop.it.semantic-digest-vectors.message-order-is-semantic-reversing-changes-the-digest', 'RFC 0150 §C', 'messages carry conversational sequence; sorting them would make two different conversations collide'),
     ).not.toBe(digest('message-order-reversed'));
   });
 
@@ -120,7 +121,7 @@ describe('RFC 0150 §C — semantic request digest golden vectors', () => {
     // The pair that catches a well-meaning "add NFC to be safe" change — and it
     // catches it only because `digest()` RECOMPUTES from the input. Comparing
     // stored values here would be two constants from one file.
-    expect(storedDigest('non-ascii-not-normalized')).not.toBe(storedDigest('non-ascii-composed'));
+    expect(storedDigest('non-ascii-not-normalized'), req('openwop.it.semantic-digest-vectors.the-two-unicode-forms-do-not-collide-because-jcs-does-not-apply-nfc', 'RFC 0150 §C', 'the two Unicode forms do not collide, because JCS does not apply NFC')).not.toBe(storedDigest('non-ascii-composed'));
     expect(
       digest('non-ascii-not-normalized'),
       'RFC 0150 §C: "Implementations MUST NOT add Unicode normalization outside JCS." An ' +
@@ -134,7 +135,7 @@ describe('RFC 0150 §C — semantic request digest golden vectors', () => {
     // these were equal to `minimal`, so requests producing different completions
     // shared a cache key — a wrong hit, not a miss.
     for (const id of ['stop-changes-digest', 'seed-changes-digest', 'max-output-changes-digest']) {
-      expect(digest(id), `${id} MUST NOT equal the minimal request`).not.toBe(digest('minimal'));
+      expect(digest(id), req('openwop.it.semantic-digest-vectors.each-field-v1-excluded-now-changes-the-digest', 'RFC 0150 §C', `${id} MUST NOT equal the minimal request`)).not.toBe(digest('minimal'));
     }
   });
 });

package/src/scenarios/speech-synthesis-roundtrip.test.ts

@@ -24,6 +24,8 @@ import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const SEAM = '/v1/host/sample/ai/call-speech-synthesizer';
 const VOICE_ID = 'host:narrator-test';
@@ -44,35 +46,35 @@ describe('speech-synthesis-roundtrip (RFC 0105 §A)', () => {
       text: 'Welcome to the weekly digest.',
       voiceId: VOICE_ID,
     });
-    if (res.status === 404) return; // seam unwired — soft-skip the behavioral suite
+    if (res.status === 404) return softSkip('blocked', 'precondition not met — `res.status === 404` returned early (seam unwired — soft-skip the behavioral suite) (seam, prior step, or fixture unavailable)'); // seam unwired — soft-skip the behavioral suite
 
     expect(
       res.status === 200,
-      driver.describe('RFC 0105 §A', 'an advertised host MUST synthesize and return 200'),
+      req('openwop.it.speech-synthesis-roundtrip.synthesizes-an-audio-asset-with-exactly-one-of-url-base64-and-echoes-the-voiceid', 'RFC 0105 §A', 'an advertised host MUST synthesize and return 200'),
     ).toBe(true);
 
     const audio = audioOf(res.json);
     expect(
       audio !== undefined,
-      driver.describe('RFC 0105 §A', 'the response MUST carry an `audio` object'),
+      req('openwop.it.speech-synthesis-roundtrip.synthesizes-an-audio-asset-with-exactly-one-of-url-base64-and-echoes-the-voiceid', 'RFC 0105 §A', 'the response MUST carry an `audio` object'),
     ).toBe(true);
-    if (!audio) return;
+    if (!audio) return softSkip('blocked', 'precondition not met — `!audio` returned early (seam, prior step, or fixture unavailable)');
 
     const hasUrl = typeof audio.url === 'string' && (audio.url as string).length > 0;
     const hasBase64 = typeof audio.base64 === 'string' && (audio.base64 as string).length > 0;
     expect(
       hasUrl !== hasBase64,
-      driver.describe('RFC 0105 §A', 'audio MUST carry EXACTLY ONE of `url` / `base64`'),
+      req('openwop.it.speech-synthesis-roundtrip.synthesizes-an-audio-asset-with-exactly-one-of-url-base64-and-echoes-the-voiceid', 'RFC 0105 §A', 'audio MUST carry EXACTLY ONE of `url` / `base64`'),
     ).toBe(true);
 
     expect(
       typeof audio.mimeType === 'string' && (audio.mimeType as string).length > 0,
-      driver.describe('RFC 0105 §A', 'audio.mimeType MUST be a non-empty string'),
+      req('openwop.it.speech-synthesis-roundtrip.synthesizes-an-audio-asset-with-exactly-one-of-url-base64-and-echoes-the-voiceid', 'RFC 0105 §A', 'audio.mimeType MUST be a non-empty string'),
     ).toBe(true);
 
     expect(
       audio.voiceId === VOICE_ID,
-      driver.describe('RFC 0105 §A', 'audio.voiceId MUST echo the input voiceId'),
+      req('openwop.it.speech-synthesis-roundtrip.synthesizes-an-audio-asset-with-exactly-one-of-url-base64-and-echoes-the-voiceid', 'RFC 0105 §A', 'audio.voiceId MUST echo the input voiceId'),
     ).toBe(true);
   });
 });

package/src/scenarios/speech-synthesis-unadvertised.test.ts

@@ -24,6 +24,8 @@ import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const SEAM = '/v1/host/sample/ai/call-speech-synthesizer';
 
@@ -50,16 +52,16 @@ describe('speech-synthesis-unadvertised (RFC 0105 §C)', () => {
       text: 'Welcome to the weekly digest.',
       voiceId: 'host:narrator-test',
     });
-    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
 
     // MUST reject — never a 200 success, never a silent no-op.
     expect(
       res.status !== 200,
-      driver.describe('RFC 0105 §C', 'an unadvertising host MUST NOT return a 200 success (never a no-op)'),
+      req('openwop.it.speech-synthesis-unadvertised.a-host-not-advertising-speechsynthesis-must-reject-the-call-with-speech-synthesi', 'RFC 0105 §C', 'an unadvertising host MUST NOT return a 200 success (never a no-op)'),
     ).toBe(true);
     expect(
       errCode(res.json) === 'speech_synthesis_unsupported',
-      driver.describe('RFC 0105 §C', 'the call MUST be rejected with `speech_synthesis_unsupported`'),
+      req('openwop.it.speech-synthesis-unadvertised.a-host-not-advertising-speechsynthesis-must-reject-the-call-with-speech-synthesi', 'RFC 0105 §C', 'the call MUST be rejected with `speech_synthesis_unsupported`'),
     ).toBe(true);
   });
 });

package/src/scenarios/sql-injection-rejection.test.ts

@@ -14,6 +14,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>;
@@ -34,10 +36,10 @@ async function call(op: string, args: Record<string, unknown>) {
 describe('sql-injection-rejection: advertisement shape (RFC 0018)', () => {
   it('capabilities.sql is either absent or a well-formed object', async () => {
     const cap = await readCap();
-    if (cap === null) return;
+    if (cap === null) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `cap === null` returned early');
     expect(
       typeof cap.supported,
-      driver.describe(
+      req('openwop.it.sql-injection-rejection.capabilities-sql-is-either-absent-or-a-well-formed-object', 
         'capabilities.schema.json §sql',
         'capabilities.sql.supported MUST be a boolean when present',
       ),
@@ -48,13 +50,13 @@ describe('sql-injection-rejection: advertisement shape (RFC 0018)', () => {
 describe('sql-injection-rejection: behavioral (RFC 0018 §C)', () => {
   it('parametric SELECT with bound user input rejects injection-shape strings as data', async () => {
     const cap = await readCap();
-    if (!cap || cap.supported !== true) return;
+    if (!cap || cap.supported !== true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!cap || cap.supported !== true` returned early');
 
     const create = await call('execute', {
       sql: `CREATE TABLE IF NOT EXISTS sql_inj_t (id TEXT PRIMARY KEY, body TEXT)`,
       params: [],
     });
-    if (create.status === 404) return;
+    if (create.status === 404) return softSkip('blocked', 'precondition not met — `create.status === 404` returned early (seam, prior step, or fixture unavailable)');
     await call('execute', { sql: `INSERT OR REPLACE INTO sql_inj_t VALUES (?, ?)`, params: ['k1', 'ok'] });
 
     // Parametric round-trip MUST succeed.
@@ -64,7 +66,7 @@ describe('sql-injection-rejection: behavioral (RFC 0018 §C)', () => {
     });
     expect(okRes.status).toBe(200);
     const okBody = okRes.json as { rows?: Array<Record<string, unknown>> };
-    expect(okBody.rows?.[0]?.body, 'parametric round-trip MUST return stored value').toBe('ok');
+    expect(okBody.rows?.[0]?.body, req('openwop.it.sql-injection-rejection.parametric-select-with-bound-user-input-rejects-injection-shape-strings-as-data', 'SECURITY/invariants.yaml sql-parametric-only', 'parametric round-trip MUST return stored value')).toBe('ok');
 
     // Injection-shape input MUST be bound as a literal value, not SQL.
     const attack = `' OR '1'='1`;
@@ -76,7 +78,7 @@ describe('sql-injection-rejection: behavioral (RFC 0018 §C)', () => {
     const attackBody = attackRes.json as { rows?: Array<Record<string, unknown>> };
     expect(
       Array.isArray(attackBody.rows) ? attackBody.rows.length : -1,
-      driver.describe(
+      req('openwop.it.sql-injection-rejection.parametric-select-with-bound-user-input-rejects-injection-shape-strings-as-data', 
         'SECURITY/invariants.yaml sql-parametric-only',
         'parametric binding MUST treat injection-shape input as a literal value, not SQL',
       ),

package/src/scenarios/sql-transaction-atomicity.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('sql-transaction-atomicity: advertisement shape (RFC 0018)', () => {
   it('capabilities.sql 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.sql-transaction-atomicity.capabilities-sql-is-either-absent-or-a-well-formed-object', 
         'capabilities.schema.json §sql',
         'capabilities.sql.supported MUST be a boolean when present',
       ),
@@ -44,17 +46,17 @@ describe('sql-transaction-atomicity: advertisement shape (RFC 0018)', () => {
 
   it('transactions is a boolean when set', async () => {
     const cap = await readCap();
-    if (!cap || cap.supported !== true) return;
+    if (!cap || cap.supported !== true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!cap || cap.supported !== true` returned early');
     const subParts = ["transactions"];
     let sub: unknown = cap;
     for (const p of subParts) {
       if (sub && typeof sub === 'object') sub = (sub as Record<string, unknown>)[p];
       else { sub = undefined; break; }
     }
-    if (sub === undefined) return; // optional sub-field
+    if (sub === undefined) return softSkip('blocked', 'precondition not met — `sub === undefined` returned early (optional sub-field) (seam, prior step, or fixture unavailable)'); // optional sub-field
     expect(
       typeof sub,
-      driver.describe(
+      req('openwop.it.sql-transaction-atomicity.transactions-is-a-boolean-when-set', 
         'RFC 0018 §A',
         'sql.transactions MUST be boolean when present',
       ),
@@ -69,7 +71,7 @@ async function call(op: string, args: Record<string, unknown>) {
 describe('sql-transaction-atomicity: behavioral (RFC 0018 §B.sql — transaction atomicity)', () => {
   it('transaction with N statements where N-th fails → earlier writes MUST roll back', async () => {
     const probe = await call('execute', { sql: 'CREATE TABLE IF NOT EXISTS atomicity_probe (id TEXT PRIMARY KEY)', params: [] });
-    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 table = `t_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
     await call('execute', { sql: `CREATE TABLE ${table} (id INTEGER PRIMARY KEY, val TEXT)`, params: [] });
 
@@ -82,7 +84,7 @@ describe('sql-transaction-atomicity: behavioral (RFC 0018 §B.sql — transactio
     });
     expect(
       txnRes.status >= 400 && txnRes.status < 500,
-      driver.describe('RFC 0018 §B.sql', 'transaction with failing statement MUST surface as 4xx'),
+      req('openwop.it.sql-transaction-atomicity.transaction-with-n-statements-where-n-th-fails-earlier-writes-must-roll-back', 'RFC 0018 §B.sql', 'transaction with failing statement MUST surface as 4xx'),
     ).toBe(true);
 
     const queryRes = await call('query', { sql: `SELECT id, val FROM ${table}`, params: [] });
@@ -90,7 +92,7 @@ describe('sql-transaction-atomicity: behavioral (RFC 0018 §B.sql — transactio
     const body = queryRes.json as { rows?: unknown[] };
     expect(
       Array.isArray(body.rows) && body.rows.length === 0,
-      driver.describe('RFC 0018 §B.sql', 'rows from earlier statements in a failed transaction MUST NOT be visible'),
+      req('openwop.it.sql-transaction-atomicity.transaction-with-n-statements-where-n-th-fails-earlier-writes-must-roll-back', 'RFC 0018 §B.sql', 'rows from earlier statements in a failed transaction MUST NOT be visible'),
     ).toBe(true);
   });
 });