@openwop/openwop-conformance 2.42.5 → 2.42.7

package/src/scenarios/eventOrdering.test.ts

@@ -20,7 +20,7 @@ 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';
+import { blockedDespiteAssertions } from '../lib/soft-skip.js';
 
 const NOOP_WORKFLOW_ID = 'conformance-noop';
 const SKIP_NO_NOOP = !isFixtureAdvertised(NOOP_WORKFLOW_ID);
@@ -42,6 +42,13 @@ function getSeq(event: RawEvent): number | null {
   return null;
 }
 
+// Every early return below follows the run-create assertion, so each is
+// `blockedDespiteAssertions`: rest-endpoints.md §"Required endpoints" makes
+// /events/poll a MUST on every host, and observability.md makes run.started and
+// exactly one terminal event MUSTs, so a completed noop run on a conforming host
+// always yields a readable events[] of at least two. A host that does not was
+// never observed ordering anything — until 2026-09-27 these recorded a
+// partial-witness PASS.
 describe.skipIf(SKIP_NO_NOOP)('event-ordering: polling returns events in monotonic order', () => {
   it('events from a single poll have non-decreasing sequence numbers', async () => {
     const create = await driver.post('/v1/runs', { workflowId: NOOP_WORKFLOW_ID });
@@ -50,11 +57,11 @@ describe.skipIf(SKIP_NO_NOOP)('event-ordering: polling returns events in monoton
     await pollUntilTerminal(runId);
 
     const res = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/events/poll`);
-    if (res.status !== 200) return softSkip('blocked', 'precondition not met — `res.status !== 200` returned early (seam, prior step, or fixture unavailable)');
+    if (res.status !== 200) return blockedDespiteAssertions('precondition not met — `res.status !== 200` returned early (seam, prior step, or fixture unavailable)');
 
     const body = res.json as { events?: RawEvent[] } | undefined;
-    if (!body?.events) return softSkip('blocked', 'precondition not met — `!body?.events` returned early (seam, prior step, or fixture unavailable)');
-    if (body.events.length < 2) return softSkip('blocked', 'precondition not met — `body.events.length < 2` returned early (single-event runs have no ordering to verify) (seam, prior step, or fixture unavailable)'); // single-event runs have no ordering to verify
+    if (!body?.events) return blockedDespiteAssertions('precondition not met — `!body?.events` returned early (seam, prior step, or fixture unavailable)');
+    if (body.events.length < 2) return blockedDespiteAssertions('precondition not met — `body.events.length < 2` returned early (single-event runs have no ordering to verify) (seam, prior step, or fixture unavailable)'); // single-event runs have no ordering to verify
 
     const seqs = body.events.map(getSeq);
     for (let i = 1; i < seqs.length; i++) {
@@ -76,11 +83,11 @@ describe.skipIf(SKIP_NO_NOOP)('event-ordering: polling returns events in monoton
 
     const a = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/events/poll`);
     const b = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/events/poll`);
-    if (a.status !== 200 || b.status !== 200) return softSkip('blocked', 'precondition not met — `a.status !== 200 || b.status !== 200` returned early (seam, prior step, or fixture unavailable)');
+    if (a.status !== 200 || b.status !== 200) return blockedDespiteAssertions('precondition not met — `a.status !== 200 || b.status !== 200` returned early (seam, prior step, or fixture unavailable)');
 
     const aBody = a.json as { events?: RawEvent[] } | undefined;
     const bBody = b.json as { events?: RawEvent[] } | undefined;
-    if (!aBody?.events || !bBody?.events) return softSkip('blocked', 'precondition not met — `!aBody?.events || !bBody?.events` returned early (seam, prior step, or fixture unavailable)');
+    if (!aBody?.events || !bBody?.events) return blockedDespiteAssertions('precondition not met — `!aBody?.events || !bBody?.events` returned early (seam, prior step, or fixture unavailable)');
 
     expect(aBody.events.length, req('openwop.it.eventOrdering.repeated-polls-of-a-terminal-run-yield-identical-event-sequences', 
       'observability.md',
@@ -107,10 +114,10 @@ describe.skipIf(SKIP_NO_NOOP)('event-ordering: terminal run has at most one term
     await pollUntilTerminal(runId);
 
     const res = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/events/poll`);
-    if (res.status !== 200) return softSkip('blocked', 'precondition not met — `res.status !== 200` returned early (seam, prior step, or fixture unavailable)');
+    if (res.status !== 200) return blockedDespiteAssertions('precondition not met — `res.status !== 200` returned early (seam, prior step, or fixture unavailable)');
 
     const body = res.json as { events?: RawEvent[] } | undefined;
-    if (!body?.events) return softSkip('blocked', 'precondition not met — `!body?.events` returned early (seam, prior step, or fixture unavailable)');
+    if (!body?.events) return blockedDespiteAssertions('precondition not met — `!body?.events` returned early (seam, prior step, or fixture unavailable)');
 
     const TERMINAL_TYPES = new Set(['run.completed', 'run.failed', 'run.cancelled']);
     const terminalCount = body.events.filter((e) => typeof e.type === 'string' && TERMINAL_TYPES.has(e.type)).length;
@@ -128,10 +135,10 @@ describe.skipIf(SKIP_NO_NOOP)('event-ordering: terminal run has at most one term
     await pollUntilTerminal(runId);
 
     const res = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/events/poll`);
-    if (res.status !== 200) return softSkip('blocked', 'precondition not met — `res.status !== 200` returned early (seam, prior step, or fixture unavailable)');
+    if (res.status !== 200) return blockedDespiteAssertions('precondition not met — `res.status !== 200` returned early (seam, prior step, or fixture unavailable)');
 
     const body = res.json as { events?: RawEvent[] } | undefined;
-    if (!body?.events || body.events.length === 0) return softSkip('blocked', 'precondition not met — `!body?.events || body.events.length === 0` returned early (seam, prior step, or fixture unavailable)');
+    if (!body?.events || body.events.length === 0) return blockedDespiteAssertions('precondition not met — `!body?.events || body.events.length === 0` returned early (seam, prior step, or fixture unavailable)');
 
     const TERMINAL_TYPES = new Set(['run.completed', 'run.failed', 'run.cancelled']);
     const lastEvent = body.events[body.events.length - 1]!;

package/src/scenarios/form-content-instantiation.test.ts

@@ -65,7 +65,7 @@ import {
   PLAIN_TEXT_CONTROLS,
 } from '../lib/formContentPacks.js';
 import { req } from '../lib/requirement-ids.js';
-import { softSkip } from '../lib/soft-skip.js';
+import { softSkip, blockedDespiteAssertions } from '../lib/soft-skip.js';
 
 /**
  * Conformance fixture templates a host wires the seam against.
@@ -140,7 +140,7 @@ describe('form-content-instantiation: a host instantiates a registered template
     ).toBe(true);
 
     const field = fieldById(res.fields, VENDOR_FIELD_ID);
-    if (field === undefined) return softSkip('blocked', 'precondition not met — `field === undefined` returned early (host doesn\'t report per-field controls on the seam — soft-skip) (seam, prior step, or fixture unavailable)'); // host doesn't report per-field controls on the seam — soft-skip
+    if (field === undefined) return blockedDespiteAssertions('the instantiate seam reports no fields[] entry for the vendor field — the plain-text degrade is unobserved');
     expect(
       field.control !== undefined && PLAIN_TEXT_CONTROLS.has(field.control),
       req('openwop.it.form-content-instantiation.2-an-unrecognized-vendor-field-type-degrades-to-plain-text-and-does-not-fail-the', 

package/src/scenarios/heartbeat-idempotent-no-spam.test.ts

@@ -11,7 +11,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { softSkip } from '../lib/soft-skip.js';
+import { softSkip, blockedDespiteAssertions } from '../lib/soft-skip.js';
 import { readHeartbeatCap, heartbeatSupported, tickHeartbeat } from '../lib/heartbeat.js';
 import { req } from '../lib/requirement-ids.js';
 
@@ -35,7 +35,7 @@ describe('heartbeat-idempotent-no-spam (RFC 0060 §B.5)', () => {
       req('openwop.it.heartbeat-idempotent-no-spam.an-unchanged-tick-enqueues-nothing-only-a-transition-does', 'RFC 0060 §B.5', 'an unchanged tick MUST NOT emit heartbeat.stateChanged'),
     ).toBe(0);
     const transition = await tickHeartbeat({ heartbeatId: hb, observedState: { unread: 3 } });
-    if (transition === null) return softSkip('blocked', 'precondition not met — `transition === null` returned early (seam, prior step, or fixture unavailable)');
+    if (transition === null) return blockedDespiteAssertions('the heartbeat seam answered the unchanged ticks but not the transition — the one-stateChanged-per-transition rule is unobserved');
     expect(
       changedCount(transition.json),
       req('openwop.it.heartbeat-idempotent-no-spam.an-unchanged-tick-enqueues-nothing-only-a-transition-does', 'RFC 0060 §B.5', 'a transitioning tick MUST emit exactly one heartbeat.stateChanged'),

package/src/scenarios/highConcurrency.test.ts

@@ -83,7 +83,7 @@ describe.skipIf(SKIP)(
         expect(
           succeeded.length + conflicted.length,
           req('openwop.it.highConcurrency.10-parallel-requests-with-same-key-yield-one-runid-and-9-replays', 
-            'idempotency.md §Concurrent duplicates',
+            'spec/v1/idempotency.md §Concurrent duplicates',
             'every concurrent request MUST resolve to either the cached response or a deterministic 409',
           ),
         ).toBe(10);
@@ -92,7 +92,7 @@ describe.skipIf(SKIP)(
         expect(
           runIds.size,
           req('openwop.it.highConcurrency.10-parallel-requests-with-same-key-yield-one-runid-and-9-replays', 
-            'idempotency.md §Layer 1',
+            'spec/v1/idempotency.md §Layer 1',
             'same idempotency key MUST yield exactly ONE runId across all successful responses',
           ),
         ).toBe(1);
@@ -103,7 +103,7 @@ describe.skipIf(SKIP)(
           expect(
             c.errorCode === 'idempotency_in_flight' || c.errorCode === undefined,
             req('openwop.it.highConcurrency.10-parallel-requests-with-same-key-yield-one-runid-and-9-replays', 
-              'idempotency.md',
+              'spec/v1/idempotency.md',
               '409 on parallel idempotency-keyed retry MUST carry error="idempotency_in_flight"',
             ),
           ).toBe(true);
@@ -111,7 +111,7 @@ describe.skipIf(SKIP)(
             expect(
               c.retryAfter,
               req('openwop.it.highConcurrency.10-parallel-requests-with-same-key-yield-one-runid-and-9-replays', 
-                'idempotency.md',
+                'spec/v1/idempotency.md',
                 '409 idempotency_in_flight MUST include a numeric retryAfter',
               ),
             ).toBeGreaterThan(0);
@@ -150,7 +150,7 @@ describe.skipIf(SKIP)(
         expect(
           uniqueRunIds.size,
           req('openwop.it.highConcurrency.10-parallel-requests-with-distinct-keys-yield-10-distinct-runids', 
-            'idempotency.md §Layer 1',
+            'spec/v1/idempotency.md §Layer 1',
             'distinct idempotency keys MUST yield distinct runIds (Layer 1 dedup is keyed)',
           ),
         ).toBe(succeededRunIds.length);
@@ -195,7 +195,7 @@ describe.skipIf(SKIP)(
         expect(
           runIds.size,
           req('openwop.it.highConcurrency.5-sequential-retries-with-same-key-100ms-apart-all-succeed-idempotency-cache-sur', 
-            'idempotency.md §Layer 1',
+            'spec/v1/idempotency.md §Layer 1',
             'all 5 retries with same key MUST resolve to the same runId',
           ),
         ).toBe(1);
@@ -204,7 +204,7 @@ describe.skipIf(SKIP)(
         expect(
           results[0]!.replay,
           req('openwop.it.highConcurrency.5-sequential-retries-with-same-key-100ms-apart-all-succeed-idempotency-cache-sur', 
-            'idempotency.md §Server responsibilities',
+            'spec/v1/idempotency.md §Server responsibilities',
             'first request with new key MUST NOT be marked as replay',
           ),
         ).toBe(false);
@@ -216,7 +216,7 @@ describe.skipIf(SKIP)(
         expect(
           someReplay,
           req('openwop.it.highConcurrency.5-sequential-retries-with-same-key-100ms-apart-all-succeed-idempotency-cache-sur', 
-            'idempotency.md §Server responsibilities #2',
+            'spec/v1/idempotency.md §Server responsibilities #2',
             'replay responses SHOULD set openwop-Idempotent-Replay: true',
           ),
         ).toBe(true);
@@ -252,7 +252,7 @@ describe.skipIf(SKIP)(
           expect(
             typeof ackTimeout === 'number' && Number.isInteger(ackTimeout) && ackTimeout >= 5,
             req('openwop.it.highConcurrency.concurrent-distinct-key-requests-respect-advertised-idempotency-cache-retention', 
-              'idempotency.md',
+              'spec/v1/idempotency.md',
               'limits.idempotencyAckTimeoutSec MUST be integer ≥5 when advertised',
             ),
           ).toBe(true);

package/src/scenarios/idempotency-concurrent-claim.test.ts

@@ -1,5 +1,5 @@
 /**
- * RFC 0150 §B / `idempotency.md` §"Concurrent duplicates (Layer 2)" — the
+ * RFC 0150 §B / `spec/v1/idempotency.md` §"Concurrent duplicates (Layer 2)" — the
  * atomic-claim witness. Gap **G17**.
  *
  * The rule: the persist that guards a side effect MUST be an **atomic claim** —
@@ -102,7 +102,7 @@ describe('idempotency-concurrent-claim: two executors of one run, one effect (RF
     expect(
       unique.size,
       req('openwop.it.idempotency-concurrent-claim.every-executor-mints-the-same-logicalinvocationid-without-this-one-delivery-prov', 
-        'idempotency.md §"Idempotency key composition" (Across a recovery boundary)',
+        'spec/v1/idempotency.md §"Idempotency key composition" (Across a recovery boundary)',
         'all executors MUST mint one identity — differing ids mean they never collided, so a single delivery is a vacuous pass rather than a working claim',
       ),
     ).toBe(1);
@@ -119,7 +119,7 @@ describe('idempotency-concurrent-claim: two executors of one run, one effect (RF
     expect(
       out.delivered,
       req('openwop.it.idempotency-concurrent-claim.exactly-one-effect-escapes-however-many-executors-attempt-it', 
-        'idempotency.md §"Concurrent duplicates (Layer 2)"',
+        'spec/v1/idempotency.md §"Concurrent duplicates (Layer 2)"',
         'the engine MUST ensure at most one concurrent executor performs the external effect — the guarding persist MUST be an atomic claim, not a read-then-write',
       ),
     ).toBe(1);
@@ -156,7 +156,7 @@ describe('idempotency-concurrent-claim: two executors of one run, one effect (RF
     expect(
       out.delivered,
       req('openwop.it.idempotency-concurrent-claim.the-race-is-real-at-higher-concurrency-too-a-claim-that-only-holds-at-2-is-not-a', 
-        'idempotency.md §"Concurrent duplicates (Layer 2)"',
+        'spec/v1/idempotency.md §"Concurrent duplicates (Layer 2)"',
         'exactly one effect regardless of how many executors race — at most one wins the compare-and-set, the rest observe the hit',
       ),
     ).toBe(1);
@@ -167,7 +167,7 @@ describe('idempotency-concurrent-claim: two executors of one run, one effect (RF
     ).toBe(out.attempted);
     expect(
       new Set(ids.map((x) => JSON.stringify(x))).size,
-      req('openwop.it.idempotency-concurrent-claim.the-race-is-real-at-higher-concurrency-too-a-claim-that-only-holds-at-2-is-not-a', 'idempotency.md §"Idempotency key composition"', 'one identity across all executors at any concurrency'),
+      req('openwop.it.idempotency-concurrent-claim.the-race-is-real-at-higher-concurrency-too-a-claim-that-only-holds-at-2-is-not-a', 'spec/v1/idempotency.md §"Idempotency key composition"', 'one identity across all executors at any concurrency'),
     ).toBe(1);
   });
 });

package/src/scenarios/idempotency-key-determinism.test.ts

@@ -135,7 +135,7 @@ describe('category: core.openwop.http.idempotency-key — determinism contract',
     };
     const a = await idempotencyKey(ctx);
     const b = await idempotencyKey(ctx);
-    expect(a.outputs.key, req('openwop.it.idempotency-key-determinism.default-mode-composite-identical-runid-nodeid-payload-produces-identical-keys', 'idempotency.md §"Idempotency-Key', 'idempotency.md §Idempotency-Key: same logical request MUST produce same key')).toBe(b.outputs.key);
+    expect(a.outputs.key, req('openwop.it.idempotency-key-determinism.default-mode-composite-identical-runid-nodeid-payload-produces-identical-keys', 'spec/v1/idempotency.md §"Idempotency-Key', 'spec/v1/idempotency.md §Idempotency-Key: same logical request MUST produce same key')).toBe(b.outputs.key);
     expect(a.outputs.key).toMatch(KEY_PATTERN);
   });
 
@@ -144,7 +144,7 @@ describe('category: core.openwop.http.idempotency-key — determinism contract',
     const baseCtx = { runId: 'run-1', nodeId: 'node-1' };
     const a = await idempotencyKey({ ...baseCtx, inputs: { payload: { hello: 'world' } } });
     const b = await idempotencyKey({ ...baseCtx, inputs: { payload: { hello: 'CHANGED' } } });
-    expect(a.outputs.key, req('openwop.it.idempotency-key-determinism.payload-sensitivity-different-payload-produces-different-key', 'idempotency.md §"Idempotency-Key', 'payload sensitivity — different payload produces different key')).not.toBe(b.outputs.key);
+    expect(a.outputs.key, req('openwop.it.idempotency-key-determinism.payload-sensitivity-different-payload-produces-different-key', 'spec/v1/idempotency.md §"Idempotency-Key', 'payload sensitivity — different payload produces different key')).not.toBe(b.outputs.key);
   });
 
   it('run isolation — different runId produces different key', async () => {
@@ -152,7 +152,7 @@ describe('category: core.openwop.http.idempotency-key — determinism contract',
     const payload = { hello: 'world' };
     const a = await idempotencyKey({ runId: 'run-1', nodeId: 'node-1', inputs: { payload } });
     const b = await idempotencyKey({ runId: 'run-2', nodeId: 'node-1', inputs: { payload } });
-    expect(a.outputs.key, req('openwop.it.idempotency-key-determinism.run-isolation-different-runid-produces-different-key', 'idempotency.md §"Idempotency-Key', 'run isolation — different runId produces different key')).not.toBe(b.outputs.key);
+    expect(a.outputs.key, req('openwop.it.idempotency-key-determinism.run-isolation-different-runid-produces-different-key', 'spec/v1/idempotency.md §"Idempotency-Key', 'run isolation — different runId produces different key')).not.toBe(b.outputs.key);
   });
 
   it('node isolation — different nodeId produces different key', async () => {
@@ -160,7 +160,7 @@ describe('category: core.openwop.http.idempotency-key — determinism contract',
     const payload = { hello: 'world' };
     const a = await idempotencyKey({ runId: 'run-1', nodeId: 'node-A', inputs: { payload } });
     const b = await idempotencyKey({ runId: 'run-1', nodeId: 'node-B', inputs: { payload } });
-    expect(a.outputs.key, req('openwop.it.idempotency-key-determinism.node-isolation-different-nodeid-produces-different-key', 'idempotency.md §"Idempotency-Key', 'node isolation — different nodeId produces different key')).not.toBe(b.outputs.key);
+    expect(a.outputs.key, req('openwop.it.idempotency-key-determinism.node-isolation-different-nodeid-produces-different-key', 'spec/v1/idempotency.md §"Idempotency-Key', 'node isolation — different nodeId produces different key')).not.toBe(b.outputs.key);
   });
 
   it('hash mode is deterministic in the payload alone (run/node ignored)', async () => {
@@ -168,7 +168,7 @@ describe('category: core.openwop.http.idempotency-key — determinism contract',
     const payload = { request: 'payload-here', id: 42 };
     const a = await idempotencyKey({ config: { mode: 'hash' }, runId: 'run-1', nodeId: 'node-1', inputs: { payload } });
     const b = await idempotencyKey({ config: { mode: 'hash' }, runId: 'run-2', nodeId: 'node-2', inputs: { payload } });
-    expect(a.outputs.key, req('openwop.it.idempotency-key-determinism.hash-mode-is-deterministic-in-the-payload-alone-run-node-ignored', 'idempotency.md §"Idempotency-Key', 'hash mode MUST ignore run/node — useful for global remote-dedup caches')).toBe(b.outputs.key);
+    expect(a.outputs.key, req('openwop.it.idempotency-key-determinism.hash-mode-is-deterministic-in-the-payload-alone-run-node-ignored', 'spec/v1/idempotency.md §"Idempotency-Key', 'hash mode MUST ignore run/node — useful for global remote-dedup caches')).toBe(b.outputs.key);
     expect(a.outputs.key).toMatch(KEY_PATTERN);
   });
 
@@ -183,7 +183,7 @@ describe('category: core.openwop.http.idempotency-key — determinism contract',
     ];
     for (const ctx of samples) {
       const result = await idempotencyKey(ctx);
-      expect(result.outputs.key, req('openwop.it.idempotency-key-determinism.output-shape-every-emitted-key-matches-openwop-sha256-prefix-16', 'idempotency.md §"Idempotency-Key', `key shape for ctx=${JSON.stringify(ctx)}`)).toMatch(KEY_PATTERN);
+      expect(result.outputs.key, req('openwop.it.idempotency-key-determinism.output-shape-every-emitted-key-matches-openwop-sha256-prefix-16', 'spec/v1/idempotency.md §"Idempotency-Key', `key shape for ctx=${JSON.stringify(ctx)}`)).toMatch(KEY_PATTERN);
     }
   });
 
@@ -197,7 +197,7 @@ describe('category: core.openwop.http.idempotency-key — determinism contract',
     } catch (err) {
       caught = err;
     }
-    expect(caught, req('openwop.it.idempotency-key-determinism.uuid-mode-rejects-with-config-invalid-safety-fix-per-1-1-2', 'idempotency.md §"Idempotency-Key', 'mode: uuid MUST be rejected — the 1.1.0/1.1.1 non-deterministic default was removed')).toBeInstanceOf(Error);
+    expect(caught, req('openwop.it.idempotency-key-determinism.uuid-mode-rejects-with-config-invalid-safety-fix-per-1-1-2', 'spec/v1/idempotency.md §"Idempotency-Key', 'mode: uuid MUST be rejected — the 1.1.0/1.1.1 non-deterministic default was removed')).toBeInstanceOf(Error);
     expect((caught as Error & { code?: string }).code).toBe('CONFIG_INVALID');
     expect((caught as Error).message).toMatch(/uuid.*removed|safety-fix/i);
   });
@@ -223,7 +223,7 @@ describe('category: core.openwop.http.idempotency-key — determinism contract',
       const expected = canonicalCompositeKey(v.runId, v.nodeId, v.payload);
       expect(
         packed.outputs.key,
-        req('openwop.it.idempotency-key-determinism.cross-impl-invariant-pack-output-equals-canonical-sha-256-formula', 'idempotency.md §"Idempotency-Key', `vector ${JSON.stringify(v)} — pack output MUST match canonical sha256(runId\\0nodeId\\0JSON(payload))`),
+        req('openwop.it.idempotency-key-determinism.cross-impl-invariant-pack-output-equals-canonical-sha-256-formula', 'spec/v1/idempotency.md §"Idempotency-Key', `vector ${JSON.stringify(v)} — pack output MUST match canonical sha256(runId\\0nodeId\\0JSON(payload))`),
       ).toBe(expected);
     }
 

package/src/scenarios/idempotency.test.ts

@@ -47,14 +47,14 @@ describe.skipIf(SKIP_NO_FIXTURE)('idempotency: same key + same body replays per
     expect(
       [200, 201].includes(replay.status),
       req('openwop.it.idempotency.returns-same-runid-twice-and-sets-openwop-idempotent-replay-on-the-replay', 
-        'idempotency.md §Layer 1',
+        'spec/v1/idempotency.md §Layer 1',
         'replay request with same key + same body MUST return success status (200/201)',
       ),
     ).toBe(true);
 
     const replayRunId = (replay.json as { runId: string }).runId;
     expect(replayRunId, req('openwop.it.idempotency.returns-same-runid-twice-and-sets-openwop-idempotent-replay-on-the-replay', 
-      'idempotency.md §Layer 1',
+      'spec/v1/idempotency.md §Layer 1',
       'replay MUST return the SAME runId (no new run created)',
     )).toBe(firstRunId);
 
@@ -84,7 +84,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('idempotency: same key + different body conflic
     );
 
     expect(conflict.status, req('openwop.it.idempotency.returns-409-when-the-body-changes-under-the-same-key', 
-      'idempotency.md §Layer 1',
+      'spec/v1/idempotency.md §Layer 1',
       'same Idempotency-Key with a different body MUST return 409',
     )).toBe(409);
 
@@ -98,7 +98,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('idempotency: same key + different body conflic
     // `idempotency_key_replay_mismatch` — a spelling in no corpus artifact at
     // all. This leg asserted the status alone, so every one of them passed.
     //
-    // `idempotency_key_mismatch` is canonical (idempotency.md §"Record shape,
+    // `idempotency_key_mismatch` is canonical (spec/v1/idempotency.md §"Record shape,
     // digest, and lease"): the only spelling already in more than one shipped
     // artifact. The two legacy spellings are TOLERATED here through the first
     // minor after 2026-11-10 so a converging host is not red on a rename it is
@@ -109,7 +109,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('idempotency: same key + different body conflic
     expect(
       code === 'idempotency_key_mismatch' || LEGACY.includes(code ?? ''),
       req('openwop.it.idempotency.returns-409-when-the-body-changes-under-the-same-key', 
-        'idempotency.md §"Record shape, digest, and lease"',
+        'spec/v1/idempotency.md §"Record shape, digest, and lease"',
         `a different request digest under the same scoped key MUST fail with the canonical ` +
           `\`idempotency_key_mismatch\` (legacy \`${LEGACY.join('` / `')}\` tolerated through the ` +
           `first minor after 2026-11-10); got \`${code ?? '<none>'}\``,
@@ -122,7 +122,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('idempotency: same key + different body conflic
     expect(
       conflictRunId,
       req('openwop.it.idempotency.returns-409-when-the-body-changes-under-the-same-key', 
-        'idempotency.md §"Record shape, digest, and lease"',
+        'spec/v1/idempotency.md §"Record shape, digest, and lease"',
         'a digest mismatch MUST NOT return the cached body (no runId on the 409)',
       ),
     ).toBeUndefined();

package/src/scenarios/idempotencyRetry.test.ts

@@ -6,7 +6,7 @@
  * additions documented in idempotency.md:
  *
  *   1. openwop-Idempotent-Replay header is present on every keyed response
- *      (idempotency.md §Server responsibilities).
+ *      (spec/v1/idempotency.md §Server responsibilities).
  *   2. Retry-budget floor — hosts handle ≥5 retries 100ms apart with
  *      the cached response (scale-profiles.md §"Retry semantics").
  *   3. Same-key replay returns same runId across the budget.
@@ -53,7 +53,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('idempotency-retry: openwop-Idempotent-Replay h
     // Permissive assertion: if present, MUST be "false" or "true".
     if (firstReplay !== null) {
       expect(['false', 'true'].includes(firstReplay), req('openwop.it.idempotencyRetry.first-request-with-new-key-returns-false-or-absent-should-per-current-spec-repla', 
-        'idempotency.md §Server responsibilities',
+        'spec/v1/idempotency.md §Server responsibilities',
         'openwop-Idempotent-Replay value MUST be "true" or "false"',
       )).toBe(true);
     }
@@ -61,19 +61,19 @@ describe.skipIf(SKIP_NO_FIXTURE)('idempotency-retry: openwop-Idempotent-Replay h
     const replay = await driver.post('/v1/runs', body, { headers: { 'Idempotency-Key': key } });
     expect(
       [200, 201].includes(replay.status),
-      req('openwop.it.idempotencyRetry.first-request-with-new-key-returns-false-or-absent-should-per-current-spec-repla', 'idempotency.md §Layer 1', 'replay returns 200 or 201'),
+      req('openwop.it.idempotencyRetry.first-request-with-new-key-returns-false-or-absent-should-per-current-spec-repla', 'spec/v1/idempotency.md §Layer 1', 'replay returns 200 or 201'),
     ).toBe(true);
 
     const replayHeader = replay.headers.get('openwop-idempotent-replay');
-    // Per idempotency.md §Server responsibilities #2: SHOULD be set.
+    // Per spec/v1/idempotency.md §Server responsibilities #2: SHOULD be set.
     // RFC 0002 §1 promotes to MUST. Today's strictness: present on replay.
     expect(replayHeader, req('openwop.it.idempotencyRetry.first-request-with-new-key-returns-false-or-absent-should-per-current-spec-repla', 
-      'idempotency.md §Server responsibilities #2',
+      'spec/v1/idempotency.md §Server responsibilities #2',
       'openwop-Idempotent-Replay SHOULD be set on idempotent replay responses',
     )).not.toBeNull();
     if (replayHeader !== null) {
       expect(replayHeader, req('openwop.it.idempotencyRetry.first-request-with-new-key-returns-false-or-absent-should-per-current-spec-repla', 
-        'idempotency.md §Server responsibilities #2',
+        'spec/v1/idempotency.md §Server responsibilities #2',
         'openwop-Idempotent-Replay on replay MUST be "true"',
       )).toBe('true');
     }
@@ -104,7 +104,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('idempotency-retry: 5-retry budget per scale-pr
 
     const runIds = new Set(responses.map((r) => (r.json as { runId?: string })?.runId));
     expect(runIds.size, req('openwop.it.idempotencyRetry.5-retries-100ms-apart-with-same-key-all-return-the-same-runid', 
-      'idempotency.md §Layer 1',
+      'spec/v1/idempotency.md §Layer 1',
       '5 retries with same key MUST collapse to exactly one runId',
     )).toBe(1);
   });
@@ -116,19 +116,24 @@ describe('idempotency-retry: limits.idempotencyAckTimeoutSec contract per idempo
     expect(res.status).toBe(200);
 
     const limits = (res.json as { limits?: Record<string, unknown> })?.limits;
-    if (!limits) return softSkip('blocked', 'precondition not met — `!limits` returned early (limits required per capabilities.md §3 — covered elsewhere) (seam, prior step, or fixture unavailable)'); // limits required per capabilities.md §3 — covered elsewhere
+    // partial-witness-ok: discovery answered 200; `limits` presence is its own requirement,
+    // asserted by the capabilities scenarios, and this leg's IF-advertised clause binds nothing
+    // without it.
+    if (!limits) return softSkip('inapplicable', 'discovery carries no limits object — its presence is asserted elsewhere; nothing for this IF-advertised leg to check');
     const ack = limits.idempotencyAckTimeoutSec;
     if (ack === undefined) {
       // Per idempotency.md, the field is optional; absence implies the
       // 5-second floor. Nothing to assert.
-      return softSkip('blocked', 'precondition not met — `ack === undefined` returned early (Per idempotency.md, the field is optional; absence implies the 5-second floor. Nothing to assert.) (seam, prior step, or fixture unavailable)');
+      // partial-witness-ok: idempotencyAckTimeoutSec is optional and absence means the 5-second
+      // floor; the IF-advertised MUSTs below bind nothing.
+      return softSkip('inapplicable', 'limits.idempotencyAckTimeoutSec not advertised (optional; the 5-second floor applies) — nothing to check');
     }
     expect(typeof ack === 'number' && Number.isInteger(ack), req('openwop.it.idempotencyRetry.host-advertising-idempotencyacktimeoutsec-sets-integer-5', 
-      'idempotency.md',
+      'spec/v1/idempotency.md',
       'limits.idempotencyAckTimeoutSec MUST be an integer when advertised',
     )).toBe(true);
     expect(ack as number, req('openwop.it.idempotencyRetry.host-advertising-idempotencyacktimeoutsec-sets-integer-5', 
-      'idempotency.md',
+      'spec/v1/idempotency.md',
       'limits.idempotencyAckTimeoutSec MUST be ≥ 5',
     )).toBeGreaterThanOrEqual(5);
   });

package/src/scenarios/interrupt-token-matrix.test.ts

@@ -31,7 +31,7 @@ import { driver } from '../lib/driver.js';
 import { pollUntilStatus } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { req } from '../lib/requirement-ids.js';
-import { softSkip } from '../lib/soft-skip.js';
+import { blockedDespiteAssertions } from '../lib/soft-skip.js';
 
 const FIXTURE = 'conformance-interrupt-external-event';
 const SKIP = !isFixtureAdvertised(FIXTURE);
@@ -72,26 +72,38 @@ describe.skipIf(SKIP)('interrupt-token-matrix: POST /v1/interrupts/{token} negat
     expect(create.status).toBe(201);
     const runId = (create.json as { runId: string }).runId;
 
-    await pollUntilStatus(runId, 'waiting-external-event', { timeoutMs: 10_000 }).catch(() => null);
+    // softskip ratchet, 2026-09-27: this leg polled for `waiting-external-event`, a
+    // status that does not exist, and read `snapshot.interrupts[].token`, a field the
+    // snapshot does not carry. It found no token on any host, so it never reached the
+    // replay assertion and recorded a partial-witness pass on the 201 alone. It now
+    // reads the token the way interrupt-external-event-correlation does
+    // (`interrupt.interruptToken`, else the `/v1/interrupts/{token}` segment of
+    // `interrupt.callbackUrl`) once the run reaches `waiting-external`.
+    await pollUntilStatus(runId, 'waiting-external', { timeoutMs: 10_000 }).catch(() => null);
 
     const snap = await driver.get(`/v1/runs/${encodeURIComponent(runId)}`);
-    const interrupts =
-      ((snap.json as { interrupts?: Array<{ token?: string }> }).interrupts ?? [])
-        .filter((i) => typeof i.token === 'string');
-    const token = interrupts[0]?.token;
+    const interrupt = (snap.json as { interrupt?: { interruptToken?: string; callbackUrl?: string } } | undefined)?.interrupt;
+    const fromCallback = interrupt?.callbackUrl?.match(/\/v1\/interrupts\/([^/?]+)/)?.[1];
+    const token = interrupt?.interruptToken ?? (fromCallback === undefined ? undefined : decodeURIComponent(fromCallback));
     if (typeof token !== 'string') {
       // eslint-disable-next-line no-console
       console.warn('[interrupt-token-matrix] host did not surface an interrupt token; skipping replay subtest');
       await driver.post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {
         reason: 'conformance-cleanup',
       });
-      return softSkip('blocked', 'precondition not met — `typeof token !== \'string\'` returned early ([interrupt-token-matrix] host did not surface an interrupt token; skipping replay subtest) (seam, prior step, or fixture unavailable)');
+      // interrupt-external-event-correlation holds token exposure as a MUST for this
+      // fixture, so a missing token leaves the replay rule unobserved: blocked.
+      return blockedDespiteAssertions('the suspended conformance-interrupt-external-event run exposed no signed token (interrupt.interruptToken or interrupt.callbackUrl) — replay of a resolved token is unobserved');
     }
 
+    // The fixture's correlation is {orderId: 'fixture-order-1', status: 'completed'}; a
+    // mismatched payload is refused 422 (interrupt-external-event-correlation), so the
+    // first resolve must match or the replay rule is never reached.
+    const MATCHING = { orderId: 'fixture-order-1', status: 'completed', externalReference: 'conformance-token-matrix' };
     const resolve1 = await driver.post(`/v1/interrupts/${encodeURIComponent(token)}`, {
-      correlation: { orderId: 'order-token-matrix', status: 'accepted' },
+      resumeValue: MATCHING,
     });
-    if (resolve1.status !== 200 && resolve1.status !== 202) {
+    if (resolve1.status < 200 || resolve1.status >= 300) {
       // eslint-disable-next-line no-console
       console.warn(
         `[interrupt-token-matrix] first resolve returned ${resolve1.status}; can't exercise replay path. Skipping.`,
@@ -99,11 +111,12 @@ describe.skipIf(SKIP)('interrupt-token-matrix: POST /v1/interrupts/{token} negat
       await driver.post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {
         reason: 'conformance-cleanup',
       });
-      return softSkip('blocked', 'precondition not met — `resolve1.status !== 200 && resolve1.status !== 202` returned early ([interrupt-token-matrix] first resolve returned …; can\'t exercise replay path. Skipping.) (seam, prior step, or fixture unava…');
+      // interrupt-external-event-correlation holds a matching resolve to 2xx as a MUST.
+      return blockedDespiteAssertions(`the first resolve of the token answered ${resolve1.status}, not 2xx — replay of a resolved token is unobserved`);
     }
 
     const resolve2 = await driver.post(`/v1/interrupts/${encodeURIComponent(token)}`, {
-      correlation: { orderId: 'order-token-matrix', status: 'accepted' },
+      resumeValue: MATCHING,
     });
     expect([404, 409, 410], req('openwop.it.interrupt-token-matrix.replay-after-successful-resolve-returns-409-or-404', 
       'rest-endpoints.md POST /v1/interrupts/{token}',

package/src/scenarios/mcp-cache-tenant-scope.test.ts

@@ -22,7 +22,7 @@
 
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
-import { seamAbsent, softSkip } from '../lib/soft-skip.js';
+import { seamAbsent, blockedDespiteAssertions } from '../lib/soft-skip.js';
 import { mcpServerMount } from '../lib/mcp-mount.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
@@ -56,10 +56,10 @@ describe.skipIf(!process.env.OPENWOP_BASE_URL)('RFC 0153 §D — mcp-cache-tenan
       // Shape only; the cross-caller half is unobservable without a second credential.
       // eslint-disable-next-line no-console
       console.warn('[mcp-cache-tenant-scope] OPENWOP_TEST_SECONDARY_API_KEY not set — cross-caller half not exercised (blocked)');
-      return softSkip('blocked', 'precondition not met — `!other` returned early ([mcp-cache-tenant-scope] OPENWOP_TEST_SECONDARY_API_KEY not set — cross-caller half not exercised (blocked)) (seam, prior step, or fixture unavailable)');
+      return blockedDespiteAssertions('OPENWOP_TEST_SECONDARY_API_KEY is unset — the cross-caller half (a per-caller list MUST be cacheScope private) is unobserved');
     }
     const theirs = await listAs(other);
-    if (theirs.status !== 200) return softSkip('blocked', 'precondition not met — `theirs.status !== 200` returned early (seam, prior step, or fixture unavailable)');
+    if (theirs.status !== 200) return blockedDespiteAssertions('tools/list under the secondary credential did not answer 200 — the cross-caller comparison is unobserved');
     const same = JSON.stringify(mine.body.result?.tools) === JSON.stringify(theirs.body.result?.tools);
     if (!same) {
       expect(mine.body.result?.cacheScope, req('openwop.it.mcp-cache-tenant-scope.a-per-caller-list-is-cachescope-private-a-public-list-is-byte-identical-across-c', 'mcp-integration.md §D', 'a list that differs per caller MUST be cacheScope private — a public list that differs is cross-context cache poisoning (mcp-cache-tenant-scoped)')).toBe('private');

package/src/scenarios/mcp-current-auth-boundary.test.ts

@@ -50,15 +50,15 @@ describe.skipIf(!process.env.OPENWOP_BASE_URL)('RFC 0153 §E — mcp-current-aut
     const { mcp, anon } = await disco();
     const claims = mcp?.supported === true && (mcp.profiles ?? []).includes(PROFILE) && mcp.serverMount?.supported === true;
     if (!behaviorGate(PROFILE, claims)) return;
+    // Anonymous access is permitted through the RFC 0132 surface when anonymousActor is
+    // advertised, so the refusal this leg checks does not apply. Known from discovery, so it
+    // is decided before any assertion (it used to follow the authenticated-call assert and
+    // record a partial-witness pass).
+    if (anon?.supported === true) return softSkip('inapplicable', 'anonymousActor is advertised — an anonymous current-profile request may be served through the RFC 0132 surface, so the refusal rule does not apply');
     const authed = await driver.post(await mcpServerMount(), REQ, { headers: HDR });
     if (authed.status === 404 || authed.status === 403) return seamAbsent(`host advertises an MCP server mount but the mount (capabilities.mcp.serverUrls[0], else /v1/host/sample/mcp) answered ${authed.status} — RFC 0153 §B is unobservable at the path the host itself advertised`);
     expect(authed.status, req('openwop.it.mcp-current-auth-boundary.an-unauthenticated-current-profile-request-is-refused-unless-anonymousactor-is-a', 'mcp-integration.md §E', 'the authenticated call MUST succeed at the same path, so a refusal below is not a wrong path')).toBe(200);
     const anonymous = await driver.post(await mcpServerMount(), REQ, { headers: HDR, authenticated: false });
-    if (anon?.supported === true) {
-      // Anonymous is permitted only through the RFC 0132 surface; a 200 here is that surface answering.
-      expect([200, 401, 403]).toContain(anonymous.status);
-      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `anon?.supported === true` returned early');
-    }
     expect(
       [401, 403],
       req('openwop.it.mcp-current-auth-boundary.an-unauthenticated-current-profile-request-is-refused-unless-anonymousactor-is-a', 'mcp-integration.md §E', 'an anonymous MCP principal MUST NOT be the production default for an advertised current profile — refuse (401/403) or advertise anonymousActor'),
@@ -74,7 +74,10 @@ describe.skipIf(!process.env.OPENWOP_BASE_URL)('RFC 0153 §E — mcp-current-aut
       ...setCookies(anonymous.headers),
       ...setCookies((await driver.get('/.well-known/openwop', { authenticated: false })).headers),
     ];
-    if (minted.length === 0) return softSkip('blocked', 'precondition not met — `minted.length === 0` returned early (host mints no anonymous session; the bare probe was the whole observation) (seam, prior step, or fixture unavailable)'); // host mints no anonymous session; the bare probe was the whole observation
+    // partial-witness-ok: the bare anonymous probe, the requirement, was refused and asserted
+    // above. The S30 replay binds only a host that mints an anonymous session, and this one
+    // minted none.
+    if (minted.length === 0) return softSkip('inapplicable', 'the host minted no anonymous session, so the bare-probe refusal asserted above was the whole observation');
     const cookie = minted.map((c) => c.split(';')[0]).join('; ');
     const withSession = await driver.post(await mcpServerMount(), REQ, { headers: { ...HDR, Cookie: cookie }, authenticated: false });
     expect(

package/src/scenarios/mcp-extension-opacity.test.ts

@@ -54,12 +54,13 @@ describe.skipIf(!process.env.OPENWOP_BASE_URL)('RFC 0153 §D — mcp-extension-o
       // an advertised-missing seam (RFC 0148 §B). A 403 is NOT a pass.
       return seamAbsent(`host advertises mcp-2026-07-28 but the invoke seam /v1/host/sample/mcp/invoke answered ${drive.status}`);
     }
-    expect(server.invocations().some((i) => i.method === 'tools/call'), req('openwop.it.mcp-extension-opacity.client-half-an-extension-meta-asserting-authority-in-a-tool-result-changes-nothi', 'host-sample-test-seams.md §23', 'the host MUST have called the tool')).toBe(true);
+    // `extensionAuthority` is an OPTIONAL seam field (host-sample-test-seams.md §23). Its
+    // absence is `inapplicable`, decided before any assertion, never a failure or a
+    // `blocked` (the 2.42.6 appendEra2Event precedent). A report that IS present is held
+    // to the contract below.
     const rep = (drive.json as { extensionAuthority?: { scopesWidened?: boolean; approvalAdvanced?: boolean } }).extensionAuthority;
-    if (rep === undefined) {
-      expect(rep, req('openwop.it.mcp-extension-opacity.client-half-an-extension-meta-asserting-authority-in-a-tool-result-changes-nothi', 'host-sample-test-seams.md §23', 'the seam SHOULD report `extensionAuthority: { scopesWidened, approvalAdvanced }` for scenario "extension-asserts-authority"; until it does the requirement is `blocked`, not passed')).toBeDefined();
-      return softSkip('blocked', 'precondition not met — `rep === undefined` returned early (seam, prior step, or fixture unavailable)');
-    }
+    if (rep === undefined) return softSkip('inapplicable', 'the invoke seam reports no extensionAuthority (an optional seam field, host-sample-test-seams.md §23), so extension opacity is not observable on this host');
+    expect(server.invocations().some((i) => i.method === 'tools/call'), req('openwop.it.mcp-extension-opacity.client-half-an-extension-meta-asserting-authority-in-a-tool-result-changes-nothi', 'host-sample-test-seams.md §23', 'the host MUST have called the tool')).toBe(true);
     expect(rep.scopesWidened, req('openwop.it.mcp-extension-opacity.client-half-an-extension-meta-asserting-authority-in-a-tool-result-changes-nothi', 'mcp-integration.md §D', 'an extension MUST NOT gain tool authority or scope by appearing in _meta (mcp-extension-no-authority)')).toBe(false);
     expect(rep.approvalAdvanced, req('openwop.it.mcp-extension-opacity.client-half-an-extension-meta-asserting-authority-in-a-tool-result-changes-nothi', 'mcp-integration.md §D/§E', 'MCP content MUST NOT advance approval gates')).toBe(false);
   });