@openwop/openwop-conformance 2.0.0-rc.1 → 2.0.0-rc.10

package/README.md

@@ -112,7 +112,7 @@ Exit code is non-zero on any failed assertion. `--certify` distinguishes: `0`
 
 ## What's Covered
 
-The current suite has 494 scenario files under `src/scenarios/`.
+The current suite has 498 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 +457,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: 494 scenario files. Use [`coverage.md`](./coverage.md) for current grade/gap tracking.
+Current source tree: 498 scenario files. Use [`coverage.md`](./coverage.md) for current grade/gap tracking.
 
 ## Remaining Gaps
 

package/dist/cli.js

@@ -46,6 +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';
 function parseArgs(argv) {
     let baseUrl;
     let apiKey;
@@ -299,13 +300,7 @@ function claimedProfilesFor(doc) {
  * no v2 host could ever certify. Falls back to the empty set only when the
  * registry is genuinely absent from the layout, and says so.
  */
-function claimedProfilesForV2(doc, conformanceRoot) {
-    // Resolve the peer the way `lib/paths.ts` does — through Node's resolver from
-    // this package — instead of guessing directory shapes. Hand-rolled candidates
-    // found the registry in a repo checkout and missed it in every published
-    // install, where npm hoists the peer to a SIBLING package dir: the probe that
-    // walked one level up landed on the `@openwop/` scope directory, not a
-    // package, so a real host run silently claimed nothing.
+function v2RegistryPath(conformanceRoot) {
     const candidates = [];
     try {
         const req = createRequire(resolvePath(conformanceRoot, 'package.json'));
@@ -313,8 +308,17 @@ function claimedProfilesForV2(doc, conformanceRoot) {
     }
     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'), resolvePath(conformanceRoot, '..', 'spec-artifacts', 'spec', 'v2', 'profiles.json'));
-    const found = candidates.find((c) => existsSync(c));
-    if (found === undefined) {
+    return candidates.find((c) => existsSync(c)) ?? null;
+}
+function claimedProfilesForV2(doc, conformanceRoot) {
+    // Resolve the peer the way `lib/paths.ts` does — through Node's resolver from
+    // this package — instead of guessing directory shapes. Hand-rolled candidates
+    // found the registry in a repo checkout and missed it in every published
+    // install, where npm hoists the peer to a SIBLING package dir: the probe that
+    // walked one level up landed on the `@openwop/` scope directory, not a
+    // package, so a real host run silently claimed nothing.
+    const found = v2RegistryPath(conformanceRoot);
+    if (found === null) {
         process.stderr.write('openwop-conformance --certify: spec/v2/profiles.json not found in this layout; claimedProfiles is empty (RFC 0169 §C.1).\n');
         return [];
     }
@@ -342,6 +346,46 @@ function claimedProfilesForV2(doc, conformanceRoot) {
     }
     return out;
 }
+/**
+ * `spec/v2/profiles.json` `floorScenarios` → scenario file names. A
+ * `planned:<name>` entry names a scenario the registry expects but that may not
+ * exist yet; it resolves to `v2-<name>.test.ts` when that file is in the
+ * manifest and is dropped otherwise, so a planned-but-unwritten floor cannot
+ * 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;
+}
 /**
  * Reduce a vitest JSON report into a per-scenario-file terminal state, keyed by
  * the test-file basename (e.g. `discovery.test.ts`) to align with the basenames
@@ -450,6 +494,10 @@ async function runCertify(args, baseUrl, apiKey) {
     const sha256 = createHash('sha256').update(canonicalJSON(document)).digest('hex');
     // (b) Derive claimedProfiles from the captured document.
     const claimedProfiles = target.major === 2 ? claimedProfilesForV2(document, conformanceRoot) : claimedProfilesFor(document);
+    // Major-2 floors come from spec/v2/profiles.json. Without this the derivation
+    // measures a v2 host against v1 scenario files a major-2 run never executes,
+    // and refuses certification for not running them.
+    setV2ProfileFloors(target.major === 2 ? v2ProfileFloors(conformanceRoot) : null);
     // (c) Run the suite, capturing per-scenario terminal state via the vitest
     // JSON reporter. server-targeted scenarios live under src/scenarios/.
     const reportDir = mkdtempSync(join(tmpdir(), 'owp-certify-'));

package/dist/lib/requirement-registry.js

@@ -76,7 +76,27 @@ export function floorFilesFor(profile, document) {
  * discovery-conditional floor (RFC 0148 §C G7 — `openwop-replay-fork`): without
  * it such a floor is UNEVALUABLE and this returns `null`, never `[]`.
  */
+/**
+ * Major-2 floors come from `spec/v2/profiles.json`, not from the v1 table.
+ * `PROFILE_FLOOR_SCENARIOS` names v1 scenario FILES (`runs-lifecycle.test.ts`,
+ * `discovery.test.ts`, …) that `scenario-majors.json` assigns to major 1 and a
+ * major-2 run therefore never executes — so every one of them came back
+ * unclassified and a v2 host was refused certification for not running v1
+ * scenarios. Set by the runner before deriving; empty means the registry
+ * declares no floor for that profile, which is a real "witnesses nothing yet",
+ * not an unclassified return.
+ */
+let v2Floors = null;
+export function setV2ProfileFloors(floors) {
+    v2Floors = floors;
+}
 export function requirementsFor(profile, document) {
+    if (v2Floors !== null) {
+        const files = v2Floors[profile];
+        if (files === undefined)
+            return null;
+        return files.map(requirementIdForScenario);
+    }
     const floor = PROFILE_FLOOR_SCENARIOS[profile];
     if (floor === undefined)
         return null;

package/dist/spec-artifacts.lock.json

@@ -1,5 +1,5 @@
 {
   "package": "@openwop/spec-artifacts",
-  "version": "2.0.0-rc.1",
-  "stampSha256": "c588b39fdcedb05d753c738cfe8e335093cdd2e9431f789d9d2085df4629e794"
+  "version": "2.0.0-rc.10",
+  "stampSha256": "9bd46582060eb1408c0bcac781805f0cee84cd4b2955251bed4a5b328e19e4af"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openwop/openwop-conformance",
-  "version": "2.0.0-rc.1",
+  "version": "2.0.0-rc.10",
   "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.1"
+    "@openwop/spec-artifacts": "2.0.0-rc.10"
   }
 }

package/requirements.json

@@ -2,9 +2,9 @@
   "$comment": "GENERATED by conformance/scripts/generate-requirement-registry.mjs — do not edit. One record per it()/test() in src/scenarios. Ids: openwop.it.<file-stem>.<title-slug>[~n] (src/lib/requirement-ids.ts). A record with id null has an interpolated title; its run-time row is keyed by the rendered title and maps here by file+line only. Renamed ids need a row in requirement-aliases.json.",
   "generatedFrom": "src/scenarios/*.test.ts",
   "counts": {
-    "files": 538,
-    "tests": 2106,
-    "withStableId": 2106,
+    "files": 544,
+    "tests": 2118,
+    "withStableId": 2118,
     "interpolatedTitles": 0,
     "explicitIds": 2057
   },
@@ -25741,6 +25741,34 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-advertised-fixtures-exist.every-advertised-fixture-id-is-one-the-corpus-defines",
+      "file": "v2-advertised-fixtures-exist.test.ts",
+      "line": 60,
+      "title": "every advertised fixture id is one the corpus defines",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-advertised-fixtures-exist.a-sampled-advertised-fixture-is-actually-creatable-not-just-listed",
+      "file": "v2-advertised-fixtures-exist.test.ts",
+      "line": 80,
+      "title": "a sampled advertised fixture is actually creatable, not just listed",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
     {
       "id": "openwop.it.v2-approver-enforced.a-resolver-outside-approverslist-is-refused-at-resolve-time",
       "file": "v2-approver-enforced.test.ts",
@@ -26501,6 +26529,49 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-era-2-append-vocabulary.a-host-append-to-an-open-era-2-run-keeps-the-log-in-v1-vocabulary-so-the-whole-l",
+      "file": "v2-era-2-append-vocabulary.test.ts",
+      "line": 48,
+      "title": "a host append to an open era-2 run keeps the log in v1 vocabulary, so the whole log still reads",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-era-2-append-vocabulary.the-run-keeps-the-era-it-was-created-with-an-append-does-not-promote-it-to-era-3",
+      "file": "v2-era-2-append-vocabulary.test.ts",
+      "line": 119,
+      "title": "the run keeps the era it was created with; an append does not promote it to era 3",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
     {
       "id": "openwop.it.v2-era-key.a-run-created-now-carries-eventlogschemaversion-3-on-its-snapshot",
       "file": "v2-era-key.test.ts",
@@ -26544,6 +26615,44 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-era-stamp-universal.discovery-advertises-an-era-the-host-actually-writes-and-a-new-run-carries-it",
+      "file": "v2-era-stamp-universal.test.ts",
+      "line": 40,
+      "title": "discovery advertises an era the host actually writes, and a new run carries it",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-era-stamp-universal.a-v2-era-host-stamps-3-so-its-new-runs-are-never-read-as-the-v1-era",
+      "file": "v2-era-stamp-universal.test.ts",
+      "line": 80,
+      "title": "a v2-era host stamps 3, so its new runs are never read as the v1 era",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": "a host advertising era 3 MUST stamp 3 on every run it creates — an unstamped run made after the cut is indistinguishable from a pre-cut run and every reader translates it as era 2, which is a silent wrong read rather than an error",
+          "interpolated": true
+        }
+      ]
+    },
     {
       "id": "openwop.it.v2-error-registry.an-error-response-is-the-closed-envelope-with-a-registered-code-at-its-registere",
       "file": "v2-error-registry.test.ts",
@@ -28015,6 +28124,49 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-version-header-honored.openwop-version-is-honored-or-refused-never-ignored",
+      "file": "v2-version-header-honored.test.ts",
+      "line": 61,
+      "title": "OpenWOP-Version is honored or refused — never ignored",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": "a host that does not serve major 2 MUST refuse with 406 protocol_version_unsupported, which it did",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "answering 200 to OpenWOP-Version: 2.0 with a body byte-identical to the header-less fetch means the header was IGNORED, not honored — the host served v1 and called it v2. Refusing with 406 is the correct answer for a host that does not implement major 2; silently returning v1 is the one answer that no presence-gated scenario can detect, because an absent v2 shape records `inapplicable` whether the host refused or ignored",
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-version-header-honored.a-host-advertising-two-majors-serves-two-different-representations",
+      "file": "v2-version-header-honored.test.ts",
+      "line": 92,
+      "title": "a host advertising two majors serves two different representations",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "the v1 document and the closed v2 root differ by construction (capabilities.md §1), so a host advertising both majors returning identical bytes for both has advertised a major it does not actually serve",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
     {
       "id": "openwop.it.v2-webhook-durable-delivery.a-failed-attempt-is-retried-and-the-event-is-delivered-at-least-once",
       "file": "v2-webhook-durable-delivery.test.ts",
@@ -34383,6 +34535,68 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-bundle-signature-attributable.the-v2-discovery-root-publishes-signingkeys-the-surface-the-rfc-named",
+      "file": "v2-bundle-signature-attributable.test.ts",
+      "line": 85,
+      "title": "the v2 discovery root publishes signingKeys[] — the surface the RFC named",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": "the v2 discovery root MUST carry signingKeys[] — RFC 0168 disposed of \"an Ed25519 attestation without a key registry is a signature nobody can check\" by naming this surface, so if it is absent the disposition names a place that does not exist and every bundle signature is unattributable",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "a signingKeys[] entry MUST be closed; an open key record lets a host attach meaning the verifier does not read",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "a signingKeys[] entry MUST be able to record retirement, because a retired key has to stay listed — dropping it silently invalidates every bundle it already signed, which is the opposite of what an evidence trail is for",
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-bundle-signature-attributable.the-front-door-gate-verifies-the-attestation-instead-of-inspecting-the-string",
+      "file": "v2-bundle-signature-attributable.test.ts",
+      "line": 116,
+      "title": "the Front-door gate verifies the attestation instead of inspecting the string",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": "the gate MUST NOT accept a bundle signature by presence: `typeof signature.sig === 'string'` is satisfied by any string, so it cannot distinguish a host key from a keypair minted seconds earlier by whoever wrote the bundle",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "the gate MUST resolve signature.keyId against the host's published signingKeys[] and verify the Ed25519 attestation under it — resolving without verifying, or verifying against a key the bundle supplied itself, both leave the signature unaccountable",
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-bundle-signature-attributable.the-four-signature-outcomes-stay-distinct-collapsing-any-two-restores-the-defect",
+      "file": "v2-bundle-signature-attributable.test.ts",
+      "line": 131,
+      "title": "the four signature outcomes stay distinct — collapsing any two restores the defect",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
     {
       "id": "openwop.it.v2-corpus-tag-pinned.every-vendoring-consumer-in-the-cross-repo-inventory-records-a-published-corpus",
       "file": "v2-corpus-tag-pinned.test.ts",
@@ -34411,6 +34625,30 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-error-registry-prose-parity.errors-md-states-the-registry-count-it-was-generated-from-and-renders-every-code",
+      "file": "v2-error-registry-prose-parity.test.ts",
+      "line": 26,
+      "title": "errors.md states the registry count it was generated from and renders every code",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "errors.md states the registry size at least once, so the claim is checkable",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
     {
       "id": "openwop.it.v2-event-naming-rule.every-closed-enum-v2-event-type-is-two-kebab-segments-and-every-recorded-artifac",
       "file": "v2-event-naming-rule.test.ts",

package/scenario-majors.json

@@ -1,9 +1,9 @@
 {
   "$comment": "GENERATED by conformance/scripts/generate-scenario-majors.mjs (RFC 0168 §D.3). Do not edit; add a file to BOTH_MAJORS in the generator to target both majors.",
   "counts": {
-    "files": 494,
+    "files": 498,
     "v1": 444,
-    "v2": 51
+    "v2": 55
   },
   "majors": {
     "a2a-1-0-agent-card.test.ts": [
@@ -1228,6 +1228,9 @@
     "trigger-stream-cdc-sources.test.ts": [
       1
     ],
+    "v2-advertised-fixtures-exist.test.ts": [
+      2
+    ],
     "v2-approver-enforced.test.ts": [
       2
     ],
@@ -1267,9 +1270,15 @@
     "v2-enum-growth-rule.test.ts": [
       2
     ],
+    "v2-era-2-append-vocabulary.test.ts": [
+      2
+    ],
     "v2-era-key.test.ts": [
       2
     ],
+    "v2-era-stamp-universal.test.ts": [
+      2
+    ],
     "v2-error-registry.test.ts": [
       2
     ],
@@ -1372,6 +1381,9 @@
     "v2-v1-signed-webhook-accepted.test.ts": [
       2
     ],
+    "v2-version-header-honored.test.ts": [
+      2
+    ],
     "v2-webhook-durable-delivery.test.ts": [
       2
     ],

package/schemas/CORPUS-STAMP.json

@@ -1,7 +1,7 @@
 {
   "_comment": "Provenance of @openwop/spec-artifacts (RFC 0168 §D.2). files: SHA-256 per file; the conformance suite compares the installed peer against dist/spec-artifacts.lock.json at start.",
   "package": "@openwop/spec-artifacts",
-  "version": "2.0.0-rc.1",
+  "version": "2.0.0-rc.10",
   "corpusTag": null,
   "files": {
     "api/.redocly.lint-ignore.yaml": "bf5a8350b88a72fa43f59605ed8d903ed24b6cfccda5e45509c9f6ed9ee4e712",
@@ -9,9 +9,9 @@
     "api/grpc/openwop.proto": "c3e72bb17cba514ee98feb6434e6c9b6ea6795bfd086489ec69fd882dd1ad977",
     "api/openapi.yaml": "39081c59fb696159806b0f2f9a42e7e9ff830d622fcf2ad4159b21357580a955",
     "api/redocly.yaml": "b0604c89b2ca6d5076ec25725c539dad44a741a811fe524439ee6daef8baa09f",
-    "api/seams-v2.yaml": "52fef8b9294f66a4b0bbf2fa53e6295808b643c8330418c478b4062e30952dd7",
-    "api/v2/asyncapi.yaml": "1362b62925d194848b269911ef7aedba46da07160dbc6f0a5c1438669d612855",
-    "api/v2/openapi.yaml": "834cdda6d57322f42061a60d8bb3b89cad8e51361506e59cb269251b8c30b86b",
+    "api/seams-v2.yaml": "09450ae021c2230e440257875149337984f319b42a7808037130305e3c48390f",
+    "api/v2/asyncapi.yaml": "0dbb71b3832ee159e03f633cbb5464a14b565d2335b9f00ec8aee456bac950be",
+    "api/v2/openapi.yaml": "a5ad8b811af848060c62feaebc9be8450bc5ca113ba84158c3b97a3bdef66ad9",
     "api/v2/redocly.yaml": "1e66b60e6118ad11a823bb620678be464d99dfe50a40e3e6f93ec9429b88b34c",
     "schemas/README.md": "0c0b737ffcf8f30e7d2809cec8a498232de710f41443212922ad8337cdde0b51",
     "schemas/a2a-task-state.schema.json": "c9365918f993f943b4b619d42551eb066a1ed33a08d895d51b395432a5b1f1bc",
@@ -32,7 +32,7 @@
     "schemas/audit-verify-result.schema.json": "e8fd013fb610ba5db27ab0113ec2eb18e7da5f9310dd3de2dd3dc87a259c21fe",
     "schemas/budget-policy.schema.json": "3d4fe30ae129fe136ab9ece395f2a2a42a76360786b1b9a1d5f1cbc753eb5b39",
     "schemas/capabilities.schema.json": "e672c35d503532d8039b5552115f5ec150d60317f537f13180d830b0fe315947",
-    "schemas/certification-bundle-v2.schema.json": "3540232676086869ae78d24f3b9c2154f9c4a8a5eeb976512d6a7409f8cf19bb",
+    "schemas/certification-bundle-v2.schema.json": "2f85530dd04824a15810c94e96869362dee1e78396eca21fdd18e5501416bb7d",
     "schemas/channel-presence-payload.schema.json": "f9d0ef4219814c2b765baf3e68cbe5eea2cb42379f516a93a0459dcd5f7db47e",
     "schemas/channel-written-payload.schema.json": "54723a56bc5a35232f64544ca686ac1ac959a5fb05b32b2401facca6b3ef51a3",
     "schemas/chat-card-pack-manifest.schema.json": "402f7e9081cc39857a52e772061f4e034a957dcbc17501fe6e8e0bcb3d337e42",
@@ -115,8 +115,8 @@
     "schemas/v2/artifact-type-pack-manifest.schema.json": "c911757562e521cb4f31a47c097f562573b64087efe60c8acb81fd352367d300",
     "schemas/v2/audit-verify-result.schema.json": "cb54c4d89ba5dfb73f49aa8959a980be65c2dc2a87a12f71ba36d3e836fe85da",
     "schemas/v2/budget-policy.schema.json": "c7449daeb6e1d95e7a047b8c2814d3d54748697c27046972834874867d9b5f4c",
-    "schemas/v2/capabilities.schema.json": "b6191deddf6bee19470eee9a45bb520de0d17385c195de6e3b8c5cb6d9520238",
-    "schemas/v2/certification-bundle.schema.json": "02aa15f17644d902a9df06a99cfdaf51273b0a9cca0d0ef515d5da03be01fb09",
+    "schemas/v2/capabilities.schema.json": "792669b2cc7b1fd44ce9a4fd3e79696ad1277734e29299a4504b39eda15913ed",
+    "schemas/v2/certification-bundle.schema.json": "d441198893c01cd14d84abe9c5bf591b69f47554db749c01899512f36cea11fa",
     "schemas/v2/channel-presence-payload.schema.json": "9475d46f358d21c19126e78204987a5633979917a2293653354ef5c5e044d54e",
     "schemas/v2/channel-written-payload.schema.json": "ccecff3c71a3275ad8db035ac0e04db25e6f8d23cf091ddbcd5a60d1be1cbb6b",
     "schemas/v2/chat-card-pack-manifest.schema.json": "566982ce509a96d1619d58a72e383eff0773fe43fc65e4bfc85a4fe158f4eaff",
@@ -149,7 +149,7 @@
     "schemas/v2/goal.schema.json": "d202ef21ed3dbff87c25fd4b553fa978862a3200999878d25c5918f6794b3060",
     "schemas/v2/heartbeat-evaluated.schema.json": "4086b1ba1d0547c08b038dfb263ac89416a3e406430db1250156fb2f9b74f8d6",
     "schemas/v2/heartbeat-state-changed.schema.json": "eb68d0082aa996650e3a6b8ccf32457f959cebc7e6728cc7c331b9d171a4bef6",
-    "schemas/v2/ids.schema.json": "0ccf5eb3ec0744296b3379f7ced3b46ec51d908705a4f03dc4404d42236ebe19",
+    "schemas/v2/ids.schema.json": "dc6c99dea35a3416167b2b883ac08694794da1c7552bbfa48fc489c612d1cf97",
     "schemas/v2/localized-content-language-settings.schema.json": "92240f19a2b4b2f05ab41a797f703485a28813848035478e72f395edd04c1d35",
     "schemas/v2/localized-content-page-response.schema.json": "476b5f2775b42e35e679814a4ce846a7be1d5311d3a748c10df4275a78b0fb27",
     "schemas/v2/localized-content-page.schema.json": "717bb51fbc64d0b34eb0a4b35c8b463d08d505267bf251b4cbc67e0a016a567a",
@@ -169,11 +169,11 @@
     "schemas/v2/residency.schema.json": "af2658a7104cbcacd0e20a91226271c4a77f91ef46ae97612768fe743e6091d8",
     "schemas/v2/run-ancestry-response.schema.json": "907e36341ba83a2147a5d76963950b6dcd47506b663ecbccae9dfa553f3724d3",
     "schemas/v2/run-diff-response.schema.json": "6ab6cd265dc7e0a2086c6659c46aa0e7b43e6302949f0adac5d7deb1c7c0ecd3",
-    "schemas/v2/run-event-payloads.schema.json": "8eb0e05e1bd3399b0e2654a1ec5a13198ac4ec8459a1fcbfd800ab2d0a0ae8c6",
-    "schemas/v2/run-event.schema.json": "4ec8eb048a79ca1343e00aa018acbf86814b5eda6768add6b17e8d7b83638fdf",
+    "schemas/v2/run-event-payloads.schema.json": "bd5cb6687828a86fb4411d331893ec183dce2c52cb27c22035d4cd7a8bc3c1a2",
+    "schemas/v2/run-event.schema.json": "1a9946374af9323b71635d00fed22abe02c300fa2cf3ae3e9c30f3e553e408ec",
     "schemas/v2/run-options.schema.json": "6d6052596ab0f17acfb00fdfc89907da7724f952e5ffbe1f81d94ba23d4c77cd",
     "schemas/v2/run-orchestrator-decided-event.schema.json": "bb76e15ff72e669f12938684033b55dc567470e1a378e19ffc3fa0e4034ab5a7",
-    "schemas/v2/run-snapshot.schema.json": "e77bf491d11c1414e62ed84cbf0c1d7149279b133a2101dc8f5eec89d3e45204",
+    "schemas/v2/run-snapshot.schema.json": "01408d8dac93e2d08d8db30f9cd7a4d903dce882a60bc1d48c3e6b921267f2a3",
     "schemas/v2/security-advisory.schema.json": "6a382f737730a738d634266315e9d335e5760020a0cdd9f30727c2f987a01770",
     "schemas/v2/self-hosted-runner-dispatch-frame.schema.json": "d8129f11d4e731d17ea951e66faaea2086081d13958b62ceaaa359fd6637dd7d",
     "schemas/v2/self-hosted-runner-registration.schema.json": "93d60003a668cacb0eeac37699ca2884c6b79332d9494cb9e0a1752ac8f8a16c",
@@ -198,7 +198,7 @@
     "schemas/workspace-file.schema.json": "464de85c2a068243084ee9c1d969bc7cd5d8f7948574e58450d6493c38a0e1e4",
     "spec/v1/alias-detectors.json": "fee4594ef49953953ffcd0b3813300067d16b3e65ebff2aac722034ac9b3f545",
     "spec/v1/capability-declaration-classes.json": "e7729aed5c4b4e1dd02abab0530f14cc95f5d4070fe51fb139e7f5cccefa00c6",
-    "spec/v1/core-standard-manifest.json": "ba7d24beac18e8b0a95becf73e89c37e7720920a71bff6bdd2e98c291c70afb7",
+    "spec/v1/core-standard-manifest.json": "a9e4e6d32753d76974f1a61d5e31bd1fcde5ad0100cf3c7aae6770f3e6fca5c6",
     "spec/v1/deprecations.json": "520d79927a8ed43ccf62c207a7cf6cf7b19b16e00bbbbdf0410667e939c19d85",
     "spec/v1/deprecations.schema.json": "4cdbbb8eb9c0092913a5704c943880f0c8581bcf0f640a7df5a84105d53c8aee",
     "spec/v1/event-codemap.json": "3da60d884157793a360da532a9fcbbfb5285636db325a74cec94b34622186d97",
@@ -210,7 +210,7 @@
     "spec/v1/migrations.schema.json": "886779aa6c22e646db097f5df210adb018a4dd14a7b815465a18c8a7056c8f72",
     "spec/v1/operation-path-manifest.json": "5f5f4e3842669371730ebbd1aace3fb794192615f0018dc144f484ba5db82ac3",
     "spec/v1/spec-gaps.json": "6cc9962c6b969f632e07a78b52a4f61447ff579e2990cbae989866f584a86042",
-    "spec/v2/declaration.json": "892b6fae1e87f279ff75451f67ffab2a63ef883203f8066886bd60f165469348",
+    "spec/v2/declaration.json": "52b8c24a2dd463d44086129bf792ad108746f5102778cbbf0ff469fa534eca48",
     "spec/v2/declaration.schema.json": "b0881a76228dfbd1b85a2ec7b7259a60197f768344535cdb475db6ff719b0e54",
     "spec/v2/errors.json": "ad1725dc7c11002450e8abc682858eb5c11952a0718ea8ef6bdb2fb5ae6e7e21",
     "spec/v2/event-codemap.json": "37869a03cdfd8758b57e6f350641a6ebbd383231cebda51f5473ad85f94ab74c",
@@ -228,7 +228,7 @@
     "spec/v2/path-manifest.json": "034152e09b1458c66810d4050e20a273b2b9b8fe2d92b66e8b819477de58a1be",
     "spec/v2/peer-dependency-aliases.json": "d10299280abee08258502925bc327293ee413e0108cd6e6ec75ff6110653308d",
     "spec/v2/profiles.json": "1f0ee40491131cf561ef19a0394c47ba476b4567514fe16befb6cada4a10a5a4",
-    "spec/v2/release.json": "41b69aed1e0c366cb287b05133ad561a1d4975b7a9e6786edf355ce976f4f12e"
+    "spec/v2/release.json": "7eb5cd641f6bb4d3143b3ddf8602bb2d856efc3c2db80cca2f15fe3a4f78c7f3"
   },
-  "corpusCommit": "56cd5d7bb1dd663a887f884a0a4504c878d71b52"
+  "corpusCommit": "f71d788362ba5a32f167c2c70a1e534ddebc4f31"
 }

package/src/cli.ts

@@ -54,6 +54,7 @@ import {
   type DiscoveryPayload,
   PROFILE_FLOOR_SCENARIOS,
 } from './lib/profiles.js';
+import { setV2ProfileFloors } from './lib/requirement-registry.js';
 
 interface ParsedArgs {
   readonly baseUrl: string | undefined;
@@ -320,14 +321,8 @@ function claimedProfilesFor(doc: DiscoveryPayload): string[] {
  * no v2 host could ever certify. Falls back to the empty set only when the
  * registry is genuinely absent from the layout, and says so.
  */
-function claimedProfilesForV2(doc: DiscoveryPayload, conformanceRoot: string): string[] {
-  // Resolve the peer the way `lib/paths.ts` does — through Node's resolver from
-  // this package — instead of guessing directory shapes. Hand-rolled candidates
-  // found the registry in a repo checkout and missed it in every published
-  // install, where npm hoists the peer to a SIBLING package dir: the probe that
-  // walked one level up landed on the `@openwop/` scope directory, not a
-  // package, so a real host run silently claimed nothing.
-  const candidates = [];
+function v2RegistryPath(conformanceRoot: string): string | null {
+  const candidates: string[] = [];
   try {
     const req = createRequire(resolvePath(conformanceRoot, 'package.json'));
     candidates.push(resolvePath(dirname(req.resolve('@openwop/spec-artifacts/package.json')), 'spec', 'v2', 'profiles.json'));
@@ -337,8 +332,18 @@ function claimedProfilesForV2(doc: DiscoveryPayload, conformanceRoot: string): s
     resolvePath(conformanceRoot, '..', 'spec', 'v2', 'profiles.json'),
     resolvePath(conformanceRoot, '..', 'spec-artifacts', 'spec', 'v2', 'profiles.json'),
   );
-  const found = candidates.find((c) => existsSync(c));
-  if (found === undefined) {
+  return candidates.find((c) => existsSync(c)) ?? null;
+}
+
+function claimedProfilesForV2(doc: DiscoveryPayload, conformanceRoot: string): string[] {
+  // Resolve the peer the way `lib/paths.ts` does — through Node's resolver from
+  // this package — instead of guessing directory shapes. Hand-rolled candidates
+  // found the registry in a repo checkout and missed it in every published
+  // install, where npm hoists the peer to a SIBLING package dir: the probe that
+  // walked one level up landed on the `@openwop/` scope directory, not a
+  // package, so a real host run silently claimed nothing.
+  const found = v2RegistryPath(conformanceRoot);
+  if (found === null) {
     process.stderr.write('openwop-conformance --certify: spec/v2/profiles.json not found in this layout; claimedProfiles is empty (RFC 0169 §C.1).\n');
     return [];
   }
@@ -364,6 +369,42 @@ function claimedProfilesForV2(doc: DiscoveryPayload, conformanceRoot: string): s
   return out;
 }
 
+/**
+ * `spec/v2/profiles.json` `floorScenarios` → scenario file names. A
+ * `planned:<name>` entry names a scenario the registry expects but that may not
+ * exist yet; it resolves to `v2-<name>.test.ts` when that file is in the
+ * manifest and is dropped otherwise, so a planned-but-unwritten floor cannot
+ * fail a host for the corpus's own backlog.
+ */
+function v2ProfileFloors(conformanceRoot: string): Record<string, readonly string[]> {
+  const registryPath = v2RegistryPath(conformanceRoot);
+  if (registryPath === null) return {};
+  let known: Set<string>;
+  try {
+    known = new Set(Object.keys((JSON.parse(readFileSync(resolvePath(conformanceRoot, 'scenario-majors.json'), 'utf8')) as { majors: Record<string, number[]> }).majors));
+  } catch {
+    known = new Set();
+  }
+  let registry: { profiles?: Array<{ id?: unknown; floorScenarios?: unknown }> };
+  try {
+    registry = JSON.parse(readFileSync(registryPath, 'utf8'));
+  } catch {
+    return {};
+  }
+  const out: Record<string, readonly string[]> = {};
+  for (const p of registry.profiles ?? []) {
+    if (typeof p.id !== 'string') continue;
+    const raw = Array.isArray(p.floorScenarios) ? (p.floorScenarios as unknown[]).map(String) : [];
+    const files: string[] = [];
+    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;
+}
+
 /** A single scenario test file's terminal state, derived from the vitest JSON report. */
 type ScenarioState = 'passed' | 'failed' | 'skipped';
 
@@ -475,6 +516,10 @@ async function runCertify(args: ParsedArgs, baseUrl: string, apiKey: string): Pr
 
   // (b) Derive claimedProfiles from the captured document.
   const claimedProfiles = target.major === 2 ? claimedProfilesForV2(document, conformanceRoot) : claimedProfilesFor(document);
+  // Major-2 floors come from spec/v2/profiles.json. Without this the derivation
+  // measures a v2 host against v1 scenario files a major-2 run never executes,
+  // and refuses certification for not running them.
+  setV2ProfileFloors(target.major === 2 ? v2ProfileFloors(conformanceRoot) : null);
 
   // (c) Run the suite, capturing per-scenario terminal state via the vitest
   // JSON reporter. server-targeted scenarios live under src/scenarios/.

package/src/lib/requirement-registry.ts

@@ -78,7 +78,28 @@ export function floorFilesFor(profile: string, document?: Readonly<Record<string
  * discovery-conditional floor (RFC 0148 §C G7 — `openwop-replay-fork`): without
  * it such a floor is UNEVALUABLE and this returns `null`, never `[]`.
  */
+/**
+ * Major-2 floors come from `spec/v2/profiles.json`, not from the v1 table.
+ * `PROFILE_FLOOR_SCENARIOS` names v1 scenario FILES (`runs-lifecycle.test.ts`,
+ * `discovery.test.ts`, …) that `scenario-majors.json` assigns to major 1 and a
+ * major-2 run therefore never executes — so every one of them came back
+ * unclassified and a v2 host was refused certification for not running v1
+ * scenarios. Set by the runner before deriving; empty means the registry
+ * declares no floor for that profile, which is a real "witnesses nothing yet",
+ * not an unclassified return.
+ */
+let v2Floors: Readonly<Record<string, readonly string[]>> | null = null;
+
+export function setV2ProfileFloors(floors: Readonly<Record<string, readonly string[]>> | null): void {
+  v2Floors = floors;
+}
+
 export function requirementsFor(profile: string, document?: Readonly<Record<string, unknown>>): readonly string[] | null {
+  if (v2Floors !== null) {
+    const files = v2Floors[profile];
+    if (files === undefined) return null;
+    return files.map(requirementIdForScenario);
+  }
   const floor = PROFILE_FLOOR_SCENARIOS[profile];
   if (floor === undefined) return null;
   if (floor.discoveryOnly === true) return [];

package/src/scenarios/v2-advertised-fixtures-exist.test.ts

@@ -0,0 +1,108 @@
+/**
+ * `spec/v2/core/conformance.md` — an advertised conformance fixture is a claim
+ * the host must be able to honour (suite 2.0.0, target major 2; unaided).
+ *
+ * `fixtures[]` in discovery gates scenarios: `isFixtureAdvertised(id)` decides
+ * whether a scenario runs at all. Nothing checked that an advertised id names a
+ * fixture the corpus actually defines, or that the host can serve it. A host
+ * whose advertised list and seeded set drift apart therefore fails somewhere
+ * else entirely — the scenario gated on the missing fixture attempts, fails on
+ * a run that cannot be created, and the failure is attributed to that
+ * scenario's requirement rather than to the advertisement that was wrong.
+ *
+ * No host is currently known to exhibit this. A tier-2 host was thought to
+ * (46 seeded against 47 advertised) and then verified and retracted it — the
+ * count had been eyeballed from an array literal rather than measured, and the
+ * two sets are in fact identical. The scenario is kept because the failure mode
+ * is a property of the gating mechanism, not of that host: `fixtures[]` decides
+ * whether a scenario runs, so a wrong advertisement is charged to whatever runs
+ * next. Leg 1 is also the stronger check — an id the corpus catalog does not
+ * define is wrong however well a host's own two lists agree with each other.
+ *
+ * Two legs, both cheap:
+ *   1. the advertised ids are a subset of the corpus fixture catalog — the
+ *      vocabulary is closed, so an id the corpus does not define is a typo or
+ *      an invention, not a capability;
+ *   2. a bounded sample of advertised fixtures is actually creatable, so the
+ *      list is a claim about reachable state rather than a wish.
+ *
+ * @see spec/v2/core/conformance.md
+ * @see conformance/fixtures.md
+ */
+
+import { describe, it, expect } from 'vitest';
+import { existsSync, readdirSync } from 'node:fs';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { v2Discovery } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { FIXTURES_DIR } from '../lib/paths.js';
+
+const ID = 'openwop.requirement.0168.advertised-fixtures-exist';
+const DOC = 'spec/v2/core/conformance.md §Fixtures';
+/** Creating one run per advertised fixture would be a load test, not a check. */
+const SAMPLE = 5;
+
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> {
+  try {
+    return await fn();
+  } catch {
+    return null;
+  }
+}
+
+function advertisedIds(doc: Record<string, unknown>): string[] {
+  const raw = doc['fixtures'];
+  return Array.isArray(raw) ? raw.filter((x): x is string => typeof x === 'string') : [];
+}
+
+describe('v2-advertised-fixtures-exist (conformance.md §Fixtures)', () => {
+  it('every advertised fixture id is one the corpus defines', async () => {
+    const doc = await v2Discovery().catch(() => null);
+    if (!doc) return softSkip('blocked', 'v2 discovery unreachable');
+    const ids = advertisedIds(doc);
+    if (ids.length === 0) return softSkip('inapplicable', 'the host advertises no fixtures[] — there is no claim to falsify');
+    if (FIXTURES_DIR === null || !existsSync(FIXTURES_DIR)) {
+      return softSkip('blocked', 'the fixture catalog is absent from this layout, so an advertised id cannot be checked against it');
+    }
+    const catalog = new Set(
+      readdirSync(FIXTURES_DIR)
+        .filter((f) => f.endsWith('.json'))
+        .map((f) => f.replace(/\.json$/, '')),
+    );
+    const unknown = ids.filter((id) => !catalog.has(id));
+    expect(
+      unknown,
+      req(ID, DOC, `every id in fixtures[] MUST name a fixture the corpus defines — the vocabulary is closed, so an id the catalog does not carry is a typo or an invention rather than a capability (${unknown.length} unknown of ${ids.length}: ${unknown.slice(0, 5).join(', ')})`),
+    ).toEqual([]);
+  });
+
+  it('a sampled advertised fixture is actually creatable, not just listed', async () => {
+    const doc = await v2Discovery().catch(() => null);
+    if (!doc) return softSkip('blocked', 'v2 discovery unreachable');
+    const ids = advertisedIds(doc);
+    if (ids.length === 0) return softSkip('inapplicable', 'the host advertises no fixtures[]');
+
+    // Deterministic sample: the first N by sort order, so a failure is
+    // reproducible and a host cannot pass by luck of ordering.
+    const sample = [...ids].sort().slice(0, SAMPLE);
+    const unreachable: string[] = [];
+    let attempted = 0;
+    for (const id of sample) {
+      const res = await http(() => driver.post('/runs', { workflowId: id, inputs: {} }));
+      if (res === null) {
+        return softSkip('blocked', `POST /runs was unreachable while sampling advertised fixtures (stopped at ${id})`);
+      }
+      attempted += 1;
+      // 201 is the claim honoured. A 4xx that names the workflow as unknown is
+      // the drift this leg exists to catch; any other status is a different
+      // problem and is not judged here.
+      if (res.status !== 201) unreachable.push(`${id} → ${res.status}`);
+    }
+    if (attempted === 0) return softSkip('blocked', 'no advertised fixture could be attempted');
+    expect(
+      unreachable,
+      req(ID, DOC, `an advertised fixture MUST be creatable: fixtures[] gates whether a scenario runs at all, so a listed-but-unseeded fixture makes some OTHER scenario fail on a run that cannot exist, and the failure is attributed to the wrong requirement (${unreachable.length} of ${attempted} sampled: ${unreachable.join(', ')})`),
+    ).toEqual([]);
+  });
+});

package/src/scenarios/v2-era-2-append-vocabulary.test.ts

@@ -0,0 +1,140 @@
+/**
+ * RFC 0176 §A / `spec/v2/core/persistence.md` §The writer rule — an append to a
+ * run in era `2` uses v1 vocabulary (suite 2.0.0, target major 2; seam-gated).
+ *
+ * The reader rule translates an era-`2` log through the codemap at the storage
+ * boundary. That is only coherent if the log stays in ONE vocabulary: the era
+ * key is fixed at run creation and fixes the log's vocabulary for the run's
+ * lifetime. A host that upgrades while runs are open and then begins writing v2
+ * names into an era-`2` log breaks the reader two ways — a renamed type gets
+ * mapped a second time, and a v2-only name is not on the codemap's v1 side at
+ * all, so the read fails with `event_type_unmapped`.
+ *
+ * This is not a hypothetical for a host with human-approval interrupts, where a
+ * run can stay open for days across a deploy. Draining era-`2` runs before
+ * serving v2 is explicitly not the path (`persistence.md` §"Runs pinned to v1"),
+ * so the writer rule is what makes an in-flight run safe across the cut.
+ *
+ * The witness: seed an era-`2` run that is still `running`, drive one canonical
+ * mutation so the HOST's own writer appends a terminal event, then read the
+ * whole log back under major 2. A host that appended in v1 vocabulary reads
+ * back cleanly; a host that appended in v2 vocabulary fails the read or returns
+ * a type the closed v2 registry does not carry.
+ *
+ * @see spec/v2/core/persistence.md §The writer rule
+ * @see RFCS/0176-v2-persisted-data-and-coexistence.md §A
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { v2Discovery } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { readErrorCode } from '../lib/error-envelope.js';
+import { codemapV1toV2, era2Gate, eventsOf, pollEvents, seedEra2Log, v1FixtureLog, type ReadEvent } from '../lib/era2-seed.js';
+
+const ID = 'openwop.requirement.0176.era-2-append-vocabulary';
+const DOC = 'spec/v2/core/persistence.md §The writer rule';
+
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> {
+  try {
+    return await fn();
+  } catch {
+    return null;
+  }
+}
+
+describe('v2-era-2-append-vocabulary (RFC 0176 §A — the writer rule)', () => {
+  it('a host append to an open era-2 run keeps the log in v1 vocabulary, so the whole log still reads', async () => {
+    const doc = await v2Discovery().catch(() => null);
+    const gate = era2Gate(doc);
+    if (gate !== null && !gate.ok) return softSkip(gate.kind, gate.reason);
+
+    // An era-2 log that is still OPEN: `running`, not `completed`. A completed
+    // run is never appended to, so it cannot witness the writer rule.
+    const seeded = await seedEra2Log(v1FixtureLog().slice(0, 2), 'running');
+    if (!seeded.ok) return softSkip(seeded.kind, seeded.reason);
+    const runId = seeded.runId;
+
+    const before = await pollEvents(runId);
+    if (before === null || before.status !== 200) {
+      return softSkip('blocked', `GET /runs/${runId}/events/poll answered ${before?.status ?? 'no response'} on the seeded era-2 run — the log cannot be read back`);
+    }
+    const seedCount = eventsOf(before).length;
+
+    // One canonical mutation so the HOST's own writer appends. Cancel is the
+    // universally available terminal transition; a host that refuses it on a
+    // seeded run records `blocked` rather than a pass.
+    const cancelled = await http(() => driver.post(`/runs/${encodeURIComponent(runId)}/cancel`, {}));
+    if (cancelled === null || (cancelled.status !== 200 && cancelled.status !== 202 && cancelled.status !== 204)) {
+      return softSkip('blocked', `POST /runs/{runId}/cancel answered ${cancelled?.status ?? 'no response'} on a seeded era-2 run — no canonical mutation drove the host's writer, so the append is unwitnessed`);
+    }
+
+    const after = await pollEvents(runId);
+    if (after === null) return softSkip('blocked', 'the event read failed after the append');
+
+    // Failure mode 1: the read itself refuses. A host that wrote a v2-only name
+    // into an era-2 log produces a type the codemap cannot map FROM.
+    if (after.status !== 200) {
+      const code = readErrorCode(after.json);
+      expect(
+        code,
+        req(ID, DOC, `reading the era-2 log after the host's own append failed with ${after.status} ${String(code)} — an append in v2 vocabulary is exactly what makes a translated read fail, and the era key fixes the log's vocabulary for the run's lifetime`),
+      ).toBe(null);
+      return softSkip('blocked', `the era-2 read failed with ${after.status} after the host's own append — the assertion above already recorded the refusal`);
+    }
+
+    const rows = eventsOf(after) as ReadEvent[];
+    expect(
+      rows.length,
+      req(ID, DOC, `the append MUST be visible in the log (seeded ${seedCount}, read ${rows.length} after cancel)`),
+    ).toBeGreaterThan(seedCount);
+
+    // Failure mode 2: the read succeeds but returns a name the v2 registry does
+    // not carry — a v1 name that survived untranslated because it was written
+    // after the upgrade and the host treated the log as era 3.
+    const v2Names = new Set(codemapV1toV2().values());
+    const v1Names = new Set(codemapV1toV2().keys());
+    for (const row of rows.slice(seedCount)) {
+      const type = String(row.type ?? '');
+      // A renamed type is the discriminator: its v1 spelling must NOT appear on
+      // the wire, because every reader translates an era-2 log.
+      const renamedV1 = v1Names.has(type) && !v2Names.has(type);
+      expect(
+        renamedV1,
+        req(ID, DOC, `the appended event reads as its v2 name, not its v1 spelling (${type}) — every reader translates an era-2 log, so a v1 name reaching the wire means the append bypassed the storage boundary`),
+      ).toBe(false);
+    }
+
+    // Sequence stays contiguous across the era boundary the append crosses.
+    const seqs = rows.map((r) => Number(r.sequence)).sort((a, b) => a - b);
+    for (let i = 0; i < seqs.length; i++) {
+      expect(
+        seqs[i],
+        req(ID, DOC, `the appended rows continue the seeded sequence space without a gap or restart (expected ${i}, got ${String(seqs[i])})`),
+      ).toBe(i);
+    }
+  });
+
+  it('the run keeps the era it was created with; an append does not promote it to era 3', async () => {
+    const doc = await v2Discovery().catch(() => null);
+    const gate = era2Gate(doc);
+    if (gate !== null && !gate.ok) return softSkip(gate.kind, gate.reason);
+
+    const seeded = await seedEra2Log(v1FixtureLog().slice(0, 2), 'running');
+    if (!seeded.ok) return softSkip(seeded.kind, seeded.reason);
+    const runId = seeded.runId;
+
+    await http(() => driver.post(`/runs/${encodeURIComponent(runId)}/cancel`, {}));
+
+    const snap = await http(() => driver.get(`/runs/${encodeURIComponent(runId)}`));
+    if (snap === null || snap.status !== 200) {
+      return softSkip('blocked', `GET /runs/{runId} answered ${snap?.status ?? 'no response'} — the era key cannot be read back`);
+    }
+    const era = (snap.json as { eventLogSchemaVersion?: unknown } | null)?.eventLogSchemaVersion;
+    expect(
+      era === undefined || era === 2,
+      req(ID, DOC, `the era key is fixed at run creation: a run seeded in era 2 and then appended to MUST still read as era 2 (got ${String(era)}) — promoting it to 3 would strand the seeded rows in a vocabulary the reader no longer translates`),
+    ).toBe(true);
+  });
+});

package/src/scenarios/v2-era-stamp-universal.test.ts

@@ -0,0 +1,103 @@
+/**
+ * RFC 0176 §A.7 / `spec/v2/core/persistence.md` §The era key — every creation
+ * path stamps the same era, and discovery advertises that one value (suite
+ * 2.0.0, target major 2; unaided).
+ *
+ * The era trichotomy (absent ⇒ `2`, `2` = v1 era, `3` = v2 era) is sound only
+ * because a v2 host stamps `3` on EVERY run it creates. A host with more than
+ * one creation path that leaves one unstamped produces runs indistinguishable
+ * from pre-cut runs, and every reader translates them as era `2` — a silent
+ * wrong read, not an error. A tier-2 host found exactly this shape in review:
+ * one creation path writing `2`, another writing nothing, and discovery
+ * advertising `1`, a value no path wrote.
+ *
+ * This is witnessable unaided because the host's own discovery document states
+ * the value it claims to write, and a run created through the canonical path
+ * states what it actually wrote. A disagreement between them is the defect.
+ *
+ * @see spec/v2/core/persistence.md §The era key
+ * @see RFCS/0176-v2-persisted-data-and-coexistence.md §A
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { v2Discovery } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+const ID = 'openwop.requirement.0176.era-stamp-universal';
+const DOC = 'spec/v2/core/persistence.md §The era key';
+
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> {
+  try {
+    return await fn();
+  } catch {
+    return null;
+  }
+}
+
+describe('v2-era-stamp-universal (RFC 0176 §A.7)', () => {
+  it('discovery advertises an era the host actually writes, and a new run carries it', async () => {
+    const doc = await v2Discovery().catch(() => null);
+    if (!doc) return softSkip('blocked', 'v2 discovery unreachable');
+
+    const advertised = doc['eventLogSchemaVersion'];
+    if (advertised === undefined) {
+      return softSkip('inapplicable', 'the host advertises no eventLogSchemaVersion — the era axis is undeclared, so there is no claim to falsify here');
+    }
+    expect(
+      typeof advertised === 'number' && Number.isInteger(advertised),
+      req(ID, DOC, `eventLogSchemaVersion is the era key and MUST be an integer (got ${JSON.stringify(advertised)})`),
+    ).toBe(true);
+
+    const created = await http(() => driver.post('/runs', { workflowId: 'conformance-noop', inputs: {} }));
+    if (created === null || created.status !== 201) {
+      return softSkip('blocked', `POST /runs answered ${created?.status ?? 'no response'} — a run the host created is what states the era it actually writes`);
+    }
+    const runId = (created.json as { runId?: unknown } | null)?.runId;
+    if (typeof runId !== 'string') return softSkip('blocked', 'POST /runs returned no runId');
+
+    const snap = await http(() => driver.get(`/runs/${encodeURIComponent(runId)}`));
+    if (snap === null || snap.status !== 200) {
+      return softSkip('blocked', `GET /runs/{runId} answered ${snap?.status ?? 'no response'} — the snapshot is where the written era is reported`);
+    }
+    const written = (snap.json as { eventLogSchemaVersion?: unknown } | null)?.eventLogSchemaVersion;
+
+    // The snapshot field is REQUIRED on the wire and may be synthesized for an
+    // era-2 run, but a run this host just created is not era 2 — it is whatever
+    // the host writes for new runs, which is the value discovery names.
+    expect(
+      written,
+      req(ID, DOC, `the run snapshot MUST carry the era key — it is required on the wire, synthesized from absent-⇒-2 for historical runs and stated outright for a run the host just created (got ${JSON.stringify(written)})`),
+    ).not.toBeUndefined();
+
+    expect(
+      written,
+      req(ID, DOC, `discovery MUST advertise the value the host writes for new runs and nothing else: discovery says ${JSON.stringify(advertised)}, the run it just created says ${JSON.stringify(written)}. A host whose creation paths disagree has no single value to advertise, and whatever it publishes is false for some of its own runs`),
+    ).toBe(advertised);
+  });
+
+  it('a v2-era host stamps 3, so its new runs are never read as the v1 era', async () => {
+    const doc = await v2Discovery().catch(() => null);
+    if (!doc) return softSkip('blocked', 'v2 discovery unreachable');
+    const advertised = doc['eventLogSchemaVersion'];
+    if (advertised === undefined) return softSkip('inapplicable', 'the host advertises no eventLogSchemaVersion');
+    if (advertised !== 3) {
+      return softSkip('inapplicable', `the host advertises era ${JSON.stringify(advertised)}, not 3 — this scenario checks that the advertised value AGREES with what the creation paths write, whatever that value is. Whether it MUST be 3 is v2-era-key's assertion, not this one; a host reached under target major 2 is a v2 host and persistence.md requires 3 there`);
+    }
+
+    const created = await http(() => driver.post('/runs', { workflowId: 'conformance-noop', inputs: {} }));
+    if (created === null || created.status !== 201) {
+      return softSkip('blocked', `POST /runs answered ${created?.status ?? 'no response'}`);
+    }
+    const runId = (created.json as { runId?: unknown } | null)?.runId;
+    if (typeof runId !== 'string') return softSkip('blocked', 'POST /runs returned no runId');
+    const snap = await http(() => driver.get(`/runs/${encodeURIComponent(runId)}`));
+    if (snap === null || snap.status !== 200) return softSkip('blocked', `GET /runs/{runId} answered ${snap?.status ?? 'no response'}`);
+
+    expect(
+      (snap.json as { eventLogSchemaVersion?: unknown } | null)?.eventLogSchemaVersion,
+      req(ID, DOC, 'a host advertising era 3 MUST stamp 3 on every run it creates — an unstamped run made after the cut is indistinguishable from a pre-cut run and every reader translates it as era 2, which is a silent wrong read rather than an error'),
+    ).toBe(3);
+  });
+});

package/src/scenarios/v2-interrupt-token-scheme.test.ts

@@ -40,7 +40,7 @@ describe('v2 interrupt-token-scheme (RFC 0170 §E.1)', () => {
     if (res === null) return softSkip('blocked', 'GET /interrupts/{token} unreachable (fetch failed)');
     expect([401, 404].includes(res.status), req('openwop.requirement.0170.interrupt-token-scheme.unprefixed-refused', DOC, `a token outside the ow2.<alg>.<kid>.<payload>.<mac> grammar MUST NOT resolve — 401 interrupt_token_invalid (or 404 not_found where the signed-token surface is not mounted); got ${res.status}`)).toBe(true);
     const code = readErrorCode(res.json);
-    expect(res.status === 401 ? code === 'interrupt_token_invalid' : code === 'not_found', req('openwop.requirement.0170.interrupt-token-scheme.unprefixed-refused', 'spec/v2/core/interrupt.md §Tokens', `the refusal MUST carry its registered code (401 → interrupt_token_invalid, 404 → not_found); got ${String(code)}`)).toBe(true);
+    expect(res.status === 401 ? code === 'interrupt_token_invalid' : (code === 'not_found' || code === 'interrupt_not_found'), req('openwop.requirement.0170.interrupt-token-scheme.unprefixed-refused', 'spec/v2/core/interrupt.md §Tokens', `the refusal MUST carry a registered code (401 → interrupt_token_invalid; 404 → not_found OR the more precise interrupt_not_found, both registered in spec/v2/errors.json for this state — a scenario narrower than its own registry fails the host that answers more precisely); got ${String(code)}`)).toBe(true);
   });
 
   it('a well-formed token under a kid the host does not hold is 401 interrupt_token_invalid', async () => {

package/src/scenarios/v2-version-header-honored.test.ts

@@ -0,0 +1,124 @@
+/**
+ * RFC 0172 §A.3 — the `OpenWOP-Version` header is HONORED or REFUSED, never
+ * ignored (suite 2.0.0, target major 2; unaided).
+ *
+ * A host that does not implement v2 has two correct answers to
+ * `OpenWOP-Version: 2`: serve the v2 representation, or refuse with `406
+ * protocol_version_unsupported`. There is a third thing it can do, and it is
+ * the dangerous one — return `200` with the v1 document, ignoring the header
+ * entirely.
+ *
+ * That third case is invisible to every presence-gated scenario in the suite.
+ * A scenario that skips when a v2 shape is absent records `inapplicable`
+ * whether the host REFUSED major 2 or silently handed back v1; both are
+ * non-failures, so a bundle looks clean while witnessing nothing. This is not
+ * hypothetical: it is the shape that let RFC 0165 sit `Accepted` on a host
+ * that served none of it — the acceptance cited merged PRs, the gated
+ * scenarios recorded `inapplicable`, and nothing in the chain ever compared
+ * the two representations. Measured on a live tier-1 host 2026-09-04:
+ * `OpenWOP-Version: 2` returned `200` with a body byte-identical to the
+ * header-less fetch. Credit to the openwop-app session for the probe.
+ *
+ * The check is cheap and needs no v2 support: fetch the resource twice, once
+ * with the header and once without. A host advertising two majors MUST NOT
+ * return the same bytes for both, because the two representations differ by
+ * construction (`capabilities.md` §1). A host advertising one major MUST
+ * refuse rather than ignore.
+ *
+ * @see spec/v2/core/versioning.md §1.3
+ * @see RFCS/0172-v2-versioning-and-release.md §A.3
+ */
+
+import { describe, it, expect } from 'vitest';
+import { loadEnv } from '../lib/env.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+const ID = 'openwop.requirement.0172.version-header-honored';
+const DOC = 'spec/v2/core/versioning.md §1.3';
+const PATH = '/.well-known/openwop';
+
+interface Fetched {
+  readonly status: number;
+  readonly body: string;
+  readonly version: string | null;
+}
+
+async function fetchRepresentation(header: string | null): Promise<Fetched | null> {
+  const { baseUrl, apiKey } = loadEnv();
+  const headers: Record<string, string> = { Accept: 'application/json' };
+  if (header !== null) headers['OpenWOP-Version'] = header;
+  if (apiKey) headers['authorization'] = `Bearer ${apiKey}`;
+  try {
+    const res = await fetch(`${baseUrl.replace(/\/$/, '')}${PATH}`, { headers });
+    return { status: res.status, body: await res.text(), version: res.headers.get('openwop-version') };
+  } catch {
+    return null;
+  }
+}
+
+describe('v2-version-header-honored (RFC 0172 §A.3)', () => {
+  it('OpenWOP-Version is honored or refused — never ignored', async () => {
+    const bare = await fetchRepresentation(null);
+    const asked = await fetchRepresentation('2.0');
+    if (bare === null || asked === null) {
+      return softSkip('blocked', `${PATH} unreachable for one of the two probes — the comparison needs both`);
+    }
+    if (bare.status !== 200) {
+      return softSkip('blocked', `the header-less GET ${PATH} answered ${bare.status}; there is no baseline representation to compare against`);
+    }
+
+    // A refusal is a correct answer and ends the check: the host has told the
+    // truth about not serving major 2.
+    if (asked.status === 406) {
+      expect(
+        asked.status,
+        req(ID, DOC, 'a host that does not serve major 2 MUST refuse with 406 protocol_version_unsupported, which it did'),
+      ).toBe(406);
+      return softSkip('inapplicable', 'the host refused major 2 with the specified 406 — a correct answer, and there is no second representation to compare bytes against');
+    }
+    if (asked.status !== 200) {
+      return softSkip('blocked', `GET ${PATH} with OpenWOP-Version: 2.0 answered ${asked.status} — neither the v2 representation (200) nor the specified refusal (406), so this scenario cannot rule on it`);
+    }
+
+    // 200 means the host claims to have served major 2. The bytes decide
+    // whether it actually did.
+    expect(
+      asked.body === bare.body,
+      req(ID, DOC, `answering 200 to OpenWOP-Version: 2.0 with a body byte-identical to the header-less fetch means the header was IGNORED, not honored — the host served v1 and called it v2. Refusing with 406 is the correct answer for a host that does not implement major 2; silently returning v1 is the one answer that no presence-gated scenario can detect, because an absent v2 shape records \`inapplicable\` whether the host refused or ignored`),
+    ).toBe(false);
+  });
+
+  it('a host advertising two majors serves two different representations', async () => {
+    const bare = await fetchRepresentation(null);
+    if (bare === null || bare.status !== 200) {
+      return softSkip('blocked', `the header-less GET ${PATH} answered ${bare?.status ?? 'no response'}`);
+    }
+    let doc: Record<string, unknown>;
+    try {
+      doc = JSON.parse(bare.body) as Record<string, unknown>;
+    } catch {
+      return softSkip('blocked', `${PATH} did not return a JSON object`);
+    }
+    const versions = Array.isArray(doc['protocolVersions']) ? (doc['protocolVersions'] as unknown[]).map(String) : [];
+    const majors = new Set(versions.map((v) => v.split('.')[0]));
+    if (!(majors.has('1') && majors.has('2'))) {
+      return softSkip('inapplicable', `the host advertises [${versions.join(', ') || 'no protocolVersions'}] — one major or none, so there is no second representation to differ from`);
+    }
+
+    const asked = await fetchRepresentation('2.0');
+    if (asked === null) return softSkip('blocked', `${PATH} unreachable under OpenWOP-Version: 2.0`);
+    expect(
+      asked.status,
+      req(ID, DOC, `a host advertising both majors MUST serve major 2 when asked for it, not refuse (got ${asked.status})`),
+    ).toBe(200);
+    expect(
+      asked.body === bare.body,
+      req(ID, DOC, 'the v1 document and the closed v2 root differ by construction (capabilities.md §1), so a host advertising both majors returning identical bytes for both has advertised a major it does not actually serve'),
+    ).toBe(false);
+    expect(
+      asked.version?.trim().split('.')[0] ?? null,
+      req(ID, DOC, `the response to OpenWOP-Version: 2.0 MUST carry OpenWOP-Version naming the major it served (got ${String(asked.version)})`),
+    ).toBe('2');
+  });
+});