@openwop/openwop-conformance 2.0.4 → 2.0.5

package/scenario-majors.json

@@ -3,7 +3,7 @@
   "counts": {
     "files": 516,
     "v1": 445,
-    "v2": 72
+    "v2": 73
   },
   "majors": {
     "a2a-1-0-agent-card.test.ts": [
@@ -773,7 +773,8 @@
       1
     ],
     "memory-attribution-replay-stable.test.ts": [
-      1
+      1,
+      2
     ],
     "memory-attribution-shape.test.ts": [
       1

package/schemas/CORPUS-STAMP.json

@@ -1,17 +1,17 @@
 {
   "_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.4",
-  "corpusTag": "v2.0.4",
+  "version": "2.0.5",
+  "corpusTag": "v2.0.5",
   "files": {
     "api/.redocly.lint-ignore.yaml": "bf5a8350b88a72fa43f59605ed8d903ed24b6cfccda5e45509c9f6ed9ee4e712",
     "api/asyncapi.yaml": "d5ecb9ee6114582be3b1f662c84bfac9ae96dae7bacb853e461168f70a8e1c7d",
     "api/grpc/openwop.proto": "c3e72bb17cba514ee98feb6434e6c9b6ea6795bfd086489ec69fd882dd1ad977",
     "api/openapi.yaml": "39081c59fb696159806b0f2f9a42e7e9ff830d622fcf2ad4159b21357580a955",
     "api/redocly.yaml": "b0604c89b2ca6d5076ec25725c539dad44a741a811fe524439ee6daef8baa09f",
-    "api/seams-v2.yaml": "7298eee975d901d9356e8893c39d43261d74a76a07955fffa5b21fb9ffdadf1f",
-    "api/v2/asyncapi.yaml": "98f304626ae95d8fef4de49ace6a4422104faf6c5348bff56ce5aafe511c1381",
-    "api/v2/openapi.yaml": "a6ace2a7b2f9adce2374a6a76fe8b62c6cb2530be5689b2343d8876733e9a54c",
+    "api/seams-v2.yaml": "99eae8d4204c4c23c4af05ed5e4982171ca6cf4fe9be03ebcedd9d977c5006dc",
+    "api/v2/asyncapi.yaml": "42040149c2a2056b1f69533fe4fb96e4f0299c8a06e952a88b8b7fd6d21748d2",
+    "api/v2/openapi.yaml": "4dcb20f14d28b4a7bfbbd2f6c1740723937169b7d1581670fe82c968e5d587a8",
     "api/v2/redocly.yaml": "1e66b60e6118ad11a823bb620678be464d99dfe50a40e3e6f93ec9429b88b34c",
     "schemas/README.md": "0c0b737ffcf8f30e7d2809cec8a498232de710f41443212922ad8337cdde0b51",
     "schemas/a2a-task-state.schema.json": "c9365918f993f943b4b619d42551eb066a1ed33a08d895d51b395432a5b1f1bc",
@@ -116,7 +116,7 @@
     "schemas/v2/audit-verify-result.schema.json": "cb54c4d89ba5dfb73f49aa8959a980be65c2dc2a87a12f71ba36d3e836fe85da",
     "schemas/v2/budget-policy.schema.json": "c7449daeb6e1d95e7a047b8c2814d3d54748697c27046972834874867d9b5f4c",
     "schemas/v2/capabilities.schema.json": "792669b2cc7b1fd44ce9a4fd3e79696ad1277734e29299a4504b39eda15913ed",
-    "schemas/v2/certification-bundle.schema.json": "b893ffa4de998b8b2b69a1038ebba0d7d50c8a32cde91ccae2b7c653fe459aa6",
+    "schemas/v2/certification-bundle.schema.json": "d2cbc5cadddff13630a528dc9673162f582c035c6a6663ca02c1ac53e8fec40c",
     "schemas/v2/channel-presence-payload.schema.json": "9475d46f358d21c19126e78204987a5633979917a2293653354ef5c5e044d54e",
     "schemas/v2/channel-written-payload.schema.json": "ccecff3c71a3275ad8db035ac0e04db25e6f8d23cf091ddbcd5a60d1be1cbb6b",
     "schemas/v2/chat-card-pack-manifest.schema.json": "8df0d9d273ae22efc6876d5586833f1d4c2e551edc3ac6cf6e8f0719329f03dd",
@@ -199,7 +199,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": "04f279931a6749086cf24131671a48f9d119eca4c3a611d2c1e19cc909ac4101",
+    "spec/v1/core-standard-manifest.json": "6e6059b6bcb2196ebbdf4015a28d4a077f93e7bec710326c492b49935988fd15",
     "spec/v1/deprecations.json": "1d5acb69a9b8ccb57275a95605f74aef1d920685f8407c9d382a46b59dc803bb",
     "spec/v1/deprecations.schema.json": "18c87e78bedc210431f795ae44c5b5d202f2f3317850d5cf86867d4f1fa1cdfb",
     "spec/v1/event-codemap.json": "3da60d884157793a360da532a9fcbbfb5285636db325a74cec94b34622186d97",
@@ -211,12 +211,50 @@
     "spec/v1/migrations.schema.json": "886779aa6c22e646db097f5df210adb018a4dd14a7b815465a18c8a7056c8f72",
     "spec/v1/operation-path-manifest.json": "5f5f4e3842669371730ebbd1aace3fb794192615f0018dc144f484ba5db82ac3",
     "spec/v1/spec-gaps.json": "6cc9962c6b969f632e07a78b52a4f61447ff579e2990cbae989866f584a86042",
-    "spec/v2/declaration.json": "a624cfa6a46d0b10e0dac40fa49abbe05190aff87a8e852ce125d19379067b00",
-    "spec/v2/declaration.schema.json": "b0881a76228dfbd1b85a2ec7b7259a60197f768344535cdb475db6ff719b0e54",
+    "spec/v2/README.md": "f56bd8d58be4ac04543c9f7b2fe92b294738d6121a4f21cbd1ce751e72b94c83",
+    "spec/v2/core/capabilities.md": "0f222434bbe58c881362a626ab9db6bce0ae2e54cb858e3d71b662dd1fc13150",
+    "spec/v2/core/conformance.md": "91418b882190e116ab9dac14527f52b8582b0462f41e96beeceb07e3fcc5f99a",
+    "spec/v2/core/connection-packs.md": "34e519dbe5b091c9758729787d398b35b1dc41f1e01ebd028e7e6b838ce2f6ee",
+    "spec/v2/core/errors.md": "671895de1b7c987a1dfd53fe0a814159efadae0ffd4c8c06bf1749d345270580",
+    "spec/v2/core/events.md": "7b9207079cede7ec335126b98bcb95d655ae3b7322b18febd1b4df51750b0a33",
+    "spec/v2/core/form-content-packs.md": "976f6e9b05a015f3bfe0748bc4f8bb11bbbd71460d12769f900bcde006b7cbb1",
+    "spec/v2/core/headers.md": "b7fc4f77904653ad47360b20302e3f406973821fb6d74ac86d6e81b674f52c4a",
+    "spec/v2/core/idempotency.md": "0ab68c1e41e81005b560421a3d22f985dda2f7537b2369bff67e40b79c8a581f",
+    "spec/v2/core/identity.md": "e3fa8d2d87c1dec2673e4bf4aec5f2257c684eaf64161c1a1016a634a87509c2",
+    "spec/v2/core/interop.md": "f701fddf15343d878faea31401e25e6ffb3672c2c8a87f30adc13b1e3c5c300c",
+    "spec/v2/core/interrupt.md": "4bd345bccdb8e2762ca95833cc67086158640c27ffa5ef84915a4ab3de348440",
+    "spec/v2/core/overview.md": "8ece6667535d24ed4013a046cb11e1a649f70e39625fc55e09ceb2c02505ed9c",
+    "spec/v2/core/packs.md": "90f32947816b4ec2b045b063ad2914126c73353883514a270ad200205dc8e51b",
+    "spec/v2/core/persistence.md": "e18195e078d7b0b799055005567e8d86a2ea7518c87809cfaf43dfe9f5d5c8ee",
+    "spec/v2/core/replay.md": "19b2fcbda4693895d39b99593f498b76376d77472a813bba6c22fca02e106332",
+    "spec/v2/core/runs.md": "f5f24df6da76b1d6e2cf655af3bbe3340195c36ec8d9ce0ca6e357385b1a8771",
+    "spec/v2/core/security-defaults.md": "53a1bc549aaa356a4fcb56cdb1c4f5880d3fb65d5d49dd570a413bb29aff82e5",
+    "spec/v2/core/versioning.md": "2eb4e8e5a1208a026a3d497d1e0fb76a4f7cb97e514d6f41f45dd66b89405abb",
+    "spec/v2/core/webhooks.md": "1d2719335f8fb46cd31dbb836b44ea7d78ed54f98ea181927502814603c5b935",
+    "spec/v2/core/workflow-chain-packs.md": "99ad4aeeeeb05521720dc2ae18ae63e6d604361780ed1b76778ca6d44da70eed",
+    "spec/v2/declaration.json": "9e191dffae9f95e622b3fc7087b8c17a2f42177bb4db3c7ee5fdf650443e036d",
+    "spec/v2/declaration.schema.json": "eac5f8080bd572f147bd57d0c4ac8ad73b14536d9236222490ae29a33b21e184",
     "spec/v2/errors.json": "f179414a92f30b5dadf26e9e57699649a67324bd7186d5287647d17605d137d3",
     "spec/v2/event-codemap.json": "37869a03cdfd8758b57e6f350641a6ebbd383231cebda51f5473ad85f94ab74c",
     "spec/v2/event-codemap.schema.json": "ce2d0ca085d7668d7ef745d2560b385ec6881d24a6d4b47c49931986b2ba642d",
+    "spec/v2/ext/a2uiSurface/README.md": "176cb0542e1c236ffcd6d682536ba0081242684444e2dec790abd480a44a571e",
+    "spec/v2/ext/brand/README.md": "1a80102a9cd766dcb6098c999e552af88f5b83c88951acde18d17cc0b29aa09d",
+    "spec/v2/ext/canvas/README.md": "a2d5f28523753e8e85cc9042db39faf9207a2eebce1a8553be22e341f7ea58d9",
+    "spec/v2/ext/chat/README.md": "39fe2961502d2937fe487cf52acfffeeb4a396731f0b2bf737b109eac2752bca",
+    "spec/v2/ext/coordination/README.md": "a193aa9a59a2d9ac8d2e9775e5be40c29b6f7476ffef35231dbab49377af9207",
+    "spec/v2/ext/dataIntegration/README.md": "8361c626ed9f77dc48a3bcaa0c9f769cb6706632941014700f7683efe0918bd1",
+    "spec/v2/ext/entities/README.md": "c3bf6c59ddf2255c22a522e689f6e7a11646fbcd309b17699b6cf69a4e2e0f91",
+    "spec/v2/ext/grpc-transport/README.md": "7fa692715744d6573443f994c521cbff0bf0be2e81ffdbb01e42f58f32a3ffaf",
+    "spec/v2/ext/kanban/README.md": "6792926f7f0cb8a4dcb0acdedb86a1988574fb0b5de164b37159dfe3ba35f908",
+    "spec/v2/ext/knowledge/README.md": "d2615320c7de4aec279f276381376a8881e962dd4e86b1435462d742dd00a52f",
+    "spec/v2/ext/launchStudio/README.md": "bfe417e774689773f3bbced9fdfa0c18809577aa6040a1312d914c821beed026",
+    "spec/v2/ext/messaging/README.md": "8a4702935483ce7900c0ee14793f9dfbeeb09d5e43f8943c946f8f94de2efa6f",
+    "spec/v2/ext/portability/README.md": "d9caf3dd723212676a0dd7f847284ce8aa3f0f5ebd4b273580c34a260ece96d7",
+    "spec/v2/ext/provider-idempotency/README.md": "c7620aadaf4e7ded997487c917e1583c8bc9ba20aa5353476d66f229207dbd1a",
     "spec/v2/ext/provider-idempotency/registry.json": "5b5fecad604fb4ab38da39f5abe697a4e57b05406c398f8afeb377331b2bd965",
+    "spec/v2/ext/restTransport/README.md": "b39f4d1ddbabd72dd945a39e90218d8413e46baea1269798b96dffb4e429cb4f",
+    "spec/v2/ext/sandbox-runtime-notes/README.md": "36c5517082b1cce0f1ccec5153e4bea10144bba88503b3b023f920444f3c15e6",
+    "spec/v2/ext/webResearch/README.md": "941dfe8323fd536791167f9fc7d119dd4e165bb7937e3382a19f15cda3d9f19a",
     "spec/v2/facets/a2a.schema.json": "6b0bceddec6d18d5115aa7d04720a0cc1ad7a9a0a78f53c208b34becaba5d16e",
     "spec/v2/facets/aiProviders.schema.json": "0c76e48e5d487b5be3b3ab1f6512a4e206c840ee5087d1336c7d7e2853b58d03",
     "spec/v2/facets/auth.schema.json": "73440c944ad12c41aab0618aeb799a90a0b59e97fc685527f248afb7d015381a",
@@ -230,8 +268,8 @@
     "spec/v2/path-manifest.json": "034152e09b1458c66810d4050e20a273b2b9b8fe2d92b66e8b819477de58a1be",
     "spec/v2/peer-dependency-aliases.json": "d10299280abee08258502925bc327293ee413e0108cd6e6ec75ff6110653308d",
     "spec/v2/profiles.json": "0636f19fceae625390003a347e70ef4797d84766b5c24ce8a02cea52aadebca4",
-    "spec/v2/release.json": "2c18f3bb246203a2de3eef9c1e433e10f548ae74d4689c2cd8eb86a2ae14b39b",
+    "spec/v2/release.json": "b5017d420b712ef558a93e0a6576df225583294157bb5c8cb198ee490c118780",
     "spec/v2/retention-floors.json": "eaf3722d95c79947af1d4269ef85117e126518c588cfcf1a2b21b97269f51624"
   },
-  "corpusCommit": "87038a29abb5a19f8eb01bece101fe74af81a7e5"
+  "corpusCommit": "3d3eca2a5b8e856c1f6cf448ee9e19fbb4fe5dd1"
 }

package/src/cli.ts

@@ -677,7 +677,11 @@ async function runCertify(args: ParsedArgs, baseUrl: string, apiKey: string): Pr
       generatedAt: new Date().toISOString(),
       suite: { name: '@openwop/openwop-conformance', version, targetMajor: target.major, specArtifactsVersion: lock?.version ?? 'repo-layout', ...(lock ? { stampSha256: lock.stampSha256 } : {}) },
       host: { name: host.name, version: host.version, ...(host.vendor ? { vendor: host.vendor } : {}), build, signingKeyId: keyId, ...(relaxations && relaxations.length ? { relaxations } : {}) },
-      discovery: { url: discoveryUrl, sha256, protocolVersions, preferredVersion },
+      // `document` is what makes `claimedProfiles[].certified` checkable by
+      // someone other than this process (RFC 0148 §B(1)); v2 carried it and v3
+      // dropped it. `sha256` is a digest of `canonicalJSON(document)`, so the
+      // two are consistent by construction and the verifier re-derives it.
+      discovery: { url: discoveryUrl, sha256, protocolVersions, preferredVersion, document },
       claimedProfiles: claimed3,
       results: { totals: totals3, requirements: rows3 },
       witnessSha256: witnessDigest(rows3),

package/src/lib/certification-bundle-v3.ts

@@ -18,6 +18,7 @@
  * in cli.ts) and pure: it never reads the environment.
  */
 import { createHash, createPrivateKey, createPublicKey, sign as edSign, verify as edVerify, type KeyObject } from 'node:crypto';
+import { profileDerivable, type DiscoveryPayload } from './profiles.js';
 
 export type BundleV3Result = 'executed-pass' | 'executed-fail' | 'skipped' | 'inapplicable' | 'blocked';
 
@@ -41,7 +42,25 @@ export interface BundleV3 {
   generatedAt: string;
   suite: { name: '@openwop/openwop-conformance'; version: string; targetMajor: 1 | 2; specArtifactsVersion: string; stampSha256?: string };
   host: { name: string; version: string; vendor?: string; build: { kind: 'image-digest' | 'commit' | 'artifact-sha256'; id: string }; signingKeyId?: string; relaxations?: BundleV3Relaxation[] };
-  discovery: { url: string; sha256: string; protocolVersions: string[]; preferredVersion: string };
+  /**
+   * `document` is the captured `/.well-known/openwop` payload, OPTIONAL.
+   *
+   * v2 bundles carried it (`discovery: { url, sha256, document }`) and
+   * `verifyBundleV2` read it to decide whether each claimed profile was
+   * DERIVABLE from what the host actually advertised. v3 shipped
+   * `{ url, sha256, protocolVersions, preferredVersion }` and `verifyBundleV3`
+   * dropped the check to match — so a v3 bundle's `certified: true` became a
+   * claim only its emitter could evaluate. `sha256` does not help a reader: it
+   * is a digest of `canonicalJSON(document)`, and a digest of a document you do
+   * not have proves nothing about its contents. Re-fetching is not a
+   * substitute, because the host redeploys and the bundle is supposed to
+   * attest to the build it names.
+   *
+   * Optional, not required: every bundle cut before this revision lacks it and
+   * stays verifiable. Present-and-inconsistent is a rejection; absent is a
+   * stated gap (`V3Verdict.derivabilityChecked === false`).
+   */
+  discovery: { url: string; sha256: string; protocolVersions: string[]; preferredVersion: string; document?: Record<string, unknown> };
   claimedProfiles: BundleV3Profile[];
   results: { totals: Record<'executedPass' | 'executedFail' | 'skipped' | 'inapplicable' | 'blocked', number>; requirements: BundleV3Requirement[] };
   witnessSha256: string;
@@ -104,6 +123,13 @@ export interface V3Verdict {
   readonly signatureVerified: boolean;
   readonly verifierSignatureVerified: boolean;
   readonly certifiedProfiles: string[];
+  /**
+   * Whether every `certified` profile was re-derived from the bundle's own
+   * `discovery.document`. `false` means the bundle did not carry one, so the
+   * certified list is the emitter's word — not wrong, but not independently
+   * checked. Read it before quoting a verdict.
+   */
+  readonly derivabilityChecked: boolean;
 }
 
 export function verifyBundleV3(bundle: BundleV3, opts: VerifyV3Options = {}): V3Verdict {
@@ -158,6 +184,32 @@ export function verifyBundleV3(bundle: BundleV3, opts: VerifyV3Options = {}): V3
     else if (p.certified) certifiedProfiles.push(p.id);
   }
   if (expected.blocked > 0 && certifiedProfiles.length > 0) rejections.push({ kind: 'blocked-certified', detail: `${expected.blocked} blocked row(s): a bundle with blocked > 0 does not certify (RFC 0168 §E.1)` });
+
+  // Derivability, restored. RFC 0148 §B(1): a profile certifies only if it is
+  // DERIVABLE from what the host advertised. `verifyBundleV2` checked exactly
+  // that against `discovery.document`; v3 stopped carrying the document and the
+  // check went with it, leaving `certified: true` a claim only its emitter
+  // could evaluate. When the document is present the check runs again — and it
+  // runs on the SAME bytes the signature covers, because `discovery.sha256` is
+  // a digest of `canonicalJSON(document)` and is re-derived here first. A
+  // document that does not hash to the signed digest is a substituted
+  // document, and rejecting it is the whole point of checking.
+  const document = bundle.discovery?.document;
+  let derivabilityChecked = false;
+  if (document !== undefined) {
+    const digest = createHash('sha256').update(canonicalJSON(document)).digest('hex');
+    if (digest !== bundle.discovery?.sha256) {
+      rejections.push({ kind: 'discovery-digest', detail: `discovery.document hashes to ${digest.slice(0, 12)} but discovery.sha256 is ${String(bundle.discovery?.sha256).slice(0, 12)} — the captured document is not the one the signature attests to` });
+    } else {
+      derivabilityChecked = true;
+      for (const p of bundle.claimedProfiles ?? []) {
+        if (!p.certified) continue;
+        if (!profileDerivable(document as DiscoveryPayload, p.id)) {
+          rejections.push({ kind: 'profile-not-derivable', profile: p.id, detail: `${p.id} is marked certified, but the captured discovery document does not derive it (RFC 0148 §B(1)) — evidence cannot certify a profile the host does not advertise` });
+        }
+      }
+    }
+  }
   // RFC 0168 §E.2: the verifier REFUSES, it does not warn — but a refusal is
   // scoped to what it names. A rejection carrying a `profile` removes that
   // profile only (a relaxation on one obligation does not poison an unrelated
@@ -171,5 +223,6 @@ export function verifyBundleV3(bundle: BundleV3, opts: VerifyV3Options = {}): V3
     signatureVerified,
     verifierSignatureVerified,
     certifiedProfiles: bundleWide.length > 0 ? [] : certifiedProfiles.filter((p) => !scoped.has(p)),
+    derivabilityChecked,
   };
 }

