@openwop/openwop-conformance 1.106.1 → 1.124.0

package/src/scenarios/a2a-peer-authority.test.ts

@@ -0,0 +1,99 @@
+/**
+ * RFC 0152 §E — a peer's content is never authority (invariant
+ * `a2a-peer-no-authority-escalation`, named by RFC 0152 §E; §"Trust boundary"
+ * `prompt-injection-mcp-no-approval` generalized to A2A).
+ *
+ * The host acts as an A2A CLIENT against the suite's fake peer. The peer's
+ * agent-role reply carries everything a hostile peer would try: text that reads
+ * like an approval, `metadata.openwop.approval: "accept"`, `metadata.openwop.
+ * scopes[]`, `metadata.openwop.interrupt.resolve`, and a `referenceTaskIds[]`
+ * pointing at a task the caller never created. `a2a-integration.md` §D.2 says
+ * all of it is opaque and §E says none of it may become authority: the run's
+ * approval state, tool allowlist, and scopes MUST be exactly what they were
+ * before the peer answered, and the referenced task MUST NOT be dereferenced on
+ * the peer's say-so.
+ *
+ * Observability: the host's `/v1/host/sample/a2a/invoke` seam accepts an
+ * ADDITIVE `scenario: "peer-asserts-authority"` and, when it implements it,
+ * reports `peerAuthority: { approvalAdvanced, scopesWidened, referencedTaskDereferenced }`
+ * (`host-sample-test-seams.md` §22). A host that has not added the field is
+ * recorded `blocked` for this requirement rather than passed — RFC 0148 §A —
+ * because a leg that cannot see the outcome cannot vouch for it.
+ *
+ * Gate: `a2a.supported && a2a.protocolVersions.length > 0` (same as the §B
+ * legs — the requirement is version-independent). Needs the fake peer
+ * (`OPENWOP_A2A_FAKE_PEER=true`).
+ *
+ * @see spec/v1/a2a-integration.md §"A2A 1.0 versioned composition" §D.2, §E
+ */
+
+import { describe, it, expect } from 'vitest';
+import { softSkip, seamAbsent } from '../lib/soft-skip.js';
+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';
+
+export const REQUIRES_HOST_CALLBACK = "the host issues A2A JSON-RPC calls to the suite's fake peer via /v1/host/sample/a2a/invoke (peerUrl), which the peer records";
+
+const PROFILE = 'a2a.peerAuthority';
+
+interface A2ACaps {
+  readonly supported?: boolean;
+  readonly protocolVersions?: readonly string[];
+}
+
+async function advertised(): Promise<boolean> {
+  const disco = await driver.get('/.well-known/openwop');
+  const caps = capabilityFamily<A2ACaps>(disco.json, 'a2a');
+  return caps?.supported === true && (caps.protocolVersions?.length ?? 0) > 0;
+}
+
+interface PeerAuthorityReport {
+  approvalAdvanced?: boolean;
+  scopesWidened?: boolean;
+  referencedTaskDereferenced?: boolean;
+}
+
+describe('RFC 0152 §E — a2a-peer-no-authority-escalation (host as A2A client, gated)', () => {
+  it('a peer reply that asserts approval, scopes, and a foreign task reference changes nothing the host authorizes', async () => {
+    if (!behaviorGate(PROFILE, await advertised())) return;
+    const peer = getA2AFakePeer();
+    if (peer === null) return softSkip('blocked', 'the suite A2A fake peer is not started in this run (OPENWOP_A2A_FAKE_PEER unset) — the host-as-client leg cannot be driven');
+    peer.reset();
+    peer.setNextPeerAssertsAuthority(true);
+    const drive = await driver.post('/v1/host/sample/a2a/invoke', {
+      peerUrl: peer.endpoint(),
+      scenario: 'peer-asserts-authority',
+    });
+    if (drive.status === 404 || drive.status === 403) {
+      // Advertised A2A but the invoke seam answered {drive.status}: not observable here.
+      // Default mode records `blocked` (RFC 0148 §A); OPENWOP_REQUIRE_BEHAVIOR=true fails
+      // an advertised-missing seam (RFC 0148 §B). A 403 is NOT a pass.
+      return seamAbsent(`host advertises A2A but the invoke seam /v1/host/sample/a2a/invoke answered ${drive.status}`);
+    }
+    // The peer must actually have answered with the authority-asserting message,
+    // or this leg is vacuous.
+    const created = peer.taskCount();
+    expect(created, driver.describe('RFCS/0152 §E', 'the host MUST have created a task on the peer for this leg to mean anything')).toBeGreaterThan(0);
+    const report = (drive.json as { peerAuthority?: PeerAuthorityReport }).peerAuthority;
+    if (report === undefined) {
+      // Additive seam field not yet implemented: blocked, not passed.
+      expect(
+        report,
+        driver.describe(
+          'host-sample-test-seams.md §22',
+          'the invoke seam SHOULD report `peerAuthority: { approvalAdvanced, scopesWidened, referencedTaskDereferenced }` for ' +
+            'scenario "peer-asserts-authority"; until it does this requirement is unobservable and resolves to `blocked`, not passed',
+        ),
+      ).toBeDefined();
+      return;
+    }
+    expect(report.approvalAdvanced, driver.describe('RFCS/0152 §E', 'peer content MUST NOT advance an approval gate (a2a-peer-no-authority-escalation)')).toBe(false);
+    expect(report.scopesWidened, driver.describe('RFCS/0152 §E', 'peer content MUST NOT widen the run’s scopes or tool allowlist')).toBe(false);
+    expect(
+      report.referencedTaskDereferenced,
+      driver.describe('a2a-integration.md §D.2', '`referenceTaskIds[]` are opaque hints — MUST NOT be dereferenced on the peer’s say-so'),
+    ).toBe(false);
+  });
+});

