@openwop/openwop-conformance 2.42.5 → 2.42.7

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

@@ -31,7 +31,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { softSkip, seamAbsent } from '../lib/soft-skip.js';
+import { softSkip, seamAbsent, seamAbsentDespiteAssertions } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { mcpServerMount } from '../lib/mcp-mount.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
@@ -72,19 +72,20 @@ describe.skipIf(!process.env.OPENWOP_BASE_URL)('RFC 0153 §C — mcp-mrtr-roundt
     const calls = server.invocations().filter((i) => i.method === 'tools/call');
     expect(calls.length, req('openwop.it.mcp-mrtr-roundtrip.input-required-gather-retry-with-inputresponses-echoed-requeststate-as-one-logic', 'RFCS/0153 §C', 'the host MUST have called the tool at least once for this leg to mean anything')).toBeGreaterThan(0);
     const mrtr = (drive.json as { mrtr?: { inputRequiredSeen?: boolean; retried?: boolean; requestStateEchoed?: boolean; result?: unknown } }).mrtr;
-    if (mrtr === undefined) {
-      expect(mrtr, req('openwop.it.mcp-mrtr-roundtrip.input-required-gather-retry-with-inputresponses-echoed-requeststate-as-one-logic', 'host-sample-test-seams.md §23', 'the invoke seam SHOULD report `mrtr: { inputRequiredSeen, retried, requestStateEchoed, result }` for tool "needs_input"; until it does this requirement is unobservable and resolves to `blocked`')).toBeDefined();
-      return softSkip('blocked', 'precondition not met — `mrtr === undefined` returned early (seam, prior step, or fixture unavailable)');
+    // `mrtr` is an OPTIONAL seam field (host-sample-test-seams.md §23). A host that omits
+    // it is not violating anything: the retry is still witnessed on the wire below, and
+    // only the seam's own report is skipped. A report that IS present is held to it.
+    if (mrtr !== undefined) {
+      expect(mrtr.inputRequiredSeen, req('openwop.it.mcp-mrtr-roundtrip.input-required-gather-retry-with-inputresponses-echoed-requeststate-as-one-logic', 'mcp-integration.md §C.1', 'the host MUST recognise resultType input_required')).toBe(true);
+      expect(mrtr.retried, req('openwop.it.mcp-mrtr-roundtrip.input-required-gather-retry-with-inputresponses-echoed-requeststate-as-one-logic', 'mcp-integration.md §C.1', 'the host MUST retry the ORIGINAL request with inputResponses (a live callback is not the current profile)')).toBe(true);
     }
-    expect(mrtr.inputRequiredSeen, req('openwop.it.mcp-mrtr-roundtrip.input-required-gather-retry-with-inputresponses-echoed-requeststate-as-one-logic', 'mcp-integration.md §C.1', 'the host MUST recognise resultType input_required')).toBe(true);
-    expect(mrtr.retried, req('openwop.it.mcp-mrtr-roundtrip.input-required-gather-retry-with-inputresponses-echoed-requeststate-as-one-logic', 'mcp-integration.md §C.1', 'the host MUST retry the ORIGINAL request with inputResponses (a live callback is not the current profile)')).toBe(true);
     // Cross-check from the wire: two tools/call, second carries requestState identical to what the server issued.
     expect(calls.length, req('openwop.it.mcp-mrtr-roundtrip.input-required-gather-retry-with-inputresponses-echoed-requeststate-as-one-logic', 'mcp-integration.md §C.1', 'initial + retry = two independent JSON-RPC requests on the wire')).toBeGreaterThanOrEqual(2);
     const retry = calls[calls.length - 1]!.params as { requestState?: string; inputResponses?: Record<string, unknown> };
     expect(typeof retry.requestState, req('openwop.it.mcp-mrtr-roundtrip.input-required-gather-retry-with-inputresponses-echoed-requeststate-as-one-logic', 'mcp-integration.md §C.1', 'requestState MUST be echoed exactly on the retry')).toBe('string');
     expect(retry.requestState?.startsWith('mrtr:needs_input:'), req('openwop.it.mcp-mrtr-roundtrip.input-required-gather-retry-with-inputresponses-echoed-requeststate-as-one-logic', 'mcp-integration.md §C.1', 'the echoed requestState is the value the server issued, byte-exact')).toBe(true);
     expect(retry.inputResponses?.['who'], req('openwop.it.mcp-mrtr-roundtrip.input-required-gather-retry-with-inputresponses-echoed-requeststate-as-one-logic', 'mcp-integration.md §C.1', 'inputResponses MUST answer every requested key')).toBeDefined();
-    expect(mrtr.requestStateEchoed).toBe(true);
+    if (mrtr !== undefined) expect(mrtr.requestStateEchoed).toBe(true);
     for (const c of calls) {
       expect(c.revision, req('openwop.it.mcp-mrtr-roundtrip.input-required-gather-retry-with-inputresponses-echoed-requeststate-as-one-logic', 'mcp-integration.md §B', 'both calls MUST carry the current revision')).toBe('2026-07-28');
     }
@@ -123,7 +124,7 @@ describe.skipIf(!process.env.OPENWOP_BASE_URL)('RFC 0153 §C — mcp-mrtr-roundt
     expect(reg.status, req('openwop.it.mcp-mrtr-roundtrip.a-suspending-tool-answers-input-required-with-elicitation-requeststate-the-retry', 'host-sample-test-seams.md §"sample workflows"', `the registration fixture MUST be accepted; a 4xx means the fixture this leg posts is malformed (suite defect): ${JSON.stringify(reg.json).slice(0, 200)}`)).toBeLessThan(400);
     const hdr = { 'MCP-Protocol-Version': '2026-07-28', 'Mcp-Method': 'tools/call', 'Mcp-Name': TOOL };
     const first = await driver.post(await mcpServerMount(), { jsonrpc: '2.0', id: 1, method: 'tools/call', params: { name: TOOL, arguments: {}, _meta: { [META_V]: '2026-07-28', [META_C]: { elicitation: {} } } } }, { headers: hdr });
-    if (first.status === 404) return seamAbsent('host advertises an MCP server mount but /v1/host/sample/mcp answered 404');
+    if (first.status === 404) return seamAbsentDespiteAssertions('host advertises an MCP server mount but /v1/host/sample/mcp answered 404 after the tool registered');
     const r1 = first.json as { result?: { resultType?: string; inputRequests?: Record<string, { method?: string }>; requestState?: string }; error?: { code: number } };
     expect(r1.error, req('openwop.it.mcp-mrtr-roundtrip.a-suspending-tool-answers-input-required-with-elicitation-requeststate-the-retry', 'mcp-integration.md §C.2', `tools/call MUST NOT error: ${JSON.stringify(r1.error)}`)).toBeUndefined();
     expect(r1.result?.resultType, req('openwop.it.mcp-mrtr-roundtrip.a-suspending-tool-answers-input-required-with-elicitation-requeststate-the-retry', 'mcp-integration.md §C.2', 'a run reaching waiting-input MUST answer the in-flight tools/call with resultType input_required (not a live callback)')).toBe('input_required');

package/src/scenarios/mcp-version-negotiation.test.ts

@@ -88,16 +88,11 @@ describe('RFC 0153 §A/§B — MCP revision negotiation', () => {
     server.reset();
     const drive = await driver.post('/v1/host/sample/mcp/invoke', { serverUrl: server.hostFacingEndpoint() });
     if (drive.status === 404 || drive.status === 403) {
-      expect(
-        drive.status,
-        req('openwop.it.mcp-version-negotiation.outbound-calls-carry-mcp-protocol-version-in-date-form', 
-          'RFCS/0153 §B',
-          'a host advertising MCP revisions MUST expose an invoke seam so the negotiated revision ' +
-            'is observable. Without it the requirement resolves to `blocked` per RFC 0148 §A — not ' +
-            'to a pass.',
-        ),
-      ).not.toBe(404);
-      return softSkip('blocked', 'precondition not met — `drive.status === 404 || drive.status === 403` returned early (seam, prior step, or fixture unavailable)');
+      // A host advertising MCP revisions MUST expose the invoke seam so the negotiated
+      // version is observable. Default mode records `blocked` (RFC 0148 §A); strict mode
+      // fails (RFC 0148 §B). This was a not-404 assert followed by a blocked note, so a 403
+      // recorded a partial-witness pass at major 1.
+      return seamAbsent(`host advertises MCP revisions but the invoke seam /v1/host/sample/mcp/invoke answered ${drive.status}`);
     }
     const calls = server.invocations();
     expect(calls.length, req('openwop.it.mcp-version-negotiation.outbound-calls-carry-mcp-protocol-version-in-date-form', 'RFCS/0153 §B', 'the host MUST have called the server')).toBeGreaterThan(0);

package/src/scenarios/media-url-inline-cap.test.ts

@@ -148,7 +148,7 @@ describe.skipIf(HTTP_SKIP)('media-url-inline-cap: advertisement shape (RFC 0055
     const runIds = ((runs.json as { runs?: { runId?: string }[] }).runs ?? [])
       .map((r) => r.runId)
       .filter((id): id is string => typeof id === 'string');
-    for (const runId of runIds) {
+    runs: for (const runId of runIds) {
       const bundle = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/debug-bundle`);
       if (bundle.status !== 200) continue;
       const events = (bundle.json as { events?: { type?: string; payload?: { url?: unknown; base64?: unknown } }[] }).events ?? [];
@@ -159,7 +159,8 @@ describe.skipIf(HTTP_SKIP)('media-url-inline-cap: advertisement shape (RFC 0055
             typeof ev.payload?.url === 'string' && ev.payload?.base64 === undefined,
             req('openwop.it.media-url-inline-cap.a-media-payload-in-a-run-debug-bundle-is-referenced-by-url-not-inlined-rfc-0055', 'ai-envelope.md §"Media reference payloads"', 'a media.* payload in a debug bundle MUST be a URL reference, never inlined binary'),
           ).toBe(true);
-          return softSkip('blocked', 'precondition not met — `typeof ev.type === \'string\' && ev.type.startsWith(\'media.\')` returned early (asserted one — contract proven) (seam, prior step, or fixture unavailable)'); // asserted one — contract proven
+          // One media.* payload asserted by URL: the §C rule-3 requirement was observed.
+          break runs;
         }
       }
     }

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

@@ -117,6 +117,8 @@ 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');
+      // partial-witness-ok: RFC 0012 §C tagging is a SHOULD. An untagged entry is this leg's
+      // "omits it cleanly" branch, and the entry was located and inspected above.
       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, req('openwop.it.memory-compaction-provenance-tag.compacted-entry-carries-a-well-formed-compacted-from-tag-or-omits-it-cleanly-no', 

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

@@ -27,7 +27,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { softSkip } from '../lib/soft-skip.js';
+import { softSkip, blockedDespiteAssertions } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 import { req } from '../lib/requirement-ids.js';
@@ -101,7 +101,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 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.');
+      return blockedDespiteAssertions('[rfc0012-sr1] the compact seam returned no outputContent, so the persisted entry\'s SR-1 carry-forward is unobserved');
     }
 
     // The load-bearing assertion: the PERSISTED entry content (what

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

@@ -22,7 +22,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { softSkip } from '../lib/soft-skip.js';
+import { softSkip, blockedDespiteAssertions } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { req } from '../lib/requirement-ids.js';
 
@@ -61,7 +61,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 softSkip('blocked', 'precondition not met — `second.status === 404 || second.status === 501` returned early (seam, prior step, or fixture unavailable)');
+    if (second.status === 404 || second.status === 501) return blockedDespiteAssertions('the consolidate seam answered the first pass but not the second — §D.2 idempotence is unobserved');
     const r2 = second.json as ConsolidateResult;
     expect(
       r2.event?.inputCount,

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

@@ -116,7 +116,7 @@ describe('memory-injection-budget (RFC 0113)', () => {
 
     const v = await driveFixtureVariables();
     expect(v, req('openwop.it.memory-injection-budget.token-bounds-the-injection-read-omits-the-over-budget-entry-and-preserves-sr-1-c', 'RFC 0113', 'fixture MUST surface run variables')).toBeDefined();
-    if (v === undefined) return softSkip('blocked', 'precondition not met — `v === undefined` returned early (seam, prior step, or fixture unavailable)');
+    if (v === undefined) throw new Error('unreachable: the assertion above has already failed this leg');
 
     // ── tokenBudget bound (the new lever) ──────────────────────────────
     const tokenBudget = numberOf(v['tokenBudget']);
@@ -177,7 +177,7 @@ describe('memory-injection-budget (RFC 0113)', () => {
 
     const v = await driveFixtureVariables();
     expect(v, req('openwop.it.memory-injection-budget.rank-relevance-reorders-vs-recency-only-when-memory-search-semantic-is-also-adve', 'RFC 0113', 'fixture MUST surface run variables')).toBeDefined();
-    if (v === undefined) return softSkip('blocked', 'precondition not met — `v === undefined` returned early (seam, prior step, or fixture unavailable)');
+    if (v === undefined) throw new Error('unreachable: the assertion above has already failed this leg');
 
     const recencyOrder = stringArrayOf(v['recencyOrder']);
     const relevanceOrder = stringArrayOf(v['relevanceOrder']);

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

@@ -38,7 +38,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { seamAbsent } from '../lib/soft-skip.js';
+import { seamAbsent, seamAbsentDespiteAssertions } from '../lib/soft-skip.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { isMultiPartyConversationSupported } from '../lib/multi-agent-capabilities.js';
 import {
@@ -89,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 seamAbsent('host advertises multiPartyConversation but the conversation seam is not wired');
+    if (ok.unwired) return seamAbsentDespiteAssertions('host advertises multiPartyConversation and the council opened, but the turn-exchange seam is not wired');
     expect(
       ok.status === 200,
       req('openwop.it.multi-party-conversation-behavioral.opens-a-council-accepts-an-attributed-turn-and-rejects-missing-non-participant-o', 'RFC 0101 §Spec', "a role:'agent' turn with an in-roster speakerId MUST be accepted"),

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

@@ -87,14 +87,14 @@ describe.skipIf(HTTP_SKIP)('multi-region-idempotency-behavior: convergence rule
     expect(
       probe.status,
       req('openwop.it.multi-region-idempotency-behavior.two-region-conflict-resolves-to-the-lex-min-runid-per-annex-convergence-rule', 
-        'idempotency.md §"Multi-region idempotency annex"',
+        'spec/v1/idempotency.md §"Multi-region idempotency annex"',
         'simulate-partition seam MUST return 200 when ≥2 conflicting claims are submitted',
       ),
     ).toBe(200);
     expect(
       probe.body.winner?.runId,
       req('openwop.it.multi-region-idempotency-behavior.two-region-conflict-resolves-to-the-lex-min-runid-per-annex-convergence-rule', 
-        'idempotency.md §"Convergence rule"',
+        'spec/v1/idempotency.md §"Convergence rule"',
         'winner MUST be the lex-min runId (run-a-west < run-b-east)',
       ),
     ).toBe('run-a-west');
@@ -115,14 +115,14 @@ describe.skipIf(HTTP_SKIP)('multi-region-idempotency-behavior: convergence rule
     expect(
       probe.body.winner?.runId,
       req('openwop.it.multi-region-idempotency-behavior.three-region-partition-resolves-to-a-single-winner', 
-        'idempotency.md §"Convergence rule"',
+        'spec/v1/idempotency.md §"Convergence rule"',
         'winner MUST be the lex-min runId across all conflicting claims',
       ),
     ).toBe('aaa-1');
     expect(
       probe.body.losers?.length,
       req('openwop.it.multi-region-idempotency-behavior.three-region-partition-resolves-to-a-single-winner', 
-        'idempotency.md §"Convergence rule"',
+        'spec/v1/idempotency.md §"Convergence rule"',
         'losers array MUST contain N-1 entries when N claims conflict',
       ),
     ).toBe(2);
@@ -143,7 +143,7 @@ describe.skipIf(HTTP_SKIP)('multi-region-idempotency-behavior: convergence rule
     expect(
       redirects.length,
       req('openwop.it.multi-region-idempotency-behavior.every-region-gets-a-cache-redirect-entry-pointing-at-the-winner', 
-        'idempotency.md §"Convergence rule"',
+        'spec/v1/idempotency.md §"Convergence rule"',
         'cacheRedirects MUST contain one entry per claim (including the winner)',
       ),
     ).toBe(2);
@@ -151,7 +151,7 @@ describe.skipIf(HTTP_SKIP)('multi-region-idempotency-behavior: convergence rule
       expect(
         redirect.redirectToRunId,
         req('openwop.it.multi-region-idempotency-behavior.every-region-gets-a-cache-redirect-entry-pointing-at-the-winner', 
-          'idempotency.md §"Convergence rule"',
+          'spec/v1/idempotency.md §"Convergence rule"',
           'every cache redirect MUST point at the winner runId',
         ),
       ).toBe('run-a');
@@ -172,7 +172,7 @@ describe.skipIf(HTTP_SKIP)('multi-region-idempotency-behavior: convergence rule
     expect(
       probe.body.loserCancelReason,
       req('openwop.it.multi-region-idempotency-behavior.loser-cancel-reason-must-be-the-canonical-cross-region-dedup-loss-string', 
-        'idempotency.md §"Convergence rule"',
+        'spec/v1/idempotency.md §"Convergence rule"',
         'loserCancelReason MUST be the canonical `cross_region_dedup_loss` string',
       ),
     ).toBe('cross_region_dedup_loss');
@@ -198,7 +198,7 @@ describe.skipIf(HTTP_SKIP)('multi-region-idempotency-behavior: convergence rule
     expect(
       p1.body.winner?.runId,
       req('openwop.it.multi-region-idempotency-behavior.resolver-is-order-invariant-shuffled-inputs-produce-the-same-winner', 
-        'idempotency.md §"Convergence rule" — determinism',
+        'spec/v1/idempotency.md §"Convergence rule" — determinism',
         'resolver MUST be order-invariant; all permutations MUST produce the same lex-min winner',
       ),
     ).toBe('a');
@@ -219,7 +219,7 @@ describe.skipIf(HTTP_SKIP)('multi-region-idempotency-behavior: convergence rule
     expect(
       probe.status,
       req('openwop.it.multi-region-idempotency-behavior.mismatched-tuple-rejects-with-400-validation-error', 
-        'idempotency.md §"Convergence rule"',
+        'spec/v1/idempotency.md §"Convergence rule"',
         'claims with non-matching (tenantId, endpoint, key) MUST be rejected — it would be a programming error in the caller',
       ),
     ).toBe(400);

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

@@ -64,7 +64,7 @@ describe('multi-region-idempotency: capability shape', () => {
     }
 
     expect(ALLOWED.has(idem.crossRegion), req('openwop.it.multi-region-idempotency.idempotency-crossregion-when-advertised-must-be-one-of-the-closed-enum', 
-      'idempotency.md §"Multi-region idempotency" §"Capability advertisement"',
+      'spec/v1/idempotency.md §"Multi-region idempotency" §"Capability advertisement"',
       'crossRegion MUST be one of {"single-region","reconciled-records","fenced-effects"}',
     )).toBe(true);
 
@@ -90,7 +90,7 @@ describe('multi-region-idempotency: capability shape', () => {
     const advertised = new Set(observability?.metrics?.names ?? []);
     for (const name of REQUIRED_METRICS_WHEN_MULTI_REGION) {
       expect(advertised.has(name), req('openwop.it.multi-region-idempotency.multi-region-hosts-should-expose-the-cross-region-conflict-counter-per-operator', 
-        'idempotency.md §"Operator surface"',
+        'spec/v1/idempotency.md §"Operator surface"',
         `multi-region hosts SHOULD advertise metric "${name}" so operators can monitor conflict frequency`,
       )).toBe(true);
     }

package/src/scenarios/pack-registry-isolation.test.ts

@@ -94,18 +94,19 @@ describe('pack-registry-isolation: test catalog MUST NOT bleed into production (
           `pack name '${name}' was written via /v1/packs-test/${name}@${version} but appeared in /v1/packs/${name} response body — test-catalog isolation MUST hold`,
         ),
       ).toBe(false);
-      return softSkip('blocked', 'precondition not met — `prodRes.status === 200` returned early (404 is the canonical "not found" — exactly what isolation requires. 200 with a payload that does NOT name our pack would mean the host returned a listing…');
+      // A 200 that does not name the pack IS isolation holding: the requirement was observed.
+      // (This branch used to end in a blocked note, a partial-witness pass at major 1.)
+    } else {
+      // Acceptable: 4xx range (404 pack_not_found is the spec-canonical
+      // shape; 410/422 also fine — any "not present in production catalog"
+      // signal satisfies the invariant).
+      expect(
+        prodRes.status >= 400 && prodRes.status < 500,
+        req('openwop.it.pack-registry-isolation.a-pack-put-to-v1-packs-test-name-must-not-appear-in-get-v1-packs-name', 
+          'RFCS/0025-test-mode-registry-namespace.md §C point 1',
+          `expected production-namespace GET to return 4xx for a test-namespace-only pack '${name}', got ${prodRes.status}`,
+        ),
+      ).toBe(true);
     }
-
-    // Acceptable: 4xx range (404 pack_not_found is the spec-canonical
-    // shape; 410/422 also fine — any "not present in production catalog"
-    // signal satisfies the invariant).
-    expect(
-      prodRes.status >= 400 && prodRes.status < 500,
-      req('openwop.it.pack-registry-isolation.a-pack-put-to-v1-packs-test-name-must-not-appear-in-get-v1-packs-name', 
-        'RFCS/0025-test-mode-registry-namespace.md §C point 1',
-        `expected production-namespace GET to return 4xx for a test-namespace-only pack '${name}', got ${prodRes.status}`,
-      ),
-    ).toBe(true);
   });
 });

package/src/scenarios/pack-registry.test.ts

@@ -330,9 +330,10 @@ describe('pack-registry: keychain shape (when present)', () => {
       authenticated: false,
     });
     // 200 with `{keys: []}` and 404 are both spec-allowed (keychain is
-    // optional; not every namespace publishes one).
+    // optional; not every namespace publishes one). A 404 is decided before
+    // any assertion, so the row is `inapplicable`, not a partial-witness pass.
+    if (res.status === 404) return softSkip('inapplicable', `${first} publishes no keychain (optional) — there are no key entries to check`);
     expect([200, 404]).toContain(res.status);
-    if (res.status === 404) return softSkip('blocked', 'precondition not met — `res.status === 404` returned early (seam, prior step, or fixture unavailable)');
 
     const body = res.json as { keys?: unknown; namespace?: unknown } | undefined;
     expect(Array.isArray(body?.keys), req('openwop.it.pack-registry.get-v1-packs-name-keychain-returns-well-formed-key-entries-when-present', 

package/src/scenarios/pause-resume.test.ts

@@ -52,6 +52,25 @@ async function cancel(runId: string): Promise<void> {
   await driver.post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, { reason: 'conformance-cleanup' });
 }
 
+/**
+ * A 404 on :pause / :resume. The routes are capability-gated
+ * (capabilities.md §`runs.pauseResume`), so a host that does not advertise the
+ * family is out of scope (`inapplicable`), and one that advertises it and 404s
+ * has made a claim the suite cannot check (`blocked`).
+ *
+ * Every leg reaches this before its first assertion — the run create is an
+ * early return, not an `expect` — so neither case records the partial-witness
+ * PASS that a note after the create assertion recorded until 2026-09-27. A
+ * host that serves the routes without advertising them still runs every leg.
+ */
+async function routeAbsent(route: ':pause' | ':resume'): Promise<undefined> {
+  const disco = await driver.get('/.well-known/openwop');
+  const advertised = capabilityFamily<{ pauseResume?: { supported?: unknown } }>(disco.json, 'runs')?.pauseResume?.supported === true;
+  return advertised
+    ? softSkip('blocked', `${route} answered 404 on a host advertising runs.pauseResume.supported — the advertised route is not served`)
+    : softSkip('inapplicable', `${route} answered 404 and the host does not advertise runs.pauseResume (capabilities.md §runs.pauseResume) — pause/resume is out of scope for it`);
+}
+
 async function eventTypes(runId: string): Promise<string[]> {
   const res = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/events/poll?timeout=1`);
   const events = (res.json as { events?: unknown } | null)?.events;
@@ -70,7 +89,7 @@ describe.skipIf(SKIP)('pause/resume: running → paused → running → terminal
       // `running`, so 3 s is ample for the pause to land first.
       inputs: { delayMs: 3_000 },
     });
-    expect(create.status).toBe(201);
+    if (create.status !== 201) return softSkip('blocked', `POST /v1/runs answered ${create.status} — no run to pause`);
     const runId = (create.json as { runId: string }).runId;
 
     await pollUntilStatus(runId, 'running', { timeoutMs: 10_000 });
@@ -84,7 +103,7 @@ describe.skipIf(SKIP)('pause/resume: running → paused → running → terminal
     });
     if (pause.status === 404) {
       await cancel(runId);
-      return softSkip('blocked', 'precondition not met — `pause.status === 404` returned early ([pause-resume] host returned 404 for :pause — endpoint not implemented; skipping rest) (seam, prior step, or fixture unavailable)');
+      return routeAbsent(':pause');
     }
     expect(pause.status, req('openwop.it.pause-resume.pause-transitions-to-paused-resume-returns-the-run-to-running',
       DOC_PAUSE,
@@ -112,7 +131,7 @@ describe.skipIf(SKIP)('pause/resume: :resume on a non-paused run returns 409', (
       workflowId: FIXTURE!,
       inputs: { delayMs: 30_000 },
     });
-    expect(create.status).toBe(201);
+    if (create.status !== 201) return softSkip('blocked', `POST /v1/runs answered ${create.status} — no run to pause`);
     const runId = (create.json as { runId: string }).runId;
 
     await pollUntilStatus(runId, 'running', { timeoutMs: 10_000 });
@@ -120,7 +139,7 @@ describe.skipIf(SKIP)('pause/resume: :resume on a non-paused run returns 409', (
     const resume = await driver.post(`/v1/runs/${encodeURIComponent(runId)}:resume`, {});
     if (resume.status === 404) {
       await cancel(runId);
-      return softSkip('blocked', 'precondition not met — `resume.status === 404` returned early (seam, prior step, or fixture unavailable)');
+      return routeAbsent(':resume');
     }
     expect(resume.status, req('openwop.it.pause-resume.resuming-a-running-not-paused-run-returns-409-with-details-runstatus',
       DOC_RESUME,
@@ -146,14 +165,14 @@ describe.skipIf(SKIP)('pause/resume: a second :pause is 409 without a matching I
       workflowId: FIXTURE!,
       inputs: { delayMs: 30_000 },
     });
-    expect(create.status).toBe(201);
+    if (create.status !== 201) return softSkip('blocked', `POST /v1/runs answered ${create.status} — no run to pause`);
     const runId = (create.json as { runId: string }).runId;
     await pollUntilStatus(runId, 'running', { timeoutMs: 10_000 });
 
     const first = await driver.post(`/v1/runs/${encodeURIComponent(runId)}:pause`, { drainPolicy: 'immediate' });
     if (first.status === 404) {
       await cancel(runId);
-      return softSkip('blocked', 'precondition not met — `first.status === 404` returned early (seam, prior step, or fixture unavailable)');
+      return routeAbsent(':pause');
     }
     expect(first.status, req('openwop.it.pause-resume.pause-on-an-already-paused-run-returns-409-with-details-runstatus-paused-unless',
       DOC_PAUSE,
@@ -211,7 +230,7 @@ describe.skipIf(SKIP)('pause/resume: :pause on a terminal run returns 409', () =
     await pollUntilTerminal(runId, { timeoutMs: 10_000 });
 
     const pause = await driver.post(`/v1/runs/${encodeURIComponent(runId)}:pause`, {});
-    if (pause.status === 404) return softSkip('blocked', 'precondition not met — `pause.status === 404` returned early (seam, prior step, or fixture unavailable)');
+    if (pause.status === 404) return routeAbsent(':pause');
     expect(pause.status, req('openwop.it.pause-resume.pause-on-a-completed-cancelled-failed-run-must-return-409',
       DOC_PAUSE,
       ':pause on a terminal run MUST return 409',
@@ -235,7 +254,7 @@ describe.skipIf(SKIP)('pause/resume: drain-current-node lets the executing node
       workflowId: FIXTURE!,
       inputs: { delayMs: 3_000 },
     });
-    expect(create.status).toBe(201);
+    if (create.status !== 201) return softSkip('blocked', `POST /v1/runs answered ${create.status} — no run to pause`);
     const runId = (create.json as { runId: string }).runId;
     await pollUntilStatus(runId, 'running', { timeoutMs: 10_000 });
 
@@ -245,7 +264,7 @@ describe.skipIf(SKIP)('pause/resume: drain-current-node lets the executing node
     });
     if (pause.status === 404) {
       await cancel(runId);
-      return softSkip('blocked', 'precondition not met — `pause.status === 404` returned early (seam, prior step, or fixture unavailable)');
+      return routeAbsent(':pause');
     }
     expect(pause.status, req('openwop.it.pause-resume.under-drain-current-node-node-completed-precedes-run-paused-in-the-log',
       DOC_PAUSE,
@@ -281,7 +300,7 @@ describe.skipIf(SKIP)('pause/resume: :pause-during-suspend race', () => {
       return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(\'conformance-approval\')` returned early ([pause-resume] conformance-approval not advertised; skipping :pause-during-suspend race subtest)');
     }
     const create = await driver.post('/v1/runs', { workflowId: 'conformance-approval' });
-    expect(create.status).toBe(201);
+    if (create.status !== 201) return softSkip('blocked', `POST /v1/runs answered ${create.status} — no run to pause`);
     const runId = (create.json as { runId: string }).runId;
     await pollUntilStatus(runId, 'waiting-approval', { timeoutMs: 10_000 });
 
@@ -290,7 +309,7 @@ describe.skipIf(SKIP)('pause/resume: :pause-during-suspend race', () => {
     });
     if (pause.status === 404) {
       await cancel(runId);
-      return softSkip('blocked', 'precondition not met — `pause.status === 404` returned early (seam, prior step, or fixture unavailable)');
+      return routeAbsent(':pause');
     }
 
     // Either rejection (preferred) or stacked-pause is OK; silent override is not.

package/src/scenarios/prompt-read-workspace-membership-enforced.test.ts

@@ -46,7 +46,8 @@
  *     diagnostic log. Indicates the host doesn't recognize `?workspaceId=`
  *     on this endpoint (e.g., host-only template library with no
  *     workspace dimension).
- *   - 5xx — PASS (refused; envelope shape unconstrained).
+ *   - 5xx — `blocked`: a server error is not a readable refusal (a crash
+ *     also answers 5xx), so enforcement was not observed.
  *
  * Why a random workspaceId is sufficient: the assertion is negative-space.
  * A host that correctly enforces membership MUST refuse for ANY workspace
@@ -118,27 +119,17 @@ describe.skipIf(HTTP_SKIP)(
         `/v1/prompts?workspaceId=${encodeURIComponent(nonMemberWorkspaceId)}`,
       );
 
-      // 4xx — refused. Acceptable shape for the membership-required failure
-      // (and any other refusal mode the host chooses: 401, 404 for
-      // existence-disclosure avoidance, etc).
-      if (res.status >= 400 && res.status < 500) {
-        // Canonical envelope on 403 per rest-endpoints.md §"Common error codes".
-        if (res.status === 403) {
-          const body = res.json as { error?: unknown } | null;
-          expect(
-            body?.error,
-            req('openwop.it.prompt-read-workspace-membership-enforced.get-v1-prompts-workspaceid-non-member-must-refuse-or-return-empty-templates-neve', 
-              'spec/v1/rest-endpoints.md §Common error codes — workspace_membership_required',
-              `403 refusal of a workspace-scoped read MUST carry error: "workspace_membership_required"; got error: ${JSON.stringify(body?.error)}`,
-            ),
-          ).toBe('workspace_membership_required');
-        }
-        return softSkip('blocked', 'precondition not met — `res.status >= 400 && res.status < 500` returned early (4xx — refused. Acceptable shape for the membership-required failure (and any other refusal mode the host chooses: 401, 404 for existence-d…');
-      }
+      const ID = 'openwop.it.prompt-read-workspace-membership-enforced.get-v1-prompts-workspaceid-non-member-must-refuse-or-return-empty-templates-neve';
+
+      // 5xx — not a refusal the suite can read as enforcement (a crash also
+      // answers 5xx). Checked first so it returns before any assertion.
+      if (res.status >= 500) return softSkip('blocked', `GET /v1/prompts?workspaceId=<non-member> answered ${res.status} — a server error is neither a refusal nor an empty result, so membership enforcement was not observed`);
 
-      // 5xx — refused (infrastructure failure is acceptable; envelope shape
-      // unconstrained).
-      if (res.status >= 500) return softSkip('blocked', 'precondition not met — `res.status >= 500` returned early (5xx — refused (infrastructure failure is acceptable; envelope shape unconstrained).) (seam, prior step, or fixture unavailable)');
+      // Other status codes (1xx, 3xx) — not a clear signal either way.
+      if (res.status < 200 || (res.status >= 300 && res.status < 400)) {
+        softSkip('skipped', `GET /v1/prompts?workspaceId=… answered ${res.status} — neither a refusal nor a list`);
+        return ctx.skip();
+      }
 
       // 2xx — must inspect the response body. The failure mode this
       // invariant guards against is a 200 response that LEAKS templates
@@ -152,35 +143,53 @@ describe.skipIf(HTTP_SKIP)(
         ) {
           // Host doesn't recognize `?workspaceId=` on this endpoint
           // (response shape doesn't include the documented `templates[]`
-          // field). Soft-skip: this scenario probes hosts that expose
+          // field). Skip: this scenario probes hosts that expose
           // workspace-scoped reads, and a host without that surface is
-          // simply out of scope.
-          ctx.skip();
-          return softSkip('blocked', 'precondition not met — `body === null || typeof body !== \'object\' || !(\'templates\' in body)` returned early (seam, prior step, or fixture unavailable)');
+          // simply out of scope. The note is written BEFORE ctx.skip(),
+          // which throws.
+          softSkip('skipped', 'GET /v1/prompts?workspaceId=… answered 2xx without a templates field — the host does not expose workspace-scoped prompt reads');
+          return ctx.skip();
         }
         const templates = body.templates;
         if (!Array.isArray(templates)) {
           // Same: unrecognized shape, skip.
-          ctx.skip();
-          return softSkip('blocked', 'precondition not met — `!Array.isArray(templates)` returned early (seam, prior step, or fixture unavailable)');
+          softSkip('skipped', 'GET /v1/prompts?workspaceId=… answered 2xx with a non-array templates field — the host does not expose workspace-scoped prompt reads');
+          return ctx.skip();
         }
 
         // A random non-member workspaceId can never legitimately contain
         // templates the caller is authorized to see. Any non-empty result
-        // is a cross-tenant data leak.
+        // is a cross-tenant data leak. An empty result IS the requirement
+        // observed, so the leg ends as a plain pass.
         expect(
           templates.length,
-          req('openwop.it.prompt-read-workspace-membership-enforced.get-v1-prompts-workspaceid-non-member-must-refuse-or-return-empty-templates-neve', 
+          req(ID,
             'spec/v1/prompts.md §Workspace membership on workspace-scoped reads and writes',
             `GET /v1/prompts?workspaceId=<random-non-member> MUST NOT return any templates; got ${templates.length} templates which is a cross-tenant data leak (the random workspaceId is freshly generated per probe and cannot legitimately contain authorized content)`,
           ),
         ).toBe(0);
-        return softSkip('blocked', 'precondition not met — `res.status >= 200 && res.status < 300` returned early (2xx — must inspect the response body. The failure mode this invariant guards against is a 200 response that LEAKS templates from a workspa…');
+      } else {
+        // 4xx — refused. Acceptable shape for the membership-required failure
+        // (and any other refusal mode the host chooses: 401, 404 for
+        // existence-disclosure avoidance, etc). The refusal IS the requirement
+        // observed; until 2026-09-27 this branch ended in a blocked soft-skip,
+        // recording a refused read as blocked (401/404) or a partial witness (403).
+        expect(
+          res.status,
+          req(ID, 'spec/v1/prompts.md §Workspace membership on workspace-scoped reads and writes', 'a workspace-scoped read for a non-member workspace MUST be refused (4xx) or return no templates'),
+        ).toBeGreaterThanOrEqual(400);
+        // Canonical envelope on 403 per rest-endpoints.md §"Common error codes".
+        if (res.status === 403) {
+          const body = res.json as { error?: unknown } | null;
+          expect(
+            body?.error,
+            req(ID,
+              'spec/v1/rest-endpoints.md §Common error codes — workspace_membership_required',
+              `403 refusal of a workspace-scoped read MUST carry error: "workspace_membership_required"; got error: ${JSON.stringify(body?.error)}`,
+            ),
+          ).toBe('workspace_membership_required');
+        }
       }
-
-      // Other status codes (1xx, 3xx) — soft-skip with note. Not a clear
-      // signal either way.
-      ctx.skip();
     });
   },
 );

package/src/scenarios/provider-usage.test.ts

@@ -29,7 +29,7 @@ import { SCHEMAS_DIR } from '../lib/paths.js';
 import { queryTestEvents, isEventLogSeamAvailable, resetTestSeam } from '../lib/event-log-query.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 import { req } from '../lib/requirement-ids.js';
-import { softSkip } from '../lib/soft-skip.js';
+import { softSkip, blockedDespiteAssertions } from '../lib/soft-skip.js';
 
 interface DiscoveryDoc {
   capabilities?: {
@@ -145,7 +145,7 @@ describe('provider-usage: event presence via emit-seam + event-log query (RFC 00
     expect(emit.status).toBe(200);
 
     const events = await queryTestEvents(runId, { type: 'provider.usage' });
-    if (!events.ok) return softSkip('blocked', 'precondition not met — `!events.ok` returned early (seam, prior step, or fixture unavailable)');
+    if (!events.ok) return blockedDespiteAssertions('the event-log seam is advertised but the provider.usage query failed — the projection is unobserved');
     expect(
       events.events.length,
       req('openwop.it.provider-usage.emit-seam-projects-exactly-one-provider-usage-event-with-required-fields-populat', 'RFC 0026 §B', 'emit-seam MUST project exactly one provider.usage event'),

package/src/scenarios/redaction.test.ts

@@ -66,15 +66,17 @@ const SKIP_NO_NOOP = !isFixtureAdvertised(NOOP_WORKFLOW_ID);
 describe('redaction: /.well-known/openwop secrets+aiProviders shape contract', () => {
   it('secrets is well-formed regardless of supported value', async () => {
     const res = await driver.get('/.well-known/openwop', { authenticated: false });
-    expect(res.status).toBe(200);
-
     const body = res.json as { secrets?: unknown } | undefined;
     const secrets = body?.secrets;
 
-    if (secrets === undefined) {
-      // Optional v1 field — hosts MAY omit. Spec-allowed; nothing to assert.
-      return softSkip('blocked', 'precondition not met — `secrets === undefined` returned early (Optional v1 field — hosts MAY omit. Spec-allowed; nothing to assert.) (seam, prior step, or fixture unavailable)');
+    if (res.status === 200 && secrets === undefined) {
+      // Optional v1 field — hosts MAY omit. Spec-allowed; nothing to assert,
+      // so the leg returns before any assertion and records `inapplicable`
+      // (it was a `blocked` note after the status assertion until 2026-09-27,
+      // i.e. a partial-witness pass).
+      return softSkip('inapplicable', '`secrets` is omitted from discovery — an OPTIONAL v1 field, so there is no shape to check');
     }
+    expect(res.status).toBe(200);
 
     // Per capabilities.schema.json: `secrets.supported` is REQUIRED
     // when secrets is present.