@openwop/openwop-conformance 1.106.1 → 1.124.0

package/src/scenarios/replay-observable-sequence-determinism.test.ts

@@ -41,6 +41,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 
@@ -162,10 +163,10 @@ describe.skipIf(HTTP_SKIP)(
   'replay-observable-sequence-determinism: prefix byte-equivalence (RFC 0041 §C)',
   () => {
     it('original and replay event-log prefixes MUST be byte-equivalent (modulo per-event clock + ULID entropy)', async (ctx) => {
-      if (!(await gateOnPhase4(ctx))) return;
+      if (!(await gateOnPhase4(ctx))) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await gateOnPhase4(ctx))` returned early');
 
       const sourceRunId = await startFixtureRun(ctx);
-      if (sourceRunId === null) return;
+      if (sourceRunId === null) return softSkip('blocked', 'precondition not met — `sourceRunId === null` returned early (seam, prior step, or fixture unavailable)');
       const sourceTerminal = await pollUntilTerminal(sourceRunId);
       expect(sourceTerminal.status).toBe('completed');
       const sourceEvents = await readEvents(sourceRunId);
@@ -196,10 +197,10 @@ describe.skipIf(HTTP_SKIP)(
   'replay-observable-sequence-determinism: observable-result caching (RFC 0041 §C)',
   () => {
     it('replay of a nondeterministic tool node reproduces the ORIGINAL observable result, NOT a fresh call', async (ctx) => {
-      if (!(await gateOnPhase4(ctx))) return;
+      if (!(await gateOnPhase4(ctx))) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await gateOnPhase4(ctx))` returned early');
 
       const sourceRunId = await startFixtureRun(ctx);
-      if (sourceRunId === null) return;
+      if (sourceRunId === null) return softSkip('blocked', 'precondition not met — `sourceRunId === null` returned early (seam, prior step, or fixture unavailable)');
       expect((await pollUntilTerminal(sourceRunId)).status).toBe('completed');
       const sourceEvents = await readEvents(sourceRunId);
 

package/src/scenarios/replay-side-effect-suppression.test.ts

@@ -45,6 +45,8 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { recordRequirement } from '../lib/requirement-ledger.js';
+import { requirementIdForScenario } from '../lib/requirement-registry.js';
 import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
@@ -111,7 +113,24 @@ describe.skipIf(SKIP_NO_FIXTURE)('replay-side-effect-suppression: a replay does
     const replay = await fetchReplay();
 
     if (replay?.sideEffectSuppression !== 'recorded-outcome') {
-      ctx.skip(); // host makes no such guarantee — RFC 0140 imposes nothing
+      // `replay.md` §"Side-effect suppression" (corrected 2026-08-08): caveat 1 —
+      // a replay MUST NOT call the external system twice — is UNCONDITIONAL and
+      // `none` is not permission to re-fire; it only means no probeable mechanism
+      // is declared. So this is not `inapplicable`: the obligation applies and is
+      // unwitnessable here. Record the floor row `blocked` (RFC 0148 §A) so a
+      // host advertising `none` cannot certify `openwop-replay-fork` on the
+      // strength of determinism alone (H20 — re-advertising `recorded-outcome`
+      // is what makes this leg run).
+      try {
+        recordRequirement(
+          requirementIdForScenario('replay-side-effect-suppression.test.ts'),
+          'blocked',
+          `host advertises replay.sideEffectSuppression ${JSON.stringify(replay?.sideEffectSuppression ?? 'none')} — caveat 1 (a replay MUST NOT re-fire external effects) is unconditional but no declared mechanism is probeable; unwitnessed, not inapplicable`,
+        );
+      } catch {
+        /* already recorded */
+      }
+      ctx.skip();
       return;
     }
     if (!replay.modes?.includes('replay')) {

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

@@ -21,7 +21,7 @@
  * Server-free and always-on.
  */
 
-import { describe, it, expect, beforeEach } from 'vitest';
+import { describe, it, expect, beforeEach, beforeAll, afterAll } from 'vitest';
 import {
   DISPOSITIONS,
   CERTIFIABLE,
@@ -30,10 +30,19 @@ import {
   entryOf,
   snapshot,
   resetLedger,
+  suspendSinkForFixtures,
   verifyProfileRequirements,
 } from '../lib/requirement-ledger.js';
 import { allRequirements, requirementsFor } from '../lib/requirement-registry.js';
 
+// This file records REAL requirement ids as fixtures; keep them out of a live
+// --certify ledger sink (they would out-vote genuine dispositions).
+let restoreSink: (() => void) | undefined;
+beforeAll(() => {
+  restoreSink = suspendSinkForFixtures();
+});
+afterAll(() => restoreSink?.());
+
 describe('RFC 0148 §A — requirement execution ledger', () => {
   beforeEach(() => resetLedger());
 
@@ -121,15 +130,29 @@ describe('RFC 0148 §A — the registry binds to the certification floor', () =>
     expect(allRequirements()).toContain('openwop.floor.any.interrupt-');
   });
 
-  it('an unwritten floor returns null, not an empty list', () => {
-    // `openwop-replay-fork` is deliberately unspecified — `profiles.md` gives it
-    // a discovery-conditional floor a flat list cannot express (gap G7). Null
-    // forces the caller to decide; an empty array would silently certify.
+  it('an unwritten floor returns null, not an empty list — and so does a conditional floor without its document (G7)', () => {
+    // `openwop-replay-fork` has a discovery-conditional floor (RFC 0148 §C G7,
+    // transcribed 2026-08-16): "the conformance scenarios pass on whichever mode
+    // the host advertises". Without the document it is UNEVALUABLE — null forces
+    // the caller to decide; an empty array would silently certify.
     expect(
       requirementsFor('openwop-replay-fork'),
-      'RFC 0148 §C: unspecified MUST be distinguishable from empty-by-design',
+      'RFC 0148 §C: unevaluable MUST be distinguishable from empty-by-design',
     ).toBeNull();
     expect(requirementsFor('openwop-does-not-exist')).toBeNull();
+    // With the document, the advertised branch is required
+    const doc = (modes: string[]) => ({ replay: { supported: true, modes } });
+    expect([...(requirementsFor('openwop-replay-fork', doc(['replay'])) ?? [])].sort()).toEqual(['openwop.floor.replay-side-effect-suppression', 'openwop.floor.replayDeterminism']);
+    expect(requirementsFor('openwop-replay-fork', doc(['branch']))).toEqual(['openwop.floor.replay-fork']);
+    expect([...(requirementsFor('openwop-replay-fork', doc(['replay', 'branch'])) ?? [])].sort()).toEqual(['openwop.floor.replay-fork', 'openwop.floor.replay-side-effect-suppression', 'openwop.floor.replayDeterminism']);
+    expect(requirementsFor('openwop-replay-fork', doc([]))).toEqual([]);
+    // and every branch is a registered requirement
+    expect(allRequirements()).toContain('openwop.floor.replayDeterminism');
+    expect(allRequirements()).toContain('openwop.floor.replay-fork');
+    // the six formerly-unprovable profiles now have floors
+    for (const p of ['openwop-interrupts', 'openwop-secrets', 'openwop-provider-policy', 'openwop-memory', 'openwop-trigger-bridge']) {
+      expect((requirementsFor(p) ?? []).length, `${p} floor MUST be non-empty`).toBeGreaterThan(0);
+    }
   });
 
   it('a discovery-only profile returns an empty list, which does not certify', () => {

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

@@ -0,0 +1,279 @@
+/**
+ * RFC 0148 §A acceptance item 2 (S6) — "Runner records requirement-level
+ * dispositions and rejects unclassified returns."
+ *
+ * The runner is a separate process reading a vitest JSON report; the §A ledger
+ * lives in the workers. S6 connects them with a JSONL file sink
+ * (`OPENWOP_LEDGER_PATH`), a file-level recording hook in `setup.ts` (every
+ * scenario file records ONE disposition + its assertion count when it finishes),
+ * and a pure derivation (`scenario-disposition.ts`) the runner uses to build
+ * bundle v2 rows and to REJECT certification when a claimed profile's floor has
+ * an unclassified requirement.
+ *
+ * Pinned here, server-free:
+ *   - the sink writes JSONL and the reader merges duplicates, resolving a
+ *     conflict to the least certifiable disposition;
+ *   - `fileDisposition` folds per-test states honestly (fail > pass > gate
+ *     reason > blocked);
+ *   - `deriveRequirementDispositions`: ledger rows win over report inference;
+ *     a file with no entry is `blocked`/unclassified; prefix requirements derive
+ *     from matching files; a claimed profile with an unclassified floor
+ *     requirement flags rejection; a VACUOUS pass (executed-pass with
+ *     assertionCount 0) on a claimed floor is unclassified — a witness of nothing;
+ *     a discoveryOnly profile certifies with an empty floor;
+ *   - and the live proof: this very run, when `OPENWOP_LEDGER_PATH` is set,
+ *     records the files that ran before this one (checked when the env is set).
+ *
+ * @see conformance/src/lib/scenario-disposition.ts, requirement-ledger.ts, setup.ts, cli.ts
+ * @see RFCS/0148-non-vacuous-conformance-certification.md §A/§C
+ */
+
+import { describe, it, expect } from 'vitest';
+import { mkdtempSync, rmSync, readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { readLedgerFile, recordRequirement, resetLedger, snapshot } from '../lib/requirement-ledger.js';
+import { fileDisposition, deriveRequirementDispositions, requirementIdForFile, floorScenarioFiles } from '../lib/scenario-disposition.js';
+import { softSkip, softSkipDisposition, resetSoftSkips, UNCLASSIFIED_RETURN_DETAIL } from '../lib/soft-skip.js';
+import { PROFILE_FLOOR_SCENARIOS } from '../lib/profiles.js';
+import { requirementsFor, requirementIdForScenario, requirementIdForPrefix } from '../lib/requirement-registry.js';
+
+describe('RFC 0148 §A (S6) — ledger file sink and reader', () => {
+  it('recordRequirement appends JSONL when OPENWOP_LEDGER_PATH is set; the reader merges and ranks conflicts least-certifiable-first', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'owp-ledger-'));
+    const path = join(dir, 'l.jsonl');
+    const prev = process.env['OPENWOP_LEDGER_PATH'];
+    process.env['OPENWOP_LEDGER_PATH'] = path;
+    resetLedger();
+    try {
+      recordRequirement('t.a', 'executed-pass', undefined, { assertionCount: 3 });
+      recordRequirement('t.b', 'inapplicable', 'not advertised');
+      // simulate a second worker writing a conflicting line for t.a
+      // (the in-memory map would throw; the FILE can carry both)
+      const { appendFileSync } = require('node:fs') as typeof import('node:fs');
+      appendFileSync(path, JSON.stringify({ requirementId: 't.a', disposition: 'blocked', detail: 'other worker' }) + '\n');
+      appendFileSync(path, 'not json\n');
+      const lines = readFileSync(path, 'utf8').trim().split('\n');
+      expect(lines.length).toBe(4);
+      const merged = readLedgerFile(path);
+      expect(merged.map((e) => e.requirementId)).toEqual(['t.a', 't.b']);
+      expect(merged.find((e) => e.requirementId === 't.a')?.disposition, 'conflict resolves to the least certifiable (blocked over executed-pass)').toBe('blocked');
+      expect(merged.find((e) => e.requirementId === 't.b')?.disposition).toBe('inapplicable');
+      expect(readLedgerFile(join(dir, 'missing.jsonl'))).toEqual([]);
+    } finally {
+      if (prev === undefined) delete process.env['OPENWOP_LEDGER_PATH'];
+      else process.env['OPENWOP_LEDGER_PATH'] = prev;
+      resetLedger();
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('RFC 0148 §A (S6) — fileDisposition folds a file honestly', () => {
+  it('fail beats pass; pass beats a gate reason; a gate reason beats blocked; nothing is blocked (unclassified)', () => {
+    expect(fileDisposition(['pass', 'fail', 'skip'], undefined).disposition).toBe('executed-fail');
+    expect(fileDisposition(['pass', 'skip'], 'inapplicable').disposition).toBe('executed-pass');
+    // real assertions + a gate reason → still an executed pass
+    expect(fileDisposition(['pass', 'skip'], 'inapplicable', 4).disposition).toBe('executed-pass');
+    // every "pass" was a behaviorGate early-return (zero assertions) → the gate's reason wins
+    expect(fileDisposition(['pass', 'pass'], 'inapplicable', 0).disposition).toBe('inapplicable');
+    expect(fileDisposition(['pass'], 'skipped', 0).disposition).toBe('skipped');
+    // zero assertions with NO gate reason stays a (vacuous) executed-pass — certification rejects it
+    expect(fileDisposition(['pass'], undefined, 0).disposition).toBe('executed-pass');
+    expect(fileDisposition(['skip', 'skip'], 'inapplicable').disposition).toBe('inapplicable');
+    expect(fileDisposition(['skip'], 'skipped').disposition).toBe('skipped');
+    const b = fileDisposition(['skip'], undefined);
+    expect(b.disposition).toBe('blocked');
+    expect(b.detail).toMatch(/unclassified/);
+    expect(fileDisposition([], undefined).disposition).toBe('blocked');
+  });
+
+  it('a floor file records under its §A floor id; any other file under openwop.scenario.*', () => {
+    const floor = [...floorScenarioFiles()];
+    expect(floor.length).toBeGreaterThan(0);
+    expect(requirementIdForFile(floor[0]!)).toBe(requirementIdForScenario(floor[0]!));
+    expect(requirementIdForFile('some-other.test.ts')).toBe('openwop.scenario.some-other');
+  });
+});
+
+describe('RFC 0148 §A (S6) — the runner derivation', () => {
+  // A profile with a real floor of file requirements + a prefix requirement.
+  const profile = Object.entries(PROFILE_FLOOR_SCENARIOS).find(([, f]) => f.required.length > 0 && (f.requiredAnyPrefix?.length ?? 0) > 0)?.[0]
+    ?? Object.entries(PROFILE_FLOOR_SCENARIOS).find(([, f]) => f.required.length > 0)![0];
+  const floor = PROFILE_FLOOR_SCENARIOS[profile]!;
+  const files = floor.required;
+  const prefix = floor.requiredAnyPrefix?.[0];
+
+  function reportAllPassed(extra: Record<string, 'passed' | 'failed' | 'skipped'> = {}) {
+    const m = new Map<string, 'passed' | 'failed' | 'skipped'>();
+    for (const f of files) m.set(f, 'passed');
+    if (prefix) m.set(`${prefix}alpha.test.ts`, 'passed');
+    for (const [k, v] of Object.entries(extra)) m.set(k, v);
+    return m;
+  }
+  function ledgerAllPassed(count = 5) {
+    const l = files.map((f) => ({ requirementId: requirementIdForScenario(f), disposition: 'executed-pass' as const, assertionCount: count }));
+    if (prefix) l.push({ requirementId: `openwop.scenario.${prefix}alpha`, disposition: 'executed-pass' as const, assertionCount: count });
+    return l;
+  }
+
+  it('ledger rows win, prefix requirements derive from matching files, and a fully recorded floor certifies', () => {
+    const d = deriveRequirementDispositions(reportAllPassed(), ledgerAllPassed(), [profile]);
+    expect(d.ledgerPresent).toBe(true);
+    expect(d.rejectUnclassified).toBe(false);
+    const v = d.verdicts.find((x) => x.profile === profile)!;
+    expect(v.certifiable, JSON.stringify(v)).toBe(true);
+    expect(v.unclassified).toEqual([]);
+    for (const f of files) {
+      const row = d.requirements.find((r) => r.requirementId === requirementIdForScenario(f))!;
+      expect(row.disposition).toBe('executed-pass');
+      expect(row.assertionCount).toBe(5);
+    }
+    if (prefix) {
+      const p = d.requirements.find((r) => r.requirementId === requirementIdForPrefix(prefix))!;
+      expect(p.disposition).toBe('executed-pass');
+      expect(p.scenarioId).toBe(`${prefix}*`);
+    }
+    expect(d.totals.executedPass).toBe(d.requirements.length);
+  });
+
+  it('a floor file that vitest passed but that recorded NOTHING is unclassified when a ledger exists — silence is not a witness', () => {
+    const l = ledgerAllPassed().filter((e) => e.requirementId !== requirementIdForScenario(files[0]!));
+    const d = deriveRequirementDispositions(reportAllPassed(), l, [profile]);
+    const v = d.verdicts.find((x) => x.profile === profile)!;
+    const row = d.requirements.find((r) => r.requirementId === requirementIdForScenario(files[0]!))!;
+    expect(row.disposition).toBe('executed-pass'); // vitest did say passed — the row is honest about the source
+    expect(row.detail).toMatch(/report-derived/);
+    expect(v.unclassified, 'no ledger entry ⇒ unclassified for a claimed floor').toContain(requirementIdForScenario(files[0]!));
+    expect(v.certifiable).toBe(false);
+    expect(d.rejectUnclassified).toBe(true);
+  });
+
+  it('a VACUOUS pass (executed-pass with assertionCount 0) on a claimed floor is unclassified and REJECTS certification', () => {
+    const l = ledgerAllPassed(5).map((e) => (e.requirementId === requirementIdForScenario(files[0]!) ? { ...e, assertionCount: 0 } : e));
+    const d = deriveRequirementDispositions(reportAllPassed(), l, [profile]);
+    const v = d.verdicts.find((x) => x.profile === profile)!;
+    expect(v.unclassified).toContain(requirementIdForScenario(files[0]!));
+    expect(v.certifiable).toBe(false);
+    expect(d.rejectUnclassified).toBe(true);
+  });
+
+  it('a skipped file with no ledger entry is blocked (unclassified) — and it never reads as skipped/inapplicable', () => {
+    const rep = reportAllPassed({ [files[0]!]: 'skipped' });
+    const l = ledgerAllPassed().filter((e) => e.requirementId !== requirementIdForScenario(files[0]!));
+    const d = deriveRequirementDispositions(rep, l, [profile]);
+    const row = d.requirements.find((r) => r.requirementId === requirementIdForScenario(files[0]!))!;
+    expect(row.disposition).toBe('blocked');
+    expect(row.detail).toMatch(/unclassified/);
+    expect(d.verdicts[0]!.unclassified).toContain(requirementIdForScenario(files[0]!));
+    expect(d.rejectUnclassified).toBe(true);
+    expect(d.totals.blocked).toBeGreaterThan(0);
+  });
+
+  it('a recorded inapplicable/skipped is certifiable and NOT unclassified; a recorded executed-fail blocks but is classified', () => {
+    const l = ledgerAllPassed().map((e) => (e.requirementId === requirementIdForScenario(files[0]!) ? { requirementId: e.requirementId, disposition: 'inapplicable' as const, detail: 'not advertised' } : e));
+    const d = deriveRequirementDispositions(reportAllPassed({ [files[0]!]: 'skipped' }), l, [profile]);
+    expect(d.verdicts[0]!.unclassified).toEqual([]);
+    expect(d.verdicts[0]!.certifiable).toBe(true);
+    const l2 = ledgerAllPassed().map((e) => (e.requirementId === requirementIdForScenario(files[0]!) ? { requirementId: e.requirementId, disposition: 'executed-fail' as const, detail: 'assertion failed', assertionCount: 2 } : e));
+    const d2 = deriveRequirementDispositions(reportAllPassed({ [files[0]!]: 'failed' }), l2, [profile]);
+    expect(d2.verdicts[0]!.unclassified).toEqual([]);
+    expect(d2.verdicts[0]!.blocking).toContain(requirementIdForScenario(files[0]!));
+    expect(d2.verdicts[0]!.certifiable).toBe(false);
+    expect(d2.rejectUnclassified).toBe(false);
+  });
+
+  it('a discoveryOnly profile certifies with an empty floor; an unknown profile does not', () => {
+    const d = deriveRequirementDispositions(new Map(), [], ['openwop-discovery-core', 'openwop-nope']);
+    expect(d.verdicts.find((v) => v.profile === 'openwop-discovery-core')?.certifiable).toBe(true);
+    expect(d.verdicts.find((v) => v.profile === 'openwop-nope')?.certifiable).toBe(false);
+    expect(requirementsFor('openwop-discovery-core')).toEqual([]);
+  });
+
+  it('a RUNTIME-DERIVED profile (openwop-node-packs) is HELD only when every floor row is a witnessed pass; otherwise it is not held — not rejected, not blocked', () => {
+    const np = 'openwop-node-packs';
+    const f = PROFILE_FLOOR_SCENARIOS[np]!;
+    expect(f.runtimeDerived, 'profiles.md: node-packs is "derivable from which scenarios pass"').toBe(true);
+    const ids = f.required.map((x) => requirementIdForScenario(x));
+    const rep = new Map<string, 'passed' | 'failed' | 'skipped'>(f.required.map((x) => [x, 'passed' as const]));
+    // (a) held: every row a witnessed pass
+    const held = deriveRequirementDispositions(rep, ids.map((id) => ({ requirementId: id, disposition: 'executed-pass' as const, assertionCount: 4 })), [np]);
+    const vh = held.verdicts.find((v) => v.profile === np)!;
+    expect(vh.runtimeDerived).toBe(true);
+    expect(vh.held).toBe(true);
+    expect(vh.certifiable).toBe(true);
+    // (b) not held: registry absent → the scenario recorded inapplicable-with-reason; publish recorded inapplicable
+    const notHeld = deriveRequirementDispositions(rep, ids.map((id) => ({ requirementId: id, disposition: 'inapplicable' as const, detail: 'host ships no pack registry (probe 404)' })), [np]);
+    const vn = notHeld.verdicts.find((v) => v.profile === np)!;
+    expect(vn.held).toBe(false);
+    expect(vn.certifiable).toBe(false);
+    expect(vn.unclassified, 'a profile the host does not hold is not a rejected claim').toEqual([]);
+    expect([...vn.blocking].sort()).toEqual([...ids].sort());
+    expect(notHeld.rejectUnclassified).toBe(false);
+    // (c) a vacuous pass on a runtime-derived floor is still not a rejection — the emitter drops the claim
+    const vac = deriveRequirementDispositions(rep, ids.map((id) => ({ requirementId: id, disposition: 'executed-pass' as const, assertionCount: 0 })), [np]);
+    const vv = vac.verdicts.find((v) => v.profile === np)!;
+    expect(vv.held).toBe(false);
+    expect(vv.unclassified).toEqual([]);
+    expect(vac.rejectUnclassified).toBe(false);
+    // (d) and a floor-defined NON-runtime-derived profile keeps the strict rule
+    const strictProfile = Object.entries(PROFILE_FLOOR_SCENARIOS).find(([, x]) => x.required.length > 0 && !x.runtimeDerived)![0];
+    const sIds = PROFILE_FLOOR_SCENARIOS[strictProfile]!.required.map((x) => requirementIdForScenario(x));
+    const sRep = new Map<string, 'passed' | 'failed' | 'skipped'>(PROFILE_FLOOR_SCENARIOS[strictProfile]!.required.map((x) => [x, 'passed' as const]));
+    const strict = deriveRequirementDispositions(sRep, sIds.map((id) => ({ requirementId: id, disposition: 'executed-pass' as const, assertionCount: 0 })), [strictProfile]);
+    expect(strict.verdicts[0]?.runtimeDerived).toBe(false);
+    expect(strict.rejectUnclassified).toBe(true);
+  });
+
+  it('the runner\'s §A resolution of a silent zero-assertion file (blocked + marker) is STILL unclassified for a claimed floor', () => {
+    const l = ledgerAllPassed().map((e) => (e.requirementId === requirementIdForScenario(files[0]!) ? { requirementId: e.requirementId, disposition: 'blocked' as const, detail: UNCLASSIFIED_RETURN_DETAIL, assertionCount: 0 } : e));
+    const d = deriveRequirementDispositions(reportAllPassed(), l, [profile]);
+    const v = d.verdicts.find((x) => x.profile === profile)!;
+    expect(v.unclassified).toContain(requirementIdForScenario(files[0]!));
+    expect(d.rejectUnclassified).toBe(true);
+    // whereas a blocked row WITH a scenario-authored reason is classified (blocking, not unclassified)
+    const l2 = ledgerAllPassed().map((e) => (e.requirementId === requirementIdForScenario(files[0]!) ? { requirementId: e.requirementId, disposition: 'blocked' as const, detail: 'seam /v1/host/sample/x not mounted', assertionCount: 0 } : e));
+    const d2 = deriveRequirementDispositions(reportAllPassed(), l2, [profile]);
+    expect(d2.verdicts.find((x) => x.profile === profile)!.unclassified).toEqual([]);
+    expect(d2.rejectUnclassified).toBe(false);
+  });
+
+  it('with no ledger at all, every skipped file is blocked and the runner says so (the pre-S6 honest reading)', () => {
+    const d = deriveRequirementDispositions(reportAllPassed({ [files[0]!]: 'skipped' }), [], [profile]);
+    expect(d.ledgerPresent).toBe(false);
+    const row = d.requirements.find((r) => r.requirementId === requirementIdForScenario(files[0]!))!;
+    expect(row.disposition).toBe('blocked');
+    expect(row.detail).toMatch(/without a ledger/);
+  });
+});
+
+describe('RFC 0148 §A — softSkip notes the reason for an early return, per file', () => {
+  it('notes are keyed to the current test file, worst-first when mixed, and read back with joined reasons', () => {
+    resetSoftSkips();
+    expect(softSkip('inapplicable', 'host does not advertise X')).toBeUndefined();
+    softSkip('inapplicable', 'host does not advertise X'); // de-duplicated
+    let d = softSkipDisposition('runner-ledger.test.ts');
+    expect(d).toEqual({ kind: 'inapplicable', reason: 'host does not advertise X' });
+    softSkip('blocked', 'seam not mounted');
+    d = softSkipDisposition('runner-ledger.test.ts');
+    expect(d?.kind).toBe('blocked');
+    expect(d?.reason).toContain('[blocked] seam not mounted');
+    expect(d?.reason).toContain('[inapplicable] host does not advertise X');
+    expect(softSkipDisposition('some-other-file.test.ts')).toBeNull();
+    resetSoftSkips();
+    expect(softSkipDisposition('runner-ledger.test.ts')).toBeNull();
+  });
+});
+
+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; // 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.
+    const fileEntries = snapshot().filter((e) => e.requirementId.startsWith('openwop.scenario.') || e.requirementId.startsWith('openwop.floor.'));
+    for (const e of fileEntries) expect(typeof e.assertionCount).toBe('number');
+    expect(entries.length).toBeGreaterThanOrEqual(0);
+  });
+});

package/src/scenarios/runtime-requires-install-gate.test.ts

@@ -28,6 +28,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { installGate } from '../lib/runtimeRequires.js';
 
@@ -44,7 +45,7 @@ function manifest(requires: string[]) {
 describe('runtime-requires install gate (RFC 0076 §A)', () => {
   it('install-grant: requires ⊆ grant-set ⇒ install succeeds', async () => {
     const res = await installGate({ manifest: manifest(['net.dns']), grantSet: ['net.dns', 'net.outbound'] });
-    if (res === null) return; // seam absent — soft-skip
+    if (res === null) return softSkip('blocked', 'seam absent — soft-skip');
     expect(
       res.status,
       driver.describe('registry-operations.md §"Runtime-requirement install gate"', 'a pack whose runtime.requires are all grantable MUST install (no refusal)'),
@@ -57,7 +58,7 @@ describe('runtime-requires install gate (RFC 0076 §A)', () => {
 
   it('install-refuse: an ungrantable primitive ⇒ pack_runtime_requirement_unmet', async () => {
     const res = await installGate({ manifest: manifest(['net.dns']), grantSet: [] });
-    if (res === null) return; // seam absent — soft-skip
+    if (res === null) return softSkip('blocked', 'seam absent — soft-skip');
     expect(
       res.status,
       driver.describe('registry-operations.md §"Runtime-requirement install gate"', 'a pack requiring an ungranted primitive MUST be refused at install (not at first invocation)'),
@@ -78,11 +79,11 @@ describe('runtime-requires install gate (RFC 0076 §A)', () => {
 
   it('non-sandbox projection: a non-gating host installs and projects requires[] (§A SHOULD)', async () => {
     const res = await installGate({ manifest: manifest(['net.dns', 'net.outbound']), gating: false });
-    if (res === null) return; // seam absent — soft-skip
+    if (res === null) return softSkip('blocked', 'seam absent — soft-skip');
     // A non-gating host installs unconditionally; the SHOULD is the projection.
     // If the host gates anyway (returns 400) the projection SHOULD does not apply — tolerate either install shape.
-    if (res.status !== 200) return;
-    if (res.body.requiresProjected === undefined) return; // SHOULD, not MUST — a non-projecting host is conformant
+    if (res.status !== 200) return softSkip('blocked', 'precondition not met — `res.status !== 200` returned early (seam, prior step, or fixture unavailable)');
+    if (res.body.requiresProjected === undefined) return softSkip('inapplicable', 'SHOULD, not MUST — a non-projecting host is conformant');
     const projected = res.body.requiresProjected as unknown;
     expect(
       Array.isArray(projected) && ['net.dns', 'net.outbound'].every((t) => (projected as unknown[]).includes(t)),

package/src/scenarios/sandbox-memory-cap.test.ts

@@ -14,6 +14,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 
@@ -39,8 +40,8 @@ async function readSandbox(): Promise<{ supported: boolean; memoryLimitBytes?: n
 describe.skipIf(HTTP_SKIP)('sandbox-memory-cap: capability shape + behavioral (RFC 0035 §B)', () => {
   it('memoryLimitBytes MUST be integer ≥ 1 MiB when present (per schema)', async () => {
     const sb = await readSandbox();
-    if (!sb) return; // soft-skip
-    if (sb.memoryLimitBytes === undefined) return; // optional field
+    if (!sb) return softSkip('blocked', 'soft-skip (!sb)');
+    if (sb.memoryLimitBytes === undefined) return softSkip('inapplicable', 'optional field (sb.memoryLimitBytes === undefined)');
 
     expect(
       Number.isInteger(sb.memoryLimitBytes) && sb.memoryLimitBytes >= 1048576,

package/src/scenarios/sandbox-mvp-behavior.test.ts

@@ -36,6 +36,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 
@@ -82,7 +83,7 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
   it('host-fs-escape — fs access from sandboxed code fails closed', async (ctx) => {
     if (!(await isSandboxAdvertised())) {
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
     }
     const probe = await invoke('misbehave.fs-escape-read');
     expect(probe.status).toBe(200);
@@ -105,7 +106,7 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
   it('host-env-leak — process.env access from sandboxed code fails closed', async (ctx) => {
     if (!(await isSandboxAdvertised())) {
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
     }
     const probe = await invoke('misbehave.env-leak');
     expect(probe.status).toBe(200);
@@ -122,7 +123,7 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
   it('network-escape — http/net access from sandboxed code fails closed', async (ctx) => {
     if (!(await isSandboxAdvertised())) {
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
     }
     const probe = await invoke('misbehave.network-escape');
     expect(probe.status).toBe(200);
@@ -139,7 +140,7 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
   it('host-process-escape — child_process access from sandboxed code fails closed', async (ctx) => {
     if (!(await isSandboxAdvertised())) {
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
     }
     const probe = await invoke('misbehave.process-escape');
     expect(probe.status).toBe(200);
@@ -153,7 +154,7 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
   it('sandbox-timeout — runaway loop terminated by wallClockLimitMs', async (ctx) => {
     if (!(await isSandboxAdvertised())) {
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
     }
     const start = Date.now();
     const probe = await invoke('misbehave.timeout');
@@ -179,7 +180,7 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
   it('cross-pack-mutation — fresh vm context per invocation, no state leaks', async (ctx) => {
     if (!(await isSandboxAdvertised())) {
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
     }
     const r1 = await invoke('misbehave.cross-pack-mutate');
     const r2 = await invoke('misbehave.cross-pack-mutate');
@@ -205,7 +206,7 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
   it('capability-gate-respected — host call NOT in allowedHostCalls fails with sandbox_capability_denied', async (ctx) => {
     if (!(await isSandboxAdvertised())) {
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
     }
     const probe = await invoke('misbehave.capability-gate-violation', {}, []);
     expect(probe.status).toBe(200);
@@ -228,7 +229,7 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
   it('memory-exceeded — runaway allocation fails with sandbox_memory_exceeded', async (ctx) => {
     if (!(await isSandboxAdvertised())) {
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
     }
     const probe = await invoke('misbehave.memory-bomb');
     expect(probe.status).toBe(200);
@@ -255,7 +256,7 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
   it('well-behaved.host-fetch — allowedHostCalls=[fetch] permits the host call', async (ctx) => {
     if (!(await isSandboxAdvertised())) {
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
     }
     const probe = await invoke('well-behaved.host-fetch', {}, ['fetch']);
     expect(probe.status).toBe(200);
@@ -271,7 +272,7 @@ describe.skipIf(HTTP_SKIP)('sandbox-mvp-behavior: RFC 0035 §B failure-mode inva
   it('well-behaved.echo — sandboxed code returns args round-trip when no escape attempt', async (ctx) => {
     if (!(await isSandboxAdvertised())) {
       ctx.skip();
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await isSandboxAdvertised())` returned early');
     }
     const probe = await invoke('well-behaved.echo', { input: 'hello-sandbox' });
     expect(probe.status).toBe(200);

package/src/scenarios/sandbox-no-host-fs-escape.test.ts

@@ -25,6 +25,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 
@@ -55,7 +56,7 @@ async function readSandboxCaps(): Promise<SandboxCaps | null> {
 describe.skipIf(HTTP_SKIP)('sandbox-no-host-fs-escape: capability shape (RFC 0035 §A)', () => {
   it('capabilities.sandbox (when present) conforms to RFC 0035 §A', async () => {
     const sb = await readSandboxCaps();
-    if (sb === null) return; // host omits the block — soft-skip cleanly
+    if (sb === null) return softSkip('inapplicable', 'host omits the block — soft-skip cleanly (sb === null)');
 
     expect(typeof sb.supported, 'capabilities.sandbox.supported MUST be boolean when present').toBe('boolean');
 

package/src/scenarios/sandbox-timeout-cap.test.ts

@@ -14,6 +14,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 
@@ -39,8 +40,8 @@ async function readSandbox(): Promise<{ supported: boolean; wallClockLimitMs?: n
 describe.skipIf(HTTP_SKIP)('sandbox-timeout-cap: capability shape + behavioral (RFC 0035 §B)', () => {
   it('wallClockLimitMs MUST be integer ≥ 100 ms when present (per schema)', async () => {
     const sb = await readSandbox();
-    if (!sb) return;
-    if (sb.wallClockLimitMs === undefined) return; // optional
+    if (!sb) return softSkip('blocked', 'precondition not met — `!sb` returned early (seam, prior step, or fixture unavailable)');
+    if (sb.wallClockLimitMs === undefined) return softSkip('inapplicable', 'optional (sb.wallClockLimitMs === undefined)');
 
     expect(
       Number.isInteger(sb.wallClockLimitMs) && sb.wallClockLimitMs >= 100,