@openwop/openwop-conformance 1.163.0 → 2.0.0-rc.1

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);
       }
     }

package/src/scenarios/agentReasoningStreaming.test.ts

@@ -29,6 +29,7 @@ import {
   isReasoningStreamingSupported,
   getReasoningVerbosity,
 } from '../lib/multi-agent-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const FIXTURE = 'conformance-agent-reasoning-streaming';
 /** Expected concatenation of the fixture's `streamChunks` — kept in sync
@@ -64,14 +65,14 @@ describe.skipIf(SKIP)('agentReasoningStreaming: RFC 0024 incremental + closing e
 
     expect(
       deltas.length,
-      driver.describe(
+      req('openwop.it.agentReasoningStreaming.emits-n-agent-reasoning-delta-events-followed-by-exactly-one-closing-agent-reaso', 
         'RFCS/0024-agent-reasoning-streaming.md §Proposal',
         'streaming host MUST emit one agent.reasoning.delta per streamChunks entry',
       ),
     ).toBe(EXPECTED_CHUNKS.length);
     expect(
       finals.length,
-      driver.describe(
+      req('openwop.it.agentReasoningStreaming.emits-n-agent-reasoning-delta-events-followed-by-exactly-one-closing-agent-reaso', 
         'RFCS/0024-agent-reasoning-streaming.md §Proposal',
         'streaming host MUST emit exactly one closing agent.reasoned event after the deltas',
       ),
@@ -95,7 +96,7 @@ describe.skipIf(SKIP)('agentReasoningStreaming: RFC 0024 incremental + closing e
 
     expect(
       sequences,
-      driver.describe(
+      req('openwop.it.agentReasoningStreaming.agent-reasoning-delta-sequence-starts-at-0-and-increments-by-1-within-the-block', 
         'RFCS/0024-agent-reasoning-streaming.md §Proposal',
         '`sequence` MUST start at 0 and increment by 1 per delta within a block',
       ),
@@ -113,15 +114,15 @@ describe.skipIf(SKIP)('agentReasoningStreaming: RFC 0024 incremental + closing e
     const list = (events.json as { events: Array<{ type: string; payload?: Record<string, unknown> }> }).events;
 
     const finalEvent = list.find((e) => e.type === 'agent.reasoned');
-    expect(finalEvent, 'closing agent.reasoned must be present').toBeDefined();
+    expect(finalEvent, req('openwop.it.agentReasoningStreaming.closing-agent-reasoned-reasoning-is-the-concatenation-of-the-deltas-authoritativ', 'RFCS/0024-agent-reasoning-streaming.md §Proposal', 'closing agent.reasoned must be present')).toBeDefined();
     const reasoning = finalEvent?.payload?.reasoning;
-    expect(typeof reasoning, 'closing event MUST carry a reasoning string').toBe('string');
+    expect(typeof reasoning, req('openwop.it.agentReasoningStreaming.closing-agent-reasoned-reasoning-is-the-concatenation-of-the-deltas-authoritativ', 'RFCS/0024-agent-reasoning-streaming.md §Proposal', 'closing event MUST carry a reasoning string')).toBe('string');
     // The mock-agent's contract: closing reasoning equals concat(streamChunks).
     // Real hosts MAY transform at finalize (summary truncation, redaction);
     // for the mock-agent fixture, no transform applies — exact equality.
     expect(
       reasoning,
-      driver.describe(
+      req('openwop.it.agentReasoningStreaming.closing-agent-reasoned-reasoning-is-the-concatenation-of-the-deltas-authoritativ', 
         'RFCS/0024-agent-reasoning-streaming.md §Proposal',
         'closing agent.reasoned.reasoning is authoritative; for the mock-agent fixture, equals delta concatenation',
       ),
@@ -149,7 +150,7 @@ describe.skipIf(SKIP)('agentReasoningStreaming: RFC 0024 incremental + closing e
 
     expect(
       agentIds.size,
-      driver.describe(
+      req('openwop.it.agentReasoningStreaming.agentid-is-consistent-across-all-streaming-closing-events-in-a-block', 
         'RFCS/0024-agent-reasoning-streaming.md §Proposal',
         'agentId MUST be consistent across all `agent.reasoning.delta` events AND the closing `agent.reasoned` for a given block',
       ),
@@ -168,7 +169,7 @@ describe.skipIf(SKIP)('agentReasoningStreaming: RFC 0024 incremental + closing e
     const arr = Array.isArray(list) ? list : list.events;
 
     const closingIdx = arr.findIndex((e) => e.type === 'agent.reasoned');
-    expect(closingIdx, 'closing event present').toBeGreaterThan(-1);
+    expect(closingIdx, req('openwop.it.agentReasoningStreaming.all-agent-reasoning-delta-events-arrive-before-the-closing-agent-reasoned', 'RFCS/0024-agent-reasoning-streaming.md §Proposal', 'closing event present')).toBeGreaterThan(-1);
     const lastDeltaIdx = arr.map((e) => e.type).lastIndexOf('agent.reasoning.delta');
 
     // Guard against vacuous pass: a host advertising streaming but
@@ -177,14 +178,14 @@ describe.skipIf(SKIP)('agentReasoningStreaming: RFC 0024 incremental + closing e
     // one delta MUST appear in the event log.
     expect(
       lastDeltaIdx,
-      driver.describe(
+      req('openwop.it.agentReasoningStreaming.all-agent-reasoning-delta-events-arrive-before-the-closing-agent-reasoned', 
         'RFCS/0024-agent-reasoning-streaming.md §Proposal',
         'streaming host MUST emit at least one `agent.reasoning.delta` for a fixture with non-empty `streamChunks`',
       ),
     ).toBeGreaterThan(-1);
     expect(
       lastDeltaIdx,
-      driver.describe(
+      req('openwop.it.agentReasoningStreaming.all-agent-reasoning-delta-events-arrive-before-the-closing-agent-reasoned', 
         'RFCS/0024-agent-reasoning-streaming.md §Proposal',
         'every `agent.reasoning.delta` MUST precede the closing `agent.reasoned` for the same block',
       ),

package/src/scenarios/agents-run-tool-allowlist.test.ts

@@ -36,6 +36,8 @@ import { describe, it, expect, beforeAll } from 'vitest';
 import { existsSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PACK_PATH = resolve(__dirname, '../../../packs/core.openwop.agents/index.mjs');
@@ -83,14 +85,14 @@ describe('category: core.openwop.agents.run — tool-allowlist enforcement (OPEN
   it('skips cleanly when pack source is not bundled', () => {
     if (!packAvailable) {
       console.warn('[agents-run-tool-allowlist] pack source not present; skipping');
-      expect(packAvailable).toBe(false);
-      return;
+      expect(packAvailable, req('openwop.it.agents-run-tool-allowlist.skips-cleanly-when-pack-source-is-not-bundled', 'threat-model-prompt-injection.md', 'skips cleanly when pack source is not bundled')).toBe(false);
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early ([agents-run-tool-allowlist] pack source not present; skipping)');
     }
     expect(packAvailable).toBe(true);
   });
 
   it('rejects function-typed tool.handler (the defect path)', async () => {
-    if (!packAvailable) return;
+    if (!packAvailable) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early');
     // The 1.0.0 defect: a workflow author could supply executable JS via
     // tools[].handler and the pack would await it directly with ctx. Closed
     // in 1.0.1 — the validator throws INVALID_TOOL_DECLARATION at the run
@@ -109,7 +111,7 @@ describe('category: core.openwop.agents.run — tool-allowlist enforcement (OPEN
   });
 
   it('rejects tool declaration missing a name', async () => {
-    if (!packAvailable) return;
+    if (!packAvailable) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early');
     await expectRejection(
       () => agentRun({ config: {}, inputs: { userPrompt: 'x', tools: [{ kind: 'workflow' }] } }),
       'INVALID_TOOL_DECLARATION',
@@ -118,7 +120,7 @@ describe('category: core.openwop.agents.run — tool-allowlist enforcement (OPEN
   });
 
   it('rejects tool declaration missing a kind discriminator', async () => {
-    if (!packAvailable) return;
+    if (!packAvailable) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early');
     await expectRejection(
       () => agentRun({ config: {}, inputs: { userPrompt: 'x', tools: [{ name: 't1' }] } }),
       'INVALID_TOOL_DECLARATION',
@@ -127,7 +129,7 @@ describe('category: core.openwop.agents.run — tool-allowlist enforcement (OPEN
   });
 
   it('rejects tool-driven runs when host does not provide agentRuntime', async () => {
-    if (!packAvailable) return;
+    if (!packAvailable) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early');
     // Tool dispatch MUST go through a host-resolved runtime — the 1.0.0
     // inline-handler fallback is gone.
     await expectRejection(
@@ -141,7 +143,7 @@ describe('category: core.openwop.agents.run — tool-allowlist enforcement (OPEN
   });
 
   it('tool-less run succeeds via callAIWithTools (safe fallback preserved)', async () => {
-    if (!packAvailable) return;
+    if (!packAvailable) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early');
     let toolsSeen: unknown = 'never-called';
     const ctx: AgentRunCtx = {
       config: {},
@@ -154,11 +156,11 @@ describe('category: core.openwop.agents.run — tool-allowlist enforcement (OPEN
     const result = await agentRun(ctx);
     expect(result.outputs.result).toBe('hello back');
     expect(result.outputs.finishReason).toBe('complete');
-    expect(toolsSeen, 'tool-less fallback MUST pass an empty tools array — no LLM-driven dispatch').toEqual([]);
+    expect(toolsSeen, req('openwop.it.agents-run-tool-allowlist.tool-less-run-succeeds-via-callaiwithtools-safe-fallback-preserved', 'threat-model-prompt-injection.md', 'tool-less fallback MUST pass an empty tools array — no LLM-driven dispatch')).toEqual([]);
   });
 
   it('agentRuntime.run path threads through unchanged when host provides it', async () => {
-    if (!packAvailable) return;
+    if (!packAvailable) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early');
     let receivedTools: unknown;
     const ctx: AgentRunCtx = {
       config: {},
@@ -167,15 +169,15 @@ describe('category: core.openwop.agents.run — tool-allowlist enforcement (OPEN
         tools: [{ name: 't1', kind: 'workflow', ref: 'vendor.acme.demo' }],
       },
       agentRuntime: {
-        run: async (req: unknown) => {
-          receivedTools = (req as { tools?: unknown[] }).tools;
+        run: async (reqBody: unknown) => {
+          receivedTools = (reqBody as { tools?: unknown[] }).tools;
           return { result: 'from-runtime', toolCalls: [{ name: 't1' }] };
         },
       },
     };
     const result = await agentRun(ctx);
     expect(result.outputs.result).toBe('from-runtime');
-    expect(receivedTools, 'host MUST receive the validated tools array').toEqual([
+    expect(receivedTools, req('openwop.it.agents-run-tool-allowlist.agentruntime-run-path-threads-through-unchanged-when-host-provides-it', 'threat-model-prompt-injection.md', 'host MUST receive the validated tools array')).toEqual([
       { name: 't1', kind: 'workflow', ref: 'vendor.acme.demo' },
     ]);
   });