@openwop/openwop-conformance 2.0.0-rc.8 → 2.0.0

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # `@openwop/openwop-conformance` Changelog
 
+## [2.0.0] — 2026-09-05 — openwop v2
+
+The v2 major. `@openwop/openwop-conformance@2.0.0` and `@openwop/spec-artifacts@2.0.0` are one release under two names — conformance pins the contract package to an exact version, so install both.
+
+**What changed from 1.x, for someone upgrading.** The suite gained `--target-major`; `req('openwop.<id>', …)` is the only assertion form and every `it` records a ledger row; `--certify` emits a signed bundle v3 whose verdict is the certification. Dispositions are the RFC 0148 §A vocabulary — `executed-pass`, `executed-fail`, `skipped`, `inapplicable`, `blocked` — and **a bundle carrying any `blocked` row does not certify**, because `blocked` means the suite could not measure an obligation the host took on. Three profiles ship with machine-checked floors: `openwop-discovery-core`, `openwop-core-standard`, `openwop-conformance-seams-v2`.
+
+**The distinction to internalise before reading a bundle:** `inapplicable` is an obligation the host never took on, `blocked` is one it took on and the suite could not measure, and only the second denies certification. Most of the rc series was spent getting individual scenarios to tell those two apart honestly.
+
+**Cut against the RFC 0167 §F predicates**, all ten machine-true on a live host at the release candidate: Identity, Registers, Closure, Deprecation, Paths, Codemods, Waiver, Witness, Coexistence, Front door. The reference host `openwop-host-v2-reference` certifies all three profiles at 181 / 0 / 0 / 42 / 0.
+
+**Honest limits at the cut.** The only host certified on all three profiles is the steward's own reference example; both production hosts are mid-migration and their remaining distance is capability adverts rather than implementation. No independent-tier host is anchored, so leg (b) of the v1 end-of-support clock does not apply — leg (a) governs, and v1 support runs to at least **2026-12-04**. RFC 0167 §157 recorded in advance that a third-party host is not required at the cut under sole-steward operation.
+
+Full per-release history for `2.0.0-rc.1` … `2.0.0-rc.67`: <https://github.com/openwop/openwop/blob/main/CHANGELOG.md>.
+
+
+## [2.0.0-rc.67] — 2026-09-05 — a core-standard floor file was flaky, and the flake blamed the host
+
+`v2-poll-cursor-v2` compared **two reads of the same event log** — a full read, then a cursor read — and asserted they agree. But `terminalRun()` waits for the run's *status* to be terminal, and a terminal status does not mean the log has stopped **appending**. A host emitting trailing or vendor rows can add an event between the two reads, and the leg then reports an array mismatch and blames the host for a cursor defect it does not have.
+
+Measured by a peer host: this leg failed **twice under a full-suite run** and passed **6/6 in isolation** on the same revision — the signature of a window widening under load, not of a wrong cursor.
+
+It now re-reads the whole log after the cursor read. If the log is unchanged the two reads straddled a quiet window and the comparison is decidable; if it grew, the suite records `blocked` naming the growth instead of failing, because it could not measure the rule. This matters more than a normal flake: the file is on the `openwop-core-standard` floor, so its flakiness made **certification non-deterministic**.
+
+
+## [2.0.0-rc.66] — 2026-09-05 — the changelog you are reading had not mentioned this major
+
+**This file went un-updated from `1.156.0` (2026-09-02) through `2.0.0-rc.65`** — twenty-one published releases, and zero mentions of any `2.0.0-rc` in the changelog that ships inside the tarball. If you installed `2.0.0-rc.65` and read its CHANGELOG, you read a document that ended three days before the v2 release series began.
+
+**Why it rotted, and why nobody noticed.** `conformance/package.json` `files` lists `CHANGELOG.md`, which resolves *inside the package* — so the shipped file is `conformance/CHANGELOG.md`. The corpus changelog at the repo root is a **different file with the same name**, it was current the whole time, and every release wrote to it. The file being edited and the file being shipped were not the same file, and nothing compared either to the version being published. `scripts/check-shipped-changelog.mjs` now fails the corpus gate whenever a packed CHANGELOG's newest heading does not equal its own package's `version`, so this cannot recur.
+
+**Where the 2.0.0 release notes actually are.** The full per-release record for `2.0.0-rc.1` … `2.0.0-rc.65` is the corpus changelog: <https://github.com/openwop/openwop/blob/main/CHANGELOG.md>. It is not reproduced here — it is ~180 KB and would be most of the tarball. What the v2 series changed, in one paragraph: the suite gained `--target-major`, a per-`it` requirement ledger with `req()` as the only assertion form, bundle v3 with signing and verification, the three v2 profiles and their floors, and the RFC 0148 §A disposition vocabulary (`executed-pass` / `executed-fail` / `skipped` / `inapplicable` / `blocked`) under which a bundle carrying any `blocked` row does not certify. `@openwop/spec-artifacts` became a required exact-pinned peer.
+
+**This entry exists because a release should say what it shipped.** The gate requires one on every future version, including versions that change nothing worth recording — which then record exactly that.
+
+
+## [2.0.0-rc.66] — 2026-09-05 — the changelog you are reading had not mentioned this major
+
+**This file went un-updated from `1.156.0` (2026-09-02) through `2.0.0-rc.65`** — twenty-one published releases, and zero mentions of any `2.0.0-rc` in the changelog that ships inside the tarball. If you installed `2.0.0-rc.65` and read its CHANGELOG, you read a document that ended three days before the v2 release series began.
+
+**Why it rotted, and why nobody noticed.** `conformance/package.json` `files` lists `CHANGELOG.md`, which resolves *inside the package* — so the shipped file is `conformance/CHANGELOG.md`. The corpus changelog at the repo root is a **different file with the same name**, it was current the whole time, and every release wrote to it. The file being edited and the file being shipped were not the same file, and nothing compared either to the version being published. `scripts/check-shipped-changelog.mjs` now fails the corpus gate whenever a packed CHANGELOG's newest heading does not equal its own package's `version`, so this cannot recur.
+
+**Where the 2.0.0 release notes actually are.** The full per-release record for `2.0.0-rc.1` … `2.0.0-rc.65` is the corpus changelog: <https://github.com/openwop/openwop/blob/main/CHANGELOG.md>. It is not reproduced here — it is ~180 KB and would be most of the tarball. What the v2 series changed, in one paragraph: the suite gained `--target-major`, a per-`it` requirement ledger with `req()` as the only assertion form, bundle v3 with signing and verification, the three v2 profiles and their floors, and the RFC 0148 §A disposition vocabulary (`executed-pass` / `executed-fail` / `skipped` / `inapplicable` / `blocked`) under which a bundle carrying any `blocked` row does not certify. `@openwop/spec-artifacts` became a required exact-pinned peer.
+
+**This entry exists because a release should say what it shipped.** The gate will require one on every future version, including versions that change nothing worth recording — which then record exactly that.
+
+
 ## [1.156.0] — 2026-09-02 — the event codemap as data (v2 charter Phase 1, tranche 5)
 
 One new corpus-coherence scenario file (471 → 472), not packed:

