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

package/src/scenarios/chain-produced-var-roundtrip.test.ts

@@ -30,8 +30,7 @@ import {
   ProducedVarProducerUnknownError,
   type WorkflowChain,
 } from '../lib/workflow-chain-expansion.js';
-
-const why = (specRef: string, requirement: string): string => `${specRef} — ${requirement}`;
+import { req } from '../lib/requirement-ids.js';
 const SPEC = 'workflow-chain-packs.md §"Produced (run-scoped) variables (RFC 0133)"';
 
 /** `generate` writes `plan`; `decompose` reads it via a variable binding. */
@@ -56,19 +55,19 @@ const PLAN_GEN: WorkflowChain = {
 describe('chain-produced-var-roundtrip: run-scoped variables (RFC 0133 §2, server-free)', () => {
   it('emits declared producedVariables into variables[] (name + type, NO value)', () => {
     const vars = emitProducedVariables(PLAN_GEN);
-    expect(vars, why(SPEC, '§2.3 — one run-scoped variable emitted')).toEqual([{ name: 'plan', type: 'object' }]);
+    expect(vars, req('openwop.it.chain-produced-var-roundtrip.emits-declared-producedvariables-into-variables-name-type-no-value', SPEC, '§2.3 — one run-scoped variable emitted')).toEqual([{ name: 'plan', type: 'object' }]);
     // Run-scoped: NO author-time value rides the emitted entry.
-    expect('value' in (vars[0] as object), why(SPEC, '§2.3 — no author-time value (distinct from parameters)')).toBe(
+    expect('value' in (vars[0] as object), req('openwop.it.chain-produced-var-roundtrip.emits-declared-producedvariables-into-variables-name-type-no-value', SPEC, '§2.3 — no author-time value (distinct from parameters)')).toBe(
       false,
     );
     expect(
       'defaultValue' in (vars[0] as object),
-      why(SPEC, '§2.3 — no default value (a produced var is written during the run)'),
+      req('openwop.it.chain-produced-var-roundtrip.emits-declared-producedvariables-into-variables-name-type-no-value', SPEC, '§2.3 — no default value (a produced var is written during the run)'),
     ).toBe(false);
   });
 
   it('validates a variable read of a DECLARED producedVariables name', () => {
-    expect(() => validateVariableReads(PLAN_GEN), why(SPEC, '§2.2 — declared read is closed-world valid')).not.toThrow();
+    expect(() => validateVariableReads(PLAN_GEN), req('openwop.it.chain-produced-var-roundtrip.validates-a-variable-read-of-a-declared-producedvariables-name', SPEC, '§2.2 — declared read is closed-world valid')).not.toThrow();
   });
 
   it('rejects a variable read of an UNDECLARED name (variable_undeclared)', () => {
@@ -86,14 +85,14 @@ describe('chain-produced-var-roundtrip: run-scoped variables (RFC 0133 §2, serv
         ],
       },
     };
-    expect(() => validateVariableReads(undeclared), why(SPEC, '§2.2 — undeclared read MUST reject')).toThrow(
+    expect(() => validateVariableReads(undeclared), req('openwop.it.chain-produced-var-roundtrip.rejects-a-variable-read-of-an-undeclared-name-variable-undeclared', SPEC, '§2.2 — undeclared read MUST reject')).toThrow(
       VariableUndeclaredError,
     );
     try {
       validateVariableReads(undeclared);
     } catch (e) {
-      expect((e as VariableUndeclaredError).code, why(SPEC, 'wire code variable_undeclared')).toBe('variable_undeclared');
-      expect((e as VariableUndeclaredError).variableName, why(SPEC, 'names the offending variable')).toBe('plan');
+      expect((e as VariableUndeclaredError).code, req('openwop.it.chain-produced-var-roundtrip.rejects-a-variable-read-of-an-undeclared-name-variable-undeclared', SPEC, 'wire code variable_undeclared')).toBe('variable_undeclared');
+      expect((e as VariableUndeclaredError).variableName, req('openwop.it.chain-produced-var-roundtrip.rejects-a-variable-read-of-an-undeclared-name-variable-undeclared', SPEC, 'names the offending variable')).toBe('plan');
     }
   });
 
@@ -104,12 +103,12 @@ describe('chain-produced-var-roundtrip: run-scoped variables (RFC 0133 §2, serv
     };
     expect(
       () => validateVariableReads(badProducer),
-      why(SPEC, '§2.2 — producedBy MUST be a real fragment node'),
+      req('openwop.it.chain-produced-var-roundtrip.rejects-a-producedvariables-whose-producedby-names-a-non-existent-node-produced', SPEC, '§2.2 — producedBy MUST be a real fragment node'),
     ).toThrow(ProducedVarProducerUnknownError);
     try {
       validateVariableReads(badProducer);
     } catch (e) {
-      expect((e as ProducedVarProducerUnknownError).code, why(SPEC, 'distinct wire code')).toBe(
+      expect((e as ProducedVarProducerUnknownError).code, req('openwop.it.chain-produced-var-roundtrip.rejects-a-producedvariables-whose-producedby-names-a-non-existent-node-produced', SPEC, 'distinct wire code')).toBe(
         'produced_var_producer_unknown',
       );
     }
@@ -123,7 +122,7 @@ describe('chain-produced-var-roundtrip: run-scoped variables (RFC 0133 §2, serv
     };
     expect(
       () => validateVariableReads(collide),
-      why(SPEC, '§2.2 — a produced var colliding with a parameter name MUST reject'),
+      req('openwop.it.chain-produced-var-roundtrip.rejects-a-producedvariables-name-that-collides-with-a-parameter-channels-must-be', SPEC, '§2.2 — a produced var colliding with a parameter name MUST reject'),
     ).toThrow(VariableUndeclaredError);
   });
 
@@ -141,12 +140,12 @@ describe('chain-produced-var-roundtrip: run-scoped variables (RFC 0133 §2, serv
     };
     expect(
       () => validateVariableReads(paramRead, new Set(['seed'])),
-      why(SPEC, '§2.2 — a materialized-parameter read validates'),
+      req('openwop.it.chain-produced-var-roundtrip.validates-a-read-of-a-materialized-parameter-name-params-produced-vars-compose', SPEC, '§2.2 — a materialized-parameter read validates'),
     ).not.toThrow();
     // …but still rejects when the name is neither a produced var nor a param.
     expect(
       () => validateVariableReads(paramRead, new Set()),
-      why(SPEC, '§2.2 — same read with no matching param still rejects'),
+      req('openwop.it.chain-produced-var-roundtrip.validates-a-read-of-a-materialized-parameter-name-params-produced-vars-compose', SPEC, '§2.2 — same read with no matching param still rejects'),
     ).toThrow(VariableUndeclaredError);
   });
 });

