@openwop/openwop-conformance 2.42.3 → 2.42.5

package/src/scenarios/audit-log-integrity.test.ts

@@ -21,6 +21,30 @@ import { behaviorGate } from '../lib/behavior-gate.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 import { req } from '../lib/requirement-ids.js';
 import { softSkip } from '../lib/soft-skip.js';
+import Ajv2020 from 'ajv/dist/2020.js';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { SCHEMAS_DIR } from '../lib/paths.js';
+
+/**
+ * audit-verify-result.schema.json with every `additionalProperties: false`
+ * relaxed: the REQUIRED members and their types are enforced, extra members
+ * are not (the reference postgres host emits `checkpointsValid` and a
+ * per-checkpoint `verified` bit; convicting extras is a separate decision).
+ */
+function relaxAdditional(node: unknown): unknown {
+  if (Array.isArray(node)) return node.map(relaxAdditional);
+  if (node === null || typeof node !== 'object') return node;
+  const out: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(node as Record<string, unknown>)) {
+    if (k === 'additionalProperties' && v === false) continue;
+    out[k] = relaxAdditional(v);
+  }
+  return out;
+}
+const VERIFY_RESULT_SCHEMA = relaxAdditional(
+  JSON.parse(readFileSync(join(SCHEMAS_DIR, 'audit-verify-result.schema.json'), 'utf8')),
+) as Record<string, unknown>;
 
 interface AuditIntegrityCaps {
   hashChain?: boolean;
@@ -90,6 +114,19 @@ describe('audit-log-integrity: verify endpoint returns chainValid', () => {
       anomalies?: unknown[];
     };
 
+    // unfailable-leg audit wave 2, 2026-09-27: a body that OMITTED
+    // `checkpoints` (or sent malformed checkpoint objects) passed — the
+    // signature check below ran only `if (Array.isArray(body.checkpoints) &&
+    // length > 0)`. The body is now validated against
+    // audit-verify-result.schema.json (checkpoints[] + anomalies[] required;
+    // each checkpoint needs checkpoint/atSequence/merkleRoot/signature).
+    const validate = new Ajv2020({ strict: false, allErrors: true }).compile(VERIFY_RESULT_SCHEMA);
+    const shapeOk = validate(body);
+    expect(shapeOk, req('openwop.it.audit-log-integrity.get-v1-audit-verify-on-a-recent-range-reports-chainvalid-true',
+      'audit-verify-result.schema.json',
+      `GET /v1/audit/verify MUST return the AuditVerifyResult shape: ${JSON.stringify(validate.errors ?? [])}`,
+    )).toBe(true);
+
     expect(body.chainValid, req('openwop.it.audit-log-integrity.get-v1-audit-verify-on-a-recent-range-reports-chainvalid-true', 
       'auth-profiles.md §"Audit-log integrity"',
       'unmodified audit range MUST report chainValid: true',

package/src/scenarios/context-budget-transcript-bound.test.ts

@@ -61,7 +61,7 @@ import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
 import { queryTestEvents } from '../lib/event-log-query.js';
 import { req } from '../lib/requirement-ids.js';
-import { softSkip, seamAbsent } from '../lib/soft-skip.js';
+import { blockedDespiteAssertions, softSkip, seamAbsent } from '../lib/soft-skip.js';
 import { seamsProfileAdvertised, targetMajor } from '../lib/seams.js';
 import { familyAdvertised, v2Discovery } from '../lib/v2.js';
 import { runsPath } from '../lib/memoryAttribution.js';
@@ -117,7 +117,11 @@ describe('context-budget-transcript-bound (RFC 0111 §"Context economy")', () =>
     for (let iteration = 1; iteration <= MAX_ITERATIONS_PROBED; iteration += 1) {
       const res = await driver.get(`/v1/host/sample/agent/transcript-window?runId=${encodeURIComponent(runId)}&iteration=${iteration}`);
       if (res.status === 404 || res.status === 405) {
-        if (iteration === 1) return major === 2 ? seamAbsent(`contextBudget is advertised but the transcript-window seam answered ${res.status} (host-sample-test-seams.md §14)`) : softSkip('blocked', `the transcript-window seam answered ${res.status} (host-sample-test-seams.md §14)`);
+        // unfailable-leg audit wave 2, 2026-09-27: the major-1 branch was
+        // `softSkip('blocked')` after the create/runId asserts, which records a
+        // partial-witness PASS — a host with no transcript-window seam passed
+        // the transcript bound without a single window being read.
+        if (iteration === 1) return major === 2 ? seamAbsent(`contextBudget is advertised but the transcript-window seam answered ${res.status} (host-sample-test-seams.md §14)`) : blockedDespiteAssertions(`the transcript-window seam answered ${res.status} (host-sample-test-seams.md §14)`);
         break;
       }
       if (res.status === 400 || res.status === 422) break;
@@ -151,7 +155,13 @@ describe('context-budget-transcript-bound (RFC 0111 §"Context economy")', () =>
       }
     }
 
-    if (log === null) return softSkip('blocked', 'the run event-log seam is unavailable, so the real-event, recent-tail and pressure rules were not measured');
-    if (!pressure) softSkip('inapplicable', `no iteration shows budget pressure — every eligible event fit under transcriptTokenBudget ${budget}, so the bound was never exercised (a budget the run never reaches is not a witness)`);
+    // unfailable-leg audit wave 2, 2026-09-27: both returns below were plain
+    // soft-skips after assertions, i.e. partial-witness PASSES. A host whose
+    // event log was unreadable (real-event / recent-tail rules unmeasured), or
+    // whose run never put the budget under pressure (the bound never
+    // exercised — any host "fits" a budget it never reaches), certified the
+    // transcript bound it was never observed to enforce.
+    if (log === null) return blockedDespiteAssertions('the run event-log seam is unavailable, so the real-event, recent-tail and pressure rules were not measured');
+    if (!pressure) return blockedDespiteAssertions(`no iteration shows budget pressure — every eligible event fit under transcriptTokenBudget ${budget}, so the bound was never exercised (a budget the run never reaches is not a witness)`);
   }, liveScenarioTimeoutMs(1));
 });

package/src/scenarios/context-summarization-replay.test.ts

@@ -44,7 +44,7 @@ import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
 import { queryTestEvents, type TestEvent } from '../lib/event-log-query.js';
 import { req } from '../lib/requirement-ids.js';
-import { softSkip } from '../lib/soft-skip.js';
+import { softSkip, blockedDespiteAssertions } from '../lib/soft-skip.js';
 import { seamsProfileAdvertised, targetMajor } from '../lib/seams.js';
 import { familyAdvertised, v2Discovery } from '../lib/v2.js';
 import { runsPath } from '../lib/memoryAttribution.js';
@@ -120,31 +120,40 @@ describe('context-summarization-replay (RFC 0111 §"Replay determinism")', () =>
     }
     if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', `the live fixture ${FIXTURE} is not advertised — RFC 0111 §Scope forbids a mock supervisor from advertising contextBudget`);
 
+    // unfailable-leg audit wave 2, 2026-09-27: the replay-mode gate moved ABOVE the
+    // create — after the 201 assert it recorded a partial-witness `executed-pass`
+    // for a host that never replayed anything.
+    if (!replayModesOf(wellKnown).includes('replay')) return softSkip('inapplicable', 'the host advertises no replay fork mode');
+
     const create = await driver.post(runsPath(), { workflowId: FIXTURE });
     expect(create.status, req(ID, 'RFC 0111', `POST ${runsPath()} MUST create the live-fixture run`)).toBe(201);
     const sourceRunId = runIdOf(create.json);
     expect(sourceRunId, req(ID, 'rest-endpoints.md POST /v1/runs', 'the create response MUST carry a runId')).toBeDefined();
-    if (sourceRunId === undefined) return softSkip('blocked', 'no runId');
+    if (sourceRunId === undefined) return blockedDespiteAssertions('no runId');
     await pollUntilTerminal(sourceRunId, { timeoutMs: LIVE_RUN_POLL_MS });
+    // unfailable-leg audit wave 2, 2026-09-27: every early return below follows the
+    // create's 201 assert, so a plain softSkip recorded a partial-witness
+    // `executed-pass` — a host whose event log was unreadable, that never
+    // summarized, or whose fork 404'd passed without the replay requirement
+    // (reuse of the recorded summaryRef) ever being observed. Now `blocked`.
 
     const sourceQ = await queryTestEvents(sourceRunId);
-    if (!sourceQ.ok) return softSkip('blocked', 'the run event-log seam is unavailable');
+    if (!sourceQ.ok) return blockedDespiteAssertions('the run event-log seam is unavailable — summaryRef reuse unobserved');
     const sourceFingerprints = summaryFingerprints(sourceQ.events);
     if (sourceFingerprints.length === 0) {
-      return softSkip('blocked', 'the live run produced no context.summarized event — a host advertising summarization must summarize this fixture for reuse to be observable');
+      return blockedDespiteAssertions('the live run produced no context.summarized event — a host advertising summarization must summarize this fixture for reuse to be observable');
     }
-    if (!replayModesOf(wellKnown).includes('replay')) return softSkip('inapplicable', 'the host advertises no replay fork mode');
 
     const fork = await driver.post(`${runsPath()}/${encodeURIComponent(sourceRunId)}:fork`, { fromSeq: 0, mode: 'replay' });
-    if (fork.status === 501 || fork.status === 404) return softSkip('blocked', `replay fork answered ${fork.status}`);
+    if (fork.status === 501 || fork.status === 404) return blockedDespiteAssertions(`replay fork answered ${fork.status} — summaryRef reuse unobserved`);
     expect(fork.status, req(ID, 'rest-endpoints.md POST /v1/runs/{runId}:fork', 'replay fork MUST return 201')).toBe(201);
     const forkRunId = runIdOf(fork.json);
     expect(forkRunId, req(ID, 'rest-endpoints.md POST /v1/runs/{runId}:fork', 'replay fork MUST return a runId')).toBeDefined();
-    if (forkRunId === undefined) return softSkip('blocked', 'no fork runId');
+    if (forkRunId === undefined) return blockedDespiteAssertions('no fork runId');
     await pollUntilTerminal(forkRunId, { timeoutMs: LIVE_RUN_POLL_MS });
 
     const forkQ = await queryTestEvents(forkRunId);
-    if (!forkQ.ok) return softSkip('blocked', 'the event-log seam is unavailable for the fork');
+    if (!forkQ.ok) return blockedDespiteAssertions('the event-log seam is unavailable for the fork — summaryRef reuse unobserved');
     expect(summaryFingerprints(forkQ.events), req(ID, 'RFC 0111 §"Replay determinism"', 'a replay fork MUST reuse the recorded context.summarized summaryRef (never re-summarize to a different transcript)')).toEqual(sourceFingerprints);
 
     // The model-facing half: the summary TEXT the host fed on the fork.

package/src/scenarios/conversationLifecycle.test.ts

@@ -35,7 +35,13 @@ describe.skipIf(SKIP)('conversationLifecycle: open → exchange → close round-
 
     // The fixture's exchange step requires resume input. Host-internal
     // mock auto-resumes for conformance.
-    await pollUntilTerminal(runId);
+    const terminal = await pollUntilTerminal(runId);
+    // unfailable-leg audit wave 2, 2026-09-27: the leg never checked the
+    // exchange happened or the run finished — a host emitting only
+    // `conversation.opened` + `conversation.closed` (zero exchanges, so the CO-3
+    // "no exchange after close" check is vacuous) in a run that FAILED passed.
+    // The fixture performs exactly one exchange (mockAutoResume) and completes.
+    expect(terminal.status, req('openwop.it.conversationLifecycle.emits-all-three-lifecycle-events-with-matching-conversationid-no-exchanges-after', 'RFCS/0005-conversation.md', 'the open → exchange → close fixture run MUST terminate `completed`')).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> }> })
@@ -47,6 +53,7 @@ describe.skipIf(SKIP)('conversationLifecycle: open → exchange → close round-
 
     expect(opened.length).toBeGreaterThan(0);
     expect(closed.length).toBeGreaterThan(0);
+    expect(exchanged.length, req('openwop.it.conversationLifecycle.emits-all-three-lifecycle-events-with-matching-conversationid-no-exchanges-after', 'RFCS/0005-conversation.md', '`conversation.exchanged` MUST be emitted for the fixture\'s one exchange turn')).toBeGreaterThan(0);
 
     // All three event types MUST share the same conversationId for the
     // fixture's single conversation.
@@ -62,5 +69,9 @@ describe.skipIf(SKIP)('conversationLifecycle: open → exchange → close round-
       .slice(closedIdx + 1)
       .filter((e) => e.type === 'conversation.exchanged' && e.payload?.conversationId === convId);
     expect(exchangedAfterClose.length).toBe(0);
+    // ...and the exchange this run DID emit precedes the close (open → exchange → close).
+    let lastExchangedIdx = -1;
+    list.forEach((e, i) => { if (e.type === 'conversation.exchanged' && e.payload?.conversationId === convId) lastExchangedIdx = i; });
+    expect(lastExchangedIdx >= 0 && lastExchangedIdx < closedIdx, req('openwop.it.conversationLifecycle.emits-all-three-lifecycle-events-with-matching-conversationid-no-exchanges-after', 'RFCS/0005-conversation.md (CO-3)', `the last conversation.exchanged (index ${lastExchangedIdx}) MUST precede conversation.closed (index ${closedIdx})`)).toBe(true);
   });
 });

