@openwop/openwop-conformance 2.42.2 → 2.42.4

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

@@ -194,7 +194,13 @@ describe('mcp-tool-roundtrip: server wire shape', () => {
       );
       return softSkip('blocked', 'precondition not met — `!probe` returned early (seam, prior step, or fixture unavailable)');
     }
-    if (!probe.isReal) getMcpFakeServer()!.reset();
+    // unfailable-leg audit wave 2, 2026-09-27: with only the in-process fake
+    // configured, this leg probed the SUITE'S OWN fake MCP server and recorded
+    // `executed-pass` — every host passed it, conforming or not, because the
+    // host under test was never contacted. The fake-path self-check is now
+    // `inapplicable` before any assertion (the host-mediated leg below is the
+    // one that exercises the host against the fake).
+    if (!probe.isReal) return softSkip('inapplicable', 'suite fixture self-test — host not exercised (only the in-process MCP fake is configured; set OPENWOP_MCP_REAL_SERVER_URL for real-server interop evidence)');
 
     // Per MCP `initialize` spec, params MUST carry protocolVersion +
     // capabilities + clientInfo. The in-process fake accepts empty
@@ -258,26 +264,6 @@ describe('mcp-tool-roundtrip: server wire shape', () => {
         `[mcp-tool-roundtrip] real-server interop OK against ${probe.url} ` +
           `(tool=${first?.name}, isError=${callResult.isError === true})`,
       );
-    } else {
-      // Fake-server path: deterministic echo tool, assert verbatim.
-      expect(listResult.tools?.some((t) => t.name === 'echo')).toBe(true);
-
-      const call = await postJsonRpc(
-        probe.url,
-        'tools/call',
-        { name: 'echo', arguments: { text: 'hello-from-conformance' } },
-        3,
-      );
-      expect(call.status).toBe(200);
-      const callResult = (call.json.result ?? {}) as {
-        content?: ReadonlyArray<{ type?: string; text?: string }>;
-      };
-      expect(callResult.content?.[0]?.type).toBe('text');
-      expect(callResult.content?.[0]?.text).toBe('hello-from-conformance');
-
-      const fake = getMcpFakeServer()!;
-      const methods = fake.invocations().map((i) => i.method);
-      expect(methods).toEqual(['initialize', 'tools/list', 'tools/call']);
     }
   });
 });

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