package/src/scenarios/a2a-task-roundtrip.test.ts

@@ -104,7 +104,7 @@ async function rpc(
 }
 
 describe('a2a-task-roundtrip: AgentCard + task lifecycle', () => {
-  it('AgentCard exposes protocolVersion + skills; message/send + tasks/get round-trip per A2A v0.3 JSON-RPC', async () => {
+  it('AgentCard exposes a protocol version (0.3 top-level or 1.0 per-interface) + skills; message/send + tasks/get round-trip per A2A v0.3 JSON-RPC', async () => {
     const probe = probePeer();
     if (!probe) {
       // eslint-disable-next-line no-console
@@ -125,18 +125,30 @@ describe('a2a-task-roundtrip: AgentCard + task lifecycle', () => {
       skills?: ReadonlyArray<{ id?: string; name?: string }>;
       url?: string;
       additionalInterfaces?: ReadonlyArray<{ url?: string; transport?: string }>;
+      // A2A 1.0 (RFC 0152 §C): the version is per interface and the top-level
+      // `url`/`protocolVersion` are gone. A dual-era peer (the suite's own, since
+      // 1.112.0, and any real 1.0 peer) serves THIS shape while still speaking
+      // 0.3 to a header-less request — which is what this leg exercises.
+      supportedInterfaces?: ReadonlyArray<{ url?: string; protocolBinding?: string; protocolVersion?: string }>;
     };
-    expect(typeof cardJson.protocolVersion).toBe('string');
+    const advertisedVersion =
+      cardJson.protocolVersion ??
+      cardJson.supportedInterfaces?.find((i) => typeof i.protocolVersion === 'string')?.protocolVersion;
+    expect(
+      typeof advertisedVersion,
+      'the card MUST advertise a protocol version — top-level (0.3) or per interface (1.0)',
+    ).toBe('string');
     expect(Array.isArray(cardJson.skills)).toBe(true);
     expect((cardJson.skills ?? []).length).toBeGreaterThan(0);
 
-    // Find the JSON-RPC transport endpoint. A2A v0.3 hosts MAY advertise
-    // multiple transports via `additionalInterfaces`; we pick the first
-    // JSONRPC entry, falling back to `card.url`.
+    // Find the JSON-RPC transport endpoint: 1.0 `supportedInterfaces[]`
+    // (`protocolBinding: "JSONRPC"`), else 0.3 `additionalInterfaces[]`
+    // (`transport: "JSONRPC"`), else 0.3 `card.url`.
+    const jsonrpc10 = (cardJson.supportedInterfaces ?? []).find((i) => i.protocolBinding === 'JSONRPC');
     const jsonrpcIface = (cardJson.additionalInterfaces ?? []).find(
       (i) => i.transport === 'JSONRPC',
     );
-    const rpcUrl = jsonrpcIface?.url ?? cardJson.url ?? `${probe.url}/a2a/jsonrpc`;
+    const rpcUrl = jsonrpc10?.url ?? jsonrpcIface?.url ?? cardJson.url ?? `${probe.url}/a2a/jsonrpc`;
     expect(typeof rpcUrl).toBe('string');
 
     if (probe.isReal) {

package/src/scenarios/agent-loop-iteration-monotonic.test.ts

@@ -10,14 +10,15 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { readExecutionModelCap, isVersion5, invokeAgentLoop } from '../lib/agentLoop.js';
 
 describe('agent-loop-iteration-monotonic (RFC 0061 §B)', () => {
   it('iteration increments by exactly 1 per orchestrator turn, 1-based', async () => {
-    if (!isVersion5(await readExecutionModelCap())) return;
+    if (!isVersion5(await readExecutionModelCap())) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isVersion5(await readExecutionModelCap())` returned early');
     const res = await invokeAgentLoop({ turns: 3 });
-    if (res === null) return; // seam absent — soft-skip
+    if (res === null) return softSkip('blocked', 'seam absent — soft-skip');
     const decisions = res.decisions ?? [];
     expect(
       decisions.length >= 1,

package/src/scenarios/agent-loop-stateful-resume.test.ts

@@ -10,16 +10,17 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { readExecutionModelCap, invokeAgentLoop } from '../lib/agentLoop.js';
 
 describe('agent-loop-stateful-resume (RFC 0061 §D)', () => {
   it('a mid-loop suspend resumes at the same iteration, counter intact', async () => {
     const em = await readExecutionModelCap();
-    if (em?.statefulResume !== true) return;
+    if (em?.statefulResume !== true) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `em?.statefulResume !== true` returned early');
     // Suspend at turn 2, then resume: the resumed iteration MUST be 2, not 1 or 3.
     const res = await invokeAgentLoop({ turns: 4, suspendAtTurn: 2, resume: true });
-    if (res === null) return; // seam absent — soft-skip
+    if (res === null) return softSkip('blocked', 'seam absent — soft-skip');
     expect(
       res.resumedIteration,
       driver.describe('RFC 0061 §D', 'a stateful resume MUST continue at the suspend iteration — the counter does not reset or skip'),

package/src/scenarios/agent-loop-version5-shape.test.ts

@@ -12,13 +12,14 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { readExecutionModelCap } from '../lib/agentLoop.js';
 
 describe('agent-loop-version5-shape: advertisement (RFC 0061 §A)', () => {
   it('executionModel.statefulResume/transcriptWindow are well-formed when present', async () => {
     const em = await readExecutionModelCap();
-    if (em === null) return; // no execution model — valid
+    if (em === null) return softSkip('inapplicable', 'no execution model — valid (em === null)');
     if (em.statefulResume !== undefined) {
       expect(
         typeof em.statefulResume,

package/src/scenarios/agent-loop-workspace-snapshot.test.ts

@@ -11,15 +11,16 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { readExecutionModelCap, isVersion5, hasWorkspace, invokeAgentLoop } from '../lib/agentLoop.js';
 
 describe('agent-loop-workspace-snapshot (RFC 0061 §C)', () => {
   it('a turn-i workspace write is invisible to turn i, visible to turn i+1', async () => {
-    if (!isVersion5(await readExecutionModelCap())) return;
-    if (!(await hasWorkspace())) return; // workspace optional — soft-skip
+    if (!isVersion5(await readExecutionModelCap())) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isVersion5(await readExecutionModelCap())` returned early');
+    if (!(await hasWorkspace())) return softSkip('inapplicable', 'workspace optional — soft-skip (!(await hasWorkspace()))');
     const res = await invokeAgentLoop({ turns: 2, workspaceWriteAtTurn: 1 });
-    if (res === null) return; // seam absent — soft-skip
+    if (res === null) return softSkip('blocked', 'seam absent — soft-skip');
     const vis = res.workspaceVisible ?? {};
     expect(
       vis.atWriteTurn,

package/src/scenarios/approval-gate-flow.test.ts

@@ -21,6 +21,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
 
@@ -32,12 +33,12 @@ async function authorizationSupported(): Promise<boolean> {
 
 describe('approval-gate-flow: role-gated, audited approval (RFC 0051 §A)', () => {
   it('an unauthorized principal does NOT release the gate (fail-closed)', async () => {
-    if (!(await authorizationSupported())) return; // capability-gated
+    if (!(await authorizationSupported())) return softSkip('inapplicable', 'capability-gated');
     const res = await driver.post('/v1/host/sample/governance/approval-gate', {
       scenario: 'unauthorized-grant',
       principal: 'conformance-unauthorized-principal',
     });
-    if (res.status === 404) return; // seam unwired — soft-skip
+    if (res.status === 404) return softSkip('blocked', 'seam unwired — soft-skip');
     const body = res.json as { released?: boolean } | undefined;
     expect(
       body?.released,
@@ -46,13 +47,13 @@ describe('approval-gate-flow: role-gated, audited approval (RFC 0051 §A)', () =
   });
 
   it('the override path emits an audited approval.overridden with a reason', async () => {
-    if (!(await authorizationSupported())) return; // capability-gated
+    if (!(await authorizationSupported())) return softSkip('inapplicable', 'capability-gated');
     const res = await driver.post('/v1/host/sample/governance/approval-gate', {
       scenario: 'override',
       principal: 'conformance-owner-principal',
       reason: 'conformance emergency publish',
     });
-    if (res.status === 404) return; // seam unwired — soft-skip
+    if (res.status === 404) return softSkip('blocked', 'seam unwired — soft-skip');
     const body = res.json as { event?: { type?: string; payload?: { reason?: string } } } | undefined;
     expect(
       body?.event?.type,

package/src/scenarios/artifact-type-store-without-render.test.ts

@@ -24,6 +24,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { behaviorGate, behaviorGatePresent } from '../lib/behavior-gate.js';
 
@@ -43,7 +44,7 @@ describe('artifact-type-store-without-render: store-only hosts must not fail the
     // Only meaningful for a host that stores but does NOT render.
     // NOT a behaviorGate: this is a SHAPE precondition, not advertise-and-skip. A host that
     // renders is not failing to implement anything — this scenario simply does not apply to it.
-    if (cap?.['store'] !== true || cap?.['render'] !== false) return; // scenario inapplicable
+    if (cap?.['store'] !== true || cap?.['render'] !== false) return softSkip('inapplicable', 'host does not advertise artifactTypes { store: true, render: false } — the store-without-render shape is not this host\'s');
 
     const { artifactTypeId, manifest, schema } = sampleArtifactTypePack();
     if (!behaviorGate(PROFILE, (await installArtifactTypePack(manifest, { [artifactTypeId]: schema })) !== null)) return;

package/src/scenarios/auth-scim-profile.test.ts

@@ -16,6 +16,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,7 +40,7 @@ async function readProfiles(): Promise<string[] | null> {
 describe('auth-scim-profile: advertisement shape (RFC 0050)', () => {
   it('claims openwop-auth-scim as a well-formed profile id when advertised', async () => {
     const profiles = await readProfiles();
-    if (profiles === null || !profiles.includes(SCIM_PROFILE)) return; // profile not claimed
+    if (profiles === null || !profiles.includes(SCIM_PROFILE)) return softSkip('inapplicable', 'profile not claimed');
     expect(
       profiles.includes(SCIM_PROFILE),
       driver.describe('RFC 0050 §B', 'openwop-auth-scim MUST appear verbatim in capabilities.auth.profiles when claimed'),
@@ -52,12 +53,12 @@ describe('auth-scim-profile: provisioning roundtrip (RFC 0050 §B — opt-in)',
 
   it('provisions a SCIM user → principal (SCIM endpoint required)', async () => {
     const profiles = await readProfiles();
-    if (profiles === null || !profiles.includes(SCIM_PROFILE)) return; // capability-gated
-    if (scimUrl === undefined || scimUrl.length === 0) return; // opt-in: SCIM endpoint not provided
+    if (profiles === null || !profiles.includes(SCIM_PROFILE)) return softSkip('inapplicable', 'capability-gated');
+    if (scimUrl === undefined || scimUrl.length === 0) return softSkip('inapplicable', 'opt-in: SCIM endpoint not provided');
     // A SCIM POST /Users against the operator-supplied endpoint MUST upsert a
     // principal the host can subsequently resolve.
     const res = await driver.post('/v1/host/sample/auth/scim/provision', { scimUrl, op: 'create-user' });
-    if (res.status === 404) return; // seam unwired
+    if (res.status === 404) return softSkip('blocked', 'seam unwired');
     expect(
       res.status,
       driver.describe('RFC 0050 §B', 'a SCIM user provisioning MUST succeed (2xx) and upsert an RFC 0048 principal'),

package/src/scenarios/authorization-fail-closed.test.ts

@@ -23,6 +23,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';
 
@@ -46,7 +47,7 @@ async function readAuthorization(): Promise<DiscoveryAuthorization | null> {
 describe('authorization-fail-closed: advertisement shape (RFC 0049 §C)', () => {
   it('failClosed is exactly true when authorization is supported', async () => {
     const authz = await readAuthorization();
-    if (!authz?.supported || authz.failClosed === undefined) return;
+    if (!authz?.supported || authz.failClosed === undefined) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!authz?.supported || authz.failClosed === undefined` returned early');
     expect(
       authz.failClosed,
       driver.describe('RFC 0049 §C', 'capabilities.authorization.failClosed MUST be `true`'),
@@ -57,7 +58,7 @@ describe('authorization-fail-closed: advertisement shape (RFC 0049 §C)', () =>
 describe('authorization-fail-closed: absent/unseeded role MUST deny (RFC 0049 §C)', () => {
   it('a decision for an unseeded-role principal resolves allowed=false', async () => {
     const authz = await readAuthorization();
-    if (!authz?.supported) return; // capability-gated
+    if (!authz?.supported) return softSkip('inapplicable', 'capability-gated');
 
     // Seam contract: request an authorization decision for a principal whose
     // role is absent/unseeded. The host MUST fail closed.
@@ -67,7 +68,7 @@ describe('authorization-fail-closed: absent/unseeded role MUST deny (RFC 0049 §
       resource: 'run-conformance-probe',
     });
     // 404 from a host that hasn't wired the seam is a soft-skip.
-    if (res.status === 404) return;
+    if (res.status === 404) return softSkip('blocked', 'precondition not met — `res.status === 404` returned early (seam, prior step, or fixture unavailable)');
 
     const decision = res.json as { allowed?: boolean } | undefined;
     expect(

package/src/scenarios/certification-bundle-non-vacuous.test.ts

@@ -0,0 +1,249 @@
+/**
+ * RFC 0148 §A/§C — `certification-bundle-non-vacuous`: a bundle with any
+ * unwitnessed required assertion is rejected (RFC 0147 program scenario;
+ * RFC 0148 "missing witness and blocked floor reject").
+ *
+ * This is the CONSUMER half of what `--certify` enforces on emit (S6). A
+ * bundle is a claim; a consumer re-derives it from the rows (RFC 0089 §B) and
+ * the rows must be witnesses, not lists. `verifyBundleV2` is that
+ * re-derivation, and these are its vectors — the shapes RFC 0148 names as
+ * fixtures: valid-v2, early-return, missing-floor, duplicate-requirement,
+ * tampered-witness — built inline against the LIVE `openwop-core-standard`
+ * floor so a floor edit re-runs them against the real requirement ids.
+ *
+ * Two verdicts are kept apart on purpose:
+ *   - `evidenceValid: false` — the document is not acceptable evidence
+ *     (unwitnessed / vacuous / duplicate / tampered / canary);
+ *   - `certified: false` with valid evidence — an honest `blocked` or
+ *     `executed-fail` on a required row. That is the host's state, not the
+ *     bundle's defect, and RFC 0148 §A says so.
+ *
+ * Server-free, always-on; MUST NOT capability-skip (RFC 0148 §Conformance).
+ */
+
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import Ajv2020 from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+import { SCHEMAS_DIR } from '../lib/paths.js';
+import { PROFILE_FLOOR_SCENARIOS } from '../lib/profiles.js';
+import { requirementIdForScenario, requirementIdForPrefix } from '../lib/requirement-registry.js';
+import {
+  verifyBundleV2,
+  type BundleV2Like,
+  type BundleV2Requirement,
+} from '../lib/certification-bundle-verify.js';
+import { UNCLASSIFIED_RETURN_DETAIL } from '../lib/soft-skip.js';
+
+export const HOST_CALLBACK_NOT_REQUIRED = 'server-free: verifies bundle documents built in-process; no host is contacted';
+
+const HEX = 'a'.repeat(64);
+const PROFILE = 'openwop-core-standard';
+
+/** A discovery document from which `openwop-core-standard` derives (§B predicate). */
+const CORE_STANDARD_DISCOVERY = {
+  protocolVersion: '1.0',
+  supportedEnvelopes: ['clarification.request'],
+  supportedTransports: ['rest'],
+  schemaVersions: { workflow: '1.0' },
+  limits: { clarificationRounds: 3, schemaRounds: 3, envelopesPerTurn: 8 },
+};
+
+function floor(): { files: string[]; prefixes: string[] } {
+  const f = PROFILE_FLOOR_SCENARIOS[PROFILE];
+  if (f === undefined) throw new Error(`${PROFILE} has no floor — this scenario is bound to the live floor`);
+  return { files: [...f.required], prefixes: [...(f.requiredAnyPrefix ?? [])] };
+}
+
+function witnessedRows(): BundleV2Requirement[] {
+  const { files, prefixes } = floor();
+  const rows: BundleV2Requirement[] = files.map((f) => ({
+    requirementId: requirementIdForScenario(f),
+    scenarioId: f,
+    disposition: 'executed-pass',
+    assertionCount: 7,
+  }));
+  for (const p of prefixes) {
+    // one matching scenario row + the emitter's summary row
+    rows.push({ requirementId: `openwop.scenario.${p}alpha`, scenarioId: `${p}alpha.test.ts`, disposition: 'executed-pass', assertionCount: 3 });
+    rows.push({ requirementId: requirementIdForPrefix(p), scenarioId: `${p}*`, disposition: 'executed-pass', assertionCount: 3 });
+  }
+  return rows;
+}
+
+function totalsFor(rows: readonly BundleV2Requirement[]): BundleV2Like['results']['totals'] {
+  const c = (d: string): number => rows.filter((r) => r.disposition === d).length;
+  return { executedPass: c('executed-pass'), executedFail: c('executed-fail'), skipped: c('skipped'), inapplicable: c('inapplicable'), blocked: c('blocked') };
+}
+
+function bundle(rows: readonly BundleV2Requirement[], overrides: Partial<BundleV2Like> = {}): BundleV2Like & Record<string, unknown> {
+  return {
+    bundleVersion: '2',
+    generatedAt: '2026-08-16T00:00:00.000Z',
+    generator: { name: 'test', version: '0.0.0' },
+    suite: { package: '@openwop/openwop-conformance', version: '1.114.0' },
+    host: { name: 'vector-host', version: '0.0.0' },
+    discovery: { url: 'https://example.invalid/.well-known/openwop', sha256: HEX, document: CORE_STANDARD_DISCOVERY },
+    claimedProfiles: [PROFILE],
+    results: { totals: totalsFor(rows), requirements: [...rows] },
+    scenarioManifestSha256: HEX,
+    targetConfigurationSha256: HEX,
+    ...overrides,
+  };
+}
+
+const ajv = new Ajv2020({ allErrors: true, strict: false });
+addFormats(ajv);
+const schema = JSON.parse(readFileSync(join(SCHEMAS_DIR, 'certification-bundle-v2.schema.json'), 'utf8')) as Record<string, unknown>;
+const schemaValid = ajv.compile(schema);
+
+describe('RFC 0148 §A/§C — certification-bundle-non-vacuous (consumer re-derivation)', () => {
+  it('valid-v2: every required row witnessed → evidence valid AND certified (and the vector is schema-valid)', () => {
+    const b = bundle(witnessedRows());
+    expect(schemaValid(b), JSON.stringify(schemaValid.errors)).toBe(true);
+    const v = verifyBundleV2(b);
+    expect(v.rejections).toEqual([]);
+    expect(v.evidenceValid).toBe(true);
+    expect(v.certified).toBe(true);
+    const p = v.profiles.find((x) => x.profile === PROFILE);
+    expect(p?.derivable).toBe(true);
+    expect(p?.required.length).toBeGreaterThan(5);
+  });
+
+  it('early-return: a required row that is executed-pass with assertionCount 0 REJECTS the evidence', () => {
+    const rows = witnessedRows();
+    rows[0] = { ...(rows[0] as BundleV2Requirement), assertionCount: 0 };
+    const v = verifyBundleV2(bundle(rows));
+    expect(v.evidenceValid).toBe(false);
+    expect(v.certified).toBe(false);
+    const p = v.profiles[0];
+    expect(p?.rejections.map((r) => r.kind)).toEqual(['vacuous-pass']);
+    expect(p?.rejections[0]?.requirementId).toBe(rows[0]?.requirementId);
+  });
+
+  it('early-return (no count at all): an executed-pass with NO assertionCount is unwitnessed and REJECTS', () => {
+    const rows = witnessedRows();
+    const { assertionCount: _drop, ...noCount } = rows[1] as BundleV2Requirement & { assertionCount: number };
+    rows[1] = noCount;
+    const v = verifyBundleV2(bundle(rows));
+    expect(v.evidenceValid).toBe(false);
+    expect(v.profiles[0]?.rejections[0]?.kind).toBe('vacuous-pass');
+  });
+
+  it("the emitter's §A resolution of a silent zero-assertion file (blocked + marker detail) on a required row REJECTS as unwitnessed", () => {
+    const rows = witnessedRows();
+    rows[0] = { requirementId: (rows[0] as BundleV2Requirement).requirementId, scenarioId: (rows[0] as BundleV2Requirement).scenarioId, disposition: 'blocked', detail: UNCLASSIFIED_RETURN_DETAIL, assertionCount: 0 };
+    const v = verifyBundleV2(bundle(rows));
+    expect(v.evidenceValid).toBe(false);
+    expect(v.profiles[0]?.rejections.map((r) => r.kind)).toEqual(['unwitnessed-requirement']);
+  });
+
+  it('missing-floor: a required requirement with no row at all REJECTS (unwitnessed), never "not certified"', () => {
+    const rows = witnessedRows().slice(1); // drop the first floor row
+    const dropped = requirementIdForScenario(floor().files[0] as string);
+    const v = verifyBundleV2(bundle(rows));
+    expect(v.evidenceValid).toBe(false);
+    const rej = v.profiles[0]?.rejections ?? [];
+    expect(rej.map((r) => r.kind)).toEqual(['unwitnessed-requirement']);
+    expect(rej[0]?.requirementId).toBe(dropped);
+    // and the row is NOT reported as merely not-certifiable
+    expect(v.profiles[0]?.notCertifiable).not.toContain(dropped);
+  });
+
+  it('missing prefix witness: no `interrupt-*` scenario row and no summary row REJECTS the prefix requirement', () => {
+    const { prefixes } = floor();
+    if (prefixes.length === 0) return; // floor without a prefix requirement — nothing to assert here
+    const rows = witnessedRows().filter((r) => !prefixes.some((p) => r.scenarioId.startsWith(p)));
+    const v = verifyBundleV2(bundle(rows));
+    expect(v.evidenceValid).toBe(false);
+    expect(v.profiles[0]?.rejections.some((r) => r.kind === 'unwitnessed-requirement' && r.requirementId === requirementIdForPrefix(prefixes[0] as string))).toBe(true);
+  });
+
+  it('duplicate-requirement: two rows for one requirement REJECTS (exactly one disposition per requirement)', () => {
+    const rows = witnessedRows();
+    rows.push({ ...(rows[0] as BundleV2Requirement) });
+    const v = verifyBundleV2(bundle(rows));
+    expect(v.evidenceValid).toBe(false);
+    expect(v.rejections.map((r) => r.kind)).toContain('duplicate-requirement');
+  });
+
+  it('tampered-witness: totals that disagree with the rows REJECT — a hand-edited count is not a witness', () => {
+    const rows = witnessedRows();
+    const b = bundle(rows);
+    const tampered = { ...b, results: { ...b.results, totals: { ...b.results.totals, blocked: 0, executedPass: b.results.totals.executedPass + 1 } } };
+    const v = verifyBundleV2(tampered);
+    expect(v.evidenceValid).toBe(false);
+    expect(v.rejections.map((r) => r.kind)).toEqual(['totals-mismatch']);
+  });
+
+  it('tampered-witness: an invented disposition name REJECTS', () => {
+    const rows = witnessedRows();
+    rows[0] = { ...(rows[0] as BundleV2Requirement), disposition: 'passed' };
+    const v = verifyBundleV2(bundle(rows));
+    expect(v.rejections.some((r) => r.kind === 'unknown-disposition')).toBe(true);
+    expect(v.evidenceValid).toBe(false);
+  });
+
+  it('a non-pass without a reason REJECTS (RFC 0148 §A: anything other than executed-pass says why)', () => {
+    const rows = witnessedRows();
+    rows[0] = { requirementId: (rows[0] as BundleV2Requirement).requirementId, scenarioId: (rows[0] as BundleV2Requirement).scenarioId, disposition: 'blocked' };
+    const v = verifyBundleV2(bundle(rows));
+    expect(v.rejections.map((r) => r.kind)).toContain('reason-missing');
+  });
+
+  it('blocked-floor: an HONEST blocked row on a required requirement is VALID evidence that does NOT certify', () => {
+    const rows = witnessedRows();
+    rows[0] = { ...(rows[0] as BundleV2Requirement), disposition: 'blocked', detail: 'seam unreachable from this runner (host-callback)' };
+    delete (rows[0] as { assertionCount?: number }).assertionCount;
+    const v = verifyBundleV2(bundle(rows));
+    expect(v.rejections).toEqual([]);
+    expect(v.evidenceValid).toBe(true);
+    expect(v.certified).toBe(false);
+    expect(v.profiles[0]?.notCertifiable).toEqual([(rows[0] as BundleV2Requirement).requirementId]);
+  });
+
+  it('executed-fail on a required row: valid evidence, not certified', () => {
+    const rows = witnessedRows();
+    rows[2] = { ...(rows[2] as BundleV2Requirement), disposition: 'executed-fail', detail: 'assertion failed against target', assertionCount: 4 };
+    const v = verifyBundleV2(bundle(rows));
+    expect(v.evidenceValid).toBe(true);
+    expect(v.certified).toBe(false);
+  });
+
+  it('inapplicable / skipped with a reason on a required row certifies (RFC 0148 §A CERTIFIABLE set)', () => {
+    const rows = witnessedRows();
+    rows[0] = { requirementId: (rows[0] as BundleV2Requirement).requirementId, scenarioId: (rows[0] as BundleV2Requirement).scenarioId, disposition: 'inapplicable', detail: 'profile not advertised in the captured discovery set', assertionCount: 0 };
+    rows[1] = { requirementId: (rows[1] as BundleV2Requirement).requirementId, scenarioId: (rows[1] as BundleV2Requirement).scenarioId, disposition: 'skipped', detail: 'operator opted the profile out (OPENWOP_OPTED_OUT_PROFILES)' };
+    const v = verifyBundleV2(bundle(rows));
+    expect(v.evidenceValid).toBe(true);
+    expect(v.certified).toBe(true);
+  });
+
+  it('a claim the discovery document does not derive is not certified even with perfect rows (RFC 0089 §B(1))', () => {
+    const b = bundle(witnessedRows(), { discovery: { document: { protocolVersion: '1.0' } } });
+    const v = verifyBundleV2(b);
+    expect(v.evidenceValid).toBe(true);
+    expect(v.profiles[0]?.derivable).toBe(false);
+    expect(v.certified).toBe(false);
+  });
+
+  it('a claimed profile with NO defined floor is unprovable — floorUnspecified, never certified (G6)', () => {
+    const b = bundle(witnessedRows(), { claimedProfiles: ['openwop-not-a-profile'] });
+    const v = verifyBundleV2(b);
+    expect(v.profiles[0]?.floorUnspecified).toBe(true);
+    expect(v.certified).toBe(false);
+  });
+
+  it('a discovery-only profile certifies on derivation alone (RFC 0155 §A: openwop-discovery-core)', () => {
+    const b = bundle(witnessedRows(), { claimedProfiles: ['openwop-discovery-core'] });
+    const v = verifyBundleV2(b);
+    expect(v.certified).toBe(true);
+  });
+
+  it('a v1 document handed to the v2 verifier is rejected as not-v2 rather than silently read', () => {
+    const b = bundle(witnessedRows(), { bundleVersion: '1' });
+    const v = verifyBundleV2(b);
+    expect(v.rejections.map((r) => r.kind)).toContain('not-v2');
+  });
+});