@openwop/openwop-conformance 2.46.24 → 2.46.26

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [2.46.26] — 2026-10-25 — RFC 0244 model-usage and cost legs
+
+- **New leg `0244.efficiency-model-usage` in `v2-eval-trajectory-trials`**, on the existing trajectory and trials runs. Per-task `modelCallCount`, `inputTokens` and `outputTokens`, times the trial count, must sum to the agent's `provider.usage` inside its `agent.invocation.*` brackets (judge and delegate calls excluded); without brackets they must not exceed the run's usage.
+- **New leg `0244.cost-every-trial`**, on the trials run: `totalCostUsd` must be at least the agent's priced usage over all trials. Judges in `lib/eval-efficiency-witness.ts`.
+- **Host impact:** a run with no model usage, no brackets or unpriced usage records `inapplicable`; one that counts judge calls as the agent's, or prices one trial, fails.
+
+## [2.46.25] — 2026-10-25 — RFC 0244 §C efficiency leg
+
+- **New leg `0244.efficiency-tool-calls` in `v2-eval-trajectory-trials`**, on the existing `conformance-eval-trajectory` run (and the `conformance-eval-trials` run when served), so no extra run. Each task's `efficiency.toolCallCount` must equal its script length, and on the one-trial run the counts must sum to the log's `agent.tool-called` events. Judge in `lib/eval-efficiency-witness.ts`.
+- **Host impact:** openwop-app and MyndHyve run it. A host that reports no `efficiency` records `inapplicable`; one that counts judge or other-agent calls fails.
+- **Three new §D legs through the reserved counter tool `conformance.eval:counter` (RFC 0244 G2):** `0244.live-miss-counted`, `0244.first-unconsumed` and `0244.miss-no-live-call`. Two new fixtures (`conformance-eval-counter-live`, `-miss`) run as three sequential eval runs. Judges in `lib/eval-counter-witness.ts`. A host opts in by listing both fixtures (contract in `fixtures.md`); no host does yet, so the legs record `inapplicable`.
+
 ## [2.46.24] — 2026-10-25 — RFC 0250 Accepted
 
 - **No assertion changes.** RFC 0250's G6 closes on openwop-app's certified cut `f94471e98` (all six `0250.*` legs `executed-pass`), so the packed `spec/v1/gaps.json` changes.

package/dist/spec-artifacts.lock.json

@@ -1,5 +1,5 @@
 {
   "package": "@openwop/spec-artifacts",
-  "version": "2.46.24",
-  "stampSha256": "780a696bf1b4d4b304151fb6e6ca825ae849c004429bc85d7f80228a616ea797"
+  "version": "2.46.26",
+  "stampSha256": "e53058ead4546c46dc23498974219d081a05193fdb5dec16db93a221d023e0d9"
 }

package/fixtures/eval-suites/conformance-eval-counter-live.json

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

package/fixtures/eval-suites/conformance-eval-counter-miss.json

@@ -0,0 +1,80 @@
+{
+  "suiteId": "core.openwop.evals.conformance-eval-counter-miss",
+  "version": "1.0.0",
+  "targetAgentId": "core.conformance.agents.scripted",
+  "modes": [
+    "golden"
+  ],
+  "tasks": [
+    {
+      "taskId": "served-then-miss",
+      "input": {
+        "script": [
+          {
+            "tool": "conformance.eval:counter",
+            "arguments": {
+              "key": "S",
+              "op": "inc"
+            }
+          },
+          {
+            "tool": "conformance.eval:counter",
+            "arguments": {
+              "key": "S",
+              "op": "inc"
+            }
+          },
+          {
+            "tool": "conformance.eval:counter",
+            "arguments": {
+              "key": "S",
+              "op": "inc"
+            }
+          },
+          {
+            "tool": "conformance.eval:counter",
+            "arguments": {
+              "key": "F",
+              "op": "inc"
+            }
+          }
+        ],
+        "output": "done"
+      },
+      "expected": {
+        "kind": "golden",
+        "match": {
+          "strategy": "contains",
+          "value": "done"
+        }
+      },
+      "fixtures": {
+        "onMiss": "fail",
+        "toolResponses": [
+          {
+            "tool": "conformance.eval:counter",
+            "args": {
+              "key": "S",
+              "op": "inc"
+            },
+            "argsMatch": "exact",
+            "response": {
+              "served": 1
+            }
+          },
+          {
+            "tool": "conformance.eval:counter",
+            "args": {
+              "key": "S",
+              "op": "inc"
+            },
+            "argsMatch": "exact",
+            "response": {
+              "served": 2
+            }
+          }
+        ]
+      }
+    }
+  ]
+}

package/fixtures.md

@@ -75,6 +75,8 @@ All fixtures MUST advertise:
 | Eval — Trajectory Gate | `conformance-eval-trajectory-gate` | RFC 0246 — two golden tasks scoring 1 at `passScore: 0.6`; `path-matched` keeps its trajectory, `path-wrong` calls a forbidden tool (`v2-eval-trajectory-trials`) | eval run `completed`; `aggregateScore` 1, `gatedAggregateScore` 0.5, suite `passed: false` | ≤ 30s |
 | Eval — Trajectory Gate (mean) | `conformance-eval-trajectory-gate-mean` | RFC 0246 — `trials: {count: 2, passRule: "mean"}`, one golden task scoring 1 that calls a forbidden tool in both trials (`v2-eval-trajectory-trials`) | eval run `completed`; `meanScore` 1, `gatedScore` 0, task `passed: false` | ≤ 30s |
 | Eval — Fixture Error | `conformance-eval-fixture-error` | RFC 0245 — `onMiss: "fail"`; one task calls the same tool twice, served first by an `isError: true` entry, then by a success (`v2-eval-trajectory-trials`) | eval run `completed`; the first call is recorded as a tool error | ≤ 30s |
