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

package/src/scenarios/commitment-fired.test.ts

@@ -20,6 +20,7 @@
 import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
+import { req } from '../lib/requirement-ids.js';
 
 interface CommitmentCaps {
   agents?: { commitments?: { supported?: boolean } };
@@ -54,14 +55,14 @@ describe('commitment-fired: fire contract (RFC 0068 §C, capability-gated)', ()
     });
     if (res.status === 404 || res.status === 501) return softSkip('blocked', 'seam not wired — soft-skip');
 
-    expect(res.status, driver.describe('RFC 0068 §C', 'an advertised commitment seam MUST succeed')).toBe(200);
+    expect(res.status, req('openwop.it.commitment-fired.a-fired-commitment-emits-a-content-free-event-with-memory-provenance-exactly-onc', 'RFC 0068 §C', 'an advertised commitment seam MUST succeed')).toBe(200);
     const r = res.json as FireResult;
 
     // §C — required identifiers.
-    expect(r.event?.commitmentId, driver.describe('RFC 0068 §C', 'commitment.fired MUST carry commitmentId')).toBeTruthy();
+    expect(r.event?.commitmentId, req('openwop.it.commitment-fired.a-fired-commitment-emits-a-content-free-event-with-memory-provenance-exactly-onc', 'RFC 0068 §C', 'commitment.fired MUST carry commitmentId')).toBeTruthy();
     expect(
       r.event?.memoryRef,
-      driver.describe('RFC 0068 §C.1', 'commitment.fired MUST carry the source memoryRef (CTI-1 provenance)'),
+      req('openwop.it.commitment-fired.a-fired-commitment-emits-a-content-free-event-with-memory-provenance-exactly-onc', 'RFC 0068 §C.1', 'commitment.fired MUST carry the source memoryRef (CTI-1 provenance)'),
     ).toBeTruthy();
 
     // §C.3 — content-free: the inferred intention text MUST NOT appear on the event.
@@ -69,7 +70,7 @@ describe('commitment-fired: fire contract (RFC 0068 §C, capability-gated)', ()
       const serialized = JSON.stringify(r.event ?? {});
       expect(
         serialized.includes(r.intentionCanary),
-        driver.describe('RFC 0068 §C.3', 'the inferred intention text MUST NOT appear on the commitment.fired payload'),
+        req('openwop.it.commitment-fired.a-fired-commitment-emits-a-content-free-event-with-memory-provenance-exactly-onc', 'RFC 0068 §C.3', 'the inferred intention text MUST NOT appear on the commitment.fired payload'),
       ).toBe(false);
     }
 
@@ -77,7 +78,7 @@ describe('commitment-fired: fire contract (RFC 0068 §C, capability-gated)', ()
     if (typeof r.fireCount === 'number') {
       expect(
         r.fireCount,
-        driver.describe('RFC 0068 §C.2', 'a commitment MUST fire at most once per satisfied condition'),
+        req('openwop.it.commitment-fired.a-fired-commitment-emits-a-content-free-event-with-memory-provenance-exactly-onc', 'RFC 0068 §C.2', 'a commitment MUST fire at most once per satisfied condition'),
       ).toBeLessThanOrEqual(1);
     }
   });

package/src/scenarios/compensation-behavior.test.ts

@@ -44,6 +44,7 @@ import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
+import { req } from '../lib/requirement-ids.js';
 
 const PROFILE = 'openwop-compensation';
 