package/README.md

@@ -3,7 +3,12 @@
 **openwop is an open, wire-level protocol for multi-agent workflow orchestration** — a single contract for runs in which LLM agents, deterministic tools, sub-workflows, and human reviewers collaborate, with durable suspend / resume, replay, version negotiation, and observability owned by the protocol itself. This package is the black-box conformance suite: point it at any OpenWOP-compliant server (your own or a third party's) and it issues real HTTP requests against the spec'd endpoints and asserts that responses match.
 
 ```bash
-npm install @openwop/openwop-conformance
+# Install BOTH packages at the SAME explicit version — the suite declares
+# @openwop/spec-artifacts as an exact-pinned peer, and `npm i --legacy-peer-deps`
+# on the suite alone does not pull it (a host measured "corpus stamp MISMATCH —
+# missing @openwop/spec-artifacts" on 2026-09-05). Pre-release 2.x is on the
+# `next` dist-tag; pin the version, never the tag (runbook §0.2b).
+npm install @openwop/openwop-conformance@2.0.0-rc.57 @openwop/spec-artifacts@2.0.0-rc.57
 # or run without install:
 npx @openwop/openwop-conformance --base-url https://api.example.com --api-key hk_test_...
 ```
@@ -112,7 +117,7 @@ Exit code is non-zero on any failed assertion. `--certify` distinguishes: `0`
 
 ## What's Covered
 
-The current suite has 498 scenario files under `src/scenarios/`.
+The current suite has 516 scenario files under `src/scenarios/`.
 - 2026-09-03 (suite `1.157.0 -> 1.158.0`, gap G17): NEW `idempotency-concurrent-claim.test.ts` — drives the new `host-sample-test-seams.md` §25 concurrent duplicate-delivery seam for the RFC 0150 §B / `idempotency.md` §"Concurrent duplicates (Layer 2)" atomic-claim MUST, which is unconditional and had no witness of any kind. Asserts every executor mints the SAME `logicalInvocationId` **before** asserting `delivered === 1` — without the identity check a host passes by minting different ids and never colliding, one effect because nothing raced. Not profile-gated and so not opt-out-able (the obligation is unconditional); an unmounted seam records `blocked`, which is not certifiable. Graduates `layer2-invocation-claim-atomic` reference-impl -> protocol.
 - 2026-08-19 (suite `1.137.0 → 1.138.0`): NEW `durability-poison-exhaustion.test.ts` — RFC 0158 §C.8, the FIRST row of that RFC's conformance table to land. Asserts what `failure-path.test.ts` cannot: not just that deterministically failing work reaches terminal, but that attempts STOP — counted on the log, re-counted after a scaled quiet window, asserted unchanged. A host still redelivering records more. Seam-gated on the existing event-log seam (`blocked` = unobservable, not unmet) and outside every profile floor.
 - 2026-08-19 (suite `1.136.15 → 1.137.0`): NEW `replay-fanout-suppression.test.ts` — capability-gated on `webhooks.supported`, **outside every profile floor**; witnesses `replay.md` §"Host-initiated fan-out is an external effect", which was the largest normative MUST NOT on the replay surface with no scenario and no SECURITY invariant. Three legs in ONE `it` against ONE receiver and ONE subscription — a positive control, the MUST NOT, and a `branch` boundary leg — because "no delivery arrived" passes identically when delivery never worked, so absence is asserted only after presence is proven on that exact wiring. A host with an SSRF guard correctly refuses the loopback receiver and records `blocked`: **unobservable, not unmet.**
@@ -457,7 +462,7 @@ Server-required (added in 1.7.0):
 | ------------- | ----------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | **Redaction** | [`capabilities.md`](../spec/v1/capabilities.md) §"Secrets" + NFR-7 + §"aiProviders" | Vendor-neutral assertions that the server doesn't leak secret material. Three scenario groups: (a) discovery shape contract — `secrets` + `aiProviders` advertisements are well-formed regardless of `secrets.supported`; when `supported === true`, scopes MUST be non-empty + `resolution === 'host-managed'`; `byok ⊆ supported`. (b) bearer-token redaction — invalid Bearer canary in `Authorization` header is not echoed in the 401 response body. (c) credentialRef echo control — gated on `secrets.supported === true`; canary planted in `configurable.ai.credentialRef` MUST NOT appear in any RunEvent payload (poll-based capture; transport-agnostic). Uses runtime-built canary fixtures (`lib/canaries.ts`) that defeat static secret scanners. 6 scenarios. |
 
-Current source tree: 498 scenario files. Use [`coverage.md`](./coverage.md) for current grade/gap tracking.
+Current source tree: 516 scenario files. Use [`coverage.md`](./coverage.md) for current grade/gap tracking.
 
 ## Remaining Gaps
 

package/dist/cli.js

@@ -46,7 +46,7 @@ import { deriveRequirementDispositions } from './lib/scenario-disposition.js';
 import { scrubEvidence, evidenceSecretsFromEnv, verifyBundleV2 } from './lib/certification-bundle-verify.js';
 import { publicKeyFromPrivate, signBundleV3, verifierSign, verifyBundleV3, witnessDigest } from './lib/certification-bundle-v3.js';
 import { deriveProfiles, isCoreStandard, agentPlatformStatus, DEPRECATED_PROFILE_ALIASES, PROFILE_FLOOR_SCENARIOS, } from './lib/profiles.js';
-import { setV2ProfileFloors } from './lib/requirement-registry.js';
+import { setV2ProfileFloors, v2ProfileFloorFiles } from './lib/requirement-registry.js';
 function parseArgs(argv) {
     let baseUrl;
     let apiKey;
@@ -354,37 +354,8 @@ function claimedProfilesForV2(doc, conformanceRoot) {
  * fail a host for the corpus's own backlog.
  */
 function v2ProfileFloors(conformanceRoot) {
-    const registryPath = v2RegistryPath(conformanceRoot);
-    if (registryPath === null)
-        return {};
-    let known;
-    try {
-        known = new Set(Object.keys(JSON.parse(readFileSync(resolvePath(conformanceRoot, 'scenario-majors.json'), 'utf8')).majors));
-    }
-    catch {
-        known = new Set();
-    }
-    let registry;
-    try {
-        registry = JSON.parse(readFileSync(registryPath, 'utf8'));
-    }
-    catch {
-        return {};
-    }
-    const out = {};
-    for (const p of registry.profiles ?? []) {
-        if (typeof p.id !== 'string')
-            continue;
-        const raw = Array.isArray(p.floorScenarios) ? p.floorScenarios.map(String) : [];
-        const files = [];
-        for (const entry of raw) {
-            const name = entry.startsWith('planned:') ? `v2-${entry.slice('planned:'.length)}.test.ts` : entry.endsWith('.test.ts') ? entry : `${entry}.test.ts`;
-            if (known.size === 0 || known.has(name))
-                files.push(name);
-        }
-        out[p.id] = files;
-    }
-    return out;
+    // One derivation, shared with the ledger's floor-file set (requirement-registry.ts).
+    return v2ProfileFloorFiles(conformanceRoot);
 }
 /**
  * Reduce a vitest JSON report into a per-scenario-file terminal state, keyed by
@@ -459,6 +430,16 @@ async function resolveTargetMajor(args, baseUrl, apiKey, conformanceRoot) {
     // Say so, or an operator reads a v1 run as the host's only option.
     if (major === 1 && dualStack)
         source += ' (the host also serves 2.x — pass --target-major 2 to measure it)';
+    // The RUNNER's own process must see the target major, not only the vitest
+    // child (rc.55). `requirementIdForFile()` decides "is this file a floor?"
+    // through `targetMajor()` = process.env; until rc.55 `--target-major 2` set
+    // the env on the child alone, so the worker recorded every v2 floor file
+    // under `openwop.floor.<stem>` while the runner looked it up as
+    // `openwop.scenario.<stem>`, found nothing, emitted a report-derived pass
+    // with no assertion count, and its own verifier rejected the bundle as a
+    // `vacuous-pass` emitter defect (exit 2, nothing written). The child env is
+    // spread from process.env after this, so one assignment covers both.
+    process.env['OPENWOP_TARGET_MAJOR'] = String(major);
     const manifest = JSON.parse(readFileSync(resolvePath(conformanceRoot, 'scenario-majors.json'), 'utf8'));
     const files = Object.entries(manifest.majors).filter(([, m]) => m.includes(major)).map(([f]) => `src/scenarios/${f}`);
     return { major, files, source };
@@ -636,15 +617,24 @@ async function runCertify(args, baseUrl, apiKey) {
         const doc3 = document;
         const protocolVersions = Array.isArray(doc3['protocolVersions']) ? doc3['protocolVersions'] : [String(doc3['protocolVersion'] ?? '')];
         const preferredVersion = typeof doc3['preferredVersion'] === 'string' ? doc3['preferredVersion'] : (protocolVersions[0] ?? '');
-        // witnessCount: executed-pass rows on the profile's floor (PROFILE_FLOOR_SCENARIOS required + requiredAnyPrefix).
+        // witnessCount: witnessed executed-pass rows on the profile's floor. At major
+        // 2 the verdict already counted them against the declaration's floor
+        // (`witnessedPasses`); the v1 hand table below knows no v2 file and printed
+        // 0 for every v2 profile until rc.45 — the third unjoined floor site.
+        const verdictFor = (profile) => derived.verdicts.find((v) => v.profile === profile);
         const witnessCountFor = (profile) => {
+            if (target.major === 2)
+                return verdictFor(profile)?.witnessedPasses ?? 0;
             const floor = PROFILE_FLOOR_SCENARIOS[profile];
             if (!floor)
                 return 0;
             const onFloor = (scenario) => floor.required.includes(scenario) || (floor.requiredAnyPrefix ?? []).some((pre) => scenario.startsWith(pre));
             return derived.requirements.filter((r) => r.disposition === 'executed-pass' && onFloor(r.scenarioId)).length;
         };
-        const claimed3 = claimedProfiles.filter((p) => !(p in DEPRECATED_PROFILE_ALIASES)).map((p) => ({ id: p, evidenceTier: args.evidenceTier, witnessCount: witnessCountFor(p), certified: !notHeld.has(p) && !rejectedProfiles.some((v) => v.profile === p) && totals3.blocked === 0 }));
+        // `certified` IS the verdict (RFC 0148 §A; RFC 0168 §E.1 adds the bundle-wide
+        // blocked rule). Until rc.45 it was `!notHeld && !rejected && blocked === 0`
+        // and never read `certifiable` — an empty v2 floor certified on no evidence.
+        const claimed3 = claimedProfiles.filter((p) => !(p in DEPRECATED_PROFILE_ALIASES)).map((p) => ({ id: p, evidenceTier: args.evidenceTier, witnessCount: witnessCountFor(p), certified: (verdictFor(p)?.certifiable ?? false) && !notHeld.has(p) && !rejectedProfiles.some((v) => v.profile === p) && totals3.blocked === 0 }));
         let relaxations;
         if (process.env['OPENWOP_HOST_RELAXATIONS']) {
             try {

package/dist/lib/requirement-registry.js

@@ -21,6 +21,9 @@
  * resolves an unrecorded requirement to `blocked`.
  */
 import { PROFILE_FLOOR_SCENARIOS } from './profiles.js';
+import { createRequire } from 'node:module';
+import { dirname, resolve as resolvePath } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
 /** `runs-lifecycle.test.ts` → `openwop.floor.runs-lifecycle`. */
 export function requirementIdForScenario(scenarioFile) {
     return `openwop.floor.${scenarioFile.replace(/\.test\.ts$/, '')}`;
@@ -90,6 +93,16 @@ let v2Floors = null;
 export function setV2ProfileFloors(floors) {
     v2Floors = floors;
 }
+/**
+ * True while a major-2 floor map is installed. The v1 hand table
+ * (`PROFILE_FLOOR_SCENARIOS`) MUST NOT be consulted for any per-profile fact
+ * (`discoveryOnly`, `runtimeDerived`, the floor itself, the witness count) while
+ * this is true — every one of those reads is a floor site, and rc.41 found two
+ * of four unjoined; rc.45 found the other two.
+ */
+export function v2FloorsActive() {
+    return v2Floors !== null;
+}
 export function requirementsFor(profile, document) {
     if (v2Floors !== null) {
         const files = v2Floors[profile];
@@ -128,3 +141,59 @@ export function allRequirements() {
     }
     return [...ids].sort();
 }
+/**
+ * The MAJOR-2 floors, derived from `spec/v2/profiles.json` (itself generated
+ * from `spec/v2/declaration.json`), keyed by profile id and resolved to
+ * scenario file names. A `planned:<stem>` entry names `v2-<stem>.test.ts`; an
+ * entry is kept only if `scenario-majors.json` knows the file.
+ *
+ * This function exists in ONE place on purpose. Until 2026-09-05 the CLI
+ * derived these floors privately for `--certify` while the ledger decided
+ * "is this file a floor?" from PROFILE_FLOOR_SCENARIOS — the v1 hand table,
+ * which knows no v2 file. So a v2 floor file was MINTED as
+ * `openwop.scenario.v2-…` and LOOKED UP at certify time as
+ * `openwop.floor.v2-…`: 101 executed-pass rows, `witnessCount: 0` on both
+ * claimed profiles, and `REJECTING — openwop-discovery-core: unclassified` on
+ * a tier-1 host's first production bundle. Two sources of the same fact, one
+ * of them stale, and the join between them silent.
+ */
+export function v2ProfileFloorFiles(conformanceRoot) {
+    const candidates = [];
+    try {
+        const req = createRequire(resolvePath(conformanceRoot, 'package.json'));
+        candidates.push(resolvePath(dirname(req.resolve('@openwop/spec-artifacts/package.json')), 'spec', 'v2', 'profiles.json'));
+    }
+    catch { /* not installed as a package; the repo-layout candidates below */ }
+    candidates.push(resolvePath(conformanceRoot, 'spec', 'v2', 'profiles.json'), resolvePath(conformanceRoot, '..', 'spec', 'v2', 'profiles.json'));
+    const registryPath = candidates.find((c) => existsSync(c));
+    if (registryPath === undefined)
+        return {};
+    let known;
+    try {
+        known = new Set(Object.keys(JSON.parse(readFileSync(resolvePath(conformanceRoot, 'scenario-majors.json'), 'utf8')).majors));
+    }
+    catch {
+        known = new Set();
+    }
+    let registry;
+    try {
+        registry = JSON.parse(readFileSync(registryPath, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+    const out = {};
+    for (const p of registry.profiles ?? []) {
+        if (typeof p.id !== 'string')
+            continue;
+        const raw = Array.isArray(p.floorScenarios) ? p.floorScenarios.map(String) : [];
+        const files = [];
+        for (const entry of raw) {
+            const name = entry.startsWith('planned:') ? `v2-${entry.slice('planned:'.length)}.test.ts` : entry.endsWith('.test.ts') ? entry : `${entry}.test.ts`;
+            if (known.size === 0 || known.has(name))
+                files.push(name);
+        }
+        out[p.id] = files;
+    }
+    return out;
+}

package/dist/lib/scenario-disposition.js

@@ -27,7 +27,10 @@
  */
 import { scenarioFileOfItId } from './requirement-ids.js';
 import { PROFILE_FLOOR_SCENARIOS } from './profiles.js';
-import { requirementIdForScenario, requirementIdForPrefix, requirementsFor } from './requirement-registry.js';
+import { targetMajor } from './seams.js';
+import { PKG_ROOT_PATH } from './paths.js';
+import { v2ProfileFloorFiles } from './requirement-registry.js';
+import { requirementIdForScenario, requirementIdForPrefix, requirementsFor, v2FloorsActive } from './requirement-registry.js';
 import { UNCLASSIFIED_RETURN_DETAIL } from './soft-skip.js';
 import { SPEC_COHERENCE_SCENARIOS, SPEC_COHERENCE_DETAIL } from './spec-coherence.js';
 import { CERTIFIABLE } from './requirement-ledger.js';
@@ -41,6 +44,22 @@ export function floorScenarioFiles() {
             for (const f of c.required)
                 out.add(f);
     }
+    // At target major 2 the floors come from the declaration, not the v1 hand
+    // table. The ledger and --certify MUST agree on this set, or a floor file is
+    // minted `openwop.scenario.*` and looked up as `openwop.floor.*` — which is
+    // exactly what refused a tier-1 host's first production bundle over 101
+    // executed-pass rows (see v2ProfileFloorFiles).
+    //
+    // rc.55: the runner installs the v2 floor map (`setV2ProfileFloors`) but
+    // reads `targetMajor()` from ITS OWN process.env, which `--target-major 2`
+    // never set — so the worker (env set) minted `openwop.floor.v2-…` and the
+    // runner (env unset) looked up `openwop.scenario.v2-…`. Either signal is
+    // the same fact; honour both so the two halves cannot disagree again.
+    if (targetMajor() === 2 || v2FloorsActive()) {
+        for (const files of Object.values(v2ProfileFloorFiles(PKG_ROOT_PATH)))
+            for (const f of files)
+                out.add(f);
+    }
     return out;
 }
 /** The requirement id a scenario FILE records under: the §A floor id when the
@@ -58,6 +77,38 @@ export function requirementIdForFile(basename) {
  * the thing that passed.
  */
 export const PARTIAL_WITNESS_PREFIX = 'partial-witness: ';
+/**
+ * The per-`it` record (RFC 0148 §A at test granularity), as `setup.ts`
+ * computes it in `afterEach`. Pure so a lib test can pin it:
+ *   - fail                         ⇒ executed-fail (detail = the first error message)
+ *   - pass with ≥ 1 assertion      ⇒ executed-pass
+ *   - a behaviorGate entry journaled during the test ⇒ that gate's disposition
+ *   - pass with 0 assertions       ⇒ the softSkip note written DURING THIS TEST
+ *                                    (`inapplicable` / `skipped` / `blocked`, worst-first),
+ *                                    else `blocked` + the unclassified-return marker
+ *   - vitest skip (ctx.skip / it.skip) ⇒ the note written before the skip, else `skipped`
+ *
+ * rc.56: the fourth line is new. Until then a zero-assertion pass consulted the
+ * journal only, so a leg that returned `softSkip('inapplicable', …)` was
+ * recorded `blocked / unclassified return` at `it` granularity while its file
+ * row (which does read the notes — `resolveFileRecord`) was `inapplicable`.
+ * A bundle with any `blocked` row does not certify (RFC 0168 §E.1), so the
+ * dishonest per-`it` rows denied certification to every profile on a host that
+ * simply did not advertise the gated surface.
+ */
+export function resolveItRecord(state, assertionCalls, gate, noted, firstError) {
+    if (state === 'fail')
+        return { disposition: 'executed-fail', detail: `the test executed and failed: ${(firstError ?? 'no message').slice(0, 300)}` };
+    if (state === 'pass' && assertionCalls > 0)
+        return { disposition: 'executed-pass' };
+    if (gate !== undefined)
+        return { disposition: gate.disposition, detail: gate.detail ?? `${gate.disposition} (gate recorded no reason)` };
+    if (noted !== null)
+        return { disposition: noted.kind, detail: noted.reason };
+    if (state === 'pass')
+        return { disposition: 'blocked', detail: 'unclassified return: the test passed with zero assertions and recorded no reason — RFC 0148 §A resolves it to blocked, never to a pass' };
+    return { disposition: 'skipped', detail: 'vitest skipped the test (ctx.skip / it.skip) without a recorded gate reason' };
+}
 /** Worker half: fold a file's per-test states (+ any gate-recorded reason) into
  *  the ONE disposition the file records. */
 export function fileDisposition(states, gateReason, assertionCount) {
@@ -207,11 +258,18 @@ document) {
         rows.push(row);
         perFile.set(file, row);
     }
-    // Prefix requirements: derived from the matching files.
+    // Prefix requirements: derived from the matching files. These are the v1 hand
+    // table's `requiredAnyPrefix` groups (`interrupt-`); at major 2 the floors are
+    // the declaration's and have no prefix groups — and the v1 `interrupt-*` files
+    // never run at major 2, so until rc.45 every major-2 bundle carried one
+    // `openwop.floor.any.interrupt-` row recorded `blocked` ("no interrupt-*
+    // scenario ran"), which by RFC 0168 §E.1 denied certification to every
+    // profile on every major-2 bundle. The fifth unjoined floor site.
     const prefixIds = new Set();
-    for (const floor of Object.values(PROFILE_FLOOR_SCENARIOS))
-        for (const p of floor.requiredAnyPrefix ?? [])
-            prefixIds.add(p);
+    if (!v2FloorsActive())
+        for (const floor of Object.values(PROFILE_FLOOR_SCENARIOS))
+            for (const p of floor.requiredAnyPrefix ?? [])
+                prefixIds.add(p);
     for (const prefix of [...prefixIds].sort()) {
         const matching = [...perFile.entries()].filter(([f]) => f.startsWith(prefix)).map(([, r]) => r);
         const id = requirementIdForPrefix(prefix);
@@ -280,12 +338,18 @@ document) {
         if (ids === null) {
             const floor = PROFILE_FLOOR_SCENARIOS[profile];
             const why = floor === undefined ? `(no floor defined for ${profile})` : `(discovery-conditional floor for ${profile} is unevaluable without the discovery document)`;
-            verdicts.push({ profile, unclassified: [], blocking: [why], certifiable: false, runtimeDerived: false, held: false });
+            verdicts.push({ profile, unclassified: [], blocking: [why], certifiable: false, runtimeDerived: false, held: false, witnessedPasses: 0 });
             continue;
         }
         const unclassified = [];
         const blocking = [];
         let witnessedPasses = 0;
+        // At major 2 the floor is the declaration's (`v2ProfileFloorFiles`), and
+        // the v1 hand table says nothing about these profiles: not their floor, not
+        // `discoveryOnly`, not `runtimeDerived`. Reading it here was the fourth
+        // unjoined floor site — `openwop-discovery-core` is `discoveryOnly` in v1
+        // terms, so at major 2 it certified whatever its v2 floor file said.
+        const atMajor2 = v2FloorsActive();
         for (const id of ids) {
             const r = rowById.get(id);
             const fromLedger = byId.has(id) || (r !== undefined && r.scenarioId.endsWith('*'));
@@ -307,25 +371,34 @@ document) {
             if (r === undefined || silent || vacuous)
                 unclassified.push(id);
             // Unclassified always blocks: a requirement nobody recorded cannot certify.
-            if (r === undefined || silent || vacuous || !CERTIFIABLE.includes(r.disposition))
+            // A `skipped` floor row at major 2 is an opt-in the host withheld — the
+            // suite was not allowed to look. That is not evidence the requirement
+            // holds; it blocks the floor (a v1 floor keeps the CERTIFIABLE reading).
+            if (r === undefined || silent || vacuous || !CERTIFIABLE.includes(r.disposition) || (atMajor2 && r.disposition === 'skipped'))
                 blocking.push(id);
         }
         // discoveryOnly floors have ids.length === 0 and certify by design here (the
         // requirement-ledger's verifyProfileRequirements is stricter; the runner
-        // consults PROFILE_FLOOR_SCENARIOS.discoveryOnly separately).
-        const discoveryOnly = PROFILE_FLOOR_SCENARIOS[profile]?.discoveryOnly === true;
-        const runtimeDerived = PROFILE_FLOOR_SCENARIOS[profile]?.runtimeDerived === true;
+        // consults PROFILE_FLOOR_SCENARIOS.discoveryOnly separately). Neither flag
+        // exists at major 2.
+        const discoveryOnly = !atMajor2 && PROFILE_FLOOR_SCENARIOS[profile]?.discoveryOnly === true;
+        const runtimeDerived = !atMajor2 && PROFILE_FLOOR_SCENARIOS[profile]?.runtimeDerived === true;
         // A runtime-derived profile is HELD only when every floor row is a witnessed
         // pass ("derivable from which scenarios pass" — profiles.md). Anything else
         // means the host does not hold it: not a rejection, not a blocked claim.
         const held = ids.length > 0 && witnessedPasses === ids.length;
+        // Major 2: a floor certifies only on a witnessed pass. `inapplicable` rows
+        // are honest per file (capabilities.md §2 requires the omission) but a floor
+        // that is inapplicable end to end has witnessed nothing and certifies nothing.
+        const certifiableAt2 = ids.length > 0 && blocking.length === 0 && witnessedPasses >= 1;
         verdicts.push({
             profile,
             unclassified: runtimeDerived && !held ? [] : unclassified,
             blocking: runtimeDerived && !held ? ids.filter((id) => rowById.get(id)?.disposition !== 'executed-pass' || (rowById.get(id)?.assertionCount ?? 0) === 0) : blocking,
-            certifiable: runtimeDerived ? held : discoveryOnly || (ids.length > 0 && blocking.length === 0),
+            certifiable: atMajor2 ? certifiableAt2 : runtimeDerived ? held : discoveryOnly || (ids.length > 0 && blocking.length === 0),
             runtimeDerived,
             held,
+            witnessedPasses,
         });
     }
     return { requirements: rows, totals, verdicts, rejectUnclassified: verdicts.some((v) => v.unclassified.length > 0), ledgerPresent };

package/dist/lib/seams.js

@@ -0,0 +1,72 @@
+/**
+ * Suite 2.0.0 — the seams profile (RFC 0168 §C; `openwop-conformance-seams-v2`).
+ *
+ * v1 scenarios reach the host-sample seams at `/v1/host/sample/…`,
+ * `/v1/host/workspace/files…` and `/v1/packs-test/…`. In v2 those operations
+ * leave the canonical API for `api/seams-v2.yaml` under `/conformance/seams/…`
+ * (RFC 0168 §C.2). Under target major 2 the driver rewrites the v1 seam path
+ * to its v2 address, so the 165 scenarios that name a seam keep working
+ * without a sweep; the sweep to `seamPath()` is the P3-F polish.
+ *
+ * How a v2 host advertises the profile: RFC 0168 §C.1 forbids a `testSeams`
+ * capability flag and RFC 0169 §C.1 removes the root `profiles[]`; the
+ * reconciliation (recorded against RFC 0168 at its flip) is the
+ * `conformance` METADATA key (RFC 0169 §A.1a): `conformance.seamsProfile:
+ * "openwop-conformance-seams-v2"`. Metadata, not a capability family.
+ */
+export const SEAMS_PROFILE_ID = 'openwop-conformance-seams-v2';
+export const SEAMS_PREFIX = '/conformance/seams';
+const V1_SEAM_PREFIXES = [
+    [/^\/v1\/host\/sample\//, `${SEAMS_PREFIX}/sample/`],
+    [/^\/v1\/host\/workspace\/files/, `${SEAMS_PREFIX}/workspace/files`],
+    [/^\/v1\/packs-test\//, `${SEAMS_PREFIX}/packs-test/`],
+];
+/** The v2 address of a v1 seam path; a non-seam path is returned unchanged. */
+export function seamPath(v1Path) {
+    for (const [re, to] of V1_SEAM_PREFIXES)
+        if (re.test(v1Path))
+            return v1Path.replace(re, to);
+    return v1Path;
+}
+export function isSeamPath(path) {
+    return V1_SEAM_PREFIXES.some(([re]) => re.test(path)) || path.startsWith(`${SEAMS_PREFIX}/`);
+}
+/**
+ * Whether a (v2) discovery document advertises the seams profile.
+ *
+ * **The disposition rule, and it is load-bearing (rc.62).** A scenario that
+ * finds this FALSE records `inapplicable`, never `blocked`. The host has not
+ * claimed the instrument, so the obligation is out of scope for it — the same
+ * sense as `softSkip('inapplicable', 'host does not advertise X')` in
+ * `soft-skip.ts`. `blocked` is reserved for the DIFFERENT fact one line later
+ * in several of these files: the profile IS advertised and the seam answers
+ * 404 — an obligation the host took on and the suite could not measure.
+ *
+ * Why it matters that these are not the same. `blocked` is bundle-wide fatal
+ * (`verifyBundleV3` `blocked-certified`, RFC 0168 §E.1). Until rc.62 fifteen
+ * scenarios recorded `blocked` on an ABSENT advert while the seams profile's
+ * predicate was empty — and an empty predicate is vacuously satisfied, so
+ * `claimedProfilesForV2` claimed the profile for every v2 host. Together that
+ * denied certification of EVERY profile to any host that had simply not
+ * mounted the conformance seams: 19 of MyndHyve's 45 blocked rows and 9 of
+ * openwop-workflow-engine's 29, on hosts that never advertised the profile
+ * they were being held to. Mounting test-only surface is not a precondition of
+ * certifying `openwop-discovery-core`, and a barrier of that shape falls
+ * hardest on the independent implementers the v1 end-of-support clock needs.
+ *
+ * The predicate (`spec/v2/declaration.json`) now requires `conformance` at the
+ * discovery root, which is NECESSARY but not sufficient; this function is the
+ * sufficient test, applied per scenario. A host with a `conformance` block
+ * naming some other profile claims seams-v2, records every floor row
+ * `inapplicable`, witnesses nothing, and so certifies nothing — without a
+ * single blocked row. Claimed-and-unwitnessed and not-claimed are both honest;
+ * blocked-because-unclaimed was not.
+ */
+export function seamsProfileAdvertised(doc) {
+    const conf = doc?.['conformance'];
+    return typeof conf === 'object' && conf !== null && conf['seamsProfile'] === SEAMS_PROFILE_ID;
+}
+/** The target major the runner selected (RFC 0168 §D.3); 1 when unset. */
+export function targetMajor() {
+    return process.env['OPENWOP_TARGET_MAJOR'] === '2' ? 2 : 1;
+}

package/dist/lib/soft-skip.js

@@ -22,12 +22,24 @@
  * resolves it to blocked" — and stays UNCLASSIFIED for certification (a floor
  * row with that disposition still rejects), so the honest bundle row and the
  * pressure to say why both survive.
+ *
+ * rc.56: every note also carries a sequence number, so the per-`it` row can
+ * read the notes written DURING ITS OWN TEST (`softSkipMark()` at test start,
+ * `softSkipDispositionSince(file, mark)` at test end). Until rc.56 the
+ * per-`it` row consulted only the journal's `behaviorGate` entries, never a
+ * softSkip note, so a leg that returned `softSkip('inapplicable', 'a2a facet
+ * not advertised')` was recorded `blocked / unclassified return` at `it`
+ * granularity while its file row was honestly `inapplicable` — and a bundle
+ * with any `blocked` row does not certify (RFC 0168 §E.1). Forty-five such
+ * rows on a host that simply does not advertise A2A/MCP denied certification
+ * to every profile it claimed.
  */
 import { expect } from 'vitest';
 import { basename } from 'node:path';
 /** Detail marker the runner writes for a zero-assertion file that noted nothing. */
 export const UNCLASSIFIED_RETURN_DETAIL = 'every test returned early with zero assertions and no recorded reason — unclassified return; RFC 0148 §A resolves it to blocked (add softSkip(kind, reason) at the early return)';
 const notes = new Map();
+let seq = 0;
 function currentFile() {
     try {
         const p = expect.getState().testPath;
@@ -43,8 +55,9 @@ export function softSkip(kind, reason) {
     if (file === null)
         return undefined;
     const arr = notes.get(file) ?? [];
-    if (!arr.some((n) => n.kind === kind && n.reason === reason))
-        arr.push({ kind, reason });
+    // Every call is recorded with its own sequence number so a per-test window
+    // sees it; the file-level join de-duplicates identical (kind, reason) pairs.
+    arr.push({ kind, reason, seq: ++seq });
     notes.set(file, arr);
     return undefined;
 }
@@ -62,6 +75,17 @@ export function seamAbsent(reason) {
     return softSkip('blocked', reason);
 }
 const RANK = { blocked: 0, skipped: 1, inapplicable: 2 };
+function fold(arr) {
+    if (arr.length === 0)
+        return null;
+    const uniq = [];
+    for (const n of arr)
+        if (!uniq.some((u) => u.kind === n.kind && u.reason === n.reason))
+            uniq.push(n);
+    const kind = [...uniq].sort((a, b) => RANK[a.kind] - RANK[b.kind])[0].kind;
+    const reason = uniq.map((n) => (uniq.length > 1 ? `[${n.kind}] ${n.reason}` : n.reason)).join('; ');
+    return { kind, reason };
+}
 /**
  * The noted disposition for a file, worst-first when mixed (`blocked` beats
  * `skipped` beats `inapplicable` — a file that could not check one thing is
@@ -69,14 +93,21 @@ const RANK = { blocked: 0, skipped: 1, inapplicable: 2 };
  * the reasons joined. `null` when nothing was noted.
  */
 export function softSkipDisposition(file) {
-    const arr = notes.get(file);
-    if (arr === undefined || arr.length === 0)
-        return null;
-    const kind = [...arr].sort((a, b) => RANK[a.kind] - RANK[b.kind])[0].kind;
-    const reason = arr.map((n) => (arr.length > 1 ? `[${n.kind}] ${n.reason}` : n.reason)).join('; ');
-    return { kind, reason };
+    return fold(notes.get(file) ?? []);
+}
+/** A position in the note sequence; pass it to `softSkipDispositionSince`. */
+export function softSkipMark() {
+    return seq;
+}
+/**
+ * The noted disposition for a file counting only notes written AFTER `mark`
+ * — the notes of the test that is ending. Same fold as the file rule.
+ */
+export function softSkipDispositionSince(file, mark) {
+    return fold((notes.get(file) ?? []).filter((n) => n.seq > mark));
 }
 /** Test hook. */
 export function resetSoftSkips() {
     notes.clear();
+    seq = 0;
 }

package/dist/spec-artifacts.lock.json

@@ -1,5 +1,5 @@
 {
   "package": "@openwop/spec-artifacts",
-  "version": "2.0.0-rc.8",
-  "stampSha256": "496861ae55503d03945c4509b57c7eab4e9b3c508c784a919cdd7bbd896b4e95"
+  "version": "2.0.0",
+  "stampSha256": "e4fcd1ca67750794f3735dfc78bd89672a73a35b57c96d5601272ca038700f3c"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openwop/openwop-conformance",
-  "version": "2.0.0-rc.8",
+  "version": "2.0.0",
   "description": "Production-ready black-box conformance suite for OpenWOP v1.0 compliant servers.",
   "repository": {
     "type": "git",
@@ -56,6 +56,6 @@
     "@openwop/spec-artifacts": "file:../spec-artifacts"
   },
   "peerDependencies": {
-    "@openwop/spec-artifacts": "2.0.0-rc.8"
+    "@openwop/spec-artifacts": "2.0.0"
   }
 }

package/requirement-aliases.json

@@ -1,4 +1,7 @@
 {
   "$comment": "old id → new id. Add a row when a test title is reworded so bundles citing the old id still resolve.",
-  "aliases": {}
+  "aliases": {
+    "openwop.it.v2-run-cancel.cancelling-a-terminal-run-answers-409-run-terminal-or-200-idempotently-the-prose": "openwop.it.v2-run-cancel.cancelling-a-terminal-run-is-refused-409-run-terminal",
+    "openwop.it.pause-resume.pause-on-an-already-paused-run-is-a-no-op-200-202-idempotent": "openwop.it.pause-resume.pause-on-an-already-paused-run-returns-409-with-details-runstatus-paused-unless"
+  }
 }