@openwop/openwop-conformance 2.46.18 → 2.46.20

package/CHANGELOG.md

@@ -1,3 +1,16 @@
+## [2.46.20] — 2026-10-24 — RFC 0081 eval envelope legs; RFC 0249 Draft
+
+- **Two new legs in `v2-eval-trajectory-trials` (RFC 0081 §C)**, on the existing `conformance-eval-trajectory` run, so no extra run: `0081.eval-envelope` (one `eval.started` and one `eval.completed` bracket every `eval.scored`, `eval.completed` precedes `run.completed`, and its counts equal the summary's) and `0081.summary-served` (the served `EvalSummary` validates and its counts match its rows). Judges in `lib/eval-envelope-witness.ts`, whose self-tests fail each wrong host answer. Before this, no v2 leg read `eval.completed`.
+- **Host impact:** hosts that advertise `agents.evalSuite.trajectory` and list the fixture (openwop-app, MyndHyve) run both legs. A host that omits `eval.completed` fails `0081.eval-envelope`.
+- RFC 0249 (v2 proposal operations and an install read-back for RFC 0096) is filed as `Draft`. Its gap register lands in the packed `spec/v1/gaps.json`, which opened this cycle.
+
+## [2.46.19] — 2026-10-22 — RFC 0248: ctx.callAI attempt accounting and retry policy
+
+- **New scenario `v2-callai-attempt-accounting`** with eight legs: `0248.attempts-count`, `output-tokens-sum`, `usage-incomplete`, `structured-output`, `attempts-replayed`, `max-attempts-cap`, `no-budget-growth` and `retry-malformed-refused`. They are gated on `aiProviders.callAccounting.attempts` / `.retryPolicy` and the fixture.
+- **New fixture `conformance-callai-attempt-accounting`.** Its node `conformance.callai.echo-attempts` makes one `ctx.callAI` call through the host's conformance mock, which serves the run's `script`, and echoes `attempts`. The mock clamps reported `outputTokens` to each request's `maxTokens`. No seam is used: the legs read `provider.usage`, `envelope.retry-exhausted` and node outputs. The judges are in `lib/callai-attempts-witness.ts`, and their self-tests fail each wrong host answer.
+- **`aiProviders.callAccounting {attempts, retryPolicy}`** is added to the facet, with the RFC 0248 rules in its descriptions.
+- **Host impact: none today.** No host advertises `callAccounting` or lists the fixture.
+
 ## [2.46.18] — 2026-10-18 — RFC 0245: a success return need not carry outcome
 
 - **`0245.fixture-error-replayed` no longer requires `outcome` on the success return.** `outcome` is optional on `agent.tool-returned`, and RFC 0064 §F lets a host omit it. The leg now asserts that the second return carries no `error` (and no `status: "error"` under tool hooks). This is an erratum from openwop-app's implementation (ADR 0929). No host was judged under 2.46.17.

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 658 scenario files under `src/scenarios/`. By target major ([`scenario-majors.json`](./scenario-majors.json)): 218 files run against a v2 host and 455 against a v1 host; 15 of them run at both.
+The current suite has 659 scenario files under `src/scenarios/`. By target major ([`scenario-majors.json`](./scenario-majors.json)): 219 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: 658 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: 659 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.18",
-  "stampSha256": "4e40e9463c8a0a9554e81e19d745f8dd90d59250be85da01cc3fc43eca1076f3"
+  "version": "2.46.20",
+  "stampSha256": "426586e18ceca126f915b8517b442ecc6178e3f2cecde3325bf00dcfd76fb37d"
 }

package/fixtures/conformance-callai-attempt-accounting.json

@@ -0,0 +1,24 @@
+{
+  "id": "conformance-callai-attempt-accounting",
+  "name": "Conformance: ctx.callAI attempt accounting and retry policy (RFC 0248)",
+  "version": "1.0",
+  "description": "Fixture for `v2-callai-attempt-accounting.test.ts` (RFC 0248; the rules are the `aiProviders.callAccounting` facet descriptions). One node, `conformance.callai.echo-attempts` (conformance-RESERVED). It makes exactly one `ctx.callAI` call through the host's conformance mock provider, passing `inputs.request` (`prompt`, and optionally `responseSchema`, `maxTokens`, `retry`) unchanged. The mock serves `inputs.script` to that call's provider requests in order, one entry per request: `{ kind: \"invalid-json\" | \"truncated\" | \"valid\", outputTokens?, usage?, structuredMode? }`; `invalid-json` is the reply `{ this is not json }` (a parse error, never the natural-language fallback), `valid` is a minimal instance of `responseSchema` (or `ok` without one); past the end it repeats the last entry. The mock reports `outputTokens = min(entry.outputTokens, the maxTokens THAT request carried)` (no clamp when the request carried none), and serves an entry whose `outputTokens` exceeds that budget as truncated. `usage: false` means that request reports no usage. For a call with `responseSchema`, the mock uses `structuredMode` (default `prompt`) as the request's structured-output mode. The node completes with `outputs.attempts`, the `attempts` record of the `ctx.callAI` result verbatim, and does no counting of its own. A call that throws fails the node with the error's code and details, unchanged. A host that does not advertise `aiProviders.callAccounting` MUST NOT advertise this fixture.",
+  "nodes": [
+    {
+      "id": "callai-echo",
+      "typeId": "conformance.callai.echo-attempts",
+      "name": "Echo ctx.callAI attempts",
+      "position": { "x": 0, "y": 0 },
+      "config": {},
+      "inputs": {}
+    }
+  ],
+  "edges": [],
+  "triggers": [{ "id": "manual", "type": "manual", "enabled": true }],
+  "variables": [
+    { "name": "request", "type": "object" },
+    { "name": "script", "type": "array" }
+  ],
+  "metadata": { "tags": ["conformance", "aiProviders", "callAccounting"] },
+  "settings": { "timeout": 0 }
+}

package/fixtures.md

@@ -133,6 +133,7 @@ All fixtures MUST advertise:
 | v2 Storage Tenant-Isolation Probe | `conformance-storage-probe` | `storage.md` §Shared rules — one `core.conformance.storage-probe` node (conformance-RESERVED) calls the host's own storage `family` for the run's tenant: `write` stores `value` at `key`, `read` returns every value and key the family's isolated reads return for `key`, `delete` removes it. See §"The storage probe fixtures" | `completed`, or `failed` (`forbidden` / `not_found`) for a refused read | ≤ 30s |
 | v2 fs Sandbox Probe | `conformance-fs-probe` | `storage.md` §`fs` — one `core.conformance.fs-probe` node (conformance-RESERVED) calls the host's own `ctx.fs.read` / `write` with the run's `path`, unchanged; a rejection fails the node with its code and details. Operator symlink `<sandboxRoot>/conformance/escape-link` points outside the root. See §"The storage probe fixtures" | `completed` inside the root; `failed` (`forbidden`, `details.reason: path-outside-sandbox`) for an escape | ≤ 30s |
 | v2 tableStorage Schema Probe | `conformance-table-schema-probe` | `storage.md` §`tableStorage` — one `core.conformance.table-schema-probe` node (conformance-RESERVED) creates a table `{ k: string, n: number }` with the host's own `ctx.storage.table`, then inserts a well-typed row (`control`), a row whose `n` is a string (`insert-mistyped`), or updates `n` to a string (`update-mistyped`). See §"The tableStorage schema probe fixture" | `completed` for `control`; `failed` (`validation_error`, `details.service: tableStorage`) for a mistyped write | ≤ 30s |
+| v2 ctx.callAI Attempt Accounting | `conformance-callai-attempt-accounting` | RFC 0248 — one `conformance.callai.echo-attempts` node (conformance-RESERVED) that makes one `ctx.callAI` call through the host's conformance mock, serves the run's `script`, and echoes the result's `attempts` (`v2-callai-attempt-accounting`) | each case run completes or fails as its script dictates | ≤ 30s |
 | v2 safeFetch SSRF Probe | `conformance-safefetch-probe` | `host-services.md` §`httpClient` — one `core.conformance.safefetch-probe` node (conformance-RESERVED) calls the host's own `ctx.http.safeFetch(url)` with the run's `url`, unchanged; completes with the response `status` only; a rejection fails the node with its code and details. See §"The safeFetch probe fixture" | `failed` (`egress_denied`, `details.reason: ssrf-blocked`) for a refused target | ≤ 60s |
 | A2A Task Roundtrip                        | `conformance-a2a-task-roundtrip`                                                                | Track 6 — host consumes the conformance suite's synthetic A2A peer; covers drift points #3 (`AUTH_REQUIRED`) and #4 (`REJECTED`). Node `core.conformance.a2a-invoke` is a **conformance-RESERVED** typeId (renamed 2026-08-16 from `core.a2a.invoke`, a multi-segment `core.*` id no host shipped and the corpus never defined): a host that consumes A2A peers MUST map it to its A2A bridge node (a host-extension node — `a2a-integration.md` §"State projection"); a host that does not consume A2A MUST NOT advertise this fixture                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `failed` or `waiting-input` (per `driftScenario` input)                             | ≤ 30s                        |
 | WASM Pack Roundtrip                       | `conformance-wasm-pack-roundtrip`                                                               | RFC 0008 — invokes `vendor.openwop.rust-hello.greet` (loaded WASM pack); exercises required exports + at least one import                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `completed`                                                                         | ≤ 10s                        |
