@openwop/openwop-conformance 2.0.0-rc.2 → 2.0.0-rc.28

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.2",
+  "version": "2.0.0-rc.28",
   "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": "7997be82785d963789a452f76455dd91f51a03c227e83706325a8b67d3d16aeb",
-    "api/v2/asyncapi.yaml": "aeed4cbeb832cfcd4de46639a2b5a8981406d307b73e3a9d11a645eb0726caff",
-    "api/v2/openapi.yaml": "cbbf5df16473902c3c36b5b048ba80b5b35336c06fd48c8ba32f4b1858dd1807",
+    "api/seams-v2.yaml": "d92f0832250f7e2943304c3ebb3b4ac4d94a627a5f275a8cd29f608cae48f920",
+    "api/v2/asyncapi.yaml": "917d25c0c03d418b43b778423182de1aaa2f7b4f30a175bdeab3b7d3ffdb894a",
+    "api/v2/openapi.yaml": "ccd9e6a5dd8084c6d6c0959157f447da96fc7493cad2479abbf97b69483f9404",
     "api/v2/redocly.yaml": "1e66b60e6118ad11a823bb620678be464d99dfe50a40e3e6f93ec9429b88b34c",
     "schemas/README.md": "0c0b737ffcf8f30e7d2809cec8a498232de710f41443212922ad8337cdde0b51",
     "schemas/a2a-task-state.schema.json": "c9365918f993f943b4b619d42551eb066a1ed33a08d895d51b395432a5b1f1bc",
@@ -31,8 +31,8 @@
     "schemas/artifact-type-pack-manifest.schema.json": "13932ea58e819e01b3a0cc7a65590b70683dd5fe9208fc06c64c339943d3c4ce",
     "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/capabilities.schema.json": "b413e0235cad412081df09234237e0f322a85903b7411b91aaff54032e946671",
+    "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",
@@ -86,7 +86,7 @@
     "schemas/run-event.schema.json": "c70c06932b9831295042836213e617c8e946f20ddd49cf4e889b74d89d2175a8",
     "schemas/run-options.schema.json": "f8241ece6ddc6527de9160d811d42c231b4f77b935f2e107b3c05608545c59ab",
     "schemas/run-orchestrator-decided-event.schema.json": "17a43a3c44680a24d411141357a867b3caed6107d56de88fe2e062eaf93fa2c1",
-    "schemas/run-snapshot.schema.json": "8a45f997beec0a2fa596f4631129a869cfbc37c9ad38583530ed11655301d2ab",
+    "schemas/run-snapshot.schema.json": "3343550f6973a0975c61624df569d341e843ac8592a2aa2b3b7cf540d72563ad",
     "schemas/security-advisory.schema.json": "9c550f0bf10a3193dcca4a127081fb66fe5dc1b6f729c4c17bfaea3ba3ce05fc",
     "schemas/self-hosted-runner-dispatch-frame.schema.json": "3f1d7edd572c6747657299525d8e85329b93b6fadf670e3a19c74d53e725adec",
     "schemas/self-hosted-runner-registration.schema.json": "6c781adf1bb915a9e47796494f4a527353cbbf72b480e5a05be4aac65a6d0c6e",
@@ -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,19 +198,19 @@
     "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": "6d0dd7cec8085554565060d2b5ed3abdcd3d13d9940404de33cac17633f3c23a",
+    "spec/v1/core-standard-manifest.json": "bd06beb20cc52f8558e8b72598becb380e3159bb842f13389bcf92619f1fad23",
     "spec/v1/deprecations.json": "520d79927a8ed43ccf62c207a7cf6cf7b19b16e00bbbbdf0410667e939c19d85",
     "spec/v1/deprecations.schema.json": "4cdbbb8eb9c0092913a5704c943880f0c8581bcf0f640a7df5a84105d53c8aee",
     "spec/v1/event-codemap.json": "3da60d884157793a360da532a9fcbbfb5285636db325a74cec94b34622186d97",
     "spec/v1/event-codemap.schema.json": "d52caf29071e3784d4c20259cdbd5a7b533986548a440bb632a80b82cadd7ea5",
