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

package/src/scenarios/agent-manifest-runtime.test.ts

@@ -15,34 +15,35 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { driver } from '../lib/driver.js';
 import { readManifestRuntimeCap, listManifestAgents, dispatchAgent } from '../lib/agentRuntime.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 describe('agent-manifest-runtime (RFC 0070)', () => {
   it('lists installed manifest agents and dispatches one with attributed events', async () => {
     const cap = await readManifestRuntimeCap();
-    if (cap?.supported !== true) return; // unadvertised — soft-skip
+    if (cap?.supported !== true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `cap?.supported !== true` returned early (unadvertised — soft-skip)'); // unadvertised — soft-skip
 
     // RFC 0074 §B — installScope governs how GET /v1/agents is scoped.
     const installScope = typeof cap.installScope === 'string' ? cap.installScope : 'host';
     expect(
       installScope === 'host' || installScope === 'tenant',
-      driver.describe('RFC 0074 §B', "agents.manifestRuntime.installScope (when present) MUST be 'host' or 'tenant'"),
+      req('openwop.it.agent-manifest-runtime.lists-installed-manifest-agents-and-dispatches-one-with-attributed-events', 'RFC 0074 §B', "agents.manifestRuntime.installScope (when present) MUST be 'host' or 'tenant'"),
     ).toBe(true);
 
     const inv = await listManifestAgents();
-    if (inv === null) return; // seam absent — soft-skip
+    if (inv === null) return softSkip('blocked', 'precondition not met — `inv === null` returned early (seam absent — soft-skip) (seam, prior step, or fixture unavailable)'); // seam absent — soft-skip
     const agents = inv.agents ?? [];
     expect(
       Array.isArray(agents),
-      driver.describe('RFC 0072 §A', 'GET /v1/agents MUST return an agents[] array'),
+      req('openwop.it.agent-manifest-runtime.lists-installed-manifest-agents-and-dispatches-one-with-attributed-events', 'RFC 0072 §A', 'GET /v1/agents MUST return an agents[] array'),
     ).toBe(true);
 
     if (installScope === 'host') {
       // Host-global inventory (RFC 0072 §A): a manifestRuntime host MUST surface ≥1 agent.
       expect(
         agents.length > 0,
-        driver.describe('RFC 0070 §A', 'a host-scoped manifestRuntime host MUST surface ≥1 installed manifest agent'),
+        req('openwop.it.agent-manifest-runtime.lists-installed-manifest-agents-and-dispatches-one-with-attributed-events', 'RFC 0070 §A', 'a host-scoped manifestRuntime host MUST surface ≥1 installed manifest agent'),
       ).toBe(true);
     } else if (agents.length === 0) {
       // RFC 0074 §A + Unresolved Q3 — tenant-scoped: GET /v1/agents is the
@@ -51,28 +52,28 @@ describe('agent-manifest-runtime (RFC 0070)', () => {
       // Empty is conformant; the cross-tenant no-disclosure 404 is covered by the
       // owner-triple isolation harness (RFC 0048/0059), not re-probed here. Nothing
       // to dispatch.
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `agents.length === 0` returned early (RFC 0074 §A + Unresolved Q3 — tenant-scoped: GET /v1/agents is the authenticated principal\'s workspace set, which MAY be e…');
     }
 
     const agentId = agents[0]?.agentId;
-    if (typeof agentId !== 'string') return;
+    if (typeof agentId !== 'string') return softSkip('blocked', 'precondition not met — `typeof agentId !== \'string\'` returned early (seam, prior step, or fixture unavailable)');
 
     // Opaque-payload dispatch (validateHandoff:false) so the assertion is
     // independent of the chosen agent's handoff schema.
     const res = await dispatchAgent(agentId, { task: {}, validateHandoff: false, availableTools: [] });
-    if (res === null) return; // seam absent — soft-skip
+    if (res === null) return softSkip('blocked', 'precondition not met — `res === null` returned early (seam absent — soft-skip) (seam, prior step, or fixture unavailable)'); // seam absent — soft-skip
     expect(
       res.status === 'completed' || res.status === 'escalated',
-      driver.describe('RFC 0070', 'dispatch MUST resolve to a terminal status (completed | escalated)'),
+      req('openwop.it.agent-manifest-runtime.lists-installed-manifest-agents-and-dispatches-one-with-attributed-events', 'RFC 0070', 'dispatch MUST resolve to a terminal status (completed | escalated)'),
     ).toBe(true);
     const types = (res.events ?? []).map((e) => e.type);
     expect(
       types.includes('agent.reasoned') && types.includes('agent.decided'),
-      driver.describe('RFC 0002 §A', 'dispatch MUST emit attributed agent.reasoned + agent.decided events'),
+      req('openwop.it.agent-manifest-runtime.lists-installed-manifest-agents-and-dispatches-one-with-attributed-events', 'RFC 0002 §A', 'dispatch MUST emit attributed agent.reasoned + agent.decided events'),
     ).toBe(true);
     expect(
       (res.events ?? []).every((e) => e.agentId === agentId),
-      driver.describe('RFC 0002 §A', 'every emitted agent.* event MUST carry the dispatched agentId'),
+      req('openwop.it.agent-manifest-runtime.lists-installed-manifest-agents-and-dispatches-one-with-attributed-events', 'RFC 0002 §A', 'every emitted agent.* event MUST carry the dispatched agentId'),
     ).toBe(true);
   });
 

package/src/scenarios/agent-org-chart-scoping.test.ts

@@ -29,9 +29,10 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { readOrgChartCap, getOrgChart, getDepartmentView } from '../lib/agentOrgChart.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const ROSTER_ID_RE = /^host:[a-z0-9][a-z0-9._-]*$/;
 
@@ -43,17 +44,17 @@ describe('agent-org-chart-scoping (RFC 0087 §A/§C/§D)', () => {
     const installScope = typeof cap?.installScope === 'string' ? cap.installScope : 'tenant';
     expect(
       installScope === 'host' || installScope === 'tenant',
-      driver.describe('RFC 0087 §E / RFC 0074', "agents.orgChart.installScope (when present) MUST be 'host' or 'tenant'"),
+      req('openwop.it.agent-org-chart-scoping.serves-the-normative-org-chart-responsibility-roll-up-tree-shaped-and-tenant-sco', 'RFC 0087 §E / RFC 0074', "agents.orgChart.installScope (when present) MUST be 'host' or 'tenant'"),
     ).toBe(true);
 
     // ---- Leg 1: normative read (black-box) -------------------------------
     const chart = await getOrgChart();
-    if (chart === null) return; // advertised but read not served yet — soft-skip
+    if (chart === null) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `chart === null` returned early (advertised but read not served yet — soft-skip)'); // advertised but read not served yet — soft-skip
     const departments = chart.departments ?? [];
     const members = chart.members ?? [];
     expect(
       Array.isArray(departments) && Array.isArray(members),
-      driver.describe('agent-org-chart.schema.json', 'GET /v1/agents/org-chart MUST return departments[] + members[]'),
+      req('openwop.it.agent-org-chart-scoping.serves-the-normative-org-chart-responsibility-roll-up-tree-shaped-and-tenant-sco', 'agent-org-chart.schema.json', 'GET /v1/agents/org-chart MUST return departments[] + members[]'),
     ).toBe(true);
 
     const deptIds = new Set(departments.map((d) => d.departmentId).filter((x): x is string => typeof x === 'string'));
@@ -62,7 +63,7 @@ describe('agent-org-chart-scoping (RFC 0087 §A/§C/§D)', () => {
       if (parent !== undefined && parent !== null) {
         expect(
           deptIds.has(parent),
-          driver.describe('agent-org-chart.md §A', 'every parentDepartmentId MUST resolve to a department in the chart (a tree)'),
+          req('openwop.it.agent-org-chart-scoping.serves-the-normative-org-chart-responsibility-roll-up-tree-shaped-and-tenant-sco', 'agent-org-chart.md §A', 'every parentDepartmentId MUST resolve to a department in the chart (a tree)'),
         ).toBe(true);
       }
     }
@@ -79,18 +80,18 @@ describe('agent-org-chart-scoping (RFC 0087 §A/§C/§D)', () => {
       }
       expect(
         steps <= departments.length,
-        driver.describe('agent-org-chart.md §A', 'the department parent graph MUST be acyclic'),
+        req('openwop.it.agent-org-chart-scoping.serves-the-normative-org-chart-responsibility-roll-up-tree-shaped-and-tenant-sco', 'agent-org-chart.md §A', 'the department parent graph MUST be acyclic'),
       ).toBe(true);
     }
     for (const m of members) {
       expect(
         typeof m.rosterId === 'string' && ROSTER_ID_RE.test(m.rosterId),
-        driver.describe('agent-org-chart.md §A', 'each member MUST reference a roster entry (host:<id> rosterId)'),
+        req('openwop.it.agent-org-chart-scoping.serves-the-normative-org-chart-responsibility-roll-up-tree-shaped-and-tenant-sco', 'agent-org-chart.md §A', 'each member MUST reference a roster entry (host:<id> rosterId)'),
       ).toBe(true);
       if (typeof m.departmentId === 'string') {
         expect(
           deptIds.size === 0 || deptIds.has(m.departmentId),
-          driver.describe('agent-org-chart.md §A', "a member's departmentId MUST be a department in the chart"),
+          req('openwop.it.agent-org-chart-scoping.serves-the-normative-org-chart-responsibility-roll-up-tree-shaped-and-tenant-sco', 'agent-org-chart.md §A', "a member's departmentId MUST be a department in the chart"),
         ).toBe(true);
       }
     }
@@ -102,23 +103,23 @@ describe('agent-org-chart-scoping (RFC 0087 §A/§C/§D)', () => {
       if (status === 200 && view) {
         expect(
           Array.isArray(view.responsibilities),
-          driver.describe('agent-org-chart.md §D', 'the responsibility view MUST carry a responsibilities[] roll-up'),
+          req('openwop.it.agent-org-chart-scoping.serves-the-normative-org-chart-responsibility-roll-up-tree-shaped-and-tenant-sco', 'agent-org-chart.md §D', 'the responsibility view MUST carry a responsibilities[] roll-up'),
         ).toBe(true);
         const r = view.responsibilities ?? [];
         expect(
           r.length === new Set(r).size,
-          driver.describe('agent-org-chart.md §D', 'responsibilities MUST be a deduped union (no duplicate workflow ids)'),
+          req('openwop.it.agent-org-chart-scoping.serves-the-normative-org-chart-responsibility-roll-up-tree-shaped-and-tenant-sco', 'agent-org-chart.md §D', 'responsibilities MUST be a deduped union (no duplicate workflow ids)'),
         ).toBe(true);
         expect(
           r.every((w) => typeof w === 'string'),
-          driver.describe('org-chart-responsibility-view.schema.json', 'responsibilities[] entries MUST be workflow-id strings'),
+          req('openwop.it.agent-org-chart-scoping.serves-the-normative-org-chart-responsibility-roll-up-tree-shaped-and-tenant-sco', 'org-chart-responsibility-view.schema.json', 'responsibilities[] entries MUST be workflow-id strings'),
         ).toBe(true);
         // recursive=false MUST keep the response shape (a subset roll-up).
         const direct = await getDepartmentView(probeDeptId, false);
         if (direct.status === 200 && direct.view) {
           expect(
             Array.isArray(direct.view.responsibilities),
-            driver.describe('agent-org-chart.md §D', 'recursive=false MUST return the same shape, scoped to direct members'),
+            req('openwop.it.agent-org-chart-scoping.serves-the-normative-org-chart-responsibility-roll-up-tree-shaped-and-tenant-sco', 'agent-org-chart.md §D', 'recursive=false MUST return the same shape, scoped to direct members'),
           ).toBe(true);
         }
       }
@@ -130,7 +131,7 @@ describe('agent-org-chart-scoping (RFC 0087 §A/§C/§D)', () => {
       const probe = await getDepartmentView(crossTenantDept);
       expect(
         probe.status === 404,
-        driver.describe('agent-org-chart.md §C / RFC 0074', 'GET /v1/agents/org-chart/{id} for a cross-tenant department MUST 404 (no cross-tenant disclosure)'),
+        req('openwop.it.agent-org-chart-scoping.serves-the-normative-org-chart-responsibility-roll-up-tree-shaped-and-tenant-sco', 'agent-org-chart.md §C / RFC 0074', 'GET /v1/agents/org-chart/{id} for a cross-tenant department MUST 404 (no cross-tenant disclosure)'),
       ).toBe(true);
     }
   });

package/src/scenarios/agent-org-chart-shape.test.ts

@@ -32,9 +32,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>;
@@ -64,9 +62,9 @@ describe('agent-org-chart-shape: capability advertisement (RFC 0087, server-free
     const caps = loadSchema('capabilities.schema.json');
     const agents = (caps.properties as Record<string, { properties?: Record<string, { properties?: Record<string, unknown> }> }>).agents;
     const orgChart = agents?.properties?.orgChart;
-    expect(orgChart, why('capabilities.md §agents', 'agents.orgChart MUST be declared')).toBeDefined();
+    expect(orgChart, req('openwop.it.agent-org-chart-shape.the-capabilities-schema-declares-agents-orgchart-with-its-sub-flags', 'capabilities.md §agents', 'agents.orgChart MUST be declared')).toBeDefined();
     for (const flag of ['supported', 'installScope', 'departmentNesting', 'responsibilityView']) {
-      expect(orgChart?.properties?.[flag], why('agent-org-chart.md §E', `agents.orgChart.${flag} MUST be declared`)).toBeDefined();
+      expect(orgChart?.properties?.[flag], req('openwop.it.agent-org-chart-shape.the-capabilities-schema-declares-agents-orgchart-with-its-sub-flags', 'agent-org-chart.md §E', `agents.orgChart.${flag} MUST be declared`)).toBeDefined();
     }
   });
 });
@@ -77,13 +75,13 @@ describe('agent-org-chart-shape: chart record (RFC 0087 §A, server-free)', () =
   const chart = ajv.compile(loadSchema('agent-org-chart.schema.json'));
 
   it('AgentOrgChart validates a conforming chart', () => {
-    expect(chart(CHART), why('RFC 0087 §A', 'a conforming org-chart MUST validate')).toBe(true);
+    expect(chart(CHART), req('openwop.it.agent-org-chart-shape.agentorgchart-validates-a-conforming-chart', 'RFC 0087 §A', 'a conforming org-chart MUST validate')).toBe(true);
   });
 
   it('rejects a non-host: member rosterId and a chart missing required arrays', () => {
     const badMember = { ...CHART, members: [{ rosterId: 'core.openwop.agents.sally', departmentId: 'dept-marketing', roleId: 'role-bw', reportsTo: null }] };
-    expect(chart(badMember), why('RFC 0087 §A', 'a non-`host:` member rosterId MUST be rejected')).toBe(false);
-    expect(chart({ owner: { tenantId: 'acme' }, departments: [] }), why('RFC 0087 §A', 'a chart without `members` MUST be rejected')).toBe(false);
+    expect(chart(badMember), req('openwop.it.agent-org-chart-shape.rejects-a-non-host-member-rosterid-and-a-chart-missing-required-arrays', 'RFC 0087 §A', 'a non-`host:` member rosterId MUST be rejected')).toBe(false);
+    expect(chart({ owner: { tenantId: 'acme' }, departments: [] }), req('openwop.it.agent-org-chart-shape.rejects-a-non-host-member-rosterid-and-a-chart-missing-required-arrays', 'RFC 0087 §A', 'a chart without `members` MUST be rejected')).toBe(false);
   });
 });
 
@@ -100,14 +98,14 @@ describe('agent-org-chart-shape: §B non-authority guarantee (RFC 0087, server-f
       };
       expect(
         chart(withAuthority),
-        why('SECURITY invariant org-position-no-authority-escalation', `a member carrying \`${authorityField}\` MUST be rejected (additionalProperties:false — position confers no authority)`),
+        req('openwop.it.agent-org-chart-shape.the-schema-rejects-an-authority-bearing-field-on-a-member-org-position-no-author', 'SECURITY invariant org-position-no-authority-escalation', `a member carrying \`${authorityField}\` MUST be rejected (additionalProperties:false — position confers no authority)`),
       ).toBe(false);
     }
   });
 
   it('a conforming member object carries exactly the descriptive key set — nothing authority-bearing', () => {
     const memberKeys = Object.keys(CHART.members[1]!).sort();
-    expect(memberKeys, why('RFC 0087 §B', 'a member is descriptive only: {departmentId, reportsTo, roleId, rosterId}')).toEqual(['departmentId', 'reportsTo', 'roleId', 'rosterId']);
+    expect(memberKeys, req('openwop.it.agent-org-chart-shape.a-conforming-member-object-carries-exactly-the-descriptive-key-set-nothing-autho', 'RFC 0087 §B', 'a member is descriptive only: {departmentId, reportsTo, roleId, rosterId}')).toEqual(['departmentId', 'reportsTo', 'roleId', 'rosterId']);
   });
 
   it('the GET /v1/agents/org-chart/{departmentId} responsibility-view response validates (RFC 0087 §D)', () => {
@@ -120,8 +118,8 @@ describe('agent-org-chart-shape: §B non-authority guarantee (RFC 0087, server-f
       members: CHART.members,
       responsibilities: ['marketing-email-campaign', 'social-post-scheduler'],
     };
-    expect(view(good), why('RFC 0087 §D', 'a conforming responsibility-view response MUST validate')).toBe(true);
-    expect(view({ ...good, unexpected: true }), why('RFC 0087 §D', 'an extra top-level property MUST be rejected')).toBe(false);
-    expect(view({ department: CHART.departments[0], members: CHART.members }), why('RFC 0087 §D', '`responsibilities` is required')).toBe(false);
+    expect(view(good), req('openwop.it.agent-org-chart-shape.the-get-v1-agents-org-chart-departmentid-responsibility-view-response-validates', 'RFC 0087 §D', 'a conforming responsibility-view response MUST validate')).toBe(true);
+    expect(view({ ...good, unexpected: true }), req('openwop.it.agent-org-chart-shape.the-get-v1-agents-org-chart-departmentid-responsibility-view-response-validates', 'RFC 0087 §D', 'an extra top-level property MUST be rejected')).toBe(false);
+    expect(view({ department: CHART.departments[0], members: CHART.members }), req('openwop.it.agent-org-chart-shape.the-get-v1-agents-org-chart-departmentid-responsibility-view-response-validates', 'RFC 0087 §D', '`responsibilities` is required')).toBe(false);
   });
 });