@@ -814,6 +815,26 @@ For `v2-tool-catalog-annotations`' unclassified-MCP leg, a host that advertises
 
 ---
 
+## The ctx.callAI attempt-accounting fixture (RFC 0248)
+
+`conformance-callai-attempt-accounting` is what `v2-callai-attempt-accounting` drives. Its node, `conformance.callai.echo-attempts`, is conformance-RESERVED. A host that advertises `aiProviders.callAccounting` maps it to a node that makes exactly one `ctx.callAI` call through the host's conformance mock provider. It does no counting of its own. A host that does not advertise `callAccounting` MUST NOT advertise the fixture.
+
+**Inputs.** `request` is passed to `ctx.callAI` unchanged: `prompt`, and optionally `responseSchema`, `maxTokens` and `retry`. `script` is the mock's replies.
+
+**The mock.** It serves `script` to the call's provider requests in order, one entry per request, and repeats the last entry past the end. Each entry is `{ kind, outputTokens?, usage?, structuredMode? }`:
+
+| Field | Meaning |
+|---|---|
+| `kind` | `invalid-json` (a clean stop with the reply `{ this is not json }`: a parse error, so it never engages the natural-language fallback), `truncated` (a `max_tokens` stop), or `valid` (a minimal instance of `responseSchema`, or `ok` without one) |
+| `outputTokens` | The tokens the reply uses. The mock reports `min(outputTokens, the maxTokens that request carried)`, and serves an entry over that budget as truncated. With no `maxTokens` on the request, there is no clamp |
+| `usage: false` | The request reports no usage |
+| `structuredMode` | For a call with `responseSchema`: `native` or `prompt` (default) is the structured-output mode that request used |
+
+**Output.** The node completes with `outputs.attempts`, the `attempts` record of the `ctx.callAI` result verbatim. A call that throws fails the node with the error's code and details unchanged: a malformed `retry` is `validation_error` with `details.field` naming the key.
+
+**Why the clamp.** A real provider cannot exceed its budget. Clamping makes a host that grows `maxTokens` against `growMaxTokens: false` visible: the over-budget reply completes only under a grown budget, and its `provider.usage.outputTokens` exceeds the request's `maxTokens`.
+
+
 ## The tableStorage schema probe fixture (storage.md)
 
 `conformance-table-schema-probe` is what `v2-table-schema-enforcement` drives. Its node, `core.conformance.table-schema-probe`, is conformance-RESERVED: a host that advertises `tableStorage` maps it to a node that calls its OWN `ctx.storage.table` (`spec/v2/core/storage.md` §`tableStorage`) for the run's tenant, and nothing else. It is a fixture, not a seam: it runs through `POST /runs` under the caller's own credential.

package/package.json

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

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": 746,
-    "tests": 2814,
-    "withStableId": 2814,
+    "files": 747,
+    "tests": 2824,
+    "withStableId": 2824,
     "interpolatedTitles": 0,
