@openwop/openwop-conformance 1.106.1 → 1.124.0

package/src/scenarios/mcp-stateless-request.test.ts

@@ -0,0 +1,77 @@
+/**
+ * RFC 0153 §B — the host as a 2026-07-28 MCP server answers a core request
+ * with NO prior `initialize` and NO session header (invariant
+ * `mcp-header-body-consistent`, named by RFC 0153 §E — the agreement half is
+ * witnessed in `mcp-2026-07-28-discover.test.ts`).
+ *
+ * `mcp-integration.md` §B: under the current profile a host MUST NOT require
+ * `initialize` / `notifications/initialized` or any `Mcp-Session-Id` for a core
+ * request; every request self-describes in `_meta`; list results are stable per
+ * caller (not per connection) and carry `resultType` + cache hints (§D).
+ *
+ * Gate: `mcp.profiles ∋ mcp-2026-07-28` and `serverMount.supported`. A
+ * 2025-06-18 host soft-skips (`blocked`). Hard-fails under
+ * `OPENWOP_REQUIRE_BEHAVIOR=true`. Non-vacuity: the leg issues `tools/list`
+ * twice on two independent connections and asserts byte-equal tool lists —
+ * per-connection state would show up as drift.
+ *
+ * @see spec/v1/mcp-integration.md §"MCP 2026-07-28 versioned composition" §B, §D
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { behaviorGate } from '../lib/behavior-gate.js';
+import { capabilityFamily } from '../lib/discovery-capabilities.js';
+import { softSkip } from '../lib/soft-skip.js';
+
+const PROFILE = 'mcp-2026-07-28';
+const META_V = 'io.modelcontextprotocol/protocolVersion';
+const META_C = 'io.modelcontextprotocol/clientCapabilities';
+const META_I = 'io.modelcontextprotocol/clientInfo';
+
+interface McpCaps { readonly supported?: boolean; readonly profiles?: readonly string[]; readonly serverMount?: { supported?: boolean } }
+async function claimsCurrent(): Promise<boolean> {
+  const disco = await driver.get('/.well-known/openwop');
+  const caps = capabilityFamily<McpCaps>(disco.json, 'mcp');
+  return caps?.supported === true && (caps.profiles ?? []).includes(PROFILE) && caps.serverMount?.supported === true;
+}
+async function list() {
+  const res = await driver.post(
+    '/v1/host/sample/mcp',
+    { jsonrpc: '2.0', id: 1, method: 'tools/list', params: { _meta: { [META_V]: '2026-07-28', [META_C]: {}, [META_I]: { name: 'openwop-conformance', version: 'suite' } } } },
+    { headers: { 'MCP-Protocol-Version': '2026-07-28', 'Mcp-Method': 'tools/list' } },
+  );
+  return { status: res.status, body: res.json as { result?: { resultType?: string; tools?: unknown[]; ttlMs?: number; cacheScope?: string }; error?: { code: number } } };
+}
+
+describe.skipIf(!process.env.OPENWOP_BASE_URL)('RFC 0153 §B — mcp-header-body-consistent, the method/name half (host as server, gated on mcp.profiles ∋ mcp-2026-07-28)', () => {
+  it('Mcp-Method ≠ body method, and Mcp-Name ≠ params.name, are refused 400 + -32020 (HeaderMismatchError) — the same fail-closed rule as the version header', async () => {
+    if (!behaviorGate(PROFILE, await claimsCurrent())) return;
+    const meta = { [META_V]: '2026-07-28', [META_C]: {}, [META_I]: { name: 'openwop-conformance', version: 'suite' } };
+    // (a) Mcp-Method header disagrees with the JSON-RPC method
+    const m = await driver.post('/v1/host/sample/mcp', { jsonrpc: '2.0', id: 1, method: 'tools/list', params: { _meta: meta } }, { headers: { 'MCP-Protocol-Version': '2026-07-28', 'Mcp-Method': 'resources/list' } });
+    if (m.status === 404 || m.status === 403) return softSkip('blocked', `MCP server mount /v1/host/sample/mcp answered ${m.status}`);
+    expect(m.status, driver.describe('mcp-integration.md §B', 'Mcp-Method MUST equal the body method; disagreement MUST be refused 400 (mcp-header-body-consistent)')).toBe(400);
+    expect((m.json as { error?: { code?: number } }).error?.code, driver.describe('mcp-integration.md §B', 'the refusal is HeaderMismatchError -32020')).toBe(-32020);
+    // (b) Mcp-Name header disagrees with params.name on tools/call
+    const n = await driver.post('/v1/host/sample/mcp', { jsonrpc: '2.0', id: 2, method: 'tools/call', params: { name: 'echo', arguments: {}, _meta: meta } }, { headers: { 'MCP-Protocol-Version': '2026-07-28', 'Mcp-Method': 'tools/call', 'Mcp-Name': 'not-echo' } });
+    expect(n.status, driver.describe('mcp-integration.md §B', 'Mcp-Name MUST equal params.name; disagreement MUST be refused 400 (mcp-header-body-consistent)')).toBe(400);
+    expect((n.json as { error?: { code?: number } }).error?.code, driver.describe('mcp-integration.md §B', 'the refusal is HeaderMismatchError -32020')).toBe(-32020);
+  });
+});
+
+describe.skipIf(!process.env.OPENWOP_BASE_URL)('RFC 0153 §B — mcp-stateless-request (host as server, gated on mcp.profiles ∋ mcp-2026-07-28)', () => {
+  it('tools/list succeeds with no initialize and no session; result carries resultType + cache hints; two connections agree', async () => {
+    if (!behaviorGate(PROFILE, await claimsCurrent())) return;
+    const a = await list();
+    if (a.status === 404 || a.status === 403) return; // mount not at the sample path — covered by mcp-server-* legs
+    expect(a.status, driver.describe('mcp-integration.md §B', 'a core request MUST succeed without a prior initialize or a session header')).toBe(200);
+    expect(a.body.error, driver.describe('mcp-integration.md §B', `stateless tools/list MUST NOT error: ${JSON.stringify(a.body.error)}`)).toBeUndefined();
+    expect(a.body.result?.resultType, driver.describe('mcp-integration.md §B', 'every current-revision result carries resultType')).toBe('complete');
+    expect(typeof a.body.result?.ttlMs, driver.describe('mcp-integration.md §D', 'tools/list MUST carry ttlMs (>= 0)')).toBe('number');
+    expect((a.body.result?.ttlMs ?? -1) >= 0).toBe(true);
+    expect(['public', 'private'], driver.describe('mcp-integration.md §D', 'cacheScope MUST be public|private')).toContain(a.body.result?.cacheScope);
+    const b = await list();
+    expect(JSON.stringify(b.body.result?.tools), driver.describe('mcp-integration.md §B', 'list results MUST NOT vary per connection — two independent requests from the same caller MUST agree')).toBe(JSON.stringify(a.body.result?.tools));
+  });
+});

package/src/scenarios/mcp-tool-roundtrip.test.ts

@@ -61,6 +61,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { getMcpFakeServer } from '../lib/mcp-fake-server.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
@@ -186,7 +187,7 @@ describe('mcp-tool-roundtrip: server wire shape', () => {
         '[mcp-tool-roundtrip] no MCP endpoint configured; set OPENWOP_MCP_FAKE_SERVER=true ' +
           'or OPENWOP_MCP_REAL_SERVER_URL=<base-url>',
       );
-      return;
+      return softSkip('blocked', 'precondition not met — `!probe` returned early (seam, prior step, or fixture unavailable)');
     }
     if (!probe.isReal) getMcpFakeServer()!.reset();
 
@@ -282,14 +283,14 @@ describe('mcp-tool-roundtrip: host-mediated tool invocation', () => {
     if (!server) {
       // eslint-disable-next-line no-console
       console.warn('[mcp-tool-roundtrip] fake server not started; skipping host-mediated test');
-      return;
+      return softSkip('blocked', '[mcp-tool-roundtrip] fake server not started; skipping host-mediated test');
     }
     if (!isFixtureAdvertised(ROUNDTRIP_FIXTURE)) {
       // eslint-disable-next-line no-console
       console.warn(
         `[mcp-tool-roundtrip] fixture ${ROUNDTRIP_FIXTURE} not advertised; skipping`,
       );
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(ROUNDTRIP_FIXTURE)` returned early');
     }
 
     server.reset();

package/src/scenarios/mcp-toolcall-redaction.test.ts

@@ -20,6 +20,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 
@@ -35,7 +36,7 @@ describe('mcp-toolcall-redaction: capability advertisement contract', () => {
     if (!(await isMcpClientSupported())) {
       // eslint-disable-next-line no-console
       console.warn('[mcp-toolcall-redaction] host does not advertise mcpClient; skipping');
-      return;
+      return softSkip('inapplicable', '[mcp-toolcall-redaction] host does not advertise mcpClient; skipping');
     }
     const disco = await driver.get('/.well-known/openwop');
     const cap = capabilityFamily((disco.json as {

package/src/scenarios/memory-attribution-emits-on-write.test.ts

@@ -9,6 +9,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { readMemoryAttributionCap, emitsWriteEvents, seedRun, memoryWrittenEvents } from '../lib/memoryAttribution.js';
@@ -16,16 +17,16 @@ import { readMemoryAttributionCap, emitsWriteEvents, seedRun, memoryWrittenEvent
 describe('memory-attribution-emits-on-write (RFC 0057 §A/§B)', () => {
   it('an advertised host emits memory.written carrying a stable memoryId', async () => {
     const cap = await readMemoryAttributionCap();
-    if (!emitsWriteEvents(cap)) return;
+    if (!emitsWriteEvents(cap)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!emitsWriteEvents(cap)` returned early');
     const runId = await seedRun('mem-attr-emit');
-    if (!runId) return;
+    if (!runId) return softSkip('blocked', 'precondition not met — `!runId` returned early (seam, prior step, or fixture unavailable)');
     try {
       await pollUntilTerminal(runId, { timeoutMs: 10_000 });
     } catch {
       return;
     }
     const events = await memoryWrittenEvents(runId);
-    if (events.length === 0) return; // run wrote no memory — soft-skip
+    if (events.length === 0) return softSkip('blocked', 'run wrote no memory — soft-skip (events.length === 0)');
     for (const e of events) {
       const memoryId = (e.payload as { memoryId?: unknown } | undefined)?.memoryId;
       expect(
@@ -37,9 +38,9 @@ describe('memory-attribution-emits-on-write (RFC 0057 §A/§B)', () => {
 
   it('a host without the capability emits no memory.written', async () => {
     const cap = await readMemoryAttributionCap();
-    if (emitsWriteEvents(cap)) return; // advertised — N/A
+    if (emitsWriteEvents(cap)) return softSkip('inapplicable', 'advertised — N/A');
     const runId = await seedRun('mem-attr-absent');
-    if (!runId) return;
+    if (!runId) return softSkip('blocked', 'precondition not met — `!runId` returned early (seam, prior step, or fixture unavailable)');
     try {
       await pollUntilTerminal(runId, { timeoutMs: 10_000 });
     } catch {

package/src/scenarios/memory-attribution-no-content.test.ts

@@ -12,6 +12,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { readMemoryAttributionCap, emitsWriteEvents, seedRun, memoryWrittenEvents } from '../lib/memoryAttribution.js';
@@ -19,16 +20,16 @@ import { readMemoryAttributionCap, emitsWriteEvents, seedRun, memoryWrittenEvent
 describe('memory-attribution-no-content (RFC 0057 §C)', () => {
   it('memory.written payloads carry no entry content', async () => {
     const cap = await readMemoryAttributionCap();
-    if (!emitsWriteEvents(cap)) return;
+    if (!emitsWriteEvents(cap)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!emitsWriteEvents(cap)` returned early');
     const runId = await seedRun('mem-attr-no-content');
-    if (!runId) return;
+    if (!runId) return softSkip('blocked', 'precondition not met — `!runId` returned early (seam, prior step, or fixture unavailable)');
     try {
       await pollUntilTerminal(runId, { timeoutMs: 10_000 });
     } catch {
       return;
     }
     const events = await memoryWrittenEvents(runId);
-    if (events.length === 0) return; // run wrote no memory — soft-skip
+    if (events.length === 0) return softSkip('blocked', 'run wrote no memory — soft-skip (events.length === 0)');
     for (const e of events) {
       const payload = e.payload ?? {};
       expect(

package/src/scenarios/memory-attribution-replay-stable.test.ts

@@ -14,6 +14,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { readMemoryAttributionCap, emitsWriteEvents, seedRun, memoryWrittenEvents } from '../lib/memoryAttribution.js';
@@ -26,22 +27,22 @@ function memoryIdOf(payload: Record<string, unknown> | undefined): string | null
 describe('memory-attribution-replay-stable (RFC 0057 §D)', () => {
   it('a replay-mode fork introduces no memory.written with a new memoryId', async () => {
     const cap = await readMemoryAttributionCap();
-    if (!emitsWriteEvents(cap)) return;
+    if (!emitsWriteEvents(cap)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!emitsWriteEvents(cap)` returned early');
     const runId = await seedRun('mem-attr-replay');
-    if (!runId) return;
+    if (!runId) return softSkip('blocked', 'precondition not met — `!runId` returned early (seam, prior step, or fixture unavailable)');
     try {
       await pollUntilTerminal(runId, { timeoutMs: 10_000 });
     } catch {
       return;
     }
     const original = await memoryWrittenEvents(runId);
-    if (original.length === 0) return; // run wrote no memory — nothing to test
+    if (original.length === 0) return softSkip('blocked', 'run wrote no memory — nothing to test');
     const recordedIds = new Set(original.map((e) => memoryIdOf(e.payload)).filter((x): x is string => x !== null));
 
     const fork = await driver.post(`/v1/runs/${runId}:fork`, { fromSeq: 0, mode: 'replay' });
-    if (fork.status !== 200 && fork.status !== 201) return; // replay fork unsupported — soft-skip
+    if (fork.status !== 200 && fork.status !== 201) return softSkip('inapplicable', 'replay fork unsupported — soft-skip (fork.status !== 200 && fork.status !== 201)');
     const forkId = (fork.json as { runId?: string } | undefined)?.runId;
-    if (!forkId) return;
+    if (!forkId) return softSkip('blocked', 'precondition not met — `!forkId` returned early (seam, prior step, or fixture unavailable)');
     try {
       await pollUntilTerminal(forkId, { timeoutMs: 10_000 });
     } catch {

package/src/scenarios/memory-attribution-tenant-scoped.test.ts

@@ -13,6 +13,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { readMemoryAttributionCap, emitsWriteEvents, seedRun, memoryWrittenEvents } from '../lib/memoryAttribution.js';
@@ -20,16 +21,16 @@ import { readMemoryAttributionCap, emitsWriteEvents, seedRun, memoryWrittenEvent
 describe('memory-attribution-tenant-scoped (RFC 0057 §C)', () => {
   it("a run's memory.written events appear only on that run's stream", async () => {
     const cap = await readMemoryAttributionCap();
-    if (!emitsWriteEvents(cap)) return;
+    if (!emitsWriteEvents(cap)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!emitsWriteEvents(cap)` returned early');
     const runId = await seedRun('mem-attr-cti');
-    if (!runId) return;
+    if (!runId) return softSkip('blocked', 'precondition not met — `!runId` returned early (seam, prior step, or fixture unavailable)');
     try {
       await pollUntilTerminal(runId, { timeoutMs: 10_000 });
     } catch {
       return;
     }
     const events = await memoryWrittenEvents(runId);
-    if (events.length === 0) return;
+    if (events.length === 0) return softSkip('blocked', 'precondition not met — `events.length === 0` returned early (seam, prior step, or fixture unavailable)');
     // Every memory.written we read came from THIS run's /events stream; if the
     // host echoes a runId in the event it MUST be this run's (no cross-run leak).
     for (const e of events) {

package/src/scenarios/memory-compaction-event-emitted.test.ts

@@ -25,6 +25,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 
@@ -50,12 +51,12 @@ describe('memory-compaction-event-emitted: canonical memory.compacted payload sh
     if (!(await isCompactionAdvertised())) {
       // eslint-disable-next-line no-console
       console.warn('[rfc0012-event] capabilities.memory.compaction.supported not advertised; skipping');
-      return;
+      return softSkip('inapplicable', '[rfc0012-event] capabilities.memory.compaction.supported not advertised; skipping');
     }
     if (!(await isTestSeamReachable())) {
       // eslint-disable-next-line no-console
       console.warn('[rfc0012-event] test seam unreachable; skipping');
-      return;
+      return softSkip('blocked', '[rfc0012-event] test seam unreachable; skipping');
     }
 
     const seed = await driver.post('/v1/test/memory/seed', {

package/src/scenarios/memory-compaction-provenance-tag.test.ts

@@ -19,6 +19,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 
@@ -49,12 +50,12 @@ describe('memory-compaction-provenance-tag: compacted-from:<id> tag follows §C
     if (!(await isCompactionAdvertised())) {
       // eslint-disable-next-line no-console
       console.warn('[rfc0012-tag] capabilities.memory.compaction.supported not advertised; skipping');
-      return;
+      return softSkip('inapplicable', '[rfc0012-tag] capabilities.memory.compaction.supported not advertised; skipping');
     }
     if (!(await isTestSeamReachable())) {
       // eslint-disable-next-line no-console
       console.warn('[rfc0012-tag] test seam unreachable; skipping');
-      return;
+      return softSkip('blocked', '[rfc0012-tag] test seam unreachable; skipping');
     }
 
     // Seed + compact.
@@ -88,7 +89,7 @@ describe('memory-compaction-provenance-tag: compacted-from:<id> tag follows §C
     if (listRes.status === 404) {
       // eslint-disable-next-line no-console
       console.warn('[rfc0012-tag] host does not expose memory:list at /v1/memory/{ref}; skipping tag inspection (canonical provenance signal remains the memory.compacted event itself)');
-      return;
+      return softSkip('blocked', '[rfc0012-tag] host does not expose memory:list at /v1/memory/{ref}; skipping tag inspection (canonical provenance signal remains the memory.compacted event itself)');
     }
     expect(listRes.status, 'memory:list MUST return 200 when reachable').toBe(200);
 
@@ -98,7 +99,7 @@ describe('memory-compaction-provenance-tag: compacted-from:<id> tag follows §C
     if (!output) {
       // eslint-disable-next-line no-console
       console.warn(`[rfc0012-tag] outputId ${outputId} not visible via memory:list; cannot inspect tags`);
-      return;
+      return softSkip('blocked', '[rfc0012-tag] outputId … not visible via memory:list; cannot inspect tags');
     }
     const tags = output.tags ?? [];
 
@@ -107,7 +108,7 @@ describe('memory-compaction-provenance-tag: compacted-from:<id> tag follows §C
     if (provenance === undefined) {
       // eslint-disable-next-line no-console
       console.warn('[rfc0012-tag] output entry has no compacted-from:<id> tag — RFC 0012 §C is SHOULD, not MUST; pass with warning');
-      return;
+      return softSkip('inapplicable', '[rfc0012-tag] output entry has no compacted-from:<id> tag — RFC 0012 §C is SHOULD, not MUST; pass with warning');
     }
     expect(provenance, driver.describe(
       'RFC 0012 §C',

package/src/scenarios/memory-compaction-sr1-carry-forward.test.ts

@@ -27,6 +27,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 
@@ -54,12 +55,12 @@ describe('memory-compaction-sr1-carry-forward: derived content passes the BYOK r
     if (!(await isCompactionAdvertised())) {
       // eslint-disable-next-line no-console
       console.warn('[rfc0012-sr1] capabilities.memory.compaction.supported not advertised; skipping');
-      return;
+      return softSkip('inapplicable', '[rfc0012-sr1] capabilities.memory.compaction.supported not advertised; skipping');
     }
     if (!(await isTestSeamReachable())) {
       // eslint-disable-next-line no-console
       console.warn('[rfc0012-sr1] test seam /v1/test/memory/compact unreachable; skipping (set host\'s OPENWOP_TEST_TRIGGER_COMPACTION=true)');
-      return;
+      return softSkip('blocked', '[rfc0012-sr1] test seam /v1/test/memory/compact unreachable; skipping (set host\'s OPENWOP_TEST_TRIGGER_COMPACTION=true)');
     }
 
     // 1. Seed source entries containing:
@@ -99,7 +100,7 @@ describe('memory-compaction-sr1-carry-forward: derived content passes the BYOK r
     if (typeof event.outputContent !== 'string') {
       // eslint-disable-next-line no-console
       console.warn('[rfc0012-sr1] test seam did not return outputContent; the wire-level memory.compacted shape does not surface content so without a host-side seam we cannot verify §D end-to-end. Skipping.');
-      return;
+      return softSkip('blocked', '[rfc0012-sr1] test seam did not return outputContent; the wire-level memory.compacted shape does not surface content so without a host-side seam we cannot verify §D end-to-end. Skipping.');
     }
 
     // The load-bearing assertion: the PERSISTED entry content (what

package/src/scenarios/memory-consolidation-idempotent.test.ts

@@ -22,6 +22,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 
 interface ConsolidationCaps {
@@ -41,13 +42,13 @@ async function consolidationSupported(): Promise<boolean> {
 
 describe('memory-consolidation-idempotent: pass contract (RFC 0068 §D, capability-gated)', () => {
   it('a consolidation pass reduces or holds entry count and is idempotent on a stable corpus', async () => {
-    if (!(await consolidationSupported())) return; // capability absent — gated skip
+    if (!(await consolidationSupported())) return softSkip('inapplicable', 'capability absent — gated skip');
 
     const first = await driver.post('/v1/host/sample/memory/consolidate', {
       memoryRef: 'mem://conformance/consolidation',
       includeSecretCanary: true,
     });
-    if (first.status === 404 || first.status === 501) return; // seam not wired — soft-skip
+    if (first.status === 404 || first.status === 501) return softSkip('blocked', 'seam not wired — soft-skip');
 
     expect(first.status, driver.describe('RFC 0068 §D', 'an advertised consolidation seam MUST succeed')).toBe(200);
     const r1 = first.json as ConsolidateResult;
@@ -59,7 +60,7 @@ describe('memory-consolidation-idempotent: pass contract (RFC 0068 §D, capabili
     const second = await driver.post('/v1/host/sample/memory/consolidate', {
       memoryRef: 'mem://conformance/consolidation',
     });
-    if (second.status === 404 || second.status === 501) return;
+    if (second.status === 404 || second.status === 501) return softSkip('blocked', 'precondition not met — `second.status === 404 || second.status === 501` returned early (seam, prior step, or fixture unavailable)');
     const r2 = second.json as ConsolidateResult;
     expect(
       r2.event?.inputCount,

package/src/scenarios/memory-injection-budget.test.ts

@@ -28,6 +28,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
@@ -110,7 +111,7 @@ describe('memory-injection-budget (RFC 0113)', () => {
   it('token-bounds the injection read, omits the over-budget entry, and preserves SR-1 + CTI-1', async () => {
     const mem = await readCapabilityFamily<MemoryCap>('memory');
     if (!behaviorGate(PROFILE, mem?.injectionBudget?.supported === true)) return;
-    if (!isFixtureAdvertised(FIXTURE)) return; // fixture-gated soft-skip
+    if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', `host does not advertise the ${FIXTURE} conformance fixture`);
 
     const v = await driveFixtureVariables();
     expect(v, 'fixture MUST surface run variables').toBeDefined();
@@ -169,9 +170,9 @@ describe('memory-injection-budget (RFC 0113)', () => {
     if (!advertisesSemanticSearch(mem)) {
       // eslint-disable-next-line no-console
       console.warn(`[${PROFILE}] memory.search semantic not advertised; relevance leg soft-skipped`);
-      return;
+      return softSkip('inapplicable', 'host does not advertise memory.search semantic ranking — the relevance leg does not apply');
     }
-    if (!isFixtureAdvertised(FIXTURE)) return;
+    if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', `host does not advertise the ${FIXTURE} conformance fixture`);
 
     const v = await driveFixtureVariables();
     expect(v, 'fixture MUST surface run variables').toBeDefined();

package/src/scenarios/metric-emission.test.ts

@@ -19,6 +19,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
@@ -69,7 +70,7 @@ describe('metric-emission: canonical openwop.* metrics arrive at the collector',
       console.warn(
         '[metric-emission] collector not started; set OPENWOP_OTEL_COLLECTOR=true to run',
       );
-      return;
+      return softSkip('blocked', 'precondition not met — `!getCollector()` returned early (seam, prior step, or fixture unavailable)');
     }
     const metricsCaps = await metricsAdvertised();
     if (!metricsCaps?.supported) {
@@ -77,12 +78,12 @@ describe('metric-emission: canonical openwop.* metrics arrive at the collector',
       console.warn(
         '[metric-emission] host does not advertise observability.metrics.supported; skipping',
       );
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!metricsCaps?.supported` returned early');
     }
     if (!isFixtureAdvertised(FIXTURE)) {
       // eslint-disable-next-line no-console
       console.warn(`[metric-emission] ${FIXTURE} not advertised; skipping`);
-      return;
+      return softSkip('inapplicable', '[metric-emission] … not advertised; skipping');
     }
 
     const collector = getCollector()!;

package/src/scenarios/multi-agent-confidence-escalation.test.ts

@@ -47,6 +47,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { pollUntil } from '../lib/polling.js';
@@ -84,11 +85,11 @@ async function readDiscovery(): Promise<DiscoveryDoc | null> {
 describe.skipIf(HTTP_SKIP)('multi-agent-confidence-escalation: capability shape (RFC 0039 §A)', () => {
   it('confidenceEscalationFloor (when advertised) MUST be in [0.5, 1.0]', async () => {
     const d = await readDiscovery();
-    if (d === null) return;
+    if (d === null) return softSkip('blocked', 'precondition not met — `d === null` returned early (seam, prior step, or fixture unavailable)');
     const em = capabilityFamily<{ executionModel?: { [k: string]: unknown; crossHostCausation?: Record<string, unknown>; replayDeterminism?: Record<string, unknown> } }>(d, 'multiAgent')?.executionModel;
-    if (em === undefined) return;
+    if (em === undefined) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `em === undefined` returned early');
     const floor = em.confidenceEscalationFloor;
-    if (floor === undefined) return;
+    if (floor === undefined) return softSkip('blocked', 'precondition not met — `floor === undefined` returned early (seam, prior step, or fixture unavailable)');
     expect(
       typeof floor === 'number' && Number.isFinite(floor) && floor >= 0.5 && floor <= 1.0,
       driver.describe(
@@ -105,7 +106,7 @@ describe.skipIf(BEHAVIORAL_SKIP)('multi-agent-confidence-escalation: behavioral
     const supported = capabilityFamily<{ executionModel?: { [k: string]: unknown; crossHostCausation?: Record<string, unknown>; replayDeterminism?: Record<string, unknown> } }>(d, 'multiAgent')?.executionModel?.supported === true;
     const versionRaw = capabilityFamily<{ executionModel?: { [k: string]: unknown; crossHostCausation?: Record<string, unknown>; replayDeterminism?: Record<string, unknown> } }>(d, 'multiAgent')?.executionModel?.version;
     const version = typeof versionRaw === 'number' ? versionRaw : 0;
-    if (!supported || version < 2) return; // soft-skip — `version: 1` hosts pass via this absence
+    if (!supported || version < 2) return softSkip('inapplicable', 'soft-skip — `version: 1` hosts pass via this absence (!supported || version < 2)');
 
     const create = await driver.post('/v1/runs', { workflowId: FIXTURE });
     expect(create.status).toBe(201);

package/src/scenarios/multi-agent-handoff-state-machine.test.ts

@@ -31,6 +31,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { pollUntilTerminal } from '../lib/polling.js';
@@ -62,9 +63,9 @@ async function readDiscovery(): Promise<DiscoveryDoc | null> {
 describe.skipIf(HTTP_SKIP)('multi-agent-handoff-state-machine: advertisement shape (RFC 0037 §C)', () => {
   it('capabilities.multiAgent.executionModel (when present) conforms to RFC 0037 §C', async () => {
     const d = await readDiscovery();
-    if (d === null) return; // discovery unavailable — skip
+    if (d === null) return softSkip('blocked', 'discovery unavailable — skip (d === null)');
     const executionModel = capabilityFamily<{ executionModel?: { [k: string]: unknown; crossHostCausation?: Record<string, unknown>; replayDeterminism?: Record<string, unknown> } }>(d, 'multiAgent')?.executionModel;
-    if (executionModel === undefined) return; // host doesn't advertise — soft-skip
+    if (executionModel === undefined) return softSkip('inapplicable', 'host doesn\'t advertise — soft-skip');
     expect(
       typeof executionModel.supported,
       driver.describe(
@@ -106,7 +107,7 @@ describe.skipIf(BEHAVIORAL_SKIP)('multi-agent-handoff-state-machine: behavioral
   it('happy-path: dispatch.began → dispatch.succeeded → child.completed → output.harvested fire in causation order', async () => {
     const d = await readDiscovery();
     const advertised = capabilityFamily<{ executionModel?: { [k: string]: unknown; crossHostCausation?: Record<string, unknown>; replayDeterminism?: Record<string, unknown> } }>(d, 'multiAgent')?.executionModel?.supported === true;
-    if (!advertised) return; // soft-skip — host honest about not implementing
+    if (!advertised) return softSkip('inapplicable', 'soft-skip — host honest about not implementing');
 
     const create = await driver.post('/v1/runs', { workflowId: PARENT_FIXTURE });
     expect(create.status).toBe(201);

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

@@ -47,6 +47,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 
@@ -80,12 +81,12 @@ describe.skipIf(HTTP_SKIP)('multi-agent-memory-lifecycle: advertisement shape (R
     const d = await readDiscovery();
     if (d === null) {
       ctx.skip();
-      return;
+      return softSkip('blocked', 'precondition not met — `d === null` returned early (seam, prior step, or fixture unavailable)');
     }
     const ccmc = capabilityFamily<{ executionModel?: { [k: string]: unknown; crossHostCausation?: Record<string, unknown>; replayDeterminism?: Record<string, unknown> } }>(d, 'multiAgent')?.executionModel?.crossChildMemoryConcurrency;
     if (ccmc === undefined) {
       ctx.skip(); // optional advertisement — host hasn't opted in
-      return;
+      return softSkip('blocked', 'precondition not met — `ccmc === undefined` returned early (seam, prior step, or fixture unavailable)');
     }
     expect(
       ccmc === 'strict' || ccmc === 'advisory',
@@ -134,7 +135,7 @@ describe.skipIf(HTTP_SKIP)('multi-agent-memory-lifecycle: behavioral (RFC 0039
     const d = await readDiscovery();
     if (d === null) {
       ctx.skip();
-      return;
+      return softSkip('blocked', 'precondition not met — `d === null` returned early (seam, prior step, or fixture unavailable)');
     }
     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;
@@ -142,7 +143,7 @@ describe.skipIf(HTTP_SKIP)('multi-agent-memory-lifecycle: behavioral (RFC 0039
     const expiredRunId = process.env.OPENWOP_TEST_EXPIRED_REPLAY_RUN_ID;
     if (!phase2OrLater || memorySupported !== true || !expiredRunId) {
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!phase2OrLater || memorySupported !== true || !expiredRunId` returned early');
     }
 
     const fromSeq = 0;

package/src/scenarios/multi-party-conversation-behavioral.test.ts

@@ -38,6 +38,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { seamAbsent } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { isMultiPartyConversationSupported } from '../lib/multi-agent-capabilities.js';
@@ -80,7 +81,7 @@ describe('multi-party-conversation-behavioral (RFC 0101 §Conformance)', () => {
     // ---- Open a 3-agent council via the conformance seam ------------------
     const convId = 'conf:multi-party:council-q1';
     const opened = await openMultiPartyConversation({ conversationId: convId, participants: ROSTER });
-    if (opened.unwired) return; // seam not wired on this host — soft-skip the behavioral leg
+    if (opened.unwired) return seamAbsent('host advertises multiPartyConversation but the open-conversation seam is not wired');
     expect(
       opened.status === 200,
       driver.describe('RFC 0101 §Spec', 'a conforming 3-agent council MUST open (≤ maxParticipants)'),
@@ -88,7 +89,7 @@ describe('multi-party-conversation-behavioral (RFC 0101 §Conformance)', () => {
 
     // ---- MUST 1: POSITIVE — a roster-valid attributed turn is accepted ----
     const ok = await exchangeMultiPartyTurn({ conversationId: convId, turn: agentTurn('host:advisor-cfo', 1) });
-    if (ok.unwired) return;
+    if (ok.unwired) return seamAbsent('host advertises multiPartyConversation but the conversation seam is not wired');
     expect(
       ok.status === 200,
       driver.describe('RFC 0101 §Spec', "a role:'agent' turn with an in-roster speakerId MUST be accepted"),