package/src/scenarios/chain-subchain-cycle-rejected.test.ts

@@ -30,8 +30,7 @@ import {
   DEFAULT_MAX_SUB_CHAIN_DEPTH,
   type WorkflowChain,
 } from '../lib/workflow-chain-expansion.js';
-
-const why = (specRef: string, requirement: string): string => `${specRef} — ${requirement}`;
+import { req } from '../lib/requirement-ids.js';
 const SPEC = 'workflow-chain-packs.md §"Sub-chain composition (RFC 0133)"';
 
 /** A chain node that dispatches a named sub-chain ref. */
@@ -88,14 +87,14 @@ const ctxFor = (siblings: Map<string, WorkflowChain>, maxDepth?: number) => ({
 describe('chain-subchain-cycle-rejected: bounded recursion (RFC 0133, server-free)', () => {
   it('rejects a chain that transitively composes itself (sub_chain_cycle)', () => {
     const siblings = new Map([[selfRef.chainId, selfRef]]);
-    expect(() => expandChainTree(selfRef, ctxFor(siblings)), why(SPEC, 'self-composition MUST reject')).toThrow(
+    expect(() => expandChainTree(selfRef, ctxFor(siblings)), req('openwop.it.chain-subchain-cycle-rejected.rejects-a-chain-that-transitively-composes-itself-sub-chain-cycle', SPEC, 'self-composition MUST reject')).toThrow(
       SubChainCycleError,
     );
     try {
       expandChainTree(selfRef, ctxFor(siblings));
     } catch (e) {
-      expect((e as SubChainCycleError).code, why(SPEC, 'wire code sub_chain_cycle')).toBe('sub_chain_cycle');
-      expect((e as SubChainCycleError).httpStatus, why(SPEC, 'HTTP 400')).toBe(400);
+      expect((e as SubChainCycleError).code, req('openwop.it.chain-subchain-cycle-rejected.rejects-a-chain-that-transitively-composes-itself-sub-chain-cycle', SPEC, 'wire code sub_chain_cycle')).toBe('sub_chain_cycle');
+      expect((e as SubChainCycleError).httpStatus, req('openwop.it.chain-subchain-cycle-rejected.rejects-a-chain-that-transitively-composes-itself-sub-chain-cycle', SPEC, 'HTTP 400')).toBe(400);
     }
   });
 
@@ -105,13 +104,13 @@ describe('chain-subchain-cycle-rejected: bounded recursion (RFC 0133, server-fre
     const { root, siblings } = linearChain(5);
     expect(
       () => expandChainTree(root, ctxFor(siblings, 2)),
-      why(SPEC, 'depth breach MUST reject (bounded recursion)'),
+      req('openwop.it.chain-subchain-cycle-rejected.rejects-nesting-past-maxsubchaindepth-with-a-distinct-sub-chain-max-depth-exceed', SPEC, 'depth breach MUST reject (bounded recursion)'),
     ).toThrow(SubChainDepthExceededError);
     try {
       expandChainTree(root, ctxFor(siblings, 2));
     } catch (e) {
-      expect((e as SubChainDepthExceededError).code, why(SPEC, 'distinct wire code')).toBe('sub_chain_max_depth_exceeded');
-      expect(e instanceof SubChainCycleError, why(SPEC, 'a depth breach is NOT a cycle')).toBe(false);
+      expect((e as SubChainDepthExceededError).code, req('openwop.it.chain-subchain-cycle-rejected.rejects-nesting-past-maxsubchaindepth-with-a-distinct-sub-chain-max-depth-exceed', SPEC, 'distinct wire code')).toBe('sub_chain_max_depth_exceeded');
+      expect(e instanceof SubChainCycleError, req('openwop.it.chain-subchain-cycle-rejected.rejects-nesting-past-maxsubchaindepth-with-a-distinct-sub-chain-max-depth-exceed', SPEC, 'a depth breach is NOT a cycle')).toBe(false);
     }
   });
 
@@ -119,7 +118,7 @@ describe('chain-subchain-cycle-rejected: bounded recursion (RFC 0133, server-fre
     const { root, siblings } = linearChain(3);
     const { children } = expandChainTree(root, ctxFor(siblings, DEFAULT_MAX_SUB_CHAIN_DEPTH));
     // 3 composing links (link.0..link.2 each compose their successor) ⇒ 3 co-registered children.
-    expect(children.length, why(SPEC, 'benign acyclic tree within the bound expands')).toBe(3);
+    expect(children.length, req('openwop.it.chain-subchain-cycle-rejected.expands-an-acyclic-tree-within-the-bound-cleanly-guard-rejects-bombs-not-benign', SPEC, 'benign acyclic tree within the bound expands')).toBe(3);
   });
 
   it('rejects a subChainRef that resolves to no sibling chain (sub_chain_unresolved)', () => {
@@ -135,7 +134,7 @@ describe('chain-subchain-cycle-rejected: bounded recursion (RFC 0133, server-fre
     const siblings = new Map([[orphan.chainId, orphan]]);
     expect(
       () => expandChainTree(orphan, ctxFor(siblings)),
-      why(SPEC, '§1.1 — unresolvable ref rejects distinctly'),
+      req('openwop.it.chain-subchain-cycle-rejected.rejects-a-subchainref-that-resolves-to-no-sibling-chain-sub-chain-unresolved', SPEC, '§1.1 — unresolvable ref rejects distinctly'),
     ).toThrow(SubChainUnresolvedError);
   });
 });

package/src/scenarios/chain-subchain-fanout.test.ts

@@ -28,8 +28,7 @@ import addFormats from 'ajv-formats';
 import { SCHEMAS_DIR } from '../lib/paths.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
-
-const cite = (section: string, requirement: string): string => `${section} — ${requirement}`;
+import { req } from '../lib/requirement-ids.js';
 const CAPS = join(SCHEMAS_DIR, 'capabilities.schema.json');
 const MANIFEST = join(SCHEMAS_DIR, 'workflow-chain-pack-manifest.schema.json');
 
@@ -40,20 +39,20 @@ function loadSchema(path: string): Record<string, unknown> {
 describe('chain-subchain-fanout §A: capability + manifest shape (RFC 0133, always-on)', () => {
   it('capabilities.schema.json §workflowChainPacks.subChains requires supported:boolean + maxDepth default 8', () => {
     const raw = readFileSync(CAPS, 'utf8');
-    expect(raw.includes('"subChains"'), cite('capabilities §workflowChainPacks', 'the subChains block MUST exist')).toBe(
+    expect(raw.includes('"subChains"'), req('openwop.it.chain-subchain-fanout.capabilities-schema-json-workflowchainpacks-subchains-requires-supported-boolean', 'capabilities §workflowChainPacks', 'the subChains block MUST exist')).toBe(
       true,
     );
     const schema = loadSchema(CAPS);
     // The subChains sub-block MUST be present somewhere in the workflowChainPacks family.
     expect(
       JSON.stringify(schema).includes('"subChains"'),
-      cite('capabilities §subChains', 'declared in the capabilities schema'),
+      req('openwop.it.chain-subchain-fanout.capabilities-schema-json-workflowchainpacks-subchains-requires-supported-boolean', 'capabilities §subChains', 'declared in the capabilities schema'),
     ).toBe(true);
     expect(
       raw.includes('sub_chain_unsupported'),
-      cite('capabilities §subChains', 'the description MUST cite the sub_chain_unsupported refusal'),
+      req('openwop.it.chain-subchain-fanout.capabilities-schema-json-workflowchainpacks-subchains-requires-supported-boolean', 'capabilities §subChains', 'the description MUST cite the sub_chain_unsupported refusal'),
     ).toBe(true);
-    expect(raw.includes('"default": 8'), cite('capabilities §subChains.maxDepth', 'RECOMMENDED default 8')).toBe(true);
+    expect(raw.includes('"default": 8'), req('openwop.it.chain-subchain-fanout.capabilities-schema-json-workflowchainpacks-subchains-requires-supported-boolean', 'capabilities §subChains.maxDepth', 'RECOMMENDED default 8')).toBe(true);
   });
 
   it('manifest schema accepts a core.dispatch fan-out over a subChainRef worker', () => {
@@ -93,7 +92,7 @@ describe('chain-subchain-fanout §A: capability + manifest shape (RFC 0133, alwa
         },
       ],
     };
-    expect(validate(pack), cite('manifest §subChains', `a subChainRef fan-out validates: ${ajv.errorsText(validate.errors)}`)).toBe(
+    expect(validate(pack), req('openwop.it.chain-subchain-fanout.manifest-schema-accepts-a-core-dispatch-fan-out-over-a-subchainref-worker', 'manifest §subChains', `a subChainRef fan-out validates: ${ajv.errorsText(validate.errors)}`)).toBe(
       true,
     );
   });
@@ -120,7 +119,7 @@ describe('chain-subchain-fanout §A: capability + manifest shape (RFC 0133, alwa
     };
     expect(
       validate(pack),
-      cite('manifest §config not-guard', 'a chain MUST NOT pin a concrete config.workflowId'),
+      req('openwop.it.chain-subchain-fanout.manifest-schema-rejects-a-concrete-config-workflowid-inside-a-fragment-the-1-2-n', 'manifest §config not-guard', 'a chain MUST NOT pin a concrete config.workflowId'),
     ).toBe(false);
   });
 });
@@ -134,6 +133,6 @@ describe('chain-subchain-fanout §B: host child fan-out (RFC 0133, capability-ga
     // invariant `sub-chain-child-tenant-scoped` (child owned by parent's tenant).
     // The from-chain response MUST carry the §1.3 contract: { workflowId,
     // subChainWorkflowIds[] (tenant-scoped, deduped), nodeCount }.
-    expect(wcp?.subChains?.supported, 'host advertising subChains.supported implements child fan-out').toBe(true);
+    expect(wcp?.subChains?.supported, req('openwop.it.chain-subchain-fanout.fans-out-n-child-runs-over-a-subchainref-worker-returns-the-from-chain-contract', 'RFC 0133 §1.2', 'host advertising subChains.supported implements child fan-out')).toBe(true);
   });
 });

