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

package/src/scenarios/mcp-toolcall-redaction.test.ts

@@ -23,6 +23,7 @@ import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { capabilityFamily, discoveryFamilies } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 async function isMcpClientSupported(): Promise<boolean> {
   const disco = await driver.get('/.well-known/openwop');
@@ -44,12 +45,12 @@ describe('mcp-toolcall-redaction: capability advertisement contract', () => {
       };
     }), 'mcpClient');
 
-    expect(cap?.supported, driver.describe(
+    expect(cap?.supported, req('openwop.it.mcp-toolcall-redaction.host-advertising-mcpclient-must-declare-trustboundary-untrusted', 
       'host-capabilities.md §host.mcp',
       'mcpClient.supported MUST be a boolean',
     )).toBe(true);
 
-    expect(Array.isArray(cap?.transports), driver.describe(
+    expect(Array.isArray(cap?.transports), req('openwop.it.mcp-toolcall-redaction.host-advertising-mcpclient-must-declare-trustboundary-untrusted', 
       'host-capabilities.md §host.mcp',
       'mcpClient.transports MUST be an array of transport identifiers',
     )).toBe(true);
@@ -59,7 +60,7 @@ describe('mcp-toolcall-redaction: capability advertisement contract', () => {
     // Hosts advertising mcpClient MUST encode the boundary in the
     // capability so downstream consumers (LLM nodes) treat the
     // content accordingly.
-    expect(cap?.trustBoundary, driver.describe(
+    expect(cap?.trustBoundary, req('openwop.it.mcp-toolcall-redaction.host-advertising-mcpclient-must-declare-trustboundary-untrusted', 
       'SECURITY/threat-model-prompt-injection.md §"UNTRUSTED marker"',
       'mcpClient.trustBoundary MUST be "untrusted" — downstream LLM nodes treat tool content as user data',
     )).toBe('untrusted');

package/src/scenarios/mcp-version-negotiation.test.ts

@@ -27,10 +27,11 @@
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { readErrorCode } from '../lib/error-envelope.js';
-import { seamAbsent } from '../lib/soft-skip.js';
+import { seamAbsent, softSkip } from '../lib/soft-skip.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 import { getMcpFakeServer } from '../lib/mcp-fake-server.js';
+import { req } from '../lib/requirement-ids.js';
 
 /**
  * Callback-shaped: the host issues MCP calls to the suite's fake server, which records the revision header.
@@ -67,7 +68,7 @@ describe('RFC 0153 §A/§B — MCP revision negotiation', () => {
     for (const v of caps?.protocolVersions ?? []) {
       expect(
         DATE_FORM.test(v),
-        driver.describe(
+        req('openwop.it.mcp-version-negotiation.advertised-revisions-use-mcp-date-form-and-include-the-preferred-one', 
           'RFCS/0153-mcp-2026-07-28-versioned-composition.md §A',
           `'${v}' is not MCP's date form. MCP revisions ARE dates, and 'latest' or an unpadded ` +
             'month lets two hosts disagree about which revision they share while both look valid.',
@@ -76,39 +77,39 @@ describe('RFC 0153 §A/§B — MCP revision negotiation', () => {
     }
     expect(
       caps?.protocolVersions ?? [],
-      driver.describe('RFCS/0153 §A', '`preferredVersion` MUST be one the host actually lists'),
+      req('openwop.it.mcp-version-negotiation.advertised-revisions-use-mcp-date-form-and-include-the-preferred-one', 'RFCS/0153 §A', '`preferredVersion` MUST be one the host actually lists'),
     ).toContain(caps?.preferredVersion);
   });
 
   it('outbound calls carry MCP-Protocol-Version in date form', async () => {
     if (!behaviorGate(PROFILE, await negotiationAdvertised())) return;
     const server = getMcpFakeServer();
-    if (server === null) return;
+    if (server === null) return softSkip('blocked', 'precondition not met — `server === null` returned early (seam, prior step, or fixture unavailable)');
     server.reset();
     const drive = await driver.post('/v1/host/sample/mcp/invoke', { serverUrl: server.endpoint() });
     if (drive.status === 404 || drive.status === 403) {
       expect(
         drive.status,
-        driver.describe(
+        req('openwop.it.mcp-version-negotiation.outbound-calls-carry-mcp-protocol-version-in-date-form', 
           'RFCS/0153 §B',
           'a host advertising MCP revisions MUST expose an invoke seam so the negotiated revision ' +
             'is observable. Without it the requirement resolves to `blocked` per RFC 0148 §A — not ' +
             'to a pass.',
         ),
       ).not.toBe(404);
-      return;
+      return softSkip('blocked', 'precondition not met — `drive.status === 404 || drive.status === 403` returned early (seam, prior step, or fixture unavailable)');
     }
     const calls = server.invocations();
-    expect(calls.length, 'the host MUST have called the server').toBeGreaterThan(0);
+    expect(calls.length, req('openwop.it.mcp-version-negotiation.outbound-calls-carry-mcp-protocol-version-in-date-form', 'RFCS/0153 §B', 'the host MUST have called the server')).toBeGreaterThan(0);
     for (const c of calls) {
       const v = c.headers['mcp-protocol-version'];
       expect(
         v,
-        driver.describe('RFCS/0153 §A', 'every MCP call MUST declare its revision'),
+        req('openwop.it.mcp-version-negotiation.outbound-calls-carry-mcp-protocol-version-in-date-form', 'RFCS/0153 §A', 'every MCP call MUST declare its revision'),
       ).toBeTruthy();
       expect(
         DATE_FORM.test(v ?? ''),
-        driver.describe(
+        req('openwop.it.mcp-version-negotiation.outbound-calls-carry-mcp-protocol-version-in-date-form', 
           'RFCS/0153 §A',
           `the revision on the wire MUST be MCP's date form; got '${v}'. A malformed revision is ` +
             'unmatchable against a pinned peer, and the failure then surfaces at the peer rather ' +
@@ -121,7 +122,7 @@ describe('RFC 0153 §A/§B — MCP revision negotiation', () => {
   it('the negotiated revision is one the host advertises', async () => {
     if (!behaviorGate(PROFILE, await negotiationAdvertised())) return;
     const server = getMcpFakeServer();
-    if (server === null) return;
+    if (server === null) return softSkip('blocked', 'precondition not met — `server === null` returned early (seam, prior step, or fixture unavailable)');
     const caps = await mcp();
     server.reset();
     const drive = await driver.post('/v1/host/sample/mcp/invoke', { serverUrl: server.endpoint() });
@@ -132,7 +133,7 @@ describe('RFC 0153 §A/§B — MCP revision negotiation', () => {
     for (const c of server.invocations()) {
       expect(
         caps?.protocolVersions ?? [],
-        driver.describe(
+        req('openwop.it.mcp-version-negotiation.the-negotiated-revision-is-one-the-host-advertises', 
           'RFCS/0153 §A/§B',
           'the revision sent on the wire MUST appear in `protocolVersions`. Negotiating an ' +
             'unadvertised revision makes the discovery document unreliable for every consumer ' +
@@ -145,7 +146,7 @@ describe('RFC 0153 §A/§B — MCP revision negotiation', () => {
   it('an unsupported revision fails through the canonical interop envelope', async () => {
     if (!behaviorGate(PROFILE, await negotiationAdvertised())) return;
     const server = getMcpFakeServer();
-    if (server === null) return;
+    if (server === null) return softSkip('blocked', 'precondition not met — `server === null` returned early (seam, prior step, or fixture unavailable)');
     const drive = await driver.post('/v1/host/sample/mcp/invoke', {
       serverUrl: server.endpoint(),
       requestVersion: '1999-01-01',
@@ -153,13 +154,13 @@ describe('RFC 0153 §A/§B — MCP revision negotiation', () => {
     if (drive.status === 404 || drive.status === 403) return seamAbsent(`host advertises mcp version negotiation but the invoke seam /v1/host/sample/mcp/invoke answered ${drive.status} — the host-as-client legs are unobservable (host-sample-test-seams.md)`);
     expect(
       drive.status >= 400,
-      driver.describe('RFCS/0153 §B', 'an unsupported revision MUST fail rather than silently proceed'),
+      req('openwop.it.mcp-version-negotiation.an-unsupported-revision-fails-through-the-canonical-interop-envelope', 'RFCS/0153 §B', 'an unsupported revision MUST fail rather than silently proceed'),
     ).toBe(true);
     // S28: canonical envelope is FLAT (`error: "<code>"`, error-envelope.schema.json);
     // the nested `error.code` is tolerated by the lib only through the deprecation window.
     expect(
       readErrorCode(drive.json),
-      driver.describe(
+      req('openwop.it.mcp-version-negotiation.an-unsupported-revision-fails-through-the-canonical-interop-envelope', 
         'RFCS/0153 §B',
         'the upstream error MUST be projected through the canonical OpenWOP interop envelope — a ' +
           'raw JSON-RPC error body leaves the caller parsing a foreign protocol to learn its own ' +

package/src/scenarios/media-url-inline-cap.test.ts

@@ -33,6 +33,8 @@ import { join } from 'node:path';
 import { driver } from '../lib/driver.js';
 import { SCHEMAS_DIR } from '../lib/paths.js';
 import { capabilityFamily, discoveryFamilies } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const MEDIA_KINDS = ['media.image', 'media.audio', 'media.file'] as const;
 const HTTP_SKIP = !process.env.OPENWOP_BASE_URL;
@@ -51,7 +53,7 @@ describe('media-url-inline-cap: media payload schemas compile + round-trip (RFC
     it(`envelopes/${kind}.schema.json compiles under Ajv2020`, () => {
       expect(
         compile(kind),
-        `ai-envelope.md §"Media reference payloads": ${kind} payload schema MUST compile`,
+        req('openwop.it.media-url-inline-cap.envelopes-schema-json-compiles-under-ajv2020', 'RFC 0055 §C', `ai-envelope.md §"Media reference payloads": ${kind} payload schema MUST compile`),
       ).toBeTypeOf('function');
     });
   }
@@ -62,22 +64,22 @@ describe('media-url-inline-cap: media payload schemas compile + round-trip (RFC
       bytes: 184320,
       mimeType: 'image/png',
     });
-    expect(ok, 'URL-reference media payload MUST validate').toBe(true);
+    expect(ok, req('openwop.it.media-url-inline-cap.accepts-a-url-reference-image-payload', 'RFC 0055 §C', 'URL-reference media payload MUST validate')).toBe(true);
   });
 
   it('accepts an inline-base64 audio payload', () => {
     const ok = compile('media.audio')({ base64: 'AAAA', bytes: 3, mimeType: 'audio/ogg', durationSeconds: 1.2 });
-    expect(ok, 'inline-base64 media payload MUST validate').toBe(true);
+    expect(ok, req('openwop.it.media-url-inline-cap.accepts-an-inline-base64-audio-payload', 'RFC 0055 §C', 'inline-base64 media payload MUST validate')).toBe(true);
   });
 
   it('rejects a payload missing required bytes', () => {
     const ok = compile('media.file')({ url: 'https://host.example/v1/runs/run_1/assets/report.pdf' });
-    expect(ok, 'ai-envelope.md §"Media reference payloads": `bytes` is required').toBe(false);
+    expect(ok, req('openwop.it.media-url-inline-cap.rejects-a-payload-missing-required-bytes', 'RFC 0055 §C', 'ai-envelope.md §"Media reference payloads": `bytes` is required')).toBe(false);
   });
 
   it('rejects an unknown property (additionalProperties:false)', () => {
     const ok = compile('media.image')({ bytes: 1, wat: true });
-    expect(ok, 'media payload is additionalProperties:false').toBe(false);
+    expect(ok, req('openwop.it.media-url-inline-cap.rejects-an-unknown-property-additionalproperties-false', 'RFC 0055 §C', 'media payload is additionalProperties:false')).toBe(false);
   });
 });
 
@@ -88,12 +90,12 @@ interface DiscoveryDoc {
 describe.skipIf(HTTP_SKIP)('media-url-inline-cap: advertisement shape (RFC 0055 §C rule 2)', () => {
   it('aiProviders.maxInlineMediaBytes is a non-negative integer when advertised', async () => {
     const res = await driver.get('/.well-known/openwop');
-    if (res.status !== 200) return;
+    if (res.status !== 200) return softSkip('blocked', 'precondition not met — `res.status !== 200` returned early (seam, prior step, or fixture unavailable)');
     const cap = capabilityFamily((res.json as DiscoveryDoc), 'aiProviders')?.maxInlineMediaBytes;
-    if (cap === undefined) return; // optional — soft-skip when absent
+    if (cap === undefined) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `cap === undefined` returned early (optional — soft-skip when absent)'); // optional — soft-skip when absent
     expect(
       Number.isInteger(cap) && (cap as number) >= 0,
-      driver.describe('capabilities.md §aiProviders.maxInlineMediaBytes', 'cap MUST be a non-negative integer'),
+      req('openwop.it.media-url-inline-cap.aiproviders-maxinlinemediabytes-is-a-non-negative-integer-when-advertised', 'capabilities.md §aiProviders.maxInlineMediaBytes', 'cap MUST be a non-negative integer'),
     ).toBe(true);
   });
 
@@ -106,24 +108,24 @@ describe.skipIf(HTTP_SKIP)('media-url-inline-cap: advertisement shape (RFC 0055
 
   it('a stored media asset is served by a tenant-scoped URL, not inlined', async () => {
     const stored = await driver.post('/v1/host/sample/media/put', { contentBase64: PNG_1x1, contentType: 'image/png' });
-    if (stored.status === 404) return; // store seam disabled — soft-skip
-    expect(stored.status, 'media store MUST return 201').toBe(201);
+    if (stored.status === 404) return softSkip('blocked', 'precondition not met — `stored.status === 404` returned early (store seam disabled — soft-skip) (seam, prior step, or fixture unavailable)'); // store seam disabled — soft-skip
+    expect(stored.status, req('openwop.it.media-url-inline-cap.a-stored-media-asset-is-served-by-a-tenant-scoped-url-not-inlined', 'ai-envelope.md §"Media reference payloads"', 'media store MUST return 201')).toBe(201);
     const body = stored.json as { url?: string; bytes?: number };
     expect(
       typeof body.url === 'string' && /\/v1\/host\/sample\/assets\//.test(body.url!),
-      driver.describe('ai-envelope.md §"Media reference payloads"', 'asset MUST be served by a URL reference, not inlined'),
+      req('openwop.it.media-url-inline-cap.a-stored-media-asset-is-served-by-a-tenant-scoped-url-not-inlined', 'ai-envelope.md §"Media reference payloads"', 'asset MUST be served by a URL reference, not inlined'),
     ).toBe(true);
     const served = await driver.get(body.url!);
-    expect(served.status, 'the asset URL MUST resolve').toBe(200);
+    expect(served.status, req('openwop.it.media-url-inline-cap.a-stored-media-asset-is-served-by-a-tenant-scoped-url-not-inlined', 'ai-envelope.md §"Media reference payloads"', 'the asset URL MUST resolve')).toBe(200);
   });
 
   it('an unminted/guessed asset token does not resolve (media-asset-url-tenant-scoped)', async () => {
     // Probe whether the serve route exists at all; soft-skip if not.
     const probe = await driver.get('/v1/host/sample/assets/probe-never-minted-token');
-    if (probe.status === 404 && !process.env.OPENWOP_BASE_URL) return;
+    if (probe.status === 404 && !process.env.OPENWOP_BASE_URL) return softSkip('blocked', 'precondition not met — `probe.status === 404 && !process.env.OPENWOP_BASE_URL` returned early (seam, prior step, or fixture unavailable)');
     expect(
       probe.status,
-      driver.describe('SECURITY/invariants.yaml#media-asset-url-tenant-scoped', 'a token not held by the caller (unguessable 256-bit) MUST NOT resolve'),
+      req('openwop.it.media-url-inline-cap.an-unminted-guessed-asset-token-does-not-resolve-media-asset-url-tenant-scoped', 'SECURITY/invariants.yaml#media-asset-url-tenant-scoped', 'a token not held by the caller (unguessable 256-bit) MUST NOT resolve'),
     ).toBe(404);
   });
 
@@ -135,14 +137,14 @@ describe.skipIf(HTTP_SKIP)('media-url-inline-cap: advertisement shape (RFC 0055
     // — and on the reference host, which exports debug bundles but has no node
     // that emits a media.* envelope into a run (so no media payload appears).
     const disc = await driver.get('/.well-known/openwop');
-    if (disc.status !== 200) return;
+    if (disc.status !== 200) return softSkip('blocked', 'precondition not met — `disc.status !== 200` returned early (seam, prior step, or fixture unavailable)');
     const caps = discoveryFamilies(disc.json) as { aiProviders?: { maxInlineMediaBytes?: unknown }; debugBundle?: { supported?: unknown } };
     if (caps.aiProviders?.maxInlineMediaBytes === undefined || caps.debugBundle?.supported !== true) {
-      return; // host doesn't serve media + export debug bundles — contract not exercisable
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `caps.aiProviders?.maxInlineMediaBytes === undefined || caps.debugBundle?.supported !== true` returned early (host doesn\'t serve media + export debug bundles — …'); // host doesn't serve media + export debug bundles — contract not exercisable
     }
     // Find a recent run and inspect its debug bundle for any media.* event.
     const runs = await driver.get('/v1/runs?limit=20');
-    if (runs.status !== 200) return;
+    if (runs.status !== 200) return softSkip('blocked', 'precondition not met — `runs.status !== 200` returned early (seam, prior step, or fixture unavailable)');
     const runIds = ((runs.json as { runs?: { runId?: string }[] }).runs ?? [])
       .map((r) => r.runId)
       .filter((id): id is string => typeof id === 'string');
@@ -155,9 +157,9 @@ describe.skipIf(HTTP_SKIP)('media-url-inline-cap: advertisement shape (RFC 0055
           // The §C rule-3 contract: served by URL, not inlined binary.
           expect(
             typeof ev.payload?.url === 'string' && ev.payload?.base64 === undefined,
-            driver.describe('ai-envelope.md §"Media reference payloads"', 'a media.* payload in a debug bundle MUST be a URL reference, never inlined binary'),
+            req('openwop.it.media-url-inline-cap.a-media-payload-in-a-run-debug-bundle-is-referenced-by-url-not-inlined-rfc-0055', 'ai-envelope.md §"Media reference payloads"', 'a media.* payload in a debug bundle MUST be a URL reference, never inlined binary'),
           ).toBe(true);
-          return; // asserted one — contract proven
+          return softSkip('blocked', 'precondition not met — `typeof ev.type === \'string\' && ev.type.startsWith(\'media.\')` returned early (asserted one — contract proven) (seam, prior step, or fixture unavailable)'); // asserted one — contract proven
         }
       }
     }

package/src/scenarios/memory-attribution-emits-on-write.test.ts

@@ -10,9 +10,9 @@
 
 import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
-import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { readMemoryAttributionCap, emitsWriteEvents, seedRun, memoryWrittenEvents } from '../lib/memoryAttribution.js';
+import { req } from '../lib/requirement-ids.js';
 
 describe('memory-attribution-emits-on-write (RFC 0057 §A/§B)', () => {
   it('an advertised host emits memory.written carrying a stable memoryId', async () => {
@@ -23,7 +23,7 @@ describe('memory-attribution-emits-on-write (RFC 0057 §A/§B)', () => {
     try {
       await pollUntilTerminal(runId, { timeoutMs: 10_000 });
     } catch {
-      return;
+      return softSkip('blocked', 'precondition not met — an earlier step threw (seam, prior step, or fixture unavailable)');
     }
     const events = await memoryWrittenEvents(runId);
     if (events.length === 0) return softSkip('blocked', 'run wrote no memory — soft-skip (events.length === 0)');
@@ -31,7 +31,7 @@ describe('memory-attribution-emits-on-write (RFC 0057 §A/§B)', () => {
       const memoryId = (e.payload as { memoryId?: unknown } | undefined)?.memoryId;
       expect(
         typeof memoryId === 'string' && memoryId.length > 0,
-        driver.describe('RFC 0057 §B', 'memory.written.memoryId MUST be a stable, non-empty identifier'),
+        req('openwop.it.memory-attribution-emits-on-write.an-advertised-host-emits-memory-written-carrying-a-stable-memoryid', 'RFC 0057 §B', 'memory.written.memoryId MUST be a stable, non-empty identifier'),
       ).toBe(true);
     }
   });
@@ -44,12 +44,12 @@ describe('memory-attribution-emits-on-write (RFC 0057 §A/§B)', () => {
     try {
       await pollUntilTerminal(runId, { timeoutMs: 10_000 });
     } catch {
-      return;
+      return softSkip('blocked', 'precondition not met — an earlier step threw (seam, prior step, or fixture unavailable)');
     }
     const events = await memoryWrittenEvents(runId);
     expect(
       events.length,
-      driver.describe('RFC 0057 §A', 'a host not advertising memory.attribution MUST NOT emit memory.written'),
+      req('openwop.it.memory-attribution-emits-on-write.a-host-without-the-capability-emits-no-memory-written', 'RFC 0057 §A', 'a host not advertising memory.attribution MUST NOT emit memory.written'),
     ).toBe(0);
   });
 });

package/src/scenarios/memory-attribution-no-content.test.ts

@@ -13,9 +13,9 @@
 
 import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
-import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { readMemoryAttributionCap, emitsWriteEvents, seedRun, memoryWrittenEvents } from '../lib/memoryAttribution.js';
+import { req } from '../lib/requirement-ids.js';
 
 describe('memory-attribution-no-content (RFC 0057 §C)', () => {
   it('memory.written payloads carry no entry content', async () => {
@@ -26,7 +26,7 @@ describe('memory-attribution-no-content (RFC 0057 §C)', () => {
     try {
       await pollUntilTerminal(runId, { timeoutMs: 10_000 });
     } catch {
-      return;
+      return softSkip('blocked', 'precondition not met — an earlier step threw (seam, prior step, or fixture unavailable)');
     }
     const events = await memoryWrittenEvents(runId);
     if (events.length === 0) return softSkip('blocked', 'run wrote no memory — soft-skip (events.length === 0)');
@@ -34,12 +34,12 @@ describe('memory-attribution-no-content (RFC 0057 §C)', () => {
       const payload = e.payload ?? {};
       expect(
         'content' in payload,
-        driver.describe('RFC 0057 §C', 'memory.written MUST NOT carry the entry content field'),
+        req('openwop.it.memory-attribution-no-content.memory-written-payloads-carry-no-entry-content', 'RFC 0057 §C', 'memory.written MUST NOT carry the entry content field'),
       ).toBe(false);
       expect(
         typeof (payload as { memoryRef?: unknown }).memoryRef === 'string' &&
           typeof (payload as { memoryId?: unknown }).memoryId === 'string',
-        driver.describe('RFC 0057 §B', 'memory.written MUST carry memoryRef + memoryId identifiers'),
+        req('openwop.it.memory-attribution-no-content.memory-written-payloads-carry-no-entry-content', 'RFC 0057 §B', 'memory.written MUST carry memoryRef + memoryId identifiers'),
       ).toBe(true);
     }
   });

package/src/scenarios/memory-attribution-replay-stable.test.ts

@@ -41,6 +41,7 @@ import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { readMemoryAttributionCap, emitsWriteEvents, seedRun, memoryWrittenEvents } from '../lib/memoryAttribution.js';
+import { req } from '../lib/requirement-ids.js';
 
 function memoryIdOf(payload: Record<string, unknown> | undefined): string | null {
   const id = (payload ?? {})['memoryId'];
@@ -56,7 +57,7 @@ describe('memory-attribution-replay-stable (RFC 0057 §D)', () => {
     try {
       await pollUntilTerminal(runId, { timeoutMs: 10_000 });
     } catch {
-      return;
+      return softSkip('blocked', 'precondition not met — an earlier step threw (seam, prior step, or fixture unavailable)');
     }
     const original = await memoryWrittenEvents(runId);
     if (original.length === 0) return softSkip('blocked', 'run wrote no memory — nothing to test');
@@ -83,7 +84,7 @@ describe('memory-attribution-replay-stable (RFC 0057 §D)', () => {
     const missing = [...recordedIds].filter((id) => !replayedIds.has(id));
     expect(
       missing,
-      driver.describe(
+      req('openwop.it.memory-attribution-replay-stable.a-replay-mode-fork-introduces-no-memory-written-with-a-new-memoryid', 
         'replay.md §"Determinism guarantees" caveat 5',
         'recorded-fact events are fixed history: a replay MUST re-emit the source run\'s ' +
           '`memory.written` events from the log. A replay whose log is SHORT of the source\'s is not ' +
@@ -97,7 +98,7 @@ describe('memory-attribution-replay-stable (RFC 0057 §D)', () => {
       const id = memoryIdOf(e.payload);
       expect(
         id !== null && recordedIds.has(id),
-        driver.describe('RFC 0057 §D', 'a replay MUST NOT regenerate memoryId — every replayed memory.written reuses a recorded id'),
+        req('openwop.it.memory-attribution-replay-stable.a-replay-mode-fork-introduces-no-memory-written-with-a-new-memoryid', 'RFC 0057 §D', 'a replay MUST NOT regenerate memoryId — every replayed memory.written reuses a recorded id'),
       ).toBe(true);
     }
   });

package/src/scenarios/memory-attribution-shape.test.ts

@@ -10,16 +10,17 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { driver } from '../lib/driver.js';
 import { readMemoryAttributionCap } from '../lib/memoryAttribution.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 describe('memory-attribution-shape: advertisement (RFC 0057 §A)', () => {
   it('capabilities.memory.attribution is absent or a well-formed object', async () => {
     const cap = await readMemoryAttributionCap();
-    if (cap === null) return; // not advertised — valid
+    if (cap === null) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `cap === null` returned early (not advertised — valid)'); // not advertised — valid
     expect(
       cap.supported,
-      driver.describe('capabilities.schema.json §memory.attribution', 'memory.attribution.supported MUST be the literal true when the block is present'),
+      req('openwop.it.memory-attribution-shape.capabilities-memory-attribution-is-absent-or-a-well-formed-object', 'capabilities.schema.json §memory.attribution', 'memory.attribution.supported MUST be the literal true when the block is present'),
     ).toBe(true);
     if (cap.emitsWriteEvents !== undefined) {
       expect(typeof cap.emitsWriteEvents).toBe('boolean');

package/src/scenarios/memory-attribution-tenant-scoped.test.ts

@@ -14,9 +14,9 @@
 
 import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
-import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { readMemoryAttributionCap, emitsWriteEvents, seedRun, memoryWrittenEvents } from '../lib/memoryAttribution.js';
+import { req } from '../lib/requirement-ids.js';
 
 describe('memory-attribution-tenant-scoped (RFC 0057 §C)', () => {
   it("a run's memory.written events appear only on that run's stream", async () => {
@@ -27,7 +27,7 @@ describe('memory-attribution-tenant-scoped (RFC 0057 §C)', () => {
     try {
       await pollUntilTerminal(runId, { timeoutMs: 10_000 });
     } catch {
-      return;
+      return softSkip('blocked', 'precondition not met — an earlier step threw (seam, prior step, or fixture unavailable)');
     }
     const events = await memoryWrittenEvents(runId);
     if (events.length === 0) return softSkip('blocked', 'precondition not met — `events.length === 0` returned early (seam, prior step, or fixture unavailable)');
@@ -37,7 +37,7 @@ describe('memory-attribution-tenant-scoped (RFC 0057 §C)', () => {
       if (typeof e.runId === 'string') {
         expect(
           e.runId,
-          driver.describe('RFC 0057 §C', "a memory.written event MUST belong to its own run's stream (CTI-1)"),
+          req('openwop.it.memory-attribution-tenant-scoped.a-run-s-memory-written-events-appear-only-on-that-run-s-stream', 'RFC 0057 §C', "a memory.written event MUST belong to its own run's stream (CTI-1)"),
         ).toBe(runId);
       }
     }

package/src/scenarios/memory-capability-model-shape.test.ts

@@ -36,8 +36,7 @@ import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
 import { SCHEMAS_DIR } from '../lib/paths.js';
 import { deriveProfiles } from '../lib/profiles.js';
-
-const why = (specRef: string, requirement: string): string => `${specRef} — ${requirement}`;
+import { req } from '../lib/requirement-ids.js';
 
 function loadSchema(name: string): Record<string, unknown> {
   return JSON.parse(readFileSync(join(SCHEMAS_DIR, name), 'utf8')) as Record<string, unknown>;
@@ -63,7 +62,7 @@ describe('memory-capability-model-shape: reconciled dimensions (RFC 0080 §A, se
     for (const dim of ['writable', 'search', 'retention']) {
       expect(
         memory?.properties?.[dim],
-        why('agent-memory.md §"Memory capability model"', `capabilities.memory.${dim} MUST be declared (RFC 0080 §A)`),
+        req('openwop.it.memory-capability-model-shape.capabilities-memory-declares-the-additive-writable-search-retention-dimensions', 'agent-memory.md §"Memory capability model"', `capabilities.memory.${dim} MUST be declared (RFC 0080 §A)`),
       ).toBeDefined();
     }
   });
@@ -72,7 +71,7 @@ describe('memory-capability-model-shape: reconciled dimensions (RFC 0080 §A, se
     for (const dim of ['supported', 'compaction', 'distillation', 'attribution']) {
       expect(
         memory?.properties?.[dim],
-        why('COMPATIBILITY.md §2.1', `capabilities.memory.${dim} MUST remain (RFC 0080 is additive)`),
+        req('openwop.it.memory-capability-model-shape.the-pre-existing-memory-fields-are-untouched-additive-no-relocation', 'COMPATIBILITY.md §2.1', `capabilities.memory.${dim} MUST remain (RFC 0080 is additive)`),
       ).toBeDefined();
     }
   });
@@ -89,22 +88,22 @@ describe('memory-capability-model-shape: reconciled dimensions (RFC 0080 §A, se
 
     expect(
       validate({ memory: { supported: true, writable: false, search: { supported: true, modes: ['semantic', 'filter'] }, retention: { ttl: true, forget: true } } }),
-      why('capabilities.md §memory', 'a full reconciled-memory advertisement MUST validate'),
+      req('openwop.it.memory-capability-model-shape.memory-search-memory-retention-validate-conforming-instances-and-reject-malforme', 'capabilities.md §memory', 'a full reconciled-memory advertisement MUST validate'),
     ).toBe(true);
 
     expect(
       validate({ memory: { retention: { ttl: 'yes' } } }),
-      why('RFC 0080 §A', 'retention.ttl MUST be boolean'),
+      req('openwop.it.memory-capability-model-shape.memory-search-memory-retention-validate-conforming-instances-and-reject-malforme', 'RFC 0080 §A', 'retention.ttl MUST be boolean'),
     ).toBe(false);
 
     expect(
       validate({ memory: { search: { supported: true, modes: ['fuzzy'] } } }),
-      why('RFC 0080 §A', 'search.modes MUST be the closed enum [semantic, filter]'),
+      req('openwop.it.memory-capability-model-shape.memory-search-memory-retention-validate-conforming-instances-and-reject-malforme', 'RFC 0080 §A', 'search.modes MUST be the closed enum [semantic, filter]'),
     ).toBe(false);
 
     expect(
       validate({ memory: { search: { supported: true, unknownField: 1 } } }),
-      why('RFC 0080 §A', 'memory.search MUST be additionalProperties:false'),
+      req('openwop.it.memory-capability-model-shape.memory-search-memory-retention-validate-conforming-instances-and-reject-malforme', 'RFC 0080 §A', 'memory.search MUST be additionalProperties:false'),
     ).toBe(false);
   });
 });
@@ -117,11 +116,11 @@ describe('memory-capability-model-shape: degraded projection (RFC 0080 §C, serv
       .AgentInventoryEntry).properties;
     expect(
       entry?.memoryDegraded,
-      why('agent-memory.md §C-1', 'memoryDegraded MUST be declared on the inventory entry'),
+      req('openwop.it.memory-capability-model-shape.agent-inventory-response-declares-memorydegraded-degradedmemorydimensions', 'agent-memory.md §C-1', 'memoryDegraded MUST be declared on the inventory entry'),
     ).toBeDefined();
     expect(
       entry?.degradedMemoryDimensions,
-      why('agent-memory.md §C-1', 'degradedMemoryDimensions MUST be declared on the inventory entry'),
+      req('openwop.it.memory-capability-model-shape.agent-inventory-response-declares-memorydegraded-degradedmemorydimensions', 'agent-memory.md §C-1', 'degradedMemoryDimensions MUST be declared on the inventory entry'),
     ).toBeDefined();
   });
 
@@ -131,7 +130,7 @@ describe('memory-capability-model-shape: degraded projection (RFC 0080 §C, serv
     const enumVals = entry?.degradedMemoryDimensions?.items?.enum ?? [];
     expect(
       [...enumVals].sort(),
-      why('agent-memory.md §A', 'the degraded-dimension enum MUST be the eight reconciled dimensions'),
+      req('openwop.it.memory-capability-model-shape.degradedmemorydimensions-enumerates-exactly-the-eight-a-dimension-names', 'agent-memory.md §A', 'the degraded-dimension enum MUST be the eight reconciled dimensions'),
     ).toEqual([...DIMENSIONS].sort());
   });
 
@@ -144,11 +143,11 @@ describe('memory-capability-model-shape: degraded projection (RFC 0080 §C, serv
     };
     expect(
       validate({ total: 1, agents: [{ ...base, memoryDegraded: true, degradedMemoryDimensions: ['write', 'long-term-durability'] }] }),
-      why('agent-memory.md §C-1', 'a degraded inventory entry MUST validate'),
+      req('openwop.it.memory-capability-model-shape.the-inventory-schema-round-trips-a-degraded-entry-and-rejects-an-out-of-enum-dim', 'agent-memory.md §C-1', 'a degraded inventory entry MUST validate'),
     ).toBe(true);
     expect(
       validate({ total: 1, agents: [{ ...base, memoryDegraded: true, degradedMemoryDimensions: ['telepathy'] }] }),
-      why('agent-memory.md §C-1', 'an out-of-enum degraded dimension MUST be rejected'),
+      req('openwop.it.memory-capability-model-shape.the-inventory-schema-round-trips-a-degraded-entry-and-rejects-an-out-of-enum-dim', 'agent-memory.md §C-1', 'an out-of-enum degraded dimension MUST be rejected'),
     ).toBe(false);
   });
 });
@@ -165,7 +164,7 @@ describe('memory-capability-model-shape: openwop-memory derivation (RFC 0080 §D
     } as Record<string, unknown>;
     expect(
       deriveProfiles(c).includes('openwop-memory'),
-      why('profiles.md §openwop-memory', 'a read/write + long-term host MUST derive openwop-memory'),
+      req('openwop.it.memory-capability-model-shape.deriveprofiles-surfaces-openwop-memory-for-a-read-write-long-term-host', 'profiles.md §openwop-memory', 'a read/write + long-term host MUST derive openwop-memory'),
     ).toBe(true);
   });
 
@@ -180,7 +179,7 @@ describe('memory-capability-model-shape: openwop-memory derivation (RFC 0080 §D
     } as Record<string, unknown>;
     expect(
       deriveProfiles(c).includes('openwop-memory'),
-      why('profiles.md §openwop-memory', 'a read-only host MUST NOT derive openwop-memory'),
+      req('openwop.it.memory-capability-model-shape.deriveprofiles-withholds-openwop-memory-from-a-read-only-writable-false-host', 'profiles.md §openwop-memory', 'a read-only host MUST NOT derive openwop-memory'),
     ).toBe(false);
   });
 });

package/src/scenarios/memory-compaction-event-emitted.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 MEMORY_REF = 'mem_tenant:default_agent:conformance-rfc0012-event_longTerm';
 
@@ -79,26 +80,26 @@ describe('memory-compaction-event-emitted: canonical memory.compacted payload sh
       payload?: Record<string, unknown>;
     };
 
-    expect(event.type, driver.describe(
+    expect(event.type, req('openwop.it.memory-compaction-event-emitted.compaction-run-returns-a-canonical-memorycompacted-payload', 
       'observability.md §"Canonical run lifecycle event names"',
       'event MUST be type=memory.compacted',
     )).toBe('memory.compacted');
 
     const payload = event.payload ?? {};
 
-    expect(typeof payload.memoryRef, driver.describe(
+    expect(typeof payload.memoryRef, req('openwop.it.memory-compaction-event-emitted.compaction-run-returns-a-canonical-memorycompacted-payload', 
       'RFC 0012 §B / run-event-payloads.schema.json §memoryCompacted',
       'memoryRef MUST be a non-empty string',
     )).toBe('string');
     expect((payload.memoryRef as string).length).toBeGreaterThan(0);
 
-    expect(typeof payload.outputId, driver.describe(
+    expect(typeof payload.outputId, req('openwop.it.memory-compaction-event-emitted.compaction-run-returns-a-canonical-memorycompacted-payload', 
       'RFC 0012 §B',
       'outputId MUST be a string identifying the distilled entry',
     )).toBe('string');
     expect((payload.outputId as string).length).toBeGreaterThan(0);
 
-    expect(Number.isInteger(payload.sourceCount), driver.describe(
+    expect(Number.isInteger(payload.sourceCount), req('openwop.it.memory-compaction-event-emitted.compaction-run-returns-a-canonical-memorycompacted-payload', 
       'RFC 0012 §B',
       'sourceCount MUST be an integer',
     )).toBe(true);
@@ -106,7 +107,7 @@ describe('memory-compaction-event-emitted: canonical memory.compacted payload sh
 
     expect(['host-managed', 'client-requested', 'both']).toContain(payload.trigger);
 
-    expect(Number.isInteger(payload.byteSize), driver.describe(
+    expect(Number.isInteger(payload.byteSize), req('openwop.it.memory-compaction-event-emitted.compaction-run-returns-a-canonical-memorycompacted-payload', 
       'RFC 0012 §B',
       'byteSize MUST be an integer',
     )).toBe(true);
@@ -115,7 +116,7 @@ describe('memory-compaction-event-emitted: canonical memory.compacted payload sh
     if (payload.sourceIds !== undefined) {
       expect(Array.isArray(payload.sourceIds)).toBe(true);
       for (const id of payload.sourceIds as unknown[]) {
-        expect(typeof id, 'sourceIds entries MUST be strings').toBe('string');
+        expect(typeof id, req('openwop.it.memory-compaction-event-emitted.compaction-run-returns-a-canonical-memorycompacted-payload', 'RFC 0012 §B', 'sourceIds entries MUST be strings')).toBe('string');
         expect((id as string).length).toBeGreaterThan(0);
       }
     }

package/src/scenarios/memory-compaction-provenance-tag.test.ts

@@ -22,6 +22,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 MEMORY_REF = 'mem_tenant:default_agent:conformance-rfc0012-tag_longTerm';
 const COMPACTED_FROM_RE = /^compacted-from:[^\s:][^\s]*$/;
@@ -91,7 +92,7 @@ describe('memory-compaction-provenance-tag: compacted-from:<id> tag follows §C
       console.warn('[rfc0012-tag] host does not expose memory:list at /v1/memory/{ref}; skipping tag inspection (canonical provenance signal remains the memory.compacted event itself)');
       return softSkip('blocked', '[rfc0012-tag] host does not expose memory:list at /v1/memory/{ref}; skipping tag inspection (canonical provenance signal remains the memory.compacted event itself)');
     }
-    expect(listRes.status, 'memory:list MUST return 200 when reachable').toBe(200);
+    expect(listRes.status, req('openwop.it.memory-compaction-provenance-tag.compacted-entry-carries-a-well-formed-compacted-from-tag-or-omits-it-cleanly-no', 'RFC 0012 §C', 'memory:list MUST return 200 when reachable')).toBe(200);
 
     const body = (listRes.json as MemoryListResponse) ?? {};
     const entries = body.entries ?? [];
@@ -110,7 +111,7 @@ describe('memory-compaction-provenance-tag: compacted-from:<id> tag follows §C
       console.warn('[rfc0012-tag] output entry has no compacted-from:<id> tag — RFC 0012 §C is SHOULD, not MUST; pass with warning');
       return softSkip('inapplicable', '[rfc0012-tag] output entry has no compacted-from:<id> tag — RFC 0012 §C is SHOULD, not MUST; pass with warning');
     }
-    expect(provenance, driver.describe(
+    expect(provenance, req('openwop.it.memory-compaction-provenance-tag.compacted-entry-carries-a-well-formed-compacted-from-tag-or-omits-it-cleanly-no', 
       'RFC 0012 §C',
       'compacted-from tag MUST match `compacted-from:<id>` shape (non-empty id, no whitespace) when present',
     )).toMatch(COMPACTED_FROM_RE);