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

package/src/scenarios/memory-compaction-sr1-carry-forward.test.ts

@@ -30,6 +30,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-sr1_longTerm';
 
@@ -77,13 +78,13 @@ describe('memory-compaction-sr1-carry-forward: derived content passes the BYOK r
         { id: `sr1-src-${Date.now()}-3`, content: 'Customer asked about pricing tiers.' },
       ],
     });
-    expect(seed.status, 'seed endpoint MUST return 201 when reachable').toBe(201);
+    expect(seed.status, req('openwop.it.memory-compaction-sr1-carry-forward.compacted-memoryentry-content-must-not-carry-source-side-form-leak-signatures', 'RFC 0012 §D', 'seed endpoint MUST return 201 when reachable')).toBe(201);
 
     // 2. Drive compaction synchronously.
     const compactRes = await driver.post('/v1/test/memory/compact', {
       memoryRef: MEMORY_REF,
     });
-    expect(compactRes.status, 'compact MUST return 200 with ≥2 source entries').toBe(200);
+    expect(compactRes.status, req('openwop.it.memory-compaction-sr1-carry-forward.compacted-memoryentry-content-must-not-carry-source-side-form-leak-signatures', 'RFC 0012 §D', 'compact MUST return 200 with ≥2 source entries')).toBe(200);
 
     const event = compactRes.json as {
       type?: string;
@@ -95,7 +96,7 @@ describe('memory-compaction-sr1-carry-forward: derived content passes the BYOK r
       // trivially without it.
       outputContent?: string;
     };
-    expect(event.type, 'event payload MUST be type=memory.compacted').toBe('memory.compacted');
+    expect(event.type, req('openwop.it.memory-compaction-sr1-carry-forward.compacted-memoryentry-content-must-not-carry-source-side-form-leak-signatures', 'RFC 0012 §D', 'event payload MUST be type=memory.compacted')).toBe('memory.compacted');
 
     if (typeof event.outputContent !== 'string') {
       // eslint-disable-next-line no-console
@@ -107,11 +108,11 @@ describe('memory-compaction-sr1-carry-forward: derived content passes the BYOK r
     // future MemoryAdapter.get / list consumers would see) MUST NOT
     // carry source-side form-leak signatures. A host that skips its
     // BYOK redaction pass on derived content fails here.
-    expect(event.outputContent.includes('[BYOK:hk_live_canary_42]'), driver.describe(
+    expect(event.outputContent.includes('[BYOK:hk_live_canary_42]'), req('openwop.it.memory-compaction-sr1-carry-forward.compacted-memoryentry-content-must-not-carry-source-side-form-leak-signatures', 
       'RFC 0012 §D',
       'derived MemoryEntry.content MUST NOT carry source-side [BYOK:...] form-leak signatures (SR-1 carry-forward)',
     )).toBe(false);
-    expect(event.outputContent.includes('<REDACTED:db-prod-creds>'), driver.describe(
+    expect(event.outputContent.includes('<REDACTED:db-prod-creds>'), req('openwop.it.memory-compaction-sr1-carry-forward.compacted-memoryentry-content-must-not-carry-source-side-form-leak-signatures', 
       'RFC 0012 §D',
       'derived MemoryEntry.content MUST NOT echo non-canonical <REDACTED:...> markers from sources',
     )).toBe(false);
@@ -121,7 +122,7 @@ describe('memory-compaction-sr1-carry-forward: derived content passes the BYOK r
     // leak. Pinning this prevents a host from "passing" by simply
     // stripping source content rather than redacting it (which would
     // also lose audit signal).
-    expect(event.outputContent, driver.describe(
+    expect(event.outputContent, req('openwop.it.memory-compaction-sr1-carry-forward.compacted-memoryentry-content-must-not-carry-source-side-form-leak-signatures', 
       'RFC 0012 §D',
       'derived MemoryEntry.content MUST carry canonical [REDACTED:...] placeholders where source-side leaks were re-substituted',
     )).toMatch(/\[REDACTED:[^\]]+\]/);

package/src/scenarios/memory-consolidation-idempotent.test.ts

@@ -24,6 +24,7 @@
 import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
+import { req } from '../lib/requirement-ids.js';
 
 interface ConsolidationCaps {
   agents?: { memoryConsolidation?: { supported?: boolean } };
@@ -50,11 +51,11 @@ describe('memory-consolidation-idempotent: pass contract (RFC 0068 §D, capabili
     });
     if (first.status === 404 || first.status === 501) return softSkip('blocked', 'seam not wired — soft-skip');
 
-    expect(first.status, driver.describe('RFC 0068 §D', 'an advertised consolidation seam MUST succeed')).toBe(200);
+    expect(first.status, req('openwop.it.memory-consolidation-idempotent.a-consolidation-pass-reduces-or-holds-entry-count-and-is-idempotent-on-a-stable', 'RFC 0068 §D', 'an advertised consolidation seam MUST succeed')).toBe(200);
     const r1 = first.json as ConsolidateResult;
     const in1 = r1.event?.inputCount ?? 0;
     const out1 = r1.event?.outputCount ?? 0;
-    expect(out1, driver.describe('RFC 0068 §D.1', 'outputCount MUST be <= inputCount for a merge/dedup pass')).toBeLessThanOrEqual(in1);
+    expect(out1, req('openwop.it.memory-consolidation-idempotent.a-consolidation-pass-reduces-or-holds-entry-count-and-is-idempotent-on-a-stable', 'RFC 0068 §D.1', 'outputCount MUST be <= inputCount for a merge/dedup pass')).toBeLessThanOrEqual(in1);
 
     // §D.2 — a second pass over the unchanged corpus is a no-op.
     const second = await driver.post('/v1/host/sample/memory/consolidate', {
@@ -64,14 +65,14 @@ describe('memory-consolidation-idempotent: pass contract (RFC 0068 §D, capabili
     const r2 = second.json as ConsolidateResult;
     expect(
       r2.event?.inputCount,
-      driver.describe('RFC 0068 §D.2', 'a second pass over an unchanged corpus MUST be a no-op (inputCount == outputCount)'),
+      req('openwop.it.memory-consolidation-idempotent.a-consolidation-pass-reduces-or-holds-entry-count-and-is-idempotent-on-a-stable', 'RFC 0068 §D.2', 'a second pass over an unchanged corpus MUST be a no-op (inputCount == outputCount)'),
     ).toBe(r2.event?.outputCount);
 
     // §D.3 — SR-1 carry-forward: a redacted secret stays redacted in the consolidated entry.
     if (typeof r1.secretLeaked === 'boolean') {
       expect(
         r1.secretLeaked,
-        driver.describe('RFC 0068 §D.3 / agent-memory.md §SR-1', 'a redacted secret MUST NOT re-appear in a consolidated entry'),
+        req('openwop.it.memory-consolidation-idempotent.a-consolidation-pass-reduces-or-holds-entry-count-and-is-idempotent-on-a-stable', 'RFC 0068 §D.3 / agent-memory.md §SR-1', 'a redacted secret MUST NOT re-appear in a consolidated entry'),
       ).toBe(false);
     }
   });

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

@@ -26,9 +26,7 @@ import { join } from 'node:path';
 import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
 import { SCHEMAS_DIR } from '../lib/paths.js';
-
-/** Server-free assertion-message helper (mirrors driver.describe's "spec — requirement" shape without requiring OPENWOP_BASE_URL). */
-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>;
@@ -40,11 +38,11 @@ describe('memory-consolidation-shape: capability advertisement (RFC 0068, server
     const agents = (caps.properties as Record<string, { properties?: Record<string, unknown> }>).agents;
     expect(
       agents?.properties?.memoryConsolidation,
-      why('capabilities.md §agents', 'agents.memoryConsolidation MUST be declared'),
+      req('openwop.it.memory-consolidation-shape.the-capabilities-schema-declares-agents-memoryconsolidation-agents-commitments', 'capabilities.md §agents', 'agents.memoryConsolidation MUST be declared'),
     ).toBeDefined();
     expect(
       agents?.properties?.commitments,
-      why('capabilities.md §agents', 'agents.commitments MUST be declared'),
+      req('openwop.it.memory-consolidation-shape.the-capabilities-schema-declares-agents-memoryconsolidation-agents-commitments', 'capabilities.md §agents', 'agents.commitments MUST be declared'),
     ).toBeDefined();
   });
 });
@@ -59,32 +57,32 @@ describe('memory-consolidation-shape: event payloads (RFC 0068, server-free)', (
   const fired = ajv.getSchema('payloads#/$defs/commitmentFired');
 
   it('agent.memory.consolidated validates a content-free pass summary', () => {
-    expect(consolidated, 'the agentMemoryConsolidated $def MUST exist').toBeTruthy();
+    expect(consolidated, req('openwop.it.memory-consolidation-shape.agent-memory-consolidated-validates-a-content-free-pass-summary', 'RFC 0068', 'the agentMemoryConsolidated $def MUST exist')).toBeTruthy();
     expect(
       consolidated!({ memoryRef: 'mem://a/agent-1', inputCount: 240, outputCount: 201, trigger: 'host-managed' }),
-      why('RFC 0068 §B', 'a conforming agent.memory.consolidated payload MUST validate'),
+      req('openwop.it.memory-consolidation-shape.agent-memory-consolidated-validates-a-content-free-pass-summary', 'RFC 0068 §B', 'a conforming agent.memory.consolidated payload MUST validate'),
     ).toBe(true);
     // Negative: outputCount as string fails the integer type.
     expect(consolidated!({ memoryRef: 'mem://a/agent-1', inputCount: 1, outputCount: 'x' })).toBe(false);
   });
 
   it('commitment.fired validates a content-free fire record and requires memoryRef', () => {
-    expect(fired, 'the commitmentFired $def MUST exist').toBeTruthy();
+    expect(fired, req('openwop.it.memory-consolidation-shape.commitment-fired-validates-a-content-free-fire-record-and-requires-memoryref', 'RFC 0068', 'the commitmentFired $def MUST exist')).toBeTruthy();
     expect(
       fired!({ commitmentId: 'cmt-1', memoryRef: 'mem://a/agent-1', condition: 'predicate', enqueuedRunId: 'run-1' }),
-      why('RFC 0068 §C', 'a conforming commitment.fired payload MUST validate'),
+      req('openwop.it.memory-consolidation-shape.commitment-fired-validates-a-content-free-fire-record-and-requires-memoryref', 'RFC 0068 §C', 'a conforming commitment.fired payload MUST validate'),
     ).toBe(true);
     // Negative: missing memoryRef — a commitment with no provenance breaks CTI-1 binding.
     expect(
       fired!({ commitmentId: 'cmt-1', condition: 'time' }),
-      why('RFC 0068 §C', 'commitment.fired without memoryRef MUST be rejected'),
+      req('openwop.it.memory-consolidation-shape.commitment-fired-validates-a-content-free-fire-record-and-requires-memoryref', 'RFC 0068 §C', 'commitment.fired without memoryRef MUST be rejected'),
     ).toBe(false);
   });
 
   it('both event names appear in the RunEventType enum', () => {
     const runEvent = loadSchema('run-event.schema.json');
     const enumVals = (runEvent.$defs as Record<string, { enum?: string[] }>).RunEventType?.enum ?? [];
-    expect(enumVals).toContain('agent.memory.consolidated');
+    expect(enumVals, req('openwop.it.memory-consolidation-shape.both-event-names-appear-in-the-runeventtype-enum', 'RFC 0068', 'both event names appear in the RunEventType enum')).toContain('agent.memory.consolidated');
     expect(enumVals).toContain('commitment.fired');
   });
 });

package/src/scenarios/memory-degraded-projection.test.ts

@@ -29,10 +29,11 @@
  */
 
 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 { readManifestRuntimeCap, listManifestAgents } from '../lib/agentRuntime.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 /** The CLOSED RFC 0080 §A dimension vocabulary (agent-inventory-response.schema.json
  *  `degradedMemoryDimensions` enum). NOT the `memoryShape` keys. */
@@ -62,13 +63,13 @@ describe('memory-degraded-projection (RFC 0080 §C)', () => {
     if (!behaviorGate('openwop-memory-degraded', advertised)) return;
 
     const inv = await listManifestAgents();
-    if (inv === null) return; // host advertises the cap but doesn't serve /v1/agents — soft-skip
+    if (inv === null) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `inv === null` returned early (host advertises the cap but doesn\'t serve /v1/agents — soft-skip)'); // host advertises the cap but doesn't serve /v1/agents — soft-skip
     const agents = (inv.agents ?? []) as InventoryEntry[];
 
     // Non-vacuity: an advertising + serving host MUST expose its inventory.
     expect(
       agents.length >= 1,
-      driver.describe('agent-memory.md §"Memory capability model"', 'GET /v1/agents MUST return the installed manifest agents'),
+      req('openwop.it.memory-degraded-projection.stamps-memorydegraded-a-closed-enum-degradedmemorydimensions-on-degraded-agents', 'agent-memory.md §"Memory capability model"', 'GET /v1/agents MUST return the installed manifest agents'),
     ).toBe(true);
 
     // §C iff-contract on EVERY entry.
@@ -79,25 +80,25 @@ describe('memory-degraded-projection (RFC 0080 §C)', () => {
       if (degraded) {
         expect(
           Array.isArray(dims) && dims.length >= 1,
-          driver.describe('RFC 0080 §C', `memoryDegraded:true MUST carry a non-empty degradedMemoryDimensions (agent ${a.agentId})`),
+          req('openwop.it.memory-degraded-projection.stamps-memorydegraded-a-closed-enum-degradedmemorydimensions-on-degraded-agents', 'RFC 0080 §C', `memoryDegraded:true MUST carry a non-empty degradedMemoryDimensions (agent ${a.agentId})`),
         ).toBe(true);
         if (Array.isArray(dims)) {
           for (const d of dims) {
             expect(
               typeof d === 'string' && DIMENSIONS.includes(d),
-              driver.describe('agent-inventory-response.schema.json', `degradedMemoryDimensions members MUST be RFC 0080 §A dimension names (got ${String(d)})`),
+              req('openwop.it.memory-degraded-projection.stamps-memorydegraded-a-closed-enum-degradedmemorydimensions-on-degraded-agents', 'agent-inventory-response.schema.json', `degradedMemoryDimensions members MUST be RFC 0080 §A dimension names (got ${String(d)})`),
             ).toBe(true);
           }
           expect(
             new Set(dims as string[]).size === dims.length,
-            driver.describe('RFC 0080 §C', 'degradedMemoryDimensions MUST be unique'),
+            req('openwop.it.memory-degraded-projection.stamps-memorydegraded-a-closed-enum-degradedmemorydimensions-on-degraded-agents', 'RFC 0080 §C', 'degradedMemoryDimensions MUST be unique'),
           ).toBe(true);
         }
       } else {
         // Not degraded ⇒ no non-empty dimension list (absent or empty both pass).
         expect(
           dims === undefined || (Array.isArray(dims) && dims.length === 0),
-          driver.describe('RFC 0080 §C', `a non-degraded entry MUST NOT carry a non-empty degradedMemoryDimensions (agent ${a.agentId})`),
+          req('openwop.it.memory-degraded-projection.stamps-memorydegraded-a-closed-enum-degradedmemorydimensions-on-degraded-agents', 'RFC 0080 §C', `a non-degraded entry MUST NOT carry a non-empty degradedMemoryDimensions (agent ${a.agentId})`),
         ).toBe(true);
       }
     }
@@ -108,12 +109,12 @@ describe('memory-degraded-projection (RFC 0080 §C)', () => {
       const target = agents.find((a) => a.agentId === degradedId);
       expect(
         target !== undefined,
-        driver.describe('RFC 0080 §C', `OPENWOP_DEGRADED_AGENT_ID=${degradedId} MUST appear in the inventory`),
+        req('openwop.it.memory-degraded-projection.stamps-memorydegraded-a-closed-enum-degradedmemorydimensions-on-degraded-agents', 'RFC 0080 §C', `OPENWOP_DEGRADED_AGENT_ID=${degradedId} MUST appear in the inventory`),
       ).toBe(true);
       if (target) {
         expect(
           target.memoryDegraded === true && Array.isArray(target.degradedMemoryDimensions) && target.degradedMemoryDimensions.length >= 1,
-          driver.describe('RFC 0080 §C', 'the named degraded agent MUST project memoryDegraded:true + a non-empty degradedMemoryDimensions'),
+          req('openwop.it.memory-degraded-projection.stamps-memorydegraded-a-closed-enum-degradedmemorydimensions-on-degraded-agents', 'RFC 0080 §C', 'the named degraded agent MUST project memoryDegraded:true + a non-empty degradedMemoryDimensions'),
         ).toBe(true);
       }
     }

package/src/scenarios/memory-injection-budget.test.ts

@@ -34,6 +34,7 @@ import { pollUntilTerminal } from '../lib/polling.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const FIXTURE = 'conformance-agent-memory-injection-budget';
 const PROFILE = 'openwop-memory-injection-budget';
@@ -114,14 +115,14 @@ describe('memory-injection-budget (RFC 0113)', () => {
     if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', `host does not advertise the ${FIXTURE} conformance fixture`);
 
     const v = await driveFixtureVariables();
-    expect(v, 'fixture MUST surface run variables').toBeDefined();
-    if (v === undefined) return;
+    expect(v, req('openwop.it.memory-injection-budget.token-bounds-the-injection-read-omits-the-over-budget-entry-and-preserves-sr-1-c', 'RFC 0113', 'fixture MUST surface run variables')).toBeDefined();
+    if (v === undefined) return softSkip('blocked', 'precondition not met — `v === undefined` returned early (seam, prior step, or fixture unavailable)');
 
     // ── tokenBudget bound (the new lever) ──────────────────────────────
     const tokenBudget = numberOf(v['tokenBudget']);
     const total = numberOf(v['budgetedTokenTotal']);
-    expect(tokenBudget, 'fixture MUST echo the requested tokenBudget').toBeDefined();
-    expect(total, 'fixture MUST surface the budgeted cumulative token total').toBeDefined();
+    expect(tokenBudget, req('openwop.it.memory-injection-budget.token-bounds-the-injection-read-omits-the-over-budget-entry-and-preserves-sr-1-c', 'RFC 0113', 'fixture MUST echo the requested tokenBudget')).toBeDefined();
+    expect(total, req('openwop.it.memory-injection-budget.token-bounds-the-injection-read-omits-the-over-budget-entry-and-preserves-sr-1-c', 'RFC 0113', 'fixture MUST surface the budgeted cumulative token total')).toBeDefined();
     // Cumulative tokens across the returned prefix MUST NOT exceed the budget.
     if (tokenBudget !== undefined && total !== undefined) {
       expect(total).toBeLessThanOrEqual(tokenBudget);
@@ -130,21 +131,21 @@ describe('memory-injection-budget (RFC 0113)', () => {
     // ── over-budget single entry omitted (not truncated) ───────────────
     expect(
       booleanOf(v['overBudgetEntryOmitted']),
-      'an entry larger than the whole budget MUST be omitted, not truncated mid-entry',
+      req('openwop.it.memory-injection-budget.token-bounds-the-injection-read-omits-the-over-budget-entry-and-preserves-sr-1-c', 'RFC 0113', 'an entry larger than the whole budget MUST be omitted, not truncated mid-entry'),
     ).toBe(true);
     const entries = recordArrayOf(v['budgetedEntries']);
-    expect(entries, 'fixture MUST surface the budgeted entry slice').toBeDefined();
+    expect(entries, req('openwop.it.memory-injection-budget.token-bounds-the-injection-read-omits-the-over-budget-entry-and-preserves-sr-1-c', 'RFC 0113', 'fixture MUST surface the budgeted entry slice')).toBeDefined();
     const overId = stringOf(v['overBudgetEntryId']);
     if (entries !== undefined && overId !== undefined) {
       const ids = entries.map((e) => stringOf(e['id']));
-      expect(ids, 'the over-budget entry MUST NOT appear in the returned slice').not.toContain(overId);
+      expect(ids, req('openwop.it.memory-injection-budget.token-bounds-the-injection-read-omits-the-over-budget-entry-and-preserves-sr-1-c', 'RFC 0113', 'the over-budget entry MUST NOT appear in the returned slice')).not.toContain(overId);
     }
 
     // ── SR-1 re-assertion on the budgeted path ─────────────────────────
     // A budgeted/ranked read ranks over already-redacted content; the read
     // surface MUST carry the redaction marker, never the plaintext.
     const redacted = stringOf(v['redactedContentSample']);
-    expect(redacted, 'budgeted read MUST surface a redacted-content sample').toBeDefined();
+    expect(redacted, req('openwop.it.memory-injection-budget.token-bounds-the-injection-read-omits-the-over-budget-entry-and-preserves-sr-1-c', 'RFC 0113', 'budgeted read MUST surface a redacted-content sample')).toBeDefined();
     if (redacted !== undefined) {
       expect(redacted).toMatch(/\[REDACTED:[^\]]+\]/);
     }
@@ -154,9 +155,9 @@ describe('memory-injection-budget (RFC 0113)', () => {
     // the cross-tenant probe under the budgeted path MUST return empty.
     const probe = v['crossTenantBudgetedProbe'];
     if (Array.isArray(probe)) {
-      expect(probe.length, 'cross-tenant probe on the budgeted path MUST return []').toBe(0);
+      expect(probe.length, req('openwop.it.memory-injection-budget.token-bounds-the-injection-read-omits-the-over-budget-entry-and-preserves-sr-1-c', 'RFC 0113', 'cross-tenant probe on the budgeted path MUST return []')).toBe(0);
     } else {
-      expect(probe, 'cross-tenant probe on the budgeted path MUST return [] / null').toBeFalsy();
+      expect(probe, req('openwop.it.memory-injection-budget.token-bounds-the-injection-read-omits-the-over-budget-entry-and-preserves-sr-1-c', 'RFC 0113', 'cross-tenant probe on the budgeted path MUST return [] / null')).toBeFalsy();
     }
   });
 
@@ -175,13 +176,13 @@ describe('memory-injection-budget (RFC 0113)', () => {
     if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', `host does not advertise the ${FIXTURE} conformance fixture`);
 
     const v = await driveFixtureVariables();
-    expect(v, 'fixture MUST surface run variables').toBeDefined();
-    if (v === undefined) return;
+    expect(v, req('openwop.it.memory-injection-budget.rank-relevance-reorders-vs-recency-only-when-memory-search-semantic-is-also-adve', 'RFC 0113', 'fixture MUST surface run variables')).toBeDefined();
+    if (v === undefined) return softSkip('blocked', 'precondition not met — `v === undefined` returned early (seam, prior step, or fixture unavailable)');
 
     const recencyOrder = stringArrayOf(v['recencyOrder']);
     const relevanceOrder = stringArrayOf(v['relevanceOrder']);
-    expect(recencyOrder, 'fixture MUST surface the recency ordering').toBeDefined();
-    expect(relevanceOrder, 'fixture MUST surface the relevance ordering').toBeDefined();
+    expect(recencyOrder, req('openwop.it.memory-injection-budget.rank-relevance-reorders-vs-recency-only-when-memory-search-semantic-is-also-adve', 'RFC 0113', 'fixture MUST surface the recency ordering')).toBeDefined();
+    expect(relevanceOrder, req('openwop.it.memory-injection-budget.rank-relevance-reorders-vs-recency-only-when-memory-search-semantic-is-also-adve', 'RFC 0113', 'fixture MUST surface the relevance ordering')).toBeDefined();
     // The crafted fixture pins a query whose semantic top-k differs from the
     // most-recent-first order — relevance MUST reorder (not echo recency).
     expect(relevanceOrder).not.toEqual(recencyOrder);

package/src/scenarios/metric-emission.test.ts

@@ -25,6 +25,7 @@ import { discoveryFamilies } from '../lib/discovery-capabilities.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { getCollector } from '../lib/otel-collector.js';
+import { req } from '../lib/requirement-ids.js';
 
 /**
  * Callback-shaped: the host exports OTLP metrics to the suite's collector.
@@ -96,19 +97,19 @@ describe('metric-emission: canonical openwop.* metrics arrive at the collector',
 
     // Wait for the host's metric-emit tick to land at the collector.
     const sawBacklog = await waitForMetric('openwop.run.backlog', 5_000);
-    expect(sawBacklog, driver.describe(
+    expect(sawBacklog, req('openwop.it.metric-emission.host-emits-openwop-run-backlog-openwop-queue-depth-and-openwop-run-duration', 
       'observability.md §"Metrics"',
       'host claiming metrics MUST emit openwop.run.backlog',
     )).toBe(true);
 
     const sawQueueDepth = await waitForMetric('openwop.queue.depth', 5_000);
-    expect(sawQueueDepth, driver.describe(
+    expect(sawQueueDepth, req('openwop.it.metric-emission.host-emits-openwop-run-backlog-openwop-queue-depth-and-openwop-run-duration', 
       'observability.md §"Metrics"',
       'host claiming metrics MUST emit openwop.queue.depth',
     )).toBe(true);
 
     const sawDuration = await waitForMetric('openwop.run.duration', 5_000);
-    expect(sawDuration, driver.describe(
+    expect(sawDuration, req('openwop.it.metric-emission.host-emits-openwop-run-backlog-openwop-queue-depth-and-openwop-run-duration', 
       'observability.md §"Metrics"',
       'host claiming metrics MUST emit openwop.run.duration after a completed run',
     )).toBe(true);

package/src/scenarios/model-capability-insufficient.test.ts

@@ -39,24 +39,24 @@ describe.skipIf(HTTP_SKIP)('model-capability-insufficient: dispatch refusal (RFC
       supportedProviders: ['unknown-vendor'],
       nodeId: 'editor-node',
     });
-    if (r.status === 404) return;
+    if (r.status === 404) return softSkip('blocked', 'precondition not met — `r.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(
       r.body.outcome?.route,
-      driver.describe(
+      req('openwop.it.model-capability-insufficient.unmet-no-fallbackmodel-declared-refuse-with-fallbackattempted-false', 
         'RFCS/0031-envelope-variants-and-model-capabilities.md §B step 4',
         'unmet capability + no fallbackModel declared → host MUST refuse',
       ),
     ).toBe('refuse');
     expect(
       r.body.outcome?.fallbackAttempted,
-      driver.describe(
+      req('openwop.it.model-capability-insufficient.unmet-no-fallbackmodel-declared-refuse-with-fallbackattempted-false', 
         'schemas/run-event-payloads.schema.json §modelCapabilityInsufficient',
         'fallbackAttempted MUST be false when no fallbackModel was declared on the NodeModule',
       ),
     ).toBe(false);
     expect(
       r.body.event?.type,
-      driver.describe(
+      req('openwop.it.model-capability-insufficient.unmet-no-fallbackmodel-declared-refuse-with-fallbackattempted-false', 
         'RFCS/0031-envelope-variants-and-model-capabilities.md §D',
         'refuse path MUST emit `model.capability.insufficient` BEFORE the node failure',
       ),
@@ -81,11 +81,11 @@ describe.skipIf(HTTP_SKIP)('model-capability-insufficient: dispatch refusal (RFC
       // authenticate per RFC 0031 §B step 3 final clause.
       supportedProviders: ['anthropic', 'unknown-vendor'],
     });
-    if (r.status === 404) return;
+    if (r.status === 404) return softSkip('blocked', 'precondition not met — `r.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(r.body.outcome?.route).toBe('refuse');
     expect(
       r.body.outcome?.fallbackAttempted,
-      driver.describe(
+      req('openwop.it.model-capability-insufficient.unmet-fallback-declared-but-provider-not-in-supportedproviders-refuse-with-fallb', 
         'RFCS/0031-envelope-variants-and-model-capabilities.md §B step 3',
         'fallback provider NOT in capabilities.aiProviders.supported[] → host cannot authenticate → fallbackAttempted MUST be true (the attempt failed at credential resolution)',
       ),
@@ -104,11 +104,11 @@ describe.skipIf(HTTP_SKIP)('model-capability-insufficient: dispatch refusal (RFC
       substitutionSupported: false,
       supportedProviders: ['anthropic', 'unknown-vendor'],
     });
-    if (r.status === 404) return;
+    if (r.status === 404) return softSkip('blocked', 'precondition not met — `r.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(r.body.outcome?.route).toBe('refuse');
     expect(
       r.body.outcome?.fallbackAttempted,
-      driver.describe(
+      req('openwop.it.model-capability-insufficient.unmet-substitutionsupported-false-host-posture-refuse-with-fallbackattempted-fal', 
         'RFCS/0031-envelope-variants-and-model-capabilities.md §E',
         'capabilities.modelCapabilities.substitutionSupported: false → host MUST NOT attempt fallback even when NodeModule.fallbackModel is declared → fallbackAttempted MUST be false (no attempt was made)',
       ),
@@ -130,11 +130,11 @@ describe.skipIf(HTTP_SKIP)('model-capability-insufficient: dispatch refusal (RFC
       substitutionSupported: true,
       supportedProviders: ['unknown-vendor', 'unknown-vendor-2'],
     });
-    if (r.status === 404) return;
+    if (r.status === 404) return softSkip('blocked', 'precondition not met — `r.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(r.body.outcome?.route).toBe('refuse');
     expect(
       r.body.outcome?.fallbackAttempted,
-      driver.describe(
+      req('openwop.it.model-capability-insufficient.recursive-fallback-not-permitted-fallback-that-itself-fails-capability-check-ref', 
         'RFCS/0031-envelope-variants-and-model-capabilities.md §"Unresolved questions" #3',
         'recursive fallback NOT permitted — when the declared fallback model itself fails the capability check, host MUST refuse with fallbackAttempted: true (NOT chain to another fallback)',
       ),
@@ -152,12 +152,14 @@ describe.skipIf(HTTP_SKIP)('model-capability-insufficient: dispatch refusal (RFC
 
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const E2E_FIXTURE = 'conformance-model-capability-insufficient';
 
 describe.skipIf(HTTP_SKIP)('model-capability-insufficient: end-to-end refusal through executor', () => {
   it('workflow with a node declaring requiredModelCapabilities the active provider does not satisfy fails with RunSnapshot.error.code = "capability_not_provided" AND emits model.capability.insufficient into the run event log BEFORE node.failed', async () => {
-    if (!isFixtureAdvertised(E2E_FIXTURE)) return; // fixture not seeded — soft-skip
+    if (!isFixtureAdvertised(E2E_FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(E2E_FIXTURE)` returned early (fixture not seeded — soft-skip)'); // fixture not seeded — soft-skip
 
     const create = await driver.post('/v1/runs', { workflowId: E2E_FIXTURE });
     expect(create.status).toBe(201);
@@ -167,7 +169,7 @@ describe.skipIf(HTTP_SKIP)('model-capability-insufficient: end-to-end refusal th
     expect(terminal.status).toBe('failed');
     expect(
       (terminal as { error?: { code?: string } }).error?.code,
-      driver.describe(
+      req('openwop.it.model-capability-insufficient.workflow-with-a-node-declaring-requiredmodelcapabilities-the-active-provider-doe', 
         'RFCS/0031-envelope-variants-and-model-capabilities.md §B step 4',
         'unmet capability without viable fallback MUST fail with error.code = "capability_not_provided"',
       ),
@@ -178,11 +180,11 @@ describe.skipIf(HTTP_SKIP)('model-capability-insufficient: end-to-end refusal th
     const events = ((eventsRes.json as { events?: Array<{ type: string }> } | undefined)?.events ?? []);
     const insufficientIdx = events.findIndex((e) => e.type === 'model.capability.insufficient');
     const nodeFailedIdx = events.findIndex((e) => e.type === 'node.failed');
-    expect(insufficientIdx, 'model.capability.insufficient MUST appear in the event log').toBeGreaterThanOrEqual(0);
-    expect(nodeFailedIdx, 'node.failed MUST appear in the event log').toBeGreaterThanOrEqual(0);
+    expect(insufficientIdx, req('openwop.it.model-capability-insufficient.workflow-with-a-node-declaring-requiredmodelcapabilities-the-active-provider-doe', 'RFCS/0031-envelope-variants-and-model-capabilities.md §B step 4', 'model.capability.insufficient MUST appear in the event log')).toBeGreaterThanOrEqual(0);
+    expect(nodeFailedIdx, req('openwop.it.model-capability-insufficient.workflow-with-a-node-declaring-requiredmodelcapabilities-the-active-provider-doe', 'RFCS/0031-envelope-variants-and-model-capabilities.md §B step 4', 'node.failed MUST appear in the event log')).toBeGreaterThanOrEqual(0);
     expect(
       insufficientIdx < nodeFailedIdx,
-      driver.describe(
+      req('openwop.it.model-capability-insufficient.workflow-with-a-node-declaring-requiredmodelcapabilities-the-active-provider-doe', 
         'RFCS/0031-envelope-variants-and-model-capabilities.md §D',
         'model.capability.insufficient MUST be emitted BEFORE node.failed (cause precedes effect)',
       ),
@@ -190,7 +192,7 @@ describe.skipIf(HTTP_SKIP)('model-capability-insufficient: end-to-end refusal th
   });
 
   it('NO envelope emission occurs after the refusal (no node.completed, provider.usage, or envelope-reliability events)', async () => {
-    if (!isFixtureAdvertised(E2E_FIXTURE)) return; // fixture not seeded — soft-skip
+    if (!isFixtureAdvertised(E2E_FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(E2E_FIXTURE)` returned early (fixture not seeded — soft-skip)'); // fixture not seeded — soft-skip
 
     const create = await driver.post('/v1/runs', { workflowId: E2E_FIXTURE });
     expect(create.status).toBe(201);
@@ -212,7 +214,7 @@ describe.skipIf(HTTP_SKIP)('model-capability-insufficient: end-to-end refusal th
     const leaked = events.filter((e) => forbidden.includes(e.type)).map((e) => e.type);
     expect(
       leaked,
-      driver.describe(
+      req('openwop.it.model-capability-insufficient.no-envelope-emission-occurs-after-the-refusal-no-node-completed-provider-usage-o', 
         'RFCS/0031-envelope-variants-and-model-capabilities.md §B step 4',
         'a refused dispatch MUST NOT emit any downstream envelope-emission events — the node never ran',
       ),

package/src/scenarios/model-capability-substituted.test.ts

@@ -18,6 +18,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';
 
 const HTTP_SKIP = !process.env.OPENWOP_BASE_URL;
 
@@ -64,12 +66,12 @@ async function evaluateGate(input: Record<string, unknown>): Promise<{ status: n
 describe.skipIf(HTTP_SKIP)('model-capability-substituted: advertisement shape (RFC 0031 §E)', () => {
   it('capabilities.modelCapabilities (when present) conforms to RFC 0031 §E', async () => {
     const d = await readDiscovery();
-    if (d === null) return;
+    if (d === null) return softSkip('blocked', 'precondition not met — `d === null` returned early (seam, prior step, or fixture unavailable)');
     const mc = capabilityFamily(d, 'modelCapabilities');
-    if (mc === undefined) return;
+    if (mc === undefined) return softSkip('blocked', 'precondition not met — `mc === undefined` returned early (seam, prior step, or fixture unavailable)');
     expect(
       typeof mc.supported,
-      driver.describe(
+      req('openwop.it.model-capability-substituted.capabilities-modelcapabilities-when-present-conforms-to-rfc-0031-e', 
         'schemas/capabilities.schema.json §modelCapabilities',
         'capabilities.modelCapabilities.supported MUST be boolean when the block is advertised',
       ),
@@ -77,7 +79,7 @@ describe.skipIf(HTTP_SKIP)('model-capability-substituted: advertisement shape (R
     if (mc.advertised !== undefined) {
       expect(
         Array.isArray(mc.advertised),
-        driver.describe('RFCS/0031-envelope-variants-and-model-capabilities.md §E', 'modelCapabilities.advertised MUST be an array of capability identifiers'),
+        req('openwop.it.model-capability-substituted.capabilities-modelcapabilities-when-present-conforms-to-rfc-0031-e', 'RFCS/0031-envelope-variants-and-model-capabilities.md §E', 'modelCapabilities.advertised MUST be an array of capability identifiers'),
       ).toBe(true);
       // RFC 0031 §C's five, PLUS the four modality identifiers RFC 0055 §A
       // promoted into the formal vocabulary (Accepted 2026-05-26; registered in
@@ -89,13 +91,13 @@ describe.skipIf(HTTP_SKIP)('model-capability-substituted: advertisement shape (R
         'vision-input', 'audio-input', 'audio-output', 'image-output',
       ];
       for (const id of mc.advertised as unknown[]) {
-        expect(typeof id, 'each advertised identifier MUST be a string').toBe('string');
+        expect(typeof id, req('openwop.it.model-capability-substituted.capabilities-modelcapabilities-when-present-conforms-to-rfc-0031-e', 'RFCS/0031-envelope-variants-and-model-capabilities.md §E', 'each advertised identifier MUST be a string')).toBe('string');
         const idStr = String(id);
         const isReserved = SPEC_RESERVED.includes(idStr);
         const isHostExt = /^x-host-[a-z][a-z0-9-]*-[a-z][a-z0-9-]*$/.test(idStr);
         expect(
           isReserved || isHostExt,
-          driver.describe(
+          req('openwop.it.model-capability-substituted.capabilities-modelcapabilities-when-present-conforms-to-rfc-0031-e', 
             'RFCS/0031-envelope-variants-and-model-capabilities.md §C',
             `advertised identifier "${idStr}" MUST be spec-reserved (RFC 0031: structured-output, discriminator-enum, long-context, reasoning, function-calling; RFC 0055: vision-input, audio-input, audio-output, image-output) or match the x-host-<host>-<key> extension pattern`,
           ),
@@ -103,7 +105,7 @@ describe.skipIf(HTTP_SKIP)('model-capability-substituted: advertisement shape (R
       }
     }
     if (mc.substitutionSupported !== undefined) {
-      expect(typeof mc.substitutionSupported, 'substitutionSupported MUST be boolean').toBe('boolean');
+      expect(typeof mc.substitutionSupported, req('openwop.it.model-capability-substituted.capabilities-modelcapabilities-when-present-conforms-to-rfc-0031-e', 'RFCS/0031-envelope-variants-and-model-capabilities.md §C', 'substitutionSupported MUST be boolean')).toBe('boolean');
     }
   });
 });
@@ -117,15 +119,15 @@ describe.skipIf(HTTP_SKIP)('model-capability-substituted: dispatch behavior (RFC
       substitutionSupported: true,
       supportedProviders: ['anthropic', 'openai'],
     });
-    if (r.status === 404) return; // host doesn't expose the seam
+    if (r.status === 404) return softSkip('blocked', 'precondition not met — `r.status === 404` returned early (host doesn\'t expose the seam) (seam, prior step, or fixture unavailable)'); // host doesn't expose the seam
     expect(
       r.body.outcome?.route,
-      driver.describe(
+      req('openwop.it.model-capability-substituted.all-required-capabilities-met-outcome-dispatch-no-event-emitted', 
         'RFCS/0031-envelope-variants-and-model-capabilities.md §B step 2',
         'all required model capabilities met → route MUST be "dispatch" (gate is a no-op)',
       ),
     ).toBe('dispatch');
-    expect(r.body.event, 'no event emitted when gate is a no-op').toBeNull();
+    expect(r.body.event, req('openwop.it.model-capability-substituted.all-required-capabilities-met-outcome-dispatch-no-event-emitted', 'RFCS/0031-envelope-variants-and-model-capabilities.md §B step 2', 'no event emitted when gate is a no-op')).toBeNull();
   });
 
   it('unmet + fallback declared + authenticatable → outcome: substitute + event with originalProvider/originalModel/fallbackProvider/fallbackModel/missingCapabilities', async () => {
@@ -148,23 +150,23 @@ describe.skipIf(HTTP_SKIP)('model-capability-substituted: dispatch behavior (RFC
       supportedProviders: ['anthropic', 'openai', 'unknown-vendor'],
       nodeId: 'writer-node',
     });
-    if (r.status === 404) return;
+    if (r.status === 404) return softSkip('blocked', 'precondition not met — `r.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(
       r.body.outcome?.route,
-      driver.describe(
+      req('openwop.it.model-capability-substituted.unmet-fallback-declared-authenticatable-outcome-substitute-event-with-originalpr', 
         'RFCS/0031-envelope-variants-and-model-capabilities.md §B step 3',
         'unmet capability + declared fallback + fallback provider authenticatable → route MUST be "substitute"',
       ),
     ).toBe('substitute');
     expect(
       r.body.event?.type,
-      driver.describe(
+      req('openwop.it.model-capability-substituted.unmet-fallback-declared-authenticatable-outcome-substitute-event-with-originalpr', 
         'RFCS/0031-envelope-variants-and-model-capabilities.md §D',
         'substitute path MUST emit `model.capability.substituted`',
       ),
     ).toBe('model.capability.substituted');
     const payload = (r.body.event?.payload ?? {}) as Record<string, unknown>;
-    expect(payload.nodeId, 'payload.nodeId MUST mirror the request').toBe('writer-node');
+    expect(payload.nodeId, req('openwop.it.model-capability-substituted.unmet-fallback-declared-authenticatable-outcome-substitute-event-with-originalpr', 'RFCS/0031-envelope-variants-and-model-capabilities.md §D', 'payload.nodeId MUST mirror the request')).toBe('writer-node');
     expect(payload.originalProvider).toBe('unknown-vendor');
     expect(payload.originalModel).toBe('unknown-model');
     expect(payload.fallbackProvider).toBe('anthropic');
@@ -172,7 +174,7 @@ describe.skipIf(HTTP_SKIP)('model-capability-substituted: dispatch behavior (RFC
     expect(
       Array.isArray(payload.missingCapabilities) &&
         (payload.missingCapabilities as string[]).includes('structured-output'),
-      driver.describe(
+      req('openwop.it.model-capability-substituted.unmet-fallback-declared-authenticatable-outcome-substitute-event-with-originalpr', 
         'schemas/run-event-payloads.schema.json §modelCapabilitySubstituted',
         'missingCapabilities[] MUST include the subset of required capabilities the active model did not satisfy',
       ),
@@ -192,10 +194,10 @@ describe.skipIf(HTTP_SKIP)('model-capability-substituted: dispatch behavior (RFC
       substitutionSupported: false,
       supportedProviders: ['anthropic', 'unknown-vendor'],
     });
-    if (r.status === 404) return;
+    if (r.status === 404) return softSkip('blocked', 'precondition not met — `r.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(
       r.body.outcome?.route,
-      driver.describe(
+      req('openwop.it.model-capability-substituted.unmet-substitutionsupported-false-outcome-refuse-with-fallbackattempted-false-ho', 
         'RFCS/0031-envelope-variants-and-model-capabilities.md §E',
         'capabilities.modelCapabilities.substitutionSupported: false → host MUST refuse on any unmet capability even when NodeModule.fallbackModel is declared',
       ),
@@ -203,7 +205,7 @@ describe.skipIf(HTTP_SKIP)('model-capability-substituted: dispatch behavior (RFC
     expect(r.body.event?.type).toBe('model.capability.insufficient');
     expect(
       (r.body.event?.payload as { fallbackAttempted?: boolean }).fallbackAttempted,
-      driver.describe(
+      req('openwop.it.model-capability-substituted.unmet-substitutionsupported-false-outcome-refuse-with-fallbackattempted-false-ho', 
         'schemas/run-event-payloads.schema.json §modelCapabilityInsufficient',
         'fallbackAttempted MUST be false when the refusal is driven by substitutionSupported: false (host posture, not fallback failure)',
       ),