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

package/src/scenarios/agent-roster-shape.test.ts

@@ -35,9 +35,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. */
-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>;
@@ -48,9 +46,9 @@ describe('agent-roster-shape: capability advertisement (RFC 0086, server-free)',
     const caps = loadSchema('capabilities.schema.json');
     const agents = (caps.properties as Record<string, { properties?: Record<string, { properties?: Record<string, unknown> }> }>).agents;
     const roster = agents?.properties?.roster;
-    expect(roster, why('capabilities.md §agents', 'agents.roster MUST be declared')).toBeDefined();
+    expect(roster, req('openwop.it.agent-roster-shape.the-capabilities-schema-declares-agents-roster-with-its-sub-flags', 'capabilities.md §agents', 'agents.roster MUST be declared')).toBeDefined();
     for (const flag of ['supported', 'installScope', 'portfolioTriggerSources']) {
-      expect(roster?.properties?.[flag], why('agent-roster.md §F', `agents.roster.${flag} MUST be declared`)).toBeDefined();
+      expect(roster?.properties?.[flag], req('openwop.it.agent-roster-shape.the-capabilities-schema-declares-agents-roster-with-its-sub-flags', 'agent-roster.md §F', `agents.roster.${flag} MUST be declared`)).toBeDefined();
     }
   });
 });
@@ -69,7 +67,7 @@ describe('agent-roster-shape: roster entry (RFC 0086 §A, server-free)', () => {
       owner: { tenantId: 'acme', workspaceId: 'growth' },
       enabled: true,
     };
-    expect(entry(good), why('RFC 0086 §A', 'a conforming roster entry MUST validate')).toBe(true);
+    expect(entry(good), req('openwop.it.agent-roster-shape.agentrosterentry-validates-a-conforming-entry', 'RFC 0086 §A', 'a conforming roster entry MUST validate')).toBe(true);
   });
 
   it('rejects a non-host: rosterId and an agentRef carrying both version and channel', () => {
@@ -79,12 +77,12 @@ describe('agent-roster-shape: roster entry (RFC 0086 §A, server-free)', () => {
       agentRef: { agentId: 'core.openwop.agents.brief-writer' },
       owner: { tenantId: 'acme' },
     };
-    expect(entry({ ...base, rosterId: 'core.openwop.agents.sally' }), why('RFC 0086 §A', 'a non-`host:` rosterId MUST be rejected')).toBe(false);
+    expect(entry({ ...base, rosterId: 'core.openwop.agents.sally' }), req('openwop.it.agent-roster-shape.rejects-a-non-host-rosterid-and-an-agentref-carrying-both-version-and-channel', 'RFC 0086 §A', 'a non-`host:` rosterId MUST be rejected')).toBe(false);
     expect(
       entry({ ...base, agentRef: { agentId: 'core.x.y.z', version: '1.0.0', channel: 'stable' } }),
-      why('RFC 0082 §A', 'an agentRef with BOTH version and channel MUST be rejected'),
+      req('openwop.it.agent-roster-shape.rejects-a-non-host-rosterid-and-an-agentref-carrying-both-version-and-channel', 'RFC 0082 §A', 'an agentRef with BOTH version and channel MUST be rejected'),
     ).toBe(false);
-    expect(entry({ persona: 'x', agentRef: { agentId: 'core.x.y.z' }, owner: { tenantId: 'acme' } }), why('RFC 0086 §A', 'a roster entry without rosterId MUST be rejected')).toBe(false);
+    expect(entry({ persona: 'x', agentRef: { agentId: 'core.x.y.z' }, owner: { tenantId: 'acme' } }), req('openwop.it.agent-roster-shape.rejects-a-non-host-rosterid-and-an-agentref-carrying-both-version-and-channel', 'RFC 0086 §A', 'a roster entry without rosterId MUST be rejected')).toBe(false);
   });
 });
 
@@ -96,23 +94,23 @@ describe('agent-roster-shape: roster.run.initiated event (RFC 0086 §C, server-f
   const initiated = ajv.getSchema('payloads#/$defs/rosterRunInitiated');
 
   it('roster.run.initiated validates a content-free attribution record and requires its ids', () => {
-    expect(initiated, 'the rosterRunInitiated $def MUST exist').toBeTruthy();
+    expect(initiated, req('openwop.it.agent-roster-shape.roster-run-initiated-validates-a-content-free-attribution-record-and-requires-it', 'RFC 0086', 'the rosterRunInitiated $def MUST exist')).toBeTruthy();
     expect(
       initiated!({ rosterId: 'host:sally-marketing', persona: 'Sally', agentId: 'core.openwop.agents.brief-writer', workflowId: 'marketing-email-campaign', triggerSource: 'schedule' }),
-      why('RFC 0086 §C', 'a conforming roster.run.initiated payload MUST validate'),
+      req('openwop.it.agent-roster-shape.roster-run-initiated-validates-a-content-free-attribution-record-and-requires-it', 'RFC 0086 §C', 'a conforming roster.run.initiated payload MUST validate'),
     ).toBe(true);
-    expect(initiated!({ rosterId: 'host:s', persona: 'S' }), why('RFC 0086 §C', 'roster.run.initiated without agentId/workflowId/triggerSource MUST be rejected')).toBe(false);
+    expect(initiated!({ rosterId: 'host:s', persona: 'S' }), req('openwop.it.agent-roster-shape.roster-run-initiated-validates-a-content-free-attribution-record-and-requires-it', 'RFC 0086 §C', 'roster.run.initiated without agentId/workflowId/triggerSource MUST be rejected')).toBe(false);
   });
 
   it('roster.run.initiated is content-free — a work-item body and a prompt are rejected (roster-attribution-no-content)', () => {
     const base = { rosterId: 'host:s', persona: 'S', agentId: 'a.b.c.d', workflowId: 'wf', triggerSource: 'queue' };
     expect(
       initiated!({ ...base, body: 'the card description' }),
-      why('SECURITY invariant roster-attribution-no-content', 'roster.run.initiated MUST NOT carry the work-item body'),
+      req('openwop.it.agent-roster-shape.roster-run-initiated-is-content-free-a-work-item-body-and-a-prompt-are-rejected', 'SECURITY invariant roster-attribution-no-content', 'roster.run.initiated MUST NOT carry the work-item body'),
     ).toBe(false);
     expect(
       initiated!({ ...base, prompt: 'system: …' }),
-      why('SECURITY invariant roster-attribution-no-content', 'roster.run.initiated MUST NOT carry prompt content'),
+      req('openwop.it.agent-roster-shape.roster-run-initiated-is-content-free-a-work-item-body-and-a-prompt-are-rejected', 'SECURITY invariant roster-attribution-no-content', 'roster.run.initiated MUST NOT carry prompt content'),
     ).toBe(false);
   });
 });
