@openwop/openwop-conformance 2.46.30 → 2.46.32

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [2.46.32] — 2026-10-26 — RFC 0252 Active
+
+- **New scenario `v2-eval-recorded-fixtures` (RFC 0252)** over three fixtures and the counter tool, run in order source, replay (`fixtureRuns: {record: source}`), drift, then the source again as a probe: `0252.shape` (server-free), `source-replayed`, `drift-fails-closed`, `source-refused`, `source-uniform`, `fields-refused`. Judges in `lib/eval-recorded-fixtures-witness.ts` with self-tests.
+- **Host impact:** opt-in. The legs need `agents.evalSuite.recordedFixtures`, `fixtureMatching` and the three fixtures listed; no host does yet, so they record `inapplicable`. Listing a recorded fixture opts the host in to the counter-tool contract.
+## [2.46.31] — 2026-10-26 — RFC 0251 Accepted
+
+- **No assertion changes.** RFC 0251's G2 closes on openwop-app's certified cut `24b6a05ff` (the five `0251.*` legs and both `0244.regression-*` legs `executed-pass`), so the packed `spec/v1/gaps.json` changes.
+
 ## [2.46.30] — 2026-10-26 — RFC 0252 Draft (no assertion changes)
 
 - **No scenario or assertion changes.** RFC 0252 (`Draft`) adds its gap register and RFC 0244's G5 row moves to it, so the packed `spec/v1/gaps.json` changes.

package/README.md