@@ -76,7 +77,7 @@ describe('RFC 0151 §C — compensation lifecycle (capability-gated behavior)',
     const caps = capabilityFamily<CompensationCaps>(disco.json, 'compensation');
     expect(
       caps?.orderingModels ?? [],
-      driver.describe(
+      req('openwop.it.compensation-behavior.a-host-advertising-compensation-implements-reverse-completion', 
         'RFCS/0151-compensation-and-partial-failure-profile.md §A',
         'an advertising host MUST implement `reverse-completion`; `dependency-graph` is optional',
       ),
@@ -93,23 +94,23 @@ describe('RFC 0151 §C — compensation lifecycle (capability-gated behavior)',
     if (seam.status === 404) {
       expect(
         seam.status,
-        driver.describe(
+        req('openwop.it.compensation-behavior.the-plan-is-persisted-before-the-first-inverse-action', 
           'RFCS/0151 §C',
           'a host advertising `compensation` MUST expose the unwind sample seam so plan-before-effect ' +
             'ordering can be witnessed; without it the requirement is unobservable and the profile ' +
             'cannot be certified (RFC 0148 §A: unobservable resolves to `blocked`, not to a pass)',
         ),
       ).not.toBe(404);
-      return;
+      return softSkip('blocked', 'precondition not met — `seam.status === 404` returned early (seam, prior step, or fixture unavailable)');
     }
     const events = (seam.json as { events?: { type: string }[] }).events ?? [];
     const requestedAt = events.findIndex((e) => e.type === 'compensation.requested');
     const startedAt = events.findIndex((e) => e.type === 'compensation.started');
-    expect(requestedAt, driver.describe('RFCS/0151 §D', '`compensation.requested` MUST be emitted')).toBeGreaterThanOrEqual(0);
-    expect(startedAt, driver.describe('RFCS/0151 §D', '`compensation.started` MUST be emitted')).toBeGreaterThanOrEqual(0);
+    expect(requestedAt, req('openwop.it.compensation-behavior.the-plan-is-persisted-before-the-first-inverse-action', 'RFCS/0151 §D', '`compensation.requested` MUST be emitted')).toBeGreaterThanOrEqual(0);
+    expect(startedAt, req('openwop.it.compensation-behavior.the-plan-is-persisted-before-the-first-inverse-action', 'RFCS/0151 §D', '`compensation.started` MUST be emitted')).toBeGreaterThanOrEqual(0);
     expect(
       requestedAt,
-      driver.describe(
+      req('openwop.it.compensation-behavior.the-plan-is-persisted-before-the-first-inverse-action', 
         'RFCS/0151 §C',
         'the plan MUST be persisted BEFORE the first inverse action executes',
       ),
@@ -119,12 +120,12 @@ describe('RFC 0151 §C — compensation lifecycle (capability-gated behavior)',
   it('inverse actions run in descending forward-completion order', async () => {
     if (!behaviorGate(PROFILE, await advertised())) return;
     const seam = await driver.post('/v1/host/sample/test/compensation/unwind', { nodes: 3 });
-    if (seam.status === 404) return; // covered by the seam assertion above
+    if (seam.status === 404) return softSkip('blocked', 'precondition not met — `seam.status === 404` returned early (covered by the seam assertion above) (seam, prior step, or fixture unavailable)'); // covered by the seam assertion above
     const order = (seam.json as { compensatedOrder?: number[] }).compensatedOrder ?? [];
     const descending = [...order].sort((a, b) => b - a);
     expect(
       order,
-      driver.describe(
+      req('openwop.it.compensation-behavior.inverse-actions-run-in-descending-forward-completion-order', 
         'RFCS/0151 §C',
         '`reverse-completion` orders compensations by DESCENDING durable forward-completion ' +
           'sequence. Compensating forward can release a resource a later inverse action still needs.',
@@ -135,10 +136,10 @@ describe('RFC 0151 §C — compensation lifecycle (capability-gated behavior)',
   it('replay does not re-fire inverse effects', async () => {
     if (!behaviorGate(PROFILE, await advertised())) return;
     const seam = await driver.post('/v1/host/sample/test/compensation/replay', {});
-    if (seam.status === 404) return;
+    if (seam.status === 404) return softSkip('blocked', 'precondition not met — `seam.status === 404` returned early (seam, prior step, or fixture unavailable)');
     expect(
       (seam.json as { refiredEffects?: number }).refiredEffects ?? 0,
-      driver.describe(
+      req('openwop.it.compensation-behavior.replay-does-not-re-fire-inverse-effects', 
         'RFCS/0151 §F',
         'replay defaults MUST use recorded compensation outcomes and MUST NOT re-fire inverse ' +
           'effects — a replay that re-executes them turns a recovery into a second outage',
@@ -149,22 +150,22 @@ describe('RFC 0151 §C — compensation lifecycle (capability-gated behavior)',
   it('the run snapshot carries the §D rollup, and it agrees with the events', async () => {
     if (!behaviorGate(PROFILE, await advertised())) return;
     const seam = await driver.post('/v1/host/sample/test/compensation/unwind', {});
-    if (seam.status === 404) return; // covered by the seam assertion above
+    if (seam.status === 404) return softSkip('blocked', 'precondition not met — `seam.status === 404` returned early (covered by the seam assertion above) (seam, prior step, or fixture unavailable)'); // covered by the seam assertion above
     const body = seam.json as { runId?: string; events?: { type: string }[] };
     expect(
       typeof body.runId === 'string' && body.runId.length > 0,
-      driver.describe(
+      req('openwop.it.compensation-behavior.the-run-snapshot-carries-the-d-rollup-and-it-agrees-with-the-events', 
         'host-sample-test-seams.md §21',
         'the unwind seam MUST return the `runId` it created — without it the §D rollup has no ' +
           'black-box path to a witness and lands as another shape-only claim',
       ),
     ).toBe(true);
     const snap = await driver.get(`/v1/runs/${encodeURIComponent(body.runId ?? '')}`);
-    expect(snap.status, driver.describe('rest-endpoints.md', 'GET /v1/runs/{runId} for the seam run')).toBe(200);
+    expect(snap.status, req('openwop.it.compensation-behavior.the-run-snapshot-carries-the-d-rollup-and-it-agrees-with-the-events', 'rest-endpoints.md', 'GET /v1/runs/{runId} for the seam run')).toBe(200);
     const status = (snap.json as { compensationStatus?: unknown }).compensationStatus;
     expect(
       status,
-      driver.describe(
+      req('openwop.it.compensation-behavior.the-run-snapshot-carries-the-d-rollup-and-it-agrees-with-the-events', 
         'compensation.md §"Run rollup: compensationStatus"',
         'a host that advertises `compensation` MUST include `compensationStatus` on every snapshot ' +
           '(`none` when idle) — presence is the wire witness of the advert',
@@ -187,17 +188,17 @@ describe('RFC 0151 §C — compensation lifecycle (capability-gated behavior)',
     if (expected === null) {
       expect(
         ['running', 'partial', 'failed'].includes(String(status)),
-        driver.describe(
+        req('openwop.it.compensation-behavior.the-run-snapshot-carries-the-d-rollup-and-it-agrees-with-the-events', 
           'compensation.md §"Run rollup: compensationStatus"',
           'an unwind that started and did not complete MUST report `running`, `partial`, or `failed` ' +
             `— got ${String(status)}`,
         ),
       ).toBe(true);
-      return;
+      return softSkip('blocked', 'precondition not met — `expected === null` returned early (seam, prior step, or fixture unavailable)');
     }
     expect(
       status,
-      driver.describe(
+      req('openwop.it.compensation-behavior.the-run-snapshot-carries-the-d-rollup-and-it-agrees-with-the-events', 
         'compensation.md §"Run rollup: compensationStatus"',
         `the rollup MUST be the deterministic fold of the compensation.* events — events ${JSON.stringify(types)} fold to \`${expected}\``,
       ),
@@ -207,7 +208,7 @@ describe('RFC 0151 §C — compensation lifecycle (capability-gated behavior)',
   it('compensation events carry no provider bodies or credentials', async () => {
     if (!behaviorGate(PROFILE, await advertised())) return;
     const seam = await driver.post('/v1/host/sample/test/compensation/unwind', {});
-    if (seam.status === 404) return;
+    if (seam.status === 404) return softSkip('blocked', 'precondition not met — `seam.status === 404` returned early (seam, prior step, or fixture unavailable)');
     const events = (seam.json as { events?: Record<string, unknown>[] }).events ?? [];
     for (const e of events) {
       if (!COMPENSATION_EVENTS.includes(e['type'] as (typeof COMPENSATION_EVENTS)[number])) continue;
@@ -215,7 +216,7 @@ describe('RFC 0151 §C — compensation lifecycle (capability-gated behavior)',
       for (const forbidden of ['-----BEGIN', 'Bearer ', 'sk-', 'authorization', 'providerResponse']) {
         expect(
           serialized.toLowerCase().includes(forbidden.toLowerCase()),
-          driver.describe(
+          req('openwop.it.compensation-behavior.compensation-events-carry-no-provider-bodies-or-credentials', 
             'RFCS/0151 §D + §G',
             'compensation event payloads carry opaque IDs and closed reason codes — never provider ' +
               'bodies or credentials. These land in the DURABLE log, which is the least revocable ' +
@@ -257,7 +258,7 @@ describe('RFC 0151 §C — compensation lifecycle (capability-gated behavior)',
     const body = seam.json as { runId?: string; events?: { type: string }[] };
     expect(
       typeof body.runId === 'string' && body.runId.length > 0,
-      driver.describe('host-sample-test-seams.md §21', '`fail: false` MUST still return the runId it created'),
+      req('openwop.it.compensation-behavior.a-healthy-run-that-declares-a-compensator-reports-compensationstatus-none-sp-11a', 'host-sample-test-seams.md §21', '`fail: false` MUST still return the runId it created'),
     ).toBe(true);
 
     // Positive control: the seam really did run a healthy compensator-declaring
@@ -274,12 +275,12 @@ describe('RFC 0151 §C — compensation lifecycle (capability-gated behavior)',
     }
 
     const snap = await driver.get(`/v1/runs/${encodeURIComponent(body.runId ?? '')}`);
-    expect(snap.status, driver.describe('rest-endpoints.md', 'GET /v1/runs/{runId} for the healthy seam run')).toBe(200);
+    expect(snap.status, req('openwop.it.compensation-behavior.a-healthy-run-that-declares-a-compensator-reports-compensationstatus-none-sp-11a', 'rest-endpoints.md', 'GET /v1/runs/{runId} for the healthy seam run')).toBe(200);
     const snapshot = snap.json as { status?: unknown; compensationStatus?: unknown };
 
     expect(
       snapshot.compensationStatus,
-      driver.describe(
+      req('openwop.it.compensation-behavior.a-healthy-run-that-declares-a-compensator-reports-compensationstatus-none-sp-11a', 
         'compensation.md §"Run rollup: compensationStatus"',
         'a host advertising `compensation` MUST carry the field on EVERY snapshot — presence is the wire witness of the advert',
       ),
@@ -287,7 +288,7 @@ describe('RFC 0151 §C — compensation lifecycle (capability-gated behavior)',
 
     expect(
       snapshot.compensationStatus,
-      driver.describe(
+      req('openwop.it.compensation-behavior.a-healthy-run-that-declares-a-compensator-reports-compensationstatus-none-sp-11a', 
         'compensation.md §"Run rollup: compensationStatus"',
         'a run that completed while declaring compensable nodes has nothing to unwind: no `compensation.requested` ' +
           'was recorded, so the fold is `none`. `pending` here means the rollup was derived from obligation ROWS ' +

package/src/scenarios/compensation-recovery.test.ts

@@ -55,6 +55,7 @@ import { behaviorGate } from '../lib/behavior-gate.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 import { seamAbsent, softSkip } from '../lib/soft-skip.js';
 import { readErrorCode, readRetriable } from '../lib/error-envelope.js';
+import { req } from '../lib/requirement-ids.js';
 
 const PROFILE = 'openwop-compensation';
 const UNWIND = '/v1/host/sample/test/compensation/unwind';
@@ -112,29 +113,29 @@ describe('RFC 0151 §C — inverse-action identity is retry-stable (capability-g
   it('a transient inverse failure retries under the SAME identity and the same downstream key', async () => {
     if (!behaviorGate(PROFILE, await advertised())) return;
     const r = await post(UNWIND, { nodes: 2, failFirstInverseAttempts: 2 });
-    if (r === null) return;
-    expect(r.status, driver.describe('spec/v1/host-sample-test-seams.md §21', 'unwind seam answers 200')).toBe(200);
+    if (r === null) return softSkip('blocked', 'precondition not met — `r === null` returned early (seam, prior step, or fixture unavailable)');
+    expect(r.status, req('openwop.it.compensation-recovery.a-transient-inverse-failure-retries-under-the-same-identity-and-the-same-downstr', 'spec/v1/host-sample-test-seams.md §21', 'unwind seam answers 200')).toBe(200);
     const body = r.json as UnwindResponse;
     if (!Array.isArray(body.inverseActions)) return extensionAbsent('`unwind` did not return `inverseActions[]`');
     // Under reverse-completion the first inverse to run is the highest forward ordinal (2).
     const first = body.inverseActions.find((a) => a.ordinal === 2) ?? body.inverseActions[0];
-    expect(first, driver.describe('spec/v1/host-sample-test-seams.md §21', 'one entry per plan entry')).toBeDefined();
+    expect(first, req('openwop.it.compensation-recovery.a-transient-inverse-failure-retries-under-the-same-identity-and-the-same-downstr', 'spec/v1/host-sample-test-seams.md §21', 'one entry per plan entry')).toBeDefined();
     const a = first as InverseAction;
-    expect(a.attempts, driver.describe('RFCS/0151 §C', 'two transient failures then success is THREE attempts of one obligation')).toBe(3);
-    expect(a.outcome, driver.describe('RFCS/0151 §C', 'a transient failure MUST be retryable — the action completes')).toBe('completed');
-    expect(Array.isArray(a.downstreamKeys) ? a.downstreamKeys.length : -1, driver.describe('spec/v1/host-sample-test-seams.md §21', '`downstreamKeys` has one entry per attempt')).toBe(3);
+    expect(a.attempts, req('openwop.it.compensation-recovery.a-transient-inverse-failure-retries-under-the-same-identity-and-the-same-downstr', 'RFCS/0151 §C', 'two transient failures then success is THREE attempts of one obligation')).toBe(3);
+    expect(a.outcome, req('openwop.it.compensation-recovery.a-transient-inverse-failure-retries-under-the-same-identity-and-the-same-downstr', 'RFCS/0151 §C', 'a transient failure MUST be retryable — the action completes')).toBe('completed');
+    expect(Array.isArray(a.downstreamKeys) ? a.downstreamKeys.length : -1, req('openwop.it.compensation-recovery.a-transient-inverse-failure-retries-under-the-same-identity-and-the-same-downstr', 'spec/v1/host-sample-test-seams.md §21', '`downstreamKeys` has one entry per attempt')).toBe(3);
     const distinct = new Set(a.downstreamKeys ?? []);
     expect(
       distinct.size,
-      driver.describe(
+      req('openwop.it.compensation-recovery.a-transient-inverse-failure-retries-under-the-same-identity-and-the-same-downstr', 
         'RFCS/0151 §C + RFC 0150 §B',
         'a retry re-presents the SAME inverse-action identity as its idempotency key — a second key at the downstream is a second obligation (two refunds). `attempt` is outside the identity for exactly this reason.',
       ),
     ).toBe(1);
     // One obligation per ordinal: no duplicate plan entries.
     const ordinals = body.inverseActions.map((x) => x.ordinal);
-    expect(new Set(ordinals).size, driver.describe('RFCS/0151 §C', 'exactly one plan entry per forward ordinal')).toBe(ordinals.length);
-    expect(typeof a.effectId === 'string' && a.effectId.length > 0, driver.describe('RFCS/0151 §D', 'the identity is carried as an opaque `effectId`')).toBe(true);
+    expect(new Set(ordinals).size, req('openwop.it.compensation-recovery.a-transient-inverse-failure-retries-under-the-same-identity-and-the-same-downstr', 'RFCS/0151 §C', 'exactly one plan entry per forward ordinal')).toBe(ordinals.length);
+    expect(typeof a.effectId === 'string' && a.effectId.length > 0, req('openwop.it.compensation-recovery.a-transient-inverse-failure-retries-under-the-same-identity-and-the-same-downstr', 'RFCS/0151 §D', 'the identity is carried as an opaque `effectId`')).toBe(true);
   });
 });
 
@@ -142,7 +143,7 @@ describe('RFC 0151 §E — operator authority is bound to the plan\'s tenant (ca
   it('cross-tenant is neutralized (404), same-tenant non-operator is refused and audited (403), the operator acts (200)', async () => {
     if (!behaviorGate(PROFILE, await advertised())) return;
     const held = await post(UNWIND, { nodes: 2, hold: true });
-    if (held === null) return;
+    if (held === null) return softSkip('blocked', 'precondition not met — `held === null` returned early (seam, prior step, or fixture unavailable)');
     const body = held.json as UnwindResponse;
     const runId = body.runId;
     if (typeof runId !== 'string') return extensionAbsent('`unwind` did not return a `runId`');
@@ -151,8 +152,8 @@ describe('RFC 0151 §E — operator authority is bound to the plan\'s tenant (ca
     if (heldEntry === undefined && !manual) return extensionAbsent('`unwind` with `hold: true` produced neither a held plan entry nor `compensation.manual_intervention_required`');
     // Snapshot must read `manual` while held (§D fold).
     const snap = await driver.get(`/v1/runs/${encodeURIComponent(runId)}`);
-    expect(snap.status, driver.describe('rest-endpoints.md', 'GET /v1/runs/{runId} for the held run')).toBe(200);
-    expect((snap.json as { compensationStatus?: string }).compensationStatus, driver.describe('spec/v1/compensation.md §D', 'a held plan reads `manual`')).toBe('manual');
+    expect(snap.status, req('openwop.it.compensation-recovery.cross-tenant-is-neutralized-404-same-tenant-non-operator-is-refused-and-audited', 'rest-endpoints.md', 'GET /v1/runs/{runId} for the held run')).toBe(200);
+    expect((snap.json as { compensationStatus?: string }).compensationStatus, req('openwop.it.compensation-recovery.cross-tenant-is-neutralized-404-same-tenant-non-operator-is-refused-and-audited', 'spec/v1/compensation.md §D', 'a held plan reads `manual`')).toBe('manual');
 
     const op = async (actor: Record<string, unknown>) =>
       driver.post(OPERATOR, { runId, action: 'retry', actor });
@@ -161,28 +162,28 @@ describe('RFC 0151 §E — operator authority is bound to the plan\'s tenant (ca
     if (cross.status === 404 && readErrorCode(cross.json) === undefined && (cross.json === null || cross.json === undefined || Object.keys(cross.json as object).length === 0)) {
       return extensionAbsent(`${OPERATOR} answered a bodiless 404 — the operator seam is absent (an absent seam and a neutralized cross-tenant plan must be told apart by the envelope: RFC 0132 §A.2 answers \`not_found\` in the canonical envelope)`);
     }
-    expect(cross.status, driver.describe('RFCS/0151 §E + RFC 0132 §A.2', 'an actor from another tenant MUST NOT learn the plan exists — 404, not 403')).toBe(404);
-    expect(readErrorCode(cross.json), driver.describe('rest-endpoints.md §Error codes', '`not_found` — do not leak existence')).toBe('not_found');
+    expect(cross.status, req('openwop.it.compensation-recovery.cross-tenant-is-neutralized-404-same-tenant-non-operator-is-refused-and-audited', 'RFCS/0151 §E + RFC 0132 §A.2', 'an actor from another tenant MUST NOT learn the plan exists — 404, not 403')).toBe(404);
+    expect(readErrorCode(cross.json), req('openwop.it.compensation-recovery.cross-tenant-is-neutralized-404-same-tenant-non-operator-is-refused-and-audited', 'rest-endpoints.md §Error codes', '`not_found` — do not leak existence')).toBe('not_found');
     // 2. Same tenant, no operator authority: refused AND audited.
     const plain = await op({ tenantId: 'default', principalId: 'conformance-bystander', operator: false });
-    expect(plain.status, driver.describe('RFCS/0151 §E', 'a principal without operator authority in the plan\'s tenant is refused')).toBe(403);
-    expect(readErrorCode(plain.json), driver.describe('rest-endpoints.md §Error codes', '`forbidden`')).toBe('forbidden');
-    expect(readRetriable(plain.json), driver.describe('spec/v1/host-sample-test-seams.md §21', 'a refused override is not retriable')).toBe(false);
+    expect(plain.status, req('openwop.it.compensation-recovery.cross-tenant-is-neutralized-404-same-tenant-non-operator-is-refused-and-audited', 'RFCS/0151 §E', 'a principal without operator authority in the plan\'s tenant is refused')).toBe(403);
+    expect(readErrorCode(plain.json), req('openwop.it.compensation-recovery.cross-tenant-is-neutralized-404-same-tenant-non-operator-is-refused-and-audited', 'rest-endpoints.md §Error codes', '`forbidden`')).toBe('forbidden');
+    expect(readRetriable(plain.json), req('openwop.it.compensation-recovery.cross-tenant-is-neutralized-404-same-tenant-non-operator-is-refused-and-audited', 'spec/v1/host-sample-test-seams.md §21', 'a refused override is not retriable')).toBe(false);
     // 3. The operator: acts, audited, rollup moves off `manual`.
     const ok = await op({ tenantId: 'default', principalId: 'conformance-operator', operator: true });
-    expect(ok.status, driver.describe('RFCS/0151 §E', 'an authorized operator MAY retry a held inverse action')).toBe(200);
+    expect(ok.status, req('openwop.it.compensation-recovery.cross-tenant-is-neutralized-404-same-tenant-non-operator-is-refused-and-audited', 'RFCS/0151 §E', 'an authorized operator MAY retry a held inverse action')).toBe(200);
     const res = ok.json as { compensationStatus?: string; audited?: boolean; planVersion?: unknown };
-    expect(res.audited, driver.describe('RFCS/0151 §E', 'every override MUST be audited (`authorization.decided`)')).toBe(true);
+    expect(res.audited, req('openwop.it.compensation-recovery.cross-tenant-is-neutralized-404-same-tenant-non-operator-is-refused-and-audited', 'RFCS/0151 §E', 'every override MUST be audited (`authorization.decided`)')).toBe(true);
     expect(
       ['completed', 'partial', 'failed', 'running'],
-      driver.describe('spec/v1/compensation.md §D', 'after the operator retries, the rollup is whatever the recorded outcomes yield — never still `manual` for a resolved hold'),
+      req('openwop.it.compensation-recovery.cross-tenant-is-neutralized-404-same-tenant-non-operator-is-refused-and-audited', 'spec/v1/compensation.md §D', 'after the operator retries, the rollup is whatever the recorded outcomes yield — never still `manual` for a resolved hold'),
     ).toContain(res.compensationStatus);
     // The refusal in step 2 was audited too: the plan's events carry a reason.
     const after = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/events`);
     if (after.status === 200) {
       const evs = (after.json as { events?: Array<{ type?: string; payload?: Record<string, unknown> }> }).events ?? [];
       const decided = evs.filter((e) => e.type === 'authorization.decided');
-      expect(decided.length, driver.describe('RFCS/0151 §E + RFC 0049', 'both the refusal and the override are `authorization.decided` records')).toBeGreaterThanOrEqual(2);
+      expect(decided.length, req('openwop.it.compensation-recovery.cross-tenant-is-neutralized-404-same-tenant-non-operator-is-refused-and-audited', 'RFCS/0151 §E + RFC 0049', 'both the refusal and the override are `authorization.decided` records')).toBeGreaterThanOrEqual(2);
     }
   });
 });
@@ -191,23 +192,23 @@ describe('RFC 0151 §B/§F — inverse inputs are recorded facts, not re-derived
   it('a replay executes the same inverse actions with the same inputs, and re-fires nothing', async () => {
     if (!behaviorGate(PROFILE, await advertised())) return;
     const r = await post(REPLAY, {});
-    if (r === null) return;
-    expect(r.status, driver.describe('spec/v1/host-sample-test-seams.md §21', 'replay seam answers 200')).toBe(200);
+    if (r === null) return softSkip('blocked', 'precondition not met — `r === null` returned early (seam, prior step, or fixture unavailable)');
+    expect(r.status, req('openwop.it.compensation-recovery.a-replay-executes-the-same-inverse-actions-with-the-same-inputs-and-re-fires-not', 'spec/v1/host-sample-test-seams.md §21', 'replay seam answers 200')).toBe(200);
     const body = r.json as ReplayResponse;
     if (!Array.isArray(body.source) || !Array.isArray(body.replayed)) return extensionAbsent('`replay` did not return `source[]` / `replayed[]`');
-    expect(body.refiredEffects, driver.describe('RFCS/0151 §F', 'replay MUST NOT re-fire inverse effects')).toBe(0);
-    expect(body.source.length, driver.describe('spec/v1/host-sample-test-seams.md §21', 'the source run had inverse actions to compare')).toBeGreaterThan(0);
+    expect(body.refiredEffects, req('openwop.it.compensation-recovery.a-replay-executes-the-same-inverse-actions-with-the-same-inputs-and-re-fires-not', 'RFCS/0151 §F', 'replay MUST NOT re-fire inverse effects')).toBe(0);
+    expect(body.source.length, req('openwop.it.compensation-recovery.a-replay-executes-the-same-inverse-actions-with-the-same-inputs-and-re-fires-not', 'spec/v1/host-sample-test-seams.md §21', 'the source run had inverse actions to compare')).toBeGreaterThan(0);
     const norm = (xs: readonly InverseAction[]) =>
       [...xs].sort((a, b) => (a.ordinal ?? 0) - (b.ordinal ?? 0)).map((x) => ({ ordinal: x.ordinal, effectId: x.effectId, input: x.input }));
     expect(
       norm(body.replayed),
-      driver.describe(
+      req('openwop.it.compensation-recovery.a-replay-executes-the-same-inverse-actions-with-the-same-inputs-and-re-fires-not', 
         'RFCS/0151 §B + §F',
         'a replay uses the RECORDED inverse inputs and identities — an inverse built from a re-derived (prompt / model / live) value is not the inverse of what was actually done',
       ),
     ).toEqual(norm(body.source));
     for (const x of body.source) {
-      expect(x.input, driver.describe('RFCS/0151 §B', 'each inverse action executed with a recorded input')).toBeDefined();
+      expect(x.input, req('openwop.it.compensation-recovery.a-replay-executes-the-same-inverse-actions-with-the-same-inputs-and-re-fires-not', 'RFCS/0151 §B', 'each inverse action executed with a recorded input')).toBeDefined();
     }
   });
 });

package/src/scenarios/configurable-schema.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 { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 // Re-use `conformance-identity` if it advertises a configurableSchema;
 // otherwise the scenario soft-skips. Hosts adopting v1.1 SHOULD seed a
@@ -44,13 +46,13 @@ describe('configurable-schema: per-workflow schema enforced', () => {
       console.warn(
         '[configurable-schema] no advertised fixture declares configurableSchema; skipping',
       );
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!fixture` returned early ([configurable-schema] no advertised fixture declares configurableSchema; skipping)');
     }
 
     const manifest = await driver.get(`/v1/workflows/${encodeURIComponent(fixture)}`);
     const schema = (manifest.json as { configurableSchema?: Record<string, unknown> })
       .configurableSchema;
-    expect(schema, driver.describe(
+    expect(schema, req('openwop.it.configurable-schema.manifest-surfaces-configurableschema-mismatched-configurable-is-rejected', 
       'run-options.md §"Per-workflow configurableSchema"',
       'GET /v1/workflows/{workflowId} MUST surface configurableSchema when the workflow declares one',
     )).toBeDefined();
@@ -64,7 +66,7 @@ describe('configurable-schema: per-workflow schema enforced', () => {
     });
     expect(
       [400, 422].includes(create.status),
-      driver.describe(
+      req('openwop.it.configurable-schema.manifest-surfaces-configurableschema-mismatched-configurable-is-rejected', 
         'run-options.md §"Per-workflow configurableSchema"',
         'configurable that violates the workflow schema MUST be rejected with 400/422',
       ),
@@ -76,12 +78,12 @@ describe('configurable-schema: per-workflow schema enforced', () => {
 
   it('configurable overlay matching configurableSchema is accepted', async () => {
     const fixture = await pickFixture();
-    if (!fixture) return; // covered by skip warning above
+    if (!fixture) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!fixture` returned early (covered by skip warning above)'); // covered by skip warning above
 
     const manifest = await driver.get(`/v1/workflows/${encodeURIComponent(fixture)}`);
     const schema = (manifest.json as { configurableSchema?: Record<string, unknown> })
       .configurableSchema;
-    if (!schema) return;
+    if (!schema) return softSkip('blocked', 'precondition not met — `!schema` returned early (seam, prior step, or fixture unavailable)');
 
     // Build a minimal valid overlay derived from the schema's first
     // `properties.*` entry. This stays generic across fixtures: we pick
@@ -106,7 +108,7 @@ describe('configurable-schema: per-workflow schema enforced', () => {
       workflowId: fixture,
       configurable: overlay,
     });
-    expect(create.status, driver.describe(
+    expect(create.status, req('openwop.it.configurable-schema.configurable-overlay-matching-configurableschema-is-accepted', 
       'run-options.md §"Per-workflow configurableSchema"',
       'configurable matching the declared schema MUST be accepted (201)',
     )).toBe(201);

package/src/scenarios/conformance-advertised-seam-required.test.ts

@@ -27,6 +27,7 @@ import { behaviorGate, behaviorGatePresent } from '../lib/behavior-gate.js';
 import { seamAbsent, softSkipDisposition, resetSoftSkips } from '../lib/soft-skip.js';
 import { dispositionOf, resetLedger, suspendSinkForFixtures } from '../lib/requirement-ledger.js';
 import { __resetEnvCacheForTests } from '../lib/env.js';
+import { req } from '../lib/requirement-ids.js';
 
 export const HOST_CALLBACK_NOT_REQUIRED = 'server-free: toggles OPENWOP_REQUIRE_BEHAVIOR in-process and pins the advertised-missing-seam rule';
 
@@ -71,7 +72,7 @@ describe('RFC 0148 §B — conformance-advertised-seam-required', () => {
     delete process.env['OPENWOP_REQUIRE_BEHAVIOR'];
     __resetEnvCacheForTests();
     delete process.env['OPENWOP_OPTED_OUT_PROFILES'];
-    expect(behaviorGate(PROFILE, false)).toBe(false);
+    expect(behaviorGate(PROFILE, false), req('openwop.it.conformance-advertised-seam-required.default-mode-an-unadvertised-profile-records-inapplicable-and-gates-false-never', 'RFC 0148 §B', 'default mode: an unadvertised profile records inapplicable and gates false — never a pass')).toBe(false);
     expect(dispositionOf(`openwop.profile.${PROFILE}`)).toBe('inapplicable');
   });
 
@@ -79,14 +80,14 @@ describe('RFC 0148 §B — conformance-advertised-seam-required', () => {
     process.env['OPENWOP_REQUIRE_BEHAVIOR'] = 'true';
     __resetEnvCacheForTests();
     delete process.env['OPENWOP_OPTED_OUT_PROFILES'];
-    expect(() => behaviorGate(PROFILE, false)).toThrow(/OPENWOP_REQUIRE_BEHAVIOR=true/);
+    expect(() => behaviorGate(PROFILE, false), req('openwop.it.conformance-advertised-seam-required.strict-mode-an-unadvertised-un-opted-out-profile-fails-advertise-or-opt-out-expl', 'RFC 0148 §B', 'strict mode: an unadvertised, un-opted-out profile FAILS (advertise or opt out explicitly)')).toThrow(/OPENWOP_REQUIRE_BEHAVIOR=true/);
   });
 
   it('strict mode: an advertised capability whose seam helper returned nothing FAILS (behaviorGatePresent)', () => {
     process.env['OPENWOP_REQUIRE_BEHAVIOR'] = 'true';
     __resetEnvCacheForTests();
     delete process.env['OPENWOP_OPTED_OUT_PROFILES'];
-    expect(() => behaviorGatePresent(PROFILE, null)).toThrow();
+    expect(() => behaviorGatePresent(PROFILE, null), req('openwop.it.conformance-advertised-seam-required.strict-mode-an-advertised-capability-whose-seam-helper-returned-nothing-fails-be', 'RFC 0148 §B', 'strict mode: an advertised capability whose seam helper returned nothing FAILS (behaviorGatePresent)')).toThrow();
     // and with a value present it narrows and passes through
     delete process.env['OPENWOP_REQUIRE_BEHAVIOR'];
     __resetEnvCacheForTests();
@@ -96,7 +97,7 @@ describe('RFC 0148 §B — conformance-advertised-seam-required', () => {
   it('strict mode: seamAbsent (advertised, seam answered 404/403 mid-scenario) FAILS; default mode notes blocked with the reason', () => {
     process.env['OPENWOP_REQUIRE_BEHAVIOR'] = 'true';
     __resetEnvCacheForTests();
-    expect(() => seamAbsent('host advertises X but /v1/host/sample/x answered 404')).toThrow(/RFC 0148 §B/);
+    expect(() => seamAbsent('host advertises X but /v1/host/sample/x answered 404'), req('openwop.it.conformance-advertised-seam-required.strict-mode-seamabsent-advertised-seam-answered-404-403-mid-scenario-fails-defau', 'RFC 0148 §B', 'strict mode: seamAbsent (advertised, seam answered 404/403 mid-scenario) FAILS; default mode notes blocked with the reason')).toThrow(/RFC 0148 §B/);
     delete process.env['OPENWOP_REQUIRE_BEHAVIOR'];
     __resetEnvCacheForTests();
     resetSoftSkips();
@@ -111,7 +112,7 @@ describe('RFC 0148 §B — conformance-advertised-seam-required', () => {
     __resetEnvCacheForTests();
     process.env['OPENWOP_OPTED_OUT_PROFILES'] = PROFILE;
     __resetEnvCacheForTests();
-    expect(behaviorGate(PROFILE, false)).toBe(false);
+    expect(behaviorGate(PROFILE, false), req('openwop.it.conformance-advertised-seam-required.the-sanctioned-escape-is-an-explicit-opt-out-which-records-skipped-with-the-reas', 'RFC 0148 §B', 'the sanctioned escape is an explicit opt-out, which records skipped with the reason — still never a pass')).toBe(false);
     expect(dispositionOf(`openwop.profile.${PROFILE}`)).toBe('skipped');
   });
 });

package/src/scenarios/conformance-execution-witness.test.ts

@@ -27,6 +27,7 @@ import { UNCLASSIFIED_RETURN_DETAIL } from '../lib/soft-skip.js';
 import { PROFILE_FLOOR_SCENARIOS } from '../lib/profiles.js';
 import { requirementIdForScenario, requirementsFor } from '../lib/requirement-registry.js';
 import { verifyBundleV2, type BundleV2Requirement } from '../lib/certification-bundle-verify.js';
+import { req } from '../lib/requirement-ids.js';
 
 export const HOST_CALLBACK_NOT_REQUIRED = 'server-free: pins the runner/emitter/verifier rule that an early return is never a pass';
 
@@ -34,19 +35,19 @@ const HEX = 'c'.repeat(64);
 
 describe('RFC 0148 §A — conformance-execution-witness: the runner record', () => {
   it('a witnessed pass is executed-pass; a failed test is executed-fail regardless of count', () => {
-    expect(resolveFileRecord(['pass', 'pass'], undefined, 7, null).disposition).toBe('executed-pass');
+    expect(resolveFileRecord(['pass', 'pass'], undefined, 7, null).disposition, req('openwop.it.conformance-execution-witness.a-witnessed-pass-is-executed-pass-a-failed-test-is-executed-fail-regardless-of-c', 'RFC 0148 §A', 'a witnessed pass is executed-pass; a failed test is executed-fail regardless of count')).toBe('executed-pass');
     expect(resolveFileRecord(['pass', 'fail'], undefined, 7, null).disposition).toBe('executed-fail');
     expect(resolveFileRecord(['fail'], undefined, 0, null).disposition).toBe('executed-fail');
   });
 
   it('a zero-assertion pass with NO reason is BLOCKED with the marker — never a pass', () => {
     const r = resolveFileRecord(['pass', 'pass'], undefined, 0, null);
-    expect(r.disposition).toBe('blocked');
+    expect(r.disposition, req('openwop.it.conformance-execution-witness.a-zero-assertion-pass-with-no-reason-is-blocked-with-the-marker-never-a-pass', 'RFC 0148 §A', 'a zero-assertion pass with NO reason is BLOCKED with the marker — never a pass')).toBe('blocked');
     expect(r.detail).toBe(UNCLASSIFIED_RETURN_DETAIL);
   });
 
   it('a zero-assertion pass takes the noted reason (softSkip / seamAbsent) — inapplicable, skipped, or blocked with the text', () => {
-    expect(resolveFileRecord(['pass'], undefined, 0, { kind: 'inapplicable', reason: 'host does not advertise X' })).toEqual({ disposition: 'inapplicable', detail: 'host does not advertise X' });
+    expect(resolveFileRecord(['pass'], undefined, 0, { kind: 'inapplicable', reason: 'host does not advertise X' }), req('openwop.it.conformance-execution-witness.a-zero-assertion-pass-takes-the-noted-reason-softskip-seamabsent-inapplicable-sk', 'RFC 0148 §A', 'a zero-assertion pass takes the noted reason (softSkip / seamAbsent) — inapplicable, skipped, or blocked with the text')).toEqual({ disposition: 'inapplicable', detail: 'host does not advertise X' });
     expect(resolveFileRecord(['pass'], undefined, 0, { kind: 'blocked', reason: 'seam answered 404' })).toEqual({ disposition: 'blocked', detail: 'seam answered 404' });
     expect(resolveFileRecord(['pass'], undefined, 0, { kind: 'skipped', reason: 'operator opt-out' })).toEqual({ disposition: 'skipped', detail: 'operator opt-out' });
   });
@@ -59,7 +60,7 @@ describe('RFC 0148 §A — conformance-execution-witness: the runner record', ()
     // from a positive control or a setup precondition. Measured on this exact
     // function by a tier-1 host writing a scenario whose first leg is a control.
     const one = resolveFileRecord(['pass'], undefined, 1, { kind: 'blocked', reason: 'fork returned 501' });
-    expect(one.disposition).toBe('executed-pass');
+    expect(one.disposition, req('openwop.it.conformance-execution-witness.gap-g8-a-file-that-asserted-then-soft-skipped-keeps-the-note-as-a-partial-witnes', 'RFC 0148 §A', 'gap G8 — a file that asserted then soft-skipped keeps the note as a partial-witness detail, and its disposition does NOT move')).toBe('executed-pass');
     expect(one.detail).toBe('partial-witness: blocked: fork returned 501');
 
     const many = resolveFileRecord(['pass', 'pass'], undefined, 4, { kind: 'inapplicable', reason: 'fork unsupported' });
@@ -83,7 +84,7 @@ describe('RFC 0148 §A — conformance-execution-witness: the runner record', ()
   it('every test ctx.skip()ped takes the noted reason when one was written before the skip, else stays the blocked marker', () => {
     // `ctx.skip()` throws — a `softSkip(...)` AFTER it is dead code. Seven files
     // carried exactly that dead note and reported as unclassified for a suite minor.
-    expect(resolveFileRecord(['skip', 'skip'], undefined, 0, { kind: 'inapplicable', reason: 'sandbox not advertised' })).toEqual({ disposition: 'inapplicable', detail: 'sandbox not advertised' });
+    expect(resolveFileRecord(['skip', 'skip'], undefined, 0, { kind: 'inapplicable', reason: 'sandbox not advertised' }), req('openwop.it.conformance-execution-witness.every-test-ctx-skip-ped-takes-the-noted-reason-when-one-was-written-before-the-s', 'RFC 0148 §A', 'every test ctx.skip()ped takes the noted reason when one was written before the skip, else stays the blocked marker')).toEqual({ disposition: 'inapplicable', detail: 'sandbox not advertised' });
     expect(resolveFileRecord(['skip'], undefined, 0, { kind: 'blocked', reason: 'simulator seam 404' })).toEqual({ disposition: 'blocked', detail: 'simulator seam 404' });
     const bare = resolveFileRecord(['skip', 'skip'], undefined, 0, null);
     expect(bare.disposition).toBe('blocked');
@@ -93,7 +94,7 @@ describe('RFC 0148 §A — conformance-execution-witness: the runner record', ()
   });
 
   it('a behaviorGate reason resolves a zero-assertion pass to inapplicable/skipped; a note outranks nothing but never a witnessed pass', () => {
-    expect(resolveFileRecord(['pass'], 'inapplicable', 0, null).disposition).toBe('inapplicable');
+    expect(resolveFileRecord(['pass'], 'inapplicable', 0, null).disposition, req('openwop.it.conformance-execution-witness.a-behaviorgate-reason-resolves-a-zero-assertion-pass-to-inapplicable-skipped-a-n', 'RFC 0148 §A', 'a behaviorGate reason resolves a zero-assertion pass to inapplicable/skipped; a note outranks nothing but never a witnessed pass')).toBe('inapplicable');
     expect(resolveFileRecord(['pass'], 'skipped', 0, null).disposition).toBe('skipped');
     // real assertions ran: the note is irrelevant, the file passed
     expect(resolveFileRecord(['pass'], undefined, 3, { kind: 'blocked', reason: 'irrelevant' }).disposition).toBe('executed-pass');
@@ -115,7 +116,7 @@ describe('RFC 0148 §A — conformance-execution-witness: emitter and verifier r
     rep.set('interrupt-alpha.test.ts', 'passed');
     const d = deriveRequirementDispositions(rep, ledger, [profile], {});
     const v = d.verdicts.find((x) => x.profile === profile)!;
-    expect(v.unclassified).toEqual([requirementIdForScenario(files[0]!)]);
+    expect(v.unclassified, req('openwop.it.conformance-execution-witness.the-emitter-derivation-marks-a-marker-blocked-floor-row-unclassified-and-rejects', 'RFC 0148 §A', 'the emitter derivation marks a marker-blocked floor row unclassified and rejects the claim')).toEqual([requirementIdForScenario(files[0]!)]);
     expect(d.rejectUnclassified).toBe(true);
     // and the same file with a witnessed pass certifies
     ledger[0] = { requirementId: requirementIdForScenario(files[0]!), disposition: 'executed-pass' as const, assertionCount: 3 };
@@ -134,7 +135,7 @@ describe('RFC 0148 §A — conformance-execution-witness: emitter and verifier r
       results: { totals: { executedPass: rs.filter((r) => r.disposition === 'executed-pass').length, executedFail: 0, skipped: 0, inapplicable: 0, blocked: rs.filter((r) => r.disposition === 'blocked').length }, requirements: rs },
       scenarioManifestSha256: HEX, targetConfigurationSha256: HEX,
     });
-    expect(verifyBundleV2(bundle(rows)).certified).toBe(true);
+    expect(verifyBundleV2(bundle(rows)).certified, req('openwop.it.conformance-execution-witness.the-consumer-verifier-rejects-a-bundle-whose-required-row-is-a-vacuous-pass-or-t', 'RFC 0148 §A', 'the consumer verifier rejects a bundle whose required row is a vacuous pass or the runner marker, and accepts the witnessed twin')).toBe(true);
     const vacuous = rows.map((r, i) => (i === 0 ? { ...r, assertionCount: 0 } : r));
     expect(verifyBundleV2(bundle(vacuous)).evidenceValid).toBe(false);
     const marker = rows.map((r, i) => (i === 0 ? { requirementId: r.requirementId, scenarioId: r.scenarioId, disposition: 'blocked', detail: UNCLASSIFIED_RETURN_DETAIL, assertionCount: 0 } : r));