@@ -121,13 +119,13 @@ describe('agent-roster-shape: inventory projection + enum (RFC 0086 §B, server-
   it('AgentInventoryEntry carries the additive optional roster portfolio projection', () => {
     const inv = loadSchema('agent-inventory-response.schema.json');
     const entry = (inv.$defs as Record<string, { properties?: Record<string, unknown> }>).AgentInventoryEntry?.properties ?? {};
-    expect(entry.roster, why('RFC 0086 §B', 'AgentInventoryEntry.roster (the portfolio projection) MUST be declared')).toBeDefined();
+    expect(entry.roster, req('openwop.it.agent-roster-shape.agentinventoryentry-carries-the-additive-optional-roster-portfolio-projection', 'RFC 0086 §B', 'AgentInventoryEntry.roster (the portfolio projection) MUST be declared')).toBeDefined();
   });
 
   it('roster.run.initiated appears 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('roster.run.initiated');
+    expect(enumVals, req('openwop.it.agent-roster-shape.roster-run-initiated-appears-in-the-runeventtype-enum', 'RFC 0086', 'roster.run.initiated appears in the RunEventType enum')).toContain('roster.run.initiated');
   });
 
   it('the GET /v1/agents/roster response schema validates + rejects extras (RFC 0086 §B)', () => {
@@ -139,8 +137,8 @@ describe('agent-roster-shape: inventory projection + enum (RFC 0086 §B, server-
       roster: [{ rosterId: 'host:sally', persona: 'Sally', agentRef: { agentId: 'core.x.y.z' }, owner: { tenantId: 'acme' } }],
       total: 1,
     };
-    expect(resp(good), why('RFC 0086 §B', 'a conforming GET /v1/agents/roster response MUST validate')).toBe(true);
-    expect(resp({ ...good, unexpected: true }), why('RFC 0086 §B', 'an extra top-level property MUST be rejected')).toBe(false);
-    expect(resp({ roster: [] }), why('RFC 0086 §B', 'the response MUST require `total`')).toBe(false);
+    expect(resp(good), req('openwop.it.agent-roster-shape.the-get-v1-agents-roster-response-schema-validates-rejects-extras-rfc-0086-b', 'RFC 0086 §B', 'a conforming GET /v1/agents/roster response MUST validate')).toBe(true);
+    expect(resp({ ...good, unexpected: true }), req('openwop.it.agent-roster-shape.the-get-v1-agents-roster-response-schema-validates-rejects-extras-rfc-0086-b', 'RFC 0086 §B', 'an extra top-level property MUST be rejected')).toBe(false);
+    expect(resp({ roster: [] }), req('openwop.it.agent-roster-shape.the-get-v1-agents-roster-response-schema-validates-rejects-extras-rfc-0086-b', 'RFC 0086 §B', 'the response MUST require `total`')).toBe(false);
   });
 });

package/src/scenarios/agent-verifier-shape.test.ts

@@ -25,9 +25,9 @@ import { join } from 'node:path';
 import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
 import { SCHEMAS_DIR } from '../lib/paths.js';
+import { req } from '../lib/requirement-ids.js';
 
 const BASE = 'https://openwop.dev/spec/v1/';
-const why = (specRef: string, requirement: string): string => `${specRef} — ${requirement}`;
 function loadSchema(name: string): Record<string, unknown> {
   return JSON.parse(readFileSync(join(SCHEMAS_DIR, name), 'utf8')) as Record<string, unknown>;
 }
@@ -52,21 +52,21 @@ describe('agent-verifier-shape: agent.verified payload (RFC 0090 §A, server-fre
   const verified = ajv.getSchema(`${BASE}run-event-payloads.schema.json#/$defs/agentVerified`);
 
   it('a conforming content-free verdict validates', () => {
-    expect(verified, 'the agentVerified $def MUST exist').toBeTruthy();
+    expect(verified, req('openwop.it.agent-verifier-shape.a-conforming-content-free-verdict-validates', 'RFC 0090', 'the agentVerified $def MUST exist')).toBeTruthy();
     expect(
       verified!({ agentId: 'core.openwop.verifier', target: 'evt-42', verdict: 'pass', criteria: ['grounded'], confidence: 0.9 }),
-      why('RFC 0090 §A', 'a conforming agent.verified payload MUST validate'),
+      req('openwop.it.agent-verifier-shape.a-conforming-content-free-verdict-validates', 'RFC 0090 §A', 'a conforming agent.verified payload MUST validate'),
     ).toBe(true);
   });
 
   it('rejects an out-of-enum verdict', () => {
-    expect(verified!({ agentId: 'c', target: 'e', verdict: 'ok' }), why('RFC 0090 §A', 'verdict MUST be pass|fail|revise')).toBe(false);
+    expect(verified!({ agentId: 'c', target: 'e', verdict: 'ok' }), req('openwop.it.agent-verifier-shape.rejects-an-out-of-enum-verdict', 'RFC 0090 §A', 'verdict MUST be pass|fail|revise')).toBe(false);
   });
 
   it('rejects a content-carrying payload (verifier-no-content-leak)', () => {
     expect(
       verified!({ agentId: 'c', target: 'e', verdict: 'fail', result: 'the secret answer' }),
-      why('RFC 0090 §SECURITY', 'agent.verified MUST be content-free (additionalProperties:false)'),
+      req('openwop.it.agent-verifier-shape.rejects-a-content-carrying-payload-verifier-no-content-leak', 'RFC 0090 §SECURITY', 'agent.verified MUST be content-free (additionalProperties:false)'),
     ).toBe(false);
   });
 });