-    "explicitIds": 2687
+    "explicitIds": 2697
   },
   "records": [
     {
@@ -29087,6 +29087,70 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-callai-attempt-accounting.attempts-count-equals-the-provider-requests-the-call-made",
+      "file": "v2-callai-attempt-accounting.test.ts",
+      "line": 91,
+      "title": "attempts.count equals the provider requests the call made",
+      "explicitId": "openwop.requirement.0248.attempts-count",
+      "citations": []
+    },
+    {
+      "id": "openwop.it.v2-callai-attempt-accounting.attempts-outputtokens-is-the-sum-over-every-attempt-and-usagecomplete-is-true-wh",
+      "file": "v2-callai-attempt-accounting.test.ts",
+      "line": 97,
+      "title": "attempts.outputTokens is the sum over every attempt, and usageComplete is true when all reported",
+      "explicitId": "openwop.requirement.0248.output-tokens-sum",
+      "citations": []
+    },
+    {
+      "id": "openwop.it.v2-callai-attempt-accounting.an-attempt-that-reported-no-usage-makes-usagecomplete-false",
+      "file": "v2-callai-attempt-accounting.test.ts",
+      "line": 103,
+      "title": "an attempt that reported no usage makes usageComplete false",
+      "explicitId": "openwop.requirement.0248.usage-incomplete",
+      "citations": []
+    },
+    {
+      "id": "openwop.it.v2-callai-attempt-accounting.structuredoutput-is-absent-without-responseschema-and-names-the-mode-the-final-a",
+      "file": "v2-callai-attempt-accounting.test.ts",
+      "line": 109,
+      "title": "structuredOutput is absent without responseSchema and names the mode the final attempt used",
+      "explicitId": "openwop.requirement.0248.structured-output",
+      "citations": []
+    },
+    {
+      "id": "openwop.it.v2-callai-attempt-accounting.a-replay-fork-reproduces-the-recorded-attempts",
+      "file": "v2-callai-attempt-accounting.test.ts",
+      "line": 117,
+      "title": "a replay fork reproduces the recorded attempts",
+      "explicitId": "openwop.requirement.0248.attempts-replayed",
+      "citations": []
+    },
+    {
+      "id": "openwop.it.v2-callai-attempt-accounting.maxattempts-caps-the-provider-requests",
+      "file": "v2-callai-attempt-accounting.test.ts",
+      "line": 131,
+      "title": "maxAttempts caps the provider requests",
+      "explicitId": "openwop.requirement.0248.max-attempts-cap",
+      "citations": []
+    },
+    {
+      "id": "openwop.it.v2-callai-attempt-accounting.growmaxtokens-false-keeps-every-attempt-within-the-request-budget",
+      "file": "v2-callai-attempt-accounting.test.ts",
+      "line": 137,
+      "title": "growMaxTokens false keeps every attempt within the request budget",
+      "explicitId": "openwop.requirement.0248.no-budget-growth",
+      "citations": []
+    },
+    {
+      "id": "openwop.it.v2-callai-attempt-accounting.a-malformed-retry-policy-is-refused-validation-error-naming-the-key",
+      "file": "v2-callai-attempt-accounting.test.ts",
+      "line": 143,
+      "title": "a malformed retry policy is refused validation_error naming the key",
+      "explicitId": "openwop.requirement.0248.retry-malformed-refused",
+      "citations": []
+    },
     {
       "id": "openwop.it.v2-callback-url-guarded.a-host-advertising-callback-delivery-refuses-a-callbackurl-its-egress-guard-woul",
       "file": "v2-callback-url-guarded.test.ts",
@@ -31028,7 +31092,7 @@
     {
       "id": "openwop.it.v2-eval-trajectory-trials.the-rfc-0244-suite-summary-and-event-fields-validate-and-the-negatives-are-refus",
       "file": "v2-eval-trajectory-trials.test.ts",
-      "line": 150,
+      "line": 162,
       "title": "the RFC 0244 suite, summary and event fields validate and the negatives are refused",
       "explicitId": "openwop.requirement.0244.wire-shape",
       "citations": [
@@ -31067,7 +31131,7 @@
     {
       "id": "openwop.it.v2-eval-trajectory-trials.the-rfc-0244-additions-are-content-free-eval-summary-no-content-leak",
       "file": "v2-eval-trajectory-trials.test.ts",
-      "line": 173,
+      "line": 185,
       "title": "the RFC 0244 additions are content-free (eval-summary-no-content-leak)",
       "explicitId": "openwop.requirement.0244.content-free",
       "citations": [
@@ -31084,7 +31148,7 @@
     {
       "id": "openwop.it.v2-eval-trajectory-trials.the-eval-suite-fixtures-validate-against-the-v2-suite-schema",
       "file": "v2-eval-trajectory-trials.test.ts",
-      "line": 180,
+      "line": 192,
       "title": "the eval-suite fixtures validate against the v2 suite schema",
       "explicitId": "openwop.requirement.0244.fixtures-valid",
       "citations": [
@@ -31098,7 +31162,7 @@
     {
       "id": "openwop.it.v2-eval-trajectory-trials.the-rfc-0246-gating-fields-validate-and-stay-in-0-1",
       "file": "v2-eval-trajectory-trials.test.ts",
-      "line": 187,
+      "line": 199,
       "title": "the RFC 0246 gating fields validate and stay in 0–1",
       "explicitId": "openwop.requirement.0246.gated-fields-shape",
       "citations": [
@@ -31120,7 +31184,7 @@
     {
       "id": "openwop.it.v2-eval-trajectory-trials.a-fixture-entry-may-be-marked-iserror-and-only-as-a-boolean-rfc-0245-a",
       "file": "v2-eval-trajectory-trials.test.ts",
-      "line": 195,
+      "line": 207,
       "title": "a fixture entry may be marked isError, and only as a boolean (RFC 0245 §A)",
       "explicitId": "openwop.requirement.0245.fixture-error-shape",
       "citations": [
@@ -31142,7 +31206,7 @@
     {
       "id": "openwop.it.v2-eval-trajectory-trials.a-trajectory-suite-is-graded-per-the-reference-grader",
       "file": "v2-eval-trajectory-trials.test.ts",
-      "line": 205,
+      "line": 217,
       "title": "a trajectory suite is graded per the reference grader",
       "explicitId": "openwop.requirement.0244.trajectory-graded",
       "citations": [
@@ -31173,10 +31237,38 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-eval-trajectory-trials.an-eval-run-brackets-its-scores-with-one-eval-started-and-one-eval-completed-rfc",
+      "file": "v2-eval-trajectory-trials.test.ts",
+      "line": 251,
+      "title": "an eval run brackets its scores with one eval.started and one eval.completed (RFC 0081 §C)",
+      "explicitId": "openwop.requirement.0081.eval-envelope",
+      "citations": [
+        {
+          "section": "run-event-payloads evalStarted / evalCompleted, eval-summary.schema.json (RFC 0081 §C)",
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-eval-trajectory-trials.the-served-evalsummary-validates-and-its-counts-match-its-rows-rfc-0081-c",
+      "file": "v2-eval-trajectory-trials.test.ts",
+      "line": 259,
+      "title": "the served EvalSummary validates and its counts match its rows (RFC 0081 §C)",
+      "explicitId": "openwop.requirement.0081.summary-served",
+      "citations": [
+        {
+          "section": "run-event-payloads evalStarted / evalCompleted, eval-summary.schema.json (RFC 0081 §C)",
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
     {
       "id": "openwop.it.v2-eval-trajectory-trials.repeated-trials-emit-one-eval-scored-per-task-per-trial",
       "file": "v2-eval-trajectory-trials.test.ts",
-      "line": 241,
+      "line": 280,
       "title": "repeated trials emit one eval.scored per task per trial",
       "explicitId": "openwop.requirement.0244.trials-per-task",
       "citations": [
@@ -31194,7 +31286,7 @@
     {
       "id": "openwop.it.v2-eval-trajectory-trials.the-per-task-trials-block-and-trialstats-follow-the-b-formulas",
       "file": "v2-eval-trajectory-trials.test.ts",
-      "line": 252,
+      "line": 291,
       "title": "the per-task trials block and trialStats follow the §B formulas",
       "explicitId": "openwop.requirement.0244.trial-stats-formula",
       "citations": [
@@ -31233,7 +31325,7 @@
     {
       "id": "openwop.it.v2-eval-trajectory-trials.a-fixture-miss-under-onmiss-fail-fails-the-trial-and-is-counted",
       "file": "v2-eval-trajectory-trials.test.ts",
-      "line": 275,
+      "line": 314,
       "title": "a fixture miss under onMiss \"fail\" fails the trial and is counted",
       "explicitId": "openwop.requirement.0244.fixture-miss-fails",
       "citations": [
@@ -31270,7 +31362,7 @@
     {
       "id": "openwop.it.v2-eval-trajectory-trials.a-suite-using-an-unadvertised-rfc-0244-feature-is-refused-at-createrun",
       "file": "v2-eval-trajectory-trials.test.ts",
-      "line": 295,
+      "line": 334,
       "title": "a suite using an unadvertised RFC 0244 feature is refused at createRun",
       "explicitId": "openwop.requirement.0244.unadvertised-feature-refused",
       "citations": [
@@ -31288,7 +31380,7 @@
     {
       "id": "openwop.it.v2-eval-trajectory-trials.under-passrule-mean-a-task-whose-trials-failed-their-trajectory-does-not-pass-rf",
       "file": "v2-eval-trajectory-trials.test.ts",
-      "line": 311,
+      "line": 350,
       "title": "under passRule \"mean\" a task whose trials failed their trajectory does not pass (RFC 0246)",
       "explicitId": "openwop.requirement.0246.mean-gated",
       "citations": [
@@ -31302,7 +31394,7 @@
     {
       "id": "openwop.it.v2-eval-trajectory-trials.a-suite-whose-tasks-failed-their-trajectory-does-not-pass-on-the-output-scores-r",
       "file": "v2-eval-trajectory-trials.test.ts",
-      "line": 324,
+      "line": 363,
       "title": "a suite whose tasks failed their trajectory does not pass on the output scores (RFC 0246)",
       "explicitId": "openwop.requirement.0246.suite-gated",
       "citations": [
@@ -31316,7 +31408,7 @@
     {
       "id": "openwop.it.v2-eval-trajectory-trials.a-fixture-entry-marked-iserror-is-replayed-as-a-tool-error-not-a-success-rfc-024",
       "file": "v2-eval-trajectory-trials.test.ts",
-      "line": 335,
+      "line": 374,
       "title": "a fixture entry marked isError is replayed as a tool error, not a success (RFC 0245)",
       "explicitId": "openwop.requirement.0245.fixture-error-replayed",
       "citations": [
@@ -31330,7 +31422,7 @@
     {
       "id": "openwop.it.v2-eval-trajectory-trials.a-suite-using-iserror-is-refused-at-createrun-without-fixtureerrors-rfc-0245-c",
       "file": "v2-eval-trajectory-trials.test.ts",
-      "line": 349,
+      "line": 388,
       "title": "a suite using isError is refused at createRun without fixtureErrors (RFC 0245 §C)",
       "explicitId": "openwop.requirement.0245.unadvertised-refused",
       "citations": [

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": 658,
+    "files": 659,
     "v1": 455,
-    "v2": 218
+    "v2": 219
   },
   "majors": {
     "a2a-1-0-agent-card.test.ts": [
@@ -1356,6 +1356,9 @@
     "v2-bundle-v3-signed.test.ts": [
       2
     ],
+    "v2-callai-attempt-accounting.test.ts": [
+      2
+    ],
     "v2-callback-url-guarded.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.18",
-  "corpusTag": "v2.46.18",
+  "version": "2.46.20",
+  "corpusTag": "v2.46.20",
   "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": "7d694b3cb21105110cff218f33bdf9c931cee03c6ae54be6e3781dbc2f5789a7",
-    "api/v2/asyncapi.yaml": "5eae29f67aee9447008184f12c04673d84b7a2bed8616c5055b675d33c8a6d29",
-    "api/v2/openapi.yaml": "49bcf512e19b7441d33819c4cb2fce26de0251296d78da3599d509217041e1c1",
+    "api/seams-v2.yaml": "14325981296aaf0ab2dcce8aa96527bd68935c1130bd9bf6103ee6b6c4df4f8e",
+    "api/v2/asyncapi.yaml": "b5f5369bbb35a2c3c75ff6c4f6c9281e77b141dd1d21e9495fef670d72b74a5b",
+    "api/v2/openapi.yaml": "3b17112c01e94987b0cef6a328cc9a6d3a0c0521bbafb14b1fc8abb4e10d9091",
     "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": "87faea080e8043abd16cba19dece777a810731fc3e4455c96c02d0bfd0997d84",
+    "schemas/v2/capabilities.schema.json": "fe28a95bc36767b99cdf529fe7db47dce49c49c5635a724e552c728871c48b06",
     "schemas/v2/certification-bundle.schema.json": "5cfa7fb5247160333e33a58b60d42bcd4e5269d8391d6a112d301e14828892ed",
     "schemas/v2/channel-presence-payload.schema.json": "fc03df0c20cc12a25f7ee6a47503a4c5931d79fe3d5ff24815e8fd7c1bcb9a87",
     "schemas/v2/channel-written-payload.schema.json": "ccecff3c71a3275ad8db035ac0e04db25e6f8d23cf091ddbcd5a60d1be1cbb6b",
@@ -208,14 +208,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": "df4bf8218c18e6a19c7fca67cd6fee1bee705e979c687b8071f8d7e23fb5c10f",
+    "spec/v1/core-standard-manifest.json": "d70cc792bd36812bfcec84c6a8b0d2cd096a3fbed19967afbc8f1dd1a7d26d87",
     "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": "572b68c8a4926339fb94017fcd8f9c78adfaa4900dc809fb8e76b094a7260ba0",
+    "spec/v1/gaps.json": "4655f3087d9917f3b6b7612af23c86a1b338c732a9c1a72ee4a705a1b4f4f7a9",
     "spec/v1/gaps.schema.json": "8fd83259f556553c9df0f53e7a82ca8c2a4771d471197f69b4e2ae0ceeacfd66",
     "spec/v1/migrations.json": "4c50760be70cb644d02427bcaf5749606700edf4513f423903cf3b1d12f5c300",
     "spec/v1/migrations.schema.json": "886779aa6c22e646db097f5df210adb018a4dd14a7b815465a18c8a7056c8f72",
@@ -232,7 +232,7 @@
     "spec/v2/core/execution.md": "4218dbb397534940f83ca5d46561f02bf8f3fdf68d2ae7fefe7f2eb2ed771103",
     "spec/v2/core/form-content-packs.md": "02931227899676fd4581a27017be2a6c4953904717be9b81c29d12f87ab3917d",
     "spec/v2/core/headers.md": "f69fe81e4a3ad21879bb85948660c16860eb05bf152928c31aa4898f6d7d1887",
-    "spec/v2/core/host-services.md": "168a40935a03867ee82461b5d83d05578be25ee3e5af4eb080587b891231e242",
+    "spec/v2/core/host-services.md": "a6b5af882cb1e5c992dddc53c4de06feb36eee01bd566614330041213b3ce657",
     "spec/v2/core/i18n.md": "882904b7d59f992ab1e5f7346167161a54cf665b8fee47e64a3862cf9133a580",
     "spec/v2/core/idempotency.md": "adbd317a6ebb57c2759c076297b31f67def9e391576bccd0bbea787b13e85872",
     "spec/v2/core/identity.md": "d0e3d388484507dd6260601ebf8dd1447b0b0f26ce2fe76c8a5d49e61387cffd",
@@ -254,7 +254,7 @@
     "spec/v2/core/workflow-chain-packs.md": "fdce7a8477e269950a2bac05ee6eddbd66eb0b670b464d00054f7196ec05d29c",
     "spec/v2/corrections.json": "3a8d93e33865b692d26a3b6bfd3819766e206b2e0c2a69669baa4bf833d05a49",
     "spec/v2/corrections.schema.json": "46bbffb954d13bd9995aebc912ceeb2544f7064331abf25fd6ab85c81a5cec94",
-    "spec/v2/declaration.json": "de8558d76a03d07101c5e26a7311d3e90b449f065c9ba418f4abd9c91864a58b",
+    "spec/v2/declaration.json": "5ccdcf9865ca02022c01a551583e1f343a4b7c73fd228049f1be620858a60ad5",
     "spec/v2/declaration.schema.json": "ef951633e4070899f64828f5cf1b5f4870270a0360f81dbb49b5b4d6cd407550",
     "spec/v2/eos-override.json": "4c72d2f6a658943b01c1de1643cf294642091933af7832f38ee5495df684cb2d",
     "spec/v2/errors.json": "1f0e29455edbd22e28f67f221766209c3c55ac4987beb77993b5702dd7cae131",
@@ -282,7 +282,7 @@
     "spec/v2/ext/webResearch/README.md": "b675e6f6646128d781b661f754c2393eed86e5935d16c3a22df582a5ce025b9b",
     "spec/v2/facets/a2a.schema.json": "b68bf5e29e455e46c2ad7cfcccf5963730ec2310ff9db81884550d8df30fd6ef",
     "spec/v2/facets/agents.schema.json": "88fe144572c25e1b09b99fd83e2ad12b2611d4d7366b5d53c3a50d0310faad93",
-    "spec/v2/facets/aiProviders.schema.json": "4eb911c2403b8f618325194855a1326680fbda2549dfbfe86a70dd2743f8fb12",
+    "spec/v2/facets/aiProviders.schema.json": "6e4327bcd48110686cc1adfd26ddd6fbbf4ff529c476dcc74eeff8c5ae9965ce",
     "spec/v2/facets/auditLogIntegrity.schema.json": "9a7f81320c8f940c6f4129bc7dd895a4063231c5458a717a08c2cbf9bb886c46",
     "spec/v2/facets/auth.schema.json": "7d98bc81a0f7d307460d039eebfebd21388091bfe1d538762583940f94c0bd2a",
     "spec/v2/facets/connections.schema.json": "f998bb206a5814183bb4720cc34fa43b7ab64d61e39a79437b009c589ce8b78e",
@@ -314,9 +314,9 @@
     "spec/v2/path-manifest.json": "7b5679a4dad98c80d855361d88a98c8a4e045af15e310862a05b285b815dc9fc",
     "spec/v2/peer-dependency-aliases.json": "d10299280abee08258502925bc327293ee413e0108cd6e6ec75ff6110653308d",
     "spec/v2/profiles.json": "b382b261c7844798575f7c1b37c934f0da19846016a2337d883d4f5ef6e05479",
-    "spec/v2/release.json": "a8ae6035c74fcc0f2b13f1c02bee4862287840cc495840febc867cd66041c8ed",
+    "spec/v2/release.json": "a8b6d20a4ed90b21b4f9feb57a9c2ec5fdb13c74a74f857e5e3aec5ee8e75e40",
     "spec/v2/retention-floors.json": "eaf3722d95c79947af1d4269ef85117e126518c588cfcf1a2b21b97269f51624",
-    "spec/v2/surface-baseline.json": "619c530713063e556abeb0f232cd905942ef8465b73936b9bf4f89ca01fe4485"
+    "spec/v2/surface-baseline.json": "c5aee6bbf8011e11351a4f9e0aafaf444d60af55116c543f04b55b88878cdf83"
   },
-  "corpusCommit": "e4a97e99e7fb158f4091df43da0422866140af2a"
+  "corpusCommit": "3ed6fc93890b4d00c44aafc0fe3ce75a24b8dcc7"
 }

package/src/lib/callai-attempts-witness.ts

@@ -0,0 +1,256 @@
+/**
+ * RFC 0248 — `ctx.callAI` reports its provider attempts and takes a per-call
+ * retry policy. The rules are the `aiProviders.callAccounting` facet
+ * descriptions (`spec/v2/facets/aiProviders.schema.json`).
+ *
+ * No seam. The suite runs the `conformance-callai-attempt-accounting` fixture
+ * once per case. Its node makes one `ctx.callAI` call, the host's conformance
+ * mock serves the case's `script` to that call's provider requests, and the
+ * node echoes the result's `attempts`. The suite wrote the script, so it knows
+ * what every request returned. Two normative surfaces corroborate it where the
+ * host advertises them:
+ *   - `provider.usage`: exactly one per provider invocation, with
+ *     `outputTokens` (`events.md` §`providerUsage`);
+ *   - `envelope.retry-exhausted.totalAttempts` (`events.md` §envelopes).
+ *
+ * The mock clamps each reported `outputTokens` to the `maxTokens` that request
+ * carried and serves an over-budget entry as truncated (fixtures.md), so a
+ * host that grows the budget against `growMaxTokens: false` shows on the log.
+ *
+ * Two halves, as in `table-schema-witness.ts`: {@link drive} observes and
+ * asserts nothing; the `judge*` functions are pure.
+ *
+ * @see RFCS/0248-callai-attempt-accounting-and-retry-policy.md
+ */
+
+import { driver, type OpenWOPResponse } from './driver.js';
+import { projectBoundId } from './bound-id.js';
+import { readErrorCode } from './error-envelope.js';
+import { isFixtureAdvertised } from './fixtures.js';
+
+export const FIXTURE = 'conformance-callai-attempt-accounting';
+export const NODE_ID = 'callai-echo';
+const DOC_A = 'aiProviders.schema.json §callAccounting.attempts (RFC 0248 §A)';
+const DOC_B = 'aiProviders.schema.json §callAccounting.retryPolicy (RFC 0248 §B)';
+
+export interface ScriptEntry { readonly kind: 'invalid-json' | 'truncated' | 'valid'; readonly outputTokens?: number; readonly usage?: false; readonly structuredMode?: 'native' | 'prompt' }
+export interface Case { readonly request: Record<string, unknown>; readonly script: readonly ScriptEntry[] }
+
+const SCHEMA = { type: 'object', properties: { answer: { type: 'string' } }, required: ['answer'] };
+const BUDGET = 100;
+export const CASES = {
+  /** §A.1/A.2: a schema violation, then a valid reply. */
+  count: { request: { prompt: 'conformance', responseSchema: SCHEMA, maxTokens: BUDGET }, script: [{ kind: 'invalid-json', outputTokens: 10 }, { kind: 'valid', outputTokens: 20 }] },
+  /** §A.2: one reply that reports no usage. */
+  incomplete: { request: { prompt: 'conformance', maxTokens: BUDGET }, script: [{ kind: 'valid', usage: false }] },
+  /** §A.3: no responseSchema, so no structuredOutput. */
+  plain: { request: { prompt: 'conformance', maxTokens: BUDGET }, script: [{ kind: 'valid', outputTokens: 5 }] },
+  /** §A.3: the mock declares native structured output. */
+  native: { request: { prompt: 'conformance', responseSchema: SCHEMA, maxTokens: BUDGET }, script: [{ kind: 'valid', outputTokens: 5, structuredMode: 'native' }] },
+  /** §B.1: one attempt allowed, and it is invalid. */
+  cap: { request: { prompt: 'conformance', responseSchema: SCHEMA, maxTokens: BUDGET, retry: { maxAttempts: 1 } }, script: [{ kind: 'invalid-json', outputTokens: 10 }, { kind: 'valid', outputTokens: 20 }] },
+  /** §B.2: truncated, then a reply that fits only a grown budget. */
+  growth: { request: { prompt: 'conformance', responseSchema: SCHEMA, maxTokens: BUDGET, retry: { growMaxTokens: false } }, script: [{ kind: 'truncated', outputTokens: BUDGET }, { kind: 'valid', outputTokens: 150 }] },
+  /** §B.5: maxAttempts out of range. */
+  malformed: { request: { prompt: 'conformance', maxTokens: BUDGET, retry: { maxAttempts: 0 } }, script: [{ kind: 'valid', outputTokens: 5 }] },
+} as const satisfies Record<string, Case>;
+export type CaseName = keyof typeof CASES;
+
+export interface CaseRun {
+  readonly runId: string;
+  readonly status: string;
+  readonly attempts: Record<string, unknown> | undefined;
+  readonly errorCode: string | null;
+  readonly errorField: unknown;
+  /** `provider.usage` payloads of the run (one node), in log order. */
+  readonly usage: readonly Record<string, unknown>[];
+  readonly exhaustedTotal: number | undefined;
+  readonly startedSeq: number | undefined;
+}
+
+export interface Finding { readonly ok: boolean; readonly doc: string; readonly message: string }
+type Rec = Record<string, unknown>;
+const isRec = (v: unknown): v is Rec => typeof v === 'object' && v !== null && !Array.isArray(v);
+const f = (ok: boolean, doc: string, message: string): Finding => ({ ok, doc, message });
+const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
+
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> {
+  try { return await fn(); } catch { return null; }
+}
+
+async function terminal(runId: string, timeoutMs: number): Promise<string | null> {
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    const snap = await http(() => driver.get(`/runs/${projectBoundId(runId)}`));
+    const status = String((snap?.json as { status?: unknown } | undefined)?.status ?? '');
+    if (TERMINAL.has(status)) return status;
+    if (Date.now() > deadline) {
+      await http(() => driver.post(`/runs/${projectBoundId(runId)}/cancel`, {}));
+      return null;
+    }
+    await new Promise((r) => setTimeout(r, 200));
+  }
+}
+
+/** Read one finished run's log into a CaseRun. Asserts nothing. */
+export async function observe(runId: string, status: string): Promise<CaseRun | string> {
+  const ev = await http(() => driver.get(`/runs/${projectBoundId(runId)}/events/poll?timeout=1`));
+  const events = (ev?.json as { events?: unknown } | undefined)?.events;
+  if (ev?.status !== 200 || !Array.isArray(events)) return `GET /runs/{runId}/events/poll answered ${ev?.status ?? 'nothing'}`;
+  // The fixture has one node, so every event of the run is the echo node's.
+  // `provider.usage.nodeId` is optional; filtering on it would blame a host
+  // that omits it.
+  const mine = (events as unknown[]).filter(isRec);
+  const of = (type: string): Rec[] => mine.filter((e) => e['type'] === type).map((e) => (isRec(e['payload']) ? e['payload'] : {}));
+  const completed = of('node.completed')[0];
+  const outputs = isRec(completed?.['outputs']) ? completed['outputs'] : undefined;
+  const failed = of('node.failed')[0];
+  const error = isRec(failed?.['error']) ? failed['error'] : undefined;
+  const details = isRec(error?.['details']) ? error['details'] : undefined;
+  const exhausted = of('envelope.retry-exhausted')[0];
+  const started = mine.find((e) => e['type'] === 'node.started');
+  return {
+    runId, status,
+    attempts: isRec(outputs?.['attempts']) ? outputs['attempts'] : undefined,
+    errorCode: typeof error?.['code'] === 'string' ? error['code'] : null,
+    errorField: details?.['field'],
+    usage: of('provider.usage'),
+    exhaustedTotal: typeof exhausted?.['totalAttempts'] === 'number' ? exhausted['totalAttempts'] : undefined,
+    startedSeq: typeof started?.['sequence'] === 'number' ? started['sequence'] : undefined,
+  };
+}
+
+export type Drive = { readonly kind: 'skip'; readonly disposition: 'inapplicable' | 'blocked'; readonly reason: string } | { readonly kind: 'observed'; readonly run: CaseRun };
+
+/** One fixture run of one case. Asserts nothing. */
+export async function runCase(name: CaseName, timeoutMs = 60_000): Promise<Drive> {
+  if (!isFixtureAdvertised(FIXTURE)) return { kind: 'skip', disposition: 'inapplicable', reason: `the host does not advertise fixture ${FIXTURE}` };
+  const c = CASES[name];
+  const created = await http(() => driver.post('/runs', { workflowId: FIXTURE, inputs: { request: c.request, script: c.script } }));
+  if (created === null) return { kind: 'skip', disposition: 'blocked', reason: 'POST /runs unreachable (fetch failed)' };
+  if (created.status === 429) return { kind: 'skip', disposition: 'blocked', reason: 'POST /runs answered 429 — the run budget, not the wire' };
+  const runId = (created.json as { runId?: unknown } | undefined)?.runId;
+  if (created.status !== 201 || typeof runId !== 'string') return { kind: 'skip', disposition: 'blocked', reason: `POST /runs {workflowId: ${FIXTURE}} answered ${created.status} ${readErrorCode(created.json) ?? ''}`.trim() };
+  const status = await terminal(runId, timeoutMs);
+  if (status === null) return { kind: 'skip', disposition: 'blocked', reason: `the ${name} run did not reach a terminal status within ${timeoutMs} ms` };
+  const run = await observe(runId, status);
+  return typeof run === 'string' ? { kind: 'skip', disposition: 'blocked', reason: run } : { kind: 'observed', run };
+}
+
+/** Fork a finished run in replay mode from the node's start and read the fork. Asserts nothing. */
+export async function replayOf(source: CaseRun, timeoutMs = 60_000): Promise<{ declined: number } | { run: CaseRun } | string> {
+  if (source.startedSeq === undefined) return 'the source run has no node.started for the echo node';
+  const res = await http(() => driver.post(`/runs/${projectBoundId(source.runId)}:fork`, { mode: 'replay', fromSeq: source.startedSeq }));
+  if (res === null) return 'POST /runs/{runId}:fork unreachable (fetch failed)';
+  if (res.status === 404 || res.status === 403 || res.status === 501) return { declined: res.status };
+  const forkId = (res.json as { runId?: unknown } | undefined)?.runId;
+  if (res.status !== 201 || typeof forkId !== 'string') return `POST /runs/{runId}:fork answered ${res.status} ${readErrorCode(res.json) ?? ''}`.trim();
+  const status = await terminal(forkId, timeoutMs);
+  if (status === null) return `the replay fork did not reach a terminal status within ${timeoutMs} ms`;
+  const run = await observe(forkId, status);
+  return typeof run === 'string' ? run : { run };
+}
+
+const tokensOf = (script: readonly ScriptEntry[], i: number, budget: number): number => {
+  const e = script[Math.min(i, script.length - 1)]!;
+  return Math.min(e.outputTokens ?? 0, budget);
+};
+const intAtLeast = (v: unknown, min: number): v is number => typeof v === 'number' && Number.isInteger(v) && v >= min;
+
+const presence = (run: CaseRun): Finding[] => {
+  const a = run.attempts;
+  const out = [f(run.status === 'completed' && a !== undefined, DOC_A, `a completed ctx.callAI call MUST carry attempts on its result (run ${run.status}, attempts ${a === undefined ? 'absent' : 'present'})`)];
+  if (a !== undefined) out.push(f(intAtLeast(a['count'], 1), DOC_A, `attempts.count MUST be an integer ≥ 1 (got ${JSON.stringify(a['count'])})`));
+  return out;
+};
+
+/**
+ * §A.1: the record's count equals the provider requests — one `provider.usage`
+ * each where the host advertises it (`withUsageEvents`).
+ */
+export function judgeCount(run: CaseRun, withUsageEvents: boolean): Finding[] {
+  const out = presence(run);
+  const count = run.attempts?.['count'];
+  if (!intAtLeast(count, 1)) return out;
+  if (withUsageEvents) out.push(f(run.usage.length === count, DOC_A, `attempts.count MUST equal the provider requests, one provider.usage each (events.md §providerUsage): ${run.usage.length} provider.usage vs count ${count}`));
+  return out;
+}
+
+/**
+ * §A.2: `outputTokens` is the sum over the requests the script served, equals
+ * the summed `provider.usage` where advertised, and `usageComplete` is true
+ * because every scripted reply reported usage.
+ */
+export function judgeSum(run: CaseRun, c: Case, withUsageEvents: boolean): Finding[] {
+  const out = presence(run);
+  const a = run.attempts;
+  const count = a?.['count'];
+  if (a === undefined || !intAtLeast(count, 1)) return out;
+  const budget = typeof c.request['maxTokens'] === 'number' ? (c.request['maxTokens'] as number) : Number.MAX_SAFE_INTEGER;
+  const want = Array.from({ length: count }, (_, i) => tokensOf(c.script, i, budget)).reduce((x, y) => x + y, 0);
+  out.push(f(a['usageComplete'] === true, DOC_A, `every scripted request reported usage, so usageComplete MUST be true (got ${JSON.stringify(a['usageComplete'])})`));
+  out.push(f(a['outputTokens'] === want, DOC_A, `attempts.outputTokens MUST be the sum over the ${count} requests the script served (want ${want}, got ${JSON.stringify(a['outputTokens'])})`));
+  if (withUsageEvents) {
+    const sum = run.usage.reduce((x, u) => x + (typeof u['outputTokens'] === 'number' ? u['outputTokens'] : 0), 0);
+    out.push(f(sum === a['outputTokens'], DOC_A, `attempts.outputTokens MUST equal the summed provider.usage.outputTokens (${sum} vs ${JSON.stringify(a['outputTokens'])})`));
+  }
+  return out;
+}
+
+/** §A.2: a request that reported no usage makes usageComplete false. */
+export function judgeIncomplete(run: CaseRun): Finding[] {
+  const a = run.attempts;
+  if (run.status !== 'completed' || a === undefined) return [f(false, DOC_A, `a completed ctx.callAI call MUST carry attempts (run ${run.status})`)];
+  return [f(a['usageComplete'] === false, DOC_A, `a request that reported no usage MUST make usageComplete false (got ${JSON.stringify(a['usageComplete'])})`)];
+}
+
+/** §A.3: absent without responseSchema; the declared mode with one. */
+export function judgeStructuredOutput(plain: CaseRun, native: CaseRun): Finding[] {
+  const out: Finding[] = [];
+  for (const [run, label] of [[plain, 'plain'], [native, 'native']] as const) {
+    if (run.status !== 'completed' || run.attempts === undefined) out.push(f(false, DOC_A, `the ${label} call MUST complete with attempts (run ${run.status})`));
+  }
+  if (plain.attempts !== undefined) out.push(f(plain.attempts['structuredOutput'] === undefined, DOC_A, `without responseSchema attempts.structuredOutput MUST be absent (got ${JSON.stringify(plain.attempts['structuredOutput'])})`));
+  if (native.attempts !== undefined) out.push(f(native.attempts['structuredOutput'] === 'native', DOC_A, `the final request used the mock's native structured output, so structuredOutput MUST be "native" (got ${JSON.stringify(native.attempts['structuredOutput'])})`));
+  return out;
+}
+
+/** §B.1: maxAttempts 1 with an invalid first reply — one request, then failure. */
+export function judgeCap(run: CaseRun, withUsageEvents: boolean): Finding[] {
+  const out: Finding[] = [f(run.status === 'failed', DOC_B, `with maxAttempts 1 and an invalid first reply the call MUST fail, since a completion needs a second request (run ${run.status})`)];
+  out.push(f(run.errorCode !== 'validation_error', DOC_B, 'a well-formed retry policy MUST NOT be refused as validation_error'));
+  if (withUsageEvents) out.push(f(run.usage.length <= 1, DOC_B, `the host MUST NOT send more than maxAttempts provider requests: ${run.usage.length} provider.usage for maxAttempts 1`));
+  if (run.exhaustedTotal !== undefined) out.push(f(run.exhaustedTotal === 1, DOC_B, `envelope.retry-exhausted.totalAttempts MUST be 1 under maxAttempts 1 (got ${run.exhaustedTotal})`));
+  return out;
+}
+
+/**
+ * §B.2: growMaxTokens false. The second reply fits only a grown budget, so a
+ * host that keeps the budget never completes, and every reported attempt stays
+ * within it.
+ */
+export function judgeNoGrowth(run: CaseRun, withUsageEvents: boolean): Finding[] {
+  const out: Finding[] = [f(run.status !== 'completed', DOC_B, `under growMaxTokens false the over-budget reply MUST stay truncated, so the call MUST NOT complete — completing means an attempt's maxTokens exceeded ${BUDGET}`)];
+  out.push(f(run.errorCode !== 'validation_error', DOC_B, 'a well-formed retry policy MUST NOT be refused as validation_error'));
+  if (withUsageEvents) {
+    const over = run.usage.map((u) => u['outputTokens']).filter((t) => typeof t === 'number' && t > BUDGET);
+    out.push(f(over.length === 0, DOC_B, `no attempt MAY exceed the request's maxTokens ${BUDGET} under growMaxTokens false (provider.usage outputTokens over it: ${JSON.stringify(over)})`));
+  }
+  return out;
+}
+
+/** §B.5: a malformed retry is refused validation_error naming the key. */
+export function judgeMalformed(run: CaseRun): Finding[] {
+  return [
+    f(run.status === 'failed' && run.errorCode === 'validation_error', DOC_B, `retry.maxAttempts 0 MUST be refused with validation_error, never ignored (run ${run.status} ${run.errorCode ?? ''})`.trim()),
+    f(run.errorField === 'retry.maxAttempts', DOC_B, `the refusal MUST name the key in details.field (got ${JSON.stringify(run.errorField)})`),
+  ];
+}
+
+/** §A.5: a replay fork reproduces the recorded attempts. */
+export function judgeReplayed(source: CaseRun, fork: CaseRun): Finding[] {
+  return [
+    f(fork.status === 'completed' && fork.attempts !== undefined, DOC_A, `the replay fork MUST complete with attempts (fork ${fork.status})`),
+    f(JSON.stringify(fork.attempts) === JSON.stringify(source.attempts), DOC_A, `on replay attempts MUST equal the recorded value (source ${JSON.stringify(source.attempts)}, fork ${JSON.stringify(fork.attempts)})`),
+  ];
+}

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

@@ -0,0 +1,74 @@
+/**
+ * RFC 0081 §C — the `eval.*` envelope of an eval run, and the summary it
+ * serves. A pure judge over one eval run, for
+ * `v2-eval-trajectory-trials.test.ts`.
+ *
+ * The rules are the `run-event-payloads` descriptions, which the `agents`
+ * family lists as normative text:
+ *   - `evalStarted` — emitted ONCE, at the start of the run;
+ *   - `evalScored` — once per task (per trial under RFC 0244 §B);
+ *   - `evalCompleted` — emitted ONCE, after all tasks and before
+ *     `run.completed`; its aggregates describe the same run the summary does.
+ * The served `EvalSummary` validates against `eval-summary.schema.json`.
+ *
+ * Until 2.46.20 no v2 leg read `eval.completed`; the frozen v1
+ * `agent-eval-run.test.ts` did (RFC 0081 correction note, 2026-10-24).
+ *
+ * @see RFCS/0081-agent-evaluation-and-scorecards.md
+ */
+
+export interface EnvelopeFinding { readonly ok: boolean; readonly doc: string; readonly message: string }
+
+type Rec = Record<string, unknown>;
+interface Event { readonly type: string; readonly sequence: number; readonly payload: Rec }
+
+const isRec = (v: unknown): v is Rec => typeof v === 'object' && v !== null && !Array.isArray(v);
+const f = (ok: boolean, doc: string, message: string): EnvelopeFinding => ({ ok, doc, message });
+
+const C = 'run-event-payloads evalStarted / evalScored / evalCompleted (RFC 0081 §C)';
+
+export interface EnvelopeOptions {
+  /** Validates an `eval.completed` payload against `run-event-payloads#/$defs/evalCompleted`. */
+  readonly completedValid: (payload: unknown) => { ok: boolean; errors: string };
+}
+
+export function judgeEvalEnvelope(events: readonly Event[], summary: Rec, opts: EnvelopeOptions): EnvelopeFinding[] {
+  const ordered = [...events].sort((a, b) => a.sequence - b.sequence);
+  const at = (type: string): number[] => ordered.flatMap((e, i) => (e.type === type ? [i] : []));
+  const started = at('eval.started');
+  const scored = at('eval.scored');
+  const completed = at('eval.completed');
+  const runCompleted = at('run.completed');
+  const out: EnvelopeFinding[] = [];
+
+  out.push(f(started.length === 1, C, `eval.started MUST be emitted once (got ${started.length})`));
+  out.push(f(completed.length === 1, C, `eval.completed MUST be emitted once (got ${completed.length})`));
+  out.push(f(scored.length > 0, C, 'the run MUST emit eval.scored for its tasks'));
+  if (started.length === 1 && scored.length > 0) {
+    out.push(f(started[0]! < scored[0]!, C, 'eval.started MUST precede every eval.scored'));
+  }
+  if (completed.length !== 1) return out;
+  const c = completed[0]!;
+  if (scored.length > 0) out.push(f(c > scored[scored.length - 1]!, C, 'eval.completed MUST follow every eval.scored ("after all tasks")'));
+  if (runCompleted.length > 0) out.push(f(c < runCompleted[0]!, C, 'eval.completed MUST precede run.completed'));
+
+  const payload = ordered[c]!.payload;
+  const v = opts.completedValid(payload);
+  out.push(f(v.ok, C, `eval.completed MUST validate: ${v.errors}`));
+  for (const k of ['taskCount', 'passedCount', 'passed'] as const) {
+    if (k in summary) out.push(f(payload[k] === summary[k], C, `eval.completed.${k} MUST equal the served summary's (event ${JSON.stringify(payload[k])}, summary ${JSON.stringify(summary[k])})`));
+  }
+  return out;
+}
+
+/** The served summary validates, and its per-task rows agree with its own counts. */
+export function judgeSummaryServed(summary: Rec, valid: (s: unknown) => { ok: boolean; errors: string }): EnvelopeFinding[] {
+  const out: EnvelopeFinding[] = [];
+  const v = valid(summary);
+  out.push(f(v.ok, 'eval-summary.schema.json (RFC 0081 §C)', `the served EvalSummary MUST validate: ${v.errors}`));
+  const tasks = Array.isArray(summary['tasks']) ? (summary['tasks'] as unknown[]).filter(isRec) : [];
+  out.push(f(summary['taskCount'] === tasks.length, 'eval-summary.schema.json (RFC 0081 §C)', `taskCount MUST equal the number of tasks (got ${JSON.stringify(summary['taskCount'])}, ${tasks.length} tasks)`));
+  const passed = tasks.filter((t) => t['passed'] === true).length;
+  out.push(f(summary['passedCount'] === passed, 'eval-summary.schema.json (RFC 0081 §C)', `passedCount MUST count the passed tasks (got ${JSON.stringify(summary['passedCount'])}, ${passed} passed)`));
+  return out;
+}

package/src/scenarios/v2-callai-attempt-accounting.test.ts

@@ -0,0 +1,148 @@
+/**
+ * v2 — `ctx.callAI` reports its provider attempts and takes a per-call retry
+ * policy (RFC 0248; the rules are the `aiProviders.callAccounting` facet
+ * descriptions in `spec/v2/facets/aiProviders.schema.json`).
+ *
+ * Unaided, through the `conformance-callai-attempt-accounting` fixture: its
+ * node makes one `ctx.callAI` call, the host's conformance mock serves the
+ * case's script, and the node echoes `attempts`. The suite wrote the script,
+ * and `provider.usage` (one per provider invocation, `events.md`
+ * §`providerUsage`) corroborates it where advertised. Judges in
+ * `lib/callai-attempts-witness.ts`.
+ *
+ *   attempts-count / output-tokens-sum  invalid then valid → the count and the
+ *                                       summed tokens match the script and log
+ *   usage-incomplete                    a reply with no usage → usageComplete false
+ *   structured-output                   absent without responseSchema; "native"
+ *                                       when the mock declares it
+ *   attempts-replayed                   a replay fork reproduces attempts
+ *   max-attempts-cap                    maxAttempts 1, invalid first reply → fails
+ *                                       after one request
+ *   no-budget-growth                    growMaxTokens false → the over-budget
+ *                                       reply stays truncated
+ *   retry-malformed-refused             maxAttempts 0 → validation_error,
+ *                                       details.field retry.maxAttempts
+ *
+ * Dispositions: the flag not advertised, or the fixture not listed ⇒
+ * `inapplicable`. A run that cannot be created or read, or a count run that
+ * failed because the host does not retry a schema violation ⇒ `blocked`.
+ *
+ * @see RFCS/0248-callai-attempt-accounting-and-retry-policy.md
+ * @see conformance/fixtures.md §The ctx.callAI attempt-accounting fixture
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Discovery } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { forkDeclined } from '../lib/fork-availability.js';
+import {
+  CASES, runCase, replayOf, judgeCount, judgeSum, judgeIncomplete, judgeStructuredOutput, judgeCap, judgeNoGrowth, judgeMalformed, judgeReplayed,
+  type CaseName, type CaseRun, type Drive, type Finding,
+} from '../lib/callai-attempts-witness.js';
+
+const ID_COUNT = 'openwop.requirement.0248.attempts-count';
+const ID_SUM = 'openwop.requirement.0248.output-tokens-sum';
+const ID_INCOMPLETE = 'openwop.requirement.0248.usage-incomplete';
+const ID_STRUCTURED = 'openwop.requirement.0248.structured-output';
+const ID_REPLAYED = 'openwop.requirement.0248.attempts-replayed';
+const ID_CAP = 'openwop.requirement.0248.max-attempts-cap';
+const ID_GROWTH = 'openwop.requirement.0248.no-budget-growth';
+const ID_MALFORMED = 'openwop.requirement.0248.retry-malformed-refused';
+const UNREADABLE = 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0';
+
+type Skip = readonly ['inapplicable' | 'blocked', string];
+const isRec = (v: unknown): v is Record<string, unknown> => typeof v === 'object' && v !== null && !Array.isArray(v);
+
+let disc: Promise<Record<string, unknown> | null> | undefined;
+const discovery = (): Promise<Record<string, unknown> | null> => (disc ??= v2Discovery().catch(() => null));
+
+async function gate(flag: 'attempts' | 'retryPolicy'): Promise<{ skip: Skip } | { usageEvents: boolean }> {
+  const doc = await discovery();
+  if (!doc) return { skip: ['blocked', UNREADABLE] };
+  const ai = doc['aiProviders'];
+  const acct = isRec(ai) && isRec(ai['callAccounting']) ? ai['callAccounting'] : undefined;
+  if (acct?.[flag] !== true) return { skip: ['inapplicable', `the host does not advertise aiProviders.callAccounting.${flag}`] };
+  return { usageEvents: isRec(doc['providerUsage']) };
+}
+
+const runs = new Map<CaseName, Promise<Drive>>();
+const once = (name: CaseName): Promise<Drive> => { let p = runs.get(name); if (!p) { p = runCase(name); runs.set(name, p); } return p; };
+
+async function observed(flag: 'attempts' | 'retryPolicy', name: CaseName): Promise<{ skip: Skip } | { run: CaseRun; usageEvents: boolean }> {
+  const g = await gate(flag);
+  if ('skip' in g) return g;
+  const d = await once(name);
+  if (d.kind === 'skip') return { skip: [d.disposition, d.reason] };
+  return { run: d.run, usageEvents: g.usageEvents };
+}
+
+/** The count run, or why it cannot be judged: a host that does not retry a schema violation fails the call and has no result to read. */
+async function countRun(): Promise<{ skip: Skip } | { run: CaseRun; usageEvents: boolean }> {
+  const o = await observed('attempts', 'count');
+  if ('skip' in o) return o;
+  if (o.run.status === 'failed') return { skip: ['blocked', `the count call failed (${o.run.errorCode ?? 'no code'}): the host did not retry the scripted schema violation, so no multi-attempt result exists to read`] };
+  return o;
+}
+
+const assertAll = (id: string, fs: readonly Finding[]): void => { for (const x of fs) expect(x.ok, req(id, x.doc, x.message)).toBe(true); };
+
+describe('v2 RFC 0248 — ctx.callAI attempt accounting (§A)', () => {
+  it('attempts.count equals the provider requests the call made', async () => {
+    const o = await countRun();
+    if ('skip' in o) return softSkip(...o.skip);
+    assertAll(ID_COUNT, judgeCount(o.run, o.usageEvents));
+  }, 180_000);
+
+  it('attempts.outputTokens is the sum over every attempt, and usageComplete is true when all reported', async () => {
+    const o = await countRun();
+    if ('skip' in o) return softSkip(...o.skip);
+    assertAll(ID_SUM, judgeSum(o.run, CASES.count, o.usageEvents));
+  }, 180_000);
+
+  it('an attempt that reported no usage makes usageComplete false', async () => {
+    const o = await observed('attempts', 'incomplete');
+    if ('skip' in o) return softSkip(...o.skip);
+    assertAll(ID_INCOMPLETE, judgeIncomplete(o.run));
+  }, 180_000);
+
+  it('structuredOutput is absent without responseSchema and names the mode the final attempt used', async () => {
+    const p = await observed('attempts', 'plain');
+    if ('skip' in p) return softSkip(...p.skip);
+    const n = await observed('attempts', 'native');
+    if ('skip' in n) return softSkip(...n.skip);
+    assertAll(ID_STRUCTURED, judgeStructuredOutput(p.run, n.run));
+  }, 180_000);
+
+  it('a replay fork reproduces the recorded attempts', async () => {
+    const o = await countRun();
+    if ('skip' in o) return softSkip(...o.skip);
+    const doc = await discovery();
+    const modes = isRec(doc?.['replay']) && Array.isArray((doc['replay'] as Record<string, unknown>)['modes']) ? ((doc['replay'] as Record<string, unknown>)['modes'] as unknown[]) : [];
+    if (!modes.includes('replay')) return softSkip('inapplicable', 'the host does not advertise replay.modes including "replay"');
+    const fork = await replayOf(o.run);
+    if (typeof fork === 'string') return softSkip('blocked', fork);
+    if ('declined' in fork) { forkDeclined(fork.declined, 'v2-callai-attempt-accounting replay'); return softSkip('blocked', `POST /runs/{runId}:fork declined with ${fork.declined}`); }
+    assertAll(ID_REPLAYED, judgeReplayed(o.run, fork.run));
+  }, 240_000);
+});
+
+describe('v2 RFC 0248 — ctx.callAI retry policy (§B)', () => {
+  it('maxAttempts caps the provider requests', async () => {
+    const o = await observed('retryPolicy', 'cap');
+    if ('skip' in o) return softSkip(...o.skip);
+    assertAll(ID_CAP, judgeCap(o.run, o.usageEvents));
+  }, 180_000);
+
+  it('growMaxTokens false keeps every attempt within the request budget', async () => {
+    const o = await observed('retryPolicy', 'growth');
+    if ('skip' in o) return softSkip(...o.skip);
+    assertAll(ID_GROWTH, judgeNoGrowth(o.run, o.usageEvents));
+  }, 180_000);
+
+  it('a malformed retry policy is refused validation_error naming the key', async () => {
+    const o = await observed('retryPolicy', 'malformed');
+    if ('skip' in o) return softSkip(...o.skip);
+    assertAll(ID_MALFORMED, judgeMalformed(o.run));
+  }, 180_000);
+});

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

@@ -32,6 +32,13 @@
  *      lists `conformance-eval-trials` refuses it at createRun with
  *      `400 validation_error`.
  *
+ * RFC 0081 §C, on the `conformance-eval-trajectory` run (2.46.20). Judges in
+ * `lib/eval-envelope-witness.ts`.
+ *   - `eval.started` and `eval.completed` are emitted once each, bracketing
+ *     every `eval.scored`, and `eval.completed` precedes `run.completed`; its
+ *     counts equal the served summary's.
+ *   - The served `EvalSummary` validates, and its counts match its rows.
+ *
  * RFC 0246 (safety fix): a trial that failed its trajectory counts 0 in the
  * two pass decisions, while every reported score is unchanged. Judges in
  * `lib/eval-gate-witness.ts`.
@@ -73,6 +80,7 @@ import { majorProfile } from '../lib/major-profile.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { FIXTURES_DIR } from '../lib/paths.js';
 import { pollTerminal, readEvents, isRecord, type Ev } from '../lib/fixture-run-observer.js';
+import { judgeEvalEnvelope, judgeSummaryServed } from '../lib/eval-envelope-witness.js';
 import { gradeTrajectory, passAtK, passHatK, scoreStderr, withinTolerance, type TrajectorySpec } from '../lib/eval-trajectory.js';
 import { judgeMeanGated, judgeSuiteGated } from '../lib/eval-gate-witness.js';
 import { judgeFixtureErrorReplayed } from '../lib/eval-fixture-error-witness.js';
@@ -97,6 +105,9 @@ const DOC_0246 = 'eval-summary.schema.json gatedScore / gatedAggregateScore (RFC
 const ID_FIXTURE_ERROR_SHAPE = 'openwop.requirement.0245.fixture-error-shape';
 const ID_FIXTURE_ERROR = 'openwop.requirement.0245.fixture-error-replayed';
 const ID_FIXTURE_ERROR_REFUSED = 'openwop.requirement.0245.unadvertised-refused';
+const ID_ENVELOPE = 'openwop.requirement.0081.eval-envelope';
+const ID_SUMMARY = 'openwop.requirement.0081.summary-served';
+const DOC_0081 = 'run-event-payloads evalStarted / evalCompleted, eval-summary.schema.json (RFC 0081 §C)';
 const DOC_0245 = 'agents.schema.json §evalSuite.fixtureErrors (RFC 0245)';
 
 interface Task { taskId: string; input: { script: Array<{ tool: string; arguments?: unknown }>; output: string }; expected: { kind: string; trajectory?: TrajectorySpec }; fixtures?: { toolResponses?: Array<Record<string, unknown>> } }
@@ -107,6 +118,7 @@ const suiteSchema = v2Validator('agent-eval-suite');
 const summarySchema = v2Validator('eval-summary');
 const scored = v2RefValidator('run-event-payloads.schema.json#/$defs/evalScored');
 const started = v2RefValidator('run-event-payloads.schema.json#/$defs/evalStarted');
+const completedPayload = v2RefValidator('run-event-payloads.schema.json#/$defs/evalCompleted');
 
 async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> {
   try { return await fn(); } catch { return null; }
@@ -225,6 +237,33 @@ describe('v2 RFC 0244 — host behaviour', () => {
     expect(calls, req(ID_TRAJECTORY, DOC, `the log MUST carry one agent.tool-called per scripted call (${scripted})`)).toBe(scripted);
   });
 
+  async function trajectoryRun(): Promise<{ skip: [Parameters<typeof softSkip>[0], string] } | { o: Extract<Observed, { kind: 'ok' }> }> {
+    const { doc, facet } = await evalSuiteFacet();
+    if (!doc) return { skip: ['blocked', UNREADABLE] };
+    if (facet?.['trajectory'] !== true) return { skip: ['inapplicable', 'the host does not advertise agents.evalSuite.trajectory'] };
+    const id = 'conformance-eval-trajectory';
+    if (!isFixtureAdvertised(id)) return { skip: ['inapplicable', `the host does not advertise fixture ${id}`] };
+    const o = await runSuite(id);
+    if (o.kind === 'skip') return { skip: [o.disposition, o.reason] };
+    return { o };
+  }
+
+  it('an eval run brackets its scores with one eval.started and one eval.completed (RFC 0081 §C)', async () => {
+    const r = await trajectoryRun();
+    if ('skip' in r) return softSkip(...r.skip);
+    for (const x of judgeEvalEnvelope(r.o.events, r.o.summary, { completedValid: completedPayload })) {
+      expect(x.ok, req(ID_ENVELOPE, DOC_0081, x.message)).toBe(true);
+    }
+  });
+
+  it('the served EvalSummary validates and its counts match its rows (RFC 0081 §C)', async () => {
+    const r = await trajectoryRun();
+    if ('skip' in r) return softSkip(...r.skip);
+    for (const x of judgeSummaryServed(r.o.summary, summarySchema)) {
+      expect(x.ok, req(ID_SUMMARY, DOC_0081, x.message)).toBe(true);
+    }
+  });
+
   async function trialsRun(): Promise<{ skip: [Parameters<typeof softSkip>[0], string] } | { o: Extract<Observed, { kind: 'ok' }>; suite: Suite; n: number; k: number }> {
     const { doc, facet } = await evalSuiteFacet();
     if (!doc) return { skip: ['blocked', UNREADABLE] };