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

package/src/scenarios/dispatch-fanout-parallel.test.ts

@@ -37,6 +37,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';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const DISPATCH_CONFIG = join(SCHEMAS_DIR, 'dispatch-config.schema.json');
 const EVENT_PAYLOADS = join(SCHEMAS_DIR, 'run-event-payloads.schema.json');
@@ -58,7 +60,7 @@ describe('dispatch-fanout: DispatchConfig schema (always-on, server-free)', () =
       maxConcurrency: 5,
       joinPolicy: { mode: 'wait-all', onChildFailure: 'collect' },
     };
-    expect(validate(cfg), `node-packs.md §parallel fan-out — a valid parallel config MUST validate. Errors: ${JSON.stringify(validate.errors)}`).toBe(true);
+    expect(validate(cfg), req('openwop.it.dispatch-fanout-parallel.accepts-fanoutpolicy-parallel-with-a-wait-all-collect-joinpolicy-maxconcurrency', 'node-packs.md', `node-packs.md §parallel fan-out — a valid parallel config MUST validate. Errors: ${JSON.stringify(validate.errors)}`)).toBe(true);
   });
 
   it('accepts each joinPolicy.mode (wait-all/quorum/first/race)', () => {
@@ -68,26 +70,26 @@ describe('dispatch-fanout: DispatchConfig schema (always-on, server-free)', () =
       { mode: 'first' },
       { mode: 'race' },
     ]) {
-      expect(validate({ fanOutPolicy: 'parallel', joinPolicy: jp }), `joinPolicy ${JSON.stringify(jp)} MUST validate`).toBe(true);
+      expect(validate({ fanOutPolicy: 'parallel', joinPolicy: jp }), req('openwop.it.dispatch-fanout-parallel.accepts-each-joinpolicy-mode-wait-all-quorum-first-race', 'node-packs.md', `joinPolicy ${JSON.stringify(jp)} MUST validate`)).toBe(true);
     }
   });
 
   it('rejects an unknown fanOutPolicy and an unknown joinPolicy.mode', () => {
-    expect(validate({ fanOutPolicy: 'broadcast' }), "fanOutPolicy MUST be one of sequential/reject/parallel").toBe(false);
-    expect(validate({ fanOutPolicy: 'parallel', joinPolicy: { mode: 'any' } }), 'joinPolicy.mode MUST be in the closed enum').toBe(false);
+    expect(validate({ fanOutPolicy: 'broadcast' }), req('openwop.it.dispatch-fanout-parallel.rejects-an-unknown-fanoutpolicy-and-an-unknown-joinpolicy-mode', 'node-packs.md', "fanOutPolicy MUST be one of sequential/reject/parallel")).toBe(false);
+    expect(validate({ fanOutPolicy: 'parallel', joinPolicy: { mode: 'any' } }), req('openwop.it.dispatch-fanout-parallel.rejects-an-unknown-fanoutpolicy-and-an-unknown-joinpolicy-mode', 'node-packs.md', 'joinPolicy.mode MUST be in the closed enum')).toBe(false);
   });
 
   it('rejects an unknown onChildFailure and additionalProperties on joinPolicy', () => {
-    expect(validate({ fanOutPolicy: 'parallel', joinPolicy: { onChildFailure: 'explode' } }), 'onChildFailure MUST be collect/fail-fast/absorb').toBe(false);
-    expect(validate({ fanOutPolicy: 'parallel', joinPolicy: { mode: 'wait-all', extra: 1 } }), 'joinPolicy is additionalProperties:false').toBe(false);
+    expect(validate({ fanOutPolicy: 'parallel', joinPolicy: { onChildFailure: 'explode' } }), req('openwop.it.dispatch-fanout-parallel.rejects-an-unknown-onchildfailure-and-additionalproperties-on-joinpolicy', 'node-packs.md', 'onChildFailure MUST be collect/fail-fast/absorb')).toBe(false);
+    expect(validate({ fanOutPolicy: 'parallel', joinPolicy: { mode: 'wait-all', extra: 1 } }), req('openwop.it.dispatch-fanout-parallel.rejects-an-unknown-onchildfailure-and-additionalproperties-on-joinpolicy', 'node-packs.md', 'joinPolicy is additionalProperties:false')).toBe(false);
   });
 
   it('rejects a non-positive maxConcurrency', () => {
-    expect(validate({ fanOutPolicy: 'parallel', maxConcurrency: 0 }), 'maxConcurrency minimum is 1').toBe(false);
+    expect(validate({ fanOutPolicy: 'parallel', maxConcurrency: 0 }), req('openwop.it.dispatch-fanout-parallel.rejects-a-non-positive-maxconcurrency', 'node-packs.md', 'maxConcurrency minimum is 1')).toBe(false);
   });
 
   it('the default config (no fanOutPolicy) stays valid — additive, default sequential', () => {
-    expect(validate({ workerDispatchModel: 'child-run' }), 'a pre-RFC-0118 config MUST stay valid').toBe(true);
+    expect(validate({ workerDispatchModel: 'child-run' }), req('openwop.it.dispatch-fanout-parallel.the-default-config-no-fanoutpolicy-stays-valid-additive-default-sequential', 'node-packs.md', 'a pre-RFC-0118 config MUST stay valid')).toBe(true);
   });
 });
 