-    "spec/v1/extensions.json": "4d7ba68bae7c7f50cc655b94646ad25945a5dd63b703d43c1d015470141cd668",
+    "spec/v1/extensions.json": "79a60754aa16cbdbdb604f8e5c00038af535a1690a4d07bd5ff7c38f0256a7bc",
     "spec/v1/gaps.json": "96ca051cb20f1a669b355d67a89421c56fef28aa5e6710c9519f592f26af33a3",
     "spec/v1/gaps.schema.json": "8fd83259f556553c9df0f53e7a82ca8c2a4771d471197f69b4e2ae0ceeacfd66",
     "spec/v1/migrations.json": "8839497d6a4830b53fa7867014a8336f0d725ef2346352e54fb580b7947897af",
     "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": "ef05b0ec4ef4296dfbbacf37e97612b3c1f8d11b701890caa7b9c8462eab8359"
+    "spec/v2/release.json": "20a6cb7efde5fcdbbc2b663976882b6dec93ec52556d422de7290e25906f2748"
   },
-  "corpusCommit": "18c32663eb8acfe76d9b5906f69c82ed214987e0"
+  "corpusCommit": "e9aa9131f3d64f814b2c0ca16535675968efad76"
 }

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/global-setup.ts

@@ -75,6 +75,17 @@ export function setup(): void {
   // Suite 2.0.0: in the published layout the contract is the spec-artifacts peer (RFC 0168 §D.2).
   const stamp = LAYOUT === 'published' ? verifyPeerContract(PKG_ROOT_PATH) : verifyCorpusStamp(PKG_ROOT_PATH, LAYOUT);
   process.stderr.write(`${describeVerdict(stamp)}\n`);
+  // A version skew and a digest mismatch both have to refuse, but they are
+  // different faults with different fixes, and reporting them in the same words
+  // sends the reader to debug a corrupt install when nothing is corrupt.
+  if (stamp.kind === 'peer-version') {
+    throw new Error(
+      `openwop-conformance: refusing to run — this suite was packed against @openwop/spec-artifacts@${stamp.lockVersion}, ` +
+      `but @openwop/spec-artifacts@${stamp.peerVersion} is installed. They are declared EXACT peers. ` +
+      `Install both at the same explicit version; do NOT install at a dist-tag such as \`next\`, which moves per package ` +
+      `and can name a pair that was never published together.`,
+    );
+  }
   if (stamp.kind === 'mismatch') {
     throw new Error('openwop-conformance: refusing to run — schemas/CORPUS-STAMP.json digests do not match the vendored api/ + schemas/ files. Reinstall the package; do not hand-patch vendored contract files.');
   }

package/src/lib/corpus-stamp.ts

@@ -39,7 +39,17 @@ export interface CorpusStamp {
 export type StampVerdict =
   | { readonly kind: 'verified'; readonly files: number }
   | { readonly kind: 'not-applicable'; readonly reason: string }
-  | { readonly kind: 'mismatch'; readonly missing: readonly string[]; readonly altered: readonly string[]; readonly extra: readonly string[] };
+  | { readonly kind: 'mismatch'; readonly missing: readonly string[]; readonly altered: readonly string[]; readonly extra: readonly string[] }
+  /**
+   * The peer is INSTALLED and INTACT but is a different version than the suite
+   * was packed against. Its own kind because the remedy is completely different
+   * from a digest mismatch — nothing is corrupt, two versions are simply out of
+   * step — and because the generic message sends readers to debug a broken
+   * install. Reported by a tier-2 host that hit it through the `next` dist-tag:
+   * the tag moves per package, so `@next` can name an exact-peer PAIR that was
+   * never published together.
+   */
+  | { readonly kind: 'peer-version'; readonly peerVersion: string; readonly lockVersion: string };
 
 export const STAMP_RELATIVE_PATH = join('schemas', 'CORPUS-STAMP.json');
 
@@ -94,7 +104,11 @@ export function verifyPeerContract(pkgRoot: string): StampVerdict {
   if (!existsSync(stampPath)) return { kind: 'mismatch', missing: ['@openwop/spec-artifacts/CORPUS-STAMP.json'], altered: [], extra: [] };
   const stamp = JSON.parse(readFileSync(stampPath, 'utf8')) as { package: string; version: string; files: Record<string, string> };
   const digest = createHash('sha256').update(JSON.stringify({ package: stamp.package, version: stamp.version, files: stamp.files })).digest('hex');
-  if (stamp.version !== lock.version || digest !== lock.stampSha256) return { kind: 'mismatch', missing: [], altered: [`@openwop/spec-artifacts ${stamp.version} (digest ${digest.slice(0, 12)}) ≠ the suite's lock ${lock.version} (${lock.stampSha256.slice(0, 12)})`], extra: [] };
+  // A plain version difference is NOT corruption; report it as itself so the
+  // message names the two versions and the fix, instead of sending the reader
+  // to hunt a damaged install.
+  if (stamp.version !== lock.version) return { kind: 'peer-version', peerVersion: stamp.version, lockVersion: lock.version };
+  if (digest !== lock.stampSha256) return { kind: 'mismatch', missing: [], altered: [`@openwop/spec-artifacts ${stamp.version} stamp digest ${digest.slice(0, 12)} ≠ the suite's lock ${lock.stampSha256.slice(0, 12)} — same version, different contents`], extra: [] };
   const missing: string[] = []; const altered: string[] = [];
   for (const [rel, d] of Object.entries(stamp.files)) { const p = join(peerRoot, ...rel.split('/')); if (!existsSync(p)) missing.push(rel); else if (sha256File(p) !== d) altered.push(rel); }
   if (missing.length || altered.length) return { kind: 'mismatch', missing, altered, extra: [] };
@@ -143,6 +157,14 @@ export function describeVerdict(v: StampVerdict): string {
       return `[openwop-conformance] corpus stamp VERIFIED — ${v.files} vendored api/ + schemas/ files match their SHA-256 digests`;
     case 'not-applicable':
       return `[openwop-conformance] corpus stamp not checked — ${v.reason}`;
+    case 'peer-version':
+      return (
+        `[openwop-conformance] peer version MISMATCH — this suite was packed against ` +
+        `@openwop/spec-artifacts@${v.lockVersion} but @openwop/spec-artifacts@${v.peerVersion} is installed. ` +
+        `Nothing is corrupt: the two are declared EXACT peers and are simply out of step. ` +
+        `Install both at the same explicit version — never at a dist-tag such as \`next\`, which moves per package ` +
+        `and can therefore name a pair that was never published together.`
+      );
     case 'mismatch':
       return (
         `[openwop-conformance] corpus stamp MISMATCH — the vendored contract is not the one this suite shipped ` +

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/era-key-stamped-v1.test.ts

@@ -0,0 +1,156 @@
+/**
+ * `spec/v1/version-negotiation.md` §Stamping / §Legacy detection — the two
+ * run-document stamping MUSTs, and the legacy rule that makes their absence
+ * actively harmful (suite 2.0.0, target major 1; unaided).
+ *
+ * The rule is a v1 `MUST` and has been since the contract was written:
+ *
+ *   §Stamping        "Every persisted run document MUST carry an
+ *                     `eventLogSchemaVersion: number` field. The current v1
+ *                     value is `2`."
+ *   §Legacy detection "Hosts identify an older run document as legacy when
+ *                     `eventLogSchemaVersion` is undefined or `< 2`" … legacy
+ *                     runs have "no event subcollection … Readers MUST fall
+ *                     back to the snapshot for state."
+ *
+ * **Nothing in the suite has ever asserted it.** `version-negotiation.test.ts`
+ * opens by claiming it checks "the four version axes (`engineVersion`,
+ * `eventLogSchemaVersion`, per-event `schemaVersion`, `pinnedVersions`) appear
+ * where the spec says they should" — and `protocolVersion` is the only axis it
+ * asserts. Across all 444 v1 scenario files the sole occurrence of the
+ * identifier `eventLogSchemaVersion` was that sentence: a docstring describing
+ * a check that does not exist. **A comment claiming coverage is worse than no
+ * comment**, because it answers "is this tested?" for anyone who greps, and
+ * answers it wrongly.
+ *
+ * Both production hosts were measured on 2026-09-04 and neither stamps the
+ * field on any run it has ever served. Each found it independently, after the
+ * other published its own greps.
+ *
+ * The consequence fails in the direction that punishes correctness. A client
+ * following §Legacy detection exactly classifies every such run as legacy and
+ * reads the snapshot — **ignoring the event log the host is in fact serving**.
+ * The host under-serves the conforming reader and over-serves the careless one.
+ *
+ * Why the schema could not catch it: `run-snapshot.schema.json` requires only
+ * `runId`, `workflowId` and `status`, so a snapshot missing the field validates
+ * cleanly. The obligation is prose-only, which is exactly the shape that needs
+ * a scenario rather than a keyword.
+ *
+ * @see spec/v1/version-negotiation.md §Stamping
+ * @see spec/v1/version-negotiation.md §Legacy detection
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+const ID_STAMPED = 'openwop.requirement.version-negotiation.era-key-stamped';
+const ID_NOT_LEGACY = 'openwop.requirement.version-negotiation.era-key-not-legacy';
+const ID_ENGINE = 'openwop.requirement.version-negotiation.engine-version-stamped';
+const DOC = 'spec/v1/version-negotiation.md §Stamping';
+
+interface Snapshot { readonly eventLogSchemaVersion?: unknown; readonly engineVersion?: unknown }
+
+/** A run this host created moments ago — the one case where "legacy" cannot apply. */
+async function freshRun(): Promise<{ runId: string } | { skip: string }> {
+  try {
+    // v1 path keys are explicit: the driver's unversioned rewrite is a major-2
+    // behaviour, and `/runs` answers 404 on a v1 host. The first version of this
+    // file used `/runs` and therefore SOFT-SKIPPED against a host that violates
+    // the rule — passing vacuously, which is the failure this scenario exists to
+    // catch, committed by the scenario itself.
+    const created = await driver.post('/v1/runs', { workflowId: 'conformance-noop', inputs: {} });
+    if (created.status !== 201) return { skip: `POST /v1/runs answered ${created.status} — no run to inspect` };
+    const runId = (created.json as { runId?: unknown } | null)?.runId;
+    if (typeof runId !== 'string') return { skip: 'POST /v1/runs returned no runId' };
+    return { runId };
+  } catch {
+    return { skip: 'POST /v1/runs unreachable' };
+  }
+}
+
+describe('era-key-stamped-v1 (version-negotiation.md §Stamping)', () => {
+  it('a run the host just created carries eventLogSchemaVersion', async () => {
+    const r = await freshRun();
+    if ('skip' in r) return softSkip('blocked', r.skip);
+
+    let snap;
+    try {
+      snap = await driver.get(`/v1/runs/${encodeURIComponent(r.runId)}`);
+    } catch {
+      return softSkip('blocked', 'GET /v1/runs/{runId} unreachable');
+    }
+    if (snap.status !== 200) return softSkip('blocked', `GET /v1/runs/{runId} answered ${snap.status}`);
+
+    const value = (snap.json as Snapshot | null)?.eventLogSchemaVersion;
+    expect(
+      value,
+      req(ID_STAMPED, DOC, 'every persisted run document MUST carry an eventLogSchemaVersion — the field is prose-only (run-snapshot.schema.json requires just runId, workflowId and status), so a snapshot without it validates cleanly and only this check can see its absence'),
+    ).not.toBeUndefined();
+    expect(
+      typeof value === 'number',
+      req(ID_STAMPED, DOC, `eventLogSchemaVersion MUST be a number (got ${JSON.stringify(value)})`),
+    ).toBe(true);
+  });
+
+  it('a freshly created run is not classified legacy by the host\'s own rule', async () => {
+    const r = await freshRun();
+    if ('skip' in r) return softSkip('blocked', r.skip);
+
+    let snap;
+    try {
+      snap = await driver.get(`/v1/runs/${encodeURIComponent(r.runId)}`);
+    } catch {
+      return softSkip('blocked', 'GET /v1/runs/{runId} unreachable');
+    }
+    if (snap.status !== 200) return softSkip('blocked', `GET /v1/runs/{runId} answered ${snap.status}`);
+    const value = (snap.json as Snapshot | null)?.eventLogSchemaVersion;
+    if (value === undefined) {
+      return softSkip('blocked', 'the field is absent — the stamping leg above records that; legacy classification cannot be judged separately from it');
+    }
+
+    // §Legacy detection: "undefined or < 2" is legacy, and a legacy run means
+    // "no event subcollection … Readers MUST fall back to the snapshot". A host
+    // that serves an event log while stamping a legacy value is telling a
+    // conforming client to ignore the log it is serving.
+    expect(
+      typeof value === 'number' && value >= 2,
+      req(ID_NOT_LEGACY, 'spec/v1/version-negotiation.md §Legacy detection', `a run created moments ago MUST NOT be legacy: legacy is "undefined or < 2", and a legacy run is specified to have no event subcollection so readers MUST fall back to the snapshot. Stamping ${JSON.stringify(value)} on a new run instructs a CONFORMING client to ignore the event log this host is serving it — the failure lands on the correct reader and spares the careless one`),
+    ).toBe(true);
+  });
+
+  it('a run the host just created carries engineVersion — the legacy escape cannot reach it', async () => {
+    const r = await freshRun();
+    if ('skip' in r) return softSkip('blocked', r.skip);
+
+    let snap;
+    try {
+      snap = await driver.get(`/v1/runs/${encodeURIComponent(r.runId)}`);
+    } catch {
+      return softSkip('blocked', 'GET /v1/runs/{runId} unreachable');
+    }
+    if (snap.status !== 200) return softSkip('blocked', `GET /v1/runs/{runId} answered ${snap.status}`);
+
+    // §Stamping: "Every persisted run document MUST carry an `engineVersion:
+    // number` field … Servers MAY omit this field on legacy runs that predate
+    // the contract." The escape is scoped to runs that PREDATE the contract, so
+    // it cannot cover a run created seconds ago — which is why this leg creates
+    // one rather than inspecting whatever happens to be in the store.
+    //
+    // Asserted here because nothing else asserts it ON A RUN: version-fold.test.ts
+    // reads engineVersion from the DISCOVERY document, and wasm-pack-load.test.ts
+    // carries it only as a type field. Both mention the identifier, so a grep
+    // suggests coverage that does not exist for this requirement.
+    const value = (snap.json as Snapshot | null)?.engineVersion;
+    expect(
+      value,
+      req(ID_ENGINE, DOC, 'every persisted run document MUST carry engineVersion; the "MAY omit" escape applies only to legacy runs that predate the contract, and this run was created moments ago'),
+    ).not.toBeUndefined();
+    expect(
+      typeof value === 'number',
+      req(ID_ENGINE, DOC, `engineVersion MUST be a number set to the writer engine's CURRENT_ENGINE_VERSION at write time (got ${JSON.stringify(value)})`),
+    ).toBe(true);
+  });
+});

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

@@ -0,0 +1,90 @@
+/**
+ * `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. So a host whose advertised list and seeded set
+ * drift apart 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. That misattribution is what this scenario exists to catch.
+ *
+ * **This scenario shipped with a second leg that was wrong, and the correction
+ * matters more than the check.** That leg asserted the advertised ids are a
+ * SUBSET of `conformance/fixtures/` — "the vocabulary is closed, so an id the
+ * corpus does not define is a typo or an invention". The vocabulary is not
+ * closed. Host-supplied fixtures are the normal case: dozens of ids the
+ * scenarios gate on are deliberately not shipped, and `v2-approver-enforced`
+ * says so in its own docstring — it needs an approval fixture whose
+ * `approversList` names a principal the suite is not, and records `blocked`
+ * naming it precisely because "no such fixture ships in `conformance/fixtures/`".
+ *
+ * So the leg failed a host for doing exactly what the corpus asks. It was found
+ * by running the suite against the reference host, which advertised two
+ * host-supplied fixtures and was marked non-conformant for it. Set membership
+ * cannot distinguish a typo from a legitimate host fixture, and a check that
+ * cannot tell those apart is not a check — it is a coin flip that happens to
+ * land on "fail" for correct hosts.
+ *
+ * What survives is the leg that was always sound: an advertised fixture MUST be
+ * creatable. That holds whoever defines it, and it is the one that catches the
+ * drift the misattribution comes from.
+ *
+ * @see spec/v2/core/conformance.md
+ * @see conformance/src/scenarios/v2-approver-enforced.test.ts (a host-supplied fixture, by design)
+ */
+
+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.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('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([]);
+  });
+});