@openwop/openwop-conformance 2.46.17 → 2.46.19

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## [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.
+
 ## [2.46.17] — 2026-10-18 — RFC 0245: a recorded tool error replays as an error
 
 - **New fixture `fixtures/eval-suites/conformance-eval-fixture-error`.** One task calls `conformance.eval:lookup` twice. Its fixtures serve an `isError: true` entry, then a success.

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.17",
-  "stampSha256": "d8df0298a5a6405eca16d0a24cb7c48123d7e3e0675b337eca37ad36585e02f6"
+  "version": "2.46.19",
+  "stampSha256": "8b0bfeeda6c1a1e8bbac41bc73b01f70e71ad88ca5dc98aee4a373b6611db396"
 }

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.
@@ -1035,7 +1056,7 @@ Every task targets **the scripted agent `core.conformance.agents.scripted`**. It
 | `conformance-eval-fixture-miss` | `agents.evalSuite.fixtureMatching` | `missed` reports `fixtureMissCount: 1`, `passed: false` and `score: 0` (summary and every `eval.scored`); `served` passes with no miss. That no live tool ran is not observable here (RFC 0244 G2) |
 | `conformance-eval-trajectory-gate` | `agents.evalSuite.trajectory` | RFC 0246: both tasks keep `score` 1 and `aggregateScore` 1; `path-matched` carries `gatedScore` 1 and `path-wrong` `gatedScore` 0; `gatedAggregateScore` 0.5; suite `passed: false` although `aggregateScore` clears `passScore` 0.6 |
 | `conformance-eval-trajectory-gate-mean` | `agents.evalSuite.trajectory` + `agents.evalSuite.trials` | RFC 0246: two `eval.scored` with `score` 1 and `passed: false`; `trials.meanScore` 1, `gatedScore` 0, task `passed: false`; the summary carries `gatedAggregateScore` |
-| `conformance-eval-fixture-error` | `agents.evalSuite.fixtureErrors` + `agents.evalSuite.fixtureMatching` | RFC 0245: two `agent.tool-called` and two `agent.tool-returned` for `conformance.eval:lookup`, paired by `callId`; the first return carries `error` with non-empty `code` and `message` and no `outcome` (`status: "error"` under `toolHooks.prePostEvents`), the second carries `outcome`; `recovers` reports `fixtureMissCount: 0`. Without `fixtureErrors`: `400 validation_error`. That the agent saw an error and no live tool ran is not observable here (RFC 0245 G1, RFC 0244 G2) |
+| `conformance-eval-fixture-error` | `agents.evalSuite.fixtureErrors` + `agents.evalSuite.fixtureMatching` | RFC 0245: two `agent.tool-called` and two `agent.tool-returned` for `conformance.eval:lookup`, paired by `callId`; the first return carries `error` with non-empty `code` and `message` and no `outcome` (`status: "error"` under `toolHooks.prePostEvents`), the second carries no `error` (`outcome` is optional; not `status: "error"` under tool hooks); `recovers` reports `fixtureMissCount: 0`. Without `fixtureErrors`: `400 validation_error`. That the agent saw an error and no live tool ran is not observable here (RFC 0245 G1, RFC 0244 G2) |
 
 ## OAuth provider fixtures
 

package/package.json

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

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": 2822,
+    "withStableId": 2822,
     "interpolatedTitles": 0,
-    "explicitIds": 2687
+    "explicitIds": 2695
   },
   "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",

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.17",
-  "corpusTag": "v2.46.17",
+  "version": "2.46.19",
+  "corpusTag": "v2.46.19",
   "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": "08c520d1ccc23d43054ee5499276d73e18f3350d0d8825d5caa3934286e7af19",
-    "api/v2/asyncapi.yaml": "4625ddc33db126fd959e48084edca58121340042a5e1e170f87a9b4851b8b2d8",
-    "api/v2/openapi.yaml": "993bda2b91c365f8b3751fd3c827de538e39ae8e4ff3fefe2452b7b261b3c110",
+    "api/seams-v2.yaml": "9133614d3cad4ff6ecf2758f2f986dfd257dc5a3a2b10110e7537114a2c03a65",
+    "api/v2/asyncapi.yaml": "5e44771306b5dfa1824967a177208228d12dca66a36c10de5bb0441b8bd26c72",
+    "api/v2/openapi.yaml": "2f7e4863b8ba09d77e5ae8a7c977311b6138878ba910d7a41d50546034cad7c2",
     "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": "d8a41123025c45515092970fae945b4cfa238d550cdfb9549cb649e740e8b7e3",
