@openwop/openwop-conformance 2.42.5 → 2.42.7

package/src/scenarios/v2-ext-rest-transport.test.ts

@@ -0,0 +1,151 @@
+/**
+ * v2-ext-rest-transport — RFC 0220 §C, the behavioral witness for the
+ * `restTransport` extension family (suite 2.42.7, target major 2).
+ *
+ * Gate: the host advertises `extensions["<org>.rest-transport"]` under a
+ * registered org (spec/v2/ext/restTransport/README.md §The claim). Absent ⇒
+ * `inapplicable`. A malformed claim fails the claim leg; it does not skip.
+ *
+ * Legs, both recorded under `openwop.family.restTransport` so the family row is
+ * the least certifiable of them (requirement-ledger fold):
+ *
+ *   1. `conditionalRunGet: true` — the `conformance-approval` fixture parks at
+ *      `waiting-approval`, a stable state. The 200 carries a strong ETag, a
+ *      matching If-None-Match gets 304 with no body, and once the approval is
+ *      resolved and the run completes the ETag differs — a 304 across that
+ *      transition would be stale (runs.md §"Caching and encoding").
+ *   2. `contentEncodings` — for each advertised coding, the response carries
+ *      that `Content-Encoding` and decodes to the identity body byte for byte.
+ *
+ * A leg whose facet the record does not set records `inapplicable` for itself
+ * only: a host that claims one facet has promised nothing about the other.
+ *
+ * Ported from the v1 `run-transport-economy` scenario, which reads the v1 root
+ * key; this one reads the v2 extensions record.
+ *
+ * @see RFCS/0220-ext-families-graduate-on-evidence.md
+ * @see spec/v2/ext/restTransport/README.md
+ * @see spec/v2/core/runs.md §"Caching and encoding"
+ */
+import { describe, it, expect } from 'vitest';
+import { gunzipSync, brotliDecompressSync } from 'node:zlib';
+import * as zlib from 'node:zlib';
+import { driver } from '../lib/driver.js';
+import { loadEnv } from '../lib/env.js';
+import { v2Discovery } from '../lib/v2.js';
+import { extDeclaration, classifyExtClaim } from '../lib/ext-claims.js';
+import { pollUntilStatus, pollUntilTerminal } from '../lib/polling.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+type Json = Record<string, unknown>;
+type Encoding = 'gzip' | 'br' | 'zstd';
+const APPROVAL_FIXTURE = 'conformance-approval';
+const APPROVAL_NODE_ID = 'gate';
+const NOOP_FIXTURE = 'conformance-noop';
+const SECTION = 'spec/v2/ext/restTransport/README.md §What the claim adds';
+const R = (why: string): string => req('openwop.family.restTransport', SECTION, why);
+
+type Claim = { ok: true; record: Json; key: string } | { ok: false; kind: 'inapplicable' | 'blocked'; reason: string };
+
+/** The one well-formed rest-transport record, or why there is none. A malformed claim is asserted here, not skipped. */
+async function claim(): Promise<Claim> {
+  const decl = extDeclaration();
+  if (!decl) return { ok: false, kind: 'blocked', reason: 'spec/v2/declaration.json is not resolvable in this layout — the extension name and the org registry come from it' };
+  const family = decl.families.find((f) => f.key === 'restTransport');
+  if (!family) return { ok: false, kind: 'blocked', reason: 'the declaration has no ext row for restTransport — this scenario is stale against the corpus' };
+  const doc = await v2Discovery();
+  if (!doc) return { ok: false, kind: 'blocked', reason: 'v2 discovery unreachable' };
+  const claims = classifyExtClaim(doc, family, decl);
+  if (claims.length === 1 && claims[0].state === 'absent') return { ok: false, kind: 'inapplicable', reason: 'no extensions["<org>.rest-transport"] record under a registered org — the host does not advertise restTransport' };
+  for (const c of claims) {
+    if (c.state === 'malformed') expect(c.state, R(`extensions["${c.key}"]: ${c.why}`)).toBe('well-formed');
+  }
+  const first = claims.find((c) => c.state === 'well-formed');
+  if (!first || first.state !== 'well-formed') return { ok: false, kind: 'blocked', reason: 'no well-formed rest-transport claim' };
+  return { ok: true, record: ((doc['extensions'] as Json)[first.key] ?? {}) as Json, key: first.key };
+}
+
+function advertisedEncodings(record: Json): Encoding[] {
+  const raw = record['contentEncodings'];
+  return Array.isArray(raw) ? raw.filter((e): e is Encoding => e === 'gzip' || e === 'br' || e === 'zstd') : [];
+}
+
+describe('RFC 0220 §C — restTransport: conditional GET on the run snapshot', () => {
+  it('a strong ETag on the 200, 304 on a match while the run is parked, and a new ETag once it completes', async () => {
+    const c = await claim();
+    if (!c.ok) return softSkip(c.kind, c.reason);
+    if (c.record['conditionalRunGet'] !== true) return softSkip('inapplicable', `extensions["${c.key}"].conditionalRunGet is not true — the host claims no validator`);
+
+    const create = await driver.post('/runs', { workflowId: APPROVAL_FIXTURE });
+    // Any non-201 is the suite's precondition failing (fixture, credential), not the claim — the v2-a2ui gate's convention.
+    if (create.status !== 201) return softSkip('blocked', `POST /runs {workflowId: ${APPROVAL_FIXTURE}} answered ${create.status} — the run the leg needs could not be created`);
+    const runId = (create.json as { runId: string }).runId;
+    const path = `/runs/${encodeURIComponent(runId)}`;
+    await pollUntilStatus(runId, 'waiting-approval', { timeoutMs: 10_000 });
+
+    const parked = await driver.get(path);
+    expect(parked.status, R('the parked run reads 200')).toBe(200);
+    const etagParked = parked.headers.get('etag');
+    expect(etagParked, R('a host whose record sets conditionalRunGet: true MUST carry an ETag on every 200 of GET /runs/{runId}')).toBeTruthy();
+    expect(etagParked?.startsWith('W/'), R('the ETag MUST be strong')).toBe(false);
+
+    const revalidate = await driver.get(path, { headers: { 'If-None-Match': etagParked as string } });
+    expect(revalidate.status, R('a matching If-None-Match MUST receive 304 while the run has not advanced (runs.md §"Caching and encoding")')).toBe(304);
+    expect(revalidate.text, R('the 304 MUST carry no body')).toBe('');
+
+    const resolve = await driver.post(`${path}/interrupts/${encodeURIComponent(APPROVAL_NODE_ID)}`, { resumeValue: { action: 'accept' } });
+    expect(resolve.status, R('the approval resolves (control: the run must advance for the rotation check to mean anything)')).toBe(200);
+    const terminal = await pollUntilTerminal(runId, { timeoutMs: 10_000 });
+    expect(terminal.status, R('the run completes')).toBe('completed');
+
+    const done = await driver.get(path);
+    const etagDone = done.headers.get('etag');
+    expect(etagDone, R('the completed run still carries an ETag')).toBeTruthy();
+    expect(etagDone, R('the ETag MUST change once the run advances; the parked ETag would otherwise answer 304 for a changed run')).not.toBe(etagParked);
+    const stale = await driver.get(path, { headers: { 'If-None-Match': etagParked as string } });
+    expect(stale.status, R('the parked ETag MUST NOT match the completed run')).toBe(200);
+  });
+});
+
+describe('RFC 0220 §C — restTransport: each advertised coding round-trips', () => {
+  it('each coding in contentEncodings is produced when asked for alone and decodes to the identity body', async () => {
+    const c = await claim();
+    if (!c.ok) return softSkip(c.kind, c.reason);
+    const encodings = advertisedEncodings(c.record);
+    if (encodings.length === 0) return softSkip('inapplicable', `extensions["${c.key}"].contentEncodings lists no coding — the host claims none`);
+
+    const create = await driver.post('/runs', { workflowId: NOOP_FIXTURE });
+    // Any non-201 is the suite's precondition failing (fixture, credential), not the claim — the v2-a2ui gate's convention.
+    if (create.status !== 201) return softSkip('blocked', `POST /runs {workflowId: ${NOOP_FIXTURE}} answered ${create.status} — the run the leg needs could not be created`);
+    const runId = (create.json as { runId: string }).runId;
+    await pollUntilTerminal(runId, { timeoutMs: 10_000 });
+
+    // A raw fetch, not the driver: the driver decodes JSON, and the oracle here is bytes.
+    const env = loadEnv();
+    const url = `${env.baseUrl}/runs/${encodeURIComponent(runId)}`;
+    const base = { Authorization: `Bearer ${env.apiKey}`, Accept: 'application/json', 'OpenWOP-Version': '2.0' };
+    const identity = await fetch(url, { headers: { ...base, 'Accept-Encoding': 'identity' } });
+    expect(identity.status, R('the identity read is 200')).toBe(200);
+    const identityBytes = Buffer.from(await identity.arrayBuffer());
+    expect(identityBytes.length, R('the identity body is non-empty')).toBeGreaterThan(0);
+
+    const zstdMaybe: { zstdDecompressSync?: (b: Buffer) => Buffer } = zlib;
+    for (const enc of encodings) {
+      const res = await fetch(url, { headers: { ...base, 'Accept-Encoding': enc } });
+      expect(res.status, R(`the ${enc} read is 200`)).toBe(200);
+      expect(res.headers.get('content-encoding'), R(`a coding listed in contentEncodings MUST be produced when it is the only one asked for (${enc})`)).toBe(enc);
+      expect((res.headers.get('vary') ?? '').toLowerCase(), R('a compressed response MUST carry Vary: Accept-Encoding (runs.md §"Caching and encoding")')).toContain('accept-encoding');
+      const bytes = Buffer.from(await res.arrayBuffer());
+      // Node's fetch decodes gzip and br in transit, so equal bytes already prove the round trip.
+      const decode = enc === 'gzip' ? gunzipSync : enc === 'br' ? brotliDecompressSync : zstdMaybe.zstdDecompressSync;
+      // No zstd decoder in this Node: the coding was produced (asserted above); the byte compare needs a decoder the suite lacks.
+      if (!bytes.equals(identityBytes) && !decode) continue;
+      let decoded = bytes;
+      if (!bytes.equals(identityBytes) && decode) {
+        try { decoded = Buffer.from(decode(bytes)); } catch { /* not compressed bytes either: a real mismatch, compared below */ }
+      }
+      expect(decoded.equals(identityBytes), R(`the ${enc}-decoded body MUST be byte-identical to the identity body`)).toBe(true);
+    }
+  });
+});

