@openwop/openwop-conformance 1.124.0 → 1.125.0

package/dist/lib/scenario-disposition.js

@@ -88,7 +88,9 @@ export function fileDisposition(states, gateReason, assertionCount) {
  *   - a zero-assertion "pass" ⇒ the file's noted reason (`softSkip` /
  *     `seamAbsent`: inapplicable | skipped | blocked) or a behaviorGate reason;
  *   - a zero-assertion "pass" with NO reason ⇒ `blocked` + the marker detail —
- *     an early return can never become a pass.
+ *     an early return can never become a pass;
+ *   - every test `ctx.skip()`ped ⇒ the file's noted reason if it wrote one
+ *     BEFORE skipping (`ctx.skip()` throws), else `blocked` + the marker.
  */
 export function resolveFileRecord(states, gateReason, assertionCount, noted) {
     let { disposition, detail } = fileDisposition(states, gateReason, assertionCount);
@@ -102,6 +104,17 @@ export function resolveFileRecord(states, gateReason, assertionCount, noted) {
             detail = UNCLASSIFIED_RETURN_DETAIL;
         }
     }
+    else if (noted !== null &&
+        gateReason === undefined &&
+        states.length > 0 &&
+        states.every((s) => s === 'skip')) {
+        // Every test called `ctx.skip()` (vitest reports them as skipped, not as
+        // zero-assertion passes) and the file noted why first. Note-then-skip is
+        // the required order: `ctx.skip()` throws, so a note written after it is
+        // dead code — which is how seven files carried notes the ledger never saw.
+        disposition = noted.kind;
+        detail = noted.reason;
+    }
     return detail === undefined ? { disposition } : { disposition, detail };
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openwop/openwop-conformance",
-  "version": "1.124.0",
+  "version": "1.125.0",
   "description": "Production-ready black-box conformance suite for OpenWOP v1.0 compliant servers.",
   "repository": {
     "type": "git",

package/schemas/CORPUS-STAMP.json

@@ -1,5 +1,5 @@
 {
   "_comment": "Provenance of this vendored schemas/ copy. See conformance/README.md \u00a7\"Resolving the contract\". Compare against the stamp in your installed @openwop/openwop-conformance to detect a stale hand-copied contract.",
-  "suiteVersion": "1.124.0",
-  "corpusCommit": "7dffa37f3864f170141130aa0360765ba89b2e7e"
+  "suiteVersion": "1.125.0",
+  "corpusCommit": "13ab2a545d4e2a30c8da66354e39d4db7233acae"
 }

package/src/lib/scenario-disposition.ts

@@ -94,7 +94,9 @@ export function fileDisposition(
  *   - a zero-assertion "pass" ⇒ the file's noted reason (`softSkip` /
  *     `seamAbsent`: inapplicable | skipped | blocked) or a behaviorGate reason;
  *   - a zero-assertion "pass" with NO reason ⇒ `blocked` + the marker detail —
- *     an early return can never become a pass.
+ *     an early return can never become a pass;
+ *   - every test `ctx.skip()`ped ⇒ the file's noted reason if it wrote one
+ *     BEFORE skipping (`ctx.skip()` throws), else `blocked` + the marker.
  */
 export function resolveFileRecord(
   states: readonly FileTestState[],
@@ -111,6 +113,18 @@ export function resolveFileRecord(
       disposition = 'blocked';
       detail = UNCLASSIFIED_RETURN_DETAIL;
     }
+  } else if (
+    noted !== null &&
+    gateReason === undefined &&
+    states.length > 0 &&
+    states.every((s) => s === 'skip')
+  ) {
+    // Every test called `ctx.skip()` (vitest reports them as skipped, not as
+    // zero-assertion passes) and the file noted why first. Note-then-skip is
+    // the required order: `ctx.skip()` throws, so a note written after it is
+    // dead code — which is how seven files carried notes the ledger never saw.
+    disposition = noted.kind;
+    detail = noted.reason;
   }
   return detail === undefined ? { disposition } : { disposition, detail };
 }

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