+    "spec/v1/core-standard-manifest.json": "6b5a2e873b59e22f27bd9832559382a42ad23e29cac8f9156d592bb19e168fb1",
     "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": "52777098a223e678d12751507b1ac0d02eef7465d6263c25175489734055cc3e",
     "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": "b6e1227e823697bad80029172057d535b866ca0d8faac6a1254ecfa9074b3654",
+    "spec/v2/release.json": "9870141128549af0cac3a0e7c4906c87a5ce65047591a3824690b9e20dcf59c1",
     "spec/v2/retention-floors.json": "eaf3722d95c79947af1d4269ef85117e126518c588cfcf1a2b21b97269f51624",
-    "spec/v2/surface-baseline.json": "60061090d890cf22d91de7a4515e95814bde5690f9f9f843ee7efbdf0cdb1712"
+    "spec/v2/surface-baseline.json": "5ba73afbabe33b983c3ac74670a6aacfe32042a0d40de2faf6cdb151b055a1ae"
   },
-  "corpusCommit": "3d19f1af09cc0499a1bdfd35dac28707b16806a9"
+  "corpusCommit": "d49a2818d766f78f7c3fc9d55403ed42a404ba71"
 }

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-fixture-error-witness.ts

@@ -8,8 +8,9 @@
  * an `isError: true` entry and then a success (RFC 0244 §D: first unconsumed
  * match). So the expected log is known in advance: two `agent.tool-called`
  * from the scripted agent, and two `agent.tool-returned` paired to them by
- * `callId` — the first with `error` and no `outcome`, the second with
- * `outcome`. A served error is not a miss, so `fixtureMissCount` stays 0.
+ * `callId` — the first with `error` and no `outcome`, the second with no
+ * `error` (`outcome` is optional on a success). A served error is not a miss,
+ * so `fixtureMissCount` stays 0.
  *
  * That the agent saw a tool error, and that no live tool ran, are seam-gated
  * (RFC 0245 G1, RFC 0244 G2) and not judged here.
@@ -67,8 +68,10 @@ export function judgeFixtureErrorReplayed(events: readonly Event[], summary: Rec
   if (second === undefined) {
     out.push(f(false, B, 'the second scripted call MUST have an agent.tool-returned with the same callId'));
   } else {
-    out.push(f('outcome' in second && second['outcome'] !== undefined, B, 'the call served by the following success entry MUST carry outcome'));
+    // A success is "not an error", not "carries outcome": `outcome` is optional
+    // on agent.tool-returned and RFC 0064 §F lets a host omit it (2.46.18).
     out.push(f(second['error'] === undefined, B, 'the call served by the following success entry MUST NOT carry error'));
+    if (opts.prePostEvents) out.push(f(second['status'] !== 'error', B, `under toolHooks.prePostEvents the success return MUST NOT carry status "error" (got ${JSON.stringify(second['status'])})`));
   }
 
   const tasks = Array.isArray(summary['tasks']) ? (summary['tasks'] as unknown[]).filter(isRec) : [];

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

@@ -50,8 +50,8 @@
  *      refused; `conformance-eval-fixture-error` validates (leg 2).
  *  11. `conformance-eval-fixture-error` (fixtureErrors + fixtureMatching) —
  *      the call served by the error entry is recorded with `error` and no
- *      `outcome` (`status: "error"` under tool hooks), the next with
- *      `outcome`, and `fixtureMissCount` is 0. The two-call sequence needs
+ *      `outcome` (`status: "error"` under tool hooks), the next with no
+ *      `error` (`outcome` optional), and `fixtureMissCount` is 0. The two-call sequence needs
  *      RFC 0244 §D's first-unconsumed selection, hence `fixtureMatching`.
  *  12. Refusal — a host advertising `agents.evalSuite` without `fixtureErrors`
  *      that lists the fixture refuses it with `400 validation_error`.