+| Eval — Counter (live) | `conformance-eval-counter-live` | RFC 0244 §D, G2 — `onMiss: "live"`; one task makes four `conformance.eval:counter` calls that match no entry, so each runs the live counter (`v2-eval-trajectory-trials`) | eval run `completed`; four live `{key, count}` outcomes | ≤ 30s |
+| Eval — Counter (miss) | `conformance-eval-counter-miss` | RFC 0244 §D, G2 — `onMiss: "fail"`; three `inc S` calls against two exact entries, then an unmatched `inc F` (`v2-eval-trajectory-trials`) | eval run `completed`; `{served: 1}`, `{served: 2}`, then two tool errors | ≤ 30s |
 | Dispatch Fan-Out Waves | `conformance-dispatch-fanout-waves` | RFC 0243 §A.3 — a parallel `core.dispatch` (`maxConcurrency: 2`, `wait-all`/`collect`) whose supervisor's `mockDispatchPlan` names three `conformance-delay` children. At most `min(2, maxFanOut)` run at once and none is dropped. Gated on `agents.fanOut` admitting `wait-all` with `collect`. | `completed` | ≤ 30s |
 | Dispatch Per-Item Input | `conformance-dispatch-per-item` | RFC 0243 §A.4 — a sequential `core.dispatch` whose decision dispatches `conformance-dispatch-input-mapping-child` twice with `nextWorkerInputs` `item-a`, `item-b`. At `agents.fanOut.perItemInput: true` each child receives its item; otherwise the dispatch node fails `validation_error` and no child is dispatched. | `completed`, or `failed` without `perItemInput` | ≤ 30s |
 | Dispatch Per-Item Length Mismatch | `conformance-dispatch-per-item-mismatch` | `orchestrator-decision.schema.json` `nextWorkerInputs` — one item for two children. Every dispatch host fails the dispatch node `validation_error` and dispatches no child. | `failed` | ≤ 30s |