package/src/scenarios/v2-idempotency-in-flight.test.ts

@@ -147,6 +147,9 @@ describe('v2 idempotency-in-flight (idempotency.md Concurrency, RFC 0213 §B)',
     // (#1525's fix, kept verbatim; `r.refusals` is the split form's spelling of
     // its `refusals`, and it now lands on the LOSER id it is about rather than
     // on a row shared with the winner clause.)
+    // partial-witness-ok: the winner/replay clauses were asserted above; RFC 0213 §B lets every
+    // loser wait for a marked replay, so the 409 branch is an outcome this host did not take,
+    // not an unobserved obligation.
     if (r.refusals.length === 0) return softSkip('inapplicable', `no loser was refused in flight — all ${N} answers were successes (each loser a marked replay, which §B permits), so the 409 branch did not run on this host`);
   }, 60_000);
   // The deterministic §B witness (host-sample-test-seams.md §26): the seam only

package/src/scenarios/v2-legacy-profiles-absent.test.ts

@@ -41,11 +41,10 @@ describe('RFC 0175 §C.1 — legacy-profiles-absent (unaided)', () => {
   it('no -legacy id appears in a2a.profiles or mcp.profiles and each id matches its facet pattern', async () => {
     const doc = await discovery();
     if (!doc) return softSkip('blocked', 'discovery unreachable');
-    let checked = 0;
-    for (const family of ['a2a', 'mcp'] as const) {
-      const profiles = profilesOf(doc, family);
-      if (profiles === null) continue;
-      checked++;
+    const families = (['a2a', 'mcp'] as const).filter((family) => profilesOf(doc, family) !== null);
+    if (families.length === 0) return softSkip('inapplicable', 'host advertises neither a2a nor mcp — no profiles[] to check for a -legacy id');
+    for (const family of families) {
+      const profiles = profilesOf(doc, family)!;
       for (const id of profiles) {
         expect(
           /-legacy$/.test(id),
@@ -64,7 +63,6 @@ describe('RFC 0175 §C.1 — legacy-profiles-absent (unaided)', () => {
         req('openwop.requirement.0175.legacy-profiles-absent', `facets/${family}.schema.json`, `the ${family} facet MUST validate against its facet schema (capabilities.schema.json ${family}): ${check.errors}`),
       ).toBe(true);
     }
-    if (checked === 0) softSkip('inapplicable', 'host advertises neither a2a nor mcp — no profiles[] to check for a -legacy id');
   });
 
   it('no root profiles[] exists in the v2 representation', async () => {

package/src/scenarios/v2-mcp-tasks.test.ts

@@ -309,7 +309,7 @@ describe('RFC 0198 — v2-mcp-tasks (MCP Tasks on the server mount; disconnect c
     if (f.result?.['resultType'] === 'task') terminal = await pollTask(m.url, String(f.result['taskId']), (s) => ['completed', 'failed', 'cancelled'].includes(s), 10_000);
     else {
       // unfailable-leg audit wave 2, 2026-09-27: this branch returned
-      // softSkip('inapplicable') after the input_required asserts — a
+      // an inapplicable soft-skip after the input_required asserts — a
       // partial-witness PASS at both majors even when the synchronous answer
       // was NOT a tool-error outcome. The synchronous CallToolResult of a
       // failed run MUST still carry isError true; the task projection itself

package/src/scenarios/v2-min-client-version.test.ts

@@ -50,6 +50,8 @@ describe('v2 min-client-version (RFC 0172 §A.5 — gated on minClientVersion)',
     if (res.status !== 426 && (res.status < 200 || res.status >= 300)) {
       return blockedDespiteAssertions(`the host advertises minClientVersion ${String(floor)} and answered ${res.status} to a client announcing 0.0.1 — neither served (the MAY) nor refused with the registered 426 client_version_unsupported; the refusal form was not observed`);
     }
+    // partial-witness-ok: the minClientVersion grammar MUST was asserted above; refusing a
+    // below-floor client is a MAY and this host served it, so the 426 shape binds nothing.
     if (res.status !== 426) return softSkip('inapplicable', `the host advertises minClientVersion ${String(floor)} but served a client announcing 0.0.1 (${res.status}) — refusal is a MAY; nothing further is observable`);
     expect(readErrorCode(res.json), req('openwop.requirement.0172.min-client-version', DOC, 'a 426 refusal MUST carry client_version_unsupported')).toBe('client_version_unsupported');
     const r = v2Validator('error-envelope')(res.json);

package/src/scenarios/v2-refresh-sla.test.ts

@@ -38,12 +38,14 @@ describe('RFC 0175 §D.4 — refresh-sla (unaided; gated on a2a or mcp)', () =>
       { family: 'a2a', offered: 'versions', preferred: 'preferredVersion', floor: 'minimumVersion' },
       { family: 'mcp', offered: 'revisions', preferred: 'preferredVersion', floor: 'minimumRevision' },
     ];
-    let checked = 0;
-    const now = Date.now();
+    const advertised: Array<{ f: (typeof facets)[number]; rec: Record<string, unknown> }> = [];
     for (const f of facets) {
       const rec = await familyAdvertised(f.family);
-      if (!rec) continue;
-      checked++;
+      if (rec) advertised.push({ f, rec });
+    }
+    if (advertised.length === 0) return softSkip('inapplicable', 'host advertises neither a2a nor mcp — no refreshedAt to check');
+    const now = Date.now();
+    for (const { f, rec } of advertised) {
       const refreshedAt = rec['refreshedAt'];
       expect(
         typeof refreshedAt === 'string' && DATE.test(refreshedAt),
@@ -73,6 +75,5 @@ describe('RFC 0175 §D.4 — refresh-sla (unaided; gated on a2a or mcp)', () =>
         req('openwop.requirement.0175.refresh-sla', 'interop.md §The facets', `${f.family}.${f.floor} MUST be one of the offered ${f.offered}[] — a floor below every offer refuses nothing`),
       ).toContain(rec[f.floor]);
     }
-    if (checked === 0) return softSkip('inapplicable', 'host advertises neither a2a nor mcp — no refreshedAt to check');
   });
 });

package/src/scenarios/v2-sse-last-event-id-cursor.test.ts

@@ -10,9 +10,9 @@
  * the caller is authorized to read the run: for a run the caller cannot read
  * the answer MUST be the one the host gives without the header.
  *
- * Off the core-standard floor: `v2-sse-last-event-id` is the floor scenario and
- * this file adds legs a committed claim was never measured against (rc.59
- * precedent). Promotion waits until the three bundle hosts are measured.
+ * On the core-standard floor since 2.42.7, beside `v2-sse-last-event-id`. It was
+ * held off until the three bundle hosts were measured (rc.59 precedent); all
+ * three recorded it executed-pass, two with partial-witness on the SHOULD leg only.
  *
  * Legs, on one completed noop run:
  *   1. a future id (last + 1000) ⇒ 200, zero frames, closed by the server — a

package/src/scenarios/v2-sse-last-event-id.test.ts

@@ -92,6 +92,8 @@ describe('v2 sse-last-event-id (events.md §SSE frames)', () => {
     // values: resumption MUST emit a state.snapshot first — only where the host serves values.
     const probe = await http(() => driver.get(`/runs/${enc(c.runId)}/events?streamMode=bogus`, { headers: { Accept: 'text/event-stream' } }));
     const supported = (probe?.json as { details?: { supported?: unknown } } | null)?.details?.supported;
+    // partial-witness-ok: every Last-Event-ID MUST was asserted above on the debug stream; the
+    // state.snapshot-first rule binds only a host serving values mode.
     if (!Array.isArray(supported) || !supported.includes('values')) return softSkip('inapplicable', `values mode not served (details.supported: ${JSON.stringify(supported)}) — the state.snapshot-first resumption leg does not apply`);
     const values = await subscribe(`/runs/${enc(c.runId)}/events?streamMode=values`, { timeoutMs: 8_000, extraHeaders: V2, lastEventId: String(first) });
     expect(values.status, req(ID, DOC, `a values resume MUST answer 200 — got ${values.status}`)).toBe(200);

package/src/scenarios/v2-version-header-honored.test.ts

@@ -168,6 +168,9 @@ describe('v2-version-header-honored (RFC 0172 §A.3)', () => {
         },
         req(ID, DOC, `a host that does not serve major 2 MUST refuse OpenWOP-Version: 2.0 with 406 protocol_version_unsupported and details.protocolVersions[] echoing [${advertised.join(', ')}]; a host that LISTS a 2.x member MUST serve it (§1.3 row 1), not refuse it`),
       ).toEqual({ status: 406, code: 'protocol_version_unsupported', echoed: [...advertised].sort(), listsMajor2: false });
+      // partial-witness-ok: the 406 refusal was held to §1.3 row 2 in full above. It is a
+      // complete, correct answer, and there is no second representation to compare bytes
+      // against.
       return softSkip('inapplicable', 'the host refused major 2 with the specified 406 — a correct answer, and there is no second representation to compare bytes against');
     }
     if (asked.status !== 200) {

package/src/scenarios/v2-webhook-durable-delivery.test.ts

@@ -366,6 +366,8 @@ describe('RFC 0173 §B — webhook-durable-delivery (gated on webhooks)', () =>
         }
       }
     } else {
+      // partial-witness-ok: delivery and retry were observed above; the spacing leg binds only
+      // an advertised backoff other than none.
       softSkip('inapplicable', 'no advertised retryPolicy.backoff other than none — the spacing leg is not asserted');
     }
 

package/src/scenarios/v2-webhook-secret-rotation.test.ts

@@ -117,7 +117,14 @@ describe('RFC 0201 §E — secret rotation overlaps, then retires (gated on webh
     // After the overlap: only when it fits the operator's wait cap.
     const expiresAt = Date.parse(body.previousSecretExpiresAt ?? '');
     if (expiresAt - Date.now() > CAP_MS) {
-      return softSkip('inapplicable', `the post-overlap leg is not observed: overlapSeconds (${overlapSeconds}) exceeds the suite wait cap (${CAP_MS}ms; raise OPENWOP_WEBHOOK_RETRY_WAIT_MS to witness it)`);
+      // partial-witness-ok: the tenant check, the rotate response and the dual signature during
+      // the overlap were asserted above. "The previous secret MUST NOT sign after
+      // previousSecretExpiresAt" cannot be observed inside a bounded run when the host's
+      // advertised webhooks.secretRotation.overlapSeconds outlasts the suite's wait cap, and
+      // blocking every long-overlap host would deny certification to conforming hosts
+      // (steward ruling, 2026-09-27). The row detail names both numbers. Raise
+      // OPENWOP_WEBHOOK_RETRY_WAIT_MS past the overlap to witness it.
+      return softSkip('inapplicable', `the post-overlap leg is not observed: the advertised webhooks.secretRotation.overlapSeconds is ${overlapSeconds}s (expiry ${new Date(expiresAt).toISOString()}) and the suite wait cap is ${CAP_MS}ms; raise OPENWOP_WEBHOOK_RETRY_WAIT_MS past the overlap to witness it`);
     }
     await new Promise((r) => setTimeout(r, Math.max(0, expiresAt - Date.now()) + 1_500));
     const after = await oneDelivery(rx, webhookId);

package/src/scenarios/verifier-gating.test.ts

@@ -24,7 +24,7 @@ import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { readCapabilityFamily } 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';
 
 const SEAM = '/v1/host/sample/agents/verify-run';
 
@@ -62,7 +62,7 @@ describe('verifier-gating (RFC 0090 §B)', () => {
 
     // PASS verdict → completes normally.
     const passRes = await driver.post(SEAM, { simulateVerdict: 'pass' });
-    if (passRes.status === 404) return softSkip('blocked', 'precondition not met — `passRes.status === 404` returned early (seam, prior step, or fixture unavailable)');
+    if (passRes.status === 404) return blockedDespiteAssertions('the verify seam answered the fail verdict but not the pass verdict — pass-completes is unobserved');
     expect(
       verifiedVerdict(passRes.json) === 'pass',
       req('openwop.it.verifier-gating.a-fail-verdict-blocks-commit-on-a-gating-host-a-pass-verdict-completes', 'RFC 0090 §A', 'a verify-run forcing a pass MUST emit agent.verified{verdict:"pass"}'),

package/src/scenarios/version-fold.test.ts

@@ -34,7 +34,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { softSkip } from '../lib/soft-skip.js';
+import { softSkip, blockedDespiteAssertions } from '../lib/soft-skip.js';
 import { driver, type OpenWOPResponse } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
@@ -106,7 +106,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('version-fold: forced engine versions fold-best
       if (create.status === 403 && errCode(create.json) === 'force_engine_version_forbidden') {
         // eslint-disable-next-line no-console
         console.warn('[version-fold] API key is production-scoped (403 force_engine_version_forbidden); skipping');
-        return softSkip('blocked', '[version-fold] API key is production-scoped (403 force_engine_version_forbidden); skipping (create.status === 403 && errCode(create.json) === \'force_engine_version_forbidden\')');
+        return blockedDespiteAssertions('[version-fold] API key is production-scoped (403 force_engine_version_forbidden) — the advertised forceEngineVersionRange cannot be exercised; run with a test key');
       }
       expect(
         create.status,

package/src/scenarios/wasm-pack-invoke-suspended.test.ts

@@ -65,12 +65,13 @@ describe('wasm-pack-invoke-suspended: suspend → resume round-trip', () => {
         'RFCS/0008-wasm-abi.md §D',
         "if a host doesn't implement WASM-driven suspends it MUST surface a recognizable code",
       )).toBe(true);
-      return softSkip('blocked', 'precondition not met — `terminal.status === \'failed\'` returned early (seam, prior step, or fixture unavailable)');
+      // A failed run carrying the recognizable code IS one of the two conformant
+      // outcomes: the requirement was observed.
+    } else {
+      // Completed path: the reference pack never suspends. Asserting
+      // 'completed' confirms the host did not spuriously enter a
+      // waiting-* state.
+      expect(terminal.status).toBe('completed');
     }
-
-    // Completed path: the reference pack never suspends. Asserting
-    // 'completed' confirms the host did not spuriously enter a
-    // waiting-* state.
-    expect(terminal.status).toBe('completed');
   });
 });

package/src/scenarios/webhook-signed-delivery.test.ts

@@ -390,6 +390,8 @@ describe('webhook-signed-delivery: end-to-end HMAC v1', () => {
     // `X-openwop-*` counterpart and the signature verifies reading either.
     const dual = first.headers['openwop-signature'];
     if (dual === undefined) {
+      // partial-witness-ok: every X-openwop-* delivery MUST was asserted above; dual-emitting
+      // the OpenWOP-* family is an RFC 0165 §C.1 SHOULD.
       softSkip('inapplicable', 'host does not yet dual-emit the OpenWOP-* webhook header family (RFC 0165 §C.1 — SHOULD)');
     } else {
       for (const [neu, old] of [

package/src/scenarios/workflow-chain-host-expansion.test.ts

@@ -169,7 +169,10 @@ describe('workflow-chain-host-expansion: live host wraps expansion algorithm cor
       const [fm, fn] = PACK.version.split('.').map(Number);
       const older = hm! < fm! || (hm === fm && hn! < fn!);
       expect(older, req('openwop.it.workflow-chain-host-expansion.positive-1-node-chain-expansion-matches-the-reference-library-for-the-bundled-pa', 'workflow-chain-host-expansion', `host bundles workflow-chain-sample ${body.packVersion}; this suite's fixture is ${PACK.version} — a host pack NEWER than the suite is unaccounted for`)).toBe(true);
-      softSkip('blocked', `host bundles workflow-chain-sample ${body.packVersion} (suite fixture ${PACK.version}) — the RFC 0157 chains are absent there until its conformance pin catches up`);
+      // No note here (until 2026-09-27 a blocked soft-skip turned this leg into
+      // a partial-witness pass): the chain this leg expands is identical in the
+      // older pack, so the comparison below is complete. The RFC 0157 legs,
+      // whose chains an older pack lacks, record their own `blocked`.
     }
     expect(typeof body.expansionId).toBe('string');
     expect(body.expansionId.length).toBeGreaterThan(0);
@@ -321,6 +324,9 @@ describe('workflow-chain-host-expansion: live host wraps expansion algorithm cor
       // the sign flipped.
       expect(res.status >= 400, req('openwop.it.workflow-chain-host-expansion.rfc-0157-a-chain-carrying-an-unwind-policy-is-refused-with-capability-required-o', 'compensation.md §"Workflow policy"', 'a non-advertising host MUST refuse a chain carrying `compensation` (policy) — 4xx, not 200')).toBe(true);
       expect(readErrorCode(res.json), req('openwop.it.workflow-chain-host-expansion.rfc-0157-a-chain-carrying-an-unwind-policy-is-refused-with-capability-required-o', 'capabilities.md §"Unsupported capability — refusal contract"', '`capability_required`')).toBe('capability_required');
+      // partial-witness-ok: the half of this requirement that binds a
+      // non-advertising host — refuse with capability_required — was observed
+      // above; the expand-on-an-advertiser half does not apply to this host.
       return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!advertises` returned early');
     }
     expect(res.status, req('openwop.it.workflow-chain-host-expansion.rfc-0157-a-chain-carrying-an-unwind-policy-is-refused-with-capability-required-o', 'workflow-chain-packs.md §"Compensation (RFC 0157)"', 'an advertising host expands the policy-carrying chain')).toBe(200);
@@ -338,6 +344,9 @@ describe('workflow-chain-host-expansion: live host wraps expansion algorithm cor
     if (body.settings?.compensation !== undefined) {
       expect(body.settings.compensation, req('openwop.it.workflow-chain-host-expansion.rfc-0157-a-chain-carrying-an-unwind-policy-is-refused-with-capability-required-o', 'workflow-chain-packs.md §"Compensation (RFC 0157)" rule 9b', 'the chain policy becomes settings.compensation, copied verbatim')).toEqual(expected.settingsCompensation);
     } else {
+      // partial-witness-ok: the node carry was observed above; echoing
+      // `settings` on the expand seam is host-optional, so the rule 9b policy
+      // carry is unobservable through it on a conforming host.
       softSkip('blocked', 'the expand seam does not echo `settings`, so the policy → settings.compensation carry (rule 9b) is unobservable through it; the node carry above was witnessed');
     }
   });

package/src/scenarios/workflow-variable-format.test.ts

@@ -48,7 +48,7 @@ import { behaviorGate } from '../lib/behavior-gate.js';
 import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { driver } from '../lib/driver.js';
-import { softSkip } from '../lib/soft-skip.js';
+import { softSkip, blockedDespiteAssertions } from '../lib/soft-skip.js';
 import { req } from '../lib/requirement-ids.js';
 const WORKFLOW_DEF = join(SCHEMAS_DIR, 'workflow-definition.schema.json');
 // S38 (2026-08-17): `spec/` is NOT in the published package (`files`), so a path built
@@ -193,7 +193,7 @@ describe('workflow-variable-format §B: host behaviour (RFC 0136, capability-gat
     if (res.status === 404) return softSkip('blocked', 'precondition not met — `res.status === 404` returned early (A host advertising deferredParameters but not yet serving the variables[]-returning seam extension soft-skips (404), as does a host with the seam disabled in…');
     expect(res.status, req('openwop.it.workflow-variable-format.b1-deferred-expansion-mints-format-onto-the-workflowvariable-string-copied-req-7', '§Deferred-parameter expansion', 'the deferred-expand seam returns 200')).toBe(200);
     const variables = (res.json as { variables?: Array<{ name: string; type?: string; format?: string }> }).variables;
-    if (!Array.isArray(variables)) return softSkip('blocked', 'precondition not met — `!Array.isArray(variables)` returned early (seam present but not returning variables[] yet — soft-skip) (seam, prior step, or fixture unavailable)'); // seam present but not returning variables[] yet — soft-skip
+    if (!Array.isArray(variables)) return blockedDespiteAssertions('the deferred-expand seam answered 200 without variables[] — the minted WorkflowVariable.format is unobserved');
     const fmt = (n: string): string | undefined => variables.find((v) => v.name === n)?.format;
 
     expect(fmt('email'), req('openwop.it.workflow-variable-format.b1-deferred-expansion-mints-format-onto-the-workflowvariable-string-copied-req-7', '§WorkflowVariable', 'req 7: a string param\'s recognised `format` is minted verbatim')).toBe('email');

package/src/scenarios/workload-identity-chain-bounds.test.ts

@@ -36,7 +36,7 @@ import { readErrorCode, readRetriable } from '../lib/error-envelope.js';
 import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
-import { seamAbsent, softSkip } from '../lib/soft-skip.js';
+import { seamAbsent, softSkip, blockedDespiteAssertions } from '../lib/soft-skip.js';
 import { req } from '../lib/requirement-ids.js';
 
 const DELEGATION_PROFILE = 'openwop-workload-identity-delegation';
@@ -94,7 +94,7 @@ describe('RFC 0154 §B — delegation chain bounds (capability-gated behavior)',
     const depth = caps.maxChainDepth as number;
     const chain = Array.from({ length: depth + 1 }, (_, i) => hop(i + 1));
     const r = await resolve({ identity: { ...IDENTITY, delegation: { chain, audience: 'openwop-host', expiresAt: LIVE } }, expectedAudience: 'openwop-host' });
-    if (r === null) return softSkip('blocked', 'precondition not met — `r === null` returned early (seam, prior step, or fixture unavailable)');
+    if (r === null) return blockedDespiteAssertions('the identity-resolve seam is unwired — the maxChainDepth refusal is unobserved');
     expectRefusal('openwop.it.workload-identity-chain-bounds.a-chain-longer-than-the-advertised-maxchaindepth-is-refused', r, 'delegation_chain_too_long', `a chain of ${depth + 1} hops exceeds the advertised bound of ${depth} — each hop is another party the host trusts transitively`);
   });
 
@@ -113,7 +113,10 @@ describe('RFC 0154 §B — delegation chain bounds (capability-gated behavior)',
       expect(r.status >= 400, req('openwop.it.workload-identity-chain-bounds.a-chain-that-revisits-a-subject-is-refused-as-cyclic', 'RFCS/0154 §B', 'a cyclic chain is refused')).toBe(true);
       expect(['delegation_chain_cyclic', 'delegation_chain_too_long'], req('openwop.it.workload-identity-chain-bounds.a-chain-that-revisits-a-subject-is-refused-as-cyclic', 'spec/v1/host-sample-test-seams.md §20', 'cyclic or too-long — the bound is below the cycle length')).toContain(readErrorCode(r.json));
       expect(readRetriable(r.json)).toBe(false);
-      return softSkip('blocked', 'precondition not met — `bound < 3` returned early (seam, prior step, or fixture unavailable)');
+      // partial-witness-ok: with maxChainDepth < 3 a 3-hop cyclic chain is also too long. The
+      // non-retriable refusal (either code) was asserted above; the cyclic-specific code cannot
+      // be told apart here.
+      return softSkip('inapplicable', 'maxChainDepth < 3: the cyclic chain is also too long, so the refusal was checked for either code');
     }
     expectRefusal('openwop.it.workload-identity-chain-bounds.a-chain-that-revisits-a-subject-is-refused-as-cyclic', r, 'delegation_chain_cyclic', 'a subject appearing twice is a chain that loops back through authority it already spent — unbounded laundering with a bounded length');
   });