@openwop/openwop-conformance 2.42.6 → 2.42.8

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

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

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

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

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.