package/src/scenarios/conversationReplayDeterminism.test.ts

@@ -21,12 +21,22 @@ import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { isConversationPrimitiveSupported } from '../lib/multi-agent-capabilities.js';
 import { softSkip } from '../lib/soft-skip.js';
 import { req } from '../lib/requirement-ids.js';
+import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
 
 const FIXTURE = 'conformance-conversation-replay';
 const SKIP = !isConversationPrimitiveSupported() || !isFixtureAdvertised(FIXTURE);
 
 describe.skipIf(SKIP)('conversationReplayDeterminism: replay-fork preserves conversation log', () => {
   it('forked run yields byte-equal conversation channel projection', async () => {
+    // unfailable-leg audit wave 2, 2026-09-27: the replay-fork gate used to be
+    // the fork response itself (404/501 → soft-skip 'inapplicable'), reached
+    // only AFTER the create/terminal asserts — a host with no fork surface
+    // recorded a partial-witness pass. Gate on the advertised `replay.modes`
+    // BEFORE any assertion; once `replay` is advertised, a 404/501 fork fails.
+    const replayCap = await readCapabilityFamily<{ supported?: unknown; modes?: unknown }>('replay');
+    const modes = replayCap?.supported === true && Array.isArray(replayCap.modes) ? replayCap.modes : [];
+    if (!modes.includes('replay')) return softSkip('inapplicable', 'host does not advertise replay.modes including "replay"');
+
     const create = await driver.post('/v1/runs', { workflowId: FIXTURE });
     expect(create.status, req('openwop.it.conversationReplayDeterminism.forked-run-yields-byte-equal-conversation-channel-projection', 'RFCS/0005-conversation.md', 'forked run yields byte-equal conversation channel projection')).toBe(201);
     const sourceRunId = (create.json as { runId: string }).runId;
@@ -36,12 +46,18 @@ describe.skipIf(SKIP)('conversationReplayDeterminism: replay-fork preserves conv
 
     const sourceSnap = await driver.get(`/v1/runs/${encodeURIComponent(sourceRunId)}`);
     const sourceConv = (sourceSnap.json as { channels?: Record<string, unknown> }).channels;
+    // unfailable-leg audit wave 2, 2026-09-27: a host that projected NO
+    // channels on either run compared `undefined` to `undefined` and passed
+    // "byte-equal". The source projection must exist and be non-empty first.
+    expect(
+      sourceConv !== null && typeof sourceConv === 'object' && !Array.isArray(sourceConv) && Object.keys(sourceConv).length > 0,
+      req('openwop.it.conversationReplayDeterminism.forked-run-yields-byte-equal-conversation-channel-projection', 'RFCS/0005-conversation.md', 'the source run of a conversation fixture MUST project a non-empty channels object'),
+    ).toBe(true);
 
     const fork = await driver.post(`/v1/runs/${encodeURIComponent(sourceRunId)}:fork`, {
       mode: 'replay',
     });
-    if (fork.status === 404 || fork.status === 501) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `fork.status === 404 || fork.status === 501` returned early (host doesn\'t support replay-fork)'); // host doesn't support replay-fork
-    expect([200, 201]).toContain(fork.status);
+    expect([200, 201], req('openwop.it.conversationReplayDeterminism.forked-run-yields-byte-equal-conversation-channel-projection', 'spec/v1/replay.md', 'a host advertising replay.modes ["replay"] MUST accept a mode:"replay" fork (404/501 is a failure)')).toContain(fork.status);
 
     const forkedRunId = (fork.json as { runId: string }).runId;
     const forkedTerminal = await pollUntilTerminal(forkedRunId);
@@ -50,6 +66,6 @@ describe.skipIf(SKIP)('conversationReplayDeterminism: replay-fork preserves conv
     const forkedSnap = await driver.get(`/v1/runs/${encodeURIComponent(forkedRunId)}`);
     const forkedConv = (forkedSnap.json as { channels?: Record<string, unknown> }).channels;
 
-    expect(JSON.stringify(forkedConv)).toBe(JSON.stringify(sourceConv));
+    expect(JSON.stringify(forkedConv), req('openwop.it.conversationReplayDeterminism.forked-run-yields-byte-equal-conversation-channel-projection', 'RFCS/0005-conversation.md', 'a replay-forked run MUST yield a byte-equal conversation channel projection')).toBe(JSON.stringify(sourceConv));
   });
 });

package/src/scenarios/cost-attribution.test.ts

@@ -163,6 +163,18 @@ describe.skipIf(SKIP_NO_COST_EMIT)('cost-attribution: end-to-end roundtrip via c
       'metrics.openwopCost MUST be populated after a node calls ctx.recordCost()',
     )).toBeDefined();
 
+    // unfailable-leg audit wave 2, 2026-09-27: every field check below is
+    // `if (field in openwopCost)` — a host returning `openwopCost: {}` (or one
+    // carrying only provider/model) passed the whole leg with no cost recorded.
+    // The canary records a cost, so at least one of usd / tokens MUST surface.
+    expect(
+      (openwopCost !== undefined && openwopCost !== null) && ('usd' in openwopCost || ('tokens' in openwopCost && openwopCost.tokens !== undefined && openwopCost.tokens !== null)),
+      req('openwop.it.cost-attribution.metrics-openwopcost-must-carry-the-canary-cost-shape-after-the-fixture-node-runs',
+        'run-snapshot.schema.json §metrics.openwopCost / observability.md §Cost attribution attributes',
+        'metrics.openwopCost MUST carry the recorded cost — at least one of usd or tokens — after ctx.recordCost()',
+      ),
+    ).toBe(true);
+
     // Provider — the fixture canary is a stable string. Host-defined
     // overrides are spec-allowed; we assert shape rather than exact match.
     if ('provider' in openwopCost!) {

package/src/scenarios/debug-bundle-truncation.test.ts

@@ -24,7 +24,7 @@ import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { req } from '../lib/requirement-ids.js';
-import { softSkip } from '../lib/soft-skip.js';
+import { softSkip, blockedDespiteAssertions } from '../lib/soft-skip.js';
 
 // `conformance-multi-node` produces enough events (run.started, three
 // node.started/completed pairs, run.completed = ~8 events) that
@@ -70,12 +70,25 @@ describe('debug-bundle-truncation: truncated: true contract', () => {
       metrics?: { eventCount?: number };
     };
 
-    if (body.truncated !== true) {
+    // unfailable-leg audit wave 2, 2026-09-27: `truncated !== true` used to
+    // soft-skip unconditionally after the create/baseline asserts — a
+    // partial-witness PASS even for a host that DID cut the events array
+    // (fewer than the full bundle) but omitted `truncated: true`, which is
+    // exactly the violation this scenario exists to catch. Now: a shortened
+    // events array MUST carry `truncated: true`; an un-shortened bundle means
+    // the cap was never lowered, so the requirement was not observed.
+    const returnedCount = Array.isArray(body.events) ? body.events.length : fullEventCount;
+    if (returnedCount < fullEventCount) {
+      expect(body.truncated, req('openwop.it.debug-bundle-truncation.host-that-supports-maxevents-n-or-otherwise-caps-surfaces-truncated-truncatedrea',
+        'debug-bundle.md §"Bundle size limits"',
+        `a bundle whose events were cut (${returnedCount} of ${fullEventCount}) MUST set truncated: true`,
+      )).toBe(true);
+    } else if (body.truncated !== true) {
       // eslint-disable-next-line no-console
       console.warn(
         '[debug-bundle-truncation] host does not honor ?maxEvents=; skipping truncated-shape assertions',
       );
-      return softSkip('blocked', 'precondition not met — `body.truncated !== true` returned early ([debug-bundle-truncation] host does not honor ?maxEvents=; skipping truncated-shape assertions) (seam, prior step, or fixture unavailable)');
+      return blockedDespiteAssertions('host does not honor ?maxEvents= (full bundle returned, truncated not set) — truncation contract not observed');
     }
 
     expect(typeof body.truncatedReason, req('openwop.it.debug-bundle-truncation.host-that-supports-maxevents-n-or-otherwise-caps-surfaces-truncated-truncatedrea', 

package/src/scenarios/distillation-shape.test.ts

@@ -12,10 +12,30 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import Ajv2020 from 'ajv/dist/2020.js';
+import { SCHEMAS_DIR } from '../lib/paths.js';
 import { softSkip } from '../lib/soft-skip.js';
 import { readDistillationCap } from '../lib/distillation.js';
 import { req } from '../lib/requirement-ids.js';
 
+/**
+ * The `memory.distillation` subtree of `capabilities.schema.json` (major 1 —
+ * this file is `[1]` in scenario-majors.json). Self-contained (no `$ref`), so
+ * it compiles alone.
+ */
+function distillationBlockValidator(): (doc: unknown) => { ok: boolean; errors: string } {
+  const caps = JSON.parse(readFileSync(join(SCHEMAS_DIR, 'capabilities.schema.json'), 'utf8')) as {
+    properties?: { memory?: { properties?: { distillation?: Record<string, unknown> } } };
+  };
+  const sub = caps.properties?.memory?.properties?.distillation;
+  if (sub === undefined) throw new Error('capabilities.schema.json has no properties.memory.properties.distillation subtree');
+  const ajv = new Ajv2020({ allErrors: true, strict: false });
+  const validate = ajv.compile(sub);
+  return (doc: unknown) => ({ ok: validate(doc) as boolean, errors: ajv.errorsText(validate.errors, { separator: '; ' }) });
+}
+
 describe('distillation-shape: advertisement (RFC 0062 §A)', () => {
   it('capabilities.memory.distillation is absent or a well-formed object', async () => {
     const cap = await readDistillationCap();
@@ -30,6 +50,16 @@ describe('distillation-shape: advertisement (RFC 0062 §A)', () => {
         req('openwop.it.distillation-shape.capabilities-memory-distillation-is-absent-or-a-well-formed-object', 'capabilities.schema.json §memory.distillation', 'maxTokenBudget MUST be a positive integer when present'),
       ).toBe(true);
     }
+    // unfailable-leg audit wave 2, 2026-09-27: the hand checks above accept a
+    // fractional `maxTokenBudget` (1.5), a non-string `tokenizerName`, and any
+    // unknown key — the schema says `integer`, `string`, and
+    // `additionalProperties: false`. The whole block now validates against the
+    // capabilities.schema.json `memory.distillation` subtree.
+    const v = distillationBlockValidator()(cap);
+    expect(
+      v.ok,
+      req('openwop.it.distillation-shape.capabilities-memory-distillation-is-absent-or-a-well-formed-object', 'capabilities.schema.json §memory.distillation', `the distillation block MUST validate against the schema subtree (${v.errors})`),
+    ).toBe(true);
     for (const k of ['scheduled', 'indexEmitted'] as const) {
       if (cap[k] !== undefined) {
         expect(

package/src/scenarios/envelope-truncated.test.ts

@@ -21,7 +21,7 @@ import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { req } from '../lib/requirement-ids.js';
-import { softSkip } from '../lib/soft-skip.js';
+import { softSkip, blockedDespiteAssertions } from '../lib/soft-skip.js';
 
 const HTTP_SKIP = !process.env.OPENWOP_BASE_URL;
 const FIXTURE = 'conformance-envelope-truncated';
@@ -67,7 +67,11 @@ describe.skipIf(HTTP_SKIP)('envelope-truncated: runtime behavior (RFC 0032 §B.4
     expect(seed.status).toBe(200);
 
     const result = await startRunAndRead();
-    if (result === null) return softSkip('blocked', 'precondition not met — `result === null` returned early (seam, prior step, or fixture unavailable)');
+    // unfailable-leg audit wave 2, 2026-09-27: after the seed assertion above a
+    // plain softSkip('blocked') records a partial-witness PASS at major 1, so a
+    // host whose run create / event read failed passed this leg without the
+    // envelope.truncated count ever being observed.
+    if (result === null) return blockedDespiteAssertions('the run create or event-log read failed after the mock was seeded — the envelope.truncated count was never observed');
     const truncated = result.events.filter((e) => e.type === 'envelope.truncated');
     expect(
       truncated.length,

package/src/scenarios/feedback-fork-not-copied.test.ts

@@ -8,7 +8,8 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { softSkip } from '../lib/soft-skip.js';
+import { softSkip, blockedDespiteAssertions } from '../lib/soft-skip.js';
+import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
 import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { readFeedbackCap, seedRun } from '../lib/feedback.js';
@@ -18,24 +19,44 @@ describe('feedback-fork-not-copied (RFC 0056 §D)', () => {
   it('a fork of an annotated run starts with zero annotations', async () => {
     const cap = await readFeedbackCap();
     if (cap?.supported !== true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `cap?.supported !== true` returned early');
+    // unfailable-leg audit wave 2, 2026-09-27: three holes, all passing a
+    // non-conforming host. (1) Fork support was discovered only AFTER the
+    // annotation 201 assert, so a host with no fork recorded a partial-witness
+    // pass — gate on advertised `replay.modes` ⊇ ['branch'] BEFORE asserting.
+    // (2) `annotations ?? []` read a 404/500/non-array list as "zero
+    // annotations" — the fork list must now be 200 + an array. (3) No positive
+    // control: a host whose annotation list NEVER returns anything passed —
+    // the SOURCE run must list the annotation just posted.
+    const replayCap = await readCapabilityFamily<{ supported?: unknown; modes?: unknown }>('replay');
+    const modes = replayCap?.supported === true && Array.isArray(replayCap.modes) ? replayCap.modes : [];
+    if (!modes.includes('branch')) return softSkip('inapplicable', 'host does not advertise replay.modes including "branch" — fork leg not applicable');
     const runId = await seedRun('feedback-fork');
     if (!runId) return softSkip('blocked', 'precondition not met — `!runId` returned early (seam, prior step, or fixture unavailable)');
     const post = await driver.post(`/v1/runs/${runId}/annotations`, { signal: { kind: 'flag' } });
     if (post.status === 501 || post.status === 404) return softSkip('blocked', 'precondition not met — `post.status === 501 || post.status === 404` returned early (seam, prior step, or fixture unavailable)');
-    expect(post.status).toBe(201);
+    expect(post.status, req('openwop.it.feedback-fork-not-copied.a-fork-of-an-annotated-run-starts-with-zero-annotations', 'RFC 0056 §B', 'POST /v1/runs/{runId}/annotations MUST return 201')).toBe(201);
     try {
       await pollUntilTerminal(runId, { timeoutMs: 10_000 });
     } catch {
-      return softSkip('blocked', 'precondition not met — an earlier step threw (seam, prior step, or fixture unavailable)');
+      return blockedDespiteAssertions('source run did not reach a terminal state within 10s — fork not attempted');
     }
+    const srcList = await driver.get(`/v1/runs/${runId}/annotations`);
+    expect(srcList.status, req('openwop.it.feedback-fork-not-copied.a-fork-of-an-annotated-run-starts-with-zero-annotations', 'RFC 0056 §B', 'GET /v1/runs/{runId}/annotations MUST return 200')).toBe(200);
+    const srcAnn = (srcList.json as { annotations?: unknown } | undefined)?.annotations;
+    expect(
+      Array.isArray(srcAnn) && srcAnn.length >= 1,
+      req('openwop.it.feedback-fork-not-copied.a-fork-of-an-annotated-run-starts-with-zero-annotations', 'RFC 0056 §B', 'positive control: the source run MUST list the annotation just posted'),
+    ).toBe(true);
     const fork = await driver.post(`/v1/runs/${runId}:fork`, { fromSeq: 0, mode: 'branch' });
-    if (fork.status !== 200 && fork.status !== 201) return softSkip('inapplicable', 'fork unsupported — soft-skip (fork.status !== 200 && fork.status !== 201)');
+    if (fork.status !== 200 && fork.status !== 201) return blockedDespiteAssertions(`branch fork declined (HTTP ${fork.status}) although replay.modes advertises "branch" — fork annotation state not observed`);
     const forkId = (fork.json as { runId?: string } | undefined)?.runId;
-    if (!forkId) return softSkip('blocked', 'precondition not met — `!forkId` returned early (seam, prior step, or fixture unavailable)');
+    if (!forkId) return blockedDespiteAssertions('fork response carried no runId — fork annotation state not observed');
     const list = await driver.get(`/v1/runs/${forkId}/annotations`);
-    const ann = (list.json as { annotations?: unknown[] } | undefined)?.annotations ?? [];
+    expect(list.status, req('openwop.it.feedback-fork-not-copied.a-fork-of-an-annotated-run-starts-with-zero-annotations', 'RFC 0056 §B', 'GET /v1/runs/{forkId}/annotations MUST return 200 for the fork')).toBe(200);
+    const ann = (list.json as { annotations?: unknown } | undefined)?.annotations;
+    expect(Array.isArray(ann), req('openwop.it.feedback-fork-not-copied.a-fork-of-an-annotated-run-starts-with-zero-annotations', 'RFC 0056 §B', 'the annotation list MUST carry an annotations[] array')).toBe(true);
     expect(
-      ann.length,
+      Array.isArray(ann) ? ann.length : -1,
       req('openwop.it.feedback-fork-not-copied.a-fork-of-an-annotated-run-starts-with-zero-annotations', 'RFC 0056 §D', 'annotations are a side-store and MUST NOT be copied into a fork'),
     ).toBe(0);
   });

package/src/scenarios/idempotency-concurrent-claim.test.ts

@@ -52,7 +52,7 @@
  */
 import { describe, it, expect } from 'vitest';
 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 SEAM = '/v1/host/sample/test/idempotency/concurrent-claim';
@@ -133,10 +133,26 @@ describe('idempotency-concurrent-claim: two executors of one run, one effect (RF
     // A host MAY cap `executors`; what it MUST NOT do is deliver more than once.
     // Say so — an unclassified return records `blocked` with no reason, which is
     // the same thing this file exists to stop happening to the requirement.
+    // unfailable-leg audit wave 2, 2026-09-27: the `executors: 5` probe runs after
+    // seamPresent's 200 assert, so a plain softSkip here recorded a partial-
+    // witness `executed-pass` — a host whose seam refused the in-range request
+    // (§25: range 2..8) passed without the higher-concurrency race ever running.
     if (res.status !== 200) {
-      return softSkip('skipped', `${SEAM} declined executors: 5 (status ${res.status}) — a host MAY cap concurrency`);
+      return blockedDespiteAssertions(`${SEAM} declined executors: 5 (status ${res.status}) — §25 accepts 2..8; the higher-concurrency race was not observed`);
     }
     const out = res.json as ClaimResult;
+    // unfailable-leg audit wave 2, 2026-09-27: previously the identity check below
+    // was guarded by `ids.length >= 2` and `mintedIds` defaulted to [] — a host
+    // that raced ≤2 executors, or omitted/garbled mintedIds, passed on
+    // `delivered === 1` alone, the exact vacuous pass §25 names. Now unguarded.
+    expect(
+      typeof out.attempted === 'number' && (out.attempted as number) >= 3,
+      req('openwop.it.idempotency-concurrent-claim.the-race-is-real-at-higher-concurrency-too-a-claim-that-only-holds-at-2-is-not-a', 'host-sample-test-seams.md §25', 'with executors: 5 at least three executors MUST reach the chokepoint — otherwise this leg repeats the two-executor case and witnesses nothing new'),
+    ).toBe(true);
+    expect(
+      Array.isArray(out.mintedIds),
+      req('openwop.it.idempotency-concurrent-claim.the-race-is-real-at-higher-concurrency-too-a-claim-that-only-holds-at-2-is-not-a', 'host-sample-test-seams.md §25', 'the seam MUST report mintedIds, one per executor'),
+    ).toBe(true);
     expect(
       out.delivered,
       req('openwop.it.idempotency-concurrent-claim.the-race-is-real-at-higher-concurrency-too-a-claim-that-only-holds-at-2-is-not-a', 
@@ -144,12 +160,14 @@ describe('idempotency-concurrent-claim: two executors of one run, one effect (RF
         'exactly one effect regardless of how many executors race — at most one wins the compare-and-set, the rest observe the hit',
       ),
     ).toBe(1);
-    const ids = Array.isArray(out.mintedIds) ? (out.mintedIds as unknown[]) : [];
-    if (ids.length >= 2) {
-      expect(
-        new Set(ids.map((x) => JSON.stringify(x))).size,
-        req('openwop.it.idempotency-concurrent-claim.the-race-is-real-at-higher-concurrency-too-a-claim-that-only-holds-at-2-is-not-a', 'idempotency.md §"Idempotency key composition"', 'one identity across all executors at any concurrency'),
-      ).toBe(1);
-    }
+    const ids = out.mintedIds as unknown[];
+    expect(
+      ids.length,
+      req('openwop.it.idempotency-concurrent-claim.the-race-is-real-at-higher-concurrency-too-a-claim-that-only-holds-at-2-is-not-a', 'host-sample-test-seams.md §25', 'mintedIds length MUST equal attempted'),
+    ).toBe(out.attempted);
+    expect(
+      new Set(ids.map((x) => JSON.stringify(x))).size,
+      req('openwop.it.idempotency-concurrent-claim.the-race-is-real-at-higher-concurrency-too-a-claim-that-only-holds-at-2-is-not-a', 'idempotency.md §"Idempotency key composition"', 'one identity across all executors at any concurrency'),
+    ).toBe(1);
   });
 });

package/src/scenarios/idempotency-key-determinism.test.ts

@@ -116,10 +116,14 @@ describe('category: core.openwop.http.idempotency-key — determinism contract',
     // — the scenario soft-skips rather than failing.
     if (!packAvailable) {
       console.warn(`[idempotency-key-determinism] packs/core.openwop.http/index.mjs not present; skipping`);
-      expect(packAvailable, req('openwop.it.idempotency-key-determinism.skips-cleanly-when-packs-is-not-bundled', 'idempotency.md §"Idempotency-Key', 'skips cleanly when packs/ is not bundled')).toBe(false);
+      // unfailable-leg audit wave 2, 2026-09-27: this leg asserted
+      // `packAvailable === false` inside `if (!packAvailable)` (and `=== true`
+      // in the else) — tautologies that turned a sentinel into an
+      // `executed-pass` row measuring nothing. It now records `inapplicable`
+      // with zero assertions either way.
       return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early ([idempotency-key-determinism] packs/core.openwop.http/index.mjs not present; skipping)');
     }
-    expect(packAvailable).toBe(true);
+    return softSkip('inapplicable', 'sentinel leg — pack source is present; the behavioural legs in this file carry the assertions');
   });
 
   it('default mode (composite) — identical (runId, nodeId, payload) produces identical keys', async () => {

package/src/scenarios/mcp-server-untrusted-args.test.ts

@@ -39,8 +39,11 @@ async function rpc(method: string, params?: Record<string, unknown>) {
 }
 
 const TEST_TOOL_NAME = `inj_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+/** Set once the strict tool is registered, so the valid-args leg can tell "no tool" from "rejected". */
+let strictToolRegistered = false;
 
 async function registerStrictWorkflow(): Promise<boolean> {
+  if (strictToolRegistered) return true;
   const res = await driver.post('/v1/host/sample/workflows', {
     workflowId: `mcp.untrusted.${Date.now()}`,
     nodes: [
@@ -60,7 +63,8 @@ async function registerStrictWorkflow(): Promise<boolean> {
       },
     ],
   });
-  return res.status === 200 || res.status === 201;
+  strictToolRegistered = res.status === 200 || res.status === 201;
+  return strictToolRegistered;
 }
 
 describe('mcp-server-untrusted-args: advertisement shape (RFC 0020)', () => {
@@ -96,14 +100,25 @@ describe('mcp-server-untrusted-args: behavioral (RFC 0020 §D)', () => {
   it('tools/call with valid arguments is accepted', async () => {
     const cap = await readCap();
     if (!cap || cap.supported !== true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!cap || cap.supported !== true` returned early');
+    // The tool this leg calls is registered by the malformed-args leg; register
+    // it here too (idempotent) so an unknown-tool error is never read as a
+    // rejection of valid arguments.
+    if (!(await registerStrictWorkflow())) return softSkip('blocked', 'precondition not met — the strict-schema tool could not be registered via /v1/host/sample/workflows');
     const r = await rpc('tools/call', {
       name: TEST_TOOL_NAME,
       arguments: { text: 'hello' },
     });
     if (r.status === 404) return seamAbsent(`host advertises an MCP server mount but the mount (capabilities.mcp.serverUrls[0], else /v1/host/sample/mcp) answered ${r.status} — RFC 0153 §B is unobservable at the path the host itself advertised`);
-    expect(r.status).toBe(200);
-    if (r.body.error) {
-      expect(r.body.error.code, req('openwop.it.mcp-server-untrusted-args.tools-call-with-valid-arguments-is-accepted', 'RFC 0020 §D', 'valid args MUST NOT trigger -32602')).not.toBe(-32602);
-    }
+    expect(r.status, req('openwop.it.mcp-server-untrusted-args.tools-call-with-valid-arguments-is-accepted', 'RFC 0020 §D', 'the JSON-RPC envelope MUST answer 200')).toBe(200);
+    // unfailable-leg audit wave 2, 2026-09-27: the only requirement assert sat
+    // inside `if (r.body.error)` and checked just `code !== -32602`, so a host
+    // that rejected VALID arguments with any other JSON-RPC error (-32603,
+    // -32000, …) — or answered with neither result nor error — passed. A valid
+    // call MUST be accepted: no JSON-RPC error, and a result present.
+    // (`result.isError` is deliberately NOT asserted: it reports the exposed
+    // workflow's own execution outcome — a failed/suspended run — not a
+    // rejection of the arguments; RFC 0020 §C.)
+    expect(r.body.error, req('openwop.it.mcp-server-untrusted-args.tools-call-with-valid-arguments-is-accepted', 'RFC 0020 §D', 'valid args MUST NOT be rejected with any JSON-RPC error')).toBeUndefined();
+    expect(r.body.result, req('openwop.it.mcp-server-untrusted-args.tools-call-with-valid-arguments-is-accepted', 'RFC 0020 §D', 'an accepted tools/call MUST return a JSON-RPC result')).toBeDefined();
   });
 });

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']);
     }
   });
 });