package/src/scenarios/agent-platform-aggregate-evidence.test.ts

@@ -29,6 +29,7 @@ import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { isAgentPlatformPartial, isAgentPlatformFull, agentPlatformStatus, agentPlatformSatisfiedTerms } from '../lib/profiles.js';
+import { req } from '../lib/requirement-ids.js';
 
 describe('agent-platform-aggregate-evidence (RFC 0085 §C)', () => {
   it('a host claiming openwop-agent-platform satisfies the §B floor on live discovery; full when the operator certifies full', async () => {
@@ -43,13 +44,13 @@ describe('agent-platform-aggregate-evidence (RFC 0085 §C)', () => {
     // the profile string alone.
     expect(
       isAgentPlatformPartial(disco!),
-      driver.describe('agent-platform-profile.md §C', 'claiming openwop-agent-platform MUST satisfy the §B floor predicate on live discovery (claim backed by per-capability evidence)'),
+      req('openwop.it.agent-platform-aggregate-evidence.a-host-claiming-openwop-agent-platform-satisfies-the-b-floor-on-live-discovery-f', 'agent-platform-profile.md §C', 'claiming openwop-agent-platform MUST satisfy the §B floor predicate on live discovery (claim backed by per-capability evidence)'),
     ).toBe(true);
 
     const status = agentPlatformStatus(disco!);
     expect(
       status === 'partial' || status === 'full',
-      driver.describe('agent-platform-profile.md §D', 'a claimed openwop-agent-platform host MUST derive to partial or full, never none'),
+      req('openwop.it.agent-platform-aggregate-evidence.a-host-claiming-openwop-agent-platform-satisfies-the-b-floor-on-live-discovery-f', 'agent-platform-profile.md §D', 'a claimed openwop-agent-platform host MUST derive to partial or full, never none'),
     ).toBe(true);
 
     // Non-vacuous FULL bar: when the operator declares the cert tier `full`,
@@ -57,11 +58,11 @@ describe('agent-platform-aggregate-evidence (RFC 0085 §C)', () => {
     if (process.env.OPENWOP_AGENT_PLATFORM_TIER === 'full') {
       expect(
         isAgentPlatformFull(disco!),
-        driver.describe('agent-platform-profile.md §B/§D', 'a host certifying `full` MUST satisfy every governance term: authorization + tenant installScope + memory.attribution + debugBundle + triggerBridge + httpClient.egressPolicy'),
+        req('openwop.it.agent-platform-aggregate-evidence.a-host-claiming-openwop-agent-platform-satisfies-the-b-floor-on-live-discovery-f', 'agent-platform-profile.md §B/§D', 'a host certifying `full` MUST satisfy every governance term: authorization + tenant installScope + memory.attribution + debugBundle + triggerBridge + httpClient.egressPolicy'),
       ).toBe(true);
       expect(
         agentPlatformSatisfiedTerms(disco!).length,
-        driver.describe('agent-platform-profile.md §D', 'a host certifying `full` satisfies all 16 §D terms'),
+        req('openwop.it.agent-platform-aggregate-evidence.a-host-claiming-openwop-agent-platform-satisfies-the-b-floor-on-live-discovery-f', 'agent-platform-profile.md §D', 'a host certifying `full` satisfies all 16 §D terms'),
       ).toBe(16);
     }
   });

package/src/scenarios/agent-platform-profile.test.ts

@@ -29,8 +29,7 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { SCHEMAS_DIR } from '../lib/paths.js';
 import { isAgentPlatformPartial, isAgentPlatformFull, agentPlatformStatus, agentPlatformSatisfiedTerms } from '../lib/profiles.js';
-
-const why = (specRef: string, requirement: string): string => `${specRef} — ${requirement}`;
+import { req } from '../lib/requirement-ids.js';
 
 const CORE = {
   protocolVersion: '1.0',
@@ -59,24 +58,24 @@ function floorPayload(extra: Record<string, unknown> = {}): Record<string, unkno
 describe('agent-platform-profile: floor (partial) predicate (RFC 0085 §B, server-free)', () => {
   it('a host meeting all floor flags is partial', () => {
     const c = floorPayload();
-    expect(isAgentPlatformPartial(c), why('agent-platform-profile.md §B', 'all floor flags ⇒ partial')).toBe(true);
-    expect(agentPlatformStatus(c)).toBe('partial');
+    expect(isAgentPlatformPartial(c), req('openwop.it.agent-platform-profile.a-host-meeting-all-floor-flags-is-partial', 'agent-platform-profile.md §B', 'all floor flags ⇒ partial')).toBe(true);
+    expect(agentPlatformStatus(c), req('openwop.it.agent-platform-profile.a-host-meeting-all-floor-flags-is-partial', 'RFC 0085', 'a host meeting all floor flags is partial')).toBe('partial');
   });
 
   it('missing a single floor flag (feedback) ⇒ none', () => {
     const c = floorPayload({ feedback: { supported: false } });
-    expect(isAgentPlatformPartial(c), why('agent-platform-profile.md §B', 'a missing floor flag ⇒ not partial')).toBe(false);
-    expect(agentPlatformStatus(c)).toBe('none');
+    expect(isAgentPlatformPartial(c), req('openwop.it.agent-platform-profile.missing-a-single-floor-flag-feedback-none', 'agent-platform-profile.md §B', 'a missing floor flag ⇒ not partial')).toBe(false);
+    expect(agentPlatformStatus(c), req('openwop.it.agent-platform-profile.missing-a-single-floor-flag-feedback-none', 'RFC 0085', 'missing a single floor flag (feedback) ⇒ none')).toBe('none');
   });
 
   it('replay-OR-nondeterminism: no replay but declared nondeterminism still meets the floor', () => {
     const c = floorPayload({ replay: { supported: false }, nondeterminismPolicy: { declared: true } });
-    expect(isAgentPlatformPartial(c), why('agent-platform-profile.md §B', 'declared nondeterminism satisfies the replay-OR term')).toBe(true);
+    expect(isAgentPlatformPartial(c), req('openwop.it.agent-platform-profile.replay-or-nondeterminism-no-replay-but-declared-nondeterminism-still-meets-the-f', 'agent-platform-profile.md §B', 'declared nondeterminism satisfies the replay-OR term')).toBe(true);
   });
 
   it('neither replay nor declared nondeterminism ⇒ floor unmet', () => {
     const c = floorPayload({ replay: { supported: false } });
-    expect(isAgentPlatformPartial(c), why('agent-platform-profile.md §B', 'neither replay nor declared policy ⇒ not partial')).toBe(false);
+    expect(isAgentPlatformPartial(c), req('openwop.it.agent-platform-profile.neither-replay-nor-declared-nondeterminism-floor-unmet', 'agent-platform-profile.md §B', 'neither replay nor declared policy ⇒ not partial')).toBe(false);
   });
 });
 
@@ -92,8 +91,8 @@ describe('agent-platform-profile: full predicate + honest-advertisement (RFC 008
 
   it('a host meeting floor + all governance terms is full', () => {
     const c = floorPayload(fullExtra);
-    expect(isAgentPlatformFull(c), why('agent-platform-profile.md §B', 'floor + governance ⇒ full')).toBe(true);
-    expect(agentPlatformStatus(c)).toBe('full');
+    expect(isAgentPlatformFull(c), req('openwop.it.agent-platform-profile.a-host-meeting-floor-all-governance-terms-is-full', 'agent-platform-profile.md §B', 'floor + governance ⇒ full')).toBe(true);
+    expect(agentPlatformStatus(c), req('openwop.it.agent-platform-profile.a-host-meeting-floor-all-governance-terms-is-full', 'RFC 0085', 'a host meeting floor + all governance terms is full')).toBe('full');
   });
 
   it('a host advertising governance flags but missing tenant installScope reports partial, not full', () => {
@@ -101,13 +100,13 @@ describe('agent-platform-profile: full predicate + honest-advertisement (RFC 008
       ...fullExtra,
       agents: { manifestRuntime: { supported: true, installScope: 'host' }, liveRuntime: { supported: true } },
     });
-    expect(isAgentPlatformFull(c), why('agent-platform-profile.md §D', 'missing a governance term ⇒ MUST NOT be full')).toBe(false);
-    expect(agentPlatformStatus(c)).toBe('partial');
+    expect(isAgentPlatformFull(c), req('openwop.it.agent-platform-profile.a-host-advertising-governance-flags-but-missing-tenant-installscope-reports-part', 'agent-platform-profile.md §D', 'missing a governance term ⇒ MUST NOT be full')).toBe(false);
+    expect(agentPlatformStatus(c), req('openwop.it.agent-platform-profile.a-host-advertising-governance-flags-but-missing-tenant-installscope-reports-part', 'RFC 0085', 'a host advertising governance flags but missing tenant installScope reports partial, not full')).toBe('partial');
   });
 
   it('eval/deploy/budget are NOT hard full terms (a full host without them is still full)', () => {
     const c = floorPayload(fullExtra); // no agents.evalSuite / agents.deployment / budget
-    expect(isAgentPlatformFull(c), why('agent-platform-profile.md §B', 'platform-plus tier is advisory, not a hard full term')).toBe(true);
+    expect(isAgentPlatformFull(c), req('openwop.it.agent-platform-profile.eval-deploy-budget-are-not-hard-full-terms-a-full-host-without-them-is-still-ful', 'agent-platform-profile.md §B', 'platform-plus tier is advisory, not a hard full term')).toBe(true);
   });
 });
 
@@ -126,12 +125,12 @@ describe('agent-platform-profile: satisfiedTerms[] non-contiguous adoption (RFC
       feedback: { supported: true },
       replay: { supported: true },
     } as Record<string, unknown>;
-    expect(agentPlatformStatus(c), why('agent-platform-profile.md §D', 'floor unmet ⇒ none')).toBe('none');
+    expect(agentPlatformStatus(c), req('openwop.it.agent-platform-profile.a-host-honoring-full-tier-terms-but-failing-floor-terms-is-status-none-yet-has-a', 'agent-platform-profile.md §D', 'floor unmet ⇒ none')).toBe('none');
     const terms = agentPlatformSatisfiedTerms(c);
-    expect(terms.includes('full:authorization'), why('§D', 'a satisfied full term is reported even at none')).toBe(true);
-    expect(terms.includes('full:memory.attribution')).toBe(true);
+    expect(terms.includes('full:authorization'), req('openwop.it.agent-platform-profile.a-host-honoring-full-tier-terms-but-failing-floor-terms-is-status-none-yet-has-a', '§D', 'a satisfied full term is reported even at none')).toBe(true);
+    expect(terms.includes('full:memory.attribution'), req('openwop.it.agent-platform-profile.a-host-honoring-full-tier-terms-but-failing-floor-terms-is-status-none-yet-has-a', 'RFC 0085', 'a host honoring full-tier terms but failing floor terms is status none yet has a non-empty satisfiedTerms[]')).toBe(true);
     expect(terms.includes('full:tenant-installScope')).toBe(true);
-    expect(terms.includes('floor:agents.liveRuntime'), why('§D', 'an unmet floor term is NOT reported')).toBe(false);
+    expect(terms.includes('floor:agents.liveRuntime'), req('openwop.it.agent-platform-profile.a-host-honoring-full-tier-terms-but-failing-floor-terms-is-status-none-yet-has-a', '§D', 'an unmet floor term is NOT reported')).toBe(false);
     expect(terms.length).toBeGreaterThan(0); // distinguishable from a 0/16 do-nothing host
   });
 
@@ -144,7 +143,7 @@ describe('agent-platform-profile: satisfiedTerms[] non-contiguous adoption (RFC
       triggerBridge: { supported: true },
       httpClient: { safeFetch: { supported: true }, egressPolicy: { supported: true } },
     });
-    expect(agentPlatformSatisfiedTerms(c).length, why('§D', 'a full host satisfies all 16 terms')).toBe(16);
+    expect(agentPlatformSatisfiedTerms(c).length, req('openwop.it.agent-platform-profile.a-full-host-reports-all-sixteen-terms-satisfied', '§D', 'a full host satisfies all 16 terms')).toBe(16);
   });
 });
 