@@ -99,8 +101,8 @@ describe('dispatch-fanout: event $defs (always-on, server-free)', () => {
 
   it('a well-formed core.dispatch.fanOut payload validates; fanOutPolicy is const "parallel"', () => {
     expect(validateFanOut({ fanOutPolicy: 'parallel', childCount: 5, maxConcurrency: 5, joinMode: 'wait-all' })).toBe(true);
-    expect(validateFanOut({ fanOutPolicy: 'sequential', childCount: 5 }), 'fanOut is emitted only on the parallel path (const)').toBe(false);
-    expect(validateFanOut({ fanOutPolicy: 'parallel', childCount: 1 }), 'childCount minimum is 2 (> 1 by construction)').toBe(false);
+    expect(validateFanOut({ fanOutPolicy: 'sequential', childCount: 5 }), req('openwop.it.dispatch-fanout-parallel.a-well-formed-core-dispatch-fanout-payload-validates-fanoutpolicy-is-const-paral', 'node-packs.md', 'fanOut is emitted only on the parallel path (const)')).toBe(false);
+    expect(validateFanOut({ fanOutPolicy: 'parallel', childCount: 1 }), req('openwop.it.dispatch-fanout-parallel.a-well-formed-core-dispatch-fanout-payload-validates-fanoutpolicy-is-const-paral', 'node-packs.md', 'childCount minimum is 2 (> 1 by construction)')).toBe(false);
   });
 
   it('a well-formed core.dispatch.join payload carries mergeOrder (replay tiebreak)', () => {
@@ -111,9 +113,9 @@ describe('dispatch-fanout: event $defs (always-on, server-free)', () => {
       cancelledCount: 0,
       mergeOrder: ['run-a', 'run-b', 'run-c'],
     };
-    expect(validateJoin(ok), `node-packs.md §parallel — join carries mergeOrder. Errors: ${JSON.stringify(validateJoin.errors)}`).toBe(true);
-    expect(validateJoin({ joinOutcome: 'satisfied', completedCount: 3, failedCount: 0 }), 'mergeOrder is required (replay determinism)').toBe(false);
-    expect(validateJoin({ ...ok, joinOutcome: 'aborted' }), 'joinOutcome MUST be satisfied/failed/partial').toBe(false);
+    expect(validateJoin(ok), req('openwop.it.dispatch-fanout-parallel.a-well-formed-core-dispatch-join-payload-carries-mergeorder-replay-tiebreak', 'node-packs.md', `node-packs.md §parallel — join carries mergeOrder. Errors: ${JSON.stringify(validateJoin.errors)}`)).toBe(true);
+    expect(validateJoin({ joinOutcome: 'satisfied', completedCount: 3, failedCount: 0 }), req('openwop.it.dispatch-fanout-parallel.a-well-formed-core-dispatch-join-payload-carries-mergeorder-replay-tiebreak', 'node-packs.md', 'mergeOrder is required (replay determinism)')).toBe(false);
+    expect(validateJoin({ ...ok, joinOutcome: 'aborted' }), req('openwop.it.dispatch-fanout-parallel.a-well-formed-core-dispatch-join-payload-carries-mergeorder-replay-tiebreak', 'node-packs.md', 'joinOutcome MUST be satisfied/failed/partial')).toBe(false);
   });
 });
 
@@ -121,43 +123,43 @@ describe('dispatch-fanout: parallel behavior (capability-gated, RFC 0118)', () =
   it('a wait-all/collect parallel fan-out joins on all children with joinOutcome satisfied', async () => {
     const dispatch = await readCapabilityFamily<{ fanOutSupported?: boolean; fanOutPolicies?: string[] }>('dispatch');
     if (!behaviorGate('dispatch.fanOutSupported', dispatch?.fanOutSupported === true)) return;
-    if (!(dispatch?.fanOutPolicies ?? []).includes('parallel')) return; // parallel unsupported → out of scope
+    if (!(dispatch?.fanOutPolicies ?? []).includes('parallel')) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(dispatch?.fanOutPolicies ?? []).includes(\'parallel\')` returned early (parallel unsupported → out of scope)'); // parallel unsupported → out of scope
 
     const res = await driver.post('/v1/host/sample/dispatch/fanout', {
       nextWorkerIds: ['conformance.child.a', 'conformance.child.b', 'conformance.child.c'],
       config: { fanOutPolicy: 'parallel', joinPolicy: { mode: 'wait-all', onChildFailure: 'collect' } },
     });
-    if (res.status === 404 || res.status === 403) return; // seam unwired — soft-skip
+    if (res.status === 404 || res.status === 403) return softSkip('blocked', 'precondition not met — `res.status === 404 || res.status === 403` returned early (seam unwired — soft-skip) (seam, prior step, or fixture unavailable)'); // seam unwired — soft-skip
 
     const body = res.json as { joinOutcome?: string; children?: unknown[]; mergeOrder?: string[] } | undefined;
     expect(
       body?.joinOutcome,
-      driver.describe('node-packs.md §parallel fan-out', 'wait-all + collect over all-completing children → joinOutcome satisfied'),
+      req('openwop.it.dispatch-fanout-parallel.a-wait-all-collect-parallel-fan-out-joins-on-all-children-with-joinoutcome-satis', 'node-packs.md §parallel fan-out', 'wait-all + collect over all-completing children → joinOutcome satisfied'),
     ).toBe('satisfied');
     expect(
       body?.children?.length,
-      driver.describe('node-packs.md §parallel fan-out', 'the output children[] reports every dispatched child'),
+      req('openwop.it.dispatch-fanout-parallel.a-wait-all-collect-parallel-fan-out-joins-on-all-children-with-joinoutcome-satis', 'node-packs.md §parallel fan-out', 'the output children[] reports every dispatched child'),
     ).toBe(3);
     expect(
       Array.isArray(body?.mergeOrder),
-      driver.describe('node-packs.md §parallel fan-out', 'the join records mergeOrder for replay-deterministic output merge'),
+      req('openwop.it.dispatch-fanout-parallel.a-wait-all-collect-parallel-fan-out-joins-on-all-children-with-joinoutcome-satis', 'node-packs.md §parallel fan-out', 'the join records mergeOrder for replay-deterministic output merge'),
     ).toBe(true);
   });
 
   it('parallel fan-out is rejected at registration on a host advertising fanOutSupported:false', async () => {
     const dispatch = await readCapabilityFamily<{ supported?: boolean; fanOutSupported?: boolean }>('dispatch');
-    if (!dispatch?.supported) return; // no dispatch surface → out of scope
-    if (dispatch.fanOutSupported === true) return; // this leg targets non-supporting hosts
+    if (!dispatch?.supported) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!dispatch?.supported` returned early (no dispatch surface → out of scope)'); // no dispatch surface → out of scope
+    if (dispatch.fanOutSupported === true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `dispatch.fanOutSupported === true` returned early (this leg targets non-supporting hosts)'); // this leg targets non-supporting hosts
 
     const res = await driver.post('/v1/workflows', {
       id: 'conformance.dispatch.parallel-unsupported',
       nodes: [{ nodeId: 'd', typeId: 'core.dispatch', config: { fanOutPolicy: 'parallel', joinPolicy: { mode: 'wait-all' } } }],
     });
-    if (res.status === 404) return; // registration surface not exposed here — soft-skip
+    if (res.status === 404) return softSkip('blocked', 'precondition not met — `res.status === 404` returned early (registration surface not exposed here — soft-skip) (seam, prior step, or fixture unavailable)'); // registration surface not exposed here — soft-skip
 
     expect(
       res.status >= 400 && res.status < 500,
-      driver.describe('node-packs.md §parallel fan-out', "a host advertising fanOutSupported:false MUST reject fanOutPolicy:'parallel' with a validation_error (4xx), never accept it"),
+      req('openwop.it.dispatch-fanout-parallel.parallel-fan-out-is-rejected-at-registration-on-a-host-advertising-fanoutsupport', 'node-packs.md §parallel fan-out', "a host advertising fanOutSupported:false MUST reject fanOutPolicy:'parallel' with a validation_error (4xx), never accept it"),
     ).toBe(true);
   });
 });

package/src/scenarios/dispatch-input-mapping.test.ts

@@ -25,6 +25,8 @@ import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { setHostCapability, resetHostCapabilities, isToggleAvailable } from '../lib/host-toggle.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const PARENT = 'conformance-dispatch-input-mapping';
 const CHILD = 'conformance-dispatch-input-mapping-child';
@@ -49,7 +51,7 @@ describe.skipIf(SKIP)('dispatch-input-mapping: parent → child variable project
     const parentRunId = (create.json as { runId: string }).runId;
 
     const parentTerminal = (await pollUntilTerminal(parentRunId)) as RunSnapshot;
-    expect(parentTerminal.status, driver.describe(
+    expect(parentTerminal.status, req('openwop.it.dispatch-input-mapping.hvmap-1a-inputmapping-projects-parent-variables-into-child-inputs', 
       'RFCS/0022-dispatch-input-output-mapping.md §A',
       'parent run MUST reach terminal `completed` once the dispatch loop terminates',
     )).toBe('completed');
@@ -61,7 +63,7 @@ describe.skipIf(SKIP)('dispatch-input-mapping: parent → child variable project
     const dispatched = events.find(
       (e) => e.type === 'node.dispatched' && e.payload?.childWorkflowId === CHILD,
     );
-    expect(dispatched, driver.describe(
+    expect(dispatched, req('openwop.it.dispatch-input-mapping.hvmap-1a-inputmapping-projects-parent-variables-into-child-inputs', 
       'RFCS/0007-dispatch.md §D',
       'parent event log MUST contain a `node.dispatched` event naming the child workflow',
     )).toBeDefined();
@@ -74,12 +76,12 @@ describe.skipIf(SKIP)('dispatch-input-mapping: parent → child variable project
     const childSnapshotRes = await driver.get(`/v1/runs/${encodeURIComponent(childRunId!)}`);
     expect(childSnapshotRes.status).toBe(200);
     const childSnapshot = childSnapshotRes.json as RunSnapshot;
-    expect(childSnapshot.status, driver.describe(
+    expect(childSnapshot.status, req('openwop.it.dispatch-input-mapping.hvmap-1a-inputmapping-projects-parent-variables-into-child-inputs', 
       'RFCS/0007-dispatch.md',
       'child run MUST reach terminal `completed`',
     )).toBe('completed');
     const childInputs = childSnapshot.inputs ?? {};
-    expect(childInputs.childGreeting, driver.describe(
+    expect(childInputs.childGreeting, req('openwop.it.dispatch-input-mapping.hvmap-1a-inputmapping-projects-parent-variables-into-child-inputs', 
       'RFCS/0022-dispatch-input-output-mapping.md §A',
       'child `inputs.childGreeting` MUST be parent\'s `parentName` projection ("Alice") per inputMapping',
     )).toBe('Alice');
@@ -87,7 +89,7 @@ describe.skipIf(SKIP)('dispatch-input-mapping: parent → child variable project
 
   it('HVMAP-1a-null: parent variable unset → child input surfaces as `undefined` per §A', async () => {
     const PARENT_NO_DEFAULT = 'conformance-dispatch-input-mapping-no-default';
-    if (!isFixtureAdvertised(PARENT_NO_DEFAULT) || !isFixtureAdvertised(CHILD)) return; // fixture not seeded — soft-skip
+    if (!isFixtureAdvertised(PARENT_NO_DEFAULT) || !isFixtureAdvertised(CHILD)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(PARENT_NO_DEFAULT) || !isFixtureAdvertised(CHILD)` returned early (fixture not seeded — soft-skip)'); // fixture not seeded — soft-skip
     const create = await driver.post('/v1/runs', { workflowId: PARENT_NO_DEFAULT });
     expect(create.status).toBe(201);
     const parentRunId = (create.json as { runId: string }).runId;
@@ -98,7 +100,7 @@ describe.skipIf(SKIP)('dispatch-input-mapping: parent → child variable project
     const dispatched = events.find(
       (e) => e.type === 'node.dispatched' && e.payload?.childWorkflowId === CHILD,
     );
-    if (!dispatched) return; // host doesn't emit node.dispatched — soft-skip
+    if (!dispatched) return softSkip('blocked', 'precondition not met — `!dispatched` returned early (host doesn\'t emit node.dispatched — soft-skip) (seam, prior step, or fixture unavailable)'); // host doesn't emit node.dispatched — soft-skip
     const childRunId = dispatched.payload?.childRunId;
 
     const childRes = await driver.get(`/v1/runs/${encodeURIComponent(childRunId!)}`);
@@ -111,7 +113,7 @@ describe.skipIf(SKIP)('dispatch-input-mapping: parent → child variable project
     const v = inputs.childGreeting;
     expect(
       v === undefined || !('childGreeting' in inputs),
-      driver.describe(
+      req('openwop.it.dispatch-input-mapping.hvmap-1a-null-parent-variable-unset-child-input-surfaces-as-undefined-per-a', 
         'RFCS/0022-dispatch-input-output-mapping.md §A',
         'unset parent variable projection MUST surface as undefined (NOT null, NOT a default placeholder)',
       ),
@@ -123,7 +125,7 @@ describe.skipIf(SKIP)('dispatch-input-mapping: parent → child variable project
 
 describe('dispatch-input-mapping: registration refusal (RFC 0022 §C HVMAP-1a-refusal)', () => {
   it('host with agents.dispatchMapping toggled OFF MUST refuse non-empty inputMapping at registration', async () => {
-    if (!(await isToggleAvailable())) return; // seam not exposed — soft-skip
+    if (!(await isToggleAvailable())) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isToggleAvailable())` returned early (seam not exposed — soft-skip)'); // seam not exposed — soft-skip
     await setHostCapability('agents.dispatchMapping', false);
     try {
       const workflow = {
@@ -142,7 +144,7 @@ describe('dispatch-input-mapping: registration refusal (RFC 0022 §C HVMAP-1a-re
       const res = await driver.post('/v1/host/sample/workflows', workflow);
       expect(
         res.status,
-        driver.describe(
+        req('openwop.it.dispatch-input-mapping.host-with-agents-dispatchmapping-toggled-off-must-refuse-non-empty-inputmapping', 
           'RFCS/0022-dispatch-input-output-mapping.md §C',
           'workflow with non-empty inputMapping MUST be refused when capabilities.agents.dispatchMapping is not advertised',
         ),
@@ -151,7 +153,7 @@ describe('dispatch-input-mapping: registration refusal (RFC 0022 §C HVMAP-1a-re
       expect(body.error).toBe('validation_error');
       expect(
         body.details?.requiredCapability,
-        driver.describe(
+        req('openwop.it.dispatch-input-mapping.host-with-agents-dispatchmapping-toggled-off-must-refuse-non-empty-inputmapping', 
           'RFCS/0022-dispatch-input-output-mapping.md §C',
           'refusal MUST surface requiredCapability: "agents.dispatchMapping"',
         ),

package/src/scenarios/dispatch-output-mapping.test.ts

@@ -22,6 +22,8 @@ import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const PARENT = 'conformance-dispatch-output-mapping';
 const CHILD = 'conformance-dispatch-output-mapping-child';
@@ -39,7 +41,7 @@ describe.skipIf(SKIP)('dispatch-output-mapping: child → parent variable harves
     const parentRunId = (create.json as { runId: string }).runId;
 
     const parentTerminal = (await pollUntilTerminal(parentRunId)) as RunSnapshot;
-    expect(parentTerminal.status, driver.describe(
+    expect(parentTerminal.status, req('openwop.it.dispatch-output-mapping.hvmap-1b-outputmapping-harvests-child-variables-into-parent-variables-on-termina', 
       'RFCS/0022-dispatch-input-output-mapping.md §A',
       'parent run MUST reach terminal `completed` once the dispatch loop terminates',
     )).toBe('completed');
@@ -49,7 +51,7 @@ describe.skipIf(SKIP)('dispatch-output-mapping: child → parent variable harves
     // Child declares childOutcome.defaultValue='done' so the value is
     // present in the child's variables_json at terminal time.
     const parentVars = parentTerminal.variables ?? {};
-    expect(parentVars.parentResult, driver.describe(
+    expect(parentVars.parentResult, req('openwop.it.dispatch-output-mapping.hvmap-1b-outputmapping-harvests-child-variables-into-parent-variables-on-termina', 
       'RFCS/0022-dispatch-input-output-mapping.md §A',
       'parent `parentResult` MUST be child\'s `childOutcome` projection ("done") per outputMapping',
     )).toBe('done');
@@ -99,7 +101,7 @@ async function registerParent(childFixtureId: string): Promise<string | null> {
 describe.skipIf(!isFixtureAdvertised('conformance-dispatch-deterministic-fail-child'))('dispatch-output-mapping: HVMAP-1b-failed (RFC 0022 §B)', () => {
   it('child terminates `failed` → outputMapping MUST be skipped; parent.parentResult stays at sentinel', async () => {
     const parentId = await registerParent('conformance-dispatch-deterministic-fail-child');
-    if (!parentId) return; // workflow-register seam not exposed — soft-skip
+    if (!parentId) return softSkip('blocked', 'precondition not met — `!parentId` returned early (workflow-register seam not exposed — soft-skip) (seam, prior step, or fixture unavailable)'); // workflow-register seam not exposed — soft-skip
     const create = await driver.post('/v1/runs', { workflowId: parentId });
     expect(create.status).toBe(201);
     const parentRunId = (create.json as { runId: string }).runId;
@@ -109,7 +111,7 @@ describe.skipIf(!isFixtureAdvertised('conformance-dispatch-deterministic-fail-ch
     const parentVars = terminal.variables ?? {};
     expect(
       parentVars.parentResult,
-      driver.describe(
+      req('openwop.it.dispatch-output-mapping.child-terminates-failed-outputmapping-must-be-skipped-parent-parentresult-stays', 
         'RFCS/0022-dispatch-input-output-mapping.md §B',
         'outputMapping MUST be SKIPPED when child terminates failed; parent variable MUST NOT be overwritten',
       ),
@@ -120,7 +122,7 @@ describe.skipIf(!isFixtureAdvertised('conformance-dispatch-deterministic-fail-ch
 describe.skipIf(!isFixtureAdvertised('conformance-dispatch-cancellable-child'))('dispatch-output-mapping: HVMAP-1b-cancelled (RFC 0022 §B)', () => {
   it('child terminates `cancelled` → outputMapping MUST be skipped; parent.parentResult stays at sentinel', async () => {
     const parentId = await registerParent('conformance-dispatch-cancellable-child');
-    if (!parentId) return; // soft-skip
+    if (!parentId) return softSkip('blocked', 'precondition not met — `!parentId` returned early (soft-skip) (seam, prior step, or fixture unavailable)'); // soft-skip
     const create = await driver.post('/v1/runs', { workflowId: parentId });
     expect(create.status).toBe(201);
     const parentRunId = (create.json as { runId: string }).runId;
@@ -138,7 +140,7 @@ describe.skipIf(!isFixtureAdvertised('conformance-dispatch-cancellable-child'))(
       }
       await new Promise((r) => setTimeout(r, 250));
     }
-    if (!childRunId) return; // dispatch didn't surface child run id — soft-skip
+    if (!childRunId) return softSkip('blocked', 'precondition not met — `!childRunId` returned early (dispatch didn\'t surface child run id — soft-skip) (seam, prior step, or fixture unavailable)'); // dispatch didn't surface child run id — soft-skip
     const cancelRes = await driver.post(`/v1/runs/${encodeURIComponent(childRunId)}/cancel`, { reason: 'hvmap-1b-cancelled test' });
     expect(cancelRes.status === 200 || cancelRes.status === 202).toBe(true);
 
@@ -146,7 +148,7 @@ describe.skipIf(!isFixtureAdvertised('conformance-dispatch-cancellable-child'))(
     const parentVars = terminal.variables ?? {};
     expect(
       parentVars.parentResult,
-      driver.describe(
+      req('openwop.it.dispatch-output-mapping.child-terminates-cancelled-outputmapping-must-be-skipped-parent-parentresult-sta', 
         'RFCS/0022-dispatch-input-output-mapping.md §B',
         'outputMapping MUST be SKIPPED when child terminates cancelled; parent variable MUST NOT be overwritten',
       ),

package/src/scenarios/dispatch-per-item-input.test.ts

@@ -44,6 +44,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';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const DECISION = join(SCHEMAS_DIR, 'orchestrator-decision.schema.json');
 
@@ -60,39 +62,39 @@ describe('dispatch-per-item: NextWorkerDecision.nextWorkerInputs schema (always-
     };
     expect(
       validate(decision),
-      `orchestrator-decision.schema.json §NextWorkerDecision — a well-formed nextWorkerInputs MUST validate. Errors: ${JSON.stringify(validate.errors)}`,
+      req('openwop.it.dispatch-per-item-input.accepts-a-next-worker-decision-carrying-a-well-formed-index-aligned-nextworkerin', 'node-packs.md', `orchestrator-decision.schema.json §NextWorkerDecision — a well-formed nextWorkerInputs MUST validate. Errors: ${JSON.stringify(validate.errors)}`),
     ).toBe(true);
   });
 
   it('still accepts a next-worker decision that omits nextWorkerInputs (additive / back-compat)', () => {
     expect(
       validate({ kind: 'next-worker', nextWorkerIds: ['pack.child'] }),
-      'a pre-RFC-0126 next-worker decision MUST stay valid — the field is OPTIONAL',
+      req('openwop.it.dispatch-per-item-input.still-accepts-a-next-worker-decision-that-omits-nextworkerinputs-additive-back-c', 'node-packs.md', 'a pre-RFC-0126 next-worker decision MUST stay valid — the field is OPTIONAL'),
     ).toBe(true);
   });
 
   it('rejects a non-object nextWorkerInputs item', () => {
     expect(
       validate({ kind: 'next-worker', nextWorkerIds: ['a'], nextWorkerInputs: ['not-an-object'] }),
-      'each nextWorkerInputs entry MUST be a per-child input object',
+      req('openwop.it.dispatch-per-item-input.rejects-a-non-object-nextworkerinputs-item', 'node-packs.md', 'each nextWorkerInputs entry MUST be a per-child input object'),
     ).toBe(false);
     expect(
       validate({ kind: 'next-worker', nextWorkerIds: ['a'], nextWorkerInputs: 'nope' }),
-      'nextWorkerInputs MUST be an array',
+      req('openwop.it.dispatch-per-item-input.rejects-a-non-object-nextworkerinputs-item', 'node-packs.md', 'nextWorkerInputs MUST be an array'),
     ).toBe(false);
   });
 
   it('still rejects an unknown property (additionalProperties:false) — the fail-closed gate', () => {
     expect(
       validate({ kind: 'next-worker', nextWorkerIds: ['a'], perItemInputs: [{ x: 1 }] }),
-      'NextWorkerDecision is additionalProperties:false — a mis-named field MUST be rejected, so old strict validators fail closed on unknown per-item shapes',
+      req('openwop.it.dispatch-per-item-input.still-rejects-an-unknown-property-additionalproperties-false-the-fail-closed-gat', 'node-packs.md', 'NextWorkerDecision is additionalProperties:false — a mis-named field MUST be rejected, so old strict validators fail closed on unknown per-item shapes'),
     ).toBe(false);
   });
 
   it('ADMITS a length-mismatch — array-length equality is a runtime MUST, not schema-expressible', () => {
     expect(
       validate({ kind: 'next-worker', nextWorkerIds: ['a', 'b'], nextWorkerInputs: [{ x: 1 }] }),
-      'the wire schema cannot express nextWorkerInputs.length == nextWorkerIds.length; the host enforces it at decision time (layer B)',
+      req('openwop.it.dispatch-per-item-input.admits-a-length-mismatch-array-length-equality-is-a-runtime-must-not-schema-expr', 'node-packs.md', 'the wire schema cannot express nextWorkerInputs.length == nextWorkerIds.length; the host enforces it at decision time (layer B)'),
     ).toBe(true);
   });
 });
@@ -106,16 +108,16 @@ describe('dispatch-per-item: per-item input behavior (capability-gated, RFC 0126
       nextWorkerIds: ['conformance.child', 'conformance.child'],
       nextWorkerInputs: [{ contactId: 'c-1' }, { contactId: 'c-2' }],
     });
-    if (res.status === 404 || res.status === 403) return; // seam unwired — soft-skip
+    if (res.status === 404 || res.status === 403) return softSkip('blocked', 'precondition not met — `res.status === 404 || res.status === 403` returned early (seam unwired — soft-skip) (seam, prior step, or fixture unavailable)'); // seam unwired — soft-skip
 
     const body = res.json as { children?: Array<{ inputs?: Record<string, unknown> }> } | undefined;
     expect(
       body?.children?.length,
-      driver.describe('node-packs.md §core.dispatch per-item input', 'one child dispatched per nextWorkerIds entry'),
+      req('openwop.it.dispatch-per-item-input.a-host-advertising-periteminput-projects-nextworkerinputs-i-into-child-i', 'node-packs.md §core.dispatch per-item input', 'one child dispatched per nextWorkerIds entry'),
     ).toBe(2);
     expect(
       body?.children?.map((c) => c.inputs?.contactId),
-      driver.describe('node-packs.md §core.dispatch per-item input', 'each child receives its own nextWorkerInputs[i] (per-item value wins over inputMapping)'),
+      req('openwop.it.dispatch-per-item-input.a-host-advertising-periteminput-projects-nextworkerinputs-i-into-child-i', 'node-packs.md §core.dispatch per-item input', 'each child receives its own nextWorkerInputs[i] (per-item value wins over inputMapping)'),
     ).toEqual(['c-1', 'c-2']);
   });
 
@@ -127,11 +129,11 @@ describe('dispatch-per-item: per-item input behavior (capability-gated, RFC 0126
       nextWorkerIds: ['conformance.child', 'conformance.child'],
       nextWorkerInputs: [{ contactId: 'c-1' }],
     });
-    if (res.status === 404 || res.status === 403) return; // seam unwired — soft-skip
+    if (res.status === 404 || res.status === 403) return softSkip('blocked', 'precondition not met — `res.status === 404 || res.status === 403` returned early (seam unwired — soft-skip) (seam, prior step, or fixture unavailable)'); // seam unwired — soft-skip
 
     expect(
       res.status >= 400 && res.status < 500,
-      driver.describe('node-packs.md §core.dispatch per-item input', 'nextWorkerInputs.length != nextWorkerIds.length MUST fail the dispatch node (4xx validation_error), dispatching no child'),
+      req('openwop.it.dispatch-per-item-input.a-length-mismatched-nextworkerinputs-fails-with-a-validation-error-and-dispatche', 'node-packs.md §core.dispatch per-item input', 'nextWorkerInputs.length != nextWorkerIds.length MUST fail the dispatch node (4xx validation_error), dispatching no child'),
     ).toBe(true);
   });
 
@@ -146,16 +148,16 @@ describe('dispatch-per-item: per-item input behavior (capability-gated, RFC 0126
       inputMapping: { contactId: 'from-mapping', region: 'us' },
       nextWorkerInputs: [{ contactId: 'c-1' }, { contactId: 'c-2' }],
     });
-    if (res.status === 404 || res.status === 403) return; // seam unwired — soft-skip
+    if (res.status === 404 || res.status === 403) return softSkip('blocked', 'precondition not met — `res.status === 404 || res.status === 403` returned early (seam unwired — soft-skip) (seam, prior step, or fixture unavailable)'); // seam unwired — soft-skip
 
     const body = res.json as { children?: Array<{ inputs?: Record<string, unknown> }> } | undefined;
     expect(
       body?.children?.map((c) => c.inputs?.contactId),
-      driver.describe('node-packs.md §core.dispatch per-item input', 'on key collision the per-item value wins over inputMapping (G1)'),
+      req('openwop.it.dispatch-per-item-input.nextworkerinputs-i-overrides-the-inputmapping-projection-on-key-collision-g1-pre', 'node-packs.md §core.dispatch per-item input', 'on key collision the per-item value wins over inputMapping (G1)'),
     ).toEqual(['c-1', 'c-2']);
     expect(
       body?.children?.every((c) => c.inputs?.region === 'us'),
-      driver.describe('node-packs.md §core.dispatch per-item input', 'non-colliding inputMapping keys still project (per-item merges OVER, does not replace)'),
+      req('openwop.it.dispatch-per-item-input.nextworkerinputs-i-overrides-the-inputmapping-projection-on-key-collision-g1-pre', 'node-packs.md §core.dispatch per-item input', 'non-colliding inputMapping keys still project (per-item merges OVER, does not replace)'),
     ).toBe(true);
   });
 
@@ -170,29 +172,29 @@ describe('dispatch-per-item: per-item input behavior (capability-gated, RFC 0126
       nextWorkerInputs: [{ contactId: 'c-1' }, { contactId: 'c-2' }],
       replay: true,
     });
-    if (res.status === 404 || res.status === 403) return; // seam unwired — soft-skip
+    if (res.status === 404 || res.status === 403) return softSkip('blocked', 'precondition not met — `res.status === 404 || res.status === 403` returned early (seam unwired — soft-skip) (seam, prior step, or fixture unavailable)'); // seam unwired — soft-skip
 
     const body = res.json as { children?: Array<{ inputs?: Record<string, unknown> }>; replayed?: boolean } | undefined;
     expect(
       body?.children?.map((c) => c.inputs?.contactId),
-      driver.describe('node-packs.md §core.dispatch per-item input', 'replay/:fork reproduces the recorded per-item children verbatim (frozen at decision time)'),
+      req('openwop.it.dispatch-per-item-input.replay-re-reads-the-recorded-nextworkerinputs-verbatim-no-recomputation-r5-repla', 'node-packs.md §core.dispatch per-item input', 'replay/:fork reproduces the recorded per-item children verbatim (frozen at decision time)'),
     ).toEqual(['c-1', 'c-2']);
   });
 
   it('a host NOT advertising perItemInput MUST fail closed on a non-empty nextWorkerInputs', async () => {
     const dispatch = await readCapabilityFamily<{ supported?: boolean; perItemInput?: boolean }>('dispatch');
-    if (!dispatch?.supported) return; // no dispatch surface → out of scope
-    if (dispatch.perItemInput === true) return; // this leg targets non-supporting hosts
+    if (!dispatch?.supported) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!dispatch?.supported` returned early (no dispatch surface → out of scope)'); // no dispatch surface → out of scope
+    if (dispatch.perItemInput === true) return softSkip('blocked', 'precondition not met — `dispatch.perItemInput === true` returned early (this leg targets non-supporting hosts) (seam, prior step, or fixture unavailable)'); // this leg targets non-supporting hosts
 
     const res = await driver.post('/v1/host/sample/dispatch/per-item', {
       nextWorkerIds: ['conformance.child', 'conformance.child'],
       nextWorkerInputs: [{ contactId: 'c-1' }, { contactId: 'c-2' }],
     });
-    if (res.status === 404 || res.status === 403) return; // seam unwired — soft-skip
+    if (res.status === 404 || res.status === 403) return softSkip('blocked', 'precondition not met — `res.status === 404 || res.status === 403` returned early (seam unwired — soft-skip) (seam, prior step, or fixture unavailable)'); // seam unwired — soft-skip
 
     expect(
       res.status >= 400 && res.status < 500,
-      driver.describe('node-packs.md §core.dispatch per-item input', 'a host not advertising perItemInput MUST fail closed (4xx) on a non-empty nextWorkerInputs — never silently drop it and dispatch N identical children'),
+      req('openwop.it.dispatch-per-item-input.a-host-not-advertising-periteminput-must-fail-closed-on-a-non-empty-nextworkerin', 'node-packs.md §core.dispatch per-item input', 'a host not advertising perItemInput MUST fail closed (4xx) on a non-empty nextWorkerInputs — never silently drop it and dispatch N identical children'),
     ).toBe(true);
   });
 });

package/src/scenarios/dispatchLoop.test.ts

@@ -15,6 +15,7 @@ import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { req } from '../lib/requirement-ids.js';
 
 const DISPATCH_LOOP_WORKFLOW_ID = 'conformance-dispatch-loop';
 const SKIP_NO_FIXTURE = !isFixtureAdvertised(DISPATCH_LOOP_WORKFLOW_ID);
@@ -30,7 +31,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('dispatchLoop: core.dispatch consumes Orchestra
     // mock. The black-box contract here is terminal completion.
     
     const terminal = await pollUntilTerminal(runId);
-    expect(terminal.status, driver.describe(
+    expect(terminal.status, req('openwop.it.dispatchLoop.host-correctly-processes-orchestrator-decisions-and-terminates', 
       'RFCS/0007-dispatch-loop.md §H',
       'run MUST reach terminal `completed` after dispatch processes terminate decision',
     )).toBe('completed');
@@ -44,7 +45,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('dispatchLoop: core.dispatch consumes Orchestra
       .filter((e) => e.type === 'runOrchestrator.decided')
       .map((e) => e.payload?.decision?.kind);
 
-    expect(decisions, driver.describe(
+    expect(decisions, req('openwop.it.dispatchLoop.host-correctly-processes-orchestrator-decisions-and-terminates', 
       'RFCS/0007-dispatch-loop.md §D',
       'host MUST emit next-worker then terminate in a loop topology'
     )).toEqual(['next-worker', 'terminate']);

package/src/scenarios/distillation-index-roundtrip.test.ts

@@ -15,8 +15,8 @@
 
 import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
-import { driver } from '../lib/driver.js';
 import { readDistillationCap, invokeDistill } from '../lib/distillation.js';
+import { req } from '../lib/requirement-ids.js';
 
 describe('distillation-index-roundtrip (RFC 0062 §B)', () => {
   it('an indexEmitted run updates a retrievable memory-index manifest', async () => {
@@ -26,11 +26,11 @@ describe('distillation-index-roundtrip (RFC 0062 §B)', () => {
     if (res === null) return softSkip('blocked', 'seam absent — soft-skip');
     expect(
       res.body.indexUpdated === true || res.body.event?.distillation?.indexUpdated === true,
-      driver.describe('RFC 0062 §B', 'an indexEmitted distillation MUST report updating the memory index'),
+      req('openwop.it.distillation-index-roundtrip.an-indexemitted-run-updates-a-retrievable-memory-index-manifest', 'RFC 0062 §B', 'an indexEmitted distillation MUST report updating the memory index'),
     ).toBe(true);
     expect(
       res.body.indexFile !== undefined && res.body.indexFile !== null,
-      driver.describe('RFC 0062 §B', 'the MEMORY-INDEX.json manifest MUST be retrievable after distillation'),
+      req('openwop.it.distillation-index-roundtrip.an-indexemitted-run-updates-a-retrievable-memory-index-manifest', 'RFC 0062 §B', 'the MEMORY-INDEX.json manifest MUST be retrievable after distillation'),
     ).toBe(true);
   });
 });

package/src/scenarios/distillation-secret-carryforward.test.ts

@@ -13,8 +13,8 @@
 
 import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
-import { driver } from '../lib/driver.js';
 import { readDistillationCap, invokeDistill } from '../lib/distillation.js';
+import { req } from '../lib/requirement-ids.js';
 
 const CANARY = 'sk-canary-rfc0062-do-not-leak-qrs456';
 
@@ -30,7 +30,7 @@ describe('distillation-secret-carryforward (RFC 0062 §B)', () => {
     if (res === null) return softSkip('blocked', 'seam absent — soft-skip');
     expect(
       JSON.stringify(res.body).includes(CANARY),
-      driver.describe('RFC 0062 §B', 'SR-1 carry-forward: a redacted secret MUST NOT re-appear in the archive or memory.compacted event'),
+      req('openwop.it.distillation-secret-carryforward.a-redacted-secret-in-source-memory-never-appears-in-the-distilled-output', 'RFC 0062 §B', 'SR-1 carry-forward: a redacted secret MUST NOT re-appear in the archive or memory.compacted event'),
     ).toBe(false);
   });
 });

package/src/scenarios/distillation-shape.test.ts

@@ -13,8 +13,8 @@
 
 import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
-import { driver } from '../lib/driver.js';
 import { readDistillationCap } from '../lib/distillation.js';
+import { req } from '../lib/requirement-ids.js';
 
 describe('distillation-shape: advertisement (RFC 0062 §A)', () => {
   it('capabilities.memory.distillation is absent or a well-formed object', async () => {
@@ -22,19 +22,19 @@ describe('distillation-shape: advertisement (RFC 0062 §A)', () => {
     if (cap === null) return softSkip('inapplicable', 'not advertised — valid');
     expect(
       typeof cap.supported,
-      driver.describe('capabilities.schema.json §memory.distillation', 'distillation.supported MUST be a boolean when the block is present'),
+      req('openwop.it.distillation-shape.capabilities-memory-distillation-is-absent-or-a-well-formed-object', 'capabilities.schema.json §memory.distillation', 'distillation.supported MUST be a boolean when the block is present'),
     ).toBe('boolean');
     if (cap.maxTokenBudget !== undefined) {
       expect(
         typeof cap.maxTokenBudget === 'number' && (cap.maxTokenBudget as number) >= 1,
-        driver.describe('capabilities.schema.json §memory.distillation', 'maxTokenBudget MUST be a positive integer when present'),
+        req('openwop.it.distillation-shape.capabilities-memory-distillation-is-absent-or-a-well-formed-object', 'capabilities.schema.json §memory.distillation', 'maxTokenBudget MUST be a positive integer when present'),
       ).toBe(true);
     }
     for (const k of ['scheduled', 'indexEmitted'] as const) {
       if (cap[k] !== undefined) {
         expect(
           typeof cap[k],
-          driver.describe('capabilities.schema.json §memory.distillation', `distillation.${k} MUST be a boolean when present`),
+          req('openwop.it.distillation-shape.capabilities-memory-distillation-is-absent-or-a-well-formed-object', 'capabilities.schema.json §memory.distillation', `distillation.${k} MUST be a boolean when present`),
         ).toBe('boolean');
       }
     }

package/src/scenarios/distillation-stable-archive.test.ts

@@ -11,28 +11,28 @@
 
 import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
-import { driver } from '../lib/driver.js';
 import { readDistillationCap, invokeDistill } from '../lib/distillation.js';
+import { req } from '../lib/requirement-ids.js';
 
 describe('distillation-stable-archive (RFC 0062 §B)', () => {
   it('identical sources + budget produce an identical archive checksum', async () => {
     if ((await readDistillationCap())?.supported !== true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `(await readDistillationCap())?.supported !== true` returned early');
-    const req = {
+    const reqBody = {
       memoryRef: 'conformance-distill',
       tokenBudget: 8000,
       sources: ['s1', 's2', 's3'],
     };
-    const a = await invokeDistill(req);
+    const a = await invokeDistill(reqBody);
     if (a === null) return softSkip('blocked', 'seam absent — soft-skip');
-    const b = await invokeDistill(req);
+    const b = await invokeDistill(reqBody);
     if (b === null) return softSkip('blocked', 'precondition not met — `b === null` returned early (seam, prior step, or fixture unavailable)');
     expect(
       typeof a.body.archiveChecksum === 'string' && (a.body.archiveChecksum as string).length > 0,
-      driver.describe('RFC 0062 §B', 'a distillation run MUST produce a non-empty archive checksum'),
+      req('openwop.it.distillation-stable-archive.identical-sources-budget-produce-an-identical-archive-checksum', 'RFC 0062 §B', 'a distillation run MUST produce a non-empty archive checksum'),
     ).toBe(true);
     expect(
       b.body.archiveChecksum,
-      driver.describe('RFC 0062 §B', 'the same source set + budget MUST yield a byte-stable archive'),
+      req('openwop.it.distillation-stable-archive.identical-sources-budget-produce-an-identical-archive-checksum', 'RFC 0062 §B', 'the same source set + budget MUST yield a byte-stable archive'),
     ).toBe(a.body.archiveChecksum);
   });
 });