@openwop/openwop-conformance 1.72.2 → 1.98.0

package/src/lib/requirement-ledger.ts

@@ -0,0 +1,138 @@
+/**
+ * RFC 0148 §A — the requirement execution ledger.
+ *
+ * The program exists because a green bundle could overstate behavior that never
+ * ran. Every instance found so far shares one shape: **something absent was
+ * treated as something proven.** `verifyBundleProfile()` derived `floorProven`
+ * from `[].every(...)` over an undefined floor. A gated subtest 404'd and
+ * soft-skipped. A scenario early-returned and the file still counted as passed.
+ *
+ * So the ledger inverts the default. A requirement has **no** disposition until
+ * a scenario explicitly records one, and a requirement with no recorded
+ * disposition resolves to `blocked` — never to `executed-pass`. Silence is
+ * evidence of nothing, and the data structure now says so rather than relying on
+ * each author to remember it.
+ *
+ * That is the whole mechanism. Everything else here is bookkeeping.
+ */
+
+/** RFC 0148 §A. Exactly one of these per requirement, per run. */
+export type Disposition =
+  /** The assertion executed against the target and passed. */
+  | 'executed-pass'
+  /** The assertion executed and failed. */
+  | 'executed-fail'
+  /** The operator explicitly excluded an optional, unadvertised profile. */
+  | 'skipped'
+  /** The requirement does not apply to the captured discovery/profile set. */
+  | 'inapplicable'
+  /** Advertised behavior could not be exercised — seam, fixture, credential, or dependency missing. */
+  | 'blocked';
+
+export const DISPOSITIONS: readonly Disposition[] = [
+  'executed-pass',
+  'executed-fail',
+  'skipped',
+  'inapplicable',
+  'blocked',
+] as const;
+
+/**
+ * Dispositions that permit a profile to certify. `blocked` is deliberately NOT
+ * here: RFC 0148 §A says a blocked requirement in a claimed profile invalidates
+ * that profile's certification, because "we could not check" and "we checked and
+ * it holds" are the two states this program exists to stop conflating.
+ */
+export const CERTIFIABLE: readonly Disposition[] = [
+  'executed-pass',
+  'skipped',
+  'inapplicable',
+] as const;
+
+export interface LedgerEntry {
+  readonly requirementId: string;
+  readonly disposition: Disposition;
+  /** Why — required for every disposition except `executed-pass`. */
+  readonly detail?: string;
+}
+
+const ledger = new Map<string, LedgerEntry>();
+
+/**
+ * Record a requirement's outcome. Recording the same id twice with different
+ * dispositions throws: RFC 0148 §A says **exactly one** disposition per
+ * requirement, and a silent last-write-wins would let a later soft-skip
+ * overwrite an earlier real failure — the failure mode in reverse.
+ */
+export function recordRequirement(
+  requirementId: string,
+  disposition: Disposition,
+  detail?: string,
+): void {
+  const prior = ledger.get(requirementId);
+  if (prior !== undefined && prior.disposition !== disposition) {
+    throw new Error(
+      `RFC 0148 §A: ${requirementId} already recorded as '${prior.disposition}', now '${disposition}'. ` +
+        'Exactly one disposition per requirement per run.',
+    );
+  }
+  if (disposition !== 'executed-pass' && (detail === undefined || detail.trim() === '')) {
+    throw new Error(
+      `RFC 0148 §A: ${requirementId} recorded as '${disposition}' without a reason. ` +
+        'Anything other than executed-pass MUST say why, or the ledger records an outcome nobody can act on.',
+    );
+  }
+  ledger.set(requirementId, detail === undefined ? { requirementId, disposition } : { requirementId, disposition, detail });
+}
+
+/**
+ * The disposition for a requirement. **Absent resolves to `blocked`, never to a
+ * pass.** This is the inversion the whole section turns on: a scenario that
+ * returned early, threw and swallowed, or was never written leaves no entry, and
+ * the honest reading of no entry is "this was not exercised".
+ */
+export function dispositionOf(requirementId: string): Disposition {
+  return ledger.get(requirementId)?.disposition ?? 'blocked';
+}
+
+export function entryOf(requirementId: string): LedgerEntry {
+  return (
+    ledger.get(requirementId) ?? {
+      requirementId,
+      disposition: 'blocked',
+      detail: 'no disposition recorded — the requirement was not exercised',
+    }
+  );
+}
+
+export function snapshot(): readonly LedgerEntry[] {
+  return [...ledger.values()].sort((a, b) => a.requirementId.localeCompare(b.requirementId));
+}
+
+/** Test-support only. Production runs record once and read once. */
+export function resetLedger(): void {
+  ledger.clear();
+}
+
+export interface ProfileVerdict {
+  readonly profile: string;
+  readonly certifiable: boolean;
+  readonly blocking: readonly LedgerEntry[];
+}
+
+/**
+ * Whether a profile's requirements permit certification. A profile with **no**
+ * requirements is NOT certifiable by this function — an empty requirement set
+ * is the `[].every(...)` shape that started all of this, and callers must
+ * distinguish "no floor by design" (`discoveryOnly`) from "no floor written yet"
+ * before reaching here.
+ */
+export function verifyProfileRequirements(
+  profile: string,
+  requirementIds: readonly string[],
+): ProfileVerdict {
+  const blocking = requirementIds
+    .map(entryOf)
+    .filter((e) => !CERTIFIABLE.includes(e.disposition));
+  return { profile, certifiable: requirementIds.length > 0 && blocking.length === 0, blocking };
+}