@@ -19,7 +19,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';
@@ -90,7 +90,11 @@ describe('memory-compaction-provenance-tag: compacted-from:<id> tag follows §C
     if (listRes.status === 404) {
       // eslint-disable-next-line no-console
       console.warn('[rfc0012-tag] host does not expose memory:list at /v1/memory/{ref}; skipping tag inspection (canonical provenance signal remains the memory.compacted event itself)');
-      return softSkip('blocked', '[rfc0012-tag] host does not expose memory:list at /v1/memory/{ref}; skipping tag inspection (canonical provenance signal remains the memory.compacted event itself)');
+      // unfailable-leg audit wave 2, 2026-09-27: this return follows the seed/
+      // compact asserts, so a plain softSkip recorded a partial-witness
+      // `executed-pass` — a host whose compacted entry was never inspectable
+      // passed the tag requirement unobserved. Now `blocked`.
+      return blockedDespiteAssertions('[rfc0012-tag] host does not expose memory:list at /v1/memory/{ref}; skipping tag inspection (canonical provenance signal remains the memory.compacted event itself)');
     }
     expect(listRes.status, req('openwop.it.memory-compaction-provenance-tag.compacted-entry-carries-a-well-formed-compacted-from-tag-or-omits-it-cleanly-no', 'RFC 0012 §C', 'memory:list MUST return 200 when reachable')).toBe(200);
 
@@ -100,7 +104,11 @@ describe('memory-compaction-provenance-tag: compacted-from:<id> tag follows §C
     if (!output) {
       // eslint-disable-next-line no-console
       console.warn(`[rfc0012-tag] outputId ${outputId} not visible via memory:list; cannot inspect tags`);
-      return softSkip('blocked', '[rfc0012-tag] outputId … not visible via memory:list; cannot inspect tags');
+      // unfailable-leg audit wave 2, 2026-09-27: this return follows the seed/
+      // compact asserts, so a plain softSkip recorded a partial-witness
+      // `executed-pass` — a host whose compacted entry was never inspectable
+      // passed the tag requirement unobserved. Now `blocked`.
+      return blockedDespiteAssertions('[rfc0012-tag] outputId … not visible via memory:list; cannot inspect tags');
     }
     const tags = output.tags ?? [];
 

package/src/scenarios/orchestratorDispatch.test.ts

@@ -45,8 +45,8 @@ describe.skipIf(SKIP)('orchestratorDispatch: supervisor → dispatch → next-wo
     expect(terminal.status).toBe('completed');
 
     const events = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/events`);
-    const list = (events.json as { events?: Array<{ type: string; payload?: Record<string, unknown> }> })
-      .events ?? [];
+    const list = ((events.json as { events?: Array<{ type: string; sequence?: number; nodeId?: string; payload?: Record<string, unknown> }> })
+      .events ?? []).slice().sort((a, b) => (a.sequence ?? 0) - (b.sequence ?? 0));
 
     const decisions = list.filter((e) => e.type === 'runOrchestrator.decided');
     expect(decisions.length).toBeGreaterThan(0);
@@ -64,5 +64,21 @@ describe.skipIf(SKIP)('orchestratorDispatch: supervisor → dispatch → next-wo
     expect(decision.kind).toBe('next-worker');
     expect(Array.isArray(decision.nextWorkerIds)).toBe(true);
     expect(decision.nextWorkerIds.length).toBeGreaterThanOrEqual(1);
+
+    // unfailable-leg audit wave 2, 2026-09-27: the leg is named "decided
+    // {next-worker} BETWEEN supervisor + dispatch" but never read an order —
+    // a host that emitted the decision AFTER the dispatch node had already
+    // started (or never started the dispatch node at all) passed. The
+    // next-worker decision MUST precede the dispatch node's first node.started.
+    const nodeIdOf = (e: { nodeId?: string; payload?: Record<string, unknown> }): unknown => e.nodeId ?? e.payload?.nodeId;
+    const dispatchStarted = list.find((e) => e.type === 'node.started' && nodeIdOf(e) === 'dispatch');
+    expect(
+      dispatchStarted,
+      req('openwop.it.orchestratorDispatch.emits-runorchestrator-decided-next-worker-between-supervisor-dispatch', 'RFCS/0006-orchestrator.md', 'the dispatch node MUST emit node.started after the supervisor decides next-worker'),
+    ).toBeDefined();
+    expect(
+      typeof nextWorker!.sequence === 'number' && typeof dispatchStarted?.sequence === 'number' && nextWorker!.sequence < dispatchStarted.sequence,
+      req('openwop.it.orchestratorDispatch.emits-runorchestrator-decided-next-worker-between-supervisor-dispatch', 'RFCS/0006-orchestrator.md', 'runOrchestrator.decided{next-worker} MUST precede node.started{dispatch} in event-log sequence'),
+    ).toBe(true);
   });
 });

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

@@ -208,7 +208,14 @@ describe('pack-registry: read-endpoint shape contracts', () => {
       'node-packs.md §"GET /v1/packs/{name}/-/{version}.sig"',
       '404 response MUST carry a string `error` field — `signature_not_available` is the canonical code',
     )).toBe('string');
-    expect((body?.error as string).length).toBeGreaterThan(0);
+    // unfailable-leg audit wave 2, 2026-09-27: any non-empty `error` string
+    // (e.g. `not_found`) previously passed; node-packs.md names
+    // `404 signature_not_available` for all four cases (missing / yanked /
+    // unsigned / storage-unwired), intentionally indistinguishable.
+    expect(body?.error, req('openwop.it.pack-registry.get-v1-packs-name-version-sig-returns-404-signature-not-available-for-nonexisten', 
+      'node-packs.md §"GET /v1/packs/{name}/-/{version}.sig"',
+      'nonexistent (name, version) MUST return 404 `signature_not_available`',
+    )).toBe('signature_not_available');
   });
 
   it('GET /v1/packs/{bad-name}/-/{version}.json returns 400 invalid_pack_name', async () => {

package/src/scenarios/production-backpressure.test.ts

@@ -42,7 +42,7 @@ import { behaviorGate } from '../lib/behavior-gate.js';
 import { isFixtureAdvertised } from '../lib/fixtures.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 BackpressureCaps {
   supported?: boolean;
@@ -212,7 +212,10 @@ describe('production-backpressure: 503 envelope under saturation', () => {
         }
       }
       await Promise.allSettled(slotPromises);
-      return softSkip('blocked', 'precondition not met — `saturationEarlyExit` returned early (seam, prior step, or fixture unavailable)');
+      // unfailable-leg audit wave 2, 2026-09-27: this plain softSkip came
+      // AFTER up to cap-1 `create.status === 201` assertions, so the row was
+      // a partial-witness PASS although no 503 envelope was ever observed.
+      return blockedDespiteAssertions('inflight cap already saturated by parallel runs before the cap+1 probe (run with --no-file-parallelism) — 503 envelope not observed');
     }
 
     // Let SSE connections register.
@@ -233,7 +236,10 @@ describe('production-backpressure: 503 envelope under saturation', () => {
         console.warn(
           `[production-backpressure] expected 503 at cap+1=${cap + 1}, got ${blocked.status}; saturation may need tuning`,
         );
-        return softSkip('blocked', 'precondition not met — `blocked.status !== 503` returned early ([production-backpressure] expected 503 at cap+1=…, got …; saturation may need tuning) (seam, prior step, or fixture unavailable)');
+        // unfailable-leg audit wave 2, 2026-09-27: after `cap` × 201 asserts a
+        // plain softSkip recorded a partial-witness PASS — a host that never
+        // 503s at cap+1 passed the 503-envelope leg. Now `blocked`.
+        return blockedDespiteAssertions(`expected 503 at cap+1=${cap + 1}, got ${blocked.status} — saturation not reached (SSE slots may not have registered); 503 envelope not observed`);
       }
 
       const retryAfterHeader = blocked.headers.get('retry-after');
@@ -318,14 +324,14 @@ describe('production-backpressure: discovery exempt from cap', () => {
 
     const cap = prod?.backpressure?.inflightCap;
     if (cap === undefined) {
-      // Without advertised cap we can't saturate deterministically;
-      // fall back to a single discovery probe.
-      const probe = await driver.get('/.well-known/openwop');
-      expect(probe.status, req('openwop.it.production-backpressure.get-well-known-openwop-returns-200-even-when-inflight-is-saturated', 
-        'production-profile.md §Backpressure',
-        'discovery MUST answer regardless of load',
-      )).toBe(200);
-      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `cap === undefined` returned early');
+      // unfailable-leg audit wave 2, 2026-09-27: this used to take one UNLOADED
+      // discovery probe and then soft-skip, which recorded a partial-witness PASS
+      // for "returns 200 even when inflight is saturated", although nothing was
+      // saturated. The cap is OPTIONAL, so a host without one has nothing to
+      // saturate and the requirement does not bind it: `inapplicable`, before
+      // any assertion. It is not `blocked`, which would deny certification to a
+      // conforming host for a surface it may decline.
+      return softSkip('inapplicable', 'host does not advertise production.backpressure.inflightCap — there is no cap to saturate, so discovery-under-saturation does not bind');
     }
 
     // Issue many concurrent discovery probes; all MUST succeed.

package/src/scenarios/redaction.test.ts

@@ -187,6 +187,9 @@ describe('redaction: 401 response MUST NOT echo invalid Bearer token (NFR-7)', (
 
 describe.skipIf(SKIP_NO_NOOP)('redaction: credentialRef value MUST NOT appear in event payloads (gated on secrets.supported)', () => {
   it('skips when host does NOT advertise secrets.supported', async () => {
+    // Names the row id first (the registry takes the FIRST req() in a body as
+    // the explicitId) now that the tautological assert below is gone.
+    req('openwop.it.redaction.skips-when-host-does-not-advertise-secrets-supported', 'capabilities.md', 'a credentialRef value MUST NOT appear in any RunEvent payload');
     const cap = await driver.get('/.well-known/openwop', { authenticated: false });
     const supported =
       (cap.json as { secrets?: { supported?: boolean } } | undefined)?.secrets
@@ -194,8 +197,11 @@ describe.skipIf(SKIP_NO_NOOP)('redaction: credentialRef value MUST NOT appear in
 
     if (supported !== true) {
       // Spec-allowed — this scenario only applies to hosts that opt
-      // into BYOK. Pass trivially.
-      expect(supported, req('openwop.it.redaction.skips-when-host-does-not-advertise-secrets-supported', 'capabilities.md', 'skips when host does NOT advertise secrets.supported')).not.toBe(true);
+      // into BYOK. unfailable-leg audit wave 2, 2026-09-27: a tautological
+      // `expect(supported).not.toBe(true)` inside `if (supported !== true)`
+      // turned every non-BYOK host's row into an executed PASS of the
+      // credentialRef no-leak requirement; with zero assertions the row now
+      // records `inapplicable`.
       return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `supported !== true` returned early');
     }
 

package/src/scenarios/replay-fanout-suppression.test.ts

@@ -88,7 +88,7 @@
 
 import { afterEach, describe, expect, it } from 'vitest';
 import { createServer, type IncomingMessage, type Server, type ServerResponse } from 'node:http';
-import { softSkip } from '../lib/soft-skip.js';
+import { softSkip, blockedDespiteAssertions } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { forkDeclined } from '../lib/fork-availability.js';
 import { discoveryFamilies, readCapabilityFamily } from '../lib/discovery-capabilities.js';
@@ -313,7 +313,7 @@ describe('replay-fanout-suppression: a replay fork MUST NOT fan out re-emitted e
     }
     expect(replay.status, req('openwop.it.replay-fanout-suppression.delivers-for-a-live-run-suppresses-for-a-replay-fork-and-delivers-again-for-a-br', 'webhooks.md §"Register"', 'replay fork should be accepted')).toBe(201);
     const replayRunId = (replay.json as { runId: string }).runId;
-    await pollUntilTerminal(replayRunId, { timeoutMs: FORK_POLL_MS });
+    const replayTerminal = await pollUntilTerminal(replayRunId, { timeoutMs: FORK_POLL_MS });
     await quietWindow(SUPPRESSION_WINDOW_MS);
 
     expect(
@@ -342,6 +342,22 @@ describe('replay-fanout-suppression: a replay fork MUST NOT fan out re-emitted e
       ),
     ).toBeGreaterThan(0);
 
+    // unfailable-leg audit wave 2, 2026-09-27: a non-empty fork log was the
+    // only re-emission check, so a replay fork that FAILED (or never reached
+    // `run.completed`, the one event the webhook subscribes to) delivered
+    // nothing because it never re-emitted the subscribed event — and was
+    // recorded `executed-pass` for the suppression MUST NOT. The fork must
+    // terminate `completed` with `run.completed` in its own log before the
+    // absence of deliveries is evidence; otherwise `blocked`.
+    const forkReemittedCompleted = forkEventList.some((e) => e.type === 'run.completed');
+    if (replayTerminal.status !== 'completed' || !forkReemittedCompleted) {
+      const why = `replay fork ${replayRunId} terminated ${String(replayTerminal.status)}`
+        + `${forkReemittedCompleted ? '' : ' without run.completed in its event log'} — the subscribed event was never re-emitted, `
+        + 'so the absence of deliveries proves nothing';
+      recordRequirement(REQUIREMENT_ID, 'blocked', why);
+      return blockedDespiteAssertions(why);
+    }
+
     // The MUST NOT has now been exercised against wiring proven to deliver, on a
     // fork proven to have re-emitted. Recorded here rather than after leg 3,
     // because leg 3 pins the boundary and may legitimately not run.

package/src/scenarios/runner-ledger.test.ts

@@ -270,11 +270,16 @@ describe('RFC 0148 §A (S6) — the live sink, when this run was given one', ()
   it('files that finished before this one appear in the ledger file with an assertion count', () => {
     const path = process.env['OPENWOP_LEDGER_PATH'];
     if (!path || !existsSync(path)) return softSkip('blocked', 'precondition not met — `!path || !existsSync(path)` returned early (not a --certify run; nothing to inspect) (seam, prior step, or fixture unavailable)'); // not a --certify run; nothing to inspect
-    const entries = readLedgerFile(path);
     // At least the in-memory ledger of THIS worker has file-level entries for
     // earlier files (setup.ts afterAll), and each carries assertionCount.
+    //
+    // unfailable-leg audit wave 2, 2026-09-27: the leg ended with
+    // `expect(entries.length).toBeGreaterThanOrEqual(0)` — a tautology (and a
+    // bare expect with no req()) that made the leg an `executed-pass` even when
+    // `fileEntries` was empty and the loop asserted nothing. Removed; an empty
+    // set now says so instead of passing vacuously.
     const fileEntries = snapshot().filter((e) => e.requirementId.startsWith('openwop.scenario.') || e.requirementId.startsWith('openwop.floor.'));
+    if (fileEntries.length === 0) return softSkip('inapplicable', 'no file-level ledger entries recorded in this worker before this leg — nothing to inspect');
     for (const e of fileEntries) expect(typeof e.assertionCount, req('openwop.it.runner-ledger.files-that-finished-before-this-one-appear-in-the-ledger-file-with-an-assertion', 'RFC 0148 §A', 'files that finished before this one appear in the ledger file with an assertion count')).toBe('number');
-    expect(entries.length).toBeGreaterThanOrEqual(0);
   });
 });

package/src/scenarios/stream-modes.test.ts

@@ -132,6 +132,33 @@ describe.skipIf(SKIP_NO_FIXTURE)('stream-modes: debug emits at least as many eve
       'debug stream event count MUST be >= updates stream event count',
     )).toBeGreaterThanOrEqual(updatesResult.events.length);
 
+    // unfailable-leg audit wave 2, 2026-09-27: superset-by-COUNT alone passed a
+    // host whose debug stream dropped canonical types (e.g. no run.completed)
+    // as long as it padded the count with other frames (log.appended,
+    // keep-alive-ish events). The mapping table is per TYPE: every type the
+    // updates stream carried MUST appear in debug, and debug MUST carry
+    // node.started (✅ debug / — updates) — the conformance-delay fixture has
+    // one node (`wait`), so a debug stream without node.started is filtering.
+    const typeOf = (e: SseEvent): string => {
+      if (e.event !== 'message') return e.event;
+      try {
+        const t = (JSON.parse(e.data) as { type?: unknown }).type;
+        return typeof t === 'string' ? t : e.event;
+      } catch {
+        return e.event;
+      }
+    };
+    const debugTypes = new Set(debugResult.events.map(typeOf));
+    const missingFromDebug = [...new Set(updatesResult.events.map(typeOf))].filter((t) => !debugTypes.has(t));
+    expect(missingFromDebug, req('openwop.it.stream-modes.debug-stream-is-a-superset-of-updates-per-stream-modes-md-mode-mapping', 
+      'stream-modes.md §Mode-to-event mapping',
+      'every event type emitted in updates mode is also ✅ in debug mode — debug MUST carry each of them',
+    )).toEqual([]);
+    expect([...debugTypes], req('openwop.it.stream-modes.debug-stream-is-a-superset-of-updates-per-stream-modes-md-mode-mapping', 
+      'stream-modes.md §Mode-to-event mapping',
+      'debug mode MUST emit node.started (✅ debug) for the fixture\'s node',
+    )).toContain('node.started');
+
     expect(debugResult.closedBy, req('openwop.it.stream-modes.debug-stream-is-a-superset-of-updates-per-stream-modes-md-mode-mapping', 
       'stream-modes.md §debug',
       'debug stream MUST close on terminal event',

package/src/scenarios/tool-catalog-projection.test.ts

@@ -55,7 +55,7 @@ import {
   TOOL_CONTENT_FORBIDDEN,
 } from '../lib/toolCatalog.js';
 import { req } from '../lib/requirement-ids.js';
-import { softSkip } from '../lib/soft-skip.js';
+import { softSkip, seamAbsent } from '../lib/soft-skip.js';
 
 function loadSchema(name: string): Record<string, unknown> {
   return JSON.parse(readFileSync(join(SCHEMAS_DIR, name), 'utf8')) as Record<string, unknown>;
@@ -92,8 +92,23 @@ describe('tool-catalog-projection (RFC 0078 §B/§F)', () => {
     ).toBe(true);
 
     // ---- Leg 1: the list (§B) -------------------------------------------
-    const tools = await listTools();
-    if (tools === null) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `tools === null` returned early (host advertises the cap but doesn\'t serve the read — soft-skip the rest)'); // host advertises the cap but doesn't serve the read — soft-skip the rest
+    // unfailable-leg audit wave 2, 2026-09-27: a host that ADVERTISES the
+    // catalog but 404s the list (or answers 500 / a non-list 200, which the
+    // old `listTools` read as `[]`) previously recorded a partial-witness pass
+    // after the 401 assertion. An unserved read is now `seamAbsent` (blocked;
+    // fails under OPENWOP_REQUIRE_BEHAVIOR=true), and any other non-200 or
+    // non-list body FAILS.
+    const read = await listTools();
+    if (read.unserved) return seamAbsent(`host advertises toolCatalog but ${toolsPath()} answered ${read.status}`);
+    expect(
+      read.status,
+      req('openwop.it.tool-catalog-projection.lists-schema-valid-tooldescriptors-serves-by-id-404s-is-auth-gated-and-never-dis', 'tool-catalog.md §B', `GET ${toolsPath()} MUST return 200 to an authenticated caller on a host advertising toolCatalog`),
+    ).toBe(200);
+    expect(
+      read.tools !== null,
+      req('openwop.it.tool-catalog-projection.lists-schema-valid-tooldescriptors-serves-by-id-404s-is-auth-gated-and-never-dis', 'tool-catalog.md §B', `GET ${toolsPath()} MUST return a ToolDescriptor[]`),
+    ).toBe(true);
+    const tools = read.tools ?? [];
 
     for (const t of tools) {
       const v = validate(t);
@@ -116,12 +131,18 @@ describe('tool-catalog-projection (RFC 0078 §B/§F)', () => {
     if (tools.length > 0 && typeof tools[0]!.toolId === 'string') {
       const id = tools[0]!.toolId as string;
       const one = await getTool(id);
-      if (one.status === 200) {
-        expect(
-          one.descriptor?.toolId === id,
-          req('openwop.it.tool-catalog-projection.lists-schema-valid-tooldescriptors-serves-by-id-404s-is-auth-gated-and-never-dis', 'tool-catalog.md §B', 'GET /v1/tools/{toolId} MUST return the requested descriptor'),
-        ).toBe(true);
-      }
+      // unfailable-leg audit wave 2, 2026-09-27: the by-id check used to run
+      // only `if (one.status === 200)`, so a host that 404'd (or 500'd) the
+      // by-id read of a tool its own list returned passed. A listed tool is
+      // one the caller may see; its by-id read MUST serve it.
+      expect(
+        one.status,
+        req('openwop.it.tool-catalog-projection.lists-schema-valid-tooldescriptors-serves-by-id-404s-is-auth-gated-and-never-dis', 'tool-catalog.md §B', 'GET /v1/tools/{toolId} MUST return 200 for a toolId the caller\'s own list returned'),
+      ).toBe(200);
+      expect(
+        one.descriptor?.toolId === id,
+        req('openwop.it.tool-catalog-projection.lists-schema-valid-tooldescriptors-serves-by-id-404s-is-auth-gated-and-never-dis', 'tool-catalog.md §B', 'GET /v1/tools/{toolId} MUST return the requested descriptor'),
+      ).toBe(true);
     }
     const unknown = await getTool('__conformance_nonexistent_tool__');
     expect(
@@ -142,9 +163,11 @@ describe('tool-catalog-projection (RFC 0078 §B/§F)', () => {
 
   it('advisory (SHOULD): an unchanged catalog reads identically, sorted by toolId', async () => {
     if (!(await toolCatalogGate('openwop-tool-catalog'))) return;
-    const a = await listTools();
-    const b = await listTools();
-    if (a === null || b === null) return softSkip('inapplicable', 'the host advertises the catalog but does not serve the list read');
+    const ra = await listTools();
+    const rb = await listTools();
+    const a = ra.tools;
+    const b = rb.tools;
+    if (a === null || b === null) return softSkip('inapplicable', `the list read did not return a ToolDescriptor[] (status ${ra.status}/${rb.status}); the normative leg above records that — this advisory leg is never failed`);
     const ids = (l: ReadonlyArray<{ toolId?: unknown }>) => l.map((t) => String(t.toolId));
     const first = ids(a); const second = ids(b);
     const sorted = [...first].sort((x, y) => (x < y ? -1 : x > y ? 1 : 0));

package/src/scenarios/v2-advertised-fixtures-exist.test.ts

@@ -65,9 +65,16 @@ describe('v2-advertised-fixtures-exist (RFC 0168 §C.3)', () => {
     const ids = advertisedIds(doc);
     if (ids.length === 0) return softSkip('inapplicable', 'the host advertises no fixtures[]');
 
-    // Deterministic sample: the first N by sort order, so a failure is
+    // Deterministic sample spread across the sorted list, so a failure is
     // reproducible and a host cannot pass by luck of ordering.
-    const sample = [...ids].sort().slice(0, SAMPLE);
+    // Unfailable-leg audit, 2026-09-26: the sample was the first N by sort
+    // order, so an unseeded fixture sorting 6th or later was never attempted.
+    // Indices round(i*(n-1)/(SAMPLE-1)), deduped, reach both ends and between.
+    const sorted = [...new Set(ids)].sort();
+    const picks = sorted.length <= SAMPLE
+      ? sorted.map((_, i) => i)
+      : Array.from({ length: SAMPLE }, (_, i) => Math.round((i * (sorted.length - 1)) / (SAMPLE - 1)));
+    const sample = [...new Set(picks)].map((i) => sorted[i]!);
     const unreachable: string[] = [];
     let attempted = 0;
     for (const id of sample) {
@@ -79,7 +86,14 @@ describe('v2-advertised-fixtures-exist (RFC 0168 §C.3)', () => {
       // 201 is the claim honoured. A 4xx that names the workflow as unknown is
       // the drift this leg exists to catch; any other status is a different
       // problem and is not judged here.
-      if (res.status !== 201) unreachable.push(`${id} → ${res.status}`);
+      // The comment above always said only an unknown-workflow refusal is
+      // judged, but the code counted ANY non-201. The 2026-09-26 audit's wider
+      // sample then hit fixtures that need an Idempotency-Key or specific
+      // inputs (a validation 4xx) and failed a conforming host. v2 has no
+      // dedicated unknown-workflow code, so the signal is 404, or a 4xx whose
+      // details.field names workflowId.
+      const field = (res.json as { details?: { field?: unknown } } | null)?.details?.field;
+      if (res.status === 404 || (res.status >= 400 && res.status < 500 && field === 'workflowId')) unreachable.push(`${id} → ${res.status}`);
     }
     if (attempted === 0) return softSkip('blocked', 'no advertised fixture could be attempted');
     expect(

package/src/scenarios/v2-artifact-a2a-shape.test.ts

@@ -118,12 +118,18 @@ describe('RFC 0205 §A.3 — a url Part does not resolve beyond the caller\'s au
     const tenantB = process.env['OPENWOP_TEST_TENANT_B_API_KEY'];
     if (!tenantB) return softSkip('blocked', 'the artifact carries a url Part but OPENWOP_TEST_TENANT_B_API_KEY is not supplied — the second-tenant leg cannot run');
     const base = loadEnv().baseUrl;
+    // unfailable-leg audit, 2026-09-26: the probes use redirect:'manual' and
+    // only failed on a 2xx, so a url that answered 302 to a public pre-signed
+    // object-store URL — readable by tenant B and by anyone — passed. A 3xx is
+    // the host resolving the url for that caller; the only answers that do not
+    // resolve it are a refusal (401/403) or a non-disclosing 404.
+    const REFUSED = new Set([401, 403, 404]);
     for (const u of urls) {
       const abs = new URL(u, base).toString();
       const asB = await fetch(abs, { headers: { Authorization: `Bearer ${tenantB}` }, redirect: 'manual' });
-      expect(asB.status >= 200 && asB.status < 300, req('openwop.requirement.0205.artifact-url-part-scoped', 'RFC 0205 §A.3', `${abs} MUST NOT answer 2xx to tenant B's credential (got ${asB.status})`)).toBe(false);
+      expect(REFUSED.has(asB.status), req('openwop.requirement.0205.artifact-url-part-scoped', 'RFC 0205 §A.3', `${abs} MUST NOT resolve for tenant B's credential: expected 401/403/404, got ${asB.status}${asB.status >= 300 && asB.status < 400 ? ` (a redirect to ${asB.headers.get('location') ?? 'no Location'} resolves the url)` : ''}`)).toBe(true);
       const anon = await fetch(abs, { redirect: 'manual' });
-      expect(anon.status >= 200 && anon.status < 300, req('openwop.requirement.0205.artifact-url-part-scoped', 'RFC 0205 §A.3', `${abs} MUST NOT answer 2xx with no credential (got ${anon.status})`)).toBe(false);
+      expect(REFUSED.has(anon.status), req('openwop.requirement.0205.artifact-url-part-scoped', 'RFC 0205 §A.3', `${abs} MUST NOT resolve with no credential: expected 401/403/404, got ${anon.status}${anon.status >= 300 && anon.status < 400 ? ` (a redirect to ${anon.headers.get('location') ?? 'no Location'} resolves the url)` : ''}`)).toBe(true);
     }
   });
 });