package/src/lib/era2-seed.ts

@@ -182,6 +182,33 @@ export function codemapV1toV2(): Map<string, string> {
   return m;
 }
 
+/**
+ * The registered vendor orgs, from `spec/v2/declaration.json` `extensions`
+ * (events.md §Rules; RFC 0171 §A.1). A vendor event type's first segment MUST
+ * be a key here, which is what separates "read under its own name unchanged"
+ * from "fail the read with `event_type_unmapped`" (persistence.md §The codemap
+ * is data / §The era key).
+ *
+ * `undefined` means the declaration is not on disk in this layout — a scenario
+ * that needs the registry MUST record that as a soft-skip rather than guess.
+ * There is no fallback list on purpose: a hard-coded org would make the suite
+ * the registry, and the whole defect this closes was a rule citing a registry
+ * that did not exist.
+ */
+let orgs: ReadonlySet<string> | null | undefined;
+export function registeredOrgs(): ReadonlySet<string> | undefined {
+  if (orgs !== undefined) return orgs ?? undefined;
+  const candidate = V1_DIR ? join(V1_DIR, '..', 'v2', 'declaration.json') : null;
+  orgs = null;
+  if (candidate && existsSync(candidate)) {
+    try {
+      const doc = JSON.parse(readFileSync(candidate, 'utf8')) as { extensions?: Record<string, unknown> };
+      if (doc.extensions && typeof doc.extensions === 'object') orgs = new Set(Object.keys(doc.extensions));
+    } catch { /* left null: unreadable is indistinguishable from absent, and both are soft-skips */ }
+  }
+  return orgs ?? undefined;
+}
+
 /** A minimal era-2 log in v1 vocabulary: two renamed rows between run.started and run.completed. */
 export function v1FixtureLog(workflowId = 'conformance-noop'): SeedEvent[] {
   const t0 = Date.parse('2026-01-15T10:00:00.000Z');

package/src/lib/memoryAttribution.ts

@@ -5,9 +5,36 @@
 import { driver } from './driver.js';
 import { discoveryFamilies } from './discovery-capabilities.js';
 import { isFixtureAdvertised } from './fixtures.js';
+import { targetMajor } from './seams.js';
+import { gateFamily } from './v2.js';
 
-/** Reads `capabilities.memory.attribution` from discovery; null when unadvertised. */
+/**
+ * The runs collection under the major in play. `/v1/runs` is a v1 address, not
+ * a seam, so `driver`'s seam rewrite does not touch it and a v1-shaped helper
+ * simply 404s on a v2 host. Every path in this file goes through here so a
+ * scenario can be made dual-major without editing three call sites and missing
+ * a fourth.
+ */
+export const runsPath = (): string => (targetMajor() === 2 ? '/runs' : '/v1/runs');
+
+/**
+ * `memory.attribution`, read the way the major in play advertises it, with the
+ * gate RECORDED at major 2.
+ *
+ * At major 1 this is the v1 capability read it always was. At major 2 it goes
+ * through `gateFamily('memory')`, which registers `openwop.family.memory` in
+ * the behaviour ledger — so a bundle distinguishes "the host does not
+ * advertise `memory`" from "the suite's reader did not understand the shape".
+ * An unrecorded early return looks identical to both, and to a scenario that
+ * was never selected; that is the whole reason a v1 behavioural file cannot
+ * just be pointed at a v2 host and trusted.
+ */
 export async function readMemoryAttributionCap(): Promise<Record<string, unknown> | null> {
+  if (targetMajor() === 2) {
+    const family = await gateFamily('memory');
+    const attr = family?.['attribution'];
+    return attr && typeof attr === 'object' && !Array.isArray(attr) ? (attr as Record<string, unknown>) : null;
+  }
   const res = await driver.get('/.well-known/openwop');
   const caps = discoveryFamilies(res.json);
   const mem = caps && typeof caps === 'object' ? (caps as Record<string, unknown>)['memory'] : undefined;
@@ -33,7 +60,7 @@ export async function seedRun(_label: string): Promise<string | null> {
   // certifying. No caller ever needed a SECOND tenant: every leg reads back its own run.
   // The tenant is the credential's own tenant (the host defaults it from the API key —
   // rest-endpoints.md), which is what "a run the bearer provably owns" means.
-  const r = await driver.post('/v1/runs', { workflowId: SEED_FIXTURE, inputs: {} });
+  const r = await driver.post(runsPath(), { workflowId: SEED_FIXTURE, inputs: {} });
   if (r.status !== 200 && r.status !== 201) return null;
   return (r.json as { runId?: string } | undefined)?.runId ?? null;
 }
@@ -46,7 +73,7 @@ interface RunEventLike {
 
 /** Fetches a run's events and returns only the `memory.written` ones. */
 export async function memoryWrittenEvents(runId: string): Promise<RunEventLike[]> {
-  const res = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/events`);
+  const res = await driver.get(`${runsPath()}/${encodeURIComponent(runId)}/events`);
   const events = (res.json as { events?: RunEventLike[] } | undefined)?.events ?? [];
   return events.filter((e) => e.type === 'memory.written');
 }

package/src/scenarios/memory-attribution-replay-stable.test.ts

@@ -29,18 +29,42 @@
  * should have: nothing normative changed, the instrument just could not see
  * it before.
  *
- * Gated on `capabilities.memory.attribution.emitsWriteEvents`; soft-skips
- * when unadvertised, when the seeded run wrote no memory, or when the host
- * doesn't support `:fork` in `replay` mode.
+ * Gated on `memory.attribution.emitsWriteEvents`; soft-skips when unadvertised,
+ * when the seeded run wrote no memory, or when the host doesn't support `:fork`
+ * in `replay` mode.
+ *
+ * MAJORS [1, 2] (suite 2.0.5), and why this file is the first one moved.
+ * The rule it checks — a replay MUST re-emit recorded-fact events and MUST NOT
+ * regenerate their ids — is `replay.md` §Determinism caveat 5 in BOTH majors,
+ * word for word. It was nevertheless `majors: [1]`, so no v2 host had ever been
+ * measured on it, for two reasons that have nothing to do with the rule:
+ *
+ *   1. Its gate read the v1 capability shape directly and returned early with
+ *      NOTHING RECORDED. An unrecorded early return is indistinguishable, in a
+ *      bundle, from a host that does not advertise `memory`, from a suite
+ *      reader that does not understand the v2 shape, and from a file that was
+ *      never selected. It now goes through `gateFamily('memory')` at major 2,
+ *      which registers `openwop.family.memory` — the gate becomes evidence.
+ *   2. Its three paths were hard-coded `/v1/…`. That is a v1 address and not a
+ *      seam, so the driver's seam rewrite never touched it; on a v2 host the
+ *      helper would simply 404 and the file would report a host defect that was
+ *      really a suite defect. `runsPath()` resolves the major.
+ *
+ * Both are properties of the INSTRUMENT, not of the obligation. That is the
+ * shape to look for in the remaining v1 behavioural files: a rule that holds at
+ * major 2, held back by a v1-shaped gate and a v1-shaped path. Neither is a
+ * reason for a host to go unmeasured, and neither announces itself — the file
+ * was green at major 1 the whole time.
  *
  * @see RFCS/0057-memory-write-attribution-event.md §D
+ * @see spec/v2/core/replay.md §Determinism caveats
  */
 
 import { describe, it, expect } from 'vitest';
 import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
-import { readMemoryAttributionCap, emitsWriteEvents, seedRun, memoryWrittenEvents } from '../lib/memoryAttribution.js';
+import { readMemoryAttributionCap, emitsWriteEvents, seedRun, memoryWrittenEvents, runsPath } from '../lib/memoryAttribution.js';
 import { req } from '../lib/requirement-ids.js';
 
 function memoryIdOf(payload: Record<string, unknown> | undefined): string | null {
@@ -51,7 +75,7 @@ function memoryIdOf(payload: Record<string, unknown> | undefined): string | null
 describe('memory-attribution-replay-stable (RFC 0057 §D)', () => {
   it('a replay-mode fork introduces no memory.written with a new memoryId', async () => {
     const cap = await readMemoryAttributionCap();
-    if (!emitsWriteEvents(cap)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!emitsWriteEvents(cap)` returned early');
+    if (!emitsWriteEvents(cap)) return softSkip('inapplicable', 'memory.attribution.emitsWriteEvents not advertised — at major 2 the gate is recorded under openwop.family.memory, so an unadvertised family and an unreadable one are distinguishable in the bundle');
     const runId = await seedRun('mem-attr-replay');
     if (!runId) return softSkip('blocked', 'precondition not met — `!runId` returned early (seam, prior step, or fixture unavailable)');
     try {
@@ -63,7 +87,7 @@ describe('memory-attribution-replay-stable (RFC 0057 §D)', () => {
     if (original.length === 0) return softSkip('blocked', 'run wrote no memory — nothing to test');
     const recordedIds = new Set(original.map((e) => memoryIdOf(e.payload)).filter((x): x is string => x !== null));
 
-    const fork = await driver.post(`/v1/runs/${runId}:fork`, { fromSeq: 0, mode: 'replay' });
+    const fork = await driver.post(`${runsPath()}/${encodeURIComponent(runId)}:fork`, { fromSeq: 0, mode: 'replay' });
     if (fork.status !== 200 && fork.status !== 201) return softSkip('inapplicable', 'replay fork unsupported — soft-skip (fork.status !== 200 && fork.status !== 201)');
     const forkId = (fork.json as { runId?: string } | undefined)?.runId;
     if (!forkId) return softSkip('blocked', 'precondition not met — `!forkId` returned early (seam, prior step, or fixture unavailable)');

package/src/scenarios/v2-run-fork-prefix.test.ts

@@ -52,13 +52,57 @@
  * file's worth: the boundary it checks is real and a tier-1 host shipped the
  * bug it catches.
  *
+ * The payload-equivalence leg below does NOT move that verdict. It strengthens
+ * the same single `it` behind the same fixture gate, so the file still cannot
+ * witness for a predicate holder that advertises no optional fixture. Promotion
+ * stays blocked on a prior condition anyway: the strengthened leg has not been
+ * MEASURED on the reference host, and a floor is not a place to find out.
+ *
  * What this file deliberately does NOT assert: the CONTENT of the re-executed
  * tail, determinism across two forks, timing, and effect re-fire suppression.
  * Those are `replay.md` §Replay determinism and the seams floor's, witnessed in
  * `replay-fork-arbitrary` (major 1) and `v2-effect-seam-no-refire` (seams).
  *
+ * PAYLOAD EQUIVALENCE, and the honest size of what it witnesses.
+ * `replay.md` §Byte-equivalence of the prefix opens: "The events at indices
+ * `[0, fromSeq)` MUST be byte-equivalent between source and replay, modulo
+ * per-region clock fields (RFC 0036 §E) and ULID time-component entropy when
+ * ULIDs are minted fresh." Until this revision the only witness of that MUST
+ * compared `${sequence}:${type}` — sequence-and-TYPE equality. A host could
+ * inherit a prefix whose event PAYLOADS differed from the source, in every
+ * field, and pass. "Byte-equivalent" was checked by comparing two of an event's
+ * ten fields, and the gap was invisible because the leg was green.
+ *
+ * The exclusion set is NOT invented here. `runs.md` §Diff and ancestry already
+ * states, normatively, what two logs are compared on: "`eventId`, `runId`,
+ * `timestamp` and other run-scoped fields MUST be excluded from comparison."
+ * That is the spec's own definition of the same event on two runs, and a fork
+ * IS a new run with its own `runId` and its own `eventId`s. So:
+ *
+ *   compared   `type`, `nodeId`, `payload` (deep)
+ *   excluded   `eventId`   run-scoped (runs.md §Diff) + ULID entropy (§36)
+ *              `runId`     the fork is a different run, by construction
+ *              `timestamp` a per-region clock field (RFC 0036 §E, named in §36)
+ *              `causationId` names an `eventId` of this run, so run-scoped
+ *
+ * NAMED RESIDUE, not silently dropped. `schemaVersion` and `engineVersion` are
+ * not asserted: §36's carve-out list does not excuse them, but neither does any
+ * clause say whether a host re-stamps them when copying fixed history into a
+ * replay running against CURRENT code, and a scenario should not settle a
+ * question the prose left open. `replay.md` line 37 — "`variables`, `channels`,
+ * and `status` of the run snapshot at each index in that range MUST be
+ * byte-equivalent" — has no witness at any major and gets none here: there is
+ * no wire surface that returns a run snapshot AS OF an index, only at head, so
+ * an unaided scenario cannot reach it. Both are gaps in the evidence, recorded
+ * as gaps. This leg witnesses a NAMED SUBSET of §36 and says which.
+ *
+ * The leg runs LAST, after the boundary assertion, so a host that fails this
+ * stricter new check still reports the boundary verdict the file was cut for.
+ *
  * @see spec/v2/core/replay.md §Endpoint
+ * @see spec/v2/core/replay.md §Byte-equivalence of the prefix
  * @see spec/v2/core/runs.md §Fork
+ * @see spec/v2/core/runs.md §Diff and ancestry
  */
 
 import { describe, it, expect } from 'vitest';
@@ -71,10 +115,32 @@ import { req } from '../lib/requirement-ids.js';
 
 const ID = 'openwop.requirement.0170.fork-prefix-boundary';
 const DOC = 'spec/v2/core/replay.md §Endpoint';
+const BYTES = 'spec/v2/core/replay.md §Byte-equivalence of the prefix';
 const MULTI = 'conformance-multi-node';
 const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
 
-interface Ev { readonly sequence?: unknown; readonly type?: unknown }
+interface Ev { readonly sequence?: unknown; readonly type?: unknown; readonly nodeId?: unknown; readonly payload?: unknown }
+
+/**
+ * Stable JSON for deep comparison: object keys sorted at every depth, so two
+ * payloads differing only in serialization order compare equal. Array order is
+ * preserved — it is content.
+ */
+function canonical(v: unknown): string {
+  const norm = (x: unknown): unknown => {
+    if (Array.isArray(x)) return x.map(norm);
+    if (x !== null && typeof x === 'object') {
+      const o: Record<string, unknown> = {};
+      for (const k of Object.keys(x as Record<string, unknown>).sort()) o[k] = norm((x as Record<string, unknown>)[k]);
+      return o;
+    }
+    return x;
+  };
+  return JSON.stringify(norm(v)) ?? 'undefined';
+}
+
+/** The compared projection of an event: everything §36 binds that is not run-scoped. */
+const projection = (e: Ev): string => canonical({ type: e.type ?? null, nodeId: e.nodeId ?? null, payload: e.payload ?? null });
 
 async function discovery(): Promise<Record<string, unknown> | null> { try { return await v2Discovery(); } catch { return null; } }
 async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> { try { return await fn(); } catch { return null; } }
@@ -156,5 +222,23 @@ describe('v2 run-fork-prefix (replay.md §Endpoint — the boundary is exclusive
       String(at.type),
       req(ID, DOC, `the event at sequence ${fromSeq} is re-executed, not fixed history: the fork MUST NOT carry the source's ${String(point.type)} at that sequence — seeing it means the prefix was copied inclusively ([0, ${fromSeq}] instead of [0, ${fromSeq}))`),
     ).not.toBe(String(point.type));
+
+    // Byte-equivalence of the prefix, on the named subset (see the docblock).
+    // Last, so a host that fails this stricter check still reports the boundary
+    // verdict above. The exclusion set is runs.md §Diff and ancestry's, not
+    // this file's: eventId, runId, timestamp and causationId are run-scoped,
+    // and a fork is a different run.
+    const src = source.filter((e) => (e.sequence as number) < fromSeq);
+    const differing = inherited
+      .map((e, i) => ({ seq: e.sequence as number, fork: projection(e), from: src[i] === undefined ? '<missing>' : projection(src[i]) }))
+      .filter((r) => r.fork !== r.from);
+    expect(
+      differing.map((r) => r.seq),
+      req(
+        ID,
+        BYTES,
+        `every event in [0, ${fromSeq}) MUST be byte-equivalent to the source's, modulo per-region clock fields and freshly minted ULIDs — compared on {type, nodeId, payload}, excluding eventId/runId/timestamp/causationId as run-scoped (runs.md §Diff and ancestry). ${differing.length} row(s) differ${differing.length ? `: ${differing.slice(0, 3).map((r) => `seq ${r.seq} fork ${r.fork.slice(0, 160)} vs source ${r.from.slice(0, 160)}`).join(' | ')}` : ''}. Inherited history is copied, not recomputed: a differing payload means the fork re-derived a row the spec calls fixed`,
+      ),
+    ).toEqual([]);
   }, 60_000);
 });

package/src/scenarios/v2-unmapped-type-refused.test.ts

@@ -11,9 +11,21 @@
  *
  * An era-2 log carrying one `foo.bar` row is seeded through the event-log seed
  * seam (lib/era2-seed.ts); the read is driven through poll and, where `replay`
- * is advertised, through a fork. A vendor-prefixed control (read under its own
- * name) needs an org registered under `extensions` in `spec/v2/declaration.json`
- * that the suite does not own, so that half is not driven.
+ * is advertised, through a fork.
+ *
+ * THE CONTROL, and why it was missing. Until this revision only the REFUSAL
+ * half was driven, and a host that refuses EVERY type the codemap does not name
+ * — including a registered vendor type it is required to pass through — went
+ * green on the whole file while violating `persistence.md` §The codemap is data.
+ * A one-sided rule is not witnessed by its own negative case. The positive half
+ * needs an org registered in the `extensions` object of `spec/v2/declaration.json`
+ * that no host owns; the registry did not exist, so the suite could not drive
+ * it and this docblock recorded the gap instead of closing it. `extensions` now
+ * exists and holds `example`, reserved by the protocol and never assignable to
+ * a vendor (RFC 2606 precedent), so `example.thing-happened` is a type that is
+ * registered, unmapped, and owned by nobody — exactly the control this file
+ * lacked. The two legs are each other's non-vacuity check: refusing both is a
+ * defect, accepting both is a defect, and only the pair can tell them apart.
  *
  * @see spec/v2/core/persistence.md §The reader rule
  * @see spec/v2/core/events.md §Reading an era-2 log
@@ -24,11 +36,35 @@ import { v2Discovery, gateFamily } from '../lib/v2.js';
 import { readErrorCode, readRetriable } from '../lib/error-envelope.js';
 import { softSkip } from '../lib/soft-skip.js';
 import { req } from '../lib/requirement-ids.js';
-import { era2Gate, eventsOf, forkRun, pollEvents, seedEra2Log, type SeedEvent } from '../lib/era2-seed.js';
+import { codemapV1toV2, era2Gate, eventsOf, forkRun, pollEvents, registeredOrgs, seedEra2Log, type SeedEvent } from '../lib/era2-seed.js';
 
 const DOC = 'spec/v2/core/persistence.md §The reader rule';
+const MAP = 'spec/v2/core/persistence.md §The codemap is data';
 const CODE = 'event_type_unmapped';
+const ID_VENDOR = 'openwop.requirement.0176.vendor-type-passthrough';
 const UNMAPPED = 'foo.bar';
+/** Registered (`extensions` in the declaration), unmapped, owned by no host. */
+const VENDOR = 'example.thing-happened';
+const orgOf = (type: string): string => type.split('.')[0] ?? '';
+
+/**
+ * The two types this file drives are only meaningful under preconditions the
+ * corpus can move: `foo` must stay unregistered, `example` must stay
+ * registered, and neither type may acquire a codemap row. Until this revision
+ * those were a note inside a seeded payload — prose in a place no runner reads,
+ * asserting a fact nothing checked. If `foo` is ever registered, the refusal
+ * leg would quietly begin testing the opposite rule and still pass. Checked
+ * here so the file fails loudly instead.
+ */
+function preconditions(): { ok: true } | { ok: false; kind: 'blocked' | 'inapplicable'; reason: string } {
+  const registered = registeredOrgs();
+  if (registered === undefined) return { ok: false, kind: 'inapplicable', reason: 'spec/v2/declaration.json is not resolvable in this layout — the vendor-org registry decides which half of the reader rule each type exercises, and guessing it would make the suite the registry' };
+  if (registered.has(orgOf(UNMAPPED))) return { ok: false, kind: 'blocked', reason: `the refusal leg drives ${UNMAPPED}, whose org '${orgOf(UNMAPPED)}' is NOW REGISTERED in spec/v2/declaration.json extensions — it is a vendor type that must pass through, not an unmapped one that must be refused; pick an unregistered org for this leg` };
+  if (!registered.has(orgOf(VENDOR))) return { ok: false, kind: 'blocked', reason: `the control leg needs org '${orgOf(VENDOR)}' registered in spec/v2/declaration.json extensions (registered: ${[...registered].join(', ') || 'none'}) — without a registered org the positive half of the vendor rule cannot be driven at all` };
+  const map = codemapV1toV2();
+  for (const t of [UNMAPPED, VENDOR]) if (map.has(t)) return { ok: false, kind: 'blocked', reason: `${t} now has a codemap row (→ ${String(map.get(t))}) — both legs require a type the codemap does not name` };
+  return { ok: true };
+}
 
 async function discovery(): Promise<Record<string, unknown> | null> {
   try { return await v2Discovery(); } catch { return null; }
@@ -39,7 +75,18 @@ function unmappedLog(): SeedEvent[] {
   const ts = (i: number) => new Date(t0 + i * 1000).toISOString();
   return [
     { type: 'run.started', sequence: 0, payload: { workflowId: 'conformance-noop' }, timestamp: ts(0) },
-    { type: UNMAPPED, sequence: 1, payload: { note: 'not a codemap row, not a vendor org' }, timestamp: ts(1) },
+    { type: UNMAPPED, sequence: 1, payload: {}, timestamp: ts(1) },
+    { type: 'run.completed', sequence: 2, payload: { durationMs: 2000 }, timestamp: ts(2) },
+  ];
+}
+
+/** The same shape carrying a REGISTERED vendor type instead of an unmapped one. */
+function vendorLog(): SeedEvent[] {
+  const t0 = Date.parse('2026-01-15T12:00:00.000Z');
+  const ts = (i: number) => new Date(t0 + i * 1000).toISOString();
+  return [
+    { type: 'run.started', sequence: 0, payload: { workflowId: 'conformance-noop' }, timestamp: ts(0) },
+    { type: VENDOR, sequence: 1, payload: { marker: 'era2-vendor-passthrough' }, timestamp: ts(1) },
     { type: 'run.completed', sequence: 2, payload: { durationMs: 2000 }, timestamp: ts(2) },
   ];
 }
@@ -50,6 +97,8 @@ describe('RFC 0176 §A.3 — unmapped-type-refused (seam-gated)', () => {
     if (!doc) return softSkip('blocked', 'discovery unreachable');
     const gate = era2Gate(doc);
     if (gate !== null && !gate.ok) return softSkip(gate.kind, gate.reason);
+    const pre = preconditions();
+    if (!pre.ok) return softSkip(pre.kind, pre.reason);
     const seeded = await seedEra2Log(unmappedLog(), 'completed');
     if (!seeded.ok) return softSkip(seeded.kind, seeded.reason);
     const res = await pollEvents(seeded.runId);
@@ -68,12 +117,40 @@ describe('RFC 0176 §A.3 — unmapped-type-refused (seam-gated)', () => {
     ).toBe(false);
   });
 
+  it('a REGISTERED vendor type the codemap does not name is read under its own name, unchanged', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', 'discovery unreachable');
+    const gate = era2Gate(doc);
+    if (gate !== null && !gate.ok) return softSkip(gate.kind, gate.reason);
+    const pre = preconditions();
+    if (!pre.ok) return softSkip(pre.kind, pre.reason);
+    const seeded = await seedEra2Log(vendorLog(), 'completed');
+    if (!seeded.ok) return softSkip(seeded.kind, seeded.reason);
+    const res = await pollEvents(seeded.runId);
+    if (res === null) return softSkip('blocked', 'GET /runs/{runId}/events/poll unreachable (fetch failed)');
+    // The whole point of the control: this is the SAME log shape as the refusal
+    // leg with one segment changed, so a 500 here says the host is refusing on
+    // "not in the codemap" and not on "not a registered org" — the tolerant
+    // reader's mirror image, and just as wrong.
+    expect(
+      res.status,
+      req(ID_VENDOR, MAP, `a vendor-prefixed type whose org IS registered MUST be read under its own name unchanged, not refused — got ${res.status}${res.status === 500 ? ` ${readErrorCode(res.json) ?? ''}: the host refuses every type the codemap does not name, which fails the registered half of the rule` : ''}`.trim()),
+    ).toBe(200);
+    const types = eventsOf(res.json).map((e) => String(e.type));
+    expect(
+      types.includes(VENDOR),
+      req(ID_VENDOR, MAP, `the ${VENDOR} row MUST appear under its own name — read back [${types.join(', ')}]; a translated or dropped row is a private mapping, and the codemap is the only authority`),
+    ).toBe(true);
+  });
+
   it('a fork of the same log is refused for the same reason — the rule binds every reader', async () => {
     const doc = await discovery();
     if (!doc) return softSkip('blocked', 'discovery unreachable');
     const gate = era2Gate(doc);
     if (gate !== null && !gate.ok) return softSkip(gate.kind, gate.reason);
     if (!(await gateFamily('replay'))) return softSkip('inapplicable', 'replay family not advertised (gate recorded under openwop.family.replay) — the fork reader has no surface');
+    const pre = preconditions();
+    if (!pre.ok) return softSkip(pre.kind, pre.reason);
     const log = unmappedLog();
     const seeded = await seedEra2Log(log, 'completed');
     if (!seeded.ok) return softSkip(seeded.kind, seeded.reason);