package/src/lib/requirement-registry.ts

@@ -0,0 +1,62 @@
+/**
+ * RFC 0148 §A — stable requirement IDs for the certification floor.
+ *
+ * §A requires "every normative conformance assertion included in a certifiable
+ * profile" to carry a stable `requirementId`. This registry is the first tranche:
+ * the floor scenarios that `PROFILE_FLOOR_SCENARIOS` already makes certification
+ * depend on. It is deliberately NOT a sweep over all 421 scenario files.
+ *
+ * The reason is the measurement in `docs/RFC-LIFECYCLE-COHERENCE.md`, applied to
+ * a different surface: a gate that fires hundreds of times on its first run gets
+ * disabled rather than fixed. Tagging every assertion in one pass would produce a
+ * registry nobody could review, and an unreviewed requirement ID is worth less
+ * than no requirement ID — it looks like coverage.
+ *
+ * So the scope is exactly what certification consumes today. `requirementsFor()`
+ * returns the IDs a profile's claim rests on, and anything outside this registry
+ * is honestly outside §A's coverage rather than silently assumed covered.
+ *
+ * Adding a requirement is deliberately cheap; adding it *without* a scenario
+ * recording a disposition for it is deliberately loud, because the ledger
+ * resolves an unrecorded requirement to `blocked`.
+ */
+
+import { PROFILE_FLOOR_SCENARIOS } from './profiles.js';
+
+/** `runs-lifecycle.test.ts` → `openwop.floor.runs-lifecycle`. */
+export function requirementIdForScenario(scenarioFile: string): string {
+  return `openwop.floor.${scenarioFile.replace(/\.test\.ts$/, '')}`;
+}
+
+/** Prefix groups become one requirement: `interrupt-` → `openwop.floor.any.interrupt-`. */
+export function requirementIdForPrefix(prefix: string): string {
+  return `openwop.floor.any.${prefix}`;
+}
+
+/**
+ * The requirement IDs a profile's certification rests on.
+ *
+ * Returns `null` — not an empty array — when the corpus has no floor for the
+ * profile. An empty array would flow into `verifyProfileRequirements()` and read
+ * as "nothing blocking", which is the `[].every(...)` shape this program exists
+ * to close. `null` forces the caller to decide between `discoveryOnly` (an empty
+ * floor by design) and unspecified (no floor written yet).
+ */
+export function requirementsFor(profile: string): readonly string[] | null {
+  const floor = PROFILE_FLOOR_SCENARIOS[profile];
+  if (floor === undefined) return null;
+  if (floor.discoveryOnly === true) return [];
+  return [
+    ...floor.required.map(requirementIdForScenario),
+    ...(floor.requiredAnyPrefix ?? []).map(requirementIdForPrefix),
+  ];
+}
+
+/** Every registered requirement ID across every profile with a runtime floor. */
+export function allRequirements(): readonly string[] {
+  const ids = new Set<string>();
+  for (const profile of Object.keys(PROFILE_FLOOR_SCENARIOS)) {
+    for (const id of requirementsFor(profile) ?? []) ids.add(id);
+  }
+  return [...ids].sort();
+}