package/src/scenarios/v2-bound-id-kinds.test.ts

@@ -221,9 +221,14 @@ describe('v2 bound-id kinds (identity.md §5, RFC 0187 §A)', () => {
     const res = await http(() => driver.get(`/runs/${projectBoundId(runId)}/effects`));
     if (res === null) return softSkip('blocked', 'GET /runs/{runId}/effects unreachable (fetch failed)');
     if (res.status === 404 || res.status === 405) return softSkip('inapplicable', `the host advertises idempotency but serves no effect ledger at /runs/{runId}/effects (${res.status})`);
-    expect(res.status, req(PER_KIND, 'security-defaults.md §Layer-2 effect identity', 'GET /runs/{runId}/effects MUST answer 200')).toBe(200);
     const effects = ((res.json as { effects?: Array<Record<string, unknown>> } | null)?.effects ?? []);
-    if (effects.length === 0) return softSkip('inapplicable', 'the noop fixture records no effects — no effectId on the wire to read (a host with an effect-producing fixture witnesses this leg)');
+    // Unfailable-leg audit (2026-09-26): the status assert used to precede this
+    // empty check, so on every host (the noop fixture records no effects) the
+    // leg asserted 200 then soft-skipped — `executed-pass` partial-witness folded
+    // into the shared per-kind row with no effectId ever read. The empty 200 now
+    // returns before any assertion.
+    if (res.status === 200 && effects.length === 0) return softSkip('inapplicable', 'the noop fixture records no effects — no effectId on the wire to read (a host with an effect-producing fixture witnesses this leg)');
+    expect(res.status, req(PER_KIND, 'security-defaults.md §Layer-2 effect identity', 'GET /runs/{runId}/effects MUST answer 200')).toBe(200);
     for (const e of effects) expectBound(e['effectId'], 'effectId', 'GET /runs/{runId}/effects', PER_KIND);
   });
 