@@ -153,7 +152,7 @@ describe('agent-platform-profile: capability shape (RFC 0085, server-free)', ()
     const caps = JSON.parse(readFileSync(join(SCHEMAS_DIR, 'capabilities.schema.json'), 'utf8')) as { properties?: Record<string, { properties?: Record<string, unknown> }> };
     expect(
       caps.properties?.nondeterminismPolicy?.properties?.declared,
-      why('agent-platform-profile.md §B', 'capabilities.nondeterminismPolicy.declared MUST be declared'),
+      req('openwop.it.agent-platform-profile.capabilities-nondeterminismpolicy-declared-is-declared', 'agent-platform-profile.md §B', 'capabilities.nondeterminismPolicy.declared MUST be declared'),
     ).toBeDefined();
   });
 });

package/src/scenarios/agent-requires-capabilities-shape.test.ts

@@ -21,9 +21,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>;
 }
@@ -47,18 +47,18 @@ describe('agent-requires-capabilities-shape: AgentManifest.requiresCapabilities
   it('a manifest WITH requiresCapabilities validates', () => {
     expect(
       manifest({ ...base, requiresCapabilities: ['host.workspace', 'aiProviders.toolCalling'] }),
-      why('RFC 0092 §A', 'a manifest declaring requiresCapabilities MUST validate'),
+      req('openwop.it.agent-requires-capabilities-shape.a-manifest-with-requirescapabilities-validates', 'RFC 0092 §A', 'a manifest declaring requiresCapabilities MUST validate'),
     ).toBe(true);
   });
 
   it('a manifest WITHOUT it still validates (absent ⇒ no requirements)', () => {
-    expect(manifest(base), why('RFC 0092 §A', 'requiresCapabilities is optional')).toBe(true);
+    expect(manifest(base), req('openwop.it.agent-requires-capabilities-shape.a-manifest-without-it-still-validates-absent-no-requirements', 'RFC 0092 §A', 'requiresCapabilities is optional')).toBe(true);
   });
 
   it('rejects a non-string-array value', () => {
     expect(
       manifest({ ...base, requiresCapabilities: [123] }),
-      why('RFC 0092 §A', 'requiresCapabilities items MUST be non-empty strings'),
+      req('openwop.it.agent-requires-capabilities-shape.rejects-a-non-string-array-value', 'RFC 0092 §A', 'requiresCapabilities items MUST be non-empty strings'),
     ).toBe(false);
   });
 });

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

