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

package/src/scenarios/prompt-template-shape.test.ts

@@ -34,6 +34,8 @@ import { join } from 'node:path';
 import { driver } from '../lib/driver.js';
 import { SCHEMAS_DIR } from '../lib/paths.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const PROMPT_KIND_VALUES = ['system', 'user', 'few-shot', 'schema-hint'] as const;
 
@@ -92,11 +94,11 @@ describe('prompt-template-shape: schema compile (RFC 0027 §A)', () => {
     // Reuse the already-registered validator when present — Ajv refuses
     // to re-`compile` a schema whose `$id` it already knows.
     const validate = ajv.getSchema(schema['$id'] as string) ?? ajv.compile(schema);
-    expect(validate, 'RFC 0027 §A: prompt-kind.schema.json MUST compile').toBeTypeOf('function');
-    expect(schema.type, 'prompt-kind MUST be type: string').toBe('string');
+    expect(validate, req('openwop.it.prompt-template-shape.prompt-kind-schema-json-compiles-and-is-a-string-enum-of-the-four-canonical-kind', 'spec/v1/prompts.md §PromptTemplate', 'RFC 0027 §A: prompt-kind.schema.json MUST compile')).toBeTypeOf('function');
+    expect(schema.type, req('openwop.it.prompt-template-shape.prompt-kind-schema-json-compiles-and-is-a-string-enum-of-the-four-canonical-kind', 'spec/v1/prompts.md §PromptTemplate', 'prompt-kind MUST be type: string')).toBe('string');
     expect(
       schema.enum,
-      driver.describe(
+      req('openwop.it.prompt-template-shape.prompt-kind-schema-json-compiles-and-is-a-string-enum-of-the-four-canonical-kind', 
         'spec/v1/prompts.md §PromptTemplate',
         'prompt-kind enum MUST contain exactly the four canonical values',
       ),
@@ -106,13 +108,13 @@ describe('prompt-template-shape: schema compile (RFC 0027 §A)', () => {
   it('prompt-template.schema.json compiles with cross-ref to prompt-kind', () => {
     const schema = loadSchema('prompt-template.schema.json');
     const validate = ajv.compile(schema);
-    expect(validate, 'RFC 0027 §A: prompt-template.schema.json MUST compile').toBeTypeOf('function');
+    expect(validate, req('openwop.it.prompt-template-shape.prompt-template-schema-json-compiles-with-cross-ref-to-prompt-kind', 'RFC 0027 §A', 'RFC 0027 §A: prompt-template.schema.json MUST compile')).toBeTypeOf('function');
   });
 
   it('prompt-ref.schema.json compiles', () => {
     const schema = loadSchema('prompt-ref.schema.json');
     const validate = ajv.compile(schema);
-    expect(validate, 'RFC 0027 §B: prompt-ref.schema.json MUST compile').toBeTypeOf('function');
+    expect(validate, req('openwop.it.prompt-template-shape.prompt-ref-schema-json-compiles', 'RFC 0027 §A', 'RFC 0027 §B: prompt-ref.schema.json MUST compile')).toBeTypeOf('function');
   });
 });
 
@@ -130,7 +132,7 @@ describe('prompt-template-shape: PromptTemplate round-trip (RFC 0027 §A)', () =
     const ok = validate(positive);
     expect(
       ok,
-      `RFC 0027 §A: minimal PromptTemplate MUST validate; errors: ${JSON.stringify(validate.errors)}`,
+      req('openwop.it.prompt-template-shape.accepts-a-minimal-positive-prompttemplate-fixture', 'RFC 0027 §A', `RFC 0027 §A: minimal PromptTemplate MUST validate; errors: ${JSON.stringify(validate.errors)}`),
     ).toBe(true);
   });
 
@@ -157,7 +159,7 @@ describe('prompt-template-shape: PromptTemplate round-trip (RFC 0027 §A)', () =
     const ok = validate(positive);
     expect(
       ok,
-      `RFC 0027 §A: full PromptTemplate MUST validate; errors: ${JSON.stringify(validate.errors)}`,
+      req('openwop.it.prompt-template-shape.accepts-a-prompttemplate-with-typed-variables-modelhints-meta', 'RFC 0027 §A', `RFC 0027 §A: full PromptTemplate MUST validate; errors: ${JSON.stringify(validate.errors)}`),
     ).toBe(true);
   });
 
@@ -170,7 +172,7 @@ describe('prompt-template-shape: PromptTemplate round-trip (RFC 0027 §A)', () =
     };
     expect(
       validate(negative),
-      driver.describe(
+      req('openwop.it.prompt-template-shape.rejects-a-prompttemplate-missing-required-text', 
         'spec/v1/prompts.md §PromptTemplate',
         'PromptTemplate MUST require text field',
       ),
@@ -186,7 +188,7 @@ describe('prompt-template-shape: PromptTemplate round-trip (RFC 0027 §A)', () =
     };
     expect(
       validate(negative),
-      driver.describe(
+      req('openwop.it.prompt-template-shape.rejects-a-prompttemplate-with-non-semver-version', 
         'spec/v1/prompts.md §PromptTemplate',
         'PromptTemplate.version MUST match SemVer 2.0.0 pattern',
       ),
@@ -202,7 +204,7 @@ describe('prompt-template-shape: PromptTemplate round-trip (RFC 0027 §A)', () =
     };
     expect(
       validate(negative),
-      driver.describe(
+      req('openwop.it.prompt-template-shape.rejects-a-prompttemplate-with-invalid-templateid-uppercase-letter', 
         'spec/v1/prompts.md §PromptTemplate',
         'PromptTemplate.templateId MUST match ^[a-z0-9][a-z0-9._-]{0,127}$',
       ),
@@ -218,7 +220,7 @@ describe('prompt-template-shape: PromptTemplate round-trip (RFC 0027 §A)', () =
     };
     expect(
       validate(negative),
-      driver.describe(
+      req('openwop.it.prompt-template-shape.rejects-a-prompttemplate-with-kind-not-in-the-prompt-kind-enum', 
         'spec/v1/prompts.md §PromptTemplate',
         'PromptTemplate.kind MUST be one of the four canonical values',
       ),
@@ -235,7 +237,7 @@ describe('prompt-template-shape: PromptTemplate round-trip (RFC 0027 §A)', () =
     };
     expect(
       validate(negative),
-      driver.describe(
+      req('openwop.it.prompt-template-shape.rejects-an-unknown-top-level-property-additionalproperties-false', 
         'spec/v1/prompts.md §PromptTemplate',
         'PromptTemplate top-level additionalProperties:false MUST reject unknown fields',
       ),
@@ -252,7 +254,7 @@ describe('prompt-template-shape: PromptTemplate round-trip (RFC 0027 §A)', () =
     };
     expect(
       validate(negative),
-      driver.describe(
+      req('openwop.it.prompt-template-shape.rejects-a-promptvariable-with-bad-name-pattern-dash', 
         'spec/v1/prompts.md §PromptTemplate',
         'PromptVariable.name MUST match common-templating identifier pattern (no dashes)',
       ),
@@ -265,19 +267,19 @@ describe('prompt-template-shape: PromptRef round-trip (RFC 0027 §B)', () => {
   const validate = ajv.compile(loadSchema('prompt-ref.schema.json'));
 
   it('accepts stringy form without version', () => {
-    expect(validate('prompt:writer-system')).toBe(true);
+    expect(validate('prompt:writer-system'), req('openwop.it.prompt-template-shape.accepts-stringy-form-without-version', 'RFC 0027 §A', 'accepts stringy form without version')).toBe(true);
   });
 
   it('accepts stringy form with version', () => {
-    expect(validate('prompt:writer-system@1.2.3')).toBe(true);
+    expect(validate('prompt:writer-system@1.2.3'), req('openwop.it.prompt-template-shape.accepts-stringy-form-with-version', 'RFC 0027 §A', 'accepts stringy form with version')).toBe(true);
   });
 
   it('accepts stringy form with vendor-prefixed templateId', () => {
-    expect(validate('prompt:vendor.acme.writer.v2@2.0.0')).toBe(true);
+    expect(validate('prompt:vendor.acme.writer.v2@2.0.0'), req('openwop.it.prompt-template-shape.accepts-stringy-form-with-vendor-prefixed-templateid', 'RFC 0027 §A', 'accepts stringy form with vendor-prefixed templateId')).toBe(true);
   });
 
   it('accepts object form with templateId only', () => {
-    expect(validate({ templateId: 'writer-system' })).toBe(true);
+    expect(validate({ templateId: 'writer-system' }), req('openwop.it.prompt-template-shape.accepts-object-form-with-templateid-only', 'RFC 0027 §A', 'accepts object form with templateId only')).toBe(true);
   });
 
   it('accepts object form with libraryId, version, and variableOverrides', () => {
@@ -287,35 +289,35 @@ describe('prompt-template-shape: PromptRef round-trip (RFC 0027 §B)', () => {
         templateId: 'writer-system',
         version: '1.0.0',
         variableOverrides: { tone: 'formal' },
-      }),
+      }), req('openwop.it.prompt-template-shape.accepts-object-form-with-libraryid-version-and-variableoverrides', 'RFC 0027 §A', 'accepts object form with libraryId, version, and variableOverrides'),
     ).toBe(true);
   });
 
   it('rejects stringy form without `prompt:` prefix', () => {
     expect(
       validate('writer-system'),
-      driver.describe('spec/v1/prompts.md §PromptRef', 'stringy PromptRef MUST start with prompt:'),
+      req('openwop.it.prompt-template-shape.rejects-stringy-form-without-prompt-prefix', 'spec/v1/prompts.md §PromptRef', 'stringy PromptRef MUST start with prompt:'),
     ).toBe(false);
   });
 
   it('rejects stringy form with non-SemVer version', () => {
     expect(
       validate('prompt:writer-system@latest'),
-      driver.describe('spec/v1/prompts.md §PromptRef', 'stringy PromptRef version MUST be SemVer'),
+      req('openwop.it.prompt-template-shape.rejects-stringy-form-with-non-semver-version', 'spec/v1/prompts.md §PromptRef', 'stringy PromptRef version MUST be SemVer'),
     ).toBe(false);
   });
 
   it('rejects object form missing required templateId', () => {
     expect(
       validate({ version: '1.0.0' }),
-      driver.describe('spec/v1/prompts.md §PromptRef', 'object PromptRef MUST require templateId'),
+      req('openwop.it.prompt-template-shape.rejects-object-form-missing-required-templateid', 'spec/v1/prompts.md §PromptRef', 'object PromptRef MUST require templateId'),
     ).toBe(false);
   });
 
   it('rejects object form with unknown additional property', () => {
     expect(
       validate({ templateId: 'writer-system', unknownExtra: true }),
-      driver.describe(
+      req('openwop.it.prompt-template-shape.rejects-object-form-with-unknown-additional-property', 
         'spec/v1/prompts.md §PromptRef',
         'object PromptRef additionalProperties:false MUST reject unknown fields',
       ),
@@ -326,24 +328,24 @@ describe('prompt-template-shape: PromptRef round-trip (RFC 0027 §B)', () => {
 describe.skipIf(HTTP_SKIP)('prompt-template-shape: capabilities.prompts advertisement (RFC 0027 §D)', () => {
   it('capabilities.prompts (when present) carries the optional shape per RFC 0027 §D', async () => {
     const d = await readDiscovery();
-    if (d === null) return;
+    if (d === null) return softSkip('blocked', 'precondition not met — `d === null` returned early (seam, prior step, or fixture unavailable)');
     const prompts = capabilityFamily(d, 'prompts');
-    if (prompts === undefined) return; // optional block; host MAY omit
+    if (prompts === undefined) return softSkip('blocked', 'precondition not met — `prompts === undefined` returned early (optional block; host MAY omit) (seam, prior step, or fixture unavailable)'); // optional block; host MAY omit
     expect(
       typeof prompts.supported,
-      driver.describe(
+      req('openwop.it.prompt-template-shape.capabilities-prompts-when-present-carries-the-optional-shape-per-rfc-0027-d', 
         'spec/v1/prompts.md §Capability advertisement',
         'capabilities.prompts.supported MUST be boolean when block is advertised',
       ),
     ).toBe('boolean');
     if (prompts.templateKinds !== undefined) {
-      expect(Array.isArray(prompts.templateKinds), 'templateKinds MUST be an array').toBe(true);
+      expect(Array.isArray(prompts.templateKinds), req('openwop.it.prompt-template-shape.capabilities-prompts-when-present-carries-the-optional-shape-per-rfc-0027-d', 'spec/v1/prompts.md §Capability advertisement', 'templateKinds MUST be an array')).toBe(true);
       for (const k of prompts.templateKinds as unknown[]) {
         expect((PROMPT_KIND_VALUES as readonly string[]).includes(String(k))).toBe(true);
       }
     }
     if (prompts.variableSources !== undefined) {
-      expect(Array.isArray(prompts.variableSources), 'variableSources MUST be an array').toBe(true);
+      expect(Array.isArray(prompts.variableSources), req('openwop.it.prompt-template-shape.capabilities-prompts-when-present-carries-the-optional-shape-per-rfc-0027-d', 'spec/v1/prompts.md §Capability advertisement', 'variableSources MUST be an array')).toBe(true);
       for (const s of prompts.variableSources as unknown[]) {
         expect(['input', 'variable', 'secret', 'context']).toContain(String(s));
       }
@@ -352,7 +354,7 @@ describe.skipIf(HTTP_SKIP)('prompt-template-shape: capabilities.prompts advertis
       expect(['off', 'hashed', 'full']).toContain(String(prompts.observability));
     }
     if (prompts.maxTemplateBytes !== undefined) {
-      expect(typeof prompts.maxTemplateBytes, 'maxTemplateBytes MUST be integer').toBe('number');
+      expect(typeof prompts.maxTemplateBytes, req('openwop.it.prompt-template-shape.capabilities-prompts-when-present-carries-the-optional-shape-per-rfc-0027-d', 'spec/v1/prompts.md §Capability advertisement', 'maxTemplateBytes MUST be integer')).toBe('number');
       expect((prompts.maxTemplateBytes as number) > 0).toBe(true);
       expect((prompts.maxTemplateBytes as number) <= 65536).toBe(true);
     }

package/src/scenarios/proposal-reviewable-learning.test.ts

@@ -31,8 +31,8 @@ import { SCHEMAS_DIR } from '../lib/paths.js';
 import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
-
-const why = (specRef: string, requirement: string): string => `${specRef} — ${requirement}`;
+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>;
 }
@@ -43,21 +43,21 @@ describe('proposal-reviewable-learning: capability advertisement (RFC 0096 §A,
 
   it('capabilities schema declares agents.proposals with its required sub-flags', () => {
     const proposals = agents?.properties?.proposals;
-    expect(proposals, why('capabilities.md §agents', 'agents.proposals MUST be declared')).toBeDefined();
+    expect(proposals, req('openwop.it.proposal-reviewable-learning.capabilities-schema-declares-agents-proposals-with-its-required-sub-flags', 'capabilities.md §agents', 'agents.proposals MUST be declared')).toBeDefined();
     for (const flag of ['artifactKinds', 'duplicationDetection', 'activation']) {
-      expect(proposals?.properties?.[flag], why('RFC 0096 §A', `agents.proposals.${flag} MUST be declared`)).toBeDefined();
+      expect(proposals?.properties?.[flag], req('openwop.it.proposal-reviewable-learning.capabilities-schema-declares-agents-proposals-with-its-required-sub-flags', 'RFC 0096 §A', `agents.proposals.${flag} MUST be declared`)).toBeDefined();
     }
-    expect(proposals?.required, why('RFC 0096 §A', 'artifactKinds + activation MUST be required')).toEqual(
+    expect(proposals?.required, req('openwop.it.proposal-reviewable-learning.capabilities-schema-declares-agents-proposals-with-its-required-sub-flags', 'RFC 0096 §A', 'artifactKinds + activation MUST be required')).toEqual(
       expect.arrayContaining(['artifactKinds', 'activation']),
     );
   });
 
   it('the `rule` artifact kind is NOT in the enum (dropped — no defining RFC)', () => {
     const kinds = (agents?.properties?.proposals as { properties?: Record<string, { items?: { enum?: string[] } }> })?.properties?.artifactKinds?.items?.enum ?? [];
-    expect(kinds, why('RFC 0096 §A', 'artifactKinds enumerates the four kinds with a defining RFC')).toEqual(
+    expect(kinds, req('openwop.it.proposal-reviewable-learning.the-rule-artifact-kind-is-not-in-the-enum-dropped-no-defining-rfc', 'RFC 0096 §A', 'artifactKinds enumerates the four kinds with a defining RFC')).toEqual(
       expect.arrayContaining(['agent-pack', 'workflow-chain-pack', 'prompt-template', 'automation']),
     );
-    expect(kinds, why('RFC 0096 §A', '`rule` MUST NOT appear — it has no defining RFC, so its artifact is unvalidatable')).not.toContain('rule');
+    expect(kinds, req('openwop.it.proposal-reviewable-learning.the-rule-artifact-kind-is-not-in-the-enum-dropped-no-defining-rfc', 'RFC 0096 §A', '`rule` MUST NOT appear — it has no defining RFC, so its artifact is unvalidatable')).not.toContain('rule');
   });
 });
 
@@ -77,13 +77,13 @@ describe('proposal-reviewable-learning: Proposal shape (RFC 0096 §B, server-fre
   };
 
   it('validates a conforming draft proposal', () => {
-    expect(validate(good), why('RFC 0096 §B', `a conforming proposal MUST validate. Errors: ${JSON.stringify(validate.errors)}`)).toBe(true);
+    expect(validate(good), req('openwop.it.proposal-reviewable-learning.validates-a-conforming-draft-proposal', 'RFC 0096 §B', `a conforming proposal MUST validate. Errors: ${JSON.stringify(validate.errors)}`)).toBe(true);
   });
 
   it('rejects an unknown state and the dropped `rule` kind', () => {
-    expect(validate({ ...good, state: 'live' }), why('RFC 0096 §B', 'a state outside the lifecycle enum MUST be rejected')).toBe(false);
-    expect(validate({ ...good, kind: 'rule' }), why('RFC 0096 §B', '`kind: "rule"` MUST be rejected (dropped from the enum)')).toBe(false);
-    expect(validate({ ...good, owner: { workspace: 'x' } }), why('RFC 0048', 'owner without tenant MUST be rejected')).toBe(false);
+    expect(validate({ ...good, state: 'live' }), req('openwop.it.proposal-reviewable-learning.rejects-an-unknown-state-and-the-dropped-rule-kind', 'RFC 0096 §B', 'a state outside the lifecycle enum MUST be rejected')).toBe(false);
+    expect(validate({ ...good, kind: 'rule' }), req('openwop.it.proposal-reviewable-learning.rejects-an-unknown-state-and-the-dropped-rule-kind', 'RFC 0096 §B', '`kind: "rule"` MUST be rejected (dropped from the enum)')).toBe(false);
+    expect(validate({ ...good, owner: { workspace: 'x' } }), req('openwop.it.proposal-reviewable-learning.rejects-an-unknown-state-and-the-dropped-rule-kind', 'RFC 0048', 'owner without tenant MUST be rejected')).toBe(false);
   });
 });
 
@@ -96,15 +96,15 @@ describe('proposal-reviewable-learning: content-free events (RFC 0096 §D, serve
 
   it('proposal.created and proposal.activated are in the RunEventType enum', () => {
     const en = (runEvent.$defs as Record<string, { enum?: string[] }>).RunEventType?.enum ?? [];
-    expect(en).toContain('proposal.created');
+    expect(en, req('openwop.it.proposal-reviewable-learning.proposal-created-and-proposal-activated-are-in-the-runeventtype-enum', 'RFC 0096', 'proposal.created and proposal.activated are in the RunEventType enum')).toContain('proposal.created');
     expect(en).toContain('proposal.activated');
   });
 
   it('proposal.created is content-free — an artifact body and rationale text are rejected', () => {
     const created = ajv.getSchema('payloads#/$defs/proposalCreated')!;
-    expect(created({ proposalId: 'p1', kind: 'agent-pack', sourceRunIds: ['r1'], duplicateOf: null }), why('RFC 0096 §D', 'a content-free proposal.created MUST validate')).toBe(true);
-    expect(created({ proposalId: 'p1', kind: 'agent-pack', artifact: { x: 1 } }), why('SECURITY invariant proposal-inert-until-applied', 'proposal.created MUST NOT carry the artifact body')).toBe(false);
-    expect(created({ proposalId: 'p1', kind: 'agent-pack', rationale: 'because…' }), why('RFC 0096 §D', 'proposal.created MUST NOT carry rationale text')).toBe(false);
+    expect(created({ proposalId: 'p1', kind: 'agent-pack', sourceRunIds: ['r1'], duplicateOf: null }), req('openwop.it.proposal-reviewable-learning.proposal-created-is-content-free-an-artifact-body-and-rationale-text-are-rejecte', 'RFC 0096 §D', 'a content-free proposal.created MUST validate')).toBe(true);
+    expect(created({ proposalId: 'p1', kind: 'agent-pack', artifact: { x: 1 } }), req('openwop.it.proposal-reviewable-learning.proposal-created-is-content-free-an-artifact-body-and-rationale-text-are-rejecte', 'SECURITY invariant proposal-inert-until-applied', 'proposal.created MUST NOT carry the artifact body')).toBe(false);
+    expect(created({ proposalId: 'p1', kind: 'agent-pack', rationale: 'because…' }), req('openwop.it.proposal-reviewable-learning.proposal-created-is-content-free-an-artifact-body-and-rationale-text-are-rejecte', 'RFC 0096 §D', 'proposal.created MUST NOT carry rationale text')).toBe(false);
   });
 });
 
@@ -114,16 +114,16 @@ describe('proposal-reviewable-learning: behavioral (RFC 0096 §E, capability-gat
     if (!behaviorGate('agents.proposals', agents?.proposals !== undefined)) return;
 
     const list = await driver.get('/v1/host/sample/proposals?state=draft');
-    if (list.status === 404 || list.status === 403) return; // seam unwired — soft-skip
+    if (list.status === 404 || list.status === 403) return softSkip('blocked', 'precondition not met — `list.status === 404 || list.status === 403` returned early (seam unwired — soft-skip) (seam, prior step, or fixture unavailable)'); // seam unwired — soft-skip
     const proposals = (list.json as { proposals?: Array<{ id: string }> })?.proposals ?? [];
-    if (proposals.length === 0) return; // nothing to act on — soft-skip
+    if (proposals.length === 0) return softSkip('blocked', 'precondition not met — `proposals.length === 0` returned early (nothing to act on — soft-skip) (seam, prior step, or fixture unavailable)'); // nothing to act on — soft-skip
 
     // Apply with no auth/scope — MUST be refused.
     const res = await driver.post(`/v1/host/sample/proposals/${proposals[0]!.id}/apply`, {});
-    if (res.status === 404) return;
+    if (res.status === 404) return softSkip('blocked', 'precondition not met — `res.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(
       res.status,
-      driver.describe('agent-memory.md §"Reviewable learning" clause 2', 'apply without the activation scope MUST be denied (403)'),
+      req('openwop.it.proposal-reviewable-learning.apply-without-the-activation-scope-is-denied-403-and-installs-nothing', 'agent-memory.md §"Reviewable learning" clause 2', 'apply without the activation scope MUST be denied (403)'),
     ).toBe(403);
   });
 });

package/src/scenarios/protocol-versions-array.test.ts

@@ -29,6 +29,7 @@ import { driver } from '../lib/driver.js';
 import { SCHEMAS_DIR } from '../lib/paths.js';
 import { isCore, type DiscoveryPayload } from '../lib/profiles.js';
 import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
 
 interface CapsSchema {
   $schema: string;
@@ -43,7 +44,7 @@ const caps = JSON.parse(readFileSync(join(SCHEMAS_DIR, 'capabilities.schema.json
 describe('protocol-versions-array: schema shape (RFC 0165 §A.1, server-free)', () => {
   it('declares root `protocolVersions` as a unique, non-empty string array', () => {
     const p = caps.properties.protocolVersions;
-    expect(p, 'RFC 0165 §A.1: capabilities.schema.json MUST declare root `protocolVersions`').toBeDefined();
+    expect(p, req('openwop.it.protocol-versions-array.declares-root-protocolversions-as-a-unique-non-empty-string-array', 'RFC 0165 §A', 'RFC 0165 §A.1: capabilities.schema.json MUST declare root `protocolVersions`')).toBeDefined();
     expect(p?.type).toBe('array');
     expect(p?.minItems).toBe(1);
     expect(p?.uniqueItems).toBe(true);
@@ -52,14 +53,14 @@ describe('protocol-versions-array: schema shape (RFC 0165 §A.1, server-free)',
   it('item grammar equals the scalar grammar (one axis, one grammar)', () => {
     expect(
       caps.properties.protocolVersions?.items?.pattern,
-      'RFC 0165 §A.1: protocolVersions items MUST use the RFC 0149 §C grammar, not the A2A item pattern',
+      req('openwop.it.protocol-versions-array.item-grammar-equals-the-scalar-grammar-one-axis-one-grammar', 'RFC 0165 §A', 'RFC 0165 §A.1: protocolVersions items MUST use the RFC 0149 §C grammar, not the A2A item pattern'),
     ).toBe(caps.properties.protocolVersion?.pattern);
   });
 
   it('accepts ["1.11", "2.0"], rejects "01.0", "1.0.0", duplicates, and empty', () => {
     const ajv = new Ajv2020({ allErrors: true, strict: false });
     const validate = ajv.compile({ $schema: caps.$schema, ...(caps.properties.protocolVersions as Record<string, unknown>) });
-    expect(validate(['1.11', '2.0'])).toBe(true);
+    expect(validate(['1.11', '2.0']), req('openwop.it.protocol-versions-array.accepts-1-11-2-0-rejects-01-0-1-0-0-duplicates-and-empty', 'RFC 0165 §A', 'accepts ["1.11", "2.0"], rejects "01.0", "1.0.0", duplicates, and empty')).toBe(true);
     expect(validate(['01.0'])).toBe(false);
     expect(validate(['1.0.0'])).toBe(false);
     expect(validate(['1.0', '1.0'])).toBe(false);
@@ -77,14 +78,14 @@ describe('protocol-versions-array: advertisement (RFC 0165 §A.2 — presence-ga
     if (arr === undefined) {
       return softSkip('inapplicable', 'host does not advertise protocolVersions (RFC 0165 §A — optional in v1.x)');
     }
-    expect(Array.isArray(arr), driver.describe('RFC 0165 §A.1', 'protocolVersions MUST be an array')).toBe(true);
+    expect(Array.isArray(arr), req('openwop.it.protocol-versions-array.when-advertised-every-item-matches-the-grammar-items-are-unique-and-the-array-co', 'RFC 0165 §A.1', 'protocolVersions MUST be an array')).toBe(true);
     const items = arr as unknown[];
-    expect(items.length, driver.describe('RFC 0165 §A.1', 'protocolVersions MUST be non-empty')).toBeGreaterThan(0);
+    expect(items.length, req('openwop.it.protocol-versions-array.when-advertised-every-item-matches-the-grammar-items-are-unique-and-the-array-co', 'RFC 0165 §A.1', 'protocolVersions MUST be non-empty')).toBeGreaterThan(0);
     for (const v of items) {
-      expect(typeof v === 'string' && GRAMMAR.test(v), driver.describe('RFC 0165 §A.1', `protocolVersions item ${JSON.stringify(v)} MUST match the RFC 0149 §C grammar`)).toBe(true);
+      expect(typeof v === 'string' && GRAMMAR.test(v), req('openwop.it.protocol-versions-array.when-advertised-every-item-matches-the-grammar-items-are-unique-and-the-array-co', 'RFC 0165 §A.1', `protocolVersions item ${JSON.stringify(v)} MUST match the RFC 0149 §C grammar`)).toBe(true);
     }
-    expect(new Set(items).size, driver.describe('RFC 0165 §A.1', 'protocolVersions items MUST be unique')).toBe(items.length);
-    expect(items, driver.describe('RFC 0165 §A.2', 'protocolVersions MUST contain the value of protocolVersion')).toContain(doc['protocolVersion']);
+    expect(new Set(items).size, req('openwop.it.protocol-versions-array.when-advertised-every-item-matches-the-grammar-items-are-unique-and-the-array-co', 'RFC 0165 §A.1', 'protocolVersions items MUST be unique')).toBe(items.length);
+    expect(items, req('openwop.it.protocol-versions-array.when-advertised-every-item-matches-the-grammar-items-are-unique-and-the-array-co', 'RFC 0165 §A.2', 'protocolVersions MUST contain the value of protocolVersion')).toContain(doc['protocolVersion']);
   });
 
   it('profile derivation is unchanged by the array (isCore reads the scalar only)', async () => {
@@ -97,7 +98,7 @@ describe('protocol-versions-array: advertisement (RFC 0165 §A.2 — presence-ga
     delete without['protocolVersions'];
     expect(
       isCore(doc),
-      driver.describe('RFC 0165 §A.2', 'openwop-discovery-core derivation MUST NOT depend on protocolVersions in v1.x'),
+      req('openwop.it.protocol-versions-array.profile-derivation-is-unchanged-by-the-array-iscore-reads-the-scalar-only', 'RFC 0165 §A.2', 'openwop-discovery-core derivation MUST NOT depend on protocolVersions in v1.x'),
     ).toBe(isCore(without as DiscoveryPayload));
   });
 });

package/src/scenarios/provider-usage.test.ts

@@ -28,6 +28,8 @@ import { driver } from '../lib/driver.js';
 import { SCHEMAS_DIR } from '../lib/paths.js';
 import { queryTestEvents, isEventLogSeamAvailable, resetTestSeam } from '../lib/event-log-query.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 interface DiscoveryDoc {
   capabilities?: {
@@ -45,21 +47,21 @@ async function readProviderUsageCap(): Promise<{ supported?: boolean; costEstima
 describe('provider-usage: capability advertisement (RFC 0026 §E)', () => {
   it('capabilities.providerUsage is either absent or a well-formed object', async () => {
     const cap = await readProviderUsageCap();
-    if (cap === null) return; // host doesn't advertise — skip
+    if (cap === null) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `cap === null` returned early (host doesn\'t advertise — skip)'); // host doesn't advertise — skip
     expect(
       typeof cap.supported,
-      driver.describe('RFC 0026 §E', 'capabilities.providerUsage.supported MUST be a boolean when the block is present'),
+      req('openwop.it.provider-usage.capabilities-providerusage-is-either-absent-or-a-well-formed-object', 'RFC 0026 §E', 'capabilities.providerUsage.supported MUST be a boolean when the block is present'),
     ).toBe('boolean');
     if (cap.costEstimates !== undefined) {
       expect(
         typeof cap.costEstimates,
-        driver.describe('RFC 0026 §E', 'capabilities.providerUsage.costEstimates MUST be a boolean when present'),
+        req('openwop.it.provider-usage.capabilities-providerusage-is-either-absent-or-a-well-formed-object', 'RFC 0026 §E', 'capabilities.providerUsage.costEstimates MUST be a boolean when present'),
       ).toBe('boolean');
     }
     if (cap.currency !== undefined) {
       expect(
         /^[A-Z]{3}$/.test(cap.currency),
-        driver.describe('RFC 0026 §E', 'capabilities.providerUsage.currency MUST be a 3-letter uppercase ISO 4217 code when present'),
+        req('openwop.it.provider-usage.capabilities-providerusage-is-either-absent-or-a-well-formed-object', 'RFC 0026 §E', 'capabilities.providerUsage.currency MUST be a 3-letter uppercase ISO 4217 code when present'),
       ).toBe(true);
     }
   });
@@ -84,7 +86,7 @@ describe('provider-usage: schema round-trip (RFC 0026 §A)', () => {
       cacheHit: false,
       nodeId: 'chat-respond',
     });
-    expect(ok, `positive fixture MUST validate; errors: ${JSON.stringify(validate.errors)}`).toBe(true);
+    expect(ok, req('openwop.it.provider-usage.positive-fixture-validates', 'RFC 0026', `positive fixture MUST validate; errors: ${JSON.stringify(validate.errors)}`)).toBe(true);
   });
 
   it('negative fixture (missing required field) MUST be rejected', () => {
@@ -96,7 +98,7 @@ describe('provider-usage: schema round-trip (RFC 0026 §A)', () => {
     });
     expect(
       ok,
-      driver.describe('RFC 0026 §A', 'payload missing required `outputTokens` MUST fail schema validation'),
+      req('openwop.it.provider-usage.negative-fixture-missing-required-field-must-be-rejected', 'RFC 0026 §A', 'payload missing required `outputTokens` MUST fail schema validation'),
     ).toBe(false);
   });
 
@@ -110,7 +112,7 @@ describe('provider-usage: schema round-trip (RFC 0026 §A)', () => {
     });
     expect(
       ok,
-      driver.describe('RFC 0026 §D', 'additionalProperties:false MUST reject credentialRef-shaped fields per provider-usage-no-credential-leak'),
+      req('openwop.it.provider-usage.negative-fixture-additionalproperties-credentialref-leak-must-be-rejected', 'RFC 0026 §D', 'additionalProperties:false MUST reject credentialRef-shaped fields per provider-usage-no-credential-leak'),
     ).toBe(false);
   });
 
@@ -121,13 +123,13 @@ describe('provider-usage: schema round-trip (RFC 0026 §A)', () => {
       inputTokens: 100.5, // non-integer
       outputTokens: 50,
     });
-    expect(ok, 'inputTokens MUST be integer per §A').toBe(false);
+    expect(ok, req('openwop.it.provider-usage.negative-fixture-non-integer-token-count-must-be-rejected', 'RFC 0026', 'inputTokens MUST be integer per §A')).toBe(false);
   });
 });
 
 describe('provider-usage: event presence via emit-seam + event-log query (RFC 0026 §B)', () => {
   it('emit-seam projects exactly one provider.usage event with required fields populated', async () => {
-    if (!(await isEventLogSeamAvailable())) return; // E.1 seam not exposed — soft-skip
+    if (!(await isEventLogSeamAvailable())) return softSkip('blocked', 'precondition not met — `!(await isEventLogSeamAvailable())` returned early (E.1 seam not exposed — soft-skip) (seam, prior step, or fixture unavailable)'); // E.1 seam not exposed — soft-skip
     const runId = `r-pu-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     const correlationId = `${runId}:node-1:turn-0:pu-1`;
     const payload = {
@@ -139,14 +141,14 @@ describe('provider-usage: event presence via emit-seam + event-log query (RFC 00
       nodeId: 'node-1',
     };
     const emit = await driver.post('/v1/host/sample/test/emit-provider-usage', { runId, payload, correlationId, nodeId: 'node-1' });
-    if (emit.status === 404) return; // emit seam not exposed
+    if (emit.status === 404) return softSkip('blocked', 'precondition not met — `emit.status === 404` returned early (emit seam not exposed) (seam, prior step, or fixture unavailable)'); // emit seam not exposed
     expect(emit.status).toBe(200);
 
     const events = await queryTestEvents(runId, { type: 'provider.usage' });
-    if (!events.ok) return;
+    if (!events.ok) return softSkip('blocked', 'precondition not met — `!events.ok` returned early (seam, prior step, or fixture unavailable)');
     expect(
       events.events.length,
-      driver.describe('RFC 0026 §B', 'emit-seam MUST project exactly one provider.usage event'),
+      req('openwop.it.provider-usage.emit-seam-projects-exactly-one-provider-usage-event-with-required-fields-populat', 'RFC 0026 §B', 'emit-seam MUST project exactly one provider.usage event'),
     ).toBe(1);
     const e = events.events[0]!;
     expect(e.payload.provider).toBe('anthropic');
@@ -159,7 +161,7 @@ describe('provider-usage: event presence via emit-seam + event-log query (RFC 00
   });
 
   it('emit-seam refuses payloads containing credentialRef-shaped content (provider-usage-no-credential-leak invariant)', async () => {
-    if (!(await isEventLogSeamAvailable())) return;
+    if (!(await isEventLogSeamAvailable())) return softSkip('blocked', 'precondition not met — `!(await isEventLogSeamAvailable())` returned early (seam, prior step, or fixture unavailable)');
     const runId = `r-pu-leak-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     // Inject a credentialRef-shaped field via a synthetic payload that
     // contains 'secret:' in a string field. The seam's defense-in-depth
@@ -175,10 +177,10 @@ describe('provider-usage: event presence via emit-seam + event-log query (RFC 00
         nodeId: 'secret:tenant:byok-anthropic:v1', // banned content
       },
     });
-    if (res.status === 404) return;
+    if (res.status === 404) return softSkip('blocked', 'precondition not met — `res.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(
       res.status,
-      driver.describe('SECURITY/invariants.yaml provider-usage-no-credential-leak', 'payload with credentialRef-shaped content MUST be refused'),
+      req('openwop.it.provider-usage.emit-seam-refuses-payloads-containing-credentialref-shaped-content-provider-usag', 'SECURITY/invariants.yaml provider-usage-no-credential-leak', 'payload with credentialRef-shaped content MUST be refused'),
     ).toBe(400);
     expect(readErrorCode(res.json)).toBe('provider_usage_credential_leak');
     await resetTestSeam();

package/src/scenarios/providerPolicyEnforcement.test.ts

@@ -30,6 +30,8 @@
 
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const CANONICAL_MODES = ['disabled', 'optional', 'required', 'restricted'] as const;
 
@@ -57,16 +59,16 @@ async function fetchPolicies(): Promise<PoliciesShape | null> {
 describe('provider-policy-enforcement: closed mode set per spec/v1/capabilities.md §`aiProviders.policies`', () => {
   it('every advertised mode is one of the four canonical values', async () => {
     const policies = await fetchPolicies();
-    if (policies === null || !Array.isArray(policies.modes)) return;
+    if (policies === null || !Array.isArray(policies.modes)) return softSkip('blocked', 'precondition not met — `policies === null || !Array.isArray(policies.modes)` returned early (seam, prior step, or fixture unavailable)');
 
     for (const mode of policies.modes) {
-      expect(typeof mode, driver.describe(
+      expect(typeof mode, req('openwop.it.providerPolicyEnforcement.every-advertised-mode-is-one-of-the-four-canonical-values', 
         'capabilities.md §"`aiProviders.policies`"',
         'each entry in policies.modes MUST be a string',
       )).toBe('string');
       expect(
         (CANONICAL_MODES as readonly string[]).includes(mode as string),
-        driver.describe(
+        req('openwop.it.providerPolicyEnforcement.every-advertised-mode-is-one-of-the-four-canonical-values', 
           'capabilities.md §"`aiProviders.policies`"',
           `mode "${String(mode)}" is not in the closed canonical set [${CANONICAL_MODES.join(', ')}]`,
         ),
@@ -76,10 +78,10 @@ describe('provider-policy-enforcement: closed mode set per spec/v1/capabilities.
 
   it('hosts that support `restricted` MUST also support `optional` (default no-restriction case)', async () => {
     const policies = await fetchPolicies();
-    if (policies === null || !Array.isArray(policies.modes)) return;
+    if (policies === null || !Array.isArray(policies.modes)) return softSkip('blocked', 'precondition not met — `policies === null || !Array.isArray(policies.modes)` returned early (seam, prior step, or fixture unavailable)');
     const modes = policies.modes as string[];
-    if (!modes.includes('restricted')) return;
-    expect(modes.includes('optional'), driver.describe(
+    if (!modes.includes('restricted')) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!modes.includes(\'restricted\')` returned early');
+    expect(modes.includes('optional'), req('openwop.it.providerPolicyEnforcement.hosts-that-support-restricted-must-also-support-optional-default-no-restriction', 
       'spec/v1/profiles.md §`openwop-provider-policy`',
       'a host advertising `restricted` MUST also advertise `optional` so workflows without policy hit the default permissive case',
     )).toBe(true);
@@ -87,12 +89,12 @@ describe('provider-policy-enforcement: closed mode set per spec/v1/capabilities.
 
   it('errorCode is a non-empty string when present', async () => {
     const policies = await fetchPolicies();
-    if (policies === null || policies.errorCode === undefined) return;
-    expect(typeof policies.errorCode, driver.describe(
+    if (policies === null || policies.errorCode === undefined) return softSkip('blocked', 'precondition not met — `policies === null || policies.errorCode === undefined` returned early (seam, prior step, or fixture unavailable)');
+    expect(typeof policies.errorCode, req('openwop.it.providerPolicyEnforcement.errorcode-is-a-non-empty-string-when-present', 
       'capabilities.md §"`aiProviders.policies`"',
       'aiProviders.policies.errorCode MUST be a string when present',
     )).toBe('string');
-    expect((policies.errorCode as string).length, driver.describe(
+    expect((policies.errorCode as string).length, req('openwop.it.providerPolicyEnforcement.errorcode-is-a-non-empty-string-when-present', 
       'capabilities.md §"`aiProviders.policies`"',
       'aiProviders.policies.errorCode MUST be non-empty when present',
     )).toBeGreaterThan(0);
@@ -102,11 +104,11 @@ describe('provider-policy-enforcement: closed mode set per spec/v1/capabilities.
 describe('provider-policy-enforcement: scope advertisement', () => {
   it('scopes contains only non-empty strings when present', async () => {
     const policies = await fetchPolicies();
-    if (policies === null) return;
-    if (!Array.isArray(policies.scopes)) return;
+    if (policies === null) return softSkip('blocked', 'precondition not met — `policies === null` returned early (seam, prior step, or fixture unavailable)');
+    if (!Array.isArray(policies.scopes)) return softSkip('blocked', 'precondition not met — `!Array.isArray(policies.scopes)` returned early (seam, prior step, or fixture unavailable)');
 
     for (const scope of policies.scopes) {
-      expect(typeof scope === 'string' && scope.length > 0, driver.describe(
+      expect(typeof scope === 'string' && scope.length > 0, req('openwop.it.providerPolicyEnforcement.scopes-contains-only-non-empty-strings-when-present', 
         'capabilities.md §"`aiProviders.policies`"',
         'each entry in policies.scopes MUST be a non-empty string',
       )).toBe(true);
@@ -120,11 +122,11 @@ describe('provider-policy-enforcement: documented denial reasons enumeration', (
     // file isn't updated, scenario authors will be surprised. This
     // assertion catches that — an empty CANONICAL_MODES or DOCUMENTED_
     // DENIAL_REASONS would indicate the test file got truncated.
-    expect(CANONICAL_MODES.length, driver.describe(
+    expect(CANONICAL_MODES.length, req('openwop.it.providerPolicyEnforcement.lists-are-non-empty-sanity-check-on-documentation-drift', 
       'spec/v1/capabilities.md §"`aiProviders.policies`"',
       'closed mode set MUST be the four canonical values',
     )).toBe(4);
-    expect(DOCUMENTED_DENIAL_REASONS.length, driver.describe(
+    expect(DOCUMENTED_DENIAL_REASONS.length, req('openwop.it.providerPolicyEnforcement.lists-are-non-empty-sanity-check-on-documentation-drift', 
       'openwop/openwop@0bebfb0 — denial-reason enum alignment',
       'documented denial-reason set is non-empty',
     )).toBeGreaterThan(0);