@@ -244,9 +249,13 @@ describe('v2 bound-id kinds (identity.md §5, RFC 0187 §A)', () => {
     try {
     const res = await http(() => driver.get(`/webhooks/${projectBoundId(webhookId)}/dead-letters`));
     if (res === null) return softSkip('blocked', 'GET /webhooks/{webhookId}/dead-letters unreachable (fetch failed)');
-    expect(res.status, req(PER_KIND, 'RFC 0188 §A.1', 'a host advertising webhooks.deadLetter MUST serve the dead-letter read (200)')).toBe(200);
     const rows = ((res.json as { deliveries?: Array<Record<string, unknown>> } | null)?.deliveries ?? []);
-    if (rows.length === 0) return softSkip('inapplicable', 'the subscription has no dead-lettered delivery in this run — the read is served and the shape is unwitnessed here; v2-webhook-durable-delivery drives an exhaustion and asserts the record');
+    // Unfailable-leg audit (2026-09-26): as with effectId above, the 200 assert
+    // preceded the empty check, so a fresh subscription (always empty) recorded
+    // `executed-pass` partial-witness with no deliveryId read. Empty-200 now
+    // returns before any assertion.
+    if (res.status === 200 && rows.length === 0) return softSkip('inapplicable', 'the subscription has no dead-lettered delivery in this run — the read is served and the shape is unwitnessed here; v2-webhook-durable-delivery drives an exhaustion and asserts the record');
+    expect(res.status, req(PER_KIND, 'RFC 0188 §A.1', 'a host advertising webhooks.deadLetter MUST serve the dead-letter read (200)')).toBe(200);
     for (const r of rows) expectBound(r['deliveryId'], 'deliveryId', 'GET /webhooks/{webhookId}/dead-letters', PER_KIND);
     } finally {
       await http(() => driver.delete(`/webhooks/${projectBoundId(webhookId)}`));