@@ -78,7 +78,7 @@ describe('agent-verifier-shape: RunEventType + terminate + capability (RFC 0090)
     const runEvent = loadSchema('run-event.schema.json') as { $defs?: { RunEventType?: { enum?: string[] } } };
     expect(
       runEvent.$defs?.RunEventType?.enum?.includes('agent.verified'),
-      why('RFC 0090 §A', 'agent.verified MUST appear in the RunEventType enum'),
+      req('openwop.it.agent-verifier-shape.agent-verified-is-registered-in-the-runeventtype-enum', 'RFC 0090 §A', 'agent.verified MUST appear in the RunEventType enum'),
     ).toBe(true);
   });
 
@@ -86,21 +86,21 @@ describe('agent-verifier-shape: RunEventType + terminate + capability (RFC 0090)
     const decision = ajv.getSchema(`${BASE}orchestrator-decision.schema.json`)!;
     expect(
       decision({ kind: 'terminate', reason: 'goal-reached', successCriteria: [{ key: 'goal-answered', met: true }] }),
-      why('RFC 0090 §C', 'terminate MUST accept successCriteria[{key,met}]'),
+      req('openwop.it.agent-verifier-shape.the-terminate-decision-accepts-the-additive-successcriteria', 'RFC 0090 §C', 'terminate MUST accept successCriteria[{key,met}]'),
     ).toBe(true);
     expect(
       decision({ kind: 'terminate', successCriteria: [{ key: 'x' }] }),
-      why('RFC 0090 §C', 'a successCriteria entry MUST require both key and met'),
+      req('openwop.it.agent-verifier-shape.the-terminate-decision-accepts-the-additive-successcriteria', 'RFC 0090 §C', 'a successCriteria entry MUST require both key and met'),
     ).toBe(false);
   });
 
   it('capabilities accepts executionModel.version 6 + verifier sub-block', () => {
     const execModel = ajv.getSchema(`${BASE}capabilities.schema.json#/properties/multiAgent/properties/executionModel`);
-    expect(execModel, 'the executionModel sub-schema MUST exist').toBeTruthy();
+    expect(execModel, req('openwop.it.agent-verifier-shape.capabilities-accepts-executionmodel-version-6-verifier-sub-block', 'RFC 0090', 'the executionModel sub-schema MUST exist')).toBeTruthy();
     expect(
       execModel!({ supported: true, version: 6, verifier: { supported: true, gating: true } }),
-      why('RFC 0090 §D', 'version:6 + verifier{supported,gating} MUST validate'),
+      req('openwop.it.agent-verifier-shape.capabilities-accepts-executionmodel-version-6-verifier-sub-block', 'RFC 0090 §D', 'version:6 + verifier{supported,gating} MUST validate'),
     ).toBe(true);
-    expect(execModel!({ supported: true, version: 7 }), why('RFC 0090 §D', 'version above the ceiling MUST be rejected')).toBe(false);
+    expect(execModel!({ supported: true, version: 7 }), req('openwop.it.agent-verifier-shape.capabilities-accepts-executionmodel-version-6-verifier-sub-block', 'RFC 0090 §D', 'version above the ceiling MUST be rejected')).toBe(false);
   });
 });

package/src/scenarios/agentConfidenceEscalation.test.ts

@@ -21,6 +21,7 @@ import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { isAgentSupported } from '../lib/multi-agent-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const FIXTURE = 'conformance-agent-low-confidence';
 const SKIP = !isAgentSupported() || !isFixtureAdvertised(FIXTURE);