@@ -137,7 +137,7 @@ Each scenario file records its disposition and assertion count in `<report-dir>/
 
 ## What's Covered
 
-The current suite has 663 scenario files under `src/scenarios/`. By target major ([`scenario-majors.json`](./scenario-majors.json)): 223 files run against a v2 host and 455 against a v1 host; 15 of them run at both.
+The current suite has 664 scenario files under `src/scenarios/`. By target major ([`scenario-majors.json`](./scenario-majors.json)): 224 files run against a v2 host and 455 against a v1 host; 15 of them run at both.
 
 The v2 scenarios (`src/scenarios/v2-*.test.ts`) cover, by area:
 
@@ -166,7 +166,7 @@ Three kinds of scenario share the tree:
 - **Host** checks drive a live host over HTTP.
 - **Gated** checks run only when the host advertises the family, profile or fixture they need, and otherwise record `inapplicable` or `blocked` with a reason. `--require-behavior` turns an advertised-but-unwitnessable behaviour into a failure.
 
-Current source tree: 663 scenario files. [`coverage.md`](./coverage.md) maps each spec document and every OpenAPI operation to its scenarios. [`CHANGELOG.md`](./CHANGELOG.md) records when each scenario landed.
+Current source tree: 664 scenario files. [`coverage.md`](./coverage.md) maps each spec document and every OpenAPI operation to its scenarios. [`CHANGELOG.md`](./CHANGELOG.md) records when each scenario landed.
 
 ## How the 2.x suite is built
 

package/dist/spec-artifacts.lock.json

@@ -1,5 +1,5 @@
 {
   "package": "@openwop/spec-artifacts",
-  "version": "2.46.30",
-  "stampSha256": "ab7c7f2bc8efddb11e0c565b046f69538a7ab3145416ee4227e8d96265b7d9b9"
+  "version": "2.46.32",
+  "stampSha256": "e6decdfd7ff3c1d06ccb5b895967821962de134e122765fa012698d3e1fa5535"
 }

package/fixtures/eval-suites/conformance-eval-recorded-drift.json

@@ -0,0 +1,46 @@
+{
+  "suiteId": "core.openwop.evals.conformance-eval-recorded-drift",
+  "version": "1.0.0",
+  "targetAgentId": "core.conformance.agents.scripted",
+  "modes": [
+    "golden"
+  ],
+  "tasks": [
+    {
+      "taskId": "record",
+      "input": {
+        "script": [
+          {
+            "tool": "conformance.eval:counter",
+            "arguments": {
+              "key": "P",
+              "op": "read"
+            }
+          },
+          {
+            "tool": "conformance.eval:counter",
+            "arguments": {
+              "key": "P",
+              "op": "inc"
+            }
+          },
+          {
+            "tool": "conformance.eval:counter",
+            "arguments": {
+              "key": "R",
+              "op": "read"
+            }
+          }
+        ],
+        "output": "done"
+      },
+      "expected": {
+        "kind": "golden",
+        "match": {
+          "strategy": "contains",
+          "value": "done"
+        }
+      }
+    }
+  ]
+}

package/fixtures/eval-suites/conformance-eval-recorded-replay.json

@@ -0,0 +1,46 @@
+{
+  "suiteId": "core.openwop.evals.conformance-eval-recorded-replay",
+  "version": "1.0.0",
+  "targetAgentId": "core.conformance.agents.scripted",
+  "modes": [
+    "golden"
+  ],
+  "tasks": [
+    {
+      "taskId": "record",
+      "input": {
+        "script": [
+          {
+            "tool": "conformance.eval:counter",
+            "arguments": {
+              "key": "P",
+              "op": "read"
+            }
+          },
+          {
+            "tool": "conformance.eval:counter",
+            "arguments": {
+              "key": "R",
+              "op": "inc"
+            }
+          },
+          {
+            "tool": "conformance.eval:counter",
+            "arguments": {
+              "key": "R",
+              "op": "read"
+            }
+          }
+        ],
+        "output": "done"
+      },
+      "expected": {
+        "kind": "golden",
+        "match": {
+          "strategy": "contains",
+          "value": "done"
+        }
+      }
+    }
+  ]
+}

package/fixtures/eval-suites/conformance-eval-recorded-source.json

@@ -0,0 +1,61 @@
+{
+  "suiteId": "core.openwop.evals.conformance-eval-recorded-source",
+  "version": "1.0.0",
+  "targetAgentId": "core.conformance.agents.scripted",
+  "modes": [
+    "golden"
+  ],
+  "tasks": [
+    {
+      "taskId": "record",
+      "input": {
+        "script": [
+          {
+            "tool": "conformance.eval:counter",
+            "arguments": {
+              "key": "P",
+              "op": "read"
+            }
+          },
+          {
+            "tool": "conformance.eval:counter",
+            "arguments": {
+              "key": "R",
+              "op": "inc"
+            }
+          },
+          {
+            "tool": "conformance.eval:counter",
+            "arguments": {
+              "key": "R",
+              "op": "read"
+            }
+          }
+        ],
+        "output": "done"
+      },
+      "expected": {
+        "kind": "golden",
+        "match": {
+          "strategy": "contains",
+          "value": "done"
+        }
+      },
+      "fixtures": {
+        "onMiss": "live",
+        "toolResponses": [
+          {
+            "tool": "conformance.eval:lookup",
+            "args": {
+              "orderId": "o-1"
+            },
+            "argsMatch": "exact",
+            "response": {
+              "status": "shipped"
+            }
+          }
+        ]
+      }
+    }
+  ]
+}

package/fixtures.md

@@ -80,6 +80,7 @@ All fixtures MUST advertise:
 | Eval — Efficiency Ungated | `conformance-eval-efficiency-ungated` | RFC 0244 §C — two golden tasks with one output, `lean` (1 call) and `busy` (8 calls), at `passScore: 1` (`v2-eval-trajectory-trials`) | eval run `completed`; both tasks and the suite pass | ≤ 30s |
 | Eval — Memory Isolation | `conformance-eval-memory-isolation` | RFC 0244 §B, G3 — `trials.count: 2`; one task seeds `seeded`, then reads it, reads `trial-note`, writes it and reads it back through `conformance.eval:memory` (`v2-eval-trajectory-trials`) | eval run `completed`; each trial reads the seed and finds no `trial-note` before its own write | ≤ 30s |
 | Eval — Gate Failing | `conformance-eval-gate-failing` | RFC 0082 §E — one task whose output never contains the golden `done`, so the summary is `passed: false`; its run is then cited by a `promote` of the scripted agent (`v2-deployment-eval-gate`) | eval run `completed`, `passed: false`; the promote is refused `422 eval_gate_unmet` | ≤ 30s |
+| Eval — Recorded Source / Replay / Drift | `conformance-eval-recorded-source`, `conformance-eval-recorded-replay`, `conformance-eval-recorded-drift` | RFC 0252 — task `record` through `conformance.eval:counter`: source `read P`, `inc R`, `read R` live; replay the same script with `fixtureRuns: {record: <source>}`; drift `read P`, `inc P`, `read R` with the same source (`v2-eval-recorded-fixtures`) | source and replay `completed`, passing; drift `completed` with `passed: false` | ≤ 30s each |
 | Eval — Regression (base) | `conformance-eval-regression-base` | RFC 0251 — the baseline run: suite 1.0.0, `base-only` fails, `shared-a` and `shared-b` pass (`v2-eval-regression-baseline`) | eval run `completed`; `aggregateScore` 2/3 | ≤ 30s |
 | Eval — Regression (candidate) | `conformance-eval-regression-candidate` | RFC 0251, RFC 0244 §F — the same `suiteId` at 1.1.0: the two shared tasks unchanged, plus `candidate-only` (passes), run against the base run (`v2-eval-regression-baseline`) | eval run `completed`; `aggregateScore` 1; `scoreDelta` 1/3; `pairedTaskCount` 2; verdict neither `improved` nor `regressed` | ≤ 30s |
 | Dispatch Fan-Out Waves | `conformance-dispatch-fanout-waves` | RFC 0243 §A.3 — a parallel `core.dispatch` (`maxConcurrency: 2`, `wait-all`/`collect`) whose supervisor's `mockDispatchPlan` names three `conformance-delay` children. At most `min(2, maxFanOut)` run at once and none is dropped. Gated on `agents.fanOut` admitting `wait-all` with `collect`. | `completed` | ≤ 30s |
@@ -1071,8 +1072,9 @@ Every task targets **the scripted agent `core.conformance.agents.scripted`**. It
 | `conformance-eval-gate-failing` | `agents.evalSuite` + `agents.deployment` | RFC 0082 §E: a `promote` of a `draft`, `test` or `staged` record of the scripted agent citing this run as `evalRunId` is refused `422 eval_gate_unmet`, and the record keeps its `state`, `channels` and `canaryPercent`. A summary that does not say `passed: false` records `blocked` |
 | `conformance-eval-regression-base` | `agents.evalSuite.baselineSelection` + `regression` in `modes` | run first with `evalModes: [golden]`; the baseline of the candidate run |
 | `conformance-eval-regression-candidate` | `agents.evalSuite.baselineSelection` + `regression` in `modes` (+ `regressionVerdict` for the §F legs) | run with `evalModes: [golden, regression]` and the base run as `baselineRunId`: both carriers name it, `scoreDelta` 1/3, `pairedTaskCount` 2, verdict neither `improved` nor `regressed`. Both fixtures share one `suiteId`, so a host's suite store resolves them by fixture id |
+| `conformance-eval-recorded-source` / `conformance-eval-recorded-replay` / `conformance-eval-recorded-drift` | `agents.evalSuite.recordedFixtures` + `fixtureMatching` | RFC 0252, run in order source, replay, drift, then source again as a probe: the replay's `eval.started.fixtureRuns` echoes the map and its three counter outcomes equal the source's with `fixtureMissCount` 0; the drift counts one miss and fails; the probe's `inc R` is the source's plus one and its `read P` equals the source's. A counter that did not persist, or moved by more than two, records `blocked` |
 
-**The counter tool `conformance.eval:counter` is conformance-RESERVED** (the pattern of `core.conformance.side-effect`). A host that lists either counter fixture in discovery `fixtures` MUST, at its eval tool boundary:
+**The counter tool `conformance.eval:counter` is conformance-RESERVED** (the pattern of `core.conformance.side-effect`). A host that lists either counter fixture, or any of `conformance-eval-recorded-source`, `conformance-eval-recorded-replay` and `conformance-eval-recorded-drift`, in discovery `fixtures` MUST, at its eval tool boundary:
 
 - answer a call that reaches the live tool with inputs `{key, op}` as follows. `inc` adds one to a counter scoped to the caller's owner triple and `key`, then returns `{key, count}`. `read` returns `{key, count}` without changing it. A key never incremented reads `0`.
 - keep that state for at least an hour, across eval runs;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openwop/openwop-conformance",
-  "version": "2.46.30",
+  "version": "2.46.32",
   "description": "Black-box conformance suite for OpenWOP hosts (v2 current; v1 scenarios retained for the frozen v1 tree).",
   "repository": {
     "type": "git",
@@ -56,6 +56,6 @@
     "@openwop/spec-artifacts": "file:../spec-artifacts"
   },
   "peerDependencies": {
-    "@openwop/spec-artifacts": "2.46.30"
+    "@openwop/spec-artifacts": "2.46.32"
   }
 }

package/requirements.json

@@ -2,11 +2,11 @@
   "$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": 751,
-    "tests": 2857,
-    "withStableId": 2857,
+    "files": 752,
+    "tests": 2863,
+    "withStableId": 2863,
     "interpolatedTitles": 0,
-    "explicitIds": 2730
+    "explicitIds": 2736
   },
   "records": [
     {
@@ -31105,6 +31105,80 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-eval-recorded-fixtures.the-recordedfixtures-member-eval-started-fixtureruns-and-the-createrun-property",
+      "file": "v2-eval-recorded-fixtures.test.ts",
+      "line": 130,
+      "title": "the recordedFixtures member, eval.started.fixtureRuns and the createRun property are in the derived contract",
+      "explicitId": "openwop.requirement.0252.shape",
+      "citations": [
+        {
+          "section": "agents.schema.json §evalSuite.recordedFixtures, createRun fixtureRuns, eval.started.fixtureRuns (RFC 0252)",
+          "requirement": "recordedFixtures: true MUST validate"
+        },
+        {
+          "section": "agents.schema.json §evalSuite.recordedFixtures, createRun fixtureRuns, eval.started.fixtureRuns (RFC 0252)",
+          "requirement": "recordedFixtures MUST be a boolean"
+        },
+        {
+          "section": "agents.schema.json §evalSuite.recordedFixtures, createRun fixtureRuns, eval.started.fixtureRuns (RFC 0252)",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "agents.schema.json §evalSuite.recordedFixtures, createRun fixtureRuns, eval.started.fixtureRuns (RFC 0252)",
+          "requirement": "an empty fixtureRuns MUST be refused"
+        },
+        {
+          "section": "agents.schema.json §evalSuite.recordedFixtures, createRun fixtureRuns, eval.started.fixtureRuns (RFC 0252)",
+          "requirement": "a fixtureRuns value MUST be a runId"
+        },
+        {
+          "section": "agents.schema.json §evalSuite.recordedFixtures, createRun fixtureRuns, eval.started.fixtureRuns (RFC 0252)",
+          "requirement": "createRun MUST carry fixtureRuns, a non-empty map onto runIds"
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-eval-recorded-fixtures.the-replay-is-served-the-source-run-s-recorded-answers-and-never-reaches-the-liv",
+      "file": "v2-eval-recorded-fixtures.test.ts",
+      "line": 149,
+      "title": "the replay is served the source run's recorded answers and never reaches the live tool",
+      "explicitId": "openwop.requirement.0252.source-replayed",
+      "citations": []
+    },
+    {
+      "id": "openwop.it.v2-eval-recorded-fixtures.a-call-the-source-never-made-misses-fails-the-task-and-never-runs-live",
+      "file": "v2-eval-recorded-fixtures.test.ts",
+      "line": 158,
+      "title": "a call the source never made misses, fails the task, and never runs live",
+      "explicitId": "openwop.requirement.0252.drift-fails-closed",
+      "citations": []
+    },
+    {
+      "id": "openwop.it.v2-eval-recorded-fixtures.an-unknown-source-and-a-run-that-never-invoked-the-agent-are-refused-without-the",
+      "file": "v2-eval-recorded-fixtures.test.ts",
+      "line": 167,
+      "title": "an unknown source, and a run that never invoked the agent, are refused without the id",
+      "explicitId": "openwop.requirement.0252.source-refused",
+      "citations": []
+    },
+    {
+      "id": "openwop.it.v2-eval-recorded-fixtures.another-tenant-s-run-is-refused-exactly-as-an-id-that-never-existed",
+      "file": "v2-eval-recorded-fixtures.test.ts",
+      "line": 186,
+      "title": "another tenant's run is refused exactly as an id that never existed",
+      "explicitId": "openwop.requirement.0252.source-uniform",
+      "citations": []
+    },
+    {
+      "id": "openwop.it.v2-eval-recorded-fixtures.a-key-naming-no-task-a-target-with-its-own-fixtures-and-fixtureruns-without-mode",
+      "file": "v2-eval-recorded-fixtures.test.ts",
+      "line": 203,
+      "title": "a key naming no task, a target with its own fixtures, and fixtureRuns without mode are refused",
+      "explicitId": "openwop.requirement.0252.fields-refused",
+      "citations": []
+    },
     {
       "id": "openwop.it.v2-eval-regression-baseline.the-baselineselection-member-and-the-createrun-eval-properties-are-in-the-derive",
       "file": "v2-eval-regression-baseline.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": 663,
+    "files": 664,
     "v1": 455,
-    "v2": 223
+    "v2": 224
   },
   "majors": {
     "a2a-1-0-agent-card.test.ts": [
@@ -1485,6 +1485,9 @@
     "v2-eval-mode-unadvertised-refused.test.ts": [
       2
     ],
+    "v2-eval-recorded-fixtures.test.ts": [
+      2
+    ],
     "v2-eval-regression-baseline.test.ts": [
       2
     ],

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.46.30",
-  "corpusTag": "v2.46.30",
+  "version": "2.46.32",
+  "corpusTag": "v2.46.32",
   "files": {
     "api/.redocly.lint-ignore.yaml": "bf5a8350b88a72fa43f59605ed8d903ed24b6cfccda5e45509c9f6ed9ee4e712",
     "api/asyncapi.yaml": "d5ecb9ee6114582be3b1f662c84bfac9ae96dae7bacb853e461168f70a8e1c7d",
     "api/grpc/openwop.proto": "c3e72bb17cba514ee98feb6434e6c9b6ea6795bfd086489ec69fd882dd1ad977",
     "api/openapi.yaml": "ac6de5303872664b78ff419c035915593e01599e02835e777a0123de1baeb398",
     "api/redocly.yaml": "b0604c89b2ca6d5076ec25725c539dad44a741a811fe524439ee6daef8baa09f",
-    "api/seams-v2.yaml": "08c68b844a0298d1f7232e5956713ed5235414eca608782f8c9cc607cee06f32",
-    "api/v2/asyncapi.yaml": "edfda007ec4a3ef1ceafa8125c87d02dbf77367e4816f0b41455c9827ae3f8fe",
-    "api/v2/openapi.yaml": "2e8450ca565d0fe75c27dae848122891ba80e5fa40f0876796c51979572efd44",
+    "api/seams-v2.yaml": "2a890e944caa3925d4e5ba1f2f6a74b0a20f5449d1cefddf27fb625b763432f7",
+    "api/v2/asyncapi.yaml": "6498030118946490e6eeeb96c9c16b95a6334a55b6e5e50f203c94b197a083b3",
+    "api/v2/openapi.yaml": "2e7da662960ecf05088eeb24b2eb2996f481c16ba5b8fc867e7869ad3f9ab20e",
     "api/v2/redocly.yaml": "1e66b60e6118ad11a823bb620678be464d99dfe50a40e3e6f93ec9429b88b34c",
     "schemas/README.md": "276fc1d51eb08e14e9127b9fd27761d7046ee33c12000f3a64a801322db8bf58",
     "schemas/a2a-task-state.schema.json": "75d5049dea8bd873ff0e7546f1c60c8d36c219bec7084264360be54a8be30ae1",
@@ -117,7 +117,7 @@
     "schemas/v2/artifact.schema.json": "85b9dc284d39b99d2a66fa8cbf47f2dd3d8526d3bd6cc411ad315b372de38975",
     "schemas/v2/audit-verify-result.schema.json": "14af8e9283510f0a40e48a2059c929ee44e0fc9fa3cc66a95bfbe90b17c48297",
     "schemas/v2/budget-policy.schema.json": "1de68095db0beb5c7a4be629de26e79f62ebbe748a88d46f36e768edfd1f0d68",
-    "schemas/v2/capabilities.schema.json": "b06b8142d288e839fe871bdddde35ca08d38d00da2a510fb9cb4ab201f37aa99",
+    "schemas/v2/capabilities.schema.json": "e580833bd80ce894ce610290de8766f15b9007642456a7404470ca81e0bf3170",
     "schemas/v2/certification-bundle.schema.json": "5cfa7fb5247160333e33a58b60d42bcd4e5269d8391d6a112d301e14828892ed",
     "schemas/v2/channel-presence-payload.schema.json": "fc03df0c20cc12a25f7ee6a47503a4c5931d79fe3d5ff24815e8fd7c1bcb9a87",
     "schemas/v2/channel-written-payload.schema.json": "ccecff3c71a3275ad8db035ac0e04db25e6f8d23cf091ddbcd5a60d1be1cbb6b",
@@ -178,7 +178,7 @@
     "schemas/v2/residency.schema.json": "3fd23c9732beb140504e81560fc426eb6764d547e56da5fb92c5a5c7bf04db3a",
     "schemas/v2/run-ancestry-response.schema.json": "334c17f2062dea62726ca1d07b8be3f169cdc422af843c1def5fb317039814c9",
     "schemas/v2/run-diff-response.schema.json": "8bdb2045c274580038bd74781f7d062f5049839797c164a89de4ed89edc53a74",
-    "schemas/v2/run-event-payloads.schema.json": "e21d0cb64cb969be32e49e87f3af418bacb40e8fcb515a848dfe7d9609d8d0b6",
+    "schemas/v2/run-event-payloads.schema.json": "8b4907cfd123d0b875a60899cd3c46c24a6b3af5a6a7e904070355477fa84814",
     "schemas/v2/run-event.schema.json": "2f0d7416bd376c56affe97b6b2b49981532e8e9ff45c0a162cf806c78b3e7fb7",
     "schemas/v2/run-list-response.schema.json": "c2dbc34768dcf64528914a213aa3cb55952e8e3e90a64b04a9423b2a19749d38",
     "schemas/v2/run-options.schema.json": "f0e9f494d80086c2ed2cf9fe87df54e5b4e66601699c4a1089f4edbc7ba58867",
@@ -212,14 +212,14 @@
     "schemas/workspace-file.schema.json": "464de85c2a068243084ee9c1d969bc7cd5d8f7948574e58450d6493c38a0e1e4",
     "spec/v1/alias-detectors.json": "22444c22bb88c568339ef512553f9fc38146e22b566d11ab8608f655d688d19c",
     "spec/v1/capability-declaration-classes.json": "e7729aed5c4b4e1dd02abab0530f14cc95f5d4070fe51fb139e7f5cccefa00c6",
-    "spec/v1/core-standard-manifest.json": "e341bdbad39a25a8c04f535b1dc44d581b5473069c5ebbe786f5f8031f61a679",
+    "spec/v1/core-standard-manifest.json": "c8cca62eac811cb159b789202137f01c658ea8a88b2a4d7c3b450f28c7cb997f",
     "spec/v1/deprecations.json": "e723bc11d7272c71789ad1303bb7f21809a8a024abf57594f9d5c35dc199ece9",
     "spec/v1/deprecations.schema.json": "3e393c405d2a41b467d8c5e3c468549078df1ce6a6d2588fc488097b95d9b55b",
     "spec/v1/end-of-support.json": "35f0bf3b70fe78b16e2a2fd81a153fc27e703f6c16376c6fe7cdf1f4f2c4e6d4",
     "spec/v1/event-codemap.json": "3da60d884157793a360da532a9fcbbfb5285636db325a74cec94b34622186d97",
     "spec/v1/event-codemap.schema.json": "d05933b2e88103aff51a2f774df97b9bda065e0fc88dbd9b114cc47a32189174",
     "spec/v1/extensions.json": "79a60754aa16cbdbdb604f8e5c00038af535a1690a4d07bd5ff7c38f0256a7bc",
-    "spec/v1/gaps.json": "16ab681ea051c41104d53161bcf179704f80659861f7dd3ba8bdbfe3015f71b8",
+    "spec/v1/gaps.json": "c2f6e7de84e8f59bc35e59e5afc39ac1359b78c5b857d6c8b45a46803240362c",
     "spec/v1/gaps.schema.json": "8fd83259f556553c9df0f53e7a82ca8c2a4771d471197f69b4e2ae0ceeacfd66",
     "spec/v1/migrations.json": "4c50760be70cb644d02427bcaf5749606700edf4513f423903cf3b1d12f5c300",
     "spec/v1/migrations.schema.json": "886779aa6c22e646db097f5df210adb018a4dd14a7b815465a18c8a7056c8f72",
@@ -285,7 +285,7 @@
     "spec/v2/ext/sandbox-runtime-notes/README.md": "0d1290fb1e20b2e35c0b15051541ab6546e4e2a6f693b4f912cb3f7d6a65e92c",
     "spec/v2/ext/webResearch/README.md": "b675e6f6646128d781b661f754c2393eed86e5935d16c3a22df582a5ce025b9b",
     "spec/v2/facets/a2a.schema.json": "b68bf5e29e455e46c2ad7cfcccf5963730ec2310ff9db81884550d8df30fd6ef",
-    "spec/v2/facets/agents.schema.json": "198c01fdbb09deeb84f8f45f9f47976e696ac35ef087a2bc5c6f3c4fbb2ac370",
+    "spec/v2/facets/agents.schema.json": "cd6bf5cd1d3d9b61646e0232027f078113e44dd4d0beec3283318fb6c5a5e296",
     "spec/v2/facets/aiProviders.schema.json": "6e4327bcd48110686cc1adfd26ddd6fbbf4ff529c476dcc74eeff8c5ae9965ce",
     "spec/v2/facets/auditLogIntegrity.schema.json": "9a7f81320c8f940c6f4129bc7dd895a4063231c5458a717a08c2cbf9bb886c46",
     "spec/v2/facets/auth.schema.json": "7d98bc81a0f7d307460d039eebfebd21388091bfe1d538762583940f94c0bd2a",
@@ -318,9 +318,9 @@
     "spec/v2/path-manifest.json": "20f598f56df460ad3ed50aba3d6bc2933ea16a3c96ce125da1c5dd6989d4155c",
     "spec/v2/peer-dependency-aliases.json": "d10299280abee08258502925bc327293ee413e0108cd6e6ec75ff6110653308d",
     "spec/v2/profiles.json": "b382b261c7844798575f7c1b37c934f0da19846016a2337d883d4f5ef6e05479",
-    "spec/v2/release.json": "5bb12627a01a0f732dc8ab1f6c7f8d23ed4f583782b83591a1d72803be9592bc",
+    "spec/v2/release.json": "8ce37c12db023b43d7a517a703130cc8baaafcf46dc49ddf9af8339c80321b59",
     "spec/v2/retention-floors.json": "eaf3722d95c79947af1d4269ef85117e126518c588cfcf1a2b21b97269f51624",
-    "spec/v2/surface-baseline.json": "da513617337bdcf1073907d88662f3c853110bb0107e789ea3cfd245e86a0933"
+    "spec/v2/surface-baseline.json": "920c6c86508e70e620595d76a45b6cd428c9bd665d0208b375c33ace60556fae"
   },
-  "corpusCommit": "2c254f70680834a1ed087ba9369dcdbfd1c0a40d"
+  "corpusCommit": "2c0733837695218c74a0875305c704eb500a1665"
 }

package/src/lib/eval-recorded-fixtures-witness.ts

@@ -0,0 +1,88 @@
+/**
+ * RFC 0252 — an eval task takes its fixtures from a recorded run. Pure judges
+ * over four sequential eval runs, for `v2-eval-recorded-fixtures.test.ts`.
+ *
+ * The runs go through the suite-owned counter tool `conformance.eval:counter`,
+ * whose live `inc` changes persistent tenant-scoped state (contract in
+ * `fixtures.md`):
+ *   1. source  `conformance-eval-recorded-source` (live): read P, inc R, read R.
+ *   2. replay  `conformance-eval-recorded-replay`, `fixtureRuns: {record: source}`:
+ *      the same script, served the source's recorded answers.
+ *   3. drift   `conformance-eval-recorded-drift`, the same source: read P,
+ *      inc P, read R. The `inc P` was never recorded, so it misses.
+ *   4. probe   the source suite again, live.
+ * The probe's `inc R` is the source's plus one when neither the replay nor
+ * the drift reached the live counter, and its `read P` equals the source's
+ * when the drift's missed `inc P` never ran. Persistence not shown, or a
+ * counter that moved by more than the replay could explain (a concurrent cut
+ * on the tenant), is `blocked`, never a failure.
+ *
+ * @see RFCS/0252-eval-fixtures-from-a-recorded-run.md
+ */
+
+import type { CounterCall } from './eval-counter-witness.js';
+
+export interface RecordedFinding { readonly ok: boolean; readonly message: string }
+export type RecordedVerdict =
+  | { readonly kind: 'blocked'; readonly reason: string }
+  | { readonly kind: 'judged'; readonly findings: readonly RecordedFinding[] };
+
+type Rec = Record<string, unknown>;
+const isRec = (v: unknown): v is Rec => typeof v === 'object' && v !== null && !Array.isArray(v);
+const count = (c: CounterCall | undefined): number | undefined => {
+  const o = c?.outcome;
+  return isRec(o) && typeof o['count'] === 'number' && Number.isInteger(o['count']) ? o['count'] : undefined;
+};
+
+export const TASK = 'record';
+
+/** The summary entry for task `record`. */
+export function recordTask(summary: Rec): Rec | undefined {
+  const tasks = summary['tasks'];
+  return Array.isArray(tasks) ? tasks.find((t): t is Rec => isRec(t) && t['taskId'] === TASK) : undefined;
+}
+
+/** A source or probe run: read P, inc R, read R, all answered live with `{key, count}`. */
+function liveCounts(calls: readonly CounterCall[], label: string): { P: number; R: number } | { reason: string } {
+  if (calls.length !== 3) return { reason: `the ${label} run MUST log its three scripted counter calls (got ${calls.length})` };
+  const [p, r] = [count(calls[0]), count(calls[1])];
+  if (p === undefined || r === undefined) return { reason: `the ${label} run's counter calls did not all return {key, count} live` };
+  return { P: p, R: r };
+}
+
+/** §E: `eval.started.fixtureRuns` is the accepted map verbatim. */
+export function judgeEchoed(events: readonly { type: string; payload: Rec }[], sent: Rec): RecordedFinding[] {
+  const started = events.filter((e) => e.type === 'eval.started');
+  const got = started[0]?.payload['fixtureRuns'];
+  return [{ ok: started.length === 1 && JSON.stringify(got) === JSON.stringify(sent), message: `eval.started MUST echo fixtureRuns ${JSON.stringify(sent)} (got ${JSON.stringify(got)})` }];
+}
+
+/** §D: the replay was served the source's answers, missed nothing, and the probe shows no live inc R. */
+export function judgeReplayed(source: readonly CounterCall[], replay: readonly CounterCall[], replayTask: Rec | undefined, probe: readonly CounterCall[]): RecordedVerdict {
+  const s = liveCounts(source, 'source');
+  if ('reason' in s) return { kind: 'blocked', reason: s.reason };
+  const p = liveCounts(probe, 'probe');
+  if ('reason' in p) return { kind: 'blocked', reason: p.reason };
+  if (p.R > s.R + 2) return { kind: 'blocked', reason: `counter R moved from ${s.R} to ${p.R} across the replay: more than this scenario can cause, so another run on the tenant is using it` };
+  if (p.R <= s.R) return { kind: 'blocked', reason: `counter R did not persist across runs (source ${s.R}, probe ${p.R})` };
+  const same = replay.length === source.length && replay.every((c, i) => c.returned && JSON.stringify(c.outcome) === JSON.stringify(source[i]!.outcome));
+  return { kind: 'judged', findings: [
+    { ok: same, message: `each replayed counter call MUST return the source run's recorded outcome (source ${JSON.stringify(source.map((c) => c.outcome))}, replay ${JSON.stringify(replay.map((c) => c.outcome))})` },
+    { ok: replayTask?.['fixtureMissCount'] === 0, message: `a replay of the same script MUST miss nothing (fixtureMissCount ${JSON.stringify(replayTask?.['fixtureMissCount'])})` },
+    { ok: p.R === s.R + 1, message: `the replay MUST NOT reach the live counter: the probe's inc R MUST be the source's plus one (source ${s.R}, probe ${p.R})` },
+  ] };
+}
+
+/** §D: an unrecorded call misses, the task fails, and the missed inc P never ran. */
+export function judgeDriftFailsClosed(source: readonly CounterCall[], driftTask: Rec | undefined, driftPassed: unknown, probe: readonly CounterCall[]): RecordedVerdict {
+  const s = liveCounts(source, 'source');
+  if ('reason' in s) return { kind: 'blocked', reason: s.reason };
+  const p = liveCounts(probe, 'probe');
+  if ('reason' in p) return { kind: 'blocked', reason: p.reason };
+  if (p.R <= s.R) return { kind: 'blocked', reason: `counter R did not persist across runs (source ${s.R}, probe ${p.R}), so an unchanged P proves nothing` };
+  return { kind: 'judged', findings: [
+    { ok: driftTask?.['fixtureMissCount'] === 1, message: `the one unrecorded call MUST be counted as a miss (fixtureMissCount ${JSON.stringify(driftTask?.['fixtureMissCount'])})` },
+    { ok: driftPassed === false, message: `a task with a miss under the derived onMiss "fail" MUST NOT pass (passed ${JSON.stringify(driftPassed)})` },
+    { ok: p.P === s.P, message: `the missed inc P MUST NOT reach the live counter: the probe MUST read P as the source did (source ${s.P}, probe ${p.P})` },
+  ] };
+}

