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

package/src/scenarios/agent-capability-degraded-projection.test.ts

@@ -26,9 +26,10 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { readManifestRuntimeCap, listManifestAgents } from '../lib/agentRuntime.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 interface InventoryEntry {
   agentId?: string;
@@ -43,13 +44,13 @@ describe('agent-capability-degraded-projection (RFC 0092 §B)', () => {
     if (!behaviorGate('openwop-agent-capability-degraded', mr?.supported === true)) return;
 
     const inv = await listManifestAgents();
-    if (inv === null) return; // cap advertised but /v1/agents unserved — soft-skip
+    if (inv === null) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `inv === null` returned early (cap advertised but /v1/agents unserved — soft-skip)'); // cap advertised but /v1/agents unserved — soft-skip
     const agents = (inv.agents ?? []) as InventoryEntry[];
 
     // Non-vacuity: an advertising + serving host MUST expose its inventory.
     expect(
       agents.length >= 1,
-      driver.describe('RFC 0072 §A', 'GET /v1/agents MUST return the installed manifest agents'),
+      req('openwop.it.agent-capability-degraded-projection.surfaces-unmet-requirescapabilities-in-degraded-and-nothing-on-the-rest', 'RFC 0072 §A', 'GET /v1/agents MUST return the installed manifest agents'),
     ).toBe(true);
 
     // §B well-formedness on EVERY entry: degraded[], when present, is a unique
@@ -59,18 +60,18 @@ describe('agent-capability-degraded-projection (RFC 0092 §B)', () => {
       if (d !== undefined) {
         expect(
           Array.isArray(d),
-          driver.describe('agent-inventory-response.schema.json', `degraded MUST be an array when present (agent ${a.agentId})`),
+          req('openwop.it.agent-capability-degraded-projection.surfaces-unmet-requirescapabilities-in-degraded-and-nothing-on-the-rest', 'agent-inventory-response.schema.json', `degraded MUST be an array when present (agent ${a.agentId})`),
         ).toBe(true);
         if (Array.isArray(d)) {
           for (const k of d) {
             expect(
               typeof k === 'string' && k.length > 0,
-              driver.describe('RFC 0072 §C', `degraded[] members MUST be non-empty strings (agent ${a.agentId}, got ${String(k)})`),
+              req('openwop.it.agent-capability-degraded-projection.surfaces-unmet-requirescapabilities-in-degraded-and-nothing-on-the-rest', 'RFC 0072 §C', `degraded[] members MUST be non-empty strings (agent ${a.agentId}, got ${String(k)})`),
             ).toBe(true);
           }
           expect(
             new Set(d as string[]).size === d.length,
-            driver.describe('RFC 0092 §B', `degraded[] MUST be unique (agent ${a.agentId})`),
+            req('openwop.it.agent-capability-degraded-projection.surfaces-unmet-requirescapabilities-in-degraded-and-nothing-on-the-rest', 'RFC 0092 §B', `degraded[] MUST be unique (agent ${a.agentId})`),
           ).toBe(true);
         }
       }
@@ -82,23 +83,23 @@ describe('agent-capability-degraded-projection (RFC 0092 §B)', () => {
       const target = agents.find((a) => a.agentId === degradedId);
       expect(
         target !== undefined,
-        driver.describe('RFC 0092 §B', `OPENWOP_DEGRADED_CAPABILITY_AGENT_ID=${degradedId} MUST appear in the inventory`),
+        req('openwop.it.agent-capability-degraded-projection.surfaces-unmet-requirescapabilities-in-degraded-and-nothing-on-the-rest', 'RFC 0092 §B', `OPENWOP_DEGRADED_CAPABILITY_AGENT_ID=${degradedId} MUST appear in the inventory`),
       ).toBe(true);
       if (target) {
         const d = target.degraded;
         expect(
           Array.isArray(d) && d.length >= 1,
-          driver.describe('RFC 0092 §B', 'the named capability-degraded agent MUST carry a non-empty degraded[]'),
+          req('openwop.it.agent-capability-degraded-projection.surfaces-unmet-requirescapabilities-in-degraded-and-nothing-on-the-rest', 'RFC 0092 §B', 'the named capability-degraded agent MUST carry a non-empty degraded[]'),
         ).toBe(true);
         // When the entry also exposes requiresCapabilities, every degraded key
         // MUST be one the agent actually requires (the projection is a subset of
         // requirements, never invented).
         if (Array.isArray(d) && Array.isArray(target.requiresCapabilities)) {
-          const req = new Set(target.requiresCapabilities as unknown[]);
+          const required = new Set(target.requiresCapabilities as unknown[]);
           for (const k of d) {
             expect(
-              req.has(k),
-              driver.describe('RFC 0092 §B', `a degraded[] key MUST be one the agent requires (got ${String(k)})`),
+              required.has(k),
+              req('openwop.it.agent-capability-degraded-projection.surfaces-unmet-requirescapabilities-in-degraded-and-nothing-on-the-rest', 'RFC 0092 §B', `a degraded[] key MUST be one the agent requires (got ${String(k)})`),
             ).toBe(true);
           }
         }

package/src/scenarios/agent-channel-dispatch.test.ts

@@ -43,6 +43,8 @@ import { pollUntilTerminal } from '../lib/polling.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { readDeploymentCap, driveDeploymentTransition } from '../lib/agentDeployment.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const FIXTURE_ID = 'conformance-agent-channel-dispatch';
 const BOUND_CHANNEL = 'stable';
@@ -93,7 +95,7 @@ async function startChannelRun(): Promise<string> {
   const create = await driver.post('/v1/runs', { workflowId: FIXTURE_ID });
   expect(
     create.status,
-    driver.describe(
+    req('openwop.it.agent-channel-dispatch.resolves-records-the-channel-pin-on-a-real-run-and-re-reads-it-on-replay-never-r', 
       'agent-deployment.md §B',
       `a host advertising agents.deployment + the ${FIXTURE_ID} fixture MUST accept a channel-bound run (201)`,
     ),
@@ -111,12 +113,12 @@ describe.skipIf(HTTP_SKIP)('agent-channel-dispatch (RFC 0082 §B): production ru
       // Host advertises agents.deployment but hasn't seeded the channel-bound
       // fixture — a host-config precondition, not a conformance failure.
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(FIXTURE_ID)` returned early');
     }
     const modes = await fetchReplayModes();
     if (!modes.includes('replay')) {
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!modes.includes(\'replay\')` returned early');
     }
 
     // ---- Leg 1: production-path channel resolution + recorded pin (§B) ----
@@ -124,14 +126,14 @@ describe.skipIf(HTTP_SKIP)('agent-channel-dispatch (RFC 0082 §B): production ru
     const started = await firstInvocationStarted(sourceRunId);
     expect(
       started !== null,
-      driver.describe(
+      req('openwop.it.agent-channel-dispatch.resolves-records-the-channel-pin-on-a-real-run-and-re-reads-it-on-replay-never-r', 
         'agent-deployment.md §B',
         'a @channel-bound run MUST emit agent.invocation.started',
       ),
     ).toBe(true);
     expect(
       started!.payload.resolvedChannel,
-      driver.describe(
+      req('openwop.it.agent-channel-dispatch.resolves-records-the-channel-pin-on-a-real-run-and-re-reads-it-on-replay-never-r', 
         'agent-deployment.md §B',
         `agent.invocation.started MUST carry the bound channel as resolvedChannel ("${BOUND_CHANNEL}")`,
       ),
@@ -139,7 +141,7 @@ describe.skipIf(HTTP_SKIP)('agent-channel-dispatch (RFC 0082 §B): production ru
     const pinnedVersion = started!.payload.resolvedAgentVersion;
     expect(
       typeof pinnedVersion === 'string' && (pinnedVersion as string).length > 0,
-      driver.describe(
+      req('openwop.it.agent-channel-dispatch.resolves-records-the-channel-pin-on-a-real-run-and-re-reads-it-on-replay-never-r', 
         'agent-deployment.md §B',
         'a @channel-bound run MUST record a concrete resolvedAgentVersion (the recorded fact a replay re-reads, RFC 0077)',
       ),
@@ -152,22 +154,22 @@ describe.skipIf(HTTP_SKIP)('agent-channel-dispatch (RFC 0082 §B): production ru
     );
     if (forkDeclined(fork1.status, 'channel-dispatch replay fork 1')) {
       ctx.skip();
-      return;
+      return softSkip('blocked', 'precondition not met — `forkDeclined(fork1.status, \'channel-dispatch replay fork 1\')` returned early (seam, prior step, or fixture unavailable)');
     }
     expect(
       fork1.status,
-      driver.describe('rest-endpoints.md POST /v1/runs/{runId}:fork', 'replay fork MUST return 201'),
+      req('openwop.it.agent-channel-dispatch.resolves-records-the-channel-pin-on-a-real-run-and-re-reads-it-on-replay-never-r', 'rest-endpoints.md POST /v1/runs/{runId}:fork', 'replay fork MUST return 201'),
     ).toBe(201);
     const fork1RunId = (fork1.json as { runId: string }).runId;
     await pollUntilTerminal(fork1RunId, { timeoutMs: 15_000 });
     const fork1Started = await firstInvocationStarted(fork1RunId);
     expect(
       fork1Started !== null,
-      driver.describe('agent-deployment.md §B', 'a replay fork MUST re-emit agent.invocation.started'),
+      req('openwop.it.agent-channel-dispatch.resolves-records-the-channel-pin-on-a-real-run-and-re-reads-it-on-replay-never-r', 'agent-deployment.md §B', 'a replay fork MUST re-emit agent.invocation.started'),
     ).toBe(true);
     expect(
       fork1Started!.payload.resolvedAgentVersion,
-      driver.describe(
+      req('openwop.it.agent-channel-dispatch.resolves-records-the-channel-pin-on-a-real-run-and-re-reads-it-on-replay-never-r', 
         'agent-deployment.md §B',
         'a replay MUST re-read the recorded resolvedAgentVersion (NOT re-resolve the channel)',
       ),
@@ -196,7 +198,7 @@ describe.skipIf(HTTP_SKIP)('agent-channel-dispatch (RFC 0082 §B): production ru
       // evidence; the cross-move proof needs the seam. Honest skip of Leg 3.
       // eslint-disable-next-line no-console
       console.warn('[agent-channel-dispatch] deployment seam absent — skipping the channel-move non-re-resolution leg (Leg 3)');
-      return;
+      return softSkip('blocked', 'precondition not met — `moved === null` returned early ([agent-channel-dispatch] deployment seam absent — skipping the channel-move non-re-resolution leg (Leg 3)) (seam, prior step, or fixture unavailable)');
     }
     // Confirm the move is OBSERVABLE: a fresh channel-bound run must now resolve
     // to a DIFFERENT version. If it doesn't (canary split, no-op promote), we
@@ -207,7 +209,7 @@ describe.skipIf(HTTP_SKIP)('agent-channel-dispatch (RFC 0082 §B): production ru
     if (typeof movedVersion !== 'string' || movedVersion === pinnedVersion) {
       // eslint-disable-next-line no-console
       console.warn('[agent-channel-dispatch] channel did not observably move — skipping Leg 3 strict assertion');
-      return;
+      return softSkip('blocked', 'precondition not met — `typeof movedVersion !== \'string\' || movedVersion === pinnedVersion` returned early ([agent-channel-dispatch] channel did not observably move — skipping Leg 3 strict assertion) (seam, prior step…');
     }
     const fork2 = await driver.post(
       `/v1/runs/${encodeURIComponent(sourceRunId)}:fork`,
@@ -215,25 +217,25 @@ describe.skipIf(HTTP_SKIP)('agent-channel-dispatch (RFC 0082 §B): production ru
     );
     if (forkDeclined(fork2.status, 'channel-dispatch replay fork 2')) {
       ctx.skip();
-      return;
+      return softSkip('blocked', 'precondition not met — `forkDeclined(fork2.status, \'channel-dispatch replay fork 2\')` returned early (seam, prior step, or fixture unavailable)');
     }
     expect(
       fork2.status,
-      driver.describe('rest-endpoints.md POST /v1/runs/{runId}:fork', 'replay fork MUST return 201'),
+      req('openwop.it.agent-channel-dispatch.resolves-records-the-channel-pin-on-a-real-run-and-re-reads-it-on-replay-never-r', 'rest-endpoints.md POST /v1/runs/{runId}:fork', 'replay fork MUST return 201'),
     ).toBe(201);
     const fork2RunId = (fork2.json as { runId: string }).runId;
     await pollUntilTerminal(fork2RunId, { timeoutMs: 15_000 });
     const fork2Started = await firstInvocationStarted(fork2RunId);
     expect(
       fork2Started?.payload.resolvedAgentVersion,
-      driver.describe(
+      req('openwop.it.agent-channel-dispatch.resolves-records-the-channel-pin-on-a-real-run-and-re-reads-it-on-replay-never-r', 
         'agent-deployment.md §B',
         'after the channel moves, a replay of the original run MUST still carry the ORIGINAL pin — never re-resolving the moved channel',
       ),
     ).toBe(pinnedVersion);
     expect(
       fork2Started?.payload.resolvedAgentVersion,
-      driver.describe(
+      req('openwop.it.agent-channel-dispatch.resolves-records-the-channel-pin-on-a-real-run-and-re-reads-it-on-replay-never-r', 
         'agent-deployment.md §B',
         'a replay MUST NOT resolve to the post-move version (proves the recorded fact is re-read, not re-resolved)',
       ),

package/src/scenarios/agent-deployment-lifecycle.test.ts

@@ -33,7 +33,6 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
-import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { SCHEMAS_DIR } from '../lib/paths.js';
 import {
@@ -43,6 +42,8 @@ import {
   DEPLOYMENT_CONTENT_FORBIDDEN,
 } from '../lib/agentDeployment.js';
 import { queryTestEvents, requireEvents, isEventLogSeamAvailable, resetTestSeam } from '../lib/event-log-query.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 function loadSchema(name: string): Record<string, unknown> {
   return JSON.parse(readFileSync(join(SCHEMAS_DIR, name), 'utf8')) as Record<string, unknown>;
@@ -52,7 +53,7 @@ function expectContentFree(payload: Record<string, unknown>, where: string): voi
   for (const f of DEPLOYMENT_CONTENT_FORBIDDEN) {
     expect(
       !(f in payload),
-      driver.describe('RFC 0082 §D (deployment-event-no-content-leak)', `${where} MUST be content-free (no ${f})`),
+      req('openwop.it.agent-deployment-lifecycle.promotes-via-the-eval-rbac-approval-gate-fails-closed-without-scope-eval-and-pin', 'RFC 0082 §D (deployment-event-no-content-leak)', `${where} MUST be content-free (no ${f})`),
     ).toBe(true);
   }
 }
@@ -61,7 +62,7 @@ describe('agent-deployment-lifecycle (RFC 0082 §B/§E)', () => {
   it('promotes via the eval+RBAC+approval gate, fails closed without scope/eval, and pins the channel version', async () => {
     const cap = await readDeploymentCap();
     if (!behaviorGate('openwop-deployment-lifecycle', cap?.supported === true)) return;
-    if (!(await isEventLogSeamAvailable())) return; // event-log seam absent — soft-skip
+    if (!(await isEventLogSeamAvailable())) return softSkip('blocked', 'precondition not met — `!(await isEventLogSeamAvailable())` returned early (event-log seam absent — soft-skip) (seam, prior step, or fixture unavailable)'); // event-log seam absent — soft-skip
 
     const ajv = new Ajv2020({ strict: false, allErrors: true });
     addFormats(ajv);
@@ -69,22 +70,22 @@ describe('agent-deployment-lifecycle (RFC 0082 §B/§E)', () => {
 
     // ---- Leg 1: eval+RBAC+approval-gated promotion (§E) ------------------
     const promote = await driveDeploymentTransition({ scenario: 'promote' });
-    if (promote === null) return; // deployment seam unwired — soft-skip the whole behavioral suite
+    if (promote === null) return softSkip('blocked', 'precondition not met — `promote === null` returned early (deployment seam unwired — soft-skip the whole behavioral suite) (seam, prior step, or fixture unavailable)'); // deployment seam unwired — soft-skip the whole behavioral suite
 
     // The host has ADVERTISED agents.deployment AND wired the seam — missing
     // evidence is a FAILURE, not a soft-skip. A successful promote MUST return
     // a runId + a schema-valid record + emit ≥1 content-free deployment.promoted.
     expect(
       typeof promote.runId === 'string' && (promote.runId as string).length > 0,
-      driver.describe('agent-deployment.md §E', 'a wired promote MUST return the runId'),
+      req('openwop.it.agent-deployment-lifecycle.promotes-via-the-eval-rbac-approval-gate-fails-closed-without-scope-eval-and-pin', 'agent-deployment.md §E', 'a wired promote MUST return the runId'),
     ).toBe(true);
     expect(
       promote.record !== undefined && promote.record !== null,
-      driver.describe('agent-deployment.md §E', 'a successful promote MUST return the deployment record'),
+      req('openwop.it.agent-deployment-lifecycle.promotes-via-the-eval-rbac-approval-gate-fails-closed-without-scope-eval-and-pin', 'agent-deployment.md §E', 'a successful promote MUST return the deployment record'),
     ).toBe(true);
     expect(
       validateRecord(promote.record),
-      driver.describe('agent-deployment.schema.json', `a promoted deployment record MUST validate (${ajv.errorsText(validateRecord.errors)})`),
+      req('openwop.it.agent-deployment-lifecycle.promotes-via-the-eval-rbac-approval-gate-fails-closed-without-scope-eval-and-pin', 'agent-deployment.schema.json', `a promoted deployment record MUST validate (${ajv.errorsText(validateRecord.errors)})`),
     ).toBe(true);
 
     const promotedEvents = requireEvents(
@@ -93,17 +94,17 @@ describe('agent-deployment-lifecycle (RFC 0082 §B/§E)', () => {
     );
     expect(
       promotedEvents.length >= 1,
-      driver.describe('agent-deployment.md §E', 'a successful promote MUST emit at least one deployment.promoted'),
+      req('openwop.it.agent-deployment-lifecycle.promotes-via-the-eval-rbac-approval-gate-fails-closed-without-scope-eval-and-pin', 'agent-deployment.md §E', 'a successful promote MUST emit at least one deployment.promoted'),
     ).toBe(true);
     for (const e of promotedEvents) {
       expectContentFree(e.payload, 'deployment.promoted');
       expect(
         typeof e.payload.toState === 'string' && DEPLOYMENT_STATES.includes(e.payload.toState as string),
-        driver.describe('run-event-payloads.schema.json#/$defs/deploymentPromoted', 'toState MUST be in the seven-state vocabulary'),
+        req('openwop.it.agent-deployment-lifecycle.promotes-via-the-eval-rbac-approval-gate-fails-closed-without-scope-eval-and-pin', 'run-event-payloads.schema.json#/$defs/deploymentPromoted', 'toState MUST be in the seven-state vocabulary'),
       ).toBe(true);
       expect(
         typeof e.payload.toVersion === 'string' && (e.payload.toVersion as string).length > 0,
-        driver.describe('agent-deployment.md §D', 'deployment.promoted MUST carry the promoted toVersion'),
+        req('openwop.it.agent-deployment-lifecycle.promotes-via-the-eval-rbac-approval-gate-fails-closed-without-scope-eval-and-pin', 'agent-deployment.md §D', 'deployment.promoted MUST carry the promoted toVersion'),
       ).toBe(true);
     }
 
@@ -111,11 +112,11 @@ describe('agent-deployment-lifecycle (RFC 0082 §B/§E)', () => {
     const unauth = await driveDeploymentTransition({ scenario: 'unauthorized' });
     expect(
       unauth !== null && typeof unauth.runId === 'string' && (unauth.runId as string).length > 0,
-      driver.describe('agent-deployment.md §E-1', 'the unauthorized scenario MUST return a runId to evidence the fail-closed denial'),
+      req('openwop.it.agent-deployment-lifecycle.promotes-via-the-eval-rbac-approval-gate-fails-closed-without-scope-eval-and-pin', 'agent-deployment.md §E-1', 'the unauthorized scenario MUST return a runId to evidence the fail-closed denial'),
     ).toBe(true);
     expect(
       unauth!.allowed !== true,
-      driver.describe('agent-deployment.md §E-1', 'a principal without deploy:promote MUST be denied (fail-closed)'),
+      req('openwop.it.agent-deployment-lifecycle.promotes-via-the-eval-rbac-approval-gate-fails-closed-without-scope-eval-and-pin', 'agent-deployment.md §E-1', 'a principal without deploy:promote MUST be denied (fail-closed)'),
     ).toBe(true);
     const unauthPromoted = requireEvents(
       await queryTestEvents(unauth!.runId as string, { type: 'deployment.promoted' }),
@@ -123,18 +124,18 @@ describe('agent-deployment-lifecycle (RFC 0082 §B/§E)', () => {
     );
     expect(
       unauthPromoted.length === 0,
-      driver.describe('SECURITY invariant deployment-promotion-fail-closed', 'a denied transition MUST emit NO deployment.promoted'),
+      req('openwop.it.agent-deployment-lifecycle.promotes-via-the-eval-rbac-approval-gate-fails-closed-without-scope-eval-and-pin', 'SECURITY invariant deployment-promotion-fail-closed', 'a denied transition MUST emit NO deployment.promoted'),
     ).toBe(true);
 
     // ---- Leg 3: eval-gate-unmet denial (§E-3) ----------------------------
     const evalUnmet = await driveDeploymentTransition({ scenario: 'eval-gate-unmet' });
     expect(
       evalUnmet !== null && typeof evalUnmet.runId === 'string' && (evalUnmet.runId as string).length > 0,
-      driver.describe('agent-deployment.md §E-3', 'the eval-gate-unmet scenario MUST return a runId to evidence the denial'),
+      req('openwop.it.agent-deployment-lifecycle.promotes-via-the-eval-rbac-approval-gate-fails-closed-without-scope-eval-and-pin', 'agent-deployment.md §E-3', 'the eval-gate-unmet scenario MUST return a runId to evidence the denial'),
     ).toBe(true);
     expect(
       evalUnmet!.error === 'eval_gate_unmet' || evalUnmet!.allowed !== true,
-      driver.describe('agent-deployment.md §E-3', 'a promote whose eval evidence has passed:false MUST be denied (eval_gate_unmet)'),
+      req('openwop.it.agent-deployment-lifecycle.promotes-via-the-eval-rbac-approval-gate-fails-closed-without-scope-eval-and-pin', 'agent-deployment.md §E-3', 'a promote whose eval evidence has passed:false MUST be denied (eval_gate_unmet)'),
     ).toBe(true);
     const evalUnmetPromoted = requireEvents(
       await queryTestEvents(evalUnmet!.runId as string, { type: 'deployment.promoted' }),
@@ -142,14 +143,14 @@ describe('agent-deployment-lifecycle (RFC 0082 §B/§E)', () => {
     );
     expect(
       evalUnmetPromoted.length === 0,
-      driver.describe('agent-deployment.md §E-3', 'an unmet eval gate MUST emit NO deployment.promoted'),
+      req('openwop.it.agent-deployment-lifecycle.promotes-via-the-eval-rbac-approval-gate-fails-closed-without-scope-eval-and-pin', 'agent-deployment.md §E-3', 'an unmet eval gate MUST emit NO deployment.promoted'),
     ).toBe(true);
 
     // ---- Leg 4: channel-resolution pin (§B) ------------------------------
     const pin = await driveDeploymentTransition({ scenario: 'channel-pin', channel: 'stable' });
     expect(
       pin !== null && typeof pin.runId === 'string' && (pin.runId as string).length > 0,
-      driver.describe('agent-deployment.md §B', 'the channel-pin scenario MUST return a runId'),
+      req('openwop.it.agent-deployment-lifecycle.promotes-via-the-eval-rbac-approval-gate-fails-closed-without-scope-eval-and-pin', 'agent-deployment.md §B', 'the channel-pin scenario MUST return a runId'),
     ).toBe(true);
     const invEvents = requireEvents(
       await queryTestEvents(pin!.runId as string, { type: 'agent.invocation.started' }),
@@ -157,12 +158,12 @@ describe('agent-deployment-lifecycle (RFC 0082 §B/§E)', () => {
     );
     expect(
       invEvents.length >= 1,
-      driver.describe('agent-deployment.md §B', 'a @channel-bound run MUST emit agent.invocation.started'),
+      req('openwop.it.agent-deployment-lifecycle.promotes-via-the-eval-rbac-approval-gate-fails-closed-without-scope-eval-and-pin', 'agent-deployment.md §B', 'a @channel-bound run MUST emit agent.invocation.started'),
     ).toBe(true);
     const startedInv = invEvents.sort((a, b) => a.sequence - b.sequence)[0]!;
     expect(
       typeof startedInv.payload.resolvedAgentVersion === 'string' && (startedInv.payload.resolvedAgentVersion as string).length > 0,
-      driver.describe('agent-deployment.md §B', 'a @channel-bound run MUST record resolvedAgentVersion on agent.invocation.started (the recorded fact a replay re-reads)'),
+      req('openwop.it.agent-deployment-lifecycle.promotes-via-the-eval-rbac-approval-gate-fails-closed-without-scope-eval-and-pin', 'agent-deployment.md §B', 'a @channel-bound run MUST record resolvedAgentVersion on agent.invocation.started (the recorded fact a replay re-reads)'),
     ).toBe(true);
 
     await resetTestSeam();

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

@@ -38,9 +38,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>;
@@ -51,11 +49,11 @@ describe('agent-deployment-shape: capability advertisement (RFC 0082, server-fre
     const caps = loadSchema('capabilities.schema.json');
     const agents = (caps.properties as Record<string, { properties?: Record<string, { properties?: Record<string, unknown> }> }>).agents;
     const deployment = agents?.properties?.deployment;
-    expect(deployment, why('capabilities.md §agents', 'agents.deployment MUST be declared')).toBeDefined();
+    expect(deployment, req('openwop.it.agent-deployment-shape.the-capabilities-schema-declares-agents-deployment-with-its-sub-flags', 'capabilities.md §agents', 'agents.deployment MUST be declared')).toBeDefined();
     for (const flag of ['supported', 'channels', 'canary', 'rollback', 'states']) {
       expect(
         deployment?.properties?.[flag],
-        why('agent-deployment.md §F', `agents.deployment.${flag} MUST be declared`),
+        req('openwop.it.agent-deployment-shape.the-capabilities-schema-declares-agents-deployment-with-its-sub-flags', 'agent-deployment.md §F', `agents.deployment.${flag} MUST be declared`),
       ).toBeDefined();
     }
   });
@@ -69,16 +67,16 @@ describe('agent-deployment-shape: deployment record + AgentRef binding (RFC 0082
 
   it('AgentDeployment validates a conforming record and rejects a bad state / out-of-range canary', () => {
     const good = { agentId: 'core.openwop.agents.support-resolver', version: '2.4.0', state: 'active', canaryPercent: 10, channels: ['stable'] };
-    expect(record(good), why('RFC 0082 §C', 'a conforming deployment record MUST validate')).toBe(true);
-    expect(record({ ...good, state: 'live' }), why('RFC 0082 §C', 'an out-of-enum state MUST be rejected')).toBe(false);
-    expect(record({ ...good, canaryPercent: 150 }), why('RFC 0082 §C', 'canaryPercent > 100 MUST be rejected')).toBe(false);
+    expect(record(good), req('openwop.it.agent-deployment-shape.agentdeployment-validates-a-conforming-record-and-rejects-a-bad-state-out-of-ran', 'RFC 0082 §C', 'a conforming deployment record MUST validate')).toBe(true);
+    expect(record({ ...good, state: 'live' }), req('openwop.it.agent-deployment-shape.agentdeployment-validates-a-conforming-record-and-rejects-a-bad-state-out-of-ran', 'RFC 0082 §C', 'an out-of-enum state MUST be rejected')).toBe(false);
+    expect(record({ ...good, canaryPercent: 150 }), req('openwop.it.agent-deployment-shape.agentdeployment-validates-a-conforming-record-and-rejects-a-bad-state-out-of-ran', 'RFC 0082 §C', 'canaryPercent > 100 MUST be rejected')).toBe(false);
   });
 
   it('AgentRef channel XOR version: each alone and neither validate; both is rejected (RFC 0082 §A)', () => {
-    expect(agentRef({ agentId: 'core.x.y.z', version: '1.0.0' }), why('RFC 0082 §A', 'version-only AgentRef MUST validate')).toBe(true);
-    expect(agentRef({ agentId: 'core.x.y.z', channel: 'stable' }), why('RFC 0082 §A', 'channel-only AgentRef MUST validate')).toBe(true);
-    expect(agentRef({ agentId: 'core.x.y.z' }), why('RFC 0082 §A', 'a ref with neither version nor channel MUST validate (host default)')).toBe(true);
-    expect(agentRef({ agentId: 'core.x.y.z', version: '1.0.0', channel: 'stable' }), why('RFC 0082 §A', 'a ref with BOTH version and channel MUST be rejected')).toBe(false);
+    expect(agentRef({ agentId: 'core.x.y.z', version: '1.0.0' }), req('openwop.it.agent-deployment-shape.agentref-channel-xor-version-each-alone-and-neither-validate-both-is-rejected-rf', 'RFC 0082 §A', 'version-only AgentRef MUST validate')).toBe(true);
+    expect(agentRef({ agentId: 'core.x.y.z', channel: 'stable' }), req('openwop.it.agent-deployment-shape.agentref-channel-xor-version-each-alone-and-neither-validate-both-is-rejected-rf', 'RFC 0082 §A', 'channel-only AgentRef MUST validate')).toBe(true);
+    expect(agentRef({ agentId: 'core.x.y.z' }), req('openwop.it.agent-deployment-shape.agentref-channel-xor-version-each-alone-and-neither-validate-both-is-rejected-rf', 'RFC 0082 §A', 'a ref with neither version nor channel MUST validate (host default)')).toBe(true);
+    expect(agentRef({ agentId: 'core.x.y.z', version: '1.0.0', channel: 'stable' }), req('openwop.it.agent-deployment-shape.agentref-channel-xor-version-each-alone-and-neither-validate-both-is-rejected-rf', 'RFC 0082 §A', 'a ref with BOTH version and channel MUST be rejected')).toBe(false);
   });
 });
 
@@ -94,29 +92,29 @@ describe('agent-deployment-shape: deployment.* event payloads (RFC 0082, server-
   const stateChanged = ajv.getSchema('payloads#/$defs/deploymentStateChanged');
 
   it('deployment.promoted validates a content-free promotion record and requires toVersion + toState', () => {
-    expect(promoted, 'the deploymentPromoted $def MUST exist').toBeTruthy();
+    expect(promoted, req('openwop.it.agent-deployment-shape.deployment-promoted-validates-a-content-free-promotion-record-and-requires-tover', 'RFC 0082', 'the deploymentPromoted $def MUST exist')).toBeTruthy();
     expect(
       promoted!({ agentId: 'core.openwop.agents.support-resolver', toVersion: '2.4.0', toState: 'active', channel: 'stable', canaryPercent: 10, evalRunId: 'run_abc' }),
-      why('RFC 0082 §D', 'a conforming deployment.promoted payload MUST validate'),
+      req('openwop.it.agent-deployment-shape.deployment-promoted-validates-a-content-free-promotion-record-and-requires-tover', 'RFC 0082 §D', 'a conforming deployment.promoted payload MUST validate'),
     ).toBe(true);
-    expect(promoted!({ agentId: 'a' }), why('RFC 0082 §D', 'deployment.promoted without toVersion/toState MUST be rejected')).toBe(false);
+    expect(promoted!({ agentId: 'a' }), req('openwop.it.agent-deployment-shape.deployment-promoted-validates-a-content-free-promotion-record-and-requires-tover', 'RFC 0082 §D', 'deployment.promoted without toVersion/toState MUST be rejected')).toBe(false);
   });
 
   it('deployment.rolled-back / canary.adjusted / state.changed validate conforming records', () => {
-    expect(rolledBack!({ agentId: 'a', fromVersion: '2.4.0', toVersion: '2.3.1', rollbackPointer: '2.3.1' }), why('RFC 0082 §D', 'a conforming deployment.rolled-back MUST validate')).toBe(true);
-    expect(canary!({ agentId: 'a', version: '2.4.0', fromPercent: 10, toPercent: 50 }), why('RFC 0082 §D', 'a conforming deployment.canary.adjusted MUST validate')).toBe(true);
-    expect(stateChanged!({ agentId: 'a', version: '2.4.0', fromState: 'active', toState: 'paused' }), why('RFC 0082 §D', 'a conforming deployment.state.changed MUST validate')).toBe(true);
-    expect(stateChanged!({ agentId: 'a', version: '2.4.0', fromState: 'active', toState: 'live' }), why('RFC 0082 §D', 'an out-of-enum toState MUST be rejected')).toBe(false);
+    expect(rolledBack!({ agentId: 'a', fromVersion: '2.4.0', toVersion: '2.3.1', rollbackPointer: '2.3.1' }), req('openwop.it.agent-deployment-shape.deployment-rolled-back-canary-adjusted-state-changed-validate-conforming-records', 'RFC 0082 §D', 'a conforming deployment.rolled-back MUST validate')).toBe(true);
+    expect(canary!({ agentId: 'a', version: '2.4.0', fromPercent: 10, toPercent: 50 }), req('openwop.it.agent-deployment-shape.deployment-rolled-back-canary-adjusted-state-changed-validate-conforming-records', 'RFC 0082 §D', 'a conforming deployment.canary.adjusted MUST validate')).toBe(true);
+    expect(stateChanged!({ agentId: 'a', version: '2.4.0', fromState: 'active', toState: 'paused' }), req('openwop.it.agent-deployment-shape.deployment-rolled-back-canary-adjusted-state-changed-validate-conforming-records', 'RFC 0082 §D', 'a conforming deployment.state.changed MUST validate')).toBe(true);
+    expect(stateChanged!({ agentId: 'a', version: '2.4.0', fromState: 'active', toState: 'live' }), req('openwop.it.agent-deployment-shape.deployment-rolled-back-canary-adjusted-state-changed-validate-conforming-records', 'RFC 0082 §D', 'an out-of-enum toState MUST be rejected')).toBe(false);
   });
 
   it('deployment.* events are content-free — a manifest body and a prompt are rejected (deployment-event-no-content-leak)', () => {
     expect(
       promoted!({ agentId: 'a', toVersion: '2.4.0', toState: 'active', manifestBody: '{...}' }),
-      why('SECURITY invariant deployment-event-no-content-leak', 'a deployment.promoted MUST NOT carry a manifest body'),
+      req('openwop.it.agent-deployment-shape.deployment-events-are-content-free-a-manifest-body-and-a-prompt-are-rejected-dep', 'SECURITY invariant deployment-event-no-content-leak', 'a deployment.promoted MUST NOT carry a manifest body'),
     ).toBe(false);
     expect(
       stateChanged!({ agentId: 'a', version: '2.4.0', fromState: 'active', toState: 'paused', prompt: 'system: …' }),
-      why('SECURITY invariant deployment-event-no-content-leak', 'a deployment.state.changed MUST NOT carry prompt content'),
+      req('openwop.it.agent-deployment-shape.deployment-events-are-content-free-a-manifest-body-and-a-prompt-are-rejected-dep', 'SECURITY invariant deployment-event-no-content-leak', 'a deployment.state.changed MUST NOT carry prompt content'),
     ).toBe(false);
   });
 });
@@ -125,15 +123,15 @@ describe('agent-deployment-shape: §B recorded-fact pin + enum (RFC 0082, server
   it('agent.invocation.started carries the additive recorded-fact resolvedAgentVersion / resolvedChannel', () => {
     const payloads = loadSchema('run-event-payloads.schema.json');
     const started = ((payloads.$defs as Record<string, { properties?: Record<string, unknown> }>).agentInvocationStarted)?.properties ?? {};
-    expect(started.resolvedAgentVersion, why('RFC 0082 §B', 'agent.invocation.started.resolvedAgentVersion MUST be declared (the channel pin)')).toBeDefined();
-    expect(started.resolvedChannel, why('RFC 0082 §B', 'agent.invocation.started.resolvedChannel MUST be declared')).toBeDefined();
+    expect(started.resolvedAgentVersion, req('openwop.it.agent-deployment-shape.agent-invocation-started-carries-the-additive-recorded-fact-resolvedagentversion', 'RFC 0082 §B', 'agent.invocation.started.resolvedAgentVersion MUST be declared (the channel pin)')).toBeDefined();
+    expect(started.resolvedChannel, req('openwop.it.agent-deployment-shape.agent-invocation-started-carries-the-additive-recorded-fact-resolvedagentversion', 'RFC 0082 §B', 'agent.invocation.started.resolvedChannel MUST be declared')).toBeDefined();
   });
 
   it('all four deployment 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 ?? [];
     for (const e of ['deployment.promoted', 'deployment.rolled-back', 'deployment.canary.adjusted', 'deployment.state.changed']) {
-      expect(enumVals).toContain(e);
+      expect(enumVals, req('openwop.it.agent-deployment-shape.all-four-deployment-event-names-appear-in-the-runeventtype-enum', 'RFC 0082', 'all four deployment event names appear in the RunEventType enum')).toContain(e);
     }
   });
 });

package/src/scenarios/agent-eval-run.test.ts

@@ -29,7 +29,6 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
-import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { SCHEMAS_DIR } from '../lib/paths.js';
 import {
@@ -39,6 +38,8 @@ import {
   EVAL_CONTENT_FORBIDDEN,
 } from '../lib/agentEval.js';
 import { queryTestEvents, requireEvents, isEventLogSeamAvailable, resetTestSeam } from '../lib/event-log-query.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 function loadSchema(name: string): Record<string, unknown> {
   return JSON.parse(readFileSync(join(SCHEMAS_DIR, name), 'utf8')) as Record<string, unknown>;
@@ -48,7 +49,7 @@ function expectContentFree(payload: Record<string, unknown>, where: string): voi
   for (const f of EVAL_CONTENT_FORBIDDEN) {
     expect(
       !(f in payload),
-      driver.describe('RFC 0081 §C (eval-summary-no-content-leak)', `${where} MUST be content-free (no ${f})`),
+      req('openwop.it.agent-eval-run.emits-eval-started-per-task-eval-scored-eval-completed-and-serves-a-content-free', 'RFC 0081 §C (eval-summary-no-content-leak)', `${where} MUST be content-free (no ${f})`),
     ).toBe(true);
   }
 }
@@ -57,10 +58,10 @@ describe('agent-eval-run (RFC 0081 §B/§C)', () => {
   it('emits eval.started → per-task eval.scored → eval.completed and serves a content-free EvalSummary', async () => {
     const cap = await readEvalSuiteCap();
     if (!behaviorGate('openwop-eval-run', cap?.supported === true)) return;
-    if (!(await isEventLogSeamAvailable())) return; // event-log seam absent — soft-skip
+    if (!(await isEventLogSeamAvailable())) return softSkip('blocked', 'precondition not met — `!(await isEventLogSeamAvailable())` returned early (event-log seam absent — soft-skip) (seam, prior step, or fixture unavailable)'); // event-log seam absent — soft-skip
 
     const run = await driveEvalRun({ modes: ['golden'] });
-    if (run === null) return; // eval-run seam unwired — soft-skip the whole behavioral suite
+    if (run === null) return softSkip('blocked', 'precondition not met — `run === null` returned early (eval-run seam unwired — soft-skip the whole behavioral suite) (seam, prior step, or fixture unavailable)'); // eval-run seam unwired — soft-skip the whole behavioral suite
 
     // From here the host has ADVERTISED agents.evalSuite AND wired the eval-run
     // seam — missing evidence is a FAILURE, not a soft-skip. A host claiming the
@@ -68,7 +69,7 @@ describe('agent-eval-run (RFC 0081 §B/§C)', () => {
     // normative EvalSummary, or it is advertising a capability it doesn't deliver.
     expect(
       typeof run.runId === 'string' && run.runId.length > 0,
-      driver.describe('agent-evaluation.md §B', 'a wired eval-run seam MUST return the projected runId'),
+      req('openwop.it.agent-eval-run.emits-eval-started-per-task-eval-scored-eval-completed-and-serves-a-content-free', 'agent-evaluation.md §B', 'a wired eval-run seam MUST return the projected runId'),
     ).toBe(true);
     const runId = run.runId as string;
 
@@ -87,15 +88,15 @@ describe('agent-eval-run (RFC 0081 §B/§C)', () => {
     // ≥1 eval.scored — a wired eval run MUST emit the full sequence.
     expect(
       startedEvents.length === 1,
-      driver.describe('agent-evaluation.md §C', 'an eval run MUST emit exactly one eval.started'),
+      req('openwop.it.agent-eval-run.emits-eval-started-per-task-eval-scored-eval-completed-and-serves-a-content-free', 'agent-evaluation.md §C', 'an eval run MUST emit exactly one eval.started'),
     ).toBe(true);
     expect(
       scoredEvents.length >= 1,
-      driver.describe('agent-evaluation.md §C', 'an eval run MUST emit at least one eval.scored'),
+      req('openwop.it.agent-eval-run.emits-eval-started-per-task-eval-scored-eval-completed-and-serves-a-content-free', 'agent-evaluation.md §C', 'an eval run MUST emit at least one eval.scored'),
     ).toBe(true);
     expect(
       completedEvents.length === 1,
-      driver.describe('agent-evaluation.md §C', 'an eval run MUST emit exactly one eval.completed'),
+      req('openwop.it.agent-eval-run.emits-eval-started-per-task-eval-scored-eval-completed-and-serves-a-content-free', 'agent-evaluation.md §C', 'an eval run MUST emit exactly one eval.completed'),
     ).toBe(true);
     const started = startedEvents[0]!;
     const completed = completedEvents[0]!;
@@ -104,22 +105,22 @@ describe('agent-eval-run (RFC 0081 §B/§C)', () => {
     for (const s of scoredEvents) {
       expect(
         started.sequence < s.sequence,
-        driver.describe('agent-evaluation.md §C', 'eval.started MUST precede every eval.scored'),
+        req('openwop.it.agent-eval-run.emits-eval-started-per-task-eval-scored-eval-completed-and-serves-a-content-free', 'agent-evaluation.md §C', 'eval.started MUST precede every eval.scored'),
       ).toBe(true);
       expect(
         s.sequence < completed.sequence,
-        driver.describe('agent-evaluation.md §C', 'every eval.scored MUST precede eval.completed'),
+        req('openwop.it.agent-eval-run.emits-eval-started-per-task-eval-scored-eval-completed-and-serves-a-content-free', 'agent-evaluation.md §C', 'every eval.scored MUST precede eval.completed'),
       ).toBe(true);
     }
 
     // One eval.scored per task (count == eval.completed.taskCount).
     expect(
       typeof completed.payload.taskCount === 'number',
-      driver.describe('run-event-payloads.schema.json#/$defs/evalCompleted', 'eval.completed MUST carry a numeric taskCount'),
+      req('openwop.it.agent-eval-run.emits-eval-started-per-task-eval-scored-eval-completed-and-serves-a-content-free', 'run-event-payloads.schema.json#/$defs/evalCompleted', 'eval.completed MUST carry a numeric taskCount'),
     ).toBe(true);
     expect(
       scoredEvents.length === completed.payload.taskCount,
-      driver.describe('agent-evaluation.md §C', 'one eval.scored per task (count == eval.completed.taskCount)'),
+      req('openwop.it.agent-eval-run.emits-eval-started-per-task-eval-scored-eval-completed-and-serves-a-content-free', 'agent-evaluation.md §C', 'one eval.scored per task (count == eval.completed.taskCount)'),
     ).toBe(true);
 
     // Content-free (§C / eval-summary-no-content-leak) + score ∈ 0..1, passed boolean.
@@ -129,11 +130,11 @@ describe('agent-eval-run (RFC 0081 §B/§C)', () => {
       expectContentFree(s.payload, 'eval.scored');
       expect(
         typeof s.payload.score === 'number' && (s.payload.score as number) >= 0 && (s.payload.score as number) <= 1,
-        driver.describe('run-event-payloads.schema.json#/$defs/evalScored', 'eval.scored.score MUST be in 0..1'),
+        req('openwop.it.agent-eval-run.emits-eval-started-per-task-eval-scored-eval-completed-and-serves-a-content-free', 'run-event-payloads.schema.json#/$defs/evalScored', 'eval.scored.score MUST be in 0..1'),
       ).toBe(true);
       expect(
         typeof s.payload.passed === 'boolean',
-        driver.describe('run-event-payloads.schema.json#/$defs/evalScored', 'eval.scored.passed MUST be a boolean'),
+        req('openwop.it.agent-eval-run.emits-eval-started-per-task-eval-scored-eval-completed-and-serves-a-content-free', 'run-event-payloads.schema.json#/$defs/evalScored', 'eval.scored.passed MUST be a boolean'),
       ).toBe(true);
     }
 
@@ -141,7 +142,7 @@ describe('agent-eval-run (RFC 0081 §B/§C)', () => {
     const { status, summary } = await getEvalSummary(runId);
     expect(
       status === 200 && summary !== undefined,
-      driver.describe('agent-evaluation.md §C', `GET /v1/runs/{runId}/eval-summary MUST serve a 200 EvalSummary for a completed eval run (got ${status})`),
+      req('openwop.it.agent-eval-run.emits-eval-started-per-task-eval-scored-eval-completed-and-serves-a-content-free', 'agent-evaluation.md §C', `GET /v1/runs/{runId}/eval-summary MUST serve a 200 EvalSummary for a completed eval run (got ${status})`),
     ).toBe(true);
     const sum = summary as Record<string, unknown>;
     const ajv = new Ajv2020({ strict: false, allErrors: true });
@@ -149,7 +150,7 @@ describe('agent-eval-run (RFC 0081 §B/§C)', () => {
     const validate = ajv.compile(loadSchema('eval-summary.schema.json'));
     expect(
       validate(sum),
-      driver.describe('eval-summary.schema.json', `EvalSummary MUST be schema-valid (${ajv.errorsText(validate.errors)})`),
+      req('openwop.it.agent-eval-run.emits-eval-started-per-task-eval-scored-eval-completed-and-serves-a-content-free', 'eval-summary.schema.json', `EvalSummary MUST be schema-valid (${ajv.errorsText(validate.errors)})`),
     ).toBe(true);
 
     const tasks = (sum.tasks as Array<Record<string, unknown>> | undefined) ?? [];
@@ -157,11 +158,11 @@ describe('agent-eval-run (RFC 0081 §B/§C)', () => {
     const taskCount = sum.taskCount as number | undefined;
     expect(
       typeof passedCount === 'number' && typeof taskCount === 'number',
-      driver.describe('eval-summary.schema.json', 'EvalSummary MUST carry numeric passedCount + taskCount'),
+      req('openwop.it.agent-eval-run.emits-eval-started-per-task-eval-scored-eval-completed-and-serves-a-content-free', 'eval-summary.schema.json', 'EvalSummary MUST carry numeric passedCount + taskCount'),
     ).toBe(true);
     expect(
       (passedCount as number) <= (taskCount as number),
-      driver.describe('agent-evaluation.md §C', 'EvalSummary.passedCount MUST NOT exceed taskCount'),
+      req('openwop.it.agent-eval-run.emits-eval-started-per-task-eval-scored-eval-completed-and-serves-a-content-free', 'agent-evaluation.md §C', 'EvalSummary.passedCount MUST NOT exceed taskCount'),
     ).toBe(true);
     for (const t of tasks) {
       expectContentFree(t, 'EvalSummary.tasks[]');