package/src/scenarios/a2a-version-negotiation.test.ts

@@ -0,0 +1,159 @@
+/**
+ * RFC 0152 §B — A2A version negotiation, witnessed against the fake peer.
+ *
+ * This file exists because I twice described RFC 0152 as needing a live
+ * upstream A2A peer, and that was only half true. **Interop needs a real peer.
+ * Negotiation does not** — negotiation is the *host's* behavior, and the host is
+ * right here. What was actually missing was that `A2AFakePeer` recorded method,
+ * path, rpcMethod, and body, but **not headers** — and §B lives entirely in the
+ * headers. The peer could observe that a call happened but not which version was
+ * negotiated, which is the only part §B is about.
+ *
+ * So the blocker was apparatus, again, and the fix was to record what the fake
+ * peer already received.
+ *
+ * `Real upstream A2A 1.0 peer passes in CI` remains a separate and unmet
+ * acceptance item — it tests interoperation, which no fake can stand in for.
+ * This file does not claim it, and RFC 0152's acceptance criteria still say so.
+ *
+ * The load-bearing requirement is negative: **"a host MUST NOT silently
+ * downgrade an authenticated request."** A silent downgrade is the dangerous
+ * outcome precisely because it *succeeds* — the caller believes it negotiated
+ * 1.0, the peer answered 0.3, and nothing in the response says otherwise. A
+ * failure would at least be visible.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { behaviorGate } from '../lib/behavior-gate.js';
+import { capabilityFamily } from '../lib/discovery-capabilities.js';
+import { getA2AFakePeer } from '../lib/a2a-fake-peer.js';
+
+const PROFILE = 'a2a.versionNegotiation';
+
+interface A2ACaps {
+  readonly supported?: boolean;
+  readonly protocolVersions?: readonly string[];
+  readonly preferredVersion?: string;
+}
+
+async function a2a(): Promise<A2ACaps | undefined> {
+  const disco = await driver.get('/.well-known/openwop');
+  return capabilityFamily<A2ACaps>(disco.json, 'a2a');
+}
+
+/** Advertised versions are a §A shape claim; §B is what the host DOES with them. */
+async function negotiationAdvertised(): Promise<boolean> {
+  const caps = await a2a();
+  return caps?.supported === true && (caps.protocolVersions?.length ?? 0) > 0;
+}
+
+describe('RFC 0152 §B — A2A version negotiation', () => {
+  it('the advertised preferred version is one the host actually claims', async () => {
+    if (!behaviorGate(PROFILE, await negotiationAdvertised())) return;
+    const caps = await a2a();
+    expect(
+      caps?.protocolVersions ?? [],
+      driver.describe(
+        'RFCS/0152-a2a-1-0-versioned-composition.md §A',
+        '`preferredVersion` MUST be present in `protocolVersions`. Preferring a version you do ' +
+          'not list is a claim no peer can act on.',
+      ),
+    ).toContain(caps?.preferredVersion);
+  });
+
+  it('outbound calls carry an explicit A2A-Version header', async () => {
+    if (!behaviorGate(PROFILE, await negotiationAdvertised())) return;
+    const peer = getA2AFakePeer();
+    if (peer === null) return; // no fake peer wired in this run
+    peer.reset();
+    const drive = await driver.post('/v1/host/sample/a2a/invoke', { peerUrl: peer.endpoint() });
+    if (drive.status === 404 || drive.status === 403) {
+      // Seam absent. RFC 0148 §A: unobservable resolves to `blocked`, not a pass.
+      expect(
+        drive.status,
+        driver.describe(
+          'RFCS/0152 §B',
+          'a host advertising A2A version negotiation MUST expose an invoke seam so the negotiated ' +
+            'version is observable. Without it the requirement cannot be witnessed and resolves to ' +
+            '`blocked` per RFC 0148 §A.',
+        ),
+      ).not.toBe(404);
+      return;
+    }
+    const calls = peer.invocations().filter((i: { method: string }) => i.method !== 'GET');
+    expect(calls.length, 'the host MUST have called the peer').toBeGreaterThan(0);
+    for (const c of calls) {
+      expect(
+        c.headers['a2a-version'],
+        driver.describe(
+          'RFCS/0152 §B',
+          'the sender MUST send `A2A-Version`. An absent header leaves the receiver guessing, and ' +
+            'a guess that happens to be right is not a negotiation.',
+        ),
+      ).toBeTruthy();
+    }
+  });
+
+  it('an authenticated request is not silently downgraded', async () => {
+    if (!behaviorGate(PROFILE, await negotiationAdvertised())) return;
+    const peer = getA2AFakePeer();
+    if (peer === null) return;
+    const caps = await a2a();
+    const preferred = caps?.preferredVersion;
+    peer.reset();
+    const drive = await driver.post('/v1/host/sample/a2a/invoke', {
+      peerUrl: peer.endpoint(),
+      authenticated: true,
+      peerOffersOnly: '0.3',
+    });
+    if (drive.status === 404 || drive.status === 403) return; // covered above
+
+    // THE load-bearing leg. A silent downgrade is dangerous precisely because it
+    // SUCCEEDS: the caller believes it negotiated `preferred`, the peer answered
+    // 0.3, and nothing in the response says otherwise. Either the host refuses
+    // (fails closed, visibly) or it negotiates down EXPLICITLY — what it must
+    // not do is return success while having quietly used the lower version.
+    if (drive.status < 400) {
+      const negotiated = (drive.json as { negotiatedVersion?: string }).negotiatedVersion;
+      expect(
+        negotiated,
+        driver.describe(
+          'RFCS/0152 §B',
+          'a host that proceeds after a downgrade MUST report the version it actually negotiated. ' +
+            'Reporting the preferred version while having used a lower one is the silent downgrade ' +
+            '§B forbids — and it is worse than a failure because it succeeds.',
+        ),
+      ).not.toBe(preferred);
+      const calls = peer.invocations().filter((i: { method: string }) => i.method !== 'GET');
+      for (const c of calls) {
+        expect(
+          c.headers['a2a-version'],
+          driver.describe('RFCS/0152 §B', 'the wire header MUST match the reported negotiated version'),
+        ).toBe(negotiated);
+      }
+    }
+  });
+
+  it('an unsupported version fails through the canonical interop error envelope', async () => {
+    if (!behaviorGate(PROFILE, await negotiationAdvertised())) return;
+    const peer = getA2AFakePeer();
+    if (peer === null) return;
+    const drive = await driver.post('/v1/host/sample/a2a/invoke', {
+      peerUrl: peer.endpoint(),
+      requestVersion: '99.0',
+    });
+    if (drive.status === 404 || drive.status === 403) return;
+    expect(drive.status >= 400, driver.describe('RFCS/0152 §B', 'an unsupported version MUST fail')).toBe(true);
+    const err = (drive.json as { error?: { code?: string; retriable?: boolean } }).error;
+    expect(
+      err?.code,
+      driver.describe(
+        'RFCS/0152 §B',
+        'the upstream version error MUST be projected through the canonical OpenWOP interop error ' +
+          'envelope when the failure crosses an OpenWOP boundary — a raw upstream body leaves the ' +
+          'caller parsing a foreign protocol to learn its own request was rejected',
+      ),
+    ).toBeTruthy();
+  });
+});