package/src/lib/eval-regression-witness.ts

@@ -63,7 +63,7 @@ export function judgeRefused(a: Answer, suppliedId: string | undefined, what: st
     { ok: a.status === 400, message: `${what} MUST be refused 400 before the run starts (got ${a.status})` },
     { ok: readErrorCode(a.json) === 'validation_error', message: `${what} MUST be refused with validation_error (got ${JSON.stringify(readErrorCode(a.json))})` },
   ];
-  if (suppliedId !== undefined) out.push({ ok: !a.text.includes(suppliedId), message: `the refusal of ${what} MUST NOT echo the supplied baselineRunId` });
+  if (suppliedId !== undefined) out.push({ ok: !a.text.includes(suppliedId), message: `the refusal of ${what} MUST NOT echo the supplied run id` });
   return out;
 }
 

package/src/scenarios/v2-eval-recorded-fixtures.test.ts

@@ -0,0 +1,218 @@
+/**
+ * v2 — an eval task takes its fixtures from a recorded run (RFC 0252; the
+ * rules are the `agents.evalSuite.recordedFixtures` facet description in
+ * `spec/v2/facets/agents.schema.json`, the `createRun` `fixtureRuns`
+ * description and `eval.started.fixtureRuns`).
+ *
+ * Server-free leg:
+ *   1. `0252.shape` — the facet member is a boolean, `eval.started` carries
+ *      `fixtureRuns` (taskId → runId, non-empty), and the derived `createRun`
+ *      eval body carries `fixtureRuns`.
+ *
+ * Host legs — gated on `recordedFixtures`, `fixtureMatching`, and the three
+ * `conformance-eval-recorded-*` fixtures in discovery `fixtures`. Four runs
+ * through the reserved counter tool, in order, once per worker: source,
+ * replay (`fixtureRuns: {record: source}`), drift (the same source), and the
+ * source suite again as a probe. Judges in `lib/eval-recorded-fixtures-witness.ts`.
+ *   2. `0252.source-replayed` — `eval.started` echoes the map; each replayed
+ *      call returns the source's outcome; no miss; the probe shows the replay
+ *      never reached the live counter.
+ *   3. `0252.drift-fails-closed` — the unrecorded `inc P` misses, the task
+ *      fails, and the probe reads P unchanged.
+ *   4. `0252.source-refused` — an unknown id, and a `conformance-noop`
+ *      workflow run (when listed) that never invoked the agent, are refused
+ *      `400 validation_error` without the id.
+ *   5. `0252.source-uniform` — tenant B's source run
+ *      (`OPENWOP_TEST_TENANT_B_API_KEY`) is refused exactly as the unknown id.
+ *   6. `0252.fields-refused` — a key naming no task, a target task that
+ *      carries its own fixtures, and `fixtureRuns` without `mode`.
+ *
+ * @see RFCS/0252-eval-fixtures-from-a-recorded-run.md
+ */
+
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { v2Discovery, v2RefValidator } 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 { majorProfile } from '../lib/major-profile.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { API_DIR } from '../lib/paths.js';
+import { pollTerminal, readEvents, isRecord, type Ev } from '../lib/fixture-run-observer.js';
+import { counterCalls, type CounterCall } from '../lib/eval-counter-witness.js';
+import { judgeRefused, judgeUniform, type Answer } from '../lib/eval-regression-witness.js';
+import { judgeDriftFailsClosed, judgeEchoed, judgeReplayed, recordTask, TASK, type RecordedFinding, type RecordedVerdict } from '../lib/eval-recorded-fixtures-witness.js';
+
+const PROFILE = majorProfile(2);
+const UNREADABLE = 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0';
+const DOC = 'agents.schema.json §evalSuite.recordedFixtures, createRun fixtureRuns, eval.started.fixtureRuns (RFC 0252)';
+const AGENT = 'core.conformance.agents.scripted';
+const SUITE_URI = (id: string) => `https://conformance.openwop.dev/eval-suites/${id}`;
+const SOURCE = 'conformance-eval-recorded-source';
+const REPLAY = 'conformance-eval-recorded-replay';
+const DRIFT = 'conformance-eval-recorded-drift';
+const ID_SHAPE = 'openwop.requirement.0252.shape';
+const ID_REPLAYED = 'openwop.requirement.0252.source-replayed';
+const ID_DRIFT = 'openwop.requirement.0252.drift-fails-closed';
+const ID_REFUSED = 'openwop.requirement.0252.source-refused';
+const ID_UNIFORM = 'openwop.requirement.0252.source-uniform';
+const ID_FIELDS = 'openwop.requirement.0252.fields-refused';
+
+type Skip = { skip: [Parameters<typeof softSkip>[0], string] };
+type Done = { runId: string; events: Ev[]; summary: Record<string, unknown>; calls: CounterCall[] };
+type Runs = { source: Done; replay: Done; drift: Done; probe: Done };
+
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> {
+  try { return await fn(); } catch { return null; }
+}
+const answer = (r: OpenWOPResponse): Answer => ({ status: r.status, json: r.json, text: r.text });
+const expectAll = (id: string, findings: readonly RecordedFinding[]): void => {
+  for (const x of findings) expect(x.ok, req(id, DOC, x.message)).toBe(true);
+};
+const expectVerdict = (id: string, v: RecordedVerdict): void => {
+  if (v.kind === 'blocked') return softSkip('blocked', v.reason);
+  expectAll(id, v.findings);
+};
+
+async function gate(): Promise<Skip | null> {
+  let doc: Record<string, unknown> | null;
+  try { doc = await v2Discovery(); } catch { return { skip: ['blocked', UNREADABLE] }; }
+  const agents = doc?.['agents'];
+  const facet = isRecord(agents) && isRecord(agents['evalSuite']) ? agents['evalSuite'] : null;
+  if (facet === null || facet['recordedFixtures'] !== true) return { skip: ['inapplicable', 'the host does not advertise agents.evalSuite.recordedFixtures'] };
+  if (facet['fixtureMatching'] !== true) return { skip: ['inapplicable', 'the host advertises recordedFixtures without fixtureMatching'] };
+  for (const id of [SOURCE, REPLAY, DRIFT]) if (!isFixtureAdvertised(id)) return { skip: ['inapplicable', `the host does not advertise fixture ${id}`] };
+  return null;
+}
+
+const create = (id: string, extra: Record<string, unknown>, headers?: Record<string, string>) =>
+  http(() => driver.post(PROFILE.runsPath, { mode: 'eval', evalSuiteRef: SUITE_URI(id), agentId: AGENT, ...extra }, headers ? { headers } : {}));
+
+async function complete(id: string, extra: Record<string, unknown>): Promise<Skip | Done> {
+  const res = await create(id, extra);
+  if (res === null) return { skip: ['blocked', 'POST /runs unreachable (fetch failed)'] };
+  if (res.status === 429) return { skip: ['blocked', 'POST /runs answered 429 — the run budget, not the wire'] };
+  const runId = isRecord(res.json) && typeof res.json['runId'] === 'string' ? res.json['runId'] : undefined;
+  if ((res.status !== 201 && res.status !== 202) || runId === undefined) return { skip: ['blocked', `createRun of ${id} answered ${res.status} ${readErrorCode(res.json) ?? ''}`.trim()] };
+  const terminal = await pollTerminal(PROFILE, runId, { timeoutMs: 60_000 });
+  if (terminal.snapshot['status'] !== 'completed') return { skip: ['blocked', `eval run ${runId} ended ${String(terminal.snapshot['status'])}, not completed`] };
+  const s = await http(() => driver.get(`${PROFILE.runsPath}/${PROFILE.idSegment(runId)}/eval-summary`));
+  if (s === null || s.status !== 200 || !isRecord(s.json)) return { skip: ['blocked', `GET …/eval-summary answered ${s?.status ?? 'nothing'}`] };
+  const events = await readEvents(PROFILE, runId);
+  return { runId, events, summary: s.json, calls: counterCalls(events, AGENT) };
+}
+
+let seq: Promise<Skip | Runs> | undefined;
+/** Source → replay → drift → probe, strictly in order, once per worker: the host legs read the same runs. */
+function runs(): Promise<Skip | Runs> {
+  seq ??= (async (): Promise<Skip | Runs> => {
+    const source = await complete(SOURCE, {});
+    if ('skip' in source) return source;
+    const replay = await complete(REPLAY, { fixtureRuns: { [TASK]: source.runId } });
+    if ('skip' in replay) return replay;
+    const drift = await complete(DRIFT, { fixtureRuns: { [TASK]: source.runId } });
+    if ('skip' in drift) return drift;
+    const probe = await complete(SOURCE, {});
+    if ('skip' in probe) return probe;
+    return { source, replay, drift, probe };
+  })();
+  return seq;
+}
+
+/** An id in the caller's own tenant, with the runId grammar, that the host never minted. */
+const unknownBeside = (runId: string): string => `${runId.split('/')[0]}/${randomBytes(16).toString('hex')}`;
+
+describe('v2 RFC 0252 — wire shape (server-free)', () => {
+  it('the recordedFixtures member, eval.started.fixtureRuns and the createRun property are in the derived contract', () => {
+    const facet = v2RefValidator('capabilities.schema.json#/properties/agents/properties/evalSuite/properties/recordedFixtures');
+    expect(facet(true).ok, req(ID_SHAPE, DOC, 'recordedFixtures: true MUST validate')).toBe(true);
+    expect(facet('yes').ok, req(ID_SHAPE, DOC, 'recordedFixtures MUST be a boolean')).toBe(false);
+    const started = v2RefValidator('run-event-payloads.schema.json#/$defs/evalStarted');
+    const base = { suiteId: 'core.openwop.evals.x', suiteVersion: '1.0.0', taskCount: 1, modes: ['golden'] };
+    const r = started({ ...base, fixtureRuns: { record: 'conformance-tenant/0123456789abcdef0123456789abcdef' } });
+    expect(r.ok, req(ID_SHAPE, DOC, `eval.started with fixtureRuns MUST validate: ${r.errors}`)).toBe(true);
+    expect(started({ ...base, fixtureRuns: {} }).ok, req(ID_SHAPE, DOC, 'an empty fixtureRuns MUST be refused')).toBe(false);
+    expect(started({ ...base, fixtureRuns: { record: 42 } }).ok, req(ID_SHAPE, DOC, 'a fixtureRuns value MUST be a runId')).toBe(false);
+    const api = readFileSync(join(API_DIR, 'v2', 'openapi.yaml'), 'utf8');
+    const at = api.indexOf('operationId: createRun');
+    const next = api.indexOf('operationId:', at + 1);
+    const block = at < 0 ? '' : api.slice(at, next < 0 ? undefined : next);
+    expect(block, req(ID_SHAPE, DOC, 'createRun MUST carry fixtureRuns, a non-empty map onto runIds')).toMatch(/fixtureRuns:\s*\n\s*type: object\s*\n\s*minProperties: 1[\s\S]*?additionalProperties:\s*\n\s*\$ref: \.\.\/\.\.\/schemas\/v2\/ids\.schema\.json#\/\$defs\/runId/);
+  });
+});
+
+describe('v2 RFC 0252 — an eval task takes its fixtures from a recorded run (host)', () => {
+  it('the replay is served the source run\'s recorded answers and never reaches the live tool', async () => {
+    const g = await gate();
+    if (g) return softSkip(...g.skip);
+    const r = await runs();
+    if ('skip' in r) return softSkip(...r.skip);
+    expectAll(ID_REPLAYED, judgeEchoed(r.replay.events, { [TASK]: r.source.runId }));
+    expectVerdict(ID_REPLAYED, judgeReplayed(r.source.calls, r.replay.calls, recordTask(r.replay.summary), r.probe.calls));
+  });
+
+  it('a call the source never made misses, fails the task, and never runs live', async () => {
+    const g = await gate();
+    if (g) return softSkip(...g.skip);
+    const r = await runs();
+    if ('skip' in r) return softSkip(...r.skip);
+    const task = recordTask(r.drift.summary);
+    expectVerdict(ID_DRIFT, judgeDriftFailsClosed(r.source.calls, task, task?.['passed'], r.probe.calls));
+  });
+
+  it('an unknown source, and a run that never invoked the agent, are refused without the id', async () => {
+    const g = await gate();
+    if (g) return softSkip(...g.skip);
+    const r = await runs();
+    if ('skip' in r) return softSkip(...r.skip);
+    const unknownId = unknownBeside(r.source.runId);
+    const unknown = await create(REPLAY, { fixtureRuns: { [TASK]: unknownId } });
+    if (unknown === null) return softSkip('blocked', 'POST /runs unreachable (fetch failed)');
+    expectAll(ID_REFUSED, judgeRefused(answer(unknown), unknownId, 'an unknown source run'));
+    // The second case needs a workflow run of the scripted fixture; without conformance-noop only the unknown id is judged.
+    const wf = isFixtureAdvertised('conformance-noop') ? await http(() => driver.post(PROFILE.runsPath, { workflowId: 'conformance-noop' })) : null;
+    const wfId = wf && isRecord(wf.json) && typeof wf.json['runId'] === 'string' ? wf.json['runId'] : undefined;
+    if (wfId !== undefined) {
+      await pollTerminal(PROFILE, wfId, { timeoutMs: 30_000 });
+      const noAgent = await create(REPLAY, { fixtureRuns: { [TASK]: wfId } });
+      if (noAgent !== null) expectAll(ID_REFUSED, judgeRefused(answer(noAgent), wfId, 'a source run that never invoked the agent'));
+    }
+  });
+
+  it("another tenant's run is refused exactly as an id that never existed", async () => {
+    const g = await gate();
+    if (g) return softSkip(...g.skip);
+    const tenantB = process.env['OPENWOP_TEST_TENANT_B_API_KEY']?.trim();
+    if (!tenantB) return softSkip('blocked', 'OPENWOP_TEST_TENANT_B_API_KEY (a credential bound to a second tenant) is not set');
+    if (tenantB === process.env['OPENWOP_API_KEY']) return softSkip('blocked', 'OPENWOP_TEST_TENANT_B_API_KEY equals OPENWOP_API_KEY — the leg needs a second tenant');
+    const foreign = await create(SOURCE, {}, { Authorization: `Bearer ${tenantB}` });
+    const foreignId = foreign && isRecord(foreign.json) && typeof foreign.json['runId'] === 'string' ? foreign.json['runId'] : undefined;
+    if (foreignId === undefined) return softSkip('blocked', `tenant B's createRun of ${SOURCE} answered ${foreign?.status ?? 'nothing'}`);
+    const r = await runs();
+    if ('skip' in r) return softSkip(...r.skip);
+    const unknown = await create(REPLAY, { fixtureRuns: { [TASK]: unknownBeside(r.source.runId) } });
+    const viaForeign = await create(REPLAY, { fixtureRuns: { [TASK]: foreignId } });
+    if (unknown === null || viaForeign === null) return softSkip('blocked', 'POST /runs unreachable (fetch failed)');
+    expectAll(ID_UNIFORM, judgeUniform(answer(unknown), answer(viaForeign), foreignId));
+  });
+
+  it('a key naming no task, a target with its own fixtures, and fixtureRuns without mode are refused', async () => {
+    const g = await gate();
+    if (g) return softSkip(...g.skip);
+    const r = await runs();
+    if ('skip' in r) return softSkip(...r.skip);
+    const map = { [TASK]: r.source.runId };
+    const noTask = await create(REPLAY, { fixtureRuns: { nope: r.source.runId } });
+    const ownFixtures = await create(SOURCE, { fixtureRuns: map });
+    if (noTask === null || ownFixtures === null) return softSkip('blocked', 'POST /runs unreachable (fetch failed)');
+    expectAll(ID_FIELDS, judgeRefused(answer(noTask), undefined, 'a fixtureRuns key naming no task of the suite'));
+    expectAll(ID_FIELDS, judgeRefused(answer(ownFixtures), undefined, 'a named task whose suite fixtures carry toolResponses or onMiss'));
+    // A workflow create needs a workflow the host holds, or its 404 would answer first.
+    const noMode = isFixtureAdvertised('conformance-noop') ? await http(() => driver.post(PROFILE.runsPath, { workflowId: 'conformance-noop', fixtureRuns: map })) : null;
+    if (noMode !== null) expectAll(ID_FIELDS, judgeRefused(answer(noMode), undefined, 'fixtureRuns without mode eval'));
+  });
+});

package/src/scenarios/v2-eval-trajectory-trials.test.ts

@@ -239,7 +239,7 @@ describe('v2 RFC 0244 — wire shape (server-free)', () => {
   });
 
   it('the eval-suite fixtures validate against the v2 suite schema', () => {
-    for (const id of ['conformance-eval-trajectory', 'conformance-eval-trials', 'conformance-eval-fixture-miss', 'conformance-eval-trajectory-gate', 'conformance-eval-trajectory-gate-mean', 'conformance-eval-fixture-error', 'conformance-eval-counter-live', 'conformance-eval-counter-miss', 'conformance-eval-efficiency-ungated', 'conformance-eval-memory-isolation', 'conformance-eval-gate-failing', 'conformance-eval-regression-base', 'conformance-eval-regression-candidate']) {
+    for (const id of ['conformance-eval-trajectory', 'conformance-eval-trials', 'conformance-eval-fixture-miss', 'conformance-eval-trajectory-gate', 'conformance-eval-trajectory-gate-mean', 'conformance-eval-fixture-error', 'conformance-eval-counter-live', 'conformance-eval-counter-miss', 'conformance-eval-efficiency-ungated', 'conformance-eval-memory-isolation', 'conformance-eval-gate-failing', 'conformance-eval-regression-base', 'conformance-eval-regression-candidate', 'conformance-eval-recorded-source', 'conformance-eval-recorded-replay', 'conformance-eval-recorded-drift']) {
       const r = suiteSchema(fixture(id));
       expect(r.ok, req(ID_FIXTURES, 'fixtures.md §eval-suites', `${id} MUST validate: ${r.errors}`)).toBe(true);
     }