package/src/scenarios/chain-subchain-sibling.test.ts

@@ -30,9 +30,7 @@ import {
   mintChildWorkflowId,
   type WorkflowChain,
 } from '../lib/workflow-chain-expansion.js';
-
-/** Server-free assertion-message helper (mirrors driver.describe without OPENWOP_BASE_URL). */
-const why = (specRef: string, requirement: string): string => `${specRef} — ${requirement}`;
+import { req } from '../lib/requirement-ids.js';
 const SPEC = 'workflow-chain-packs.md §"Sub-chain composition (RFC 0133)"';
 
 /** A leaf child chain — one plain node, no further composition. */
@@ -83,53 +81,53 @@ const ctx = (tenantId = 'tenant-a') => ({
 describe('chain-subchain-sibling: co-registration (RFC 0133 §1, server-free)', () => {
   it('co-registers the referenced sibling as its own workflow', () => {
     const { children } = expandChainTree(PARENT, ctx());
-    expect(children.length, why(SPEC, '§1.3 step 2 — one distinct sibling ref ⇒ one co-registered child')).toBe(1);
-    expect(children[0]?.chainId, why(SPEC, 'child carries the composed chainId')).toBe('lesson-batch');
+    expect(children.length, req('openwop.it.chain-subchain-sibling.co-registers-the-referenced-sibling-as-its-own-workflow', SPEC, '§1.3 step 2 — one distinct sibling ref ⇒ one co-registered child')).toBe(1);
+    expect(children[0]?.chainId, req('openwop.it.chain-subchain-sibling.co-registers-the-referenced-sibling-as-its-own-workflow', SPEC, 'child carries the composed chainId')).toBe('lesson-batch');
     expect(
       children[0]?.fragment.nodes.length,
-      why(SPEC, 'child is a fully expanded fragment (its own registered workflow)'),
+      req('openwop.it.chain-subchain-sibling.co-registers-the-referenced-sibling-as-its-own-workflow', SPEC, 'child is a fully expanded fragment (its own registered workflow)'),
     ).toBe(1);
   });
 
   it('mints a DETERMINISTIC, TENANT-SCOPED, version-pinned child id', () => {
     const { children } = expandChainTree(PARENT, ctx());
     const expected = mintChildWorkflowId('tenant-a', 'lesson-batch', '1.0.0');
-    expect(children[0]?.childWorkflowId, why(SPEC, '§1.3 step 2 — deterministic (tenantId, childChainId, version) id')).toBe(
+    expect(children[0]?.childWorkflowId, req('openwop.it.chain-subchain-sibling.mints-a-deterministic-tenant-scoped-version-pinned-child-id', SPEC, '§1.3 step 2 — deterministic (tenantId, childChainId, version) id')).toBe(
       expected,
     );
     // Re-instantiating in the same tenant converges on the same id.
     const again = expandChainTree(PARENT, ctx());
-    expect(again.children[0]?.childWorkflowId, why(SPEC, 'repeat instantiation in-tenant converges')).toBe(expected);
+    expect(again.children[0]?.childWorkflowId, req('openwop.it.chain-subchain-sibling.mints-a-deterministic-tenant-scoped-version-pinned-child-id', SPEC, 'repeat instantiation in-tenant converges')).toBe(expected);
   });
 
   it('scopes the child id per TENANT — two tenants NEVER collide on the global registry (isolation)', () => {
     const a = expandChainTree(PARENT, ctx('tenant-a')).children[0]?.childWorkflowId;
     const b = expandChainTree(PARENT, ctx('tenant-b')).children[0]?.childWorkflowId;
-    expect(a, why(SPEC, 'tenant-a mints an id')).toBeTruthy();
+    expect(a, req('openwop.it.chain-subchain-sibling.scopes-the-child-id-per-tenant-two-tenants-never-collide-on-the-global-registry', SPEC, 'tenant-a mints an id')).toBeTruthy();
     expect(
       a !== b,
-      why(SPEC, '§1.3 SECURITY sub-chain-child-tenant-scoped — distinct tenants ⇒ distinct child ids, no cross-tenant collision'),
+      req('openwop.it.chain-subchain-sibling.scopes-the-child-id-per-tenant-two-tenants-never-collide-on-the-global-registry', SPEC, '§1.3 SECURITY sub-chain-child-tenant-scoped — distinct tenants ⇒ distinct child ids, no cross-tenant collision'),
     ).toBe(true);
   });
 
   it('registers a child referenced twice exactly ONCE (dedup by deterministic id)', () => {
     const { children } = expandChainTree(PARENT, ctx());
     const ids = children.map((c) => c.childWorkflowId);
-    expect(new Set(ids).size, why(SPEC, '§1.3 step 2 — a shared child registers once')).toBe(ids.length);
-    expect(ids.length, why(SPEC, 'both build-0 + build-1 collapse to one child')).toBe(1);
+    expect(new Set(ids).size, req('openwop.it.chain-subchain-sibling.registers-a-child-referenced-twice-exactly-once-dedup-by-deterministic-id', SPEC, '§1.3 step 2 — a shared child registers once')).toBe(ids.length);
+    expect(ids.length, req('openwop.it.chain-subchain-sibling.registers-a-child-referenced-twice-exactly-once-dedup-by-deterministic-id', SPEC, 'both build-0 + build-1 collapse to one child')).toBe(1);
   });
 
   it('rewrites config.subChainRef → the minted child config.workflowId', () => {
     const { parent } = expandChainTree(PARENT, ctx());
     const expected = mintChildWorkflowId('tenant-a', 'lesson-batch', '1.0.0');
     const dispatchNodes = parent.nodes.filter((n) => n.typeId === 'core.subWorkflow');
-    expect(dispatchNodes.length, why(SPEC, 'both dispatch nodes present')).toBe(2);
+    expect(dispatchNodes.length, req('openwop.it.chain-subchain-sibling.rewrites-config-subchainref-the-minted-child-config-workflowid', SPEC, 'both dispatch nodes present')).toBe(2);
     for (const n of dispatchNodes) {
       const config = n.config as Record<string, unknown>;
-      expect(config['workflowId'], why(SPEC, '§1.3 step 3 — subChainRef rewritten to minted child id')).toBe(expected);
+      expect(config['workflowId'], req('openwop.it.chain-subchain-sibling.rewrites-config-subchainref-the-minted-child-config-workflowid', SPEC, '§1.3 step 3 — subChainRef rewritten to minted child id')).toBe(expected);
       expect(
         'subChainRef' in config,
-        why(SPEC, '§1.3 step 3 — transient subChainRef key dropped from the runtime config'),
+        req('openwop.it.chain-subchain-sibling.rewrites-config-subchainref-the-minted-child-config-workflowid', SPEC, '§1.3 step 3 — transient subChainRef key dropped from the runtime config'),
       ).toBe(false);
     }
   });
@@ -140,7 +138,7 @@ describe('chain-subchain-sibling: co-registration (RFC 0133 §1, server-free)',
     const referenced = parent.nodes
       .filter((n) => n.typeId === 'core.subWorkflow')
       .map((n) => (n.config as Record<string, unknown>)['workflowId']);
-    expect(referenced.every((id) => id === childId), why(SPEC, 'parent HOLDS the co-registered child at runtime')).toBe(
+    expect(referenced.every((id) => id === childId), req('openwop.it.chain-subchain-sibling.preserves-the-child-reference-at-runtime-concrete-workflowid-unlike-inline-mode', SPEC, 'parent HOLDS the co-registered child at runtime')).toBe(
       true,
     );
   });

package/src/scenarios/channel-presence-behavioral.test.ts

@@ -33,6 +33,8 @@ import { describe, it, expect } from 'vitest';
 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 PROFILE = 'openwop-channel-presence';
 const SUBJECT_REF = /^(user|agent):.+/;
@@ -47,37 +49,37 @@ describe('channel-presence-behavioral (RFC 0110 §Conformance)', () => {
 
     const conversationId = 'conf:channel-presence:c1';
     const res = await driver.post('/v1/host/sample/channel-presence/snapshot', { conversationId, member: 'user:conformance-runner' });
-    if (res.status === 404 || res.status === 405) return; // seam unwired — host witnesses via its own route test (dual-staging)
+    if (res.status === 404 || res.status === 405) return softSkip('blocked', 'precondition not met — `res.status === 404 || res.status === 405` returned early (seam unwired — host witnesses via its own route test (dual-staging)) (seam, prior step, or fixture unavailable)'); // seam unwired — host witnesses via its own route test (dual-staging)
 
     expect(
       res.status === 200,
-      driver.describe('RFC 0110 §Proposal', 'the presence snapshot seam MUST return 200 for a member'),
+      req('openwop.it.channel-presence-behavioral.a-presence-snapshot-is-the-closed-members-only-non-vacuous-channel-presence-shap', 'RFC 0110 §Proposal', 'the presence snapshot seam MUST return 200 for a member'),
     ).toBe(true);
     const snap = res.json as PresenceSnapshot;
 
     // MUST 1 — CLOSED shape: exactly conversationId / present / typing (no PII field rides).
     expect(
       Object.keys(snap).sort().join(','),
-      driver.describe('RFC 0110 §Proposal', 'channel.presence carries ONLY conversationId/present/typing (no PII)'),
+      req('openwop.it.channel-presence-behavioral.a-presence-snapshot-is-the-closed-members-only-non-vacuous-channel-presence-shap', 'RFC 0110 §Proposal', 'channel.presence carries ONLY conversationId/present/typing (no PII)'),
     ).toBe('conversationId,present,typing');
-    expect(snap.conversationId, driver.describe('RFC 0110 §Proposal', 'the snapshot echoes the conversationId')).toBe(conversationId);
+    expect(snap.conversationId, req('openwop.it.channel-presence-behavioral.a-presence-snapshot-is-the-closed-members-only-non-vacuous-channel-presence-shap', 'RFC 0110 §Proposal', 'the snapshot echoes the conversationId')).toBe(conversationId);
 
     // MUST 2 — every ref is an opaque RFC 0041 subject ref (no PII).
     for (const ref of [...snap.present, ...snap.typing]) {
       expect(
         SUBJECT_REF.test(ref),
-        driver.describe('RFC 0110 §Proposal / RFC 0041', `present/typing ref "${ref}" MUST be an opaque user:/agent: subject ref`),
+        req('openwop.it.channel-presence-behavioral.a-presence-snapshot-is-the-closed-members-only-non-vacuous-channel-presence-shap', 'RFC 0110 §Proposal / RFC 0041', `present/typing ref "${ref}" MUST be an opaque user:/agent: subject ref`),
       ).toBe(true);
     }
     // typing is a subset of present.
     for (const ref of snap.typing) {
-      expect(snap.present.includes(ref), driver.describe('RFC 0110 §Proposal', 'every typing ref MUST also be present')).toBe(true);
+      expect(snap.present.includes(ref), req('openwop.it.channel-presence-behavioral.a-presence-snapshot-is-the-closed-members-only-non-vacuous-channel-presence-shap', 'RFC 0110 §Proposal', 'every typing ref MUST also be present')).toBe(true);
     }
 
     // MUST 3 — NON-VACUOUS: the snapshotting member is present.
     expect(
       snap.present.includes('user:conformance-runner'),
-      driver.describe('RFC 0110 §Proposal', 'the snapshotting member MUST appear in present (members-only, real)'),
+      req('openwop.it.channel-presence-behavioral.a-presence-snapshot-is-the-closed-members-only-non-vacuous-channel-presence-shap', 'RFC 0110 §Proposal', 'the snapshotting member MUST appear in present (members-only, real)'),
     ).toBe(true);
   });
 });

package/src/scenarios/channel-presence-shape.test.ts

@@ -34,8 +34,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>;
@@ -49,26 +48,26 @@ describe('channel-presence-shape: the channel.presence payload (RFC 0110 §Propo
   it('a conforming presence snapshot (present + typing) validates', () => {
     expect(
       presence({ conversationId: 'chan-eng', present: ['user:alice', 'agent:iris'], typing: ['user:alice'] }),
-      why('RFC 0110 §Proposal', 'a conforming channel.presence payload MUST validate'),
+      req('openwop.it.channel-presence-shape.a-conforming-presence-snapshot-present-typing-validates', 'RFC 0110 §Proposal', 'a conforming channel.presence payload MUST validate'),
     ).toBe(true);
   });
 
   it('typing is OPTIONAL — a snapshot with nobody typing validates', () => {
     expect(
       presence({ conversationId: 'chan-eng', present: ['user:alice'] }),
-      why('RFC 0110 §Proposal', 'typing is optional'),
+      req('openwop.it.channel-presence-shape.typing-is-optional-a-snapshot-with-nobody-typing-validates', 'RFC 0110 §Proposal', 'typing is optional'),
     ).toBe(true);
   });
 
   it('conversationId and present are REQUIRED', () => {
-    expect(presence({ present: ['user:a'] }), why('RFC 0110 §Proposal', 'conversationId is required')).toBe(false);
-    expect(presence({ conversationId: 'c' }), why('RFC 0110 §Proposal', 'present is required')).toBe(false);
+    expect(presence({ present: ['user:a'] }), req('openwop.it.channel-presence-shape.conversationid-and-present-are-required', 'RFC 0110 §Proposal', 'conversationId is required')).toBe(false);
+    expect(presence({ conversationId: 'c' }), req('openwop.it.channel-presence-shape.conversationid-and-present-are-required', 'RFC 0110 §Proposal', 'present is required')).toBe(false);
   });
 
   it('the payload is CLOSED — a non-subject-ref field (ip/location) MUST be rejected (the no-PII guard)', () => {
     expect(
       presence({ conversationId: 'c', present: ['user:a'], ip: '10.0.0.1' }),
-      why('RFC 0110 §Proposal', 'channel.presence MUST forbid extra keys — no PII rides the payload'),
+      req('openwop.it.channel-presence-shape.the-payload-is-closed-a-non-subject-ref-field-ip-location-must-be-rejected-the-n', 'RFC 0110 §Proposal', 'channel.presence MUST forbid extra keys — no PII rides the payload'),
     ).toBe(false);
   });
 });
@@ -77,7 +76,7 @@ describe('channel-presence-shape: event type + capability advertisement (RFC 011
   it('run-event.schema.json enumerates `channel.presence` as a RunEvent type', () => {
     const re = loadSchema('run-event.schema.json');
     const enumVals = JSON.stringify(re);
-    expect(enumVals.includes('"channel.presence"'), why('RFC 0110 §Proposal', 'channel.presence MUST be a declared RunEvent type')).toBe(true);
+    expect(enumVals.includes('"channel.presence"'), req('openwop.it.channel-presence-shape.run-event-schema-json-enumerates-channel-presence-as-a-runevent-type', 'RFC 0110 §Proposal', 'channel.presence MUST be a declared RunEvent type')).toBe(true);
   });
 
   it('capabilities.schema.json declares channelPresence with supported, closed', () => {
@@ -85,9 +84,9 @@ describe('channel-presence-shape: event type + capability advertisement (RFC 011
     const block = (caps.properties as Record<string, Record<string, unknown>>).channelPresence as
       | { properties?: Record<string, unknown>; required?: string[]; additionalProperties?: boolean }
       | undefined;
-    expect(block, why('RFC 0110 §Conformance', 'capabilities.channelPresence MUST be declared')).toBeDefined();
-    expect(block?.properties?.supported, why('RFC 0110 §Conformance', 'channelPresence.supported MUST be declared')).toBeDefined();
-    expect(block?.required, why('RFC 0110 §Conformance', 'supported MUST be required on the block')).toContain('supported');
-    expect(block?.additionalProperties, why('RFC 0110 §Conformance', 'the block MUST be closed')).toBe(false);
+    expect(block, req('openwop.it.channel-presence-shape.capabilities-schema-json-declares-channelpresence-with-supported-closed', 'RFC 0110 §Conformance', 'capabilities.channelPresence MUST be declared')).toBeDefined();
+    expect(block?.properties?.supported, req('openwop.it.channel-presence-shape.capabilities-schema-json-declares-channelpresence-with-supported-closed', 'RFC 0110 §Conformance', 'channelPresence.supported MUST be declared')).toBeDefined();
+    expect(block?.required, req('openwop.it.channel-presence-shape.capabilities-schema-json-declares-channelpresence-with-supported-closed', 'RFC 0110 §Conformance', 'supported MUST be required on the block')).toContain('supported');
+    expect(block?.additionalProperties, req('openwop.it.channel-presence-shape.capabilities-schema-json-declares-channelpresence-with-supported-closed', 'RFC 0110 §Conformance', 'the block MUST be closed')).toBe(false);
   });
 });

package/src/scenarios/channel-ttl.test.ts

@@ -22,6 +22,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 WORKFLOW_ID = 'conformance-channel-ttl';
 const SKIP_NO_FIXTURE = !isFixtureAdvertised(WORKFLOW_ID);
@@ -38,7 +39,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('channel-ttl: conformance-channel-ttl drops ent
     const runId = (create.json as { runId: string }).runId;
 
     const terminal = await pollUntilTerminal(runId);
-    expect(terminal.status, driver.describe(
+    expect(terminal.status, req('openwop.it.channel-ttl.after-the-post-ttl-write-the-channel-contains-exactly-one-entry-with-value-d', 
       'fixtures.md conformance-channel-ttl §Terminal status',
       'fixture MUST reach terminal `completed`',
     )).toBe('completed');
@@ -46,22 +47,22 @@ describe.skipIf(SKIP_NO_FIXTURE)('channel-ttl: conformance-channel-ttl drops ent
     const variables = terminal.variables ?? {};
     const events = variables.events as ChannelEntry[] | undefined;
 
-    expect(Array.isArray(events), driver.describe(
+    expect(Array.isArray(events), req('openwop.it.channel-ttl.after-the-post-ttl-write-the-channel-contains-exactly-one-entry-with-value-d', 
       'channels-and-reducers.md §append',
       'channel state MUST be stored as an array of {value, _ts} entries',
     )).toBe(true);
 
-    expect(events!.length, driver.describe(
+    expect(events!.length, req('openwop.it.channel-ttl.after-the-post-ttl-write-the-channel-contains-exactly-one-entry-with-value-d', 
       'channels-and-reducers.md §TTL — write-time filter',
       'after the post-TTL write, exactly 1 entry MUST remain (the 3 priors aged out)',
     )).toBe(1);
 
-    expect(events![0].value, driver.describe(
+    expect(events![0].value, req('openwop.it.channel-ttl.after-the-post-ttl-write-the-channel-contains-exactly-one-entry-with-value-d', 
       'fixtures.md conformance-channel-ttl §Topology',
       'the surviving entry MUST be the post-delay write (value "d")',
     )).toBe('d');
 
-    expect(typeof events![0]._ts, driver.describe(
+    expect(typeof events![0]._ts, req('openwop.it.channel-ttl.after-the-post-ttl-write-the-channel-contains-exactly-one-entry-with-value-d', 
       'channels-and-reducers.md §append entry shape',
       'each channel entry MUST carry a numeric `_ts` write timestamp',
     )).toBe('number');

package/src/scenarios/chat-card-pack-execution.test.ts

@@ -27,9 +27,9 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { driver } from '../lib/driver.js';
 import { behaviorGate, behaviorGatePresent } from '../lib/behavior-gate.js';
 import { readCardPacksCap, cardPacksSupported, executeCard } from '../lib/cardPacks.js';
+import { req } from '../lib/requirement-ids.js';
 
 const PROFILE = 'openwop-chat-card-packs';
 
@@ -40,13 +40,13 @@ describe('chat-card-pack-execution: prompt -> envelope -> typed artifact (RFC 00
     if (!behaviorGatePresent(PROFILE, res)) return; // seam absent: skip default, FAIL strict
     expect(
       res.json['validated'],
-      driver.describe('chat-card-packs.md "Card execution"', 'the host MUST validate the LLM output against the linked outputArtifactType schema'),
+      req('openwop.it.chat-card-pack-execution.a-registered-card-produces-a-schema-validated-artifact', 'chat-card-packs.md "Card execution"', 'the host MUST validate the LLM output against the linked outputArtifactType schema'),
     ).toBe(true);
     const evt = res.json['artifactCreated'] as { registered?: unknown } | undefined;
     if (evt && 'registered' in evt) {
       expect(
         evt.registered,
-        driver.describe('run-event-payloads.schema.json artifactCreated', 'a validated card output MUST emit artifact.created with registered:true'),
+        req('openwop.it.chat-card-pack-execution.a-registered-card-produces-a-schema-validated-artifact', 'run-event-payloads.schema.json artifactCreated', 'a validated card output MUST emit artifact.created with registered:true'),
       ).toBe(true);
     }
   });
@@ -62,7 +62,7 @@ describe('chat-card-pack-execution: prompt -> envelope -> typed artifact (RFC 00
     if (!behaviorGatePresent(PROFILE, res.json['contentTrust'])) return; // FAIL strict
     expect(
       res.json['contentTrust'],
-      driver.describe('chat-card-packs.md "Trust boundary" (R2)', 'a prompt segment derived from a card input MUST carry contentTrust:"untrusted"'),
+      req('openwop.it.chat-card-pack-execution.card-input-derived-prompt-content-propagates-contenttrust-untrusted-r2', 'chat-card-packs.md "Trust boundary" (R2)', 'a prompt segment derived from a card input MUST carry contentTrust:"untrusted"'),
     ).toBe('untrusted');
   });
 });

package/src/scenarios/chat-card-pack-manifest-validation.test.ts

@@ -30,6 +30,7 @@ import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
 import type { ErrorObject } from 'ajv';
 import { SCHEMAS_DIR } from '../lib/paths.js';
+import { req } from '../lib/requirement-ids.js';
 
 const SCHEMA_PATH = join(SCHEMAS_DIR, 'chat-card-pack-manifest.schema.json');
 
@@ -68,7 +69,7 @@ describe('category: chat-card-pack manifest validation', () => {
   it('positive: a valid chat card pack manifest validates cleanly', () => {
     expect(
       validate(validManifest()),
-      `chat-card-packs.md §"Manifest format": a well-formed kind:"card" manifest MUST validate. Errors: ${JSON.stringify(validate.errors)}`,
+      req('openwop.it.chat-card-pack-manifest-validation.positive-a-valid-chat-card-pack-manifest-validates-cleanly', 'chat-card-packs.md', `chat-card-packs.md §"Manifest format": a well-formed kind:"card" manifest MUST validate. Errors: ${JSON.stringify(validate.errors)}`),
     ).toBe(true);
   });
 
@@ -77,24 +78,24 @@ describe('category: chat-card-pack manifest validation', () => {
     const errs = failsWith(manifest, 'additionalProperties');
     expect(
       errs.some((e) => (e.params as { additionalProperty?: string }).additionalProperty === 'artifactTypes'),
-      'chat-card-packs.md §"Pack kind": one kind per pack (additionalProperties:false)',
+      req('openwop.it.chat-card-pack-manifest-validation.negative-a-manifest-mixing-cards-and-artifacttypes-is-rejected', 'chat-card-packs.md', 'chat-card-packs.md §"Pack kind": one kind per pack (additionalProperties:false)'),
     ).toBe(true);
   });
 
   it('negative: an empty cards[] is rejected', () => {
-    expect(failsWith({ ...validManifest(), cards: [] }, 'minItems').length).toBeGreaterThan(0);
+    expect(failsWith({ ...validManifest(), cards: [] }, 'minItems').length, req('openwop.it.chat-card-pack-manifest-validation.negative-an-empty-cards-is-rejected', 'chat-card-packs.md', 'negative: an empty cards[] is rejected')).toBeGreaterThan(0);
   });
 
   it('negative: an uppercase-scope cardTypeId is rejected', () => {
     const m = validManifest();
     m.cards[0]!.cardTypeId = 'Vendor.Acme.Card';
-    expect(failsWith(m, 'pattern').length).toBeGreaterThan(0);
+    expect(failsWith(m, 'pattern').length, req('openwop.it.chat-card-pack-manifest-validation.negative-an-uppercase-scope-cardtypeid-is-rejected', 'chat-card-packs.md', 'negative: an uppercase-scope cardTypeId is rejected')).toBeGreaterThan(0);
   });
 
   it('negative: a card missing prompt is rejected', () => {
     const m = validManifest();
     delete (m.cards[0] as { prompt?: unknown }).prompt;
-    expect(failsWith(m, 'required').length).toBeGreaterThan(0);
+    expect(failsWith(m, 'required').length, req('openwop.it.chat-card-pack-manifest-validation.negative-a-card-missing-prompt-is-rejected', 'chat-card-packs.md', 'negative: a card missing prompt is rejected')).toBeGreaterThan(0);
   });
 
   it('negative: a non-portable inputs[].type (canvas-reference) is rejected', () => {
@@ -102,7 +103,7 @@ describe('category: chat-card-pack manifest validation', () => {
     m.cards[0]!.inputs[0]!.type = 'canvas-reference';
     expect(
       failsWith(m, 'pattern').length,
-      'chat-card-packs.md §"Input fields": type is the closed portable enum OR a vendor.*/x- extension',
+      req('openwop.it.chat-card-pack-manifest-validation.negative-a-non-portable-inputs-type-canvas-reference-is-rejected', 'chat-card-packs.md', 'chat-card-packs.md §"Input fields": type is the closed portable enum OR a vendor.*/x- extension'),
     ).toBeGreaterThan(0);
   });
 
@@ -111,7 +112,7 @@ describe('category: chat-card-pack manifest validation', () => {
     m.cards[0]!.inputs[0]!.type = 'vendor.myndhyve.canvas-ref';
     expect(
       validate(m),
-      'chat-card-packs.md §"Input fields": a vendor.<org>.<kind> input type extension MUST validate (other hosts ignore it)',
+      req('openwop.it.chat-card-pack-manifest-validation.positive-a-vendor-prefixed-inputs-type-extension-is-tolerated', 'chat-card-packs.md', 'chat-card-packs.md §"Input fields": a vendor.<org>.<kind> input type extension MUST validate (other hosts ignore it)'),
     ).toBe(true);
   });
 
@@ -121,7 +122,7 @@ describe('category: chat-card-pack manifest validation', () => {
       m.cards[0]!.inputs[0]!.type = t;
       expect(
         validate(m),
-        `chat-card-packs.md §"Input fields": portable inputs[].type "${t}" MUST validate (G9 resolved 2026-05-27)`,
+        req('openwop.it.chat-card-pack-manifest-validation.positive-the-full-portable-inputs-type-subset-validates-g9-incl-multiselect-file', 'chat-card-packs.md', `chat-card-packs.md §"Input fields": portable inputs[].type "${t}" MUST validate (G9 resolved 2026-05-27)`),
       ).toBe(true);
     }
   });