package/src/scenarios/capability-example-root-layout.test.ts

@@ -0,0 +1,113 @@
+/**
+ * RFC 0149 §B — normative discovery examples place capability families at the
+ * document root.
+ *
+ * RFC 0073 (`Accepted`) made the root layout "the normative MUST since Phase 1"
+ * and, at Phase 4, made the suite enforce it: a wrapper-only host "grades as
+ * non-conformant". The `capabilities` wrapper survives only as a deprecated
+ * shape that runtime discovery tolerates through the v1.x window, retiring at
+ * v2.0 when `capabilities.schema.json` tightens.
+ *
+ * Tolerating a shape at runtime and teaching it in a normative example are
+ * different things. Eight `spec/v1` examples — several under headings like
+ * "Capability advertisement (normative)", introduced by prose saying hosts
+ * "advertise it under `/.well-known/openwop`" — showed the deprecated wrapper.
+ * An implementer copying one produced a document RFC 0073 grades as
+ * non-conformant, and no gate noticed, because a fenced example is prose to
+ * every validator in the corpus.
+ *
+ * This gate is authoring-time only. It says nothing about what a server may
+ * emit: RFC 0149 §B is explicit that the runtime schema MUST NOT reject an
+ * otherwise legal unknown server-emitted property, and nothing here reads a
+ * host.
+ *
+ * `spec/v1/` and `RFCS/` ship in the repository, NOT in the published tarball,
+ * so this self-skips under the published layout. That asymmetry has produced
+ * three defects in this corpus — the `CORPUS-STAMP` gate, the link-checker's
+ * filesystem walk, and RFC 0146 leg A4, which ENOENT'd for every adopter
+ * running from the package.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { readFileSync, readdirSync, existsSync } from 'node:fs';
+import { join, resolve as pathResolve } from 'node:path';
+import { V1_DIR } from '../lib/paths.js';
+
+/** RFC 0073 established the root layout; examples in earlier RFCs are historical record. */
+const ROOT_LAYOUT_RFC = 73;
+
+const RFCS_DIR = V1_DIR === null ? null : pathResolve(V1_DIR, '..', '..', 'RFCS');
+
+interface FencedExample {
+  readonly file: string;
+  readonly line: number;
+  readonly rootWrapper: boolean;
+}
+
+/** Fenced ```json / ```jsonc blocks, flagged when the root object's first key is `capabilities`. */
+function fencedExamples(dir: string): FencedExample[] {
+  const found: FencedExample[] = [];
+  for (const name of readdirSync(dir).filter((f) => f.endsWith('.md')).sort()) {
+    const lines = readFileSync(join(dir, name), 'utf8').split('\n');
+    for (let i = 0; i < lines.length; i++) {
+      if (!/^```(json|jsonc)\s*$/.test(lines[i]!.trim())) continue;
+      const body: string[] = [];
+      let j = i + 1;
+      while (j < lines.length && lines[j]!.trim() !== '```') {
+        body.push(lines[j]!);
+        j++;
+      }
+      const rootWrapper =
+        body.length > 1 && /^\s*\{\s*$/.test(body[0]!) && /^\s*"capabilities"\s*:\s*\{\s*$/.test(body[1]!);
+      found.push({ file: name, line: i + 2, rootWrapper });
+      i = j;
+    }
+  }
+  return found;
+}
+
+describe.skipIf(V1_DIR === null)('RFC 0149 §B — discovery examples use the document-root layout', () => {
+  const v1Dir = V1_DIR as string;
+
+  it('the scan finds fenced examples at all', () => {
+    // Guard: an extractor that silently matched nothing would make the
+    // assertions below vacuously true, which is the failure mode RFC 0148
+    // exists to close. This gate must not become an instance of it.
+    const examples = fencedExamples(v1Dir);
+    expect(examples.length, 'spec/v1 MUST contain fenced json/jsonc examples to check').toBeGreaterThan(20);
+  });
+
+  it('no spec/v1 example wraps capability families in a top-level `capabilities` object', () => {
+    const offenders = fencedExamples(v1Dir)
+      .filter((e) => e.rootWrapper)
+      .map((e) => `spec/v1/${e.file}:${e.line}`);
+    expect(
+      offenders,
+      'RFC 0073: capability families are a property of the DOCUMENT ROOT; there is no `capabilities` wrapper. ' +
+        'A normative example showing the deprecated shape teaches a document RFC 0073 grades as non-conformant.\n  ' +
+        offenders.join('\n  '),
+    ).toEqual([]);
+  });
+
+  it('every RFC still showing the wrapper predates RFC 0073, which established root layout', () => {
+    // RFCs are a dated record of what was proposed, so their examples are NOT
+    // rewritten to match a later layout — that would make the record lie. The
+    // exemption is asserted rather than assumed: a NEW post-0073 RFC that
+    // introduces a wrapper fails here, so the historical carve-out cannot widen
+    // into a licence.
+    if (RFCS_DIR === null || !existsSync(RFCS_DIR)) return;
+    const late = fencedExamples(RFCS_DIR)
+      .filter((e) => e.rootWrapper)
+      .filter((e) => {
+        const n = Number.parseInt(e.file.slice(0, 4), 10);
+        return Number.isFinite(n) && n >= ROOT_LAYOUT_RFC;
+      })
+      .map((e) => `RFCS/${e.file}:${e.line}`);
+    expect(
+      late,
+      `an RFC numbered >= ${ROOT_LAYOUT_RFC} uses the deprecated \`capabilities\` wrapper. ` +
+        'Pre-0073 RFCs keep theirs as historical record; a later one has no such excuse.\n  ' +
+        late.join('\n  '),
+    ).toEqual([]);
+  });
+});

package/src/scenarios/certification-bundle-v2.test.ts

@@ -0,0 +1,157 @@
+/**
+ * RFC 0148 §C — certification bundle v2.
+ *
+ * v1 recorded `{passed, failed, skipped}` as scenario-file lists. Those three
+ * words cannot express the distinction this entire program turns on:
+ *
+ *   - a file counted as **passed** whether its assertions ran or its runner
+ *     returned early — which is how a gated subtest that 404'd left a green file;
+ *   - **skipped** flattened three different claims into one word: "the operator
+ *     excluded this", "the requirement does not apply here", and "we could not
+ *     check". The first two are certifiable. The third invalidates the claim,
+ *     and v1 had no way to say it.
+ *
+ * v2 replaces the lists with per-requirement dispositions from §A and adds the
+ * counts §A.4 requires. Two properties are load-bearing and are what these legs
+ * defend:
+ *
+ *   - **`blocked` is a required total.** `blocked: 0` asserted is a different
+ *     claim from `blocked` unstated, and an omitted total is indistinguishable
+ *     from zero.
+ *   - **`assertionCount` makes a vacuous pass visible.** `executed-pass` with
+ *     `assertionCount: 0` is exactly the shape RFC 0148 exists to close, and a
+ *     reader can now see it in the artifact rather than having to re-run.
+ *
+ * Server-free.
+ */
+
+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';
+
+const HEX = 'a'.repeat(64);
+
+/**
+ * Resolve the schema through `SCHEMAS_DIR`, not through `V1_DIR/../..`.
+ *
+ * The earlier form derived the repo root from the PROSE directory, which is
+ * `null` in the published tarball because prose is not bundled — and then cast
+ * the null away with `as string`. The cast satisfied the compiler and the file
+ * still passed in a repo checkout, so nothing anywhere reported a problem;
+ * installed from npm it threw at import and took the whole suite file down.
+ *
+ * Schemas ARE vendored into the package, so `SCHEMAS_DIR` is non-null in both
+ * layouts. Reading through it does not merely stop the crash — it makes these
+ * legs RUN for consumers, where before they could only have skipped.
+ */
+function validator() {
+  const schema = JSON.parse(
+    readFileSync(join(SCHEMAS_DIR, 'certification-bundle-v2.schema.json'), 'utf8'),
+  ) as object;
+  return new Ajv2020({ strict: false, allErrors: true }).compile(schema);
+}
+
+const bundle = (over: Record<string, unknown> = {}) => ({
+  bundleVersion: '2',
+  suite: { package: '@openwop/openwop-conformance', version: '1.92.0' },
+  host: { name: 'example-host', version: '1.0.0' },
+  discovery: { sha256: HEX, document: { protocolVersion: '1.0' } },
+  claimedProfiles: ['openwop-core-standard'],
+  results: {
+    totals: { executedPass: 41, executedFail: 0, skipped: 2, inapplicable: 7, blocked: 0 },
+    requirements: [
+      { requirementId: 'openwop.floor.runs-lifecycle', scenarioId: 'runs-lifecycle', disposition: 'executed-pass', assertionCount: 3, witnessSha256: HEX },
+    ],
+  },
+  scenarioManifestSha256: HEX,
+  targetConfigurationSha256: HEX,
+  ...over,
+});
+
+describe('RFC 0148 §C — certification bundle v2', () => {
+  const validate = validator();
+
+  it('a well-formed v2 bundle validates', () => {
+    expect(validate(bundle()), JSON.stringify(validate.errors)).toBe(true);
+  });
+
+  it('all five totals are required, including blocked', () => {
+    // `blocked: 0` asserted is a different claim from `blocked` unstated. An
+    // omitted total is indistinguishable from zero, and the one total that
+    // invalidates a certification is the one most worth omitting.
+    for (const missing of ['executedPass', 'executedFail', 'skipped', 'inapplicable', 'blocked']) {
+      const totals: Record<string, number> = { executedPass: 1, executedFail: 0, skipped: 0, inapplicable: 0, blocked: 0 };
+      delete totals[missing];
+      expect(
+        validate(bundle({ results: { totals, requirements: bundle().results.requirements } })),
+        `RFC 0148 §C: \`${missing}\` MUST be present — an omitted total reads as zero without ` +
+          'anyone having asserted it',
+      ).toBe(false);
+    }
+  });
+
+  it('the requirement list cannot be empty', () => {
+    expect(
+      validate(bundle({ results: { totals: bundle().results.totals, requirements: [] } })),
+      'RFC 0148 §C: a bundle with no requirement rows records no execution. An empty evidence set ' +
+        'reading as proof is the defect this section exists to close.',
+    ).toBe(false);
+  });
+
+  it('a disposition outside the §A vocabulary is rejected', () => {
+    expect(
+      validate(bundle({
+        results: {
+          totals: bundle().results.totals,
+          requirements: [{ requirementId: 'x', scenarioId: 'y', disposition: 'probably-fine' }],
+        },
+      })),
+    ).toBe(false);
+  });
+
+  it('a vacuous pass is representable and therefore visible', () => {
+    // Deliberately VALID. The schema does not forbid `executed-pass` with zero
+    // assertions — forbidding it would only move the lie one field over, since
+    // a generator could write `assertionCount: 1`. What v2 buys is that the
+    // number is IN the artifact, so a reader or a downstream verifier can see a
+    // pass that executed nothing without re-running the suite.
+    const b = bundle({
+      results: {
+        totals: bundle().results.totals,
+        requirements: [{ requirementId: 'x', scenarioId: 'y', disposition: 'executed-pass', assertionCount: 0 }],
+      },
+    });
+    expect(validate(b), JSON.stringify(validate.errors)).toBe(true);
+    const rows = (b.results as { requirements: { disposition: string; assertionCount?: number }[] }).requirements;
+    expect(
+      rows.some((r) => r.disposition === 'executed-pass' && r.assertionCount === 0),
+      'the vacuous shape MUST remain inspectable in the artifact — v1 could not express it at all',
+    ).toBe(true);
+  });
+
+  it('claimed profiles use canonical IDs, not deprecated aliases', () => {
+    // RFC 0155 §E. A badge substantiated by a name that no longer means what it
+    // did is the `openwop-core` ambiguity in bundle form.
+    expect(validate(bundle({ claimedProfiles: ['openwop-core-standard'] }))).toBe(true);
+    expect(validate(bundle({ claimedProfiles: ['Legacy Core'] }))).toBe(false);
+    expect(validate(bundle({ claimedProfiles: [] }))).toBe(false);
+  });
+
+  it('provenance digests are required and hex-shaped', () => {
+    // Without `scenarioManifestSha256` a bundle cannot be distinguished from one
+    // produced against a different, smaller suite; without
+    // `targetConfigurationSha256`, from one against a differently-configured host.
+    for (const field of ['scenarioManifestSha256', 'targetConfigurationSha256']) {
+      const b = bundle() as Record<string, unknown>;
+      delete b[field];
+      expect(validate(b), `RFC 0147 §A.4: ${field} MUST be present`).toBe(false);
+    }
+    expect(validate(bundle({ scenarioManifestSha256: 'not-a-digest' }))).toBe(false);
+  });
+
+  it('bundleVersion is pinned to 2', () => {
+    expect(validate(bundle({ bundleVersion: '1' })), 'a v1 bundle MUST NOT validate as v2').toBe(false);
+  });
+});