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

package/src/scenarios/runner-ledger.test.ts

@@ -37,6 +37,7 @@ import { fileDisposition, deriveRequirementDispositions, requirementIdForFile, f
 import { softSkip, softSkipDisposition, resetSoftSkips, UNCLASSIFIED_RETURN_DETAIL } from '../lib/soft-skip.js';
 import { PROFILE_FLOOR_SCENARIOS } from '../lib/profiles.js';
 import { requirementsFor, requirementIdForScenario, requirementIdForPrefix } from '../lib/requirement-registry.js';
+import { req } from '../lib/requirement-ids.js';
 
 describe('RFC 0148 §A (S6) — ledger file sink and reader', () => {
   it('recordRequirement appends JSONL when OPENWOP_LEDGER_PATH is set; the reader merges and ranks conflicts least-certifiable-first', () => {
@@ -57,7 +58,7 @@ describe('RFC 0148 §A (S6) — ledger file sink and reader', () => {
       expect(lines.length).toBe(4);
       const merged = readLedgerFile(path);
       expect(merged.map((e) => e.requirementId)).toEqual(['t.a', 't.b']);
-      expect(merged.find((e) => e.requirementId === 't.a')?.disposition, 'conflict resolves to the least certifiable (blocked over executed-pass)').toBe('blocked');
+      expect(merged.find((e) => e.requirementId === 't.a')?.disposition, req('openwop.it.runner-ledger.recordrequirement-appends-jsonl-when-openwop-ledger-path-is-set-the-reader-merge', 'RFC 0148 §A', 'conflict resolves to the least certifiable (blocked over executed-pass)')).toBe('blocked');
       expect(merged.find((e) => e.requirementId === 't.b')?.disposition).toBe('inapplicable');
       expect(readLedgerFile(join(dir, 'missing.jsonl'))).toEqual([]);
     } finally {
@@ -71,7 +72,7 @@ describe('RFC 0148 §A (S6) — ledger file sink and reader', () => {
 
 describe('RFC 0148 §A (S6) — fileDisposition folds a file honestly', () => {
   it('fail beats pass; pass beats a gate reason; a gate reason beats blocked; nothing is blocked (unclassified)', () => {
-    expect(fileDisposition(['pass', 'fail', 'skip'], undefined).disposition).toBe('executed-fail');
+    expect(fileDisposition(['pass', 'fail', 'skip'], undefined).disposition, req('openwop.it.runner-ledger.fail-beats-pass-pass-beats-a-gate-reason-a-gate-reason-beats-blocked-nothing-is', 'RFC 0148 §A', 'fail beats pass; pass beats a gate reason; a gate reason beats blocked; nothing is blocked (unclassified)')).toBe('executed-fail');
     expect(fileDisposition(['pass', 'skip'], 'inapplicable').disposition).toBe('executed-pass');
     // real assertions + a gate reason → still an executed pass
     expect(fileDisposition(['pass', 'skip'], 'inapplicable', 4).disposition).toBe('executed-pass');
@@ -90,7 +91,7 @@ describe('RFC 0148 §A (S6) — fileDisposition folds a file honestly', () => {
 
   it('a floor file records under its §A floor id; any other file under openwop.scenario.*', () => {
     const floor = [...floorScenarioFiles()];
-    expect(floor.length).toBeGreaterThan(0);
+    expect(floor.length, req('openwop.it.runner-ledger.a-floor-file-records-under-its-a-floor-id-any-other-file-under-openwop-scenario', 'RFC 0148 §A', 'a floor file records under its §A floor id; any other file under openwop.scenario.*')).toBeGreaterThan(0);
     expect(requirementIdForFile(floor[0]!)).toBe(requirementIdForScenario(floor[0]!));
     expect(requirementIdForFile('some-other.test.ts')).toBe('openwop.scenario.some-other');
   });
@@ -119,7 +120,7 @@ describe('RFC 0148 §A (S6) — the runner derivation', () => {
 
   it('ledger rows win, prefix requirements derive from matching files, and a fully recorded floor certifies', () => {
     const d = deriveRequirementDispositions(reportAllPassed(), ledgerAllPassed(), [profile]);
-    expect(d.ledgerPresent).toBe(true);
+    expect(d.ledgerPresent, req('openwop.it.runner-ledger.ledger-rows-win-prefix-requirements-derive-from-matching-files-and-a-fully-recor', 'RFC 0148 §A', 'ledger rows win, prefix requirements derive from matching files, and a fully recorded floor certifies')).toBe(true);
     expect(d.rejectUnclassified).toBe(false);
     const v = d.verdicts.find((x) => x.profile === profile)!;
     expect(v.certifiable, JSON.stringify(v)).toBe(true);
@@ -144,7 +145,7 @@ describe('RFC 0148 §A (S6) — the runner derivation', () => {
     const row = d.requirements.find((r) => r.requirementId === requirementIdForScenario(files[0]!))!;
     expect(row.disposition).toBe('executed-pass'); // vitest did say passed — the row is honest about the source
     expect(row.detail).toMatch(/report-derived/);
-    expect(v.unclassified, 'no ledger entry ⇒ unclassified for a claimed floor').toContain(requirementIdForScenario(files[0]!));
+    expect(v.unclassified, req('openwop.it.runner-ledger.a-floor-file-that-vitest-passed-but-that-recorded-nothing-is-unclassified-when-a', 'RFC 0148 §A', 'no ledger entry ⇒ unclassified for a claimed floor')).toContain(requirementIdForScenario(files[0]!));
     expect(v.certifiable).toBe(false);
     expect(d.rejectUnclassified).toBe(true);
   });
@@ -153,7 +154,7 @@ describe('RFC 0148 §A (S6) — the runner derivation', () => {
     const l = ledgerAllPassed(5).map((e) => (e.requirementId === requirementIdForScenario(files[0]!) ? { ...e, assertionCount: 0 } : e));
     const d = deriveRequirementDispositions(reportAllPassed(), l, [profile]);
     const v = d.verdicts.find((x) => x.profile === profile)!;
-    expect(v.unclassified).toContain(requirementIdForScenario(files[0]!));
+    expect(v.unclassified, req('openwop.it.runner-ledger.a-vacuous-pass-executed-pass-with-assertioncount-0-on-a-claimed-floor-is-unclass', 'RFC 0148 §A', 'a VACUOUS pass (executed-pass with assertionCount 0) on a claimed floor is unclassified and REJECTS certification')).toContain(requirementIdForScenario(files[0]!));
     expect(v.certifiable).toBe(false);
     expect(d.rejectUnclassified).toBe(true);
   });
@@ -163,7 +164,7 @@ describe('RFC 0148 §A (S6) — the runner derivation', () => {
     const l = ledgerAllPassed().filter((e) => e.requirementId !== requirementIdForScenario(files[0]!));
     const d = deriveRequirementDispositions(rep, l, [profile]);
     const row = d.requirements.find((r) => r.requirementId === requirementIdForScenario(files[0]!))!;
-    expect(row.disposition).toBe('blocked');
+    expect(row.disposition, req('openwop.it.runner-ledger.a-skipped-file-with-no-ledger-entry-is-blocked-unclassified-and-it-never-reads-a', 'RFC 0148 §A', 'a skipped file with no ledger entry is blocked (unclassified) — and it never reads as skipped/inapplicable')).toBe('blocked');
     expect(row.detail).toMatch(/unclassified/);
     expect(d.verdicts[0]!.unclassified).toContain(requirementIdForScenario(files[0]!));
     expect(d.rejectUnclassified).toBe(true);
@@ -173,7 +174,7 @@ describe('RFC 0148 §A (S6) — the runner derivation', () => {
   it('a recorded inapplicable/skipped is certifiable and NOT unclassified; a recorded executed-fail blocks but is classified', () => {
     const l = ledgerAllPassed().map((e) => (e.requirementId === requirementIdForScenario(files[0]!) ? { requirementId: e.requirementId, disposition: 'inapplicable' as const, detail: 'not advertised' } : e));
     const d = deriveRequirementDispositions(reportAllPassed({ [files[0]!]: 'skipped' }), l, [profile]);
-    expect(d.verdicts[0]!.unclassified).toEqual([]);
+    expect(d.verdicts[0]!.unclassified, req('openwop.it.runner-ledger.a-recorded-inapplicable-skipped-is-certifiable-and-not-unclassified-a-recorded-e', 'RFC 0148 §A', 'a recorded inapplicable/skipped is certifiable and NOT unclassified; a recorded executed-fail blocks but is classified')).toEqual([]);
     expect(d.verdicts[0]!.certifiable).toBe(true);
     const l2 = ledgerAllPassed().map((e) => (e.requirementId === requirementIdForScenario(files[0]!) ? { requirementId: e.requirementId, disposition: 'executed-fail' as const, detail: 'assertion failed', assertionCount: 2 } : e));
     const d2 = deriveRequirementDispositions(reportAllPassed({ [files[0]!]: 'failed' }), l2, [profile]);
@@ -185,7 +186,7 @@ describe('RFC 0148 §A (S6) — the runner derivation', () => {
 
   it('a discoveryOnly profile certifies with an empty floor; an unknown profile does not', () => {
     const d = deriveRequirementDispositions(new Map(), [], ['openwop-discovery-core', 'openwop-nope']);
-    expect(d.verdicts.find((v) => v.profile === 'openwop-discovery-core')?.certifiable).toBe(true);
+    expect(d.verdicts.find((v) => v.profile === 'openwop-discovery-core')?.certifiable, req('openwop.it.runner-ledger.a-discoveryonly-profile-certifies-with-an-empty-floor-an-unknown-profile-does-no', 'RFC 0148 §A', 'a discoveryOnly profile certifies with an empty floor; an unknown profile does not')).toBe(true);
     expect(d.verdicts.find((v) => v.profile === 'openwop-nope')?.certifiable).toBe(false);
     expect(requirementsFor('openwop-discovery-core')).toEqual([]);
   });
@@ -193,7 +194,7 @@ describe('RFC 0148 §A (S6) — the runner derivation', () => {
   it('a RUNTIME-DERIVED profile (openwop-node-packs) is HELD only when every floor row is a witnessed pass; otherwise it is not held — not rejected, not blocked', () => {
     const np = 'openwop-node-packs';
     const f = PROFILE_FLOOR_SCENARIOS[np]!;
-    expect(f.runtimeDerived, 'profiles.md: node-packs is "derivable from which scenarios pass"').toBe(true);
+    expect(f.runtimeDerived, req('openwop.it.runner-ledger.a-runtime-derived-profile-openwop-node-packs-is-held-only-when-every-floor-row-i', 'RFC 0148 §A', 'profiles.md: node-packs is "derivable from which scenarios pass"')).toBe(true);
     const ids = f.required.map((x) => requirementIdForScenario(x));
     const rep = new Map<string, 'passed' | 'failed' | 'skipped'>(f.required.map((x) => [x, 'passed' as const]));
     // (a) held: every row a witnessed pass
@@ -207,7 +208,7 @@ describe('RFC 0148 §A (S6) — the runner derivation', () => {
     const vn = notHeld.verdicts.find((v) => v.profile === np)!;
     expect(vn.held).toBe(false);
     expect(vn.certifiable).toBe(false);
-    expect(vn.unclassified, 'a profile the host does not hold is not a rejected claim').toEqual([]);
+    expect(vn.unclassified, req('openwop.it.runner-ledger.a-runtime-derived-profile-openwop-node-packs-is-held-only-when-every-floor-row-i', 'RFC 0148 §A', 'a profile the host does not hold is not a rejected claim')).toEqual([]);
     expect([...vn.blocking].sort()).toEqual([...ids].sort());
     expect(notHeld.rejectUnclassified).toBe(false);
     // (c) a vacuous pass on a runtime-derived floor is still not a rejection — the emitter drops the claim
@@ -229,7 +230,7 @@ describe('RFC 0148 §A (S6) — the runner derivation', () => {
     const l = ledgerAllPassed().map((e) => (e.requirementId === requirementIdForScenario(files[0]!) ? { requirementId: e.requirementId, disposition: 'blocked' as const, detail: UNCLASSIFIED_RETURN_DETAIL, assertionCount: 0 } : e));
     const d = deriveRequirementDispositions(reportAllPassed(), l, [profile]);
     const v = d.verdicts.find((x) => x.profile === profile)!;
-    expect(v.unclassified).toContain(requirementIdForScenario(files[0]!));
+    expect(v.unclassified, req('openwop.it.runner-ledger.the-runner-s-a-resolution-of-a-silent-zero-assertion-file-blocked-marker-is-stil', 'RFC 0148 §A', 'the runner\'s §A resolution of a silent zero-assertion file (blocked + marker) is STILL unclassified for a claimed floor')).toContain(requirementIdForScenario(files[0]!));
     expect(d.rejectUnclassified).toBe(true);
     // whereas a blocked row WITH a scenario-authored reason is classified (blocking, not unclassified)
     const l2 = ledgerAllPassed().map((e) => (e.requirementId === requirementIdForScenario(files[0]!) ? { requirementId: e.requirementId, disposition: 'blocked' as const, detail: 'seam /v1/host/sample/x not mounted', assertionCount: 0 } : e));
@@ -240,7 +241,7 @@ describe('RFC 0148 §A (S6) — the runner derivation', () => {
 
   it('with no ledger at all, every skipped file is blocked and the runner says so (the pre-S6 honest reading)', () => {
     const d = deriveRequirementDispositions(reportAllPassed({ [files[0]!]: 'skipped' }), [], [profile]);
-    expect(d.ledgerPresent).toBe(false);
+    expect(d.ledgerPresent, req('openwop.it.runner-ledger.with-no-ledger-at-all-every-skipped-file-is-blocked-and-the-runner-says-so-the-p', 'RFC 0148 §A', 'with no ledger at all, every skipped file is blocked and the runner says so (the pre-S6 honest reading)')).toBe(false);
     const row = d.requirements.find((r) => r.requirementId === requirementIdForScenario(files[0]!))!;
     expect(row.disposition).toBe('blocked');
     expect(row.detail).toMatch(/without a ledger/);
@@ -250,7 +251,7 @@ describe('RFC 0148 §A (S6) — the runner derivation', () => {
 describe('RFC 0148 §A — softSkip notes the reason for an early return, per file', () => {
   it('notes are keyed to the current test file, worst-first when mixed, and read back with joined reasons', () => {
     resetSoftSkips();
-    expect(softSkip('inapplicable', 'host does not advertise X')).toBeUndefined();
+    expect(softSkip('inapplicable', 'host does not advertise X'), req('openwop.it.runner-ledger.notes-are-keyed-to-the-current-test-file-worst-first-when-mixed-and-read-back-wi', 'RFC 0148 §A', 'notes are keyed to the current test file, worst-first when mixed, and read back with joined reasons')).toBeUndefined();
     softSkip('inapplicable', 'host does not advertise X'); // de-duplicated
     let d = softSkipDisposition('runner-ledger.test.ts');
     expect(d).toEqual({ kind: 'inapplicable', reason: 'host does not advertise X' });
@@ -268,12 +269,12 @@ describe('RFC 0148 §A — softSkip notes the reason for an early return, per fi
 describe('RFC 0148 §A (S6) — the live sink, when this run was given one', () => {
   it('files that finished before this one appear in the ledger file with an assertion count', () => {
     const path = process.env['OPENWOP_LEDGER_PATH'];
-    if (!path || !existsSync(path)) return; // not a --certify run; nothing to inspect
+    if (!path || !existsSync(path)) return softSkip('blocked', 'precondition not met — `!path || !existsSync(path)` returned early (not a --certify run; nothing to inspect) (seam, prior step, or fixture unavailable)'); // not a --certify run; nothing to inspect
     const entries = readLedgerFile(path);
     // At least the in-memory ledger of THIS worker has file-level entries for
     // earlier files (setup.ts afterAll), and each carries assertionCount.
     const fileEntries = snapshot().filter((e) => e.requirementId.startsWith('openwop.scenario.') || e.requirementId.startsWith('openwop.floor.'));
-    for (const e of fileEntries) expect(typeof e.assertionCount).toBe('number');
+    for (const e of fileEntries) expect(typeof e.assertionCount, req('openwop.it.runner-ledger.files-that-finished-before-this-one-appear-in-the-ledger-file-with-an-assertion', 'RFC 0148 §A', 'files that finished before this one appear in the ledger file with an assertion count')).toBe('number');
     expect(entries.length).toBeGreaterThanOrEqual(0);
   });
 });

package/src/scenarios/runs-lifecycle.test.ts

@@ -13,6 +13,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 NOOP_WORKFLOW_ID = 'conformance-noop';
 const SKIP_NO_NOOP = !isFixtureAdvertised(NOOP_WORKFLOW_ID);
@@ -21,17 +22,17 @@ describe.skipIf(SKIP_NO_NOOP)('run lifecycle: conformance-noop fixture', () => {
   it('POST /v1/runs returns 201 with runId per rest-endpoints.md', async () => {
     const res = await driver.post('/v1/runs', { workflowId: NOOP_WORKFLOW_ID });
 
-    expect(res.status, driver.describe(
+    expect(res.status, req('openwop.it.runs-lifecycle.post-v1-runs-returns-201-with-runid-per-rest-endpoints-md', 
       'rest-endpoints.md',
       'POST /v1/runs MUST return 201 on accepted run',
     )).toBe(201);
 
     const body = res.json as { runId?: unknown; status?: unknown } | undefined;
-    expect(typeof body?.runId, driver.describe(
+    expect(typeof body?.runId, req('openwop.it.runs-lifecycle.post-v1-runs-returns-201-with-runid-per-rest-endpoints-md', 
       'rest-endpoints.md',
       'POST /v1/runs response body MUST include `runId` string',
     )).toBe('string');
-    expect(typeof body?.status, driver.describe(
+    expect(typeof body?.status, req('openwop.it.runs-lifecycle.post-v1-runs-returns-201-with-runid-per-rest-endpoints-md', 
       'rest-endpoints.md',
       'POST /v1/runs response body MUST include `status` string',
     )).toBe('string');
@@ -44,12 +45,12 @@ describe.skipIf(SKIP_NO_NOOP)('run lifecycle: conformance-noop fixture', () => {
 
     const terminal = await pollUntilTerminal(runId);
 
-    expect(terminal.status, driver.describe(
+    expect(terminal.status, req('openwop.it.runs-lifecycle.reaches-terminal-completed-within-bounded-time-per-fixtures-md-noop-spec', 
       'fixtures.md conformance-noop §Terminal status',
       'fixture MUST reach terminal status `completed`',
     )).toBe('completed');
 
-    expect(terminal.runId, driver.describe(
+    expect(terminal.runId, req('openwop.it.runs-lifecycle.reaches-terminal-completed-within-bounded-time-per-fixtures-md-noop-spec', 
       'rest-endpoints.md RunSnapshot',
       'GET /v1/runs/{runId} MUST echo runId',
     )).toBe(runId);
@@ -59,7 +60,7 @@ describe.skipIf(SKIP_NO_NOOP)('run lifecycle: conformance-noop fixture', () => {
     const res = await driver.get('/v1/runs/openwop-conformance-this-run-id-does-not-exist');
     expect(
       [403, 404].includes(res.status),
-      driver.describe('rest-endpoints.md', 'unknown run MUST return 404 or 403'),
+      req('openwop.it.runs-lifecycle.get-v1-runs-nonexistentid-returns-404-or-403-per-rest-endpoints-md', 'rest-endpoints.md', 'unknown run MUST return 404 or 403'),
     ).toBe(true);
   });
 });

package/src/scenarios/runtime-capabilities.test.ts

@@ -29,6 +29,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 CAPABILITY_MISSING_WORKFLOW_ID = 'conformance-capability-missing';
 const SKIP_NO_FIXTURE = !isFixtureAdvertised(CAPABILITY_MISSING_WORKFLOW_ID);
@@ -37,7 +39,7 @@ describe('runtime-capabilities: /.well-known/openwop forward-compat shape', () =
   it('IF runtimeCapabilities is present, it MUST be a string[] of unique non-empty entries', async () => {
     const res = await driver.get('/.well-known/openwop', { authenticated: false });
 
-    expect(res.status, driver.describe(
+    expect(res.status, req('openwop.it.runtime-capabilities.if-runtimecapabilities-is-present-it-must-be-a-string-of-unique-non-empty-entrie', 
       'capabilities.md §2',
       'discovery endpoint MUST return 200',
     )).toBe(200);
@@ -50,28 +52,28 @@ describe('runtime-capabilities: /.well-known/openwop forward-compat shape', () =
       // of v1 hosts will omit it. Assertion passes trivially; don't
       // force a value on a host that doesn't advertise any.
       expect(caps).toBeUndefined();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `caps === undefined` returned early');
     }
 
-    expect(Array.isArray(caps), driver.describe(
+    expect(Array.isArray(caps), req('openwop.it.runtime-capabilities.if-runtimecapabilities-is-present-it-must-be-a-string-of-unique-non-empty-entrie', 
       'capabilities.md §"Runtime capabilities"',
       'runtimeCapabilities MUST be an array when present',
     )).toBe(true);
 
     const arr = caps as unknown[];
     for (const entry of arr) {
-      expect(typeof entry, driver.describe(
+      expect(typeof entry, req('openwop.it.runtime-capabilities.if-runtimecapabilities-is-present-it-must-be-a-string-of-unique-non-empty-entrie', 
         'capabilities.md §"Runtime capabilities"',
         'every runtimeCapabilities entry MUST be a string',
       )).toBe('string');
-      expect((entry as string).length, driver.describe(
+      expect((entry as string).length, req('openwop.it.runtime-capabilities.if-runtimecapabilities-is-present-it-must-be-a-string-of-unique-non-empty-entrie', 
         'capabilities.md §"Runtime capabilities"',
         'every runtimeCapabilities entry MUST be non-empty',
       )).toBeGreaterThan(0);
     }
 
     const unique = new Set(arr as string[]);
-    expect(unique.size, driver.describe(
+    expect(unique.size, req('openwop.it.runtime-capabilities.if-runtimecapabilities-is-present-it-must-be-a-string-of-unique-non-empty-entrie', 
       'capabilities.md §"Runtime capabilities"',
       'runtimeCapabilities entries MUST be unique',
     )).toBe(arr.length);
@@ -91,7 +93,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('runtime-capabilities: dispatch refusal on unsa
     const create = await driver.post('/v1/runs', {
       workflowId: 'conformance-capability-missing',
     });
-    expect(create.status, driver.describe(
+    expect(create.status, req('openwop.it.runtime-capabilities.terminates-the-run-with-error-code-capability-not-provided', 
       'capabilities.md §"Runtime capabilities"',
       'POST /v1/runs MUST accept the run; refusal is engine-side at dispatch time, not request-validation',
     )).toBe(201);
@@ -99,18 +101,18 @@ describe.skipIf(SKIP_NO_FIXTURE)('runtime-capabilities: dispatch refusal on unsa
 
     const terminal = await pollUntilTerminal(runId);
 
-    expect(terminal.status, driver.describe(
+    expect(terminal.status, req('openwop.it.runtime-capabilities.terminates-the-run-with-error-code-capability-not-provided', 
       'capabilities.md §"Runtime capabilities"',
       'a node with unsatisfied requires MUST cause the run to terminate as failed',
     )).toBe('failed');
 
     const error = (terminal as { error?: { code?: string; message?: string } }).error;
-    expect(error?.code, driver.describe(
+    expect(error?.code, req('openwop.it.runtime-capabilities.terminates-the-run-with-error-code-capability-not-provided', 
       'rest-endpoints.md §"Common error codes"',
       'terminal RunSnapshot.error.code MUST be "capability_not_provided"',
     )).toBe('capability_not_provided');
 
-    expect(error?.message, driver.describe(
+    expect(error?.message, req('openwop.it.runtime-capabilities.terminates-the-run-with-error-code-capability-not-provided', 
       'capabilities.md §"Runtime capabilities"',
       'error.message MUST name the missing capability id verbatim so operators can act without grepping logs',
     )).toContain('conformance.never-provided');

package/src/scenarios/runtime-requires-install-gate.test.ts

@@ -29,8 +29,8 @@
 
 import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
-import { driver } from '../lib/driver.js';
 import { installGate } from '../lib/runtimeRequires.js';
+import { req } from '../lib/requirement-ids.js';
 
 function manifest(requires: string[]) {
   return {
@@ -48,11 +48,11 @@ describe('runtime-requires install gate (RFC 0076 §A)', () => {
     if (res === null) return softSkip('blocked', 'seam absent — soft-skip');
     expect(
       res.status,
-      driver.describe('registry-operations.md §"Runtime-requirement install gate"', 'a pack whose runtime.requires are all grantable MUST install (no refusal)'),
+      req('openwop.it.runtime-requires-install-gate.install-grant-requires-grant-set-install-succeeds', 'registry-operations.md §"Runtime-requirement install gate"', 'a pack whose runtime.requires are all grantable MUST install (no refusal)'),
     ).toBe(200);
     expect(
       res.body.outcome,
-      driver.describe('registry-operations.md §"Runtime-requirement install gate"', 'a granted install reports outcome:"installed"'),
+      req('openwop.it.runtime-requires-install-gate.install-grant-requires-grant-set-install-succeeds', 'registry-operations.md §"Runtime-requirement install gate"', 'a granted install reports outcome:"installed"'),
     ).toBe('installed');
   });
 
@@ -61,19 +61,19 @@ describe('runtime-requires install gate (RFC 0076 §A)', () => {
     if (res === null) return softSkip('blocked', 'seam absent — soft-skip');
     expect(
       res.status,
-      driver.describe('registry-operations.md §"Runtime-requirement install gate"', 'a pack requiring an ungranted primitive MUST be refused at install (not at first invocation)'),
+      req('openwop.it.runtime-requires-install-gate.install-refuse-an-ungrantable-primitive-pack-runtime-requirement-unmet', 'registry-operations.md §"Runtime-requirement install gate"', 'a pack requiring an ungranted primitive MUST be refused at install (not at first invocation)'),
     ).toBe(400);
     expect(
       res.body.error,
-      driver.describe('registry-operations.md §"Runtime-requirement install gate"', 'the refusal MUST carry error code pack_runtime_requirement_unmet'),
+      req('openwop.it.runtime-requires-install-gate.install-refuse-an-ungrantable-primitive-pack-runtime-requirement-unmet', 'registry-operations.md §"Runtime-requirement install gate"', 'the refusal MUST carry error code pack_runtime_requirement_unmet'),
     ).toBe('pack_runtime_requirement_unmet');
     expect(
       Array.isArray(res.body.unmet) && (res.body.unmet as unknown[]).includes('net.dns'),
-      driver.describe('registry-operations.md §"Runtime-requirement install gate"', 'unmet[] MUST list the ungranted primitive(s) (capability_not_provided envelope)'),
+      req('openwop.it.runtime-requires-install-gate.install-refuse-an-ungrantable-primitive-pack-runtime-requirement-unmet', 'registry-operations.md §"Runtime-requirement install gate"', 'unmet[] MUST list the ungranted primitive(s) (capability_not_provided envelope)'),
     ).toBe(true);
     expect(
       typeof res.body.manifest === 'string' && (res.body.manifest as string).includes('vendor.example.http'),
-      driver.describe('registry-operations.md §"Runtime-requirement install gate"', 'the refusal MUST name the offending manifest (name@version)'),
+      req('openwop.it.runtime-requires-install-gate.install-refuse-an-ungrantable-primitive-pack-runtime-requirement-unmet', 'registry-operations.md §"Runtime-requirement install gate"', 'the refusal MUST name the offending manifest (name@version)'),
     ).toBe(true);
   });
 
@@ -87,7 +87,7 @@ describe('runtime-requires install gate (RFC 0076 §A)', () => {
     const projected = res.body.requiresProjected as unknown;
     expect(
       Array.isArray(projected) && ['net.dns', 'net.outbound'].every((t) => (projected as unknown[]).includes(t)),
-      driver.describe('node-packs.md §"Runtime platform requirements"', 'a non-gating host that projects SHOULD surface the declared runtime.requires[] on the inventory entry verbatim'),
+      req('openwop.it.runtime-requires-install-gate.non-sandbox-projection-a-non-gating-host-installs-and-projects-requires-a-should', 'node-packs.md §"Runtime platform requirements"', 'a non-gating host that projects SHOULD surface the declared runtime.requires[] on the inventory entry verbatim'),
     ).toBe(true);
   });
 });

package/src/scenarios/runtime-requires-shape.test.ts

@@ -37,6 +37,7 @@ import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
 import type { ErrorObject, ValidateFunction } from 'ajv';
 import { SCHEMAS_DIR } from '../lib/paths.js';
+import { req } from '../lib/requirement-ids.js';
 
 const SCHEMA_PATH = join(SCHEMAS_DIR, 'node-pack-manifest.schema.json');
 
@@ -89,21 +90,21 @@ describe('category: runtime.requires vocabulary + shape (RFC 0076 §A)', () => {
     const ok = validate(manifest(['net.dns', 'net.outbound']));
     expect(
       ok,
-      `node-packs.md §"Runtime platform requirements": a well-formed runtime.requires MUST validate. Errors: ${JSON.stringify(validate.errors)}`,
+      req('openwop.it.runtime-requires-shape.positive-a-manifest-declaring-valid-primitives-validates-cleanly', 'node-packs.md', `node-packs.md §"Runtime platform requirements": a well-formed runtime.requires MUST validate. Errors: ${JSON.stringify(validate.errors)}`),
     ).toBe(true);
   });
 
   it('positive: runtime.requires is OPTIONAL — a manifest omitting it validates (additive)', () => {
     expect(
       validate(manifest(undefined)),
-      'node-pack-manifest.schema.json: runtime.requires is additive/OPTIONAL — packs predating RFC 0076 validate unchanged',
+      req('openwop.it.runtime-requires-shape.positive-runtime-requires-is-optional-a-manifest-omitting-it-validates-additive', 'node-packs.md', 'node-pack-manifest.schema.json: runtime.requires is additive/OPTIONAL — packs predating RFC 0076 validate unchanged'),
     ).toBe(true);
   });
 
   it('positive: an empty requires[] validates (equivalent to omission per §A)', () => {
     expect(
       validate(manifest([])),
-      'node-packs.md §"Runtime platform requirements": runtime.requires:[] is valid and equivalent to omission',
+      req('openwop.it.runtime-requires-shape.positive-an-empty-requires-validates-equivalent-to-omission-per-a', 'node-packs.md', 'node-packs.md §"Runtime platform requirements": runtime.requires:[] is valid and equivalent to omission'),
     ).toBe(true);
   });
 
@@ -111,7 +112,7 @@ describe('category: runtime.requires vocabulary + shape (RFC 0076 §A)', () => {
     for (const token of VOCABULARY) {
       expect(
         validate(manifest([token])),
-        `node-pack-manifest.schema.json: "${token}" is in the RFC 0076 §A vocabulary. Errors: ${JSON.stringify(validate.errors)}`,
+        req('openwop.it.runtime-requires-shape.positive-every-vocabulary-token-individually-validates', 'node-packs.md', `node-pack-manifest.schema.json: "${token}" is in the RFC 0076 §A vocabulary. Errors: ${JSON.stringify(validate.errors)}`),
       ).toBe(true);
     }
   });
@@ -120,7 +121,7 @@ describe('category: runtime.requires vocabulary + shape (RFC 0076 §A)', () => {
     const errs = errorsOn(manifest(['node:dns/promises']));
     expect(
       errs.some((e) => e.instancePath.includes('/runtime/requires')),
-      'node-packs.md §"Runtime platform requirements": raw language builtin names are NOT in the closed vocabulary — the abstract net.dns is the portable equivalent; the registry/host surfaces this as invalid_manifest',
+      req('openwop.it.runtime-requires-shape.negative-a-raw-builtin-name-node-dns-promises-is-rejected-invalid-manifest', 'node-packs.md', 'node-packs.md §"Runtime platform requirements": raw language builtin names are NOT in the closed vocabulary — the abstract net.dns is the portable equivalent; the registry/host surfaces this as invalid_manifest'),
     ).toBe(true);
   });
 
@@ -128,7 +129,7 @@ describe('category: runtime.requires vocabulary + shape (RFC 0076 §A)', () => {
     const errs = errorsOn(manifest(['net.dns', 'net.dns']));
     expect(
       errs.some((e) => e.keyword === 'uniqueItems'),
-      'node-pack-manifest.schema.json: runtime.requires has uniqueItems:true',
+      req('openwop.it.runtime-requires-shape.negative-a-duplicate-token-is-rejected-uniqueitems', 'node-packs.md', 'node-pack-manifest.schema.json: runtime.requires has uniqueItems:true'),
     ).toBe(true);
   });
 });

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

@@ -29,71 +29,72 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { driver } from '../lib/driver.js';
 import { isSafeFetchSupported, isToolHookAuditOn, safeFetch } from '../lib/safeFetch.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 describe('safefetch-behavior (RFC 0076 §B / §host.http)', () => {
   it('blocks a metadata-endpoint target (SSRF guard)', async () => {
-    if (!(await isSafeFetchSupported())) return; // capability absent — soft-skip
+    if (!(await isSafeFetchSupported())) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSafeFetchSupported())` returned early (capability absent — soft-skip)'); // capability absent — soft-skip
     const res = await safeFetch({ url: 'http://169.254.169.254/latest/meta-data/' });
-    if (res === null) return; // seam absent — soft-skip
+    if (res === null) return softSkip('blocked', 'precondition not met — `res === null` returned early (seam absent — soft-skip) (seam, prior step, or fixture unavailable)'); // seam absent — soft-skip
     expect(
       res.outcome,
-      driver.describe('host-capabilities.md §host.http', 'safeFetch MUST NOT connect to a cloud-metadata address'),
+      req('openwop.it.safefetch-behavior.blocks-a-metadata-endpoint-target-ssrf-guard', 'host-capabilities.md §host.http', 'safeFetch MUST NOT connect to a cloud-metadata address'),
     ).toBe('blocked');
     expect(
       res.blocked,
-      driver.describe('host-capabilities.md §host.http', 'a blocked SSRF target reports blocked:"ssrf" (http-client-ssrf-guard invariant)'),
+      req('openwop.it.safefetch-behavior.blocks-a-metadata-endpoint-target-ssrf-guard', 'host-capabilities.md §host.http', 'a blocked SSRF target reports blocked:"ssrf" (http-client-ssrf-guard invariant)'),
     ).toBe('ssrf');
   });
 
   it('blocks a loopback target (SSRF guard)', async () => {
-    if (!(await isSafeFetchSupported())) return;
+    if (!(await isSafeFetchSupported())) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSafeFetchSupported())` returned early');
     const res = await safeFetch({ url: 'http://127.0.0.1:6379/' });
-    if (res === null) return;
+    if (res === null) return softSkip('blocked', 'precondition not met — `res === null` returned early (seam, prior step, or fixture unavailable)');
     expect(
       res.outcome,
-      driver.describe('host-capabilities.md §host.http', 'safeFetch MUST NOT connect to loopback'),
+      req('openwop.it.safefetch-behavior.blocks-a-loopback-target-ssrf-guard', 'host-capabilities.md §host.http', 'safeFetch MUST NOT connect to loopback'),
     ).toBe('blocked');
   });
 
   it('blocks DNS-rebinding (resolved IP is pinned for the connection)', async () => {
-    if (!(await isSafeFetchSupported())) return;
+    if (!(await isSafeFetchSupported())) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSafeFetchSupported())` returned early');
     const res = await safeFetch({ url: 'http://example.com/', simulateRebindTo: '169.254.169.254' });
-    if (res === null) return;
+    if (res === null) return softSkip('blocked', 'precondition not met — `res === null` returned early (seam, prior step, or fixture unavailable)');
     expect(
       res.outcome,
-      driver.describe('host-capabilities.md §host.http', 'a public name that re-resolves to a blocked address MUST be blocked (rebinding defeat)'),
+      req('openwop.it.safefetch-behavior.blocks-dns-rebinding-resolved-ip-is-pinned-for-the-connection', 'host-capabilities.md §host.http', 'a public name that re-resolves to a blocked address MUST be blocked (rebinding defeat)'),
     ).toBe('blocked');
   });
 
   it('refuses a Connection: upgrade request (no 101 socket-hijack escape)', async () => {
-    if (!(await isSafeFetchSupported())) return;
+    if (!(await isSafeFetchSupported())) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSafeFetchSupported())` returned early');
     const res = await safeFetch({ url: 'https://example.com/', init: { headers: { Connection: 'upgrade' } } });
-    if (res === null) return;
+    if (res === null) return softSkip('blocked', 'precondition not met — `res === null` returned early (seam, prior step, or fixture unavailable)');
     expect(
       res.outcome,
-      driver.describe('host-capabilities.md §host.http', 'safeFetch MUST refuse a connection-upgrade attempt'),
+      req('openwop.it.safefetch-behavior.refuses-a-connection-upgrade-request-no-101-socket-hijack-escape', 'host-capabilities.md §host.http', 'safeFetch MUST refuse a connection-upgrade attempt'),
     ).toBe('blocked');
     expect(
       res.blocked,
-      driver.describe('host-capabilities.md §host.http', 'a refused upgrade reports blocked:"upgrade"'),
+      req('openwop.it.safefetch-behavior.refuses-a-connection-upgrade-request-no-101-socket-hijack-escape', 'host-capabilities.md §host.http', 'a refused upgrade reports blocked:"upgrade"'),
     ).toBe('upgrade');
   });
 
   it('emits the tool-hooks audit pair when prePostEvents is also advertised', async () => {
-    if (!(await isSafeFetchSupported())) return;
-    if (!(await isToolHookAuditOn())) return; // audit MUST applies only when both advertised
+    if (!(await isSafeFetchSupported())) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSafeFetchSupported())` returned early');
+    if (!(await isToolHookAuditOn())) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isToolHookAuditOn())` returned early (audit MUST applies only when both advertised)'); // audit MUST applies only when both advertised
     const res = await safeFetch({ url: 'https://example.com/' });
-    if (res === null) return;
-    if (res.outcome !== 'fetched') return; // only a completed call carries the pair
+    if (res === null) return softSkip('blocked', 'precondition not met — `res === null` returned early (seam, prior step, or fixture unavailable)');
+    if (res.outcome !== 'fetched') return softSkip('blocked', 'precondition not met — `res.outcome !== \'fetched\'` returned early (only a completed call carries the pair) (seam, prior step, or fixture unavailable)'); // only a completed call carries the pair
     expect(
       res.toolCalled !== undefined && res.toolReturned !== undefined,
-      driver.describe('host-capabilities.md §host.http', 'when toolHooks.prePostEvents + safeFetch are both advertised, a safeFetch call MUST emit the agent.toolCalled/agent.toolReturned pair'),
+      req('openwop.it.safefetch-behavior.emits-the-tool-hooks-audit-pair-when-prepostevents-is-also-advertised', 'host-capabilities.md §host.http', 'when toolHooks.prePostEvents + safeFetch are both advertised, a safeFetch call MUST emit the agent.toolCalled/agent.toolReturned pair'),
     ).toBe(true);
     expect(
       (res.toolCalled as { transport?: string } | undefined)?.transport,
-      driver.describe('host-capabilities.md §host.http', 'the audit pair carries transport:"http"'),
+      req('openwop.it.safefetch-behavior.emits-the-tool-hooks-audit-pair-when-prepostevents-is-also-advertised', 'host-capabilities.md §host.http', 'the audit pair carries transport:"http"'),
     ).toBe('http');
   });
 });

package/src/scenarios/safefetch-live-audit.test.ts

@@ -53,10 +53,11 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { isSafeFetchLiveAuditAdvertised, safeFetchViaRun } from '../lib/safeFetch.js';
 import { queryTestEvents } from '../lib/event-log-query.js';
+import { req } from '../lib/requirement-ids.js';
+import { softSkip } from '../lib/soft-skip.js';
 
 const PROFILE = 'openwop-safefetch-live-audit';
 const CITE = 'host-capabilities.md §host.http';
@@ -78,7 +79,7 @@ const FETCH_URL = 'https://example.com/';
  * `false` (caller treats as host-pending soft-skip) only when the event-log
  * query seam is unavailable; otherwise asserts and returns `true`.
  */
-async function assertDurableHttpPair(runId: string, label: string): Promise<boolean> {
+async function assertDurableHttpPair(requirementId: string, runId: string, label: string): Promise<boolean> {
   const calledQ = await queryTestEvents(runId, { type: 'agent.toolCalled' });
   const returnedQ = await queryTestEvents(runId, { type: 'agent.toolReturned' });
   if (!calledQ.ok || !returnedQ.ok) {
@@ -91,7 +92,7 @@ async function assertDurableHttpPair(runId: string, label: string): Promise<bool
   const httpCall = calledQ.events.find((e) => (e.payload as { transport?: string }).transport === 'http');
   expect(
     httpCall !== undefined,
-    driver.describe(
+    req(requirementId, 
       CITE,
       `(${label}) when toolHooks.prePostEvents + safeFetch are both advertised, a production ctx.http.safeFetch call MUST persist an agent.toolCalled with transport:"http" to the durable run event log (not just the seam echo), for EVERY invocation incl. blocked ones`,
     ),
@@ -101,14 +102,14 @@ async function assertDurableHttpPair(runId: string, label: string): Promise<bool
   const callId = (httpCall.payload as { callId?: string }).callId;
   expect(
     typeof callId === 'string' && callId.length > 0,
-    driver.describe(CITE, `(${label}) the persisted agent.toolCalled MUST carry the required callId (run-event-payloads.schema.json §agentToolCalled)`),
+    req(requirementId, CITE, `(${label}) the persisted agent.toolCalled MUST carry the required callId (run-event-payloads.schema.json §agentToolCalled)`),
   ).toBe(true);
 
   // The paired agent.toolReturned — matched by the required callId (RFC 0002 §B pairing).
   const paired = returnedQ.events.find((e) => (e.payload as { callId?: string }).callId === callId);
   expect(
     paired !== undefined,
-    driver.describe(CITE, `(${label}) the agent.toolCalled MUST be followed by a callId-paired agent.toolReturned in the durable log (no quiet bypass)`),
+    req(requirementId, CITE, `(${label}) the agent.toolCalled MUST be followed by a callId-paired agent.toolReturned in the durable log (no quiet bypass)`),
   ).toBe(true);
 
   // Stricter, when the host surfaces causation: RFC 0002 §B says
@@ -117,7 +118,7 @@ async function assertDurableHttpPair(runId: string, label: string): Promise<bool
   if (paired && typeof paired.causationId === 'string') {
     expect(
       paired.causationId,
-      driver.describe('RFC 0002 §B', 'agent.toolReturned.causationId MUST equal the paired agent.toolCalled.eventId when surfaced'),
+      req(requirementId, 'RFC 0002 §B', 'agent.toolReturned.causationId MUST equal the paired agent.toolCalled.eventId when surfaced'),
     ).toBe(httpCall.eventId);
   }
   return true;
@@ -135,7 +136,7 @@ describe('safefetch-live-audit (RFC 0076 §B / RFC 0064 §B — production path,
     if (run === null) {
       // eslint-disable-next-line no-console
       console.warn(`[${PROFILE}] safe-fetch-run seam unwired (404); host-pending — skipping`);
-      return;
+      return softSkip('blocked', 'precondition not met — `run === null` returned early ([…] safe-fetch-run seam unwired (404); host-pending — skipping) (seam, prior step, or fixture unavailable)');
     }
 
     // The metadata IP MUST be refused by a conformant SSRF guard
@@ -144,9 +145,9 @@ describe('safefetch-live-audit (RFC 0076 §B / RFC 0064 §B — production path,
     // exist — this is the egress-independent floor that makes the bar non-vacuous.
     expect(
       typeof run.runId === 'string' && (run.runId as string).length > 0,
-      driver.describe(CITE, 'the safe-fetch-run seam MUST return the runId of the real run it executed the safeFetch in'),
+      req('openwop.it.safefetch-live-audit.a-blocked-real-run-safefetch-emits-the-durable-agent-toolcalled-agent-toolreturn', CITE, 'the safe-fetch-run seam MUST return the runId of the real run it executed the safeFetch in'),
     ).toBe(true);
-    await assertDurableHttpPair(run.runId as string, 'blocked');
+    await assertDurableHttpPair('openwop.it.safefetch-live-audit.a-blocked-real-run-safefetch-emits-the-durable-agent-toolcalled-agent-toolreturn', run.runId as string, 'blocked');
   });
 
   it('a FETCHED real-run safeFetch also emits the durable pair (success-path coverage — skipped without public egress)', async () => {
@@ -154,7 +155,7 @@ describe('safefetch-live-audit (RFC 0076 §B / RFC 0064 §B — production path,
     if (!behaviorGate(PROFILE, advertised)) return;
 
     const run = await safeFetchViaRun({ url: FETCH_URL });
-    if (run === null) return; // seam unwired — already warned by the floor test
+    if (run === null) return softSkip('blocked', 'precondition not met — `run === null` returned early (seam unwired — already warned by the floor test) (seam, prior step, or fixture unavailable)'); // seam unwired — already warned by the floor test
 
     if (run.outcome !== 'fetched') {
       // No public egress in this environment — the blocked-path floor already
@@ -164,12 +165,12 @@ describe('safefetch-live-audit (RFC 0076 §B / RFC 0064 §B — production path,
       console.warn(
         `[${PROFILE}] ${FETCH_URL} did not fetch (outcome=${run.outcome ?? 'n/a'}); no public egress — success-path coverage skipped (the blocked floor covers emission)`,
       );
-      return;
+      return softSkip('blocked', 'precondition not met — `run.outcome !== \'fetched\'` returned early ([…] … did not fetch (outcome=…); no public egress — success-path coverage skipped (the blocked floor covers emission)) (seam, prior step, or fixture u…');
     }
     expect(
       typeof run.runId === 'string' && (run.runId as string).length > 0,
-      driver.describe(CITE, 'the safe-fetch-run seam MUST return the runId of the real run it executed the fetch in'),
+      req('openwop.it.safefetch-live-audit.a-fetched-real-run-safefetch-also-emits-the-durable-pair-success-path-coverage-s', CITE, 'the safe-fetch-run seam MUST return the runId of the real run it executed the fetch in'),
     ).toBe(true);
-    await assertDurableHttpPair(run.runId as string, 'fetched');
+    await assertDurableHttpPair('openwop.it.safefetch-live-audit.a-fetched-real-run-safefetch-also-emits-the-durable-pair-success-path-coverage-s', run.runId as string, 'fetched');
   });
 });