@@ -1046,17 +1048,27 @@ The `fixtures/eval-suites/` sub-directory holds `AgentEvalSuite` documents (`../
 Every task targets **the scripted agent `core.conformance.agents.scripted`**. Its contract:
 
 - `input.script` is an ordered list of `{ tool, arguments? }`. The agent makes exactly those tool calls, in order, each emitting `agent.tool-called` with `agentId: "core.conformance.agents.scripted"`, `toolName: tool` and `inputs: arguments`.
-- Each call goes through the host's eval tool boundary. In a task with `fixtures.toolResponses`, the RFC 0244 §D selection and `onMiss` rules apply. Otherwise the host answers the call with its own `arguments`. No scripted call reaches a live tool or an external effect.
+- Each call goes through the host's eval tool boundary. In a task with `fixtures.toolResponses`, the RFC 0244 §D selection and `onMiss` rules apply. Otherwise the host answers the call with its own `arguments`. No scripted call reaches a live tool or an external effect, except a miss on the counter tool under `onMiss: "live"` (below).
 - After the last call the agent decides, and its output is `input.output`.
 
 | Fixture | Facet | What the suite asserts |
 | --- | --- | --- |
 | `conformance-eval-trajectory` | `agents.evalSuite.trajectory` | each task's `trajectory` counts equal `lib/eval-trajectory.ts`'s grade of the script; an unmatched trajectory fails; a `kind: "trajectory"` task scores 1 or 0; the log carries one `agent.tool-called` per scripted call |
-| `conformance-eval-trials` | `agents.evalSuite.trials` | `eval.started.trialCount: 3`; three `eval.scored` per task with `trialIndex` 0..2; the per-task `trials` block and `trialStats` equal the §B formulas. Without the facet: `400 validation_error` at `createRun` |
-| `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-trials` | `agents.evalSuite.trials` | `eval.started.trialCount: 3`; three `eval.scored` per task with `trialIndex` 0..2; the per-task `trials` block and `trialStats` equal the §B formulas; `totalCostUsd`, when served with bracketed priced usage, is at least the agent's cost over all three trials. Without the facet: `400 validation_error` at `createRun` |
+| `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 shown by the counter fixtures below (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 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) |
+| `conformance-eval-counter-live` | `agents.evalSuite.fixtureMatching` | run twice, before and after `conformance-eval-counter-miss`: `fixtureMissCount` > 0; the two live `inc L` counts are consecutive; the second run's first `L` is the first run's last plus one (else `blocked`), and its `F` and `S` reads equal the first run's |
+| `conformance-eval-counter-miss` | `agents.evalSuite.fixtureMatching` | the three `inc S` calls return `{served: 1}`, `{served: 2}`, then a tool error; `inc F` returns a tool error. Neither miss moves the live counter |
+
+**The counter tool `conformance.eval:counter` is conformance-RESERVED** (the pattern of `core.conformance.side-effect`). A host that lists either counter fixture in discovery `fixtures` MUST, at its eval tool boundary:
+
+- answer a call that reaches the live tool with inputs `{key, op}` as follows. `inc` adds one to a counter scoped to the caller's owner triple and `key`, then returns `{key, count}`. `read` returns `{key, count}` without changing it. A key never incremented reads `0`.
+- keep that state for at least an hour, across eval runs;
+- record `outcome` on `agent.tool-returned` for every counter call: the live `{key, count}`, or a served entry's `response` verbatim. A miss under `onMiss: "fail"` carries `error` instead.
+
+The counter has no external effect, so serving it is safe on a production tenant. Two concurrent cuts on one tenant make the persistence check fail; the legs then record `blocked`, not a failure.
 
 ## OAuth provider fixtures
 

package/package.json

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

package/requirements.json

@@ -3,10 +3,10 @@
   "generatedFrom": "src/scenarios/*.test.ts",
   "counts": {
     "files": 749,
-    "tests": 2840,
-    "withStableId": 2840,
+    "tests": 2846,
+    "withStableId": 2846,
     "interpolatedTitles": 0,
-    "explicitIds": 2713
+    "explicitIds": 2719
   },
   "records": [
     {
@@ -31092,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": 162,
+      "line": 196,
       "title": "the RFC 0244 suite, summary and event fields validate and the negatives are refused",
       "explicitId": "openwop.requirement.0244.wire-shape",
       "citations": [
@@ -31131,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": 185,
+      "line": 219,
       "title": "the RFC 0244 additions are content-free (eval-summary-no-content-leak)",
       "explicitId": "openwop.requirement.0244.content-free",
       "citations": [
@@ -31148,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": 192,
+      "line": 226,
       "title": "the eval-suite fixtures validate against the v2 suite schema",
       "explicitId": "openwop.requirement.0244.fixtures-valid",
       "citations": [
@@ -31162,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": 199,
+      "line": 233,
       "title": "the RFC 0246 gating fields validate and stay in 0–1",
       "explicitId": "openwop.requirement.0246.gated-fields-shape",
       "citations": [
@@ -31184,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": 207,
+      "line": 241,
       "title": "a fixture entry may be marked isError, and only as a boolean (RFC 0245 §A)",
       "explicitId": "openwop.requirement.0245.fixture-error-shape",
       "citations": [
@@ -31206,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": 217,
+      "line": 251,
       "title": "a trajectory suite is graded per the reference grader",
       "explicitId": "openwop.requirement.0244.trajectory-graded",
       "citations": [
@@ -31240,7 +31240,7 @@
     {
       "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,
+      "line": 285,
       "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": [
@@ -31254,7 +31254,7 @@
     {
       "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,
+      "line": 293,
       "title": "the served EvalSummary validates and its counts match its rows (RFC 0081 §C)",
       "explicitId": "openwop.requirement.0081.summary-served",
       "citations": [
@@ -31268,7 +31268,7 @@
     {
       "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": 280,
+      "line": 314,
       "title": "repeated trials emit one eval.scored per task per trial",
       "explicitId": "openwop.requirement.0244.trials-per-task",
       "citations": [
@@ -31286,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": 291,
+      "line": 325,
       "title": "the per-task trials block and trialStats follow the §B formulas",
       "explicitId": "openwop.requirement.0244.trial-stats-formula",
       "citations": [
@@ -31322,10 +31322,94 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-eval-trajectory-trials.efficiency-toolcallcount-counts-the-scripted-agent-tool-called-events-c",
+      "file": "v2-eval-trajectory-trials.test.ts",
+      "line": 348,
+      "title": "efficiency.toolCallCount counts the scripted agent.tool-called events (§C)",
+      "explicitId": "openwop.requirement.0244.efficiency-tool-calls",
+      "citations": [
+        {
+          "section": "eval-summary.schema.json efficiency (RFC 0244 §C)",
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-eval-trajectory-trials.efficiency-model-and-token-counts-match-the-agent-s-provider-usage-c",
+      "file": "v2-eval-trajectory-trials.test.ts",
+      "line": 360,
+      "title": "efficiency model and token counts match the agent's provider.usage (§C)",
+      "explicitId": "openwop.requirement.0244.efficiency-model-usage",
+      "citations": [
+        {
+          "section": "eval-summary.schema.json efficiency (RFC 0244 §C)",
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-eval-trajectory-trials.totalcostusd-counts-every-trial-b",
+      "file": "v2-eval-trajectory-trials.test.ts",
+      "line": 371,
+      "title": "totalCostUsd counts every trial (§B)",
+      "explicitId": "openwop.requirement.0244.cost-every-trial",
+      "citations": [
+        {
+          "section": "agent-eval-suite.schema.json thresholds.maxCostUsd, eval-summary.schema.json totalCostUsd (RFC 0244 §B)",
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-eval-trajectory-trials.a-miss-under-onmiss-live-reaches-the-live-counter-and-is-counted-d",
+      "file": "v2-eval-trajectory-trials.test.ts",
+      "line": 401,
+      "title": "a miss under onMiss \"live\" reaches the live counter and is counted (§D)",
+      "explicitId": "openwop.requirement.0244.live-miss-counted",
+      "citations": [
+        {
+          "section": "RFC 0244 §D, fixtures.md counter contract",
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-eval-trajectory-trials.repeated-calls-are-served-the-first-unconsumed-fixture-entry-once-each-d",
+      "file": "v2-eval-trajectory-trials.test.ts",
+      "line": 409,
+      "title": "repeated calls are served the first unconsumed fixture entry, once each (§D)",
+      "explicitId": "openwop.requirement.0244.first-unconsumed",
+      "citations": [
+        {
+          "section": "RFC 0244 §D, fixtures.md counter contract",
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-eval-trajectory-trials.a-miss-under-onmiss-fail-never-reaches-the-live-counter-d",
+      "file": "v2-eval-trajectory-trials.test.ts",
+      "line": 417,
+      "title": "a miss under onMiss \"fail\" never reaches the live counter (§D)",
+      "explicitId": "openwop.requirement.0244.miss-no-live-call",
+      "citations": [
+        {
+          "section": "RFC 0244 §D, fixtures.md counter contract",
+          "requirement": null,
+          "interpolated": true
+        }
+      ]
+    },
     {
       "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": 314,
+      "line": 425,
       "title": "a fixture miss under onMiss \"fail\" fails the trial and is counted",
       "explicitId": "openwop.requirement.0244.fixture-miss-fails",
       "citations": [
@@ -31362,7 +31446,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": 334,
+      "line": 445,
       "title": "a suite using an unadvertised RFC 0244 feature is refused at createRun",
       "explicitId": "openwop.requirement.0244.unadvertised-feature-refused",
       "citations": [
@@ -31380,7 +31464,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": 350,
+      "line": 461,
       "title": "under passRule \"mean\" a task whose trials failed their trajectory does not pass (RFC 0246)",
       "explicitId": "openwop.requirement.0246.mean-gated",
       "citations": [
@@ -31394,7 +31478,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": 363,
+      "line": 474,
       "title": "a suite whose tasks failed their trajectory does not pass on the output scores (RFC 0246)",
       "explicitId": "openwop.requirement.0246.suite-gated",
       "citations": [
@@ -31408,7 +31492,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": 374,
+      "line": 485,
       "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": [
@@ -31422,7 +31506,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": 388,
+      "line": 499,
       "title": "a suite using isError is refused at createRun without fixtureErrors (RFC 0245 §C)",
       "explicitId": "openwop.requirement.0245.unadvertised-refused",
       "citations": [

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.24",
-  "corpusTag": "v2.46.24",
+  "version": "2.46.26",
+  "corpusTag": "v2.46.26",
   "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": "320f8d121cb19c16fe19dbe3ee0783c64951a117af461b6e371c74f1e1607dfa",
-    "api/v2/asyncapi.yaml": "51c944d2fb8fcf4169b5cda25bd83378f281e26a8ddda8942eccc6926c55c8a9",
-    "api/v2/openapi.yaml": "723c3df7a711a282a1b827fe024cadc365862f49da1f2800e358dac6584360c5",
+    "api/seams-v2.yaml": "fc5aaff321913531e04b13522de92a9a8fa3f61be836696e9ab83fbc563caa87",
+    "api/v2/asyncapi.yaml": "0ea85f3cb0af276cd7ed82e14810c1093917f0d1daa80bc0226b78e127c4e17d",
+    "api/v2/openapi.yaml": "7c7cd37cc0cabcd37285502594977f6ddc5a59f30938d7aede36f69e05322244",
     "api/v2/redocly.yaml": "1e66b60e6118ad11a823bb620678be464d99dfe50a40e3e6f93ec9429b88b34c",
     "schemas/README.md": "276fc1d51eb08e14e9127b9fd27761d7046ee33c12000f3a64a801322db8bf58",
     "schemas/a2a-task-state.schema.json": "75d5049dea8bd873ff0e7546f1c60c8d36c219bec7084264360be54a8be30ae1",
@@ -212,7 +212,7 @@
     "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": "c2bf78d9853dd41eefebc4e6408feb7abbec4bc52b8e675570512fd5056f20a3",
+    "spec/v1/core-standard-manifest.json": "580b853bb37383d5acea488fba6747193d1db4e6e63025255433dababf008d60",
     "spec/v1/deprecations.json": "e723bc11d7272c71789ad1303bb7f21809a8a024abf57594f9d5c35dc199ece9",
     "spec/v1/deprecations.schema.json": "3e393c405d2a41b467d8c5e3c468549078df1ce6a6d2588fc488097b95d9b55b",
     "spec/v1/end-of-support.json": "35f0bf3b70fe78b16e2a2fd81a153fc27e703f6c16376c6fe7cdf1f4f2c4e6d4",
@@ -318,9 +318,9 @@
     "spec/v2/path-manifest.json": "20f598f56df460ad3ed50aba3d6bc2933ea16a3c96ce125da1c5dd6989d4155c",
     "spec/v2/peer-dependency-aliases.json": "d10299280abee08258502925bc327293ee413e0108cd6e6ec75ff6110653308d",
     "spec/v2/profiles.json": "b382b261c7844798575f7c1b37c934f0da19846016a2337d883d4f5ef6e05479",
-    "spec/v2/release.json": "c7708b05e5fdced4ffab715f549f3dc5c9f8947739907eb93f1a2fba401ce0d2",
+    "spec/v2/release.json": "e2a9a7d13015eb3ca85bdbcd6ec422b6e91780fb9019b0e75e2855b826728b1d",
     "spec/v2/retention-floors.json": "eaf3722d95c79947af1d4269ef85117e126518c588cfcf1a2b21b97269f51624",
-    "spec/v2/surface-baseline.json": "e8fa9e1445ee9f65a4448a6daf31386a63a2ed1393ac7cc8aadb874bd8bb7646"
+    "spec/v2/surface-baseline.json": "4a1e5ab2349349eeeb9fa173e392627d49c2bee77ac8a42897aeacf2c3a4d784"
   },
-  "corpusCommit": "cff9ff17f18b589a3cea7fe96b0d00d751d82c2a"
+  "corpusCommit": "e5e8306a4f9c8c41394cfbe63fb58a08a74fe5b9"
 }

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

@@ -0,0 +1,112 @@
+/**
+ * RFC 0244 §D, G2 — the suite-owned counter tool `conformance.eval:counter`
+ * makes "a miss under onMiss: \"fail\" never reaches a live tool" and "the
+ * first unconsumed entry is served" observable from outside. Pure judges over
+ * three sequential eval runs, for `v2-eval-trajectory-trials.test.ts`.
+ *
+ * The counter's live effect is persistent, tenant-scoped state: `inc` adds one
+ * to `(owner, key)` and returns `{key, count}`; `read` returns it unchanged
+ * (contract in `fixtures.md` §Eval-suite fixtures). The runs are:
+ *   A. `conformance-eval-counter-live` (`onMiss: "live"`): inc L, inc L, read F, read S.
+ *   B. `conformance-eval-counter-miss` (`onMiss: "fail"`): inc S three times
+ *      against two exact entries serving `{served: 1}` then `{served: 2}`, then inc F.
+ *   C. `conformance-eval-counter-live` again.
+ * C's first L is A's second L plus one, which proves the state persisted
+ * between runs; only then do unchanged F and S counts prove B's two misses
+ * never ran the live tool. A host that leaked a miss reads one higher. When
+ * persistence is not shown (a concurrent cut on the tenant, or no durable
+ * state) the verdict is `blocked`, never a failure.
+ *
+ * @see RFCS/0244-eval-trajectories-trials-and-recorded-fixtures.md §D
+ */
+
+export const COUNTER_TOOL = 'conformance.eval:counter';
+
+export interface CounterFinding { readonly ok: boolean; readonly message: string }
+export type CounterVerdict =
+  | { readonly kind: 'blocked'; readonly reason: string }
+  | { readonly kind: 'judged'; readonly findings: readonly CounterFinding[] };
+
+type Rec = Record<string, unknown>;
+export interface CounterEvent { readonly type: string; readonly payload: Rec }
+export interface CounterCall { readonly key: unknown; readonly op: unknown; readonly outcome: unknown; readonly error: unknown; readonly returned: boolean }
+
+const isRec = (v: unknown): v is Rec => typeof v === 'object' && v !== null && !Array.isArray(v);
+const count = (c: CounterCall | undefined): number | undefined => {
+  const o = c?.outcome;
+  return isRec(o) && typeof o['count'] === 'number' && Number.isInteger(o['count']) ? o['count'] : undefined;
+};
+
+/** The counter calls of one run, in log order, each paired with its return by `callId`. */
+export function counterCalls(events: readonly CounterEvent[], agentId: string): CounterCall[] {
+  const returns = new Map<string, Rec>();
+  for (const e of events) {
+    if (e.type === 'agent.tool-returned' && e.payload['toolName'] === COUNTER_TOOL && typeof e.payload['callId'] === 'string') returns.set(e.payload['callId'], e.payload);
+  }
+  const out: CounterCall[] = [];
+  for (const e of events) {
+    if (e.type !== 'agent.tool-called' || e.payload['toolName'] !== COUNTER_TOOL || e.payload['agentId'] !== agentId) continue;
+    const inputs = isRec(e.payload['inputs']) ? e.payload['inputs'] : {};
+    const r = typeof e.payload['callId'] === 'string' ? returns.get(e.payload['callId']) : undefined;
+    out.push({ key: inputs['key'], op: inputs['op'], outcome: r?.['outcome'], error: r?.['error'], returned: r !== undefined });
+  }
+  return out;
+}
+
+/** Run A or C: inc L, inc L, read F, read S, every one answered live with `{key, count}`. */
+function liveCounts(calls: readonly CounterCall[], label: string): { counts: { L1: number; L2: number; F: number; S: number } } | { reason: string } {
+  if (calls.length !== 4) return { reason: `run ${label} MUST log the four scripted counter calls (got ${calls.length})` };
+  const [l1, l2, f, s] = calls.map(count);
+  if (l1 === undefined || l2 === undefined || f === undefined || s === undefined) {
+    return { reason: `run ${label}: every live counter call MUST record outcome {key, count} on agent.tool-returned (fixtures.md counter contract)` };
+  }
+  return { counts: { L1: l1, L2: l2, F: f, S: s } };
+}
+
+/** §D `onMiss: "live"` on run A: the misses reached the live tool, and the summary reports them. */
+export function judgeLiveMiss(a: readonly CounterCall[], fixtureMissCount: unknown): CounterVerdict {
+  const live = liveCounts(a, 'A');
+  if ('reason' in live) return { kind: 'blocked', reason: live.reason };
+  return {
+    kind: 'judged',
+    findings: [
+      { ok: typeof fixtureMissCount === 'number' && fixtureMissCount > 0, message: `a task whose misses ran live under onMiss "live" MUST report fixtureMissCount > 0 (got ${String(fixtureMissCount)})` },
+      { ok: live.counts.L2 === live.counts.L1 + 1, message: `two live inc calls MUST advance the counter by one each (got ${live.counts.L1} then ${live.counts.L2})` },
+    ],
+  };
+}
+
+/** §D selection on run B: the two exact entries are served in order, once each, and the third call is a miss. */
+export function judgeFirstUnconsumed(b: readonly CounterCall[]): CounterVerdict {
+  const s = b.filter((c) => c.key === 'S');
+  if (s.length !== 3 || !s.every((c) => c.returned)) return { kind: 'blocked', reason: `run B MUST log three paired counter calls for key S (got ${s.length})` };
+  const served = (c: CounterCall): unknown => (isRec(c.outcome) ? c.outcome['served'] : undefined);
+  return {
+    kind: 'judged',
+    findings: [
+      { ok: served(s[0]!) === 1 && s[0]!.error === undefined, message: `the first call MUST be served the first unconsumed entry {served: 1} (got ${JSON.stringify(s[0]!.outcome ?? s[0]!.error)})` },
+      { ok: served(s[1]!) === 2 && s[1]!.error === undefined, message: `the second call MUST be served the next unconsumed entry {served: 2}, each entry consumed once (got ${JSON.stringify(s[1]!.outcome ?? s[1]!.error)})` },
+      { ok: s[2]!.error !== undefined && count(s[2]) === undefined && served(s[2]!) === undefined, message: `the third call matches no unconsumed entry, so under onMiss "fail" it MUST return a tool error (got ${JSON.stringify(s[2]!.outcome ?? s[2]!.error)})` },
+    ],
+  };
+}
+
+/** §D `onMiss: "fail"` across A → B → C: neither miss in B ran the live tool. */
+export function judgeMissNoLiveCall(a: readonly CounterCall[], b: readonly CounterCall[], c: readonly CounterCall[]): CounterVerdict {
+  const ra = liveCounts(a, 'A');
+  if ('reason' in ra) return { kind: 'blocked', reason: ra.reason };
+  const rc = liveCounts(c, 'C');
+  if ('reason' in rc) return { kind: 'blocked', reason: rc.reason };
+  if (rc.counts.L1 !== ra.counts.L2 + 1) {
+    return { kind: 'blocked', reason: `the counter state did not persist from run A to run C on its own (L went ${ra.counts.L2} → ${rc.counts.L1}, want ${ra.counts.L2 + 1}): another run on the tenant, or no durable state, so unchanged counts prove nothing` };
+  }
+  const f = b.filter((x) => x.key === 'F');
+  return {
+    kind: 'judged',
+    findings: [
+      { ok: f.length === 1 && f[0]!.error !== undefined && count(f[0]) === undefined, message: `run B's unmatched inc F MUST return a tool error, not a live count (got ${JSON.stringify(f[0]?.outcome ?? f[0]?.error)})` },
+      { ok: rc.counts.F === ra.counts.F, message: `a miss under onMiss "fail" MUST NOT reach the live tool: counter F MUST read the same after run B (${ra.counts.F} → ${rc.counts.F})` },
+      { ok: rc.counts.S === ra.counts.S, message: `fixture-served calls and the unmatched third inc S MUST NOT reach the live tool: counter S MUST read the same after run B (${ra.counts.S} → ${rc.counts.S})` },
+    ],
+  };
+}

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

@@ -0,0 +1,139 @@
+/**
+ * RFC 0244 §C — the per-task `efficiency.toolCallCount` is the count of
+ * `agent.tool-called` events inside the task's invocation brackets, as a mean
+ * over its trials. A pure judge over an eval run's `EvalSummary` and event log,
+ * for `v2-eval-trajectory-trials.test.ts`.
+ *
+ * The expected count is known in advance: the scripted agent replays each
+ * task's `input.script` as tool calls on every trial, so a task's mean is its
+ * script length, whatever the host. The judge never reads the host's own count
+ * to decide what the count should be. Only `toolCallCount` is judged:
+ * `modelCallCount` and the token sums depend on whether the host's scripted
+ * agent calls a model, which the fixture contract leaves to the host.
+ *
+ * `efficiency` is optional on a summary entry, so a run whose entries carry
+ * none is not evidence either way (`applicable: false`).
+ *
+ * @see RFCS/0244-eval-trajectories-trials-and-recorded-fixtures.md §C
+ */
+
+export interface EfficiencyFinding { readonly ok: boolean; readonly message: string }
+export interface EfficiencyVerdict { readonly applicable: boolean; readonly findings: readonly EfficiencyFinding[] }
+export interface ScriptedTask { readonly taskId: string; readonly scriptLength: number }
+
+type Rec = Record<string, unknown>;
+const isRec = (v: unknown): v is Rec => typeof v === 'object' && v !== null && !Array.isArray(v);
+
+/**
+ * `toolCallsInLog` is the number of `agent.tool-called` events the run's log
+ * carries for the agent under test. On a run of one trial per task the
+ * per-task counts sum to it; on a multi-trial run pass `undefined`, since the
+ * sum of means is not an event count.
+ */
+export function judgeToolCallCount(summary: Rec, tasks: readonly ScriptedTask[], toolCallsInLog: number | undefined): EfficiencyVerdict {
+  const entries = (Array.isArray(summary['tasks']) ? (summary['tasks'] as unknown[]) : []).filter(isRec);
+  const findings: EfficiencyFinding[] = [];
+  let reported = 0;
+  let sum = 0;
+  for (const t of tasks) {
+    const entry = entries.find((e) => e['taskId'] === t.taskId);
+    const eff = entry?.['efficiency'];
+    if (!isRec(eff)) continue;
+    reported += 1;
+    const got = eff['toolCallCount'];
+    findings.push({
+      ok: typeof got === 'number' && got === t.scriptLength,
+      message: `task ${t.taskId}: efficiency.toolCallCount MUST count the agent.tool-called events in its brackets, the ${t.scriptLength} scripted calls per trial (got ${String(got)})`,
+    });
+    if (typeof got === 'number') sum += got;
+  }
+  if (reported === 0) return { applicable: false, findings: [] };
+  if (toolCallsInLog !== undefined && reported === tasks.length) {
+    findings.push({
+      ok: sum === toolCallsInLog,
+      message: `the per-task toolCallCount values MUST sum to the run's ${toolCallsInLog} agent.tool-called events on a one-trial run (got ${sum})`,
+    });
+  }
+  return { applicable: true, findings };
+}
+
+/**
+ * The `provider.usage` payloads of the agent under test, in log order.
+ * `provider.usage` carries no `agentId`, so attribution is positional: a usage
+ * event counts while an `agent.invocation.started` of `agentId` is open and no
+ * other agent's invocation (a judge, a delegate) is open inside it. Brackets
+ * are emitted only by an `agents.liveRuntime` host; `bracketed: false` means
+ * the log has none, and the usage list is then every `provider.usage` of the run.
+ */
+export function agentUsage(events: readonly { readonly type: string; readonly payload: Rec }[], agentId: string): { bracketed: boolean; usage: Rec[] } {
+  const open = new Map<string, boolean>();
+  let mine = 0;
+  let other = 0;
+  let bracketed = false;
+  const inside: Rec[] = [];
+  const all: Rec[] = [];
+  for (const e of events) {
+    const id = e.payload['invocationId'];
+    if (e.type === 'agent.invocation.started' && typeof id === 'string') {
+      bracketed = true;
+      const isMine = e.payload['agentId'] === agentId;
+      open.set(id, isMine);
+      if (isMine) mine += 1; else other += 1;
+    } else if (e.type === 'agent.invocation.completed' && typeof id === 'string' && open.has(id)) {
+      if (open.get(id)) mine -= 1; else other -= 1;
+      open.delete(id);
+    } else if (e.type === 'provider.usage') {
+      all.push(e.payload);
+      if (mine > 0 && other === 0) inside.push(e.payload);
+    }
+  }
+  return bracketed ? { bracketed, usage: inside } : { bracketed, usage: all };
+}
+
+const FIELDS = [['modelCallCount', () => 1], ['inputTokens', (u: Rec) => u['inputTokens']], ['outputTokens', (u: Rec) => u['outputTokens']]] as const;
+const close = (a: number, b: number): boolean => Math.abs(a - b) <= 1e-9 * Math.max(1, Math.abs(b));
+
+/**
+ * §C `modelCallCount`, `inputTokens` and `outputTokens`. Each is a mean over
+ * `trials` identical trials, so the per-task values times `trials` sum to the
+ * agent's usage in the log. With brackets the sums MUST be equal; without them
+ * the run's usage also holds any host-internal call, so the sums MUST NOT
+ * exceed it. A field is judged only when every task reports it. A run with no
+ * usage and zero counts witnesses nothing (`applicable: false`).
+ */
+export function judgeModelUsage(summary: Rec, taskIds: readonly string[], log: { bracketed: boolean; usage: readonly Rec[] }, trials: number): EfficiencyVerdict {
+  const entries = (Array.isArray(summary['tasks']) ? (summary['tasks'] as unknown[]) : []).filter(isRec);
+  const effs = taskIds.map((id) => entries.find((e) => e['taskId'] === id)?.['efficiency']);
+  const findings: EfficiencyFinding[] = [];
+  let witnessed = false;
+  for (const [field, of] of FIELDS) {
+    const vals = effs.map((x) => (isRec(x) ? x[field] : undefined));
+    if (!vals.every((v) => typeof v === 'number')) continue;
+    const reported = (vals as number[]).reduce((a, b) => a + b, 0) * trials;
+    const inLog = log.usage.reduce((a, u) => a + (typeof of(u) === 'number' ? (of(u) as number) : 0), 0);
+    if (reported === 0 && inLog === 0) continue;
+    witnessed = true;
+    findings.push(log.bracketed
+      ? { ok: close(reported, inLog), message: `the per-task efficiency.${field} values times ${trials} trial(s) MUST sum to the ${inLog} the agent's provider.usage events inside its invocation brackets carry (got ${reported})` }
+      : { ok: reported <= inLog + 1e-9 * Math.max(1, inLog), message: `the per-task efficiency.${field} values times ${trials} trial(s) MUST NOT exceed the ${inLog} the run's provider.usage events carry (got ${reported})` });
+  }
+  return witnessed ? { applicable: true, findings } : { applicable: false, findings: [] };
+}
+
+/**
+ * §B "cost counts every trial": on a multi-trial run the summary's
+ * `totalCostUsd` holds the `costEstimateUsd` of the agent's usage in every
+ * trial, so a host that priced only one trial reads short. Only that floor is
+ * judged: whether a judge's or the host's own calls are priced in is not
+ * pinned, so a higher total is not a failure. Judged only
+ * with brackets (otherwise the agent's usage cannot be told from the host's
+ * own) and only when every attributed usage event carries a cost.
+ */
+export function judgeCostEveryTrial(summary: Rec, log: { bracketed: boolean; usage: readonly Rec[] }): EfficiencyVerdict {
+  const total = summary['totalCostUsd'];
+  if (typeof total !== 'number' || !log.bracketed || log.usage.length === 0) return { applicable: false, findings: [] };
+  const costs = log.usage.map((u) => u['costEstimateUsd']);
+  if (!costs.every((c) => typeof c === 'number')) return { applicable: false, findings: [] };
+  const sum = (costs as number[]).reduce((a, b) => a + b, 0);
+  return { applicable: true, findings: [{ ok: total >= sum || close(total, sum), message: `totalCostUsd MUST count every trial: it MUST be at least the ${sum} costEstimateUsd of the agent's ${log.usage.length} provider.usage events across all trials (got ${total})` }] };
+}

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

@@ -31,6 +31,31 @@
  *   6. Refusal — a host advertising `agents.evalSuite` without `trials` that
  *      lists `conformance-eval-trials` refuses it at createRun with
  *      `400 validation_error`.
+ *   6a. §C efficiency (2.46.25) — on the trajectory run, and on the trials run
+ *      when served, each task's `efficiency.toolCallCount` equals its script
+ *      length (the mean over identical trials), and on the one-trial run the
+ *      counts sum to the log's `agent.tool-called` events. `efficiency` is
+ *      optional, so a host that reports none records `inapplicable`. Judge in
+ *      `lib/eval-efficiency-witness.ts`. The never-gated rule is not judged:
+ *      no fixture makes efficiency the only difference between two verdicts.
+ *   6c. §C model usage and §B cost (2.46.26), on the same runs. The per-task
+ *      `modelCallCount`, `inputTokens` and `outputTokens`, times the trial
+ *      count, sum to the agent's `provider.usage` inside its
+ *      `agent.invocation.*` brackets (judge and delegate calls excluded), or do
+ *      not exceed the run's usage when the host emits no brackets
+ *      (`0244.efficiency-model-usage`). On the trials run, `totalCostUsd` is
+ *      at least the agent's priced usage over all three trials
+ *      (`0244.cost-every-trial`). The scripted agent need not call a model, so
+ *      a run with no usage, no brackets or no prices records `inapplicable`.
+ *   6b. §D through the counter tool `conformance.eval:counter` (2.46.25, G2),
+ *      gated on `fixtureMatching` and both counter fixtures in discovery.
+ *      Three sequential runs: `conformance-eval-counter-live` (A), then
+ *      `conformance-eval-counter-miss` (B), then the live suite again (C).
+ *      `0244.live-miss-counted` (A's misses ran live and are counted),
+ *      `0244.first-unconsumed` (B serves `{served: 1}`, `{served: 2}`, then a
+ *      tool error), `0244.miss-no-live-call` (the live counters B's misses
+ *      touched read the same in C as in A, once C proves the state persisted).
+ *      Judges in `lib/eval-counter-witness.ts`.
  *
  * RFC 0081 §C, on the `conformance-eval-trajectory` run (2.46.20). Judges in
  * `lib/eval-envelope-witness.ts`.
@@ -84,6 +109,8 @@ import { judgeEvalEnvelope, judgeSummaryServed } from '../lib/eval-envelope-witn
 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';
+import { agentUsage, judgeCostEveryTrial, judgeModelUsage, judgeToolCallCount } from '../lib/eval-efficiency-witness.js';
+import { counterCalls, judgeFirstUnconsumed, judgeLiveMiss, judgeMissNoLiveCall, type CounterCall } from '../lib/eval-counter-witness.js';
 
 const PROFILE = majorProfile(2);
 const UNREADABLE = 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0';
@@ -98,6 +125,13 @@ const ID_TRIALS = 'openwop.requirement.0244.trials-per-task';
 const ID_TRIAL_STATS = 'openwop.requirement.0244.trial-stats-formula';
 const ID_MISS = 'openwop.requirement.0244.fixture-miss-fails';
 const ID_REFUSED = 'openwop.requirement.0244.unadvertised-feature-refused';
+const ID_EFFICIENCY = 'openwop.requirement.0244.efficiency-tool-calls';
+const ID_MODEL_USAGE = 'openwop.requirement.0244.efficiency-model-usage';
+const ID_COST_TRIALS = 'openwop.requirement.0244.cost-every-trial';
+const ID_LIVE_MISS = 'openwop.requirement.0244.live-miss-counted';
+const ID_FIRST_UNCONSUMED = 'openwop.requirement.0244.first-unconsumed';
+const ID_NO_LIVE_CALL = 'openwop.requirement.0244.miss-no-live-call';
+const DOC_COUNTER = 'RFC 0244 §D, fixtures.md counter contract';
 const ID_GATED_SHAPE = 'openwop.requirement.0246.gated-fields-shape';
 const ID_MEAN_GATED = 'openwop.requirement.0246.mean-gated';
 const ID_SUITE_GATED = 'openwop.requirement.0246.suite-gated';
@@ -190,7 +224,7 @@ describe('v2 RFC 0244 — wire shape (server-free)', () => {
   });
 
   it('the eval-suite fixtures validate against the v2 suite schema', () => {
-    for (const id of ['conformance-eval-trajectory', 'conformance-eval-trials', 'conformance-eval-fixture-miss', 'conformance-eval-trajectory-gate', 'conformance-eval-trajectory-gate-mean', 'conformance-eval-fixture-error']) {
+    for (const id of ['conformance-eval-trajectory', 'conformance-eval-trials', 'conformance-eval-fixture-miss', 'conformance-eval-trajectory-gate', 'conformance-eval-trajectory-gate-mean', 'conformance-eval-fixture-error', 'conformance-eval-counter-live', 'conformance-eval-counter-miss']) {
       const r = suiteSchema(fixture(id));
       expect(r.ok, req(ID_FIXTURES, 'fixtures.md §eval-suites', `${id} MUST validate: ${r.errors}`)).toBe(true);
     }
@@ -311,6 +345,83 @@ describe('v2 RFC 0244 — host behaviour', () => {
     if (se !== undefined) expect(withinTolerance(Number(stats['scoreStderr']), se), req(ID_TRIAL_STATS, DOC, `trialStats.scoreStderr MUST equal sd(per-task means)/√T within 1e-9 relative (got ${String(stats['scoreStderr'])}, want ${se})`)).toBe(true);
   });
 
+  it('efficiency.toolCallCount counts the scripted agent.tool-called events (§C)', async () => {
+    const r = await trajectoryRun();
+    if ('skip' in r) return softSkip(...r.skip);
+    const scriptedTasks = (s: Suite) => s.tasks.map((t) => ({ taskId: t.taskId, scriptLength: t.input.script.length }));
+    const logCalls = r.o.events.filter((e) => e.type === 'agent.tool-called' && e.payload['agentId'] === AGENT).length;
+    const verdicts = [judgeToolCallCount(r.o.summary, scriptedTasks(fixture('conformance-eval-trajectory')), logCalls)];
+    const t = await trialsRun();
+    if (!('skip' in t)) verdicts.push(judgeToolCallCount(t.o.summary, scriptedTasks(t.suite), undefined));
+    if (!verdicts.some((v) => v.applicable)) return softSkip('inapplicable', 'no task entry carries efficiency, which RFC 0244 §C makes optional');
+    for (const v of verdicts) for (const x of v.findings) expect(x.ok, req(ID_EFFICIENCY, 'eval-summary.schema.json efficiency (RFC 0244 §C)', x.message)).toBe(true);
+  });
+
+  it('efficiency model and token counts match the agent\'s provider.usage (§C)', async () => {
+    const r = await trajectoryRun();
+    if ('skip' in r) return softSkip(...r.skip);
+    const ids = (s: Suite) => s.tasks.map((t) => t.taskId);
+    const verdicts = [judgeModelUsage(r.o.summary, ids(fixture('conformance-eval-trajectory')), agentUsage(r.o.events, AGENT), 1)];
+    const t = await trialsRun();
+    if (!('skip' in t)) verdicts.push(judgeModelUsage(t.o.summary, ids(t.suite), agentUsage(t.o.events, AGENT), t.n));
+    if (!verdicts.some((v) => v.applicable)) return softSkip('inapplicable', 'no run carries both a reported model count and provider.usage to check it against (the scripted agent need not call a model; RFC 0244 §C fields are optional)');
+    for (const v of verdicts) for (const x of v.findings) expect(x.ok, req(ID_MODEL_USAGE, 'eval-summary.schema.json efficiency (RFC 0244 §C)', x.message)).toBe(true);
+  });
+
+  it('totalCostUsd counts every trial (§B)', async () => {
+    const t = await trialsRun();
+    if ('skip' in t) return softSkip(...t.skip);
+    const v = judgeCostEveryTrial(t.o.summary, agentUsage(t.o.events, AGENT));
+    if (!v.applicable) return softSkip('inapplicable', 'the trials run carries no totalCostUsd, no agent.invocation.* brackets, or an unpriced provider.usage, so the per-trial cost is not observable');
+    for (const x of v.findings) expect(x.ok, req(ID_COST_TRIALS, 'agent-eval-suite.schema.json thresholds.maxCostUsd, eval-summary.schema.json totalCostUsd (RFC 0244 §B)', x.message)).toBe(true);
+  });
+
+  type CounterRuns = { skip: [Parameters<typeof softSkip>[0], string] } | { a: CounterCall[]; b: CounterCall[]; c: CounterCall[]; aMisses: unknown };
+  let counterSeq: Promise<CounterRuns> | undefined;
+  /** A → B → C, strictly in order, once per worker: the three counter legs read the same runs. */
+  function counterRuns(): Promise<CounterRuns> {
+    counterSeq ??= (async (): Promise<CounterRuns> => {
+      const { doc, facet } = await evalSuiteFacet();
+      if (!doc) return { skip: ['blocked', UNREADABLE] };
+      if (facet?.['fixtureMatching'] !== true) return { skip: ['inapplicable', 'the host does not advertise agents.evalSuite.fixtureMatching'] };
+      for (const id of ['conformance-eval-counter-live', 'conformance-eval-counter-miss']) {
+        if (!isFixtureAdvertised(id)) return { skip: ['inapplicable', `the host does not advertise fixture ${id}, its opt-in to the counter-tool contract`] };
+      }
+      const a = await runSuiteOnce('conformance-eval-counter-live');
+      if (a.kind === 'skip') return { skip: [a.disposition, `run A: ${a.reason}`] };
+      const b = await runSuiteOnce('conformance-eval-counter-miss');
+      if (b.kind === 'skip') return { skip: [b.disposition, `run B: ${b.reason}`] };
+      const c = await runSuiteOnce('conformance-eval-counter-live');
+      if (c.kind === 'skip') return { skip: [c.disposition, `run C: ${c.reason}`] };
+      return { a: counterCalls(a.events, AGENT), b: counterCalls(b.events, AGENT), c: counterCalls(c.events, AGENT), aMisses: taskEntry(a.summary, 'live-counter')?.['fixtureMissCount'] };
+    })();
+    return counterSeq;
+  }
+
+  it('a miss under onMiss "live" reaches the live counter and is counted (§D)', async () => {
+    const r = await counterRuns();
+    if ('skip' in r) return softSkip(...r.skip);
+    const v = judgeLiveMiss(r.a, r.aMisses);
+    if (v.kind === 'blocked') return softSkip('blocked', v.reason);
+    for (const x of v.findings) expect(x.ok, req(ID_LIVE_MISS, DOC_COUNTER, x.message)).toBe(true);
+  });
+
+  it('repeated calls are served the first unconsumed fixture entry, once each (§D)', async () => {
+    const r = await counterRuns();
+    if ('skip' in r) return softSkip(...r.skip);
+    const v = judgeFirstUnconsumed(r.b);
+    if (v.kind === 'blocked') return softSkip('blocked', v.reason);
+    for (const x of v.findings) expect(x.ok, req(ID_FIRST_UNCONSUMED, DOC_COUNTER, x.message)).toBe(true);
+  });
+
+  it('a miss under onMiss "fail" never reaches the live counter (§D)', async () => {
+    const r = await counterRuns();
+    if ('skip' in r) return softSkip(...r.skip);
+    const v = judgeMissNoLiveCall(r.a, r.b, r.c);
+    if (v.kind === 'blocked') return softSkip('blocked', v.reason);
+    for (const x of v.findings) expect(x.ok, req(ID_NO_LIVE_CALL, DOC_COUNTER, x.message)).toBe(true);
+  });
+
   it('a fixture miss under onMiss "fail" fails the trial and is counted', async () => {
     const { doc, facet } = await evalSuiteFacet();
     if (!doc) return softSkip('blocked', UNREADABLE);