@@ -34,7 +34,6 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { readRosterCap, listRoster, getRosterEntry, fireRosterPortfolio } from '../lib/agentRoster.js';
 import {
@@ -43,6 +42,8 @@ import {
   resetTestSeam,
   type TestEvent,
 } from '../lib/event-log-query.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const ROSTER_ID_RE = /^host:[a-z0-9][a-z0-9._-]*$/;
 
@@ -62,42 +63,42 @@ describe('agent-roster-attribution (RFC 0086 §B/§C)', () => {
     const installScope = typeof cap?.installScope === 'string' ? cap.installScope : 'host';
     expect(
       installScope === 'host' || installScope === 'tenant',
-      driver.describe('RFC 0086 §F / RFC 0074 §B', "agents.roster.installScope (when present) MUST be 'host' or 'tenant'"),
+      req('openwop.it.agent-roster-attribution.serves-the-normative-roster-attributes-a-portfolio-fire-content-free-ordered-and', 'RFC 0086 §F / RFC 0074 §B', "agents.roster.installScope (when present) MUST be 'host' or 'tenant'"),
     ).toBe(true);
 
     // ---- Leg 1: normative read (black-box on any roster host) -------------
     const body = await listRoster();
-    if (body === null) return; // host advertises roster but doesn't serve the read yet — soft-skip
+    if (body === null) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `body === null` returned early (host advertises roster but doesn\'t serve the read yet — soft-skip)'); // host advertises roster but doesn't serve the read yet — soft-skip
     const roster = body.roster ?? [];
     expect(
       Array.isArray(roster),
-      driver.describe('agent-roster.md §B', 'GET /v1/agents/roster MUST return a roster[] array'),
+      req('openwop.it.agent-roster-attribution.serves-the-normative-roster-attributes-a-portfolio-fire-content-free-ordered-and', 'agent-roster.md §B', 'GET /v1/agents/roster MUST return a roster[] array'),
     ).toBe(true);
     expect(
       body.total === roster.length,
-      driver.describe('agent-roster-response.schema.json', 'total MUST equal roster.length'),
+      req('openwop.it.agent-roster-attribution.serves-the-normative-roster-attributes-a-portfolio-fire-content-free-ordered-and', 'agent-roster-response.schema.json', 'total MUST equal roster.length'),
     ).toBe(true);
     for (const entry of roster) {
       expect(
         typeof entry.rosterId === 'string' && ROSTER_ID_RE.test(entry.rosterId),
-        driver.describe('agent-roster-entry.schema.json', 'each entry MUST carry a host:<id> rosterId'),
+        req('openwop.it.agent-roster-attribution.serves-the-normative-roster-attributes-a-portfolio-fire-content-free-ordered-and', 'agent-roster-entry.schema.json', 'each entry MUST carry a host:<id> rosterId'),
       ).toBe(true);
       expect(
         typeof entry.persona === 'string' && entry.persona.length > 0,
-        driver.describe('agent-roster.md §A', 'each entry MUST carry a non-empty persona'),
+        req('openwop.it.agent-roster-attribution.serves-the-normative-roster-attributes-a-portfolio-fire-content-free-ordered-and', 'agent-roster.md §A', 'each entry MUST carry a non-empty persona'),
       ).toBe(true);
       expect(
         typeof entry.agentRef?.agentId === 'string',
-        driver.describe('agent-roster.md §A', 'each entry MUST reference an agentRef.agentId'),
+        req('openwop.it.agent-roster-attribution.serves-the-normative-roster-attributes-a-portfolio-fire-content-free-ordered-and', 'agent-roster.md §A', 'each entry MUST reference an agentRef.agentId'),
       ).toBe(true);
       expect(
         typeof entry.owner?.tenantId === 'string',
-        driver.describe('agent-roster.md §B / RFC 0074', 'each entry MUST carry an owner.tenantId scope'),
+        req('openwop.it.agent-roster-attribution.serves-the-normative-roster-attributes-a-portfolio-fire-content-free-ordered-and', 'agent-roster.md §B / RFC 0074', 'each entry MUST carry an owner.tenantId scope'),
       ).toBe(true);
       // RFC 0082 §A XOR: an agentRef MUST NOT pin both version and channel.
       expect(
         !(entry.agentRef?.version !== undefined && entry.agentRef?.channel !== undefined),
-        driver.describe('RFC 0082 §A', 'agentRef MUST NOT carry both version and channel'),
+        req('openwop.it.agent-roster-attribution.serves-the-normative-roster-attributes-a-portfolio-fire-content-free-ordered-and', 'RFC 0082 §A', 'agentRef MUST NOT carry both version and channel'),
       ).toBe(true);
     }
 
@@ -111,7 +112,7 @@ describe('agent-roster-attribution (RFC 0086 §B/§C)', () => {
           const init = firstOf(q.events, ['roster.run.initiated']);
           expect(
             init !== undefined,
-            driver.describe('agent-roster.md §C', 'a portfolio fire MUST emit roster.run.initiated'),
+            req('openwop.it.agent-roster-attribution.serves-the-normative-roster-attributes-a-portfolio-fire-content-free-ordered-and', 'agent-roster.md §C', 'a portfolio fire MUST emit roster.run.initiated'),
           ).toBe(true);
 
           if (init) {
@@ -124,7 +125,7 @@ describe('agent-roster-attribution (RFC 0086 §B/§C)', () => {
             if (firstAgent) {
               expect(
                 init.sequence < firstAgent.sequence,
-                driver.describe('agent-roster.md §C', 'roster.run.initiated MUST precede any agent.* event in the run'),
+                req('openwop.it.agent-roster-attribution.serves-the-normative-roster-attributes-a-portfolio-fire-content-free-ordered-and', 'agent-roster.md §C', 'roster.run.initiated MUST precede any agent.* event in the run'),
               ).toBe(true);
             }
 
@@ -133,18 +134,18 @@ describe('agent-roster-attribution (RFC 0086 §B/§C)', () => {
             for (const key of ['rosterId', 'persona', 'agentId', 'workflowId', 'triggerSource']) {
               expect(
                 typeof p[key] === 'string' && (p[key] as string).length > 0,
-                driver.describe('run-event-payloads.schema.json#rosterRunInitiated', `roster.run.initiated MUST carry ${key}`),
+                req('openwop.it.agent-roster-attribution.serves-the-normative-roster-attributes-a-portfolio-fire-content-free-ordered-and', 'run-event-payloads.schema.json#rosterRunInitiated', `roster.run.initiated MUST carry ${key}`),
               ).toBe(true);
             }
             for (const forbidden of ['body', 'prompt', 'input', 'payload', 'apiKey', 'secret', 'credentials', 'token']) {
               expect(
                 !(forbidden in p),
-                driver.describe('SECURITY roster-attribution-no-content', `roster.run.initiated MUST be content-free (no ${forbidden})`),
+                req('openwop.it.agent-roster-attribution.serves-the-normative-roster-attributes-a-portfolio-fire-content-free-ordered-and', 'SECURITY roster-attribution-no-content', `roster.run.initiated MUST be content-free (no ${forbidden})`),
               ).toBe(true);
             }
             expect(
               typeof p.rosterId === 'string' && ROSTER_ID_RE.test(p.rosterId),
-              driver.describe('agent-roster.md §C', 'roster.run.initiated.rosterId MUST be a host:<id> AgentRef id'),
+              req('openwop.it.agent-roster-attribution.serves-the-normative-roster-attributes-a-portfolio-fire-content-free-ordered-and', 'agent-roster.md §C', 'roster.run.initiated.rosterId MUST be a host:<id> AgentRef id'),
             ).toBe(true);
           }
         }
@@ -158,7 +159,7 @@ describe('agent-roster-attribution (RFC 0086 §B/§C)', () => {
           const p = q.events[0].payload;
           expect(
             typeof p.triggerSubscriptionId === 'string' && (p.triggerSubscriptionId as string).length > 0,
-            driver.describe('agent-roster.md §D / RFC 0083', 'a durable work-item fire MUST carry triggerSubscriptionId for trigger→run→roster ancestry'),
+            req('openwop.it.agent-roster-attribution.serves-the-normative-roster-attributes-a-portfolio-fire-content-free-ordered-and', 'agent-roster.md §D / RFC 0083', 'a durable work-item fire MUST carry triggerSubscriptionId for trigger→run→roster ancestry'),
           ).toBe(true);
         }
       }
@@ -172,7 +173,7 @@ describe('agent-roster-attribution (RFC 0086 §B/§C)', () => {
       const probe = await getRosterEntry(crossTenantId);
       expect(
         probe.status === 404,
-        driver.describe('agent-roster.md §B / RFC 0074', "GET /v1/agents/roster/{id} for a cross-tenant id MUST 404 (no cross-tenant disclosure)"),
+        req('openwop.it.agent-roster-attribution.serves-the-normative-roster-attributes-a-portfolio-fire-content-free-ordered-and', 'agent-roster.md §B / RFC 0074', "GET /v1/agents/roster/{id} for a cross-tenant id MUST 404 (no cross-tenant disclosure)"),
       ).toBe(true);
     }
   });