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

package/src/scenarios/context-budget-transcript-bound.test.ts

@@ -46,6 +46,8 @@ import { behaviorGate } from '../lib/behavior-gate.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
 import { queryTestEvents } from '../lib/event-log-query.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const FIXTURE = 'conformance-context-budget-multiturn';
 const PROFILE = 'openwop-context-budget';
@@ -135,20 +137,20 @@ describe('context-budget-transcript-bound (RFC 0111 §"Context economy")', () =>
     const cb = ma?.executionModel?.contextBudget;
     const budget = numberOf(cb?.transcriptTokenBudget);
     if (!behaviorGate(PROFILE, budget !== undefined)) return;
-    if (!isFixtureAdvertised(FIXTURE)) return; // fixture-gated soft-skip
+    if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(FIXTURE)` returned early (fixture-gated soft-skip)'); // fixture-gated soft-skip
 
     const advertisedCounter = stringOf(cb?.tokenCounter);
     expect(
       advertisedCounter,
-      driver.describe('RFC 0111', 'tokenCounter MUST be advertised when transcriptTokenBudget is present (schema if/then)'),
+      req('openwop.it.context-budget-transcript-bound.bounds-the-per-turn-transcript-to-transcripttokenbudget-with-an-internally-consi', 'RFC 0111', 'tokenCounter MUST be advertised when transcriptTokenBudget is present (schema if/then)'),
     ).toBeDefined();
 
     // Drive the multi-turn orchestrator run.
     const create = await driver.post('/v1/runs', { workflowId: FIXTURE });
     expect(create.status).toBe(201);
     const runId = runIdOf(create.json);
-    expect(runId, 'POST /v1/runs MUST return a runId').toBeDefined();
-    if (runId === undefined) return;
+    expect(runId, req('openwop.it.context-budget-transcript-bound.bounds-the-per-turn-transcript-to-transcripttokenbudget-with-an-internally-consi', 'RFC 0111', 'POST /v1/runs MUST return a runId')).toBeDefined();
+    if (runId === undefined) return softSkip('blocked', 'precondition not met — `runId === undefined` returned early (seam, prior step, or fixture unavailable)');
     await pollUntilTerminal(runId);
 
     // Probe the per-iteration transcript-window seam (OPTIONAL).
@@ -158,25 +160,25 @@ describe('context-budget-transcript-bound (RFC 0111 §"Context economy")', () =>
         `/v1/host/sample/agent/transcript-window?runId=${encodeURIComponent(runId)}&iteration=${iteration}`,
       );
       if (res.status === 404 || res.status === 405) {
-        if (iteration === 1) return; // seam unwired — soft-skip the whole scenario
+        if (iteration === 1) return softSkip('blocked', 'precondition not met — `iteration === 1` returned early (seam unwired — soft-skip the whole scenario) (seam, prior step, or fixture unavailable)'); // seam unwired — soft-skip the whole scenario
         break; // iterations exhausted
       }
       if (res.status === 400 || res.status === 422) break; // iteration past the run's last turn
       expect(
         res.status === 200,
-        driver.describe('host-sample-test-seams.md §14', 'the transcript-window seam MUST return 200 for a valid iteration'),
+        req('openwop.it.context-budget-transcript-bound.bounds-the-per-turn-transcript-to-transcripttokenbudget-with-an-internally-consi', 'host-sample-test-seams.md §14', 'the transcript-window seam MUST return 200 for a valid iteration'),
       ).toBe(true);
       const window = transcriptWindowOf(res.json);
       expect(
         window,
-        driver.describe('host-sample-test-seams.md §14', 'the seam MUST return { tokenCounter, tokenCount, eventIds, summarizedRanges }'),
+        req('openwop.it.context-budget-transcript-bound.bounds-the-per-turn-transcript-to-transcripttokenbudget-with-an-internally-consi', 'host-sample-test-seams.md §14', 'the seam MUST return { tokenCounter, tokenCount, eventIds, summarizedRanges }'),
       ).toBeDefined();
-      if (window === undefined) return;
+      if (window === undefined) return softSkip('blocked', 'precondition not met — `window === undefined` returned early (seam, prior step, or fixture unavailable)');
       windows.push({ iteration, window });
     }
 
     // Non-vacuity: a wired seam MUST report at least one iteration.
-    expect(windows.length, 'a wired transcript-window seam MUST report at least one orchestrator iteration').toBeGreaterThan(0);
+    expect(windows.length, req('openwop.it.context-budget-transcript-bound.bounds-the-per-turn-transcript-to-transcripttokenbudget-with-an-internally-consi', 'host-sample-test-seams.md §14', 'a wired transcript-window seam MUST report at least one orchestrator iteration')).toBeGreaterThan(0);
 
     // Independent event-log read for the cross-check (OPTIONAL seam).
     const q = await queryTestEvents(runId);
@@ -196,14 +198,14 @@ describe('context-budget-transcript-bound (RFC 0111 §"Context economy")', () =>
       // 1 — tokenCounter agreement.
       expect(
         window.tokenCounter,
-        driver.describe('RFC 0111', `iteration ${iteration}: seam tokenCounter MUST equal the advertised contextBudget.tokenCounter`),
+        req('openwop.it.context-budget-transcript-bound.bounds-the-per-turn-transcript-to-transcripttokenbudget-with-an-internally-consi', 'RFC 0111', `iteration ${iteration}: seam tokenCounter MUST equal the advertised contextBudget.tokenCounter`),
       ).toBe(advertisedCounter);
 
       // 2 — the per-turn token bound.
       if (budget !== undefined) {
         expect(
           window.tokenCount,
-          driver.describe('RFC 0111', `iteration ${iteration}: tokenCount MUST NOT exceed transcriptTokenBudget`),
+          req('openwop.it.context-budget-transcript-bound.bounds-the-per-turn-transcript-to-transcripttokenbudget-with-an-internally-consi', 'RFC 0111', `iteration ${iteration}: tokenCount MUST NOT exceed transcriptTokenBudget`),
         ).toBeLessThanOrEqual(budget);
       }
 
@@ -212,7 +214,7 @@ describe('context-budget-transcript-bound (RFC 0111 §"Context economy")', () =>
         for (const id of window.eventIds) {
           expect(
             logEventIds.has(id),
-            driver.describe('RFC 0111 §"Conformance seam"', `iteration ${iteration}: eventId "${id}" in the seam accounting MUST be a real persisted run event`),
+            req('openwop.it.context-budget-transcript-bound.bounds-the-per-turn-transcript-to-transcripttokenbudget-with-an-internally-consi', 'RFC 0111 §"Conformance seam"', `iteration ${iteration}: eventId "${id}" in the seam accounting MUST be a real persisted run event`),
           ).toBe(true);
         }
       }
@@ -221,7 +223,7 @@ describe('context-budget-transcript-bound (RFC 0111 §"Context economy")', () =>
       const uniqueIds = new Set(window.eventIds);
       expect(
         uniqueIds.size,
-        driver.describe('RFC 0111 §"Conformance seam"', `iteration ${iteration}: eventIds MUST be a tail with no repeated entry`),
+        req('openwop.it.context-budget-transcript-bound.bounds-the-per-turn-transcript-to-transcripttokenbudget-with-an-internally-consi', 'RFC 0111 §"Conformance seam"', `iteration ${iteration}: eventIds MUST be a tail with no repeated entry`),
       ).toBe(window.eventIds.length);
 
       // 5 — every summarized range references a recorded context.summarized event.
@@ -229,7 +231,7 @@ describe('context-budget-transcript-bound (RFC 0111 §"Context economy")', () =>
         for (const range of window.summarizedRanges) {
           expect(
             summarizedRefs.has(range.summaryRef),
-            driver.describe('RFC 0111', `iteration ${iteration}: summarizedRanges summaryRef "${range.summaryRef}" MUST have a matching context.summarized event`),
+            req('openwop.it.context-budget-transcript-bound.bounds-the-per-turn-transcript-to-transcripttokenbudget-with-an-internally-consi', 'RFC 0111', `iteration ${iteration}: summarizedRanges summaryRef "${range.summaryRef}" MUST have a matching context.summarized event`),
           ).toBe(true);
         }
       }
@@ -245,7 +247,7 @@ describe('context-budget-transcript-bound (RFC 0111 §"Context economy")', () =>
       for (const id of verbatimTail) {
         expect(
           summarizedIds.has(id),
-          driver.describe('RFC 0111', `a kept (verbatim) turn "${id}" MUST NOT appear inside a summarized range`),
+          req('openwop.it.context-budget-transcript-bound.bounds-the-per-turn-transcript-to-transcripttokenbudget-with-an-internally-consi', 'RFC 0111', `a kept (verbatim) turn "${id}" MUST NOT appear inside a summarized range`),
         ).toBe(false);
       }
     }

package/src/scenarios/context-summarization-replay.test.ts

@@ -34,6 +34,8 @@ import { behaviorGate } from '../lib/behavior-gate.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
 import { queryTestEvents, type TestEvent } from '../lib/event-log-query.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const FIXTURE = 'conformance-context-budget-multiturn';
 const PROFILE = 'openwop-context-summarization';
@@ -98,55 +100,55 @@ describe('context-summarization-replay (RFC 0111 §"Replay determinism")', () =>
     const ma = await readCapabilityFamily<MultiAgentCap>('multiAgent');
     const summarizationSupported = ma?.executionModel?.contextBudget?.summarization?.supported === true;
     if (!behaviorGate(PROFILE, summarizationSupported)) return;
-    if (!isFixtureAdvertised(FIXTURE)) return; // fixture-gated soft-skip
+    if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(FIXTURE)` returned early (fixture-gated soft-skip)'); // fixture-gated soft-skip
 
     // Drive the multi-turn orchestrator run.
     const create = await driver.post('/v1/runs', { workflowId: FIXTURE });
     expect(create.status).toBe(201);
     const sourceRunId = runIdOf(create.json);
-    expect(sourceRunId, 'POST /v1/runs MUST return a runId').toBeDefined();
-    if (sourceRunId === undefined) return;
+    expect(sourceRunId, req('openwop.it.context-summarization-replay.replay-reuses-the-recorded-context-summarized-summaryref-never-re-summarizes', 'rest-endpoints.md POST /v1/runs/{runId}:fork', 'POST /v1/runs MUST return a runId')).toBeDefined();
+    if (sourceRunId === undefined) return softSkip('blocked', 'precondition not met — `sourceRunId === undefined` returned early (seam, prior step, or fixture unavailable)');
     await pollUntilTerminal(sourceRunId);
 
     // Read the recorded summarization records (OPTIONAL event-log seam).
     const sourceQ = await queryTestEvents(sourceRunId, { type: 'context.summarized' });
-    if (!sourceQ.ok) return; // event-log seam unwired — soft-skip
+    if (!sourceQ.ok) return softSkip('blocked', 'precondition not met — `!sourceQ.ok` returned early (event-log seam unwired — soft-skip) (seam, prior step, or fixture unavailable)'); // event-log seam unwired — soft-skip
     const sourceFingerprints = summaryFingerprints(sourceQ.events);
     if (sourceFingerprints.length === 0) {
       // The run did not summarize (budget not exceeded on this host) — nothing
       // to prove about reuse. Honest soft-skip; not a vacuous pass of the MUST.
       // eslint-disable-next-line no-console
       console.warn(`[${PROFILE}] run produced no context.summarized events; replay-reuse leg soft-skipped`);
-      return;
+      return softSkip('blocked', 'precondition not met — `sourceFingerprints.length === 0` returned early ([…] run produced no context.summarized events; replay-reuse leg soft-skipped) (seam, prior step, or fixture unavailable)');
     }
 
     // Only attempt replay when the host advertises the replay fork mode.
     const wellKnown = await driver.get('/.well-known/openwop');
-    if (!replayModesOf(wellKnown.json).includes('replay')) return;
+    if (!replayModesOf(wellKnown.json).includes('replay')) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!replayModesOf(wellKnown.json).includes(\'replay\')` returned early');
 
     const fork = await driver.post(
       `/v1/runs/${encodeURIComponent(sourceRunId)}:fork`,
       { fromSeq: 0, mode: 'replay' },
     );
-    if (fork.status === 501 || fork.status === 404) return; // replay not implemented for this run — soft-skip
+    if (fork.status === 501 || fork.status === 404) return softSkip('blocked', 'precondition not met — `fork.status === 501 || fork.status === 404` returned early (replay not implemented for this run — soft-skip) (seam, prior step, or fixture unavailable)'); // replay not implemented for this run — soft-skip
     expect(
       fork.status,
-      driver.describe('rest-endpoints.md POST /v1/runs/{runId}:fork', 'replay fork MUST return 201'),
+      req('openwop.it.context-summarization-replay.replay-reuses-the-recorded-context-summarized-summaryref-never-re-summarizes', 'rest-endpoints.md POST /v1/runs/{runId}:fork', 'replay fork MUST return 201'),
     ).toBe(201);
     const forkRunId = runIdOf(fork.json);
-    expect(forkRunId, 'replay fork MUST return a runId').toBeDefined();
-    if (forkRunId === undefined) return;
+    expect(forkRunId, req('openwop.it.context-summarization-replay.replay-reuses-the-recorded-context-summarized-summaryref-never-re-summarizes', 'rest-endpoints.md POST /v1/runs/{runId}:fork', 'replay fork MUST return a runId')).toBeDefined();
+    if (forkRunId === undefined) return softSkip('blocked', 'precondition not met — `forkRunId === undefined` returned early (seam, prior step, or fixture unavailable)');
     await pollUntilTerminal(forkRunId);
 
     const forkQ = await queryTestEvents(forkRunId, { type: 'context.summarized' });
-    if (!forkQ.ok) return; // event-log seam unwired for the fork — soft-skip
+    if (!forkQ.ok) return softSkip('blocked', 'precondition not met — `!forkQ.ok` returned early (event-log seam unwired for the fork — soft-skip) (seam, prior step, or fixture unavailable)'); // event-log seam unwired for the fork — soft-skip
     const forkFingerprints = summaryFingerprints(forkQ.events);
 
     // The replay MUST reuse the recorded summaries (same summaryRef + replacedTurns),
     // NOT regenerate them — the direct analogue of RFC 0041 envelope-refusal recovery.
     expect(
       forkFingerprints,
-      driver.describe(
+      req('openwop.it.context-summarization-replay.replay-reuses-the-recorded-context-summarized-summaryref-never-re-summarizes', 
         'RFC 0111 §"Replay determinism"',
         'a replay fork MUST reuse the recorded context.summarized summaryRef (never re-summarize to a different transcript)',
       ),

package/src/scenarios/contract-provenance.test.ts

@@ -49,8 +49,8 @@ import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
 import { driver } from '../lib/driver.js';
 import { SCHEMAS_DIR } from '../lib/paths.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 provenanceSubschema(): Record<string, unknown> {
   const caps = JSON.parse(
@@ -73,11 +73,11 @@ describe('contract-provenance (RFC 0146, always-on)', () => {
 
     expect(
       caps.properties['contractProvenance'],
-      why('capabilities.schema.json', 'declared as a root property — families live at the document root per capabilities.md §"Document-root layout", never under the deprecated wrapper'),
+      req('openwop.it.contract-provenance.a1-declared-at-the-document-root-and-optional', 'capabilities.schema.json', 'declared as a root property — families live at the document root per capabilities.md §"Document-root layout", never under the deprecated wrapper'),
     ).toBeDefined();
     expect(
       (caps.required ?? []).includes('contractProvenance'),
-      why('RFC 0146 req 1', 'OPTIONAL — absent means UNSPECIFIED provenance, not "current" and not "stale"; a host must not be non-conformant for staying silent'),
+      req('openwop.it.contract-provenance.a1-declared-at-the-document-root-and-optional', 'RFC 0146 req 1', 'OPTIONAL — absent means UNSPECIFIED provenance, not "current" and not "stale"; a host must not be non-conformant for staying silent'),
     ).toBe(false);
   });
 
@@ -86,32 +86,32 @@ describe('contract-provenance (RFC 0146, always-on)', () => {
 
     expect(
       validate({ suiteVersion: '1.72.0', corpusCommit: '93d4692eb1e28244b860da6ddcb6521b57a712b3' }),
-      why('RFC 0146 req 4', `a real stamp validates: ${JSON.stringify(validate.errors)}`),
+      req('openwop.it.contract-provenance.a2-a-full-40-hex-commit-validates-a-short-sha-or-a-vendor-build-string-does-not', 'RFC 0146 req 4', `a real stamp validates: ${JSON.stringify(validate.errors)}`),
     ).toBe(true);
     // This is what keeps the field from decaying into a free-text version box. A short SHA is
     // ambiguous across a growing history; a vendor build id belongs in `implementation`, which
     // already exists for exactly that.
     expect(
       validate({ corpusCommit: '93d4692' }),
-      why('RFC 0146 req 4', 'a SHORT sha is REJECTED — abbreviated commits are ambiguous and this field is an identity, not a hint'),
+      req('openwop.it.contract-provenance.a2-a-full-40-hex-commit-validates-a-short-sha-or-a-vendor-build-string-does-not', 'RFC 0146 req 4', 'a SHORT sha is REJECTED — abbreviated commits are ambiguous and this field is an identity, not a hint'),
     ).toBe(false);
     expect(
       validate({ corpusCommit: 'build-4711' }),
-      why('RFC 0146 req 4', 'a vendor build identifier is REJECTED — `implementation` is the field for that'),
+      req('openwop.it.contract-provenance.a2-a-full-40-hex-commit-validates-a-short-sha-or-a-vendor-build-string-does-not', 'RFC 0146 req 4', 'a vendor build identifier is REJECTED — `implementation` is the field for that'),
     ).toBe(false);
   });
 
   it('A3 — both members optional, and unknown members rejected', () => {
     const validate = compiled();
 
-    expect(validate({}), why('RFC 0146 req 1', 'an empty object validates — a host may know neither')).toBe(true);
+    expect(validate({}), req('openwop.it.contract-provenance.a3-both-members-optional-and-unknown-members-rejected', 'RFC 0146 req 1', 'an empty object validates — a host may know neither')).toBe(true);
     expect(
       validate({ suiteVersion: '1.72.0' }),
-      why('RFC 0146 req 1', 'a host that knows only its suite version advertises only that'),
+      req('openwop.it.contract-provenance.a3-both-members-optional-and-unknown-members-rejected', 'RFC 0146 req 1', 'a host that knows only its suite version advertises only that'),
     ).toBe(true);
     expect(
       validate({ suiteVersion: '1.72.0', schemaDigest: 'abc' }),
-      why('RFC 0146 §Proposal', 'the object is closed — a digest is a DIFFERENT artifact answering a different question (tamper vs identity) and is deliberately not part of this shape'),
+      req('openwop.it.contract-provenance.a3-both-members-optional-and-unknown-members-rejected', 'RFC 0146 §Proposal', 'the object is closed — a digest is a DIFFERENT artifact answering a different question (tamper vs identity) and is deliberately not part of this shape'),
     ).toBe(false);
   });
 
@@ -135,7 +135,7 @@ describe('contract-provenance (RFC 0146, always-on)', () => {
     const rfc = rfcText ?? '';
     expect(
       /MUST NOT reject a request, refuse interop, or fail a run solely because/.test(rfc),
-      why('RFC 0146 req 3', 'a consumer MUST NOT reject on a mismatch — v1.x revisions are additive, so a host on an older revision is CONFORMANT and the field detects drift rather than creating an error'),
+      req('openwop.it.contract-provenance.a4-the-rfc-states-the-advisory-rule-which-is-what-stops-this-becoming-an-upgrade', 'RFC 0146 req 3', 'a consumer MUST NOT reject on a mismatch — v1.x revisions are additive, so a host on an older revision is CONFORMANT and the field detects drift rather than creating an error'),
     ).toBe(true);
   });
 });
@@ -156,14 +156,14 @@ function suiteStamp(): { suiteVersion?: string; corpusCommit?: string } | null {
 describe('contract-provenance: the suite READS the advert — the consumer half (RFC 0146 G3)', () => {
   it('compares the advertised revision against the suite\'s own, and reports drift', async () => {
     const mine = suiteStamp();
-    if (mine === null) return; // repo layout — inapplicable, see the docblock
+    if (mine === null) return softSkip('blocked', 'precondition not met — `mine === null` returned early (repo layout — inapplicable, see the docblock) (seam, prior step, or fixture unavailable)'); // repo layout — inapplicable, see the docblock
 
     const res = await driver.get('/.well-known/openwop');
-    if (res.status !== 200 || res.json === null || res.json === undefined) return;
+    if (res.status !== 200 || res.json === null || res.json === undefined) return softSkip('blocked', 'precondition not met — `res.status !== 200 || res.json === null || res.json === undefined` returned early (seam, prior step, or fixture unavailable)');
     const adv = (res.json as Record<string, unknown>)['contractProvenance'] as
       | { suiteVersion?: string; corpusCommit?: string }
       | undefined;
-    if (adv === undefined) return; // silent host — absent means UNSPECIFIED (req 1), not stale
+    if (adv === undefined) return softSkip('blocked', 'precondition not met — `adv === undefined` returned early (silent host — absent means UNSPECIFIED (req 1), not stale) (seam, prior step, or fixture unavailable)'); // silent host — absent means UNSPECIFIED (req 1), not stale
 
     const same = adv.corpusCommit !== undefined && adv.corpusCommit === mine.corpusCommit;
     console.log(
@@ -178,7 +178,7 @@ describe('contract-provenance: the suite READS the advert — the consumer half
     // because an unparseable provenance is useless to every consumer, not just this one.
     expect(
       typeof adv.corpusCommit === 'string' || typeof adv.suiteVersion === 'string',
-      driver.describe(
+      req('openwop.it.contract-provenance.compares-the-advertised-revision-against-the-suite-s-own-and-reports-drift', 
         'RFC 0146 req 1 + req 4',
         'an advertised contractProvenance carries at least one of suiteVersion / corpusCommit — an object conveying neither is indistinguishable from silence while looking like an answer',
       ),
@@ -189,18 +189,18 @@ describe('contract-provenance: the suite READS the advert — the consumer half
 describe('contract-provenance: a host advertising it makes a well-formed claim (RFC 0146)', () => {
   it('the advertised provenance validates against the declared shape', async () => {
     const res = await driver.get('/.well-known/openwop');
-    if (res.status !== 200 || res.json === null || res.json === undefined) return;
+    if (res.status !== 200 || res.json === null || res.json === undefined) return softSkip('blocked', 'precondition not met — `res.status !== 200 || res.json === null || res.json === undefined` returned early (seam, prior step, or fixture unavailable)');
 
     const doc = res.json as Record<string, unknown>;
     const adv = doc['contractProvenance'];
     // INAPPLICABLE, not gated. The field is OPTIONAL (req 1) and strict mode must not coerce a
     // host into advertising — the same call RFC 0142 makes for `store` and RFC 0145 for
     // `registrationSource`. Silence is an honest answer here.
-    if (adv === undefined) return;
+    if (adv === undefined) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `adv === undefined` returned early (INAPPLICABLE, not gated. The field is OPTIONAL (req 1) and strict mode must not coerce a host into advertising — the same ca…');
 
     expect(
       compiled()(adv),
-      driver.describe(
+      req('openwop.it.contract-provenance.the-advertised-provenance-validates-against-the-declared-shape', 
         'capabilities.schema.json §contractProvenance',
         `an advertised contractProvenance MUST match the declared shape — a full 40-hex corpusCommit and a published suiteVersion, nothing else: ${JSON.stringify(compiled().errors)}`,
       ),

package/src/scenarios/conversation-turn-model-provenance-shape.test.ts

@@ -35,8 +35,7 @@ import { join } from 'node:path';
 import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
 import { SCHEMAS_DIR } from '../lib/paths.js';
-
-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>;
@@ -60,36 +59,36 @@ describe('conversation-turn-model-provenance-shape: agent.model on a role:agent
   it('an agent turn carrying a conforming agent.model { provider, model } validates', () => {
     expect(
       turn({ ...agentBase, agent: { agentId: 'advisor-cfo', model: { provider: 'anthropic', model: 'claude-opus-4-8' } } }),
-      why('RFC 0109 §Proposal', "a role:'agent' turn with agent.model { provider, model } MUST validate"),
+      req('openwop.it.conversation-turn-model-provenance-shape.an-agent-turn-carrying-a-conforming-agent-model-provider-model-validates', 'RFC 0109 §Proposal', "a role:'agent' turn with agent.model { provider, model } MUST validate"),
     ).toBe(true);
   });
 
   it('agent.model REQUIRES both provider and model', () => {
     expect(
       turn({ ...agentBase, agent: { model: { provider: 'anthropic' } } }),
-      why('RFC 0109 §Proposal', 'agent.model without `model` MUST be rejected'),
+      req('openwop.it.conversation-turn-model-provenance-shape.agent-model-requires-both-provider-and-model', 'RFC 0109 §Proposal', 'agent.model without `model` MUST be rejected'),
     ).toBe(false);
     expect(
       turn({ ...agentBase, agent: { model: { model: 'claude-opus-4-8' } } }),
-      why('RFC 0109 §Proposal', 'agent.model without `provider` MUST be rejected'),
+      req('openwop.it.conversation-turn-model-provenance-shape.agent-model-requires-both-provider-and-model', 'RFC 0109 §Proposal', 'agent.model without `provider` MUST be rejected'),
     ).toBe(false);
   });
 
   it('agent.model is CLOSED — an extra key (a secret/endpoint/prompt) MUST be rejected (the SR-1 guard)', () => {
     expect(
       turn({ ...agentBase, agent: { model: { provider: 'anthropic', model: 'claude-opus-4-8', apiKey: 'sk-secret' } } }),
-      why('RFC 0109 §Proposal', 'agent.model MUST forbid extra keys — no credential/endpoint/prompt rides the provenance stamp'),
+      req('openwop.it.conversation-turn-model-provenance-shape.agent-model-is-closed-an-extra-key-a-secret-endpoint-prompt-must-be-rejected-the', 'RFC 0109 §Proposal', 'agent.model MUST forbid extra keys — no credential/endpoint/prompt rides the provenance stamp'),
     ).toBe(false);
   });
 
   it('agent.model is OPTIONAL — an agent turn that omits it still validates (additive, back-compat)', () => {
     expect(
       turn({ ...agentBase, agent: { agentId: 'advisor-cfo' } }),
-      why('RFC 0109 §Compatibility', 'agent.model is additive — a turn without it MUST still validate'),
+      req('openwop.it.conversation-turn-model-provenance-shape.agent-model-is-optional-an-agent-turn-that-omits-it-still-validates-additive-bac', 'RFC 0109 §Compatibility', 'agent.model is additive — a turn without it MUST still validate'),
     ).toBe(true);
     expect(
       turn(agentBase),
-      why('RFC 0109 §Compatibility', 'a turn with no agent object at all MUST still validate'),
+      req('openwop.it.conversation-turn-model-provenance-shape.agent-model-is-optional-an-agent-turn-that-omits-it-still-validates-additive-bac', 'RFC 0109 §Compatibility', 'a turn with no agent object at all MUST still validate'),
     ).toBe(true);
   });
 });
@@ -101,10 +100,10 @@ describe('conversation-turn-model-provenance-shape: capability advertisement (RF
     const block = props.conversationTurnModelProvenance as
       | { properties?: Record<string, unknown>; required?: string[]; additionalProperties?: boolean }
       | undefined;
-    expect(block, why('RFC 0109 §Conformance', 'capabilities.conversationTurnModelProvenance MUST be declared')).toBeDefined();
-    expect(block?.properties?.supported, why('RFC 0109 §Conformance', 'conversationTurnModelProvenance.supported MUST be declared')).toBeDefined();
-    expect(block?.required, why('RFC 0109 §Conformance', 'supported MUST be required on the block')).toContain('supported');
-    expect(block?.additionalProperties, why('RFC 0109 §Conformance', 'the block MUST be closed')).toBe(false);
+    expect(block, req('openwop.it.conversation-turn-model-provenance-shape.capabilities-schema-json-declares-conversationturnmodelprovenance-with-supported', 'RFC 0109 §Conformance', 'capabilities.conversationTurnModelProvenance MUST be declared')).toBeDefined();
+    expect(block?.properties?.supported, req('openwop.it.conversation-turn-model-provenance-shape.capabilities-schema-json-declares-conversationturnmodelprovenance-with-supported', 'RFC 0109 §Conformance', 'conversationTurnModelProvenance.supported MUST be declared')).toBeDefined();
+    expect(block?.required, req('openwop.it.conversation-turn-model-provenance-shape.capabilities-schema-json-declares-conversationturnmodelprovenance-with-supported', 'RFC 0109 §Conformance', 'supported MUST be required on the block')).toContain('supported');
+    expect(block?.additionalProperties, req('openwop.it.conversation-turn-model-provenance-shape.capabilities-schema-json-declares-conversationturnmodelprovenance-with-supported', 'RFC 0109 §Conformance', 'the block MUST be closed')).toBe(false);
   });
 
   it('the conversationTurnModelProvenance block validates a conforming advertisement and rejects extras', () => {
@@ -113,8 +112,8 @@ describe('conversation-turn-model-provenance-shape: capability advertisement (RF
     const ajv = new Ajv2020({ strict: false, allErrors: true });
     addFormats(ajv);
     const validate = ajv.compile(block);
-    expect(validate({ supported: true }), why('RFC 0109 §Conformance', 'a conforming advertisement MUST validate')).toBe(true);
-    expect(validate({}), why('RFC 0109 §Conformance', 'supported is required')).toBe(false);
-    expect(validate({ supported: true, unexpected: 1 }), why('RFC 0109 §Conformance', 'an extra key MUST be rejected (closed block)')).toBe(false);
+    expect(validate({ supported: true }), req('openwop.it.conversation-turn-model-provenance-shape.the-conversationturnmodelprovenance-block-validates-a-conforming-advertisement-a', 'RFC 0109 §Conformance', 'a conforming advertisement MUST validate')).toBe(true);
+    expect(validate({}), req('openwop.it.conversation-turn-model-provenance-shape.the-conversationturnmodelprovenance-block-validates-a-conforming-advertisement-a', 'RFC 0109 §Conformance', 'supported is required')).toBe(false);
+    expect(validate({ supported: true, unexpected: 1 }), req('openwop.it.conversation-turn-model-provenance-shape.the-conversationturnmodelprovenance-block-validates-a-conforming-advertisement-a', 'RFC 0109 §Conformance', 'an extra key MUST be rejected (closed block)')).toBe(false);
   });
 });

package/src/scenarios/conversationCapabilityNegotiation.test.ts

@@ -21,6 +21,7 @@ import { readErrorCode } from '../lib/error-envelope.js';
 import { driver } from '../lib/driver.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { isConversationPrimitiveSupported } from '../lib/multi-agent-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const FIXTURE = 'conformance-conversation-capability-negotiation';
 // Inverted gate: this scenario runs when host does NOT advertise the
@@ -33,7 +34,7 @@ describe.skipIf(SKIP)('conversationCapabilityNegotiation: refusal contract', ()
     // The host MUST reject — either at workflow registration (404/400)
     // or at run-create (400). What MUST NOT happen is a successful
     // 201 followed by silent fallback.
-    expect([400, 404, 422]).toContain(create.status);
+    expect([400, 404, 422], req('openwop.it.conversationCapabilityNegotiation.host-without-conversationprimitive-capability-refuses-conversation-bearing-workf', 'RFCS/0005-conversation.md', 'host without conversationPrimitive capability refuses conversation-bearing workflow')).toContain(create.status);
     const body = create.json as { code?: string };
     const code = readErrorCode(create.json) ?? body.code ?? '';
     expect(typeof code).toBe('string');

package/src/scenarios/conversationLifecycle.test.ts

@@ -22,6 +22,7 @@ import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { isConversationPrimitiveSupported } from '../lib/multi-agent-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const FIXTURE = 'conformance-conversation-lifecycle';
 const SKIP = !isConversationPrimitiveSupported() || !isFixtureAdvertised(FIXTURE);
@@ -29,7 +30,7 @@ const SKIP = !isConversationPrimitiveSupported() || !isFixtureAdvertised(FIXTURE
 describe.skipIf(SKIP)('conversationLifecycle: open → exchange → close round-trip', () => {
   it('emits all three lifecycle events with matching conversationId; no exchanges after close', async () => {
     const create = await driver.post('/v1/runs', { workflowId: FIXTURE });
-    expect(create.status).toBe(201);
+    expect(create.status, req('openwop.it.conversationLifecycle.emits-all-three-lifecycle-events-with-matching-conversationid-no-exchanges-after', 'RFCS/0005-conversation.md', 'emits all three lifecycle events with matching conversationId; no exchanges after close')).toBe(201);
     const runId = (create.json as { runId: string }).runId;
 
     // The fixture's exchange step requires resume input. Host-internal

package/src/scenarios/conversationReplayDeterminism.test.ts

@@ -19,6 +19,8 @@ import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { isConversationPrimitiveSupported } from '../lib/multi-agent-capabilities.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
 
 const FIXTURE = 'conformance-conversation-replay';
 const SKIP = !isConversationPrimitiveSupported() || !isFixtureAdvertised(FIXTURE);
@@ -26,7 +28,7 @@ const SKIP = !isConversationPrimitiveSupported() || !isFixtureAdvertised(FIXTURE
 describe.skipIf(SKIP)('conversationReplayDeterminism: replay-fork preserves conversation log', () => {
   it('forked run yields byte-equal conversation channel projection', async () => {
     const create = await driver.post('/v1/runs', { workflowId: FIXTURE });
-    expect(create.status).toBe(201);
+    expect(create.status, req('openwop.it.conversationReplayDeterminism.forked-run-yields-byte-equal-conversation-channel-projection', 'RFCS/0005-conversation.md', 'forked run yields byte-equal conversation channel projection')).toBe(201);
     const sourceRunId = (create.json as { runId: string }).runId;
 
     const terminal = await pollUntilTerminal(sourceRunId);
@@ -38,7 +40,7 @@ describe.skipIf(SKIP)('conversationReplayDeterminism: replay-fork preserves conv
     const fork = await driver.post(`/v1/runs/${encodeURIComponent(sourceRunId)}:fork`, {
       mode: 'replay',
     });
-    if (fork.status === 404 || fork.status === 501) return; // host doesn't support replay-fork
+    if (fork.status === 404 || fork.status === 501) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `fork.status === 404 || fork.status === 501` returned early (host doesn\'t support replay-fork)'); // host doesn't support replay-fork
     expect([200, 201]).toContain(fork.status);
 
     const forkedRunId = (fork.json as { runId: string }).runId;

package/src/scenarios/conversationVsLegacySuspend.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 { isConversationPrimitiveSupported } from '../lib/multi-agent-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const FIXTURE = 'conformance-conversation-vs-clarification';
 const SKIP = !isConversationPrimitiveSupported() || !isFixtureAdvertised(FIXTURE);
@@ -41,7 +42,7 @@ describe.skipIf(SKIP)('conversationVsLegacySuspend: distinct event surfaces', ()
     expect(conversationEvents.length).toBeGreaterThan(0);
     expect(
       clarificationEvents.length,
-      'conversation.exchange MUST NOT emit clarification.* events',
+      req('openwop.it.conversationVsLegacySuspend.conversation-suspend-emits-conversation-events-not-clarification', 'RFCS/0005-conversation.md', 'conversation.exchange MUST NOT emit clarification.* events'),
     ).toBe(0);
   });
 });

package/src/scenarios/core-standard-profile.test.ts

@@ -24,8 +24,7 @@
 
 import { describe, it, expect } from 'vitest';
 import { isCoreStandard, isCore, deriveProfiles } from '../lib/profiles.js';
-
-const why = (specRef: string, requirement: string): string => `${specRef} — ${requirement}`;
+import { req } from '../lib/requirement-ids.js';
 
 const CORE = {
   protocolVersion: '1.0',
@@ -38,29 +37,29 @@ describe('core-standard-profile: floor predicate (RFC 0088 §B, server-free)', (
   it('a host meeting core + interrupts + a default transport is core-standard', () => {
     // No supportedTransports ⇒ both stream predicates default-true (profiles.md).
     const c = { ...CORE };
-    expect(isCoreStandard(c), why('core-standard-profile.md §B', 'core + interrupts + transport ⇒ core-standard')).toBe(true);
+    expect(isCoreStandard(c), req('openwop.it.core-standard-profile.a-host-meeting-core-interrupts-a-default-transport-is-core-standard', 'core-standard-profile.md §B', 'core + interrupts + transport ⇒ core-standard')).toBe(true);
   });
 
   it('a bare openwop-core host without interrupts is NOT core-standard', () => {
     // openwop-core minimum, but no clarification.request ⇒ fails openwop-interrupts.
     const c = { ...CORE, supportedEnvelopes: ['schema.request'] };
-    expect(isCore(c), why('profiles.md §openwop-core', 'still a valid openwop-core host')).toBe(true);
-    expect(isCoreStandard(c), why('core-standard-profile.md §B', 'the floor is stricter than the v1 minimum')).toBe(false);
+    expect(isCore(c), req('openwop.it.core-standard-profile.a-bare-openwop-core-host-without-interrupts-is-not-core-standard', 'profiles.md §openwop-core', 'still a valid openwop-core host')).toBe(true);
+    expect(isCoreStandard(c), req('openwop.it.core-standard-profile.a-bare-openwop-core-host-without-interrupts-is-not-core-standard', 'core-standard-profile.md §B', 'the floor is stricter than the v1 minimum')).toBe(false);
   });
 
   it('a host advertising no event transport fails the floor', () => {
     const c = { ...CORE, supportedTransports: [] as string[] };
-    expect(isCoreStandard(c), why('core-standard-profile.md §B', 'at least one event transport is required')).toBe(false);
+    expect(isCoreStandard(c), req('openwop.it.core-standard-profile.a-host-advertising-no-event-transport-fails-the-floor', 'core-standard-profile.md §B', 'at least one event transport is required')).toBe(false);
   });
 
   it('a host advertising the rest transport satisfies the transport term', () => {
     const c = { ...CORE, supportedTransports: ['rest'] };
-    expect(isCoreStandard(c), why('core-standard-profile.md §B', 'rest transport ⇒ stream term satisfied')).toBe(true);
+    expect(isCoreStandard(c), req('openwop.it.core-standard-profile.a-host-advertising-the-rest-transport-satisfies-the-transport-term', 'core-standard-profile.md §B', 'rest transport ⇒ stream term satisfied')).toBe(true);
   });
 
   it('a non-1.x host is not core-standard', () => {
     const c = { ...CORE, protocolVersion: '2.0' };
-    expect(isCoreStandard(c), why('profiles.md §openwop-core', 'core-standard implies openwop-core (1.x)')).toBe(false);
+    expect(isCoreStandard(c), req('openwop.it.core-standard-profile.a-non-1-x-host-is-not-core-standard', 'profiles.md §openwop-core', 'core-standard implies openwop-core (1.x)')).toBe(false);
   });
 });
 
@@ -69,7 +68,7 @@ describe('core-standard-profile: composes, does not redefine (RFC 0088 §A, serv
     const c = { ...CORE };
     expect(
       (deriveProfiles(c) as readonly string[]).includes('openwop-core-standard'),
-      why('core-standard-profile.md §A', 'the annex is not a closed-catalog predicate'),
+      req('openwop.it.core-standard-profile.openwop-core-standard-is-an-annex-not-a-closed-catalog-profile-absent-from-deriv', 'core-standard-profile.md §A', 'the annex is not a closed-catalog predicate'),
     ).toBe(false);
   });
 });