@@ -51,6 +51,18 @@ describe('RFC 0148 §A — conformance-execution-witness: the runner record', ()
     expect(resolveFileRecord(['pass'], undefined, 0, { kind: 'skipped', reason: 'operator opt-out' })).toEqual({ disposition: 'skipped', detail: 'operator opt-out' });
   });
 
+  it('every test ctx.skip()ped takes the noted reason when one was written before the skip, else stays the blocked marker', () => {
+    // `ctx.skip()` throws — a `softSkip(...)` AFTER it is dead code. Seven files
+    // carried exactly that dead note and reported as unclassified for a suite minor.
+    expect(resolveFileRecord(['skip', 'skip'], undefined, 0, { kind: 'inapplicable', reason: 'sandbox not advertised' })).toEqual({ disposition: 'inapplicable', detail: 'sandbox not advertised' });
+    expect(resolveFileRecord(['skip'], undefined, 0, { kind: 'blocked', reason: 'simulator seam 404' })).toEqual({ disposition: 'blocked', detail: 'simulator seam 404' });
+    const bare = resolveFileRecord(['skip', 'skip'], undefined, 0, null);
+    expect(bare.disposition).toBe('blocked');
+    expect(bare.detail).toMatch(/every test skipped with no recorded reason/);
+    // A behaviorGate reason still wins over a note — the gate is the more specific record.
+    expect(resolveFileRecord(['skip'], 'inapplicable', 0, { kind: 'blocked', reason: 'x' }).disposition).toBe('inapplicable');
+  });
+
   it('a behaviorGate reason resolves a zero-assertion pass to inapplicable/skipped; a note outranks nothing but never a witnessed pass', () => {
     expect(resolveFileRecord(['pass'], 'inapplicable', 0, null).disposition).toBe('inapplicable');
     expect(resolveFileRecord(['pass'], 'skipped', 0, null).disposition).toBe('skipped');

package/src/scenarios/cross-engine-append-behavior.test.ts

@@ -29,7 +29,8 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { softSkip } from '../lib/soft-skip.js';
+import { softSkip, seamAbsent } from '../lib/soft-skip.js';
+import { capabilityFamily } from '../lib/discovery-capabilities.js';
 import { driver } from '../lib/driver.js';
 
 const HTTP_SKIP = !process.env.OPENWOP_BASE_URL;
@@ -69,12 +70,29 @@ async function resetLog(): Promise<number> {
   return res.status;
 }
 
+/**
+ * The cross-engine harness seam answered 404. Whether that is `blocked` (the host
+ * advertises `eventLog.crossEngineOrdering.supported: true` and so made a claim
+ * this file cannot check) or `inapplicable` (no such advertisement) depends on
+ * discovery — record the honest one (RFC 0148 §A).
+ */
+async function noteHarnessAbsent(): Promise<void> {
+  const disco = await driver.get('/.well-known/openwop');
+  const el = capabilityFamily<{ crossEngineOrdering?: { supported?: unknown } }>(disco.json, 'eventLog');
+  if (el?.crossEngineOrdering?.supported === true) {
+    seamAbsent('host advertises `eventLog.crossEngineOrdering.supported: true` but `POST /v1/host/sample/test/cross-engine/reset` answered 404 — the ordering claim is unobservable (host-sample-test-seams.md)');
+  } else {
+    softSkip('inapplicable', 'optional advertisement — `eventLog.crossEngineOrdering` not advertised by this host, and the cross-engine harness seam is absent (RFC 0036 §B)');
+  }
+}
+
 describe.skipIf(HTTP_SKIP)('cross-engine-append-behavior: §B cross-engine ordering (RFC 0036)', () => {
   it('interleaved appends from two engines converge to a single globally-ordered sequence', async (ctx) => {
     const resetStatus = await resetLog();
     if (resetStatus === 404) {
+      await noteHarnessAbsent();
       ctx.skip(); // host doesn't expose the cross-engine harness seam
-      return softSkip('blocked', 'precondition not met — `resetStatus === 404` returned early (seam, prior step, or fixture unavailable)');
+      return;
     }
     expect(resetStatus).toBe(200);
 
@@ -125,8 +143,9 @@ describe.skipIf(HTTP_SKIP)('cross-engine-append-behavior: §B cross-engine order
   it('lamport clocks monotonically advance across engines', async (ctx) => {
     const resetStatus = await resetLog();
     if (resetStatus === 404) {
+      await noteHarnessAbsent();
       ctx.skip();
-      return softSkip('blocked', 'precondition not met — `resetStatus === 404` returned early (seam, prior step, or fixture unavailable)');
+      return;
     }
     expect(resetStatus).toBe(200);
 
@@ -153,8 +172,9 @@ describe.skipIf(HTTP_SKIP)('cross-engine-append-behavior: §B cross-engine order
   it('lamport hint from engine A advances engine B past it', async (ctx) => {
     const resetStatus = await resetLog();
     if (resetStatus === 404) {
+      await noteHarnessAbsent();
       ctx.skip();
-      return softSkip('blocked', 'precondition not met — `resetStatus === 404` returned early (seam, prior step, or fixture unavailable)');
+      return;
     }
     expect(resetStatus).toBe(200);
 
@@ -180,8 +200,9 @@ describe.skipIf(HTTP_SKIP)('cross-engine-append-behavior: §B cross-engine order
   it('linearization is deterministic — same appends → same total order', async (ctx) => {
     const resetStatus = await resetLog();
     if (resetStatus === 404) {
+      await noteHarnessAbsent();
       ctx.skip();
-      return softSkip('blocked', 'precondition not met — `resetStatus === 404` returned early (seam, prior step, or fixture unavailable)');
+      return;
     }
     expect(resetStatus).toBe(200);
 

package/src/scenarios/cross-host-ancestry-endpoint.test.ts

@@ -69,8 +69,9 @@ describe.skipIf(HTTP_SKIP)('cross-host-ancestry-endpoint: behavioral (RFC 0040
     const d = await readDiscovery();
     const chc = capabilityFamily<{ executionModel?: { [k: string]: unknown; crossHostCausation?: Record<string, unknown>; replayDeterminism?: Record<string, unknown> } }>(d, 'multiAgent')?.executionModel?.crossHostCausation;
     if (chc?.ancestryEndpointSupported !== true) {
+      softSkip('inapplicable', 'capability or profile not advertised by this host — gate `chc?.ancestryEndpointSupported !== true` returned early');
       ctx.skip();
-      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `chc?.ancestryEndpointSupported !== true` returned early');
+      return;
     }
 
     // Create a fresh top-level run via the host's conformance-dispatch-loop
@@ -78,8 +79,9 @@ describe.skipIf(HTTP_SKIP)('cross-host-ancestry-endpoint: behavioral (RFC 0040
     // depend on the specific workflow).
     const create = await driver.post('/v1/runs', { workflowId: 'conformance-dispatch-loop' });
     if (create.status !== 201) {
+      softSkip('blocked', 'precondition not met — `create.status !== 201` returned early (seam, prior step, or fixture unavailable)');
       ctx.skip();
-      return softSkip('blocked', 'precondition not met — `create.status !== 201` returned early (seam, prior step, or fixture unavailable)');
+      return;
     }
     const runId = (create.json as { runId: string }).runId;
 
@@ -116,12 +118,14 @@ describe.skipIf(HTTP_SKIP)('cross-host-ancestry-endpoint: behavioral (RFC 0040
     const d = await readDiscovery();
     const chc = capabilityFamily<{ executionModel?: { [k: string]: unknown; crossHostCausation?: Record<string, unknown>; replayDeterminism?: Record<string, unknown> } }>(d, 'multiAgent')?.executionModel?.crossHostCausation;
     if (chc?.supported !== true) {
+      softSkip('inapplicable', 'capability or profile not advertised by this host — gate `chc?.supported !== true` returned early');
       ctx.skip();
-      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `chc?.supported !== true` returned early');
+      return;
     }
     if (chc.ancestryEndpointSupported === true) {
+      softSkip('inapplicable', 'capability or profile not advertised by this host — gate `chc.ancestryEndpointSupported === true` returned early');
       ctx.skip(); // covered by the test above
-      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `chc.ancestryEndpointSupported === true` returned early');
+      return;
     }
 
     // Use any runId — even a synthetic non-existent one. The endpoint should

package/src/scenarios/cross-host-causation-shape.test.ts

@@ -62,13 +62,15 @@ describe.skipIf(HTTP_SKIP)('cross-host-causation-shape: advertisement shape (RFC
   it('crossHostCausation (when present) conforms to RFC 0040 §D', async (ctx) => {
     const d = await readDiscovery();
     if (d === null) {
+      softSkip('blocked', 'precondition not met — `d === null` returned early (seam, prior step, or fixture unavailable)');
       ctx.skip();
-      return softSkip('blocked', 'precondition not met — `d === null` returned early (seam, prior step, or fixture unavailable)');
+      return;
     }
     const chc = capabilityFamily<{ executionModel?: { [k: string]: unknown; crossHostCausation?: Record<string, unknown>; replayDeterminism?: Record<string, unknown> } }>(d, 'multiAgent')?.executionModel?.crossHostCausation;
     if (chc === undefined) {
+      softSkip('inapplicable', 'optional advertisement — `multiAgent.executionModel.crossHostCausation` not advertised by this host (RFC 0040 §D)');
       ctx.skip(); // host doesn't advertise — soft-skip
-      return softSkip('blocked', 'precondition not met — `chc === undefined` returned early (seam, prior step, or fixture unavailable)');
+      return;
     }
 
     expect(

package/src/scenarios/multi-agent-memory-lifecycle.test.ts

@@ -80,13 +80,15 @@ describe.skipIf(HTTP_SKIP)('multi-agent-memory-lifecycle: advertisement shape (R
   it('crossChildMemoryConcurrency (when advertised) MUST be one of {strict, advisory}', async (ctx) => {
     const d = await readDiscovery();
     if (d === null) {
+      softSkip('blocked', 'precondition not met — `d === null` returned early (seam, prior step, or fixture unavailable)');
       ctx.skip();
-      return softSkip('blocked', 'precondition not met — `d === null` returned early (seam, prior step, or fixture unavailable)');
+      return;
     }
     const ccmc = capabilityFamily<{ executionModel?: { [k: string]: unknown; crossHostCausation?: Record<string, unknown>; replayDeterminism?: Record<string, unknown> } }>(d, 'multiAgent')?.executionModel?.crossChildMemoryConcurrency;
     if (ccmc === undefined) {
+      softSkip('inapplicable', 'optional advertisement — `multiAgent.executionModel.crossChildMemoryConcurrency` not advertised by this host');
       ctx.skip(); // optional advertisement — host hasn't opted in
-      return softSkip('blocked', 'precondition not met — `ccmc === undefined` returned early (seam, prior step, or fixture unavailable)');
+      return;
     }
     expect(
       ccmc === 'strict' || ccmc === 'advisory',
@@ -134,16 +136,18 @@ describe.skipIf(HTTP_SKIP)('multi-agent-memory-lifecycle: behavioral (RFC 0039
   it('MAE-3 replay snapshot refusal: fork mode:replay against a past-retention runId MUST return 422 replay_memory_snapshot_unavailable with documented envelope; silent substitution is non-conformant', async (ctx) => {
     const d = await readDiscovery();
     if (d === null) {
+      softSkip('blocked', 'precondition not met — `d === null` returned early (seam, prior step, or fixture unavailable)');
       ctx.skip();
-      return softSkip('blocked', 'precondition not met — `d === null` returned early (seam, prior step, or fixture unavailable)');
+      return;
     }
     const v = capabilityFamily<{ executionModel?: { [k: string]: unknown; crossHostCausation?: Record<string, unknown>; replayDeterminism?: Record<string, unknown> } }>(d, 'multiAgent')?.executionModel?.version;
     const memorySupported = capabilityFamily<{ supported?: unknown }>(d, 'memory')?.supported;
     const phase2OrLater = typeof v === 'number' && v >= 2;
     const expiredRunId = process.env.OPENWOP_TEST_EXPIRED_REPLAY_RUN_ID;
     if (!phase2OrLater || memorySupported !== true || !expiredRunId) {
+      softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!phase2OrLater || memorySupported !== true || !expiredRunId` returned early');
       ctx.skip();
-      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!phase2OrLater || memorySupported !== true || !expiredRunId` returned early');
+      return;
     }
 
     const fromSeq = 0;

package/src/scenarios/multi-region-idempotency-behavior.test.ts

@@ -31,7 +31,8 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { softSkip } from '../lib/soft-skip.js';
+import { softSkip, seamAbsent } from '../lib/soft-skip.js';
+import { capabilityFamily } from '../lib/discovery-capabilities.js';
 import { driver } from '../lib/driver.js';
 
 const HTTP_SKIP = !process.env.OPENWOP_BASE_URL;
@@ -56,6 +57,21 @@ async function simulatePartition(claims: ConflictClaim[]): Promise<{ status: num
   return { status: res.status, body: (res.json as ConvergenceResult) ?? {} };
 }
 
+/**
+ * The multi-region simulator seam answered 404. `blocked` when the host advertises
+ * a cross-region posture (`idempotency.crossRegion` present) it has made
+ * unobservable, `inapplicable` when it advertises none (RFC 0148 §A).
+ */
+async function noteSimulatorAbsent(): Promise<void> {
+  const disco = await driver.get('/.well-known/openwop');
+  const idem = capabilityFamily<{ crossRegion?: unknown }>(disco.json, 'idempotency');
+  if (idem?.crossRegion !== undefined) {
+    seamAbsent(`host advertises \`idempotency.crossRegion: ${String(idem.crossRegion)}\` but \`POST /v1/host/sample/test/multi-region/simulate-partition\` answered 404 — the convergence rule is unobservable (host-sample-test-seams.md §6)`);
+  } else {
+    softSkip('inapplicable', 'optional advertisement — `idempotency.crossRegion` not advertised by this host, and the multi-region simulator seam is absent (RFC 0036 §C)');
+  }
+}
+
 describe.skipIf(HTTP_SKIP)('multi-region-idempotency-behavior: convergence rule (RFC 0036 §C)', () => {
   it('two-region conflict resolves to the lex-min runId per annex §"Convergence rule"', async (ctx) => {
     const probe = await simulatePartition([
@@ -63,8 +79,9 @@ describe.skipIf(HTTP_SKIP)('multi-region-idempotency-behavior: convergence rule
       { runId: 'run-a-west', tenantId: 't1', endpoint: 'POST /v1/runs', key: 'idem-1', region: 'eu-west-1' },
     ]);
     if (probe.status === 404) {
+      await noteSimulatorAbsent();
       ctx.skip(); // host doesn't expose the simulator seam
-      return softSkip('blocked', 'precondition not met — `probe.status === 404` returned early (seam, prior step, or fixture unavailable)');
+      return;
     }
     expect(
       probe.status,
@@ -89,8 +106,9 @@ describe.skipIf(HTTP_SKIP)('multi-region-idempotency-behavior: convergence rule
       { runId: 'mmm-2', tenantId: 't1', endpoint: 'POST /v1/runs', key: 'idem-2', region: 'r3' },
     ]);
     if (probe.status === 404) {
+      await noteSimulatorAbsent();
       ctx.skip();
-      return softSkip('blocked', 'precondition not met — `probe.status === 404` returned early (seam, prior step, or fixture unavailable)');
+      return;
     }
     expect(probe.status).toBe(200);
     expect(
@@ -115,8 +133,9 @@ describe.skipIf(HTTP_SKIP)('multi-region-idempotency-behavior: convergence rule
       { runId: 'run-a', tenantId: 't1', endpoint: 'POST /v1/runs', key: 'idem-3', region: 'r2' },
     ]);
     if (probe.status === 404) {
+      await noteSimulatorAbsent();
       ctx.skip();
-      return softSkip('blocked', 'precondition not met — `probe.status === 404` returned early (seam, prior step, or fixture unavailable)');
+      return;
     }
     expect(probe.status).toBe(200);
     const redirects = probe.body.cacheRedirects ?? [];
@@ -144,8 +163,9 @@ describe.skipIf(HTTP_SKIP)('multi-region-idempotency-behavior: convergence rule
       { runId: 'run-a', tenantId: 't1', endpoint: 'POST /v1/runs', key: 'idem-4', region: 'r2' },
     ]);
     if (probe.status === 404) {
+      await noteSimulatorAbsent();
       ctx.skip();
-      return softSkip('blocked', 'precondition not met — `probe.status === 404` returned early (seam, prior step, or fixture unavailable)');
+      return;
     }
     expect(probe.status).toBe(200);
     expect(
@@ -165,8 +185,9 @@ describe.skipIf(HTTP_SKIP)('multi-region-idempotency-behavior: convergence rule
     ];
     const p1 = await simulatePartition(claims);
     if (p1.status === 404) {
+      await noteSimulatorAbsent();
       ctx.skip();
-      return softSkip('blocked', 'precondition not met — `p1.status === 404` returned early (seam, prior step, or fixture unavailable)');
+      return;
     }
     expect(p1.status).toBe(200);
     const p2 = await simulatePartition([claims[2]!, claims[0]!, claims[1]!]);
@@ -190,8 +211,9 @@ describe.skipIf(HTTP_SKIP)('multi-region-idempotency-behavior: convergence rule
       { runId: 'r2', tenantId: 't2', endpoint: 'POST /v1/runs', key: 'idem-6', region: 'r2' },
     ]);
     if (probe.status === 404) {
+      await noteSimulatorAbsent();
       ctx.skip();
-      return softSkip('blocked', 'precondition not met — `probe.status === 404` returned early (seam, prior step, or fixture unavailable)');
+      return;
     }
     expect(
       probe.status,

package/src/scenarios/replay-divergence-at-refusal.test.ts

@@ -78,13 +78,15 @@ describe.skipIf(HTTP_SKIP)('replay-divergence-at-refusal: advertisement shape (R
   it('replayDeterminism (when present) conforms to RFC 0041 §D', async (ctx) => {
     const d = await readDiscovery();
     if (d === null) {
+      softSkip('blocked', 'precondition not met — `d === null` returned early (seam, prior step, or fixture unavailable)');
       ctx.skip();
-      return softSkip('blocked', 'precondition not met — `d === null` returned early (seam, prior step, or fixture unavailable)');
+      return;
     }
     const rd = capabilityFamily<{ executionModel?: { [k: string]: unknown; crossHostCausation?: Record<string, unknown>; replayDeterminism?: Record<string, unknown> } }>(d, 'multiAgent')?.executionModel?.replayDeterminism;
     if (rd === undefined) {
+      softSkip('inapplicable', 'optional advertisement — `multiAgent.executionModel.replayDeterminism` not advertised by this host (RFC 0041 §D)');
       ctx.skip(); // optional advertisement — host hasn't opted in
-      return softSkip('blocked', 'precondition not met — `rd === undefined` returned early (seam, prior step, or fixture unavailable)');
+      return;
     }
 
     expect(
@@ -192,8 +194,9 @@ describe.skipIf(HTTP_SKIP)('replay-divergence-at-refusal: behavioral (RFC 0041
       { content: validEnv, stopReason: 'end_turn' as const },
     ]);
     if (programStatus === 404) {
+      softSkip('blocked', 'precondition not met — `programStatus === 404` returned early (seam, prior step, or fixture unavailable)');
       ctx.skip(); // mock-AI program seam not exposed — soft-skip
-      return softSkip('blocked', 'precondition not met — `programStatus === 404` returned early (seam, prior step, or fixture unavailable)');
+      return;
     }
     expect(programStatus).toBe(200);
 
@@ -201,8 +204,9 @@ describe.skipIf(HTTP_SKIP)('replay-divergence-at-refusal: behavioral (RFC 0041
       workflowId: 'conformance-phase4-replay-divergence',
     });
     if (createRes.status === 404 || createRes.status === 422) {
+      softSkip('blocked', 'precondition not met — `createRes.status === 404 || createRes.status === 422` returned early (seam, prior step, or fixture unavailable)');
       ctx.skip(); // fixture not advertised
-      return softSkip('blocked', 'precondition not met — `createRes.status === 404 || createRes.status === 422` returned early (seam, prior step, or fixture unavailable)');
+      return;
     }
     expect(createRes.status).toBe(201);
     const sourceRunId = (createRes.json as { runId: string }).runId;
@@ -273,8 +277,9 @@ describe.skipIf(HTTP_SKIP)('replay-divergence-at-refusal: behavioral (RFC 0041
       { content: 'safety-refused-for-conformance', stopReason: 'safety' as const, refusalText: 'safety-refused-for-conformance' },
     ]);
     if (programStatus === 404) {
+      softSkip('blocked', 'precondition not met — `programStatus === 404` returned early (seam, prior step, or fixture unavailable)');
       ctx.skip();
-      return softSkip('blocked', 'precondition not met — `programStatus === 404` returned early (seam, prior step, or fixture unavailable)');
+      return;
     }
     expect(programStatus).toBe(200);
 
@@ -282,8 +287,9 @@ describe.skipIf(HTTP_SKIP)('replay-divergence-at-refusal: behavioral (RFC 0041
       workflowId: 'conformance-phase4-replay-divergence',
     });
     if (createRes.status === 404 || createRes.status === 422) {
+      softSkip('blocked', 'precondition not met — `createRes.status === 404 || createRes.status === 422` returned early (seam, prior step, or fixture unavailable)');
       ctx.skip();
-      return softSkip('blocked', 'precondition not met — `createRes.status === 404 || createRes.status === 422` returned early (seam, prior step, or fixture unavailable)');
+      return;
     }
     expect(createRes.status).toBe(201);
     const sourceRunId = (createRes.json as { runId: string }).runId;

package/src/scenarios/replay-observable-sequence-determinism.test.ts

@@ -41,7 +41,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { softSkip } from '../lib/soft-skip.js';
+import { softSkip, seamAbsent } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 
@@ -85,6 +85,7 @@ async function gateOnPhase4(ctx: { skip: () => void }): Promise<boolean> {
   const em = capabilityFamily<{ executionModel?: ExecutionModelCaps }>(d, 'multiAgent')?.executionModel;
   const version = typeof em?.version === 'number' ? em.version : 0;
   if (em?.replayDeterminism?.supported !== true || version < 4) {
+    softSkip('inapplicable', 'optional advertisement — `multiAgent.executionModel.replayDeterminism.supported` with `version >= 4` not advertised by this host (RFC 0041 §C)');
     ctx.skip();
     return false;
   }
@@ -152,7 +153,8 @@ function stripVolatile(ev: RunEventDoc): unknown {
 async function startFixtureRun(ctx: { skip: () => void }): Promise<string | null> {
   const create = await driver.post('/v1/runs', { workflowId: FIXTURE });
   if (create.status === 404 || create.status === 422) {
-    ctx.skip(); // fixture not advertised by this host
+    seamAbsent(`fixture \`${FIXTURE}\` not registered on this host (POST /v1/runs → ${create.status}) while replayDeterminism is advertised`);
+    ctx.skip();
     return null;
   }
   expect(create.status).toBe(201);

package/src/scenarios/sandbox-mvp-behavior.test.ts

@@ -82,8 +82,9 @@ async function invoke(typeId: string, args: Record<string, unknown> = {}, allowe
 describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode invariants (node:vm MVP)', () => {
   it('host-fs-escape — fs access from sandboxed code fails closed', async (ctx) => {
     if (!(await isSandboxAdvertised())) {
+      softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
       ctx.skip();
-      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
+      return;
     }
     const probe = await invoke('misbehave.fs-escape-read');
     expect(probe.status).toBe(200);
@@ -105,8 +106,9 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
 
   it('host-env-leak — process.env access from sandboxed code fails closed', async (ctx) => {
     if (!(await isSandboxAdvertised())) {
+      softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
       ctx.skip();
-      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
+      return;
     }
     const probe = await invoke('misbehave.env-leak');
     expect(probe.status).toBe(200);
@@ -122,8 +124,9 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
 
   it('network-escape — http/net access from sandboxed code fails closed', async (ctx) => {
     if (!(await isSandboxAdvertised())) {
+      softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
       ctx.skip();
-      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
+      return;
     }
     const probe = await invoke('misbehave.network-escape');
     expect(probe.status).toBe(200);
@@ -139,8 +142,9 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
 
   it('host-process-escape — child_process access from sandboxed code fails closed', async (ctx) => {
     if (!(await isSandboxAdvertised())) {
+      softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
       ctx.skip();
-      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
+      return;
     }
     const probe = await invoke('misbehave.process-escape');
     expect(probe.status).toBe(200);
@@ -153,8 +157,9 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
 
   it('sandbox-timeout — runaway loop terminated by wallClockLimitMs', async (ctx) => {
     if (!(await isSandboxAdvertised())) {
+      softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
       ctx.skip();
-      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
+      return;
     }
     const start = Date.now();
     const probe = await invoke('misbehave.timeout');
@@ -179,8 +184,9 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
 
   it('cross-pack-mutation — fresh vm context per invocation, no state leaks', async (ctx) => {
     if (!(await isSandboxAdvertised())) {
+      softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
       ctx.skip();
-      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
+      return;
     }
     const r1 = await invoke('misbehave.cross-pack-mutate');
     const r2 = await invoke('misbehave.cross-pack-mutate');
@@ -205,8 +211,9 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
 
   it('capability-gate-respected — host call NOT in allowedHostCalls fails with sandbox_capability_denied', async (ctx) => {
     if (!(await isSandboxAdvertised())) {
+      softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
       ctx.skip();
-      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
+      return;
     }
     const probe = await invoke('misbehave.capability-gate-violation', {}, []);
     expect(probe.status).toBe(200);
@@ -228,8 +235,9 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
 
   it('memory-exceeded — runaway allocation fails with sandbox_memory_exceeded', async (ctx) => {
     if (!(await isSandboxAdvertised())) {
+      softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
       ctx.skip();
-      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
+      return;
     }
     const probe = await invoke('misbehave.memory-bomb');
     expect(probe.status).toBe(200);
@@ -255,8 +263,9 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
 
   it('well-behaved.host-fetch — allowedHostCalls=[fetch] permits the host call', async (ctx) => {
     if (!(await isSandboxAdvertised())) {
+      softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
       ctx.skip();
-      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
+      return;
     }
     const probe = await invoke('well-behaved.host-fetch', {}, ['fetch']);
     expect(probe.status).toBe(200);
@@ -271,8 +280,9 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
 
   it('well-behaved.echo — sandboxed code returns args round-trip when no escape attempt', async (ctx) => {
     if (!(await isSandboxAdvertised())) {
+      softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
       ctx.skip();
-      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
+      return;
     }
     const probe = await invoke('well-behaved.echo', { input: 'hello-sandbox' });
     expect(probe.status).toBe(200);