@@ -51,7 +52,7 @@ describe.skipIf(SKIP)('agentConfidenceEscalation: confidence < threshold → low
     const lowConfSuspend = list.find(
       (e) => e.type === 'node.suspended' && e.payload?.reason === 'low-confidence',
     );
-    expect(lowConfSuspend, 'CP-1: low-confidence agent.decided MUST emit node.suspended { reason: low-confidence }').toBeDefined();
+    expect(lowConfSuspend, req('openwop.it.agentConfidenceEscalation.low-confidence-agent-decided-suspends-with-reason-low-confidence-and-run-reaches', 'RFCS/0002-agent-identity-and-reasoning-events.md', 'CP-1: low-confidence agent.decided MUST emit node.suspended { reason: low-confidence }')).toBeDefined();
 
     const payload = lowConfSuspend!.payload as Record<string, unknown>;
     expect(typeof payload.agentId).toBe('string');

package/src/scenarios/agentMemoryCrossTenantIsolation.test.ts

@@ -20,6 +20,7 @@ import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { hasLongTermMemory } from '../lib/multi-agent-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const FIXTURE = 'conformance-agent-memory-cross-tenant';
 const SKIP = !hasLongTermMemory() || !isFixtureAdvertised(FIXTURE);
@@ -50,13 +51,13 @@ describe.skipIf(SKIP)('agentMemoryCrossTenantIsolation: CTI-1 invariant', () =>
       const ownerProbe = vars.ownerProbe;
       expect(
         Array.isArray(ownerProbe) && ownerProbe.length > 0,
-        driver.describe('agent-memory.md §CTI-1 / fixtures.md conformance-agent-memory-cross-tenant', 'ownerProbe MUST be a NON-EMPTY array — the run\'s own tenant can read the entry it just wrote (positive control; an unset or empty ownerProbe means the probe never ran)'),
+        req('openwop.it.agentMemoryCrossTenantIsolation.cross-tenant-memoryref-returns-empty-null-no-leak-across-tenant-boundary', 'agent-memory.md §CTI-1 / fixtures.md conformance-agent-memory-cross-tenant', 'ownerProbe MUST be a NON-EMPTY array — the run\'s own tenant can read the entry it just wrote (positive control; an unset or empty ownerProbe means the probe never ran)'),
       ).toBe(true);
       const ownerEntryId = vars.ownerEntryId;
       if (typeof ownerEntryId === 'string' && ownerEntryId.length > 0) {
         expect(
           (ownerProbe as Array<{ id?: unknown }>).some((e) => e && typeof e === 'object' && e.id === ownerEntryId),
-          driver.describe('agent-memory.md §CTI-1', `ownerProbe MUST contain the entry the host reports writing (ownerEntryId=${ownerEntryId})`),
+          req('openwop.it.agentMemoryCrossTenantIsolation.cross-tenant-memoryref-returns-empty-null-no-leak-across-tenant-boundary', 'agent-memory.md §CTI-1', `ownerProbe MUST contain the entry the host reports writing (ownerEntryId=${ownerEntryId})`),
         ).toBe(true);
       }
 
@@ -65,12 +66,12 @@ describe.skipIf(SKIP)('agentMemoryCrossTenantIsolation: CTI-1 invariant', () =>
       const crossTenantResult = vars.crossTenantProbe;
       expect(
         crossTenantResult !== undefined,
-        driver.describe('agent-memory.md §CTI-1', 'crossTenantProbe MUST be set — an unset variable means the cross-tenant probe was never issued, which proves nothing'),
+        req('openwop.it.agentMemoryCrossTenantIsolation.cross-tenant-memoryref-returns-empty-null-no-leak-across-tenant-boundary', 'agent-memory.md §CTI-1', 'crossTenantProbe MUST be set — an unset variable means the cross-tenant probe was never issued, which proves nothing'),
       ).toBe(true);
       if (Array.isArray(crossTenantResult)) {
-        expect(crossTenantResult.length, driver.describe('agent-memory.md §CTI-1', 'a cross-tenant memoryRef probe MUST return [] — no entries of another tenant')).toBe(0);
+        expect(crossTenantResult.length, req('openwop.it.agentMemoryCrossTenantIsolation.cross-tenant-memoryref-returns-empty-null-no-leak-across-tenant-boundary', 'agent-memory.md §CTI-1', 'a cross-tenant memoryRef probe MUST return [] — no entries of another tenant')).toBe(0);
       } else {
-        expect(crossTenantResult, driver.describe('agent-memory.md §CTI-1', 'a non-array cross-tenant probe result MUST be null')).toBeNull();
+        expect(crossTenantResult, req('openwop.it.agentMemoryCrossTenantIsolation.cross-tenant-memoryref-returns-empty-null-no-leak-across-tenant-boundary', 'agent-memory.md §CTI-1', 'a non-array cross-tenant probe result MUST be null')).toBeNull();
       }
     }
   });

package/src/scenarios/agentMemoryRedactionContract.test.ts

@@ -20,6 +20,7 @@ import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { hasLongTermMemory } from '../lib/multi-agent-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const FIXTURE = 'conformance-agent-memory-redaction';
 const SKIP = !hasLongTermMemory() || !isFixtureAdvertised(FIXTURE);
@@ -27,7 +28,7 @@ const SKIP = !hasLongTermMemory() || !isFixtureAdvertised(FIXTURE);
 describe.skipIf(SKIP)('agentMemoryRedactionContract: SR-1 invariant', () => {
   it('BYOK plaintext is redacted to [REDACTED:<secretId>] at the read surface', async () => {
     const create = await driver.post('/v1/runs', { workflowId: FIXTURE });
-    expect(create.status).toBe(201);
+    expect(create.status, req('openwop.it.agentMemoryRedactionContract.byok-plaintext-is-redacted-to-redacted-secretid-at-the-read-surface', 'RFCS/0004-memory-layer.md', 'BYOK plaintext is redacted to [REDACTED:<secretId>] at the read surface')).toBe(201);
     const runId = (create.json as { runId: string }).runId;
 
     const terminal = await pollUntilTerminal(runId);

package/src/scenarios/agentMemoryRoundTrip.test.ts

@@ -19,6 +19,7 @@ import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { hasLongTermMemory } from '../lib/multi-agent-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const FIXTURE = 'conformance-agent-memory-roundtrip';
 const SKIP = !hasLongTermMemory() || !isFixtureAdvertised(FIXTURE);
@@ -26,7 +27,7 @@ const SKIP = !hasLongTermMemory() || !isFixtureAdvertised(FIXTURE);
 describe.skipIf(SKIP)('agentMemoryRoundTrip: write → read via MemoryAdapter', () => {
   it('memory entries written during a run are readable via the resolved memoryRef', async () => {
     const create = await driver.post('/v1/runs', { workflowId: FIXTURE });
-    expect(create.status).toBe(201);
+    expect(create.status, req('openwop.it.agentMemoryRoundTrip.memory-entries-written-during-a-run-are-readable-via-the-resolved-memoryref', 'RFCS/0004-memory-layer.md', 'memory entries written during a run are readable via the resolved memoryRef')).toBe(201);
     const runId = (create.json as { runId: string }).runId;
 
     const terminal = await pollUntilTerminal(runId);

package/src/scenarios/agentMemoryTtlExpiry.test.ts

@@ -18,6 +18,7 @@ import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { hasLongTermMemory } from '../lib/multi-agent-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const FIXTURE = 'conformance-agent-memory-ttl';
 const SKIP = !hasLongTermMemory() || !isFixtureAdvertised(FIXTURE);
@@ -52,15 +53,15 @@ describe.skipIf(SKIP)('agentMemoryTtlExpiry: expired entries are excluded from l
     const expiredId = body.variables?.expiredId;
     expect(
       typeof freshId === 'string' && freshId.length > 0 && typeof expiredId === 'string' && expiredId.length > 0,
-      driver.describe('fixtures.md conformance-agent-memory-ttl', 'the host MUST land freshId and expiredId (the ids of the two entries it wrote) so the list can be checked on both sides'),
+      req('openwop.it.agentMemoryTtlExpiry.list-excludes-entries-whose-expiresat-is-in-the-past', 'fixtures.md conformance-agent-memory-ttl', 'the host MUST land freshId and expiredId (the ids of the two entries it wrote) so the list can be checked on both sides'),
     ).toBe(true);
     expect(
       listResult!.some((e) => e.id === freshId),
-      driver.describe('agent-memory.md §TTL', `list() MUST include the fresh entry (freshId=${String(freshId)})`),
+      req('openwop.it.agentMemoryTtlExpiry.list-excludes-entries-whose-expiresat-is-in-the-past', 'agent-memory.md §TTL', `list() MUST include the fresh entry (freshId=${String(freshId)})`),
     ).toBe(true);
     expect(
       listResult!.some((e) => e.id === expiredId),
-      driver.describe('agent-memory.md §TTL', `list() MUST NOT include the expired entry (expiredId=${String(expiredId)})`),
+      req('openwop.it.agentMemoryTtlExpiry.list-excludes-entries-whose-expiresat-is-in-the-past', 'agent-memory.md §TTL', `list() MUST NOT include the expired entry (expiredId=${String(expiredId)})`),
     ).toBe(false);
   });
 });

package/src/scenarios/agentMessageReducer.test.ts

@@ -23,6 +23,7 @@ import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { isAgentSupported } from '../lib/multi-agent-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const FIXTURE = 'conformance-message-reducer';
 const SKIP = !isAgentSupported() || !isFixtureAdvertised(FIXTURE);
@@ -44,7 +45,7 @@ describe.skipIf(SKIP)('agentMessageReducer: message reducer idempotency + append
     // fixture convention is `conversation` or `messages`).
     const channelEntries = Object.entries(body.channels ?? {});
     const messageChannel = channelEntries.find(([, val]) => Array.isArray(val));
-    expect(messageChannel, 'fixture MUST expose at least one message-reducer channel').toBeDefined();
+    expect(messageChannel, req('openwop.it.agentMessageReducer.duplicate-messageid-emissions-fold-to-a-single-channel-entry', 'RFCS/0002-agent-identity-and-reasoning-events.md', 'fixture MUST expose at least one message-reducer channel')).toBeDefined();
 
     const messages = messageChannel![1] as Array<{ messageId?: string }>;
     const messageIds = messages

package/src/scenarios/agentMetadata.test.ts

@@ -23,6 +23,7 @@ import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { isAgentSupported } from '../lib/multi-agent-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const FIXTURE = 'conformance-agent-identity';
 const SKIP = !isAgentSupported() || !isFixtureAdvertised(FIXTURE);
@@ -44,7 +45,7 @@ describe.skipIf(SKIP)('agentMetadata: RunSnapshot.agent + runOrchestrator wire-s
     const hasOrch = body.runOrchestrator && typeof body.runOrchestrator.agentId === 'string';
     expect(
       hasAgent || hasOrch,
-      'fixture-runs MUST populate at least one of RunSnapshot.agent / runOrchestrator',
+      req('openwop.it.agentMetadata.host-populates-agentref-shaped-agent-identity-on-runsnapshot', 'RFCS/0002-agent-identity-and-reasoning-events.md', 'fixture-runs MUST populate at least one of RunSnapshot.agent / runOrchestrator'),
     ).toBe(true);
 
     if (hasAgent) {

package/src/scenarios/agentPackCatalog.test.ts

@@ -31,6 +31,8 @@
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { isAgentSupported } from '../lib/multi-agent-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 interface PackList {
   packs?: Array<{
@@ -68,7 +70,7 @@ async function findPack(name: string): Promise<PackList['packs'] extends Array<i
   return (found ?? null) as never;
 }
 
-function assertAgentManifestShape(
+function assertAgentManifestShape(requirementId: string, 
   agent: NonNullable<NonNullable<PackList['packs']>[number]['agents']>[number],
   expectations: { agentIdEndsWith?: string; modelClass?: string; minTools?: number },
 ): void {
@@ -80,7 +82,7 @@ function assertAgentManifestShape(
   // agentId pattern (RFCS/0003 §A namespace tiers).
   expect(
     AGENT_ID_PATTERN.test(agent.agentId ?? ''),
-    driver.describe(
+    req(requirementId, 
       'schemas/agent-manifest.schema.json §agentId',
       `agentId "${agent.agentId}" MUST match the namespace-tier pattern`,
     ),
@@ -133,10 +135,10 @@ const SKIP = !isAgentSupported();
 describe.skipIf(SKIP)('core.openwop.agents.deep-research — pack catalog evidence', () => {
   it('host pack-list includes deep-research with a well-formed AgentManifest', async () => {
     const pack = await findPack('core.openwop.agents.deep-research');
-    if (pack === null) return; // host doesn't expose /v1/packs or doesn't have this pack
-    expect(pack.version, 'pack version MUST be present').toBeDefined();
-    expect(Array.isArray(pack.agents) && pack.agents.length === 1, 'deep-research ships exactly one agent').toBe(true);
-    assertAgentManifestShape(pack.agents![0]!, {
+    if (pack === null) return softSkip('blocked', 'precondition not met — `pack === null` returned early (host doesn\'t expose /v1/packs or doesn\'t have this pack) (seam, prior step, or fixture unavailable)'); // host doesn't expose /v1/packs or doesn't have this pack
+    expect(pack.version, req('openwop.it.agentPackCatalog.host-pack-list-includes-deep-research-with-a-well-formed-agentmanifest', 'RFCS/0003-agent-packs.md', 'pack version MUST be present')).toBeDefined();
+    expect(Array.isArray(pack.agents) && pack.agents.length === 1, req('openwop.it.agentPackCatalog.host-pack-list-includes-deep-research-with-a-well-formed-agentmanifest', 'RFCS/0003-agent-packs.md', 'deep-research ships exactly one agent')).toBe(true);
+    assertAgentManifestShape('openwop.it.agentPackCatalog.host-pack-list-includes-deep-research-with-a-well-formed-agentmanifest', pack.agents![0]!, {
       agentIdEndsWith: 'deep-research',
       modelClass: 'research',
       minTools: 1,
@@ -145,11 +147,11 @@ describe.skipIf(SKIP)('core.openwop.agents.deep-research — pack catalog eviden
     const tools = pack.agents![0]!.toolAllowlist ?? [];
     expect(
       tools.some((t) => t.includes('rag') || t.includes('retriever')),
-      'deep-research SHOULD allow at least one rag/retriever tool',
+      req('openwop.it.agentPackCatalog.host-pack-list-includes-deep-research-with-a-well-formed-agentmanifest', 'RFCS/0003-agent-packs.md', 'deep-research SHOULD allow at least one rag/retriever tool'),
     ).toBe(true);
     expect(
       pack.agents![0]!.memoryShape?.longTerm,
-      'deep-research MUST request longTerm memory (it persists facts across runs)',
+      req('openwop.it.agentPackCatalog.host-pack-list-includes-deep-research-with-a-well-formed-agentmanifest', 'RFCS/0003-agent-packs.md', 'deep-research MUST request longTerm memory (it persists facts across runs)'),
     ).toBe(true);
   });
 });
@@ -157,27 +159,27 @@ describe.skipIf(SKIP)('core.openwop.agents.deep-research — pack catalog eviden
 describe.skipIf(SKIP)('core.openwop.agents.react — pack catalog evidence', () => {
   it('host pack-list includes react with a well-formed AgentManifest', async () => {
     const pack = await findPack('core.openwop.agents.react');
-    if (pack === null) return;
+    if (pack === null) return softSkip('blocked', 'precondition not met — `pack === null` returned early (seam, prior step, or fixture unavailable)');
     expect(pack.version).toBeDefined();
-    expect(Array.isArray(pack.agents) && pack.agents.length >= 1, 'react ships at least one agent').toBe(true);
-    assertAgentManifestShape(pack.agents![0]!, {
+    expect(Array.isArray(pack.agents) && pack.agents.length >= 1, req('openwop.it.agentPackCatalog.host-pack-list-includes-react-with-a-well-formed-agentmanifest', 'RFCS/0003-agent-packs.md', 'react ships at least one agent')).toBe(true);
+    assertAgentManifestShape('openwop.it.agentPackCatalog.host-pack-list-includes-react-with-a-well-formed-agentmanifest', pack.agents![0]!, {
       agentIdEndsWith: 'react',
     });
     // ReAct pattern requires handoff schemas (task + return).
     const handoff = pack.agents![0]!.handoff;
-    expect(handoff, 'react AgentManifest MUST include a handoff block').toBeDefined();
-    expect(typeof handoff?.taskSchemaRef, 'handoff.taskSchemaRef MUST be a string').toBe('string');
-    expect(typeof handoff?.returnSchemaRef, 'handoff.returnSchemaRef MUST be a string').toBe('string');
+    expect(handoff, req('openwop.it.agentPackCatalog.host-pack-list-includes-react-with-a-well-formed-agentmanifest', 'RFCS/0003-agent-packs.md', 'react AgentManifest MUST include a handoff block')).toBeDefined();
+    expect(typeof handoff?.taskSchemaRef, req('openwop.it.agentPackCatalog.host-pack-list-includes-react-with-a-well-formed-agentmanifest', 'RFCS/0003-agent-packs.md', 'handoff.taskSchemaRef MUST be a string')).toBe('string');
+    expect(typeof handoff?.returnSchemaRef, req('openwop.it.agentPackCatalog.host-pack-list-includes-react-with-a-well-formed-agentmanifest', 'RFCS/0003-agent-packs.md', 'handoff.returnSchemaRef MUST be a string')).toBe('string');
   });
 });
 
 describe.skipIf(SKIP)('core.openwop.agents.supervisor — pack catalog evidence', () => {
   it('host pack-list includes supervisor with a well-formed AgentManifest', async () => {
     const pack = await findPack('core.openwop.agents.supervisor');
-    if (pack === null) return;
+    if (pack === null) return softSkip('blocked', 'precondition not met — `pack === null` returned early (seam, prior step, or fixture unavailable)');
     expect(pack.version).toBeDefined();
-    expect(Array.isArray(pack.agents) && pack.agents.length >= 1, 'supervisor ships at least one agent').toBe(true);
-    assertAgentManifestShape(pack.agents![0]!, {
+    expect(Array.isArray(pack.agents) && pack.agents.length >= 1, req('openwop.it.agentPackCatalog.host-pack-list-includes-supervisor-with-a-well-formed-agentmanifest', 'RFCS/0003-agent-packs.md', 'supervisor ships at least one agent')).toBe(true);
+    assertAgentManifestShape('openwop.it.agentPackCatalog.host-pack-list-includes-supervisor-with-a-well-formed-agentmanifest', pack.agents![0]!, {
       agentIdEndsWith: 'supervisor',
     });
     // Supervisor pattern delegates to crew members; its modelClass should
@@ -185,10 +187,10 @@ describe.skipIf(SKIP)('core.openwop.agents.supervisor — pack catalog evidence'
     const mc = pack.agents![0]!.modelClass;
     expect(
       mc === 'delegate' || mc === 'reasoning',
-      `supervisor SHOULD have modelClass=delegate|reasoning, got "${mc}"`,
+      req('openwop.it.agentPackCatalog.host-pack-list-includes-supervisor-with-a-well-formed-agentmanifest', 'RFCS/0003-agent-packs.md', `supervisor SHOULD have modelClass=delegate|reasoning, got "${mc}"`),
     ).toBe(true);
     // Supervisor needs handoff schemas to dispatch work.
-    expect(pack.agents![0]!.handoff, 'supervisor MUST include handoff schemas').toBeDefined();
+    expect(pack.agents![0]!.handoff, req('openwop.it.agentPackCatalog.host-pack-list-includes-supervisor-with-a-well-formed-agentmanifest', 'RFCS/0003-agent-packs.md', 'supervisor MUST include handoff schemas')).toBeDefined();
   });
 });
 
@@ -207,10 +209,10 @@ describe.skipIf(SKIP)('agent-pack catalog summary', () => {
     // Either none are present (host doesn't ship these — skip) OR all are
     // present (host ships the full reference batch). Half-shipping is a
     // configuration error worth flagging.
-    if (found.length === 0) return;
+    if (found.length === 0) return softSkip('blocked', 'precondition not met — `found.length === 0` returned early (Either none are present (host doesn\'t ship these — skip) OR all are present (host ships the full reference batch). Half-shipping is a configuration error wor…');
     expect(
       found.length,
-      'host SHOULD ship the reference agent packs as a coherent batch (none, or all three)',
+      req('openwop.it.agentPackCatalog.all-three-2026-05-17-reference-agent-packs-are-catalog-reachable', 'RFCS/0003-agent-packs.md', 'host SHOULD ship the reference agent packs as a coherent batch (none, or all three)'),
     ).toBe(names.length);
   });
 });

package/src/scenarios/agentPackExport.test.ts

@@ -18,6 +18,8 @@ import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { isAgentSupported } from '../lib/multi-agent-capabilities.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
 
 const FIXTURE = 'conformance-agent-pack-export';
 const SKIP = !isAgentSupported() || !isFixtureAdvertised(FIXTURE);
@@ -27,9 +29,9 @@ describe.skipIf(SKIP)('agentPackExport: workspace agents project to AgentManifes
     const res = await driver.get('/v1/packs/export');
     if (res.status === 404 || res.status === 501) {
       // Host doesn't expose pack-export over REST; treated as skip.
-      return;
+      return softSkip('blocked', 'precondition not met — `res.status === 404 || res.status === 501` returned early (Host doesn\'t expose pack-export over REST; treated as skip.) (seam, prior step, or fixture unavailable)');
     }
-    expect(res.status).toBe(200);
+    expect(res.status, req('openwop.it.agentPackExport.exported-manifests-contain-required-agentmanifest-fields', 'RFCS/0003-agent-packs.md', 'exported manifests contain required AgentManifest fields')).toBe(200);
 
     const body = res.json as {
       manifests?: Array<{ agentId?: string; modelClass?: string; sourceManifestId?: string }>;

package/src/scenarios/agentPackHandoffSchemaValidation.test.ts

@@ -51,6 +51,7 @@ import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { isAgentSupported, hasHandoffValidation } from '../lib/multi-agent-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const FIXTURE = 'conformance-agent-pack-handoff-schema-validation';
 const SKIP = !isAgentSupported() || !isFixtureAdvertised(FIXTURE);
@@ -82,7 +83,7 @@ describe.skipIf(SKIP)('agentPackHandoffSchemaValidation: handoff schema enforcem
     const runId = (create.json as { runId: string }).runId;
 
     const snap = await settle(runId);
-    expect(snap?.status, 'HV-1a: valid task payload should NOT be rejected by handoff-schema validation').toBe('completed');
+    expect(snap?.status, req('openwop.it.agentPackHandoffSchemaValidation.hv-1a-valid-task-payload-that-matches-taskschemaref-is-dispatched-and-completes', 'RFCS/0003-agent-packs.md §D', 'HV-1a: valid task payload should NOT be rejected by handoff-schema validation')).toBe('completed');
   });
 
   // HV-1b / HV-1c assert a REJECTION, which only a host performing handoff
@@ -101,7 +102,7 @@ describe.skipIf(SKIP)('agentPackHandoffSchemaValidation: handoff schema enforcem
       const snap = await settle(runId, ['completed', 'failed']);
       expect(
         snap?.status,
-        'HV-1b: invalid task payload MUST cause the run to fail rather than silently dispatch off-contract',
+        req('openwop.it.agentPackHandoffSchemaValidation.hv-1b-invalid-task-payload-missing-required-field-fails-before-dispatch-with-a-s', 'RFCS/0003-agent-packs.md §D', 'HV-1b: invalid task payload MUST cause the run to fail rather than silently dispatch off-contract'),
       ).toBe('failed');
 
       const events = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/events`);
@@ -115,7 +116,7 @@ describe.skipIf(SKIP)('agentPackHandoffSchemaValidation: handoff schema enforcem
       );
       expect(
         validationFailure,
-        'HV-1b: failure event payload MUST carry a recognizable handoff-validation error code',
+        req('openwop.it.agentPackHandoffSchemaValidation.hv-1b-invalid-task-payload-missing-required-field-fails-before-dispatch-with-a-s', 'RFCS/0003-agent-packs.md §D', 'HV-1b: failure event payload MUST carry a recognizable handoff-validation error code'),
       ).toBeDefined();
     });
 
@@ -148,7 +149,7 @@ describe.skipIf(SKIP)('agentPackHandoffSchemaValidation: handoff schema enforcem
       );
       expect(
         returnViolation,
-        'HV-1c: off-schema return payload MUST surface a structured violation event before persistence',
+        req('openwop.it.agentPackHandoffSchemaValidation.hv-1c-agent-return-payload-that-fails-returnschemaref-surfaces-a-structured-viol', 'RFCS/0003-agent-packs.md §D', 'HV-1c: off-schema return payload MUST surface a structured violation event before persistence'),
       ).toBeDefined();
     });
   });

package/src/scenarios/agentPackInstall.test.ts

@@ -19,6 +19,8 @@ import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { isAgentSupported } from '../lib/multi-agent-capabilities.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
 
 const FIXTURE = 'conformance-agent-pack-install';
 const SKIP = !isAgentSupported() || !isFixtureAdvertised(FIXTURE);
@@ -32,9 +34,9 @@ describe.skipIf(SKIP)('agentPackInstall: pack agents[] entries surface as AgentM
     if (res.status === 404 || res.status === 501) {
       // Host doesn't expose pack registry over REST; scenario assertion is
       // skipped (capability surface is host-internal).
-      return;
+      return softSkip('blocked', 'precondition not met — `res.status === 404 || res.status === 501` returned early (Host doesn\'t expose pack registry over REST; scenario assertion is skipped (capability surface is host-internal).) (seam, prior step, o…');
     }
-    expect(res.status).toBe(200);
+    expect(res.status, req('openwop.it.agentPackInstall.host-exposes-installed-agent-manifests-with-required-agentmanifest-fields', 'RFCS/0003-agent-packs.md', 'host exposes installed agent manifests with required AgentManifest fields')).toBe(200);
 
     const body = res.json as {
       packs?: Array<{ agents?: Array<{ agentId?: string; modelClass?: string }> }>;

package/src/scenarios/agentPackProvenance.test.ts

@@ -20,6 +20,7 @@ import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { isAgentSupported } from '../lib/multi-agent-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const FIXTURE = 'conformance-agent-pack-provenance';
 const SKIP = !isAgentSupported() || !isFixtureAdvertised(FIXTURE);
@@ -48,7 +49,7 @@ describe.skipIf(SKIP)('agentPackProvenance: sourceManifestId survives install +
     const withProvenance = refs.filter((r) => typeof r.sourceManifestId === 'string');
     expect(
       withProvenance.length,
-      'pack-installed agents MUST surface sourceManifestId on their runtime AgentRef projection',
+      req('openwop.it.agentPackProvenance.run-level-agentref-carries-sourcemanifestid-pointing-back-to-the-install-source', 'RFCS/0003-agent-packs.md', 'pack-installed agents MUST surface sourceManifestId on their runtime AgentRef projection'),
     ).toBeGreaterThan(0);
   });
 });

package/src/scenarios/agentReasoningEvents.test.ts

@@ -22,6 +22,7 @@ import {
   isAgentSupported,
   getReasoningVerbosity,
 } from '../lib/multi-agent-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const FIXTURE = 'conformance-agent-reasoning';
 const SKIP =
@@ -103,7 +104,7 @@ describe.skipIf(SKIP)('agentReasoningEvents: agent.* event family emission', ()
       const matched = calls.find((c) => c.payload?.callId === callId);
       expect(
         matched,
-        `agent.toolReturned.callId=${callId} MUST pair with a prior agent.toolCalled`,
+        req('openwop.it.agentReasoningEvents.host-emits-at-least-one-canonical-agent-event-during-a-reasoning-fixture-run', 'schemas/run-event-payloads.schema.json', `agent.toolReturned.callId=${callId} MUST pair with a prior agent.toolCalled`),
       ).toBeDefined();
 
       // Strict causationId chain — only assert when the host actually
@@ -115,7 +116,7 @@ describe.skipIf(SKIP)('agentReasoningEvents: agent.* event family emission', ()
       if (typeof matchedEventId === 'string' && matchedEventId.length > 0) {
         expect(
           ret.causationId,
-          `agent.toolReturned (callId=${callId}) MUST carry causationId === paired agent.toolCalled.eventId per RFC 0002 §B`,
+          req('openwop.it.agentReasoningEvents.host-emits-at-least-one-canonical-agent-event-during-a-reasoning-fixture-run', 'schemas/run-event-payloads.schema.json', `agent.toolReturned (callId=${callId}) MUST carry causationId === paired agent.toolCalled.eventId per RFC 0002 §B`),
         ).toBe(matchedEventId);
       }
     }