diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml
index f292f95..56e8223 100644
--- a/.github/workflows/test.yaml
+++ b/.github/workflows/test.yaml
@@ -65,10 +65,16 @@ jobs:
         with:
           filter: blob:none
           fetch-depth: 0
+      - name: Set up Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: 22
       - name: Install uv
         uses: astral-sh/setup-uv@v7
         with:
           python-version: ${{ matrix.env.python }}
+      - name: Install agent CLIs
+        run: npm install --global @anthropic-ai/claude-code @openai/codex
       - name: create hatch environment
         run: uvx hatch env create ${{ matrix.env.name }}
       - name: list all all installed package versions
diff --git a/.gitignore b/.gitignore
index eea4877..fc17263 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,6 +11,10 @@ __pycache__/
 # Distribution / packaging
 /dist/
 
+# uv's resolved dependency set. acumen is a library — consumers resolve their own tree, and
+# CI resolves fresh through hatch — so a committed lock would pin nothing that is checked.
+/uv.lock
+
 # Tests and coverage
 /data/
 /node_modules/
diff --git a/.vscode/settings.json b/.vscode/settings.json
index e034b91..7c09f6d 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -15,4 +15,5 @@
     "python.analysis.typeCheckingMode": "basic",
     "python.testing.pytestEnabled": true,
     "python.testing.pytestArgs": ["-vv", "--color=yes"],
+    "cursorpyright.analysis.typeCheckingMode": "basic",
 }
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6700dde..aca4e2f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,3 +9,69 @@ and this project adheres to [Semantic Versioning][].
 [semantic versioning]: https://semver.org/
 
 ## [0.0.1dev]
+
+### Added
+
+- Run Claude and Codex models side by side in benchmark matrices and use either
+  provider for drafting, improving, task generation, and shipping.
+- Compute `cost_usd` from each run's token breakdown rather than the provider's own
+  figure, so both providers are priced by one arithmetic path and cached input is billed
+  at its own rate. The rates used are frozen into `result.json`.
+- Add `acumen prices` to show the rate table and `acumen prices --refresh` to diff it
+  against the providers' published pricing, plus a `prices:` config key to override it.
+- Ship no rate table at all: rates are read from the providers' pricing pages on every
+  command that prices something, since a table compiled into a release is wrong from
+  whatever date prices next move, and each run's cost is frozen when written rather than
+  corrected later. `prices:` in `config.yaml` still overrides, and still wins.
+- Fail `acumen bench` when the pricing pages cannot be read, before anything is spent:
+  cost is a headline metric of the report, so a pass that cannot establish rates should
+  not run. `draft`, `improve`, `tasks`, and `ship` degrade to unpriced instead, warning
+  that Codex's `max_usd` cannot be enforced without rates.
+- Record `price_source` and `price_rates_as_of` next to `price_rates` in every
+  `result.json`, so runs benchmarked months apart remain individually attributable and a
+  single report can mix them without restating either.
+- Flag arms in a report that were priced on different dates: the cost difference between
+  them includes any change in provider pricing, not only the skill's effect.
+- Render an HTML transcript for Codex runs too, from the `codex exec` event stream.
+- Run the whole comparison from one `acumen bench`: with no arm selected it now covers
+  every arm the project has — the baseline plus each version in `skills/` — benching them
+  one after another against a single prepared target, with per-arm counts and tallies and a
+  combined total. `--dry-run` plans the same set for free, and `--no-skill` / `--skill vN`
+  still restrict the pass to one arm. A version in `skills/` that fails to load stops the
+  pass at planning rather than being dropped from the comparison.
+
+### Changed
+
+- Make both backends optional, so a Claude-only and a Codex-only install are each complete:
+  the Claude Agent SDK moves to the `claude` extra (`pip install acumen[claude]`, or
+  `acumen[all]`) and Codex needs only its CLI on `PATH`. Selecting a model whose backend is
+  not installed fails preflight with the command that installs it.
+- Enforce `max_turns` and `max_usd` for Codex, which has no cap of its own, from its event
+  stream. Turns are counted in completed model actions rather than `codex exec` invocations —
+  one invocation is a single Codex turn, so the old count was always 1 — and the run is
+  stopped at the cap. `max_usd` can only mark the outcome: Codex reports usage when a turn
+  ends, so an over-budget run is recorded as a `budget` failure after the spend.
+
+- Allow `acumen bench --auth {auto,session,api}`, defaulting to the provider's subscription
+  like every other command. The old API-only rule existed because a per-run `cost_usd` needed
+  metered billing; cost is now derived from token counts, which a subscription run reports
+  just as fully. `result.json` records the run's `auth_mode`, since under `session` the figure
+  is what the run would have cost at API rates rather than metered spend.
+- Treat exhausted provider subscription usage and API credit as benchmark-invalid
+  infrastructure failures: print the provider error, cancel only that provider's remaining
+  cells while other providers finish, exit non-zero, and refuse to report or improve from the
+  invalid evidence. Resuming automatically retries the invalid and cancelled cells after the
+  credential is replenished.
+
+### Fixed
+
+- Let `acumen tasks` generate over the untouched `tasks.yaml` placeholder that `acumen init`
+  writes, instead of demanding `--force` — the two documented first steps of the loop
+  contradicted each other. A file the user has edited is still protected.
+- Stop feeding Codex transcripts to `claude-code-log`, which reads the SDK-native format
+  only: it skipped every line, exited 0, and wrote an empty page that was then recorded as a
+  successfully rendered transcript.
+- Drop `Claude` from the drafting and improving prompts, which described the artifact as a
+  "Claude Skill" even when a Codex agent was writing it for a non-Claude skills directory.
+- Remove `check_auth`/`auth_available`, which only ever looked for Claude credentials and
+  would report a Codex-only setup as unauthenticated. `resolve_auth_mode` replaced them.
diff --git a/README.md b/README.md
index cecf89e..54cf871 100644
--- a/README.md
+++ b/README.md
@@ -48,6 +48,7 @@ acumen draft                     # generate skills/v1 from the package source, o
 acumen bench --skill v1          # benchmark the skill against the baseline
 acumen improve                   # generate skills/v2 from v1's train results, or write by hand
 acumen bench --skill v2
+acumen bench                     # or: every arm at once (baseline + each skills/vN)
 acumen report                    # aggregate every run into report.html
 
 # 4. Once a version proves out, ship it into the package itself:
@@ -67,6 +68,95 @@ train/test isolation, and for `draft`/`improve` it is recorded in the version's
 shown in the report. (Don't paste held-out test answers into `improve` feedback — that would
 defeat the split.)
 
+Claude and Codex can run side by side. Put both model families in `models` to compare them
+in one matrix; model IDs beginning with `claude` use Claude Code, while `gpt-*`, `o1`,
+`o3`, `o4`, and `codex-*` use Codex:
+
+```yaml
+models:
+  - claude-opus-5
+  - claude-sonnet-5
+  - claude-haiku-4-5-20251001
+  - gpt-5.6-sol
+  - gpt-5.6-terra
+  - gpt-5.6-luna
+```
+
+This spans each provider's quality/cost range; it is not a claim that the tiers are
+one-to-one equivalents.
+
+Neither backend is required. Claude is an optional dependency and Codex is an external CLI,
+so install only the one you run — `pip install acumen[claude]`, or plain `acumen` plus the
+`codex` CLI on `PATH`. Selecting a model whose backend is missing fails immediately, with the
+install command, before acumen prepares a target or spends anything.
+
+Claude API runs use `ANTHROPIC_API_KEY`; Codex API runs use `CODEX_API_KEY` (or
+`OPENAI_API_KEY`). The meta-agent commands also accept a Codex model through their
+`*_model` config keys or `--model`.
+
+Every agentic command — `bench` included — takes `--auth {auto,session,api}` and defaults to
+the provider's logged-in subscription, falling back to its API key. Both billing modes report
+tokens, so Acumen can calculate the same API-rate estimate for either. Under `session`, that
+estimate is what the run *would* have cost at API rates, not money billed — so each run records
+its `auth_mode` alongside the figure.
+
+If the selected subscription runs out of usage or the API account runs out of credit, Acumen
+invalidates the pass instead of scoring that as an agent failure: it prints the provider error,
+cancels remaining cells for that provider, lets other providers finish all running and queued
+cells, and exits non-zero. Replenish the credential and rerun the same command; automatic resume
+retries the invalid and cancelled cells. Reports and `improve` refuse invalid quota/credit
+evidence.
+
+`max_turns` and `max_usd` apply to both providers, but they are not equally strict for Codex,
+which has no cap of its own — acumen enforces both against its event stream:
+
+- **`max_turns` bounds the run.** One `codex exec` is a single Codex turn however much work
+  happens inside it, so turns are counted in completed model actions (a message, a command, a
+  file change, a tool or search call) and the agent is stopped at the cap.
+- **`max_usd` cannot.** Codex reports usage once, when the turn ends, so a breach is only
+  visible after the money is spent. The run is recorded as a budget failure — the same outcome
+  Claude gives it — but bound Codex spend with `max_turns`. acumen prints this before the pass.
+
+**Reports compare inferred cost per run.** Every run records its token breakdown — fresh
+input, cache reads, cache writes, and output — and Acumen prices it with the rate table
+stored in `result.json`. That gives Claude and Codex one comparable basis and prevents an old
+benchmark from being silently re-priced. The result itself retains both
+`provider_cost_usd` (when the backend supplies one) and `inferred_cost_usd`; its compatibility
+field `cost_usd` remains provider-first. The report's sidecar CSV calls the former
+`recorded_cost_usd` and keeps it separate from `inferred_cost_usd`, while every displayed cost
+and comparison uses the inferred value.
+
+**Rates are read from the providers' pricing pages, never shipped with the package.** Prices
+move, and each run's cost is frozen into its `result.json` and never recomputed, so a table
+compiled into a release would store numbers that were already wrong. `bench` resolves rates
+before it spends anything and **fails the pass** if the pages cannot be read: cost is a headline
+metric, and a benchmark that cannot establish rates has not earned the numbers it would print.
+`draft`, `improve`, `tasks`, and `ship` fetch too but degrade to unpriced instead — their cost
+line is progress reporting, not stored evidence.
+
+Alongside the rates themselves each run records `price_source` (`config` or `fetched`) and
+`price_rates_as_of`, so a pass run in August and another in October stay individually
+attributable and one report can cover both without restating either. When arms in a report were
+priced on different dates, the report says so: the cost gap between them includes the price
+change, not only the skill's effect.
+
+```bash
+acumen prices              # the rates in use today, and where each came from
+acumen prices --refresh    # check pinned rates against what the providers publish
+```
+
+Pin rates with a `prices:` block in `config.yaml` to price a model the providers don't publish,
+to price a gateway, or to record negotiated rates — pins outrank a live fetch, since only you
+know what you are billed. They are also the only rates that can drift unnoticed, which is what
+`--refresh` checks; it prints a diff for you to accept and never rewrites anything, because
+picking the wrong tier or context band would silently misprice future runs. A model no layer
+prices records its tokens and leaves report cost unavailable — never zero, which would read as
+free.
+
+> One consequence worth knowing: Codex's `max_usd` cap is enforced from these same rates, so an
+> unpriced model under Codex has no enforceable budget cap. Bound those runs with `max_turns`,
+> or pin the rates.
+
 `draft`, `improve`, `tasks`, and `ship` each drive a long autonomous agent. Every run writes a
 live `logs/acumen-<command>-<datetime>.jsonl` (one event per step, flushed as it goes — so you
 can watch progress by reading the file) and a rendered `.html` transcript. Add `--stream` to
@@ -82,6 +172,15 @@ in particular, the [API documentation][].
 You need to have Python 3.12 or newer installed on your system.
 If you don't have Python installed, we recommend installing [uv][].
 
+Install the backend you actually run — both are optional, and either alone is a complete
+install:
+
+| you run | install | also needs |
+|---|---|---|
+| Claude only | `pip install acumen[claude]` | an Anthropic key or a `claude` login |
+| Codex only | `pip install acumen` | the `codex` CLI on `PATH`, plus a Codex login or key |
+| both | `pip install acumen[all]` | both of the above |
+
 <!--
 1) Install the latest release of `acumen` from [PyPI][]:
 
diff --git a/docs/api.md b/docs/api.md
index ab47e72..15f6ca3 100644
--- a/docs/api.md
+++ b/docs/api.md
@@ -81,6 +81,7 @@ so `from acumen import build_report` works.
     :toctree: generated
 
     PlannedRun
+    BenchmarkInvalidError
     build_matrix
     pending
     run_matrix
@@ -133,7 +134,9 @@ conversion.
 
     LiveLog
     locate_transcript
+    render_agent_transcript
     render_transcript
+    render_codex_transcript
 ```
 
 ## Reporting
diff --git a/pyproject.toml b/pyproject.toml
index 04ccb5d..c164f78 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -22,8 +22,6 @@ classifiers = [
   "Programming Language :: Python :: 3.14",
 ]
 dependencies = [
-  "claude-agent-sdk>=0.2.116",
-  "claude-code-log",
   "matplotlib",
   "numpy",
   "pandas",
@@ -33,12 +31,20 @@ dependencies = [
   # for debug logging (referenced from the issue template)
   "session-info2",
 ]
+# Backends are optional and independent: install the ones you actually run. Claude needs a
+# Python SDK (and claude-code-log to render its transcripts); Codex is an external CLI, so it
+# adds no Python dependency at all — `codex` on PATH is the whole requirement.
+optional-dependencies.all = [ "acumen[claude]" ]
+optional-dependencies.claude = [
+  "claude-agent-sdk>=0.2.116",
+  "claude-code-log",
+]
 # https://docs.pypi.org/project_metadata/#project-urls
 urls.Documentation = "https://acumen.readthedocs.io/"
 urls.Homepage = "https://github.com/scverse/acumen"
 urls.Source = "https://github.com/scverse/acumen"
 scripts.acumen = "acumen.cli:main"
-scripts."acumen-install-skills" = "acumen._skills.install:main"
+scripts.acumen-install-skills = "acumen._skills.install:main"
 
 [dependency-groups]
 dev = [
@@ -73,6 +79,9 @@ envs.docs.scripts.build = "sphinx-build -M html docs docs/_build -W {args}"
 envs.docs.scripts.clean = "git clean -fdX -- {args:docs}"
 envs.docs.scripts.open = "python -m webbrowser -t docs/_build/html/index.html"
 envs.docs.dependency-groups = [ "doc" ]
+# The test suite covers both backends, so it installs every optional one. The Codex-only and
+# Claude-only import paths are covered from within the suite, by hiding a backend at import time.
+envs.hatch-test.features = [ "all" ]
 envs.hatch-test.matrix = [
   # Test the lowest and highest supported Python versions with normal deps
   { deps = [ "stable" ], python = [ "3.12", "3.14" ] },
diff --git a/src/acumen/__init__.py b/src/acumen/__init__.py
index 3d88e5c..1c886bf 100644
--- a/src/acumen/__init__.py
+++ b/src/acumen/__init__.py
@@ -1,8 +1,18 @@
-"""Build, benchmark, and optimize Claude skills for Python packages."""
+"""Build, benchmark, and optimize agentic skills for Python packages."""
 
 from importlib.metadata import version
 
-from acumen.bench import PlannedRun, build_matrix, pending, run_matrix, summarize
+from acumen.agents import (
+    AgentError,
+    AgentOptions,
+    AgentProvider,
+    AgentResult,
+    check_agent_cli,
+    claude_sdk_available,
+    provider_for_model,
+    run_agent,
+)
+from acumen.bench import BenchmarkInvalidError, PlannedRun, build_matrix, pending, run_matrix, summarize
 from acumen.config import Config, ConfigError, load_config, parse_config
 from acumen.draft import DraftError, DraftResult, draft_skill
 from acumen.env import (
@@ -10,9 +20,7 @@
     EnvError,
     Target,
     api_auth_available,
-    auth_available,
     build_agent_env,
-    check_auth,
     prepare_target,
     resolve_auth_mode,
     scrubbed_env,
@@ -66,10 +74,20 @@
     make_skill_guard,
 )
 from acumen.tasks import Task, TaskError, TaskSplit, load_tasks, parse_tasks
-from acumen.transcript import locate_transcript, render_transcript
+from acumen.transcript import (
+    locate_transcript,
+    render_agent_transcript,
+    render_codex_transcript,
+    render_transcript,
+)
 
 __all__ = [
     "AuthMode",
+    "AgentError",
+    "AgentOptions",
+    "AgentProvider",
+    "AgentResult",
+    "BenchmarkInvalidError",
     "Config",
     "ConfigError",
     "DraftError",
@@ -104,9 +122,9 @@
     "api_auth_available",
     "arm_metrics",
     "arm_name",
-    "auth_available",
     "available_versions",
-    "check_auth",
+    "check_agent_cli",
+    "claude_sdk_available",
     "build_agent_env",
     "build_filtered_source",
     "build_matrix",
@@ -137,10 +155,14 @@
     "parse_tasks",
     "pending",
     "prepare_target",
+    "provider_for_model",
+    "render_agent_transcript",
+    "render_codex_transcript",
     "render_transcript",
     "resolve_auth_mode",
     "resolve_palette",
     "run_dir",
+    "run_agent",
     "run_matrix",
     "run_once",
     "sandbox",
diff --git a/src/acumen/_skills/data/SKILL.md b/src/acumen/_skills/data/SKILL.md
index 982da29..0a7fbf3 100644
--- a/src/acumen/_skills/data/SKILL.md
+++ b/src/acumen/_skills/data/SKILL.md
@@ -13,7 +13,7 @@ run from the project dir and default to `config.yaml`, `tasks.yaml`, `skills/`,
 ```bash
 acumen init                # scaffold config.yaml + tasks.yaml (placeholders the user must fill)
 acumen tasks               # optional: mine the package for tasks, run them for ground truth
-acumen bench --no-skill    # baseline arm  (this is also the default arm)
+acumen bench --no-skill    # baseline arm  (bare `acumen bench` runs every arm there is)
 acumen draft               # agent reads the package source -> skills/v1/
 acumen bench --skill v1
 acumen improve             # agent reads v1's TRAIN runs -> skills/v2/
@@ -43,7 +43,7 @@ a command.
 | `acumen init` | Both files are placeholders (`repo: OWNER/REPO`, `REPLACE_ME` answers). Ask the user for what only they can supply — the target repo/path, ref, models, budgets — and fill in `config.yaml` with their answers. Do not guess a target or run the next command. |
 | `config.yaml` filled | Offer both ways to get tasks: `acumen tasks` to generate them, or writing `tasks.yaml` by hand. Review generated tasks with the user before benching. |
 | config + tasks ready | `acumen bench --no-skill` and `acumen draft` are **both** correct next steps — they are independent, and you need the baseline arm and a skill arm before any comparison means anything. Offer both. |
-| a skill version exists | `acumen bench --skill vN`. |
+| a skill version exists | `acumen bench --skill vN`, or bare `acumen bench` to cover the baseline and every version at once (resume means only the unbenched cells cost anything). |
 | any `bench` finished | `acumen report` — the per-arm, per-split numbers come from the report; do not judge a version by eyeballing runs or by one arm's pass count. |
 | `report` written | Discuss the results with the user and propose next steps: `improve` + re-bench if it has not beaten the baseline or the previous version, `ship` once a version has proven out, or stop. The user decides. |
 | user has a skill dir from elsewhere | Copy it into `skills/v1/` (next unused version) inside the acumen project — versions are only ever read from `skills/`; there is no import command and no external path flag. |
@@ -70,10 +70,24 @@ a command.
 - The target (`repo`: a GitHub URL or a local path) must be pip-installable and declare
   `[project].name` in `pyproject.toml`. A local `repo` path is resolved **relative to
   `config.yaml`**.
-- Credentials: `bench` **always bills the Anthropic API** and refuses to run without
-  `ANTHROPIC_API_KEY` (or `ANTHROPIC_AUTH_TOKEN` / Bedrock / Vertex) — it records real
-  per-run `cost_usd`, and it has no `--auth` flag. `tasks`/`draft`/`improve`/`ship`
-  default to the Claude subscription if you are logged in (`--auth {auto,session,api}`).
+- Credentials: every agentic command takes `--auth {auto,session,api}` and defaults to the
+  selected provider's logged-in subscription, falling back to its API key. Claude uses
+  `ANTHROPIC_API_KEY` (or Anthropic provider credentials) / a `claude` login; Codex uses
+  `CODEX_API_KEY` or `OPENAI_API_KEY` / a `codex login`. `bench` included: cost comes from
+  token counts, which both billing modes report, so a subscription run prices as accurately
+  as a metered one — but under `session` `cost_usd` is what the run *would* have cost at API
+  rates, not metered spend. Each run records its `auth_mode`.
+  Both backends are optional: `pip install acumen[claude]` for Claude, plain `acumen` plus
+  the `codex` CLI for Codex. A model whose backend is missing fails preflight with the
+  install command.
+- **Codex caps are not equally strict.** `codex exec` has no cap of its own, so acumen
+  enforces both from its event stream. `max_turns` bounds the run (counted in completed
+  model actions, since one `codex exec` is a single Codex turn). `max_usd` cannot: Codex
+  reports usage only when a turn ends, so an over-budget run is recorded as a `budget`
+  failure but the spend already happened — bound Codex with `max_turns`.
+- **`cost_usd` is derived from token counts**, not from the provider — one arithmetic
+  path for both. Rates are frozen into each run; see them with `acumen prices`, re-check
+  them with `acumen prices --refresh`, override or extend via `prices:` in `config.yaml`.
 - The target is cloned + installed into a venv cached under `~/.cache/acumen`, keyed by
   (repo, ref). Use `--refresh-target` after changing the target's own source.
 
@@ -82,10 +96,12 @@ a command.
 1. **Grading is exact string match on `answer.md` after `strip()`, case-sensitive.**
    Nothing is normalized. `**TOKEN**` against `TOKEN` fails (recorded as `format_error`,
    not `wrong_answer`). Task answers must be one short unambiguous token.
-2. **A pass is models × tasks × splits × replicates.** The scaffolded config lists 3
-   models and `n_replicates: 3`, so *one* task costs 18 agent runs *per arm*. Check with
-   `acumen bench --dry-run` (it plans and exits, spending nothing) and agree the size with
-   the user before spending. Trim with `models:`, `n_replicates: 1`, `--task ID`, `--split`.
+2. **A pass is models × tasks × splits × replicates, times the arms it covers.** The
+   scaffolded config lists 6 models and `n_replicates: 3`, so *one* task costs 36 agent runs
+   *per arm* — and bare `acumen bench` runs every arm on disk, so with two skill versions
+   that is 108. Check with `acumen bench --dry-run` (it plans and exits, spending nothing,
+   over the same arms the real run would) and agree the size with the user before spending.
+   Trim with `models:`, `n_replicates: 1`, `--task ID`, `--split`, or by naming one arm.
 3. **`max_turns`/`max_usd` in `config.yaml` cap benchmark agents only.** `draft`,
    `improve`, `tasks`, and `ship` are **unbounded** unless you pass `--max-turns`/`--max-usd`.
 4. **Skill versions are immutable.** `draft` refuses (exit 2) if any `skills/vN` exists;
@@ -101,9 +117,11 @@ a command.
    train/test gap in the report is the overfitting signal you are watching for.
 8. **Task prompts must not name the target package** — the harness already tells the agent
    which package to use and that it is installed.
-9. **Resume is automatic**: a run is "complete" when its `result.json` exists and is
-   non-empty, and completed runs are skipped. `--no-resume` re-runs them. Renaming a task
-   `id` orphans its old runs (the id is a path component).
+9. **Resume is automatic**: a valid run is "complete" when its `result.json` exists and is
+   non-empty, and completed runs are skipped. `--no-resume` re-runs them. Provider usage/credit
+   exhaustion writes a diagnostic `valid: false` result, cancels only that provider's remaining
+   cells while other providers finish, and remains pending; replenish the credential and rerun
+   the same command. Renaming a task `id` orphans its old runs (the id is a path component).
 10. **Confirm the skill actually loaded.** `bench` prints `skill loaded in N/M runs` from
     per-run `skill_loaded` evidence, and warns when a skill arm never fired the Skill tool
     (that arm measures nothing) or when the baseline did.
diff --git a/src/acumen/_skills/data/references/authoring.md b/src/acumen/_skills/data/references/authoring.md
index a9a72fb..9b6c72c 100644
--- a/src/acumen/_skills/data/references/authoring.md
+++ b/src/acumen/_skills/data/references/authoring.md
@@ -84,8 +84,8 @@ report. What makes a version score well:
 ## Watching a long agent run
 
 `tasks`/`draft`/`improve`/`ship` each write `logs/acumen-<command>-<YYYYMMDD-HHMMSS>.jsonl`,
-one compact event per SDK message, **flushed as it goes** — read that file to follow
+one compact event per agent message, **flushed as it goes** — read that file to follow
 progress instead of streaming into your context. Tool results are recorded by status and
 size, not inlined. `--stream` mirrors the conversation to the terminal; `--log-dir` moves
-the logs. A rendered `.html` transcript lands beside the jsonl at the end (skipped, with a
-note, if `claude-code-log` is missing).
+the logs. A rendered `.html` transcript lands beside the jsonl at the end, for either
+provider (a Claude one is skipped, with a note, if `claude-code-log` is missing).
diff --git a/src/acumen/_skills/data/references/benchmark.md b/src/acumen/_skills/data/references/benchmark.md
index 78285a9..48990fb 100644
--- a/src/acumen/_skills/data/references/benchmark.md
+++ b/src/acumen/_skills/data/references/benchmark.md
@@ -6,22 +6,42 @@
 acumen bench [--no-skill | --skill v1] [--split train|test]... [--task ID]...
              [--replicates N] [--max-concurrency N] [--dry-run] [--no-resume]
              [--keep-sandboxes] [--refresh-target]
+             [--auth auto|session|api]
              [--config config.yaml] [--tasks tasks.yaml] [--runs runs] [--skills skills]
              [--cache ~/.cache/acumen]
 ```
 
-- Neither `--no-skill` nor `--skill` → the **baseline** arm (they are mutually exclusive).
-- `--split` and `--task` are repeatable; omitted means all.
+- Neither `--no-skill` nor `--skill` → **every arm the project has**: the baseline plus each
+  version in `skills/`, benched one arm after another against one prepared target. That is
+  the whole comparison in one command, and also the largest thing `bench` can spend, so
+  check it with `--dry-run` first. Name an arm (`--no-skill` / `--skill vN`, mutually
+  exclusive) to run just that one.
+- Arms run sequentially; within an arm, runs go `max_concurrency` at a time. Each arm prints
+  its own tally, then a combined one. Completed runs are skipped per arm as usual, so adding
+  `skills/v3` and rerunning `acumen bench` benches only v3.
+- A version in `skills/` that fails to load stops the pass at planning, before target prep
+  and before any spend, rather than being silently dropped from the comparison.
+- `--split` and `--task` are repeatable; omitted means all. They apply to every arm.
 - `--dry-run` prints the planned matrix and exits **before** target prep and before any
-  agent runs — free, and the right way to check the size of a pass.
+  agent runs — free, and the right way to check the size of a pass. It covers the same arms
+  the real run would, with per-arm counts and a total.
 - `--replicates` / `--max-concurrency` override the config for this pass only.
-- Always bills the API (`ANTHROPIC_API_KEY` etc.); there is no `--auth` here, because the
-  recorded `cost_usd` must be real metered spend.
+- `--auth auto` (default) prefers a stored account/subscription login, then falls back to
+  metered API credentials. Use `--auth session` or `--auth api` to require one explicitly.
+  Each run records the resolved mode; under `session`, `inferred_cost_usd` is the equivalent
+  API-rate cost computed from tokens, not money charged to the subscription.
 - Ctrl-C is safe: completed runs are preserved and the next invocation resumes.
+- Provider account/session usage exhaustion or an API account without credit invalidates the
+  pass rather than counting against the agent. Acumen prints the provider error, cancels the
+  remaining cells for that provider, lets every other provider finish its running and queued
+  cells, exits non-zero, and records the triggering cell as `valid: false` for diagnosis.
+  Reports and `improve` refuse that evidence; after replenishing the credential, rerun the same
+  command and automatic resume retries invalid and cancelled cells.
 
 **Arm parity is the whole point.** Both arms get an identical prompt, tools, caps, and
 environment; the only difference is that a skill arm copies the skill's content files into
-`<sandbox>/.claude/skills/<skill_name>/` where project settings discovery finds it.
+`<sandbox>/.claude/skills/<skill_name>/` for Claude or
+`<sandbox>/.agents/skills/<skill_name>/` for Codex, where project discovery finds it.
 `meta.json` is never copied. Each run gets a fresh empty sandbox with the target venv on
 PATH, a throwaway `HOME` and `CLAUDE_CONFIG_DIR` — no repo source, no user settings, no
 `CLAUDE.md` memories, no visibility of other runs.
@@ -39,14 +59,53 @@ holds five files:
 |---|---|
 | `answer.md` | What the agent wrote — the only thing graded |
 | `script.py` | The agent's reproduction script (absent if it ran no code) |
-| `transcript.jsonl` | SDK-native transcript |
-| `transcript.html` | Rendered transcript (via `claude-code-log`) |
+| `transcript.jsonl` | The provider's own transcript — SDK-native for Claude, the `codex exec` event stream for Codex |
+| `transcript.html` | Rendered transcript, written for both providers |
 | `result.json` | The unit of record — written **last** |
 
 `result.json` presence + non-zero size is what marks a run complete, which is what makes
 resume safe. Useful fields: `success`, `reason`, `answer`, `expected`, `model`, `turns`,
 `cost_usd`, `input_tokens`, `output_tokens`, `duration_s`, `skill_hash`, `skill_name`,
-`skill_loaded`, `pkg_version`, `commit`, `session_id`, `subtype`, `error`.
+`skill_loaded`, `pkg_version`, `commit`, `session_id`, `subtype`, `valid`, `error`.
+
+**`cost_usd` prefers the provider's value and falls back to token inference.** Each run records
+`provider_cost_usd`, `inferred_cost_usd`, `cost_source`, and the absolute/relative delta when
+both exist. Claude's SDK total is API-equivalent (not necessarily an invoice charge under
+session authentication); Codex reports no dollars, so it uses inference. Token classes and the
+rates frozen into `price_rates` remain available for reproduction, including Claude's separate
+five-minute and one-hour cache writes plus the legacy aggregate. A model with neither provider
+cost nor rates leaves `cost_available` false and `cost_usd` null. A run without rates leaves
+`inferred_cost_usd` null even when the provider supplied a value, so reports cannot mistake it
+for a free or cross-provider-comparable run.
+
+**No rates ship with the package.** They are read from the providers' pricing pages, because a
+compiled-in table is wrong from whatever date prices next move, and each run's cost is frozen
+when written rather than corrected later. `bench` resolves rates before it spends anything and
+exits 2 if the pages cannot be read. Each run records `price_source` (`config` or `fetched`) and
+`price_rates_as_of` next to the rates themselves, so passes months apart stay individually
+attributable and one report can mix them; the report flags arms priced on different dates, whose
+cost gap includes the price change rather than only the skill's effect.
+
+`draft`, `improve`, `tasks`, and `ship` also fetch, but degrade to unpriced rather than failing:
+their cost line is progress reporting. Note that Codex's `max_usd` is derived from these rates,
+so an unpriced Codex run has no enforceable budget cap — bound it with `max_turns`.
+
+Inspect today's rates with `acumen prices`. Set `prices:` in `config.yaml` to price a model the
+providers don't publish or to pin negotiated rates, which outrank a fetch; `acumen prices
+--refresh` reports pins that have drifted from the published price.
+
+Reports deliberately use `inferred_cost_usd` for every cost-per-run value and comparison, so
+Claude and Codex stay on the same pricing basis even when Claude supplies an SDK estimate. The
+sidecar CSV preserves the two values separately as `recorded_cost_usd` and
+`inferred_cost_usd`; `cost_usd` remains present as the provider-first compatibility field.
+
+`codex exec` has no cap of its own, so acumen enforces both from its event stream, at
+different resolutions. `max_turns` really does stop the run — counted in completed model
+actions (message, command, file change, tool/search call), because one `codex exec` is a
+single Codex turn however much work happens inside it. `max_usd` only marks the outcome:
+Codex reports usage once, when the turn ends, so the breach is visible after the spend, not
+before. The run is recorded `budget` either way; the CLI warns before the pass. A turn-capped
+Codex run is stopped mid-turn and so records no usage — a failure with zero tokens.
 
 ## Reasons
 
@@ -58,6 +117,7 @@ resume safe. Useful fields: `success`, `reason`, `answer`, `expected`, `model`,
 | `no_answer_file` | The agent never wrote `answer.md` |
 | `budget` / `max_turns` | Cap breached — a **failure regardless** of what `answer.md` contains |
 | `error` | The agent crashed or produced no result |
+| `provider_exhausted` | Provider usage/credit ran out; infrastructure-invalid, never agent evidence |
 
 A run of `format_error`s means the harness's answer-format instruction is losing to the
 task prompt; a run of `no_answer_file` usually means the task is too big for `max_turns`.
diff --git a/src/acumen/_skills/data/references/python-api.md b/src/acumen/_skills/data/references/python-api.md
index 0a4cb5e..4f58cda 100644
--- a/src/acumen/_skills/data/references/python-api.md
+++ b/src/acumen/_skills/data/references/python-api.md
@@ -11,8 +11,8 @@ stderr — call the functions directly if you want the exceptions.
 from pathlib import Path
 from acumen import load_config, load_tasks, parse_config, parse_tasks
 
-cfg = load_config(Path("config.yaml"))    # validates; resolves a local repo relative to the file
-tasks = load_tasks(Path("tasks.yaml"))    # list[Task]; task.split("train") -> TaskSplit(prompt, answer)
+cfg = load_config(Path("config.yaml"))  # validates; resolves a local repo relative to the file
+tasks = load_tasks(Path("tasks.yaml"))  # list[Task]; task.split("train") -> TaskSplit(prompt, answer)
 ```
 
 `Config` is a frozen dataclass — override with `dataclasses.replace(cfg, n_replicates=1)`.
@@ -25,9 +25,9 @@ from acumen import prepare_target
 from acumen.env import DEFAULT_CACHE_ROOT
 
 target = prepare_target(cfg, DEFAULT_CACHE_ROOT, refresh=False)
-target.python      # venv interpreter with the package installed
-target.bin_dir     # what goes on an agent's PATH
-target.fingerprint # "<pkg> <version>", as recorded in result.json
+target.python  # venv interpreter with the package installed
+target.bin_dir  # what goes on an agent's PATH
+target.fingerprint  # "<pkg> <version>", as recorded in result.json
 ```
 
 Needs `uv` on PATH. Cached by (repo, ref) under `~/.cache/acumen`.
@@ -38,16 +38,23 @@ Needs `uv` on PATH. Cached by (repo, ref) under `~/.cache/acumen`.
 import asyncio
 from acumen import build_matrix, pending, run_matrix, load_skill, summarize
 
-skill = load_skill(Path("skills"), "v1", expect_name=cfg.skill_name)   # None for the baseline
+skill = load_skill(Path("skills"), "v1", expect_name=cfg.skill_name)  # None for the baseline
 planned = build_matrix(cfg, tasks, skill="v1", splits=("train",), task_ids=["t1"])
 todo = pending(planned, Path("runs"), resume=True)
-outcomes = asyncio.run(run_matrix(
-    todo, target=target, runs_root=Path("runs"),
-    max_concurrency=cfg.max_concurrency, auth_mode="api", skill=skill,
-    on_start=lambda p: None, on_done=lambda o: None,
-    env_passthrough=cfg.env_passthrough,
-))
-summarize(outcomes)   # {"ok": 5, "wrong_answer": 1, ...}
+outcomes = asyncio.run(
+    run_matrix(
+        todo,
+        target=target,
+        runs_root=Path("runs"),
+        max_concurrency=cfg.max_concurrency,
+        auth_mode="api",
+        skill=skill,
+        on_start=lambda p: None,
+        on_done=lambda o: None,
+        env_passthrough=cfg.env_passthrough,
+    )
+)
+summarize(outcomes)  # {"ok": 5, "wrong_answer": 1, ...}
 ```
 
 `run_matrix` and `run_once` are coroutines. `run_once` records agent crashes as failed runs
@@ -61,10 +68,9 @@ rather than raising, so one bad run never kills a pass. `run_once` raises `Value
 ```python
 from acumen import grade_answer, grade_run, run_dir, parse_run_dir, is_complete, RunKey, arm_name
 
-grade_answer("**SPI1**", "SPI1")   # Grade(success=False, reason='format_error', answer='**SPI1**')
-run_dir(Path("runs"), RunKey(arm=arm_name("v1"), split="test", model="claude-opus-5",
-                            task_id="t1", rep=1))
-is_complete(d)                     # a non-empty result.json is what "done" means
+grade_answer("**SPI1**", "SPI1")  # Grade(success=False, reason='format_error', answer='**SPI1**')
+run_dir(Path("runs"), RunKey(arm=arm_name("v1"), split="test", model="claude-opus-5", task_id="t1", rep=1))
+is_complete(d)  # a non-empty result.json is what "done" means
 ```
 
 ## The meta-agents
@@ -77,10 +83,10 @@ Pass a `LiveLog` as `log=` for the JSONL feed:
 
 ```python
 from acumen import LiveLog, draft_skill
+
 log = LiveLog.open(Path("logs"), "draft", stream=False)
 with log:
-    result = asyncio.run(draft_skill(cfg=cfg, target=target, skills_root=Path("skills"),
-                                     auth_mode="session", log=log))
+    result = asyncio.run(draft_skill(cfg=cfg, target=target, skills_root=Path("skills"), auth_mode="session", log=log))
 ```
 
 ## Aggregating results
@@ -88,10 +94,10 @@ with log:
 ```python
 from acumen import load_results, arm_metrics, build_report
 
-df = load_results(Path("runs"))            # one row per result.json, + total_tokens, arm_label
-arm_metrics(df[df["split"] == "test"])     # per-arm rate, stderr, tokens, cost, time, n
+df = load_results(Path("runs"))  # one row per result.json, + total_tokens, arm_label
+arm_metrics(df[df["split"] == "test"])  # per-arm rate, stderr, tokens, cost, time, n
 report = build_report(Path("runs"), Path("report.html"), tasks, skills_root=Path("skills"))
-report.n_runs, report.results              # the DataFrame behind the HTML
+report.n_runs, report.results  # the DataFrame behind the HTML
 ```
 
 `build_report` writes `report.html` **and `report.csv`** (same stem) and returns `Report`.
diff --git a/src/acumen/_skills/data/references/setup.md b/src/acumen/_skills/data/references/setup.md
index 7c77f23..67f9eb8 100644
--- a/src/acumen/_skills/data/references/setup.md
+++ b/src/acumen/_skills/data/references/setup.md
@@ -16,19 +16,34 @@ Only `repo` is required; delete a line to take its default.
 |---|---|---|
 | `repo` | — | GitHub URL (`https://`, `git@`, `ssh://`, `git://`) or a local path. A local path is resolved relative to `config.yaml` and must exist. |
 | `ref` | `main` | Branch/tag/commit; ignored for local paths. |
-| `extras` | `[]` | pip extras installed with the target, e.g. `[test]`. |
+| `extras` | `[]` | Extras the target publishes in `[project.optional-dependencies]`, e.g. `[test]`. |
+| `dependency_groups` | `[]` | PEP 735 groups from the target's `[dependency-groups]`, e.g. `[full]`. |
+| `pip_packages` | `[]` | Packages the target declares nowhere, installed alongside it. PEP 508 specifiers allowed (`numpy<2`). |
 | `python` | `"3.12"` | Interpreter for the target's venv (quote it — `3.10` unquoted is a float). |
 | `env_passthrough` | `[]` | Extra env var names agents may keep. The agent env is a clean allowlist (auth/proxy/TLS only); **everything else from your shell is blanked**. A target needing `OMP_NUM_THREADS`, `R_HOME`, a service key, etc. must name it here. |
-| `models` | `[claude-opus-5]` | Benchmark models. Duplicates rejected. `models[0]` is the default for the four `*_model` keys below. |
+| `models` | `[claude-opus-5]` | Benchmark models. Claude (`claude*`) and Codex (`gpt-*`, `o1`/`o3`/`o4`, `codex-*`) models may be mixed. Duplicates rejected. `models[0]` is the default for the four `*_model` keys below. |
 | `n_replicates` | `3` | Runs per (model, task, split) cell. |
 | `max_concurrency` | `4` | Simultaneous benchmark agents. |
 | `max_turns` | `40` | **Benchmark agents only.** |
 | `max_usd` | `3.0` | **Benchmark agents only.** |
 | `draft_model` / `improve_model` / `tasks_model` / `ship_model` | `models[0]` | Meta-agent models; overridable per command with `--model`. |
 | `skill_name` | repo basename, slugified + lowercased | Must equal the `name:` in the skill's frontmatter. |
+| `prices` | built-in table | Per-model token rates (USD per million): `{model: {input, output, cached_input?, cache_write?, cache_write_5m?, cache_write_1h?}}`. Overrides or extends acumen's table — needed for a model it doesn't ship a rate for, a gateway, or negotiated rates. See `acumen prices`. |
 
-The scaffold's `models:` line lists three models — with `n_replicates: 3` that is 18 runs
-per task per arm. Cut it down before the first real pass.
+**`extras` vs `dependency_groups` — pick the wrong one and the packages are missing.** Extras
+are published in package metadata, so they are what `pip install pkg[name]` resolves. PEP 735
+groups live only in the source tree and are invisible to anyone installing from PyPI. Rule of
+thumb: if `pip install <target>[name]` from PyPI would not work, `name` is a group. Check the
+target's `pyproject.toml` rather than guessing — many scverse packages declare **no** extras
+and put their optional stack in a `full` group. Asking for the wrong kind is now a hard error
+naming the right key, but only after the checkout, so read the file first.
+
+Changing `extras`, `dependency_groups` or `pip_packages` changes the cache key, so the venv
+rebuilds on the next command — no `--refresh-target` needed.
+
+The scaffold's `models:` line lists three Claude and three Codex models. With
+`n_replicates: 3`, one task expands to 36 runs per arm, so cut the matrix down before
+the first real pass.
 
 ## tasks.yaml
 
@@ -86,7 +101,7 @@ sizeable file. Unbounded in turns and cost by default.
 - **There is no append mode.** The generator never reads your existing tasks file, so
   appending would silently duplicate. To combine, generate to a separate path and merge by
   hand.
-- Existing skills and agent-instruction files (`SKILL.md`, `.claude/`, `CLAUDE.md`,
+- Existing skills and agent-instruction files (`SKILL.md`, `.agents/`, `.claude/`, `.codex/`, `CLAUDE.md`,
   `AGENTS.md`, `.cursor/`, root `skills/`) are stripped from the source copy it reads and
   blocked by a hook, so pre-written guidance cannot bias which tasks it picks.
 - The output is validated through the strict tasks loader before it is written — it can
diff --git a/src/acumen/_skills/install.py b/src/acumen/_skills/install.py
index 1847ea3..1ea990a 100644
--- a/src/acumen/_skills/install.py
+++ b/src/acumen/_skills/install.py
@@ -59,16 +59,10 @@ def _claude_science_skills_dir() -> Path:
         active_org = json.loads(active_org_path.read_text(encoding="utf-8"))
     except (OSError, json.JSONDecodeError) as error:
         raise ValueError(
-            "cannot resolve the Claude Science active organization from "
-            f"{active_org_path}; pass --dest instead"
+            f"cannot resolve the Claude Science active organization from {active_org_path}; pass --dest instead"
         ) from error
     org_uuid = active_org.get("org_uuid") if isinstance(active_org, dict) else None
-    if (
-        not isinstance(org_uuid, str)
-        or not org_uuid
-        or Path(org_uuid).name != org_uuid
-        or org_uuid in {".", ".."}
-    ):
+    if not isinstance(org_uuid, str) or not org_uuid or Path(org_uuid).name != org_uuid or org_uuid in {".", ".."}:
         raise ValueError(f"invalid Claude Science org_uuid in {active_org_path}; pass --dest instead")
     return root / "orgs" / org_uuid / "skills"
 
@@ -96,11 +90,7 @@ def resolve_dest(agent: str | None, dest: Path | None) -> Path:
 
 def _snapshot(root: Path) -> dict[str, bytes]:
     """Map each file under ``root`` to its bytes, for exact tree comparison."""
-    return {
-        str(item.relative_to(root)): item.read_bytes()
-        for item in root.rglob("*")
-        if item.is_file()
-    }
+    return {str(item.relative_to(root)): item.read_bytes() for item in root.rglob("*") if item.is_file()}
 
 
 def _matches(source: Path, target: Path) -> bool:
diff --git a/src/acumen/agents.py b/src/acumen/agents.py
new file mode 100644
index 0000000..07f5a96
--- /dev/null
+++ b/src/acumen/agents.py
@@ -0,0 +1,708 @@
+"""Provider-neutral agent execution for Claude Code and Codex.
+
+The rest of acumen deals in one small result shape. Claude is driven through its
+Python SDK; Codex is driven through its documented non-interactive JSONL interface.
+Keeping both adapters here prevents provider-specific message types and subprocess
+details from leaking into the benchmark and meta-agent workflows.
+
+Neither backend is required to use acumen. The Claude SDK is an optional dependency
+(``pip install acumen[claude]``) and Codex is an external CLI, so a Claude-only and a
+Codex-only install are both complete. Every import of a backend is therefore made inside
+the function that needs it, and :func:`check_agent_cli` turns a missing one into an
+actionable error before a command does any expensive work.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import importlib.util
+import json
+import shlex
+import shutil
+import sys
+import time
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass, field, replace
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Literal
+
+if TYPE_CHECKING:
+    from claude_agent_sdk import ClaudeAgentOptions, ResultMessage
+
+AgentProvider = Literal["claude", "codex"]
+
+_PRIVATE_NETWORK_HOSTS = (
+    "localhost",
+    "*.localhost",
+    "127.*",
+    "0.0.0.0",
+    "10.*",
+    "169.254.*",
+    "192.168.*",
+    *(f"172.{second}.*" for second in range(16, 32)),
+    "::1",
+    "metadata.google.internal",
+)
+
+
+class AgentError(RuntimeError):
+    """Raised when an agent model or provider cannot be resolved."""
+
+
+def provider_for_model(model: str) -> AgentProvider:
+    """Infer the agent provider from a model ID.
+
+    Anthropic model IDs begin with ``claude``. OpenAI's coding-capable IDs use
+    ``gpt-*``, ``o*``, or ``codex-*``. Provider-qualified IDs are accepted too,
+    which keeps proxy/router configurations readable.
+    """
+    value = model.strip().lower()
+    tail = value.rsplit("/", 1)[-1]
+    if tail.startswith("claude"):
+        return "claude"
+    if tail.startswith(("gpt-", "o1", "o3", "o4", "codex-")):
+        return "codex"
+    raise AgentError(
+        f"cannot infer an agent for model {model!r}; use a Claude model ID beginning "
+        "with 'claude' or an OpenAI model ID beginning with 'gpt-', 'o1', 'o3', "
+        "'o4', or 'codex-'"
+    )
+
+
+def claude_sdk_available() -> bool:
+    """Whether the optional Claude Agent SDK is installed."""
+    return importlib.util.find_spec("claude_agent_sdk") is not None
+
+
+def check_agent_cli(provider: AgentProvider) -> None:
+    """Fail before target preparation when the selected backend is not installed.
+
+    Each backend is optional and they are checked the same way: acumen refuses to prepare a
+    target, build a sandbox, or spend a token for a provider it cannot actually drive.
+    """
+    if provider == "codex" and shutil.which("codex") is None:
+        raise AgentError("codex is not on PATH — install Codex CLI before running an OpenAI model")
+    if provider == "claude" and not claude_sdk_available():
+        raise AgentError(
+            "the Claude Agent SDK is not installed — run `pip install acumen[claude]` before "
+            "running a Claude model, or select a Codex model"
+        )
+
+
+@dataclass(frozen=True)
+class AgentResult:
+    """The provider-neutral terminal result of one autonomous agent run."""
+
+    provider: AgentProvider
+    is_error: bool
+    subtype: str
+    errors: list[str] | None
+    session_id: str | None
+    result: str
+    num_turns: int
+    total_cost_usd: float | None
+    duration_ms: int
+    usage: dict[str, int]
+    stop_reason: str | None = None
+    transcript: list[dict[str, Any]] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class AgentOptions:
+    """Provider-neutral options shared by benchmark and meta-agent runs."""
+
+    cwd: Path
+    env: dict[str, str]
+    model: str
+    max_turns: int | None = None
+    max_usd: float | None = None
+    read_dirs: tuple[Path, ...] = ()
+    write_dirs: tuple[Path, ...] = ()
+    discover_skills: bool = True
+    claude_hooks: dict[str, Any] | None = None
+    deny_paths: tuple[Path, ...] = ()
+    stderr: Callable[[str], None] | None = None
+    #: Prices one provider usage block in USD. Claude enforces ``max_usd`` itself against the
+    #: figure it bills; Codex reports tokens and no dollar amount, so enforcing a budget there
+    #: means pricing its usage ourselves — pass the caller's rate table in as this hook.
+    #: Without it ``max_usd`` cannot be enforced for a Codex run.
+    price_usd: Callable[[dict[str, Any]], float | None] | None = None
+
+
+def _dedupe_paths(paths: Sequence[Path]) -> list[Path]:
+    result: list[Path] = []
+    for path in paths:
+        resolved = path.expanduser().resolve()
+        if resolved.exists() and resolved not in result:
+            result.append(resolved)
+    return result
+
+
+def _runtime_read_dirs() -> list[Path]:
+    """Host paths required to start ordinary Python and shell subprocesses."""
+    candidates = [
+        Path(sys.base_prefix),
+        Path(sys.prefix),
+        Path(sys.executable).resolve().parent,
+        Path("/bin"),
+        Path("/usr"),
+        Path("/lib"),
+        Path("/lib64"),
+        Path("/etc/ssl"),
+        Path("/etc/hosts"),
+        Path("/etc/resolv.conf"),
+        Path("/System"),
+        Path("/Library"),
+    ]
+    return _dedupe_paths(candidates)
+
+
+def _access_roots(options: AgentOptions) -> tuple[list[Path], list[Path]]:
+    env_paths = [
+        Path(value)
+        for key in ("HOME", "TMPDIR", "XDG_CACHE_HOME", "XDG_CONFIG_HOME", "CLAUDE_CONFIG_DIR", "CODEX_HOME")
+        if (value := options.env.get(key))
+    ]
+    writes = _dedupe_paths([options.cwd, *options.write_dirs, *env_paths])
+    reads = _dedupe_paths([*_runtime_read_dirs(), *options.read_dirs, *writes])
+    return reads, writes
+
+
+def _claude_path_rule(tool: str, path: Path) -> str:
+    return f"{tool}(//{str(path).lstrip('/')}/**)"
+
+
+def _claude_settings(options: AgentOptions) -> dict[str, Any]:
+    """Build strict run-local Claude settings for unattended execution."""
+    reads, writes = _access_roots(options)
+    return {
+        "permissions": {
+            "allow": [
+                "Bash",
+                "WebFetch",
+                "WebSearch",
+                "Skill",
+                *(_claude_path_rule("Read", path) for path in reads),
+                *(_claude_path_rule("Edit", path) for path in writes),
+            ],
+            "deny": [f"WebFetch(domain:{host})" for host in _PRIVATE_NETWORK_HOSTS],
+        },
+        "sandbox": {
+            "enabled": True,
+            "failIfUnavailable": True,
+            "autoAllowBashIfSandboxed": True,
+            "allowUnsandboxedCommands": False,
+            "excludedCommands": [],
+            "filesystem": {
+                "denyRead": ["/"],
+                "allowRead": [str(path) for path in reads],
+                "denyWrite": ["/"],
+                "allowWrite": [str(path) for path in writes],
+            },
+            "network": {
+                "allowedDomains": ["*"],
+                "deniedDomains": list(_PRIVATE_NETWORK_HOSTS),
+                "strictAllowlist": True,
+                "allowLocalBinding": False,
+                "allowAllUnixSockets": False,
+            },
+        },
+    }
+
+
+def _claude_options(options: AgentOptions) -> ClaudeAgentOptions:
+    from claude_agent_sdk import ClaudeAgentOptions
+
+    config_dir_value = options.env.get("CLAUDE_CONFIG_DIR")
+    if not config_dir_value:
+        raise AgentError("Claude sandboxing requires a run-local CLAUDE_CONFIG_DIR")
+    settings_path = Path(config_dir_value) / "acumen-settings.json"
+    settings_path.parent.mkdir(parents=True, exist_ok=True)
+    settings_path.write_text(json.dumps(_claude_settings(options)), encoding="utf-8")
+
+    return ClaudeAgentOptions(
+        cwd=str(options.cwd),
+        env=options.env,
+        model=options.model,
+        max_turns=options.max_turns,
+        max_budget_usd=options.max_usd,
+        add_dirs=[],
+        setting_sources=["project"] if options.discover_skills else [],
+        permission_mode="dontAsk",
+        # The SDK's ``settings`` field is a path passed to Claude Code's
+        # ``--settings`` flag, not an in-memory settings object.  Keeping this
+        # file in the isolated config directory also prevents user settings
+        # from being inherited by the run.
+        settings=str(settings_path),
+        system_prompt={"type": "preset", "preset": "claude_code"},
+        hooks=options.claude_hooks,
+        stderr=options.stderr,
+    )
+
+
+def _from_claude(result: ResultMessage) -> AgentResult:
+    return AgentResult(
+        provider="claude",
+        is_error=bool(result.is_error),
+        subtype=result.subtype or "",
+        errors=result.errors,
+        session_id=result.session_id,
+        result=result.result or "",
+        num_turns=result.num_turns,
+        total_cost_usd=result.total_cost_usd,
+        duration_ms=result.duration_ms or 0,
+        usage=dict(result.usage or {}),
+        stop_reason=result.stop_reason,
+    )
+
+
+async def _run_claude(
+    prompt: str,
+    options: AgentOptions,
+    on_event: Callable[[Any], None] | None,
+) -> AgentResult:
+    from claude_agent_sdk import ResultMessage, query
+
+    result: ResultMessage | None = None
+    noise: list[str] = []
+
+    def capture_stderr(line: str) -> None:
+        noise.append(line)
+        if options.stderr is not None:
+            options.stderr(line)
+        else:
+            print(line, file=sys.stderr, flush=True)
+
+    try:
+        async for message in query(prompt=prompt, options=_claude_options(replace(options, stderr=capture_stderr))):
+            if on_event is not None:
+                on_event(message)
+            if isinstance(message, ResultMessage):
+                result = message
+    except Exception as err:
+        # SDK connection/process exceptions can be generic while the actionable quota or
+        # billing message was emitted only on stderr. Preserve it so the benchmark runner can
+        # classify infrastructure exhaustion instead of blaming the agent.
+        detail = "\n".join(line.strip() for line in noise if line.strip())
+        if detail:
+            raise AgentError(f"{err}\nClaude stderr:\n{detail}") from err
+        raise
+    if result is None:
+        raise AgentError("the Claude agent produced no result message")
+    return _from_claude(result)
+
+
+def _codex_command(options: AgentOptions, prompt: str) -> list[str]:
+    cli = shutil.which("codex", path=options.env.get("PATH"))
+    if cli is None:
+        raise AgentError("codex is not on PATH — install Codex CLI before running an OpenAI model")
+    command = [
+        cli,
+        "exec",
+        "--json",
+        "--ephemeral",
+        "--ignore-user-config",
+        "--ignore-rules",
+        "--strict-config",
+        "--skip-git-repo-check",
+        "--color",
+        "never",
+        "-c",
+        "project_doc_max_bytes=0",
+        "-c",
+        "project_doc_fallback_filenames=[]",
+        # Built-in web/browser/app surfaces do not run under local permission
+        # profiles. Disable them so every network request made by an isolated
+        # run goes through the profile-controlled command proxy.
+        "-c",
+        'web_search="disabled"',
+        "-c",
+        "tools.web_search=false",
+        "-c",
+        "features.browser_use=false",
+        "-c",
+        "features.browser_use_external=false",
+        "-c",
+        "features.browser_use_full_cdp_access=false",
+        "-c",
+        "features.apps=false",
+        "-c",
+        "features.remote_plugin=false",
+        "-c",
+        "features.network_proxy=true",
+        "-c",
+        'approval_policy="never"',
+        "--cd",
+        str(options.cwd),
+        "--model",
+        options.model,
+    ]
+    if options.deny_paths:
+        command.append("--dangerously-bypass-hook-trust")
+    reads, writes = _access_roots(options)
+    # The Linux command sandbox re-executes the Codex binary through bubblewrap.
+    # Its resolved standalone install is outside the usual /usr runtime roots,
+    # so make the containing directory visible without exposing user config.
+    reads = [*reads, Path(cli).resolve().parent]
+    # Keep lexical system aliases as well as their resolved targets.  Landlock
+    # evaluates the command path it is given, so allowing /usr/bin does not make
+    # an invocation through the /bin -> /usr/bin symlink readable.
+    reads.extend(path for path in (Path("/bin"), Path("/lib"), Path("/lib64")) if path.exists())
+    reads = list(dict.fromkeys(reads))
+    command.extend(("-c", 'default_permissions="acumen"'))
+    filesystem = {":root": "deny", ":minimal": "read"}
+    for path in reads:
+        filesystem[str(path)] = "read"
+    for path in writes:
+        filesystem[str(path)] = "write"
+    # One inline TOML table keeps paths opaque. Passing each path as a dotted
+    # ``-c`` key misparses versioned and hidden directories (for example
+    # ``0.146.0/...`` or ``.venv``) as nested configuration keys.
+    filesystem_toml = ",".join(f"{json.dumps(path)}={json.dumps(access)}" for path, access in filesystem.items())
+    command.extend(("-c", f"permissions.acumen.filesystem={{{filesystem_toml}}}"))
+    command.extend(("-c", "permissions.acumen.network.enabled=true"))
+    command.extend(("-c", 'permissions.acumen.network.mode="limited"'))
+    domains = {
+        "*": "allow",
+        "localhost": "deny",
+        "*.localhost": "deny",
+        "127.0.0.1": "deny",
+        "0.0.0.0": "deny",
+        "::1": "deny",
+        "metadata.google.internal": "deny",
+    }
+    domains_toml = ",".join(f"{json.dumps(host)}={json.dumps(access)}" for host, access in domains.items())
+    command.extend(("-c", f"permissions.acumen.network.domains={{{domains_toml}}}"))
+    command.extend(("-c", "permissions.acumen.network.allow_local_binding=false"))
+    command.append(prompt)
+    return command
+
+
+def _codex_guard_source(denied: Sequence[Path]) -> str:
+    """Return a standalone Codex PreToolUse guard for absolute denied roots."""
+    roots = repr([str(path.resolve()) for path in denied])
+    return f"""\
+import json
+import shlex
+import sys
+from pathlib import Path
+
+ROOTS = [Path(value) for value in {roots}]
+
+
+def blocked(value, cwd):
+    if not isinstance(value, str) or not value.strip():
+        return None
+    candidates = [value]
+    expanded = value.translate(str.maketrans({{char: " " for char in "|&;()<>`\\n\\r\\t"}}))
+    try:
+        candidates.extend(shlex.split(expanded))
+    except ValueError:
+        candidates.extend(expanded.split())
+    for raw in candidates:
+        raw = raw.strip(" ,;()[]{{}}'\\\"")
+        if not raw:
+            continue
+        try:
+            path = Path(raw).expanduser()
+            resolved = (path if path.is_absolute() else cwd / path).resolve()
+        except (OSError, RuntimeError, ValueError):
+            continue
+        for root in ROOTS:
+            try:
+                resolved.relative_to(root)
+            except ValueError:
+                continue
+            return raw
+    return None
+
+
+def strings(value):
+    if isinstance(value, str):
+        yield value
+    elif isinstance(value, dict):
+        for item in value.values():
+            yield from strings(item)
+    elif isinstance(value, list):
+        for item in value:
+            yield from strings(item)
+
+
+payload = json.load(sys.stdin)
+cwd = Path(payload.get("cwd") or ".").resolve()
+for value in strings(payload.get("tool_input") or {{}}):
+    hit = blocked(value, cwd)
+    if hit is not None:
+        print(json.dumps({{
+            "hookSpecificOutput": {{
+                "hookEventName": "PreToolUse",
+                "permissionDecision": "deny",
+                "permissionDecisionReason": "acumen blocks access to isolated benchmark data: " + hit,
+            }}
+        }}))
+        raise SystemExit(0)
+"""
+
+
+def _install_codex_guard(options: AgentOptions) -> None:
+    """Install a trusted, run-local Codex guard when isolation needs a deny boundary."""
+    if not options.deny_paths:
+        return
+    codex_home = Path(options.env["CODEX_HOME"])
+    script = codex_home / "acumen_guard.py"
+    script.parent.mkdir(parents=True, exist_ok=True)
+    script.write_text(_codex_guard_source(options.deny_paths))
+    hooks_dir = options.cwd / ".codex"
+    hooks_dir.mkdir(parents=True, exist_ok=True)
+    hooks = {
+        "description": "acumen run isolation",
+        "hooks": {
+            "PreToolUse": [
+                {
+                    "matcher": "*",
+                    "hooks": [
+                        {
+                            "type": "command",
+                            "command": f"{shlex.quote(sys.executable)} {shlex.quote(str(script))}",
+                            "timeout": 10,
+                        }
+                    ],
+                }
+            ]
+        },
+    }
+    (hooks_dir / "hooks.json").write_text(json.dumps(hooks, indent=2) + "\n")
+
+
+#: Item types that count as one model action. ``codex exec`` runs the whole prompt as a single
+#: turn — one ``turn.started``/``turn.completed`` pair however much work happens inside it — so
+#: counting turns would record 1 for every run. A completed item is the closest analogue to a
+#: Claude turn, and it is the unit :attr:`AgentOptions.max_turns` is enforced in. ``reasoning``
+#: and ``todo_list`` items are the model's own narration and bookkeeping, not actions, so they
+#: do not count.
+_TURN_ITEM_TYPES = frozenset({"agent_message", "command_execution", "file_change", "mcp_tool_call", "web_search"})
+
+#: Terminal subtypes for a cap acumen enforced itself. They deliberately reuse the strings the
+#: Claude CLI reports for its own caps, so a breach maps onto the same reason for both providers.
+_MAX_TURNS_SUBTYPE = "error_max_turns"
+_MAX_BUDGET_SUBTYPE = "error_max_budget_usd"
+
+#: Subtype for a run whose *sandbox* failed, as distinct from a run that failed the task.
+_SANDBOX_SUBTYPE = "error_sandbox"
+
+#: Stderr fragments that mean Codex's own sandbox could not carry out the agent's file writes.
+#: On a host where unprivileged user namespaces are restricted — Ubuntu 24.04's AppArmor
+#: default, a container without the capability — bubblewrap cannot start, and every write the
+#: agent attempts fails. The agent still does the whole task and still spends the tokens; it
+#: just cannot save the answer, which would otherwise be graded ``no_answer_file`` and read as
+#: the model failing. It is the harness that failed, so the run is recorded as an error and
+#: leaves the comparison rather than being counted against the model.
+_SANDBOX_FAILURES = (
+    "fs sandbox helper failed",
+    "bwrap:",
+    "failed to write file",
+    "sandbox helper",
+    "sandbox setup failed",
+    "failed to apply sandbox",
+    "landlock",
+    "unprivileged user namespace",
+)
+
+
+def _sandbox_failure(lines: Sequence[str]) -> str | None:
+    """Return the first stderr line showing a sandbox failure, or ``None``."""
+    for line in lines:
+        lowered = line.lower()
+        if any(marker in lowered for marker in _SANDBOX_FAILURES):
+            return line.strip()
+    return None
+
+
+def _is_turn_item(event: dict[str, Any]) -> bool:
+    """Whether ``event`` is one completed model action — the unit Codex turns are counted in."""
+    if event.get("type") != "item.completed":
+        return False
+    item = event.get("item")
+    return isinstance(item, dict) and item.get("type") in _TURN_ITEM_TYPES
+
+
+def _codex_terminal(
+    events: Sequence[dict[str, Any]],
+    returncode: int,
+    duration_ms: int,
+    capped: str | None = None,
+    sandbox_failure: str | None = None,
+    stderr_lines: Sequence[str] = (),
+) -> AgentResult:
+    session_id: str | None = None
+    final = ""
+    usage: dict[str, int] = {}
+    errors: list[str] = []
+    subtype = "success"
+    turns = 0
+    for event in events:
+        kind = event.get("type")
+        if _is_turn_item(event):
+            turns += 1
+        if kind == "thread.started":
+            value = event.get("thread_id")
+            session_id = str(value) if value else None
+        elif kind == "item.completed":
+            item = event.get("item")
+            if isinstance(item, dict) and item.get("type") == "agent_message":
+                text = item.get("text")
+                if isinstance(text, str):
+                    final = text
+        elif kind == "turn.completed":
+            raw = event.get("usage")
+            if isinstance(raw, dict):
+                usage = {str(key): int(value or 0) for key, value in raw.items() if isinstance(value, int | float)}
+        elif kind in {"error", "turn.failed"}:
+            subtype = str(event.get("type"))
+            detail = event.get("message") or event.get("error")
+            errors.append(str(detail or event))
+
+    if sandbox_failure is not None:
+        # Checked before the cap and before the exit status: when the sandbox cannot carry out
+        # the agent's writes, nothing downstream of it means anything. The run did the work and
+        # spent the tokens, so the usage is kept, but the outcome is the harness's failure and
+        # is recorded as such — never as the model declining to answer.
+        is_error = True
+        subtype = _SANDBOX_SUBTYPE
+        errors.append(f"the Codex sandbox could not complete the run's file operations: {sandbox_failure}")
+    elif capped is not None:
+        # We terminated the process on purpose, so its non-zero status is ours and must not be
+        # reported as a codex failure. The partial transcript is kept: it is the evidence of
+        # what the run spent the cap on.
+        is_error = True
+        subtype = capped
+        errors.append(
+            "acumen stopped the run at its turn cap"
+            if capped == _MAX_TURNS_SUBTYPE
+            else "acumen stopped the run at its budget cap"
+        )
+    else:
+        is_error = returncode != 0 or bool(errors)
+        if returncode != 0:
+            errors.extend(line.strip() for line in stderr_lines if line.strip() and line.strip() not in errors)
+        if returncode != 0 and not errors:
+            errors.append(f"codex exited with status {returncode}")
+    return AgentResult(
+        provider="codex",
+        is_error=is_error,
+        subtype=subtype if is_error else "success",
+        errors=errors or None,
+        session_id=session_id,
+        result=final,
+        num_turns=turns,
+        # Codex's JSONL protocol reports tokens, not a billed dollar amount.
+        total_cost_usd=None,
+        duration_ms=duration_ms,
+        usage=usage,
+        transcript=list(events),
+    )
+
+
+async def _drain_stderr(
+    stream: asyncio.StreamReader,
+    callback: Callable[[str], None] | None,
+    sink: list[str] | None = None,
+) -> None:
+    while line := await stream.readline():
+        text = line.decode(errors="replace").rstrip("\r\n")
+        if sink is not None:
+            sink.append(text)
+        if callback is not None:
+            callback(text)
+        else:
+            print(text, file=sys.stderr, flush=True)
+
+
+def _cap_breach(event: dict[str, Any], options: AgentOptions, turns: int) -> str | None:
+    """Return the cap ``event`` breached, or ``None``.
+
+    ``codex exec`` has no turn or budget cap of its own, so acumen enforces both against the
+    event stream and terminates the process on a breach. The two caps are enforced at different
+    resolutions, and the difference matters:
+
+    * ``max_turns`` is checked as each model action completes, so the run really is stopped at
+      the cap — the agent gets ``max_turns`` actions and no more. The cost of stopping mid-turn
+      is that ``turn.completed`` never arrives, so a turn-capped run reports no usage and is
+      priced at zero; it is a failed run either way, but its tokens are not recoverable.
+    * ``max_usd`` can only be checked when usage is reported, and Codex reports it once, in
+      ``turn.completed``, at the end of the turn. A single-turn ``codex exec`` therefore has
+      already spent the money by the time the breach is visible: the cap makes the *outcome*
+      honest — the run is recorded as a budget failure, exactly as it would be for Claude —
+      but it cannot prevent the overspend. Bound Codex spend with ``max_turns`` instead.
+    """
+    if options.max_turns is not None and _is_turn_item(event) and turns >= options.max_turns:
+        return _MAX_TURNS_SUBTYPE
+    if options.max_usd is None or options.price_usd is None or event.get("type") != "turn.completed":
+        return None
+    usage = event.get("usage")
+    if not isinstance(usage, dict):
+        return None
+    spent = options.price_usd(usage)
+    return _MAX_BUDGET_SUBTYPE if spent is not None and spent > options.max_usd else None
+
+
+async def _run_codex(
+    prompt: str,
+    options: AgentOptions,
+    on_event: Callable[[Any], None] | None,
+) -> AgentResult:
+    _install_codex_guard(options)
+    started = time.monotonic()
+    process = await asyncio.create_subprocess_exec(
+        *_codex_command(options, prompt),
+        stdin=asyncio.subprocess.DEVNULL,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        env=options.env,
+    )
+    assert process.stdout is not None
+    assert process.stderr is not None
+    noise: list[str] = []
+    stderr_task = asyncio.create_task(_drain_stderr(process.stderr, options.stderr, noise))
+    events: list[dict[str, Any]] = []
+    turns = 0
+    capped: str | None = None
+    try:
+        while line := await process.stdout.readline():
+            try:
+                event = json.loads(line)
+            except json.JSONDecodeError:
+                event = {"type": "error", "message": line.decode(errors="replace").strip()}
+            if not isinstance(event, dict):
+                continue
+            events.append(event)
+            if on_event is not None:
+                on_event(event)
+            if _is_turn_item(event):
+                turns += 1
+            capped = _cap_breach(event, options, turns)
+            if capped is not None:
+                process.terminate()
+                break
+        returncode = await process.wait()
+        await stderr_task
+    except BaseException:
+        process.terminate()
+        await process.wait()
+        stderr_task.cancel()
+        raise
+    duration_ms = round((time.monotonic() - started) * 1000)
+    return _codex_terminal(events, returncode, duration_ms, capped, _sandbox_failure(noise), noise)
+
+
+async def run_agent(
+    prompt: str,
+    *,
+    options: AgentOptions,
+    on_event: Callable[[Any], None] | None = None,
+) -> AgentResult:
+    """Run one Claude or Codex agent, selected from ``options.model``."""
+    provider = provider_for_model(options.model)
+    if provider == "claude":
+        return await _run_claude(prompt, options, on_event)
+    return await _run_codex(prompt, options, on_event)
diff --git a/src/acumen/bench.py b/src/acumen/bench.py
index 676fe4f..60b8b8b 100644
--- a/src/acumen/bench.py
+++ b/src/acumen/bench.py
@@ -3,13 +3,15 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Callable, Iterable, Sequence
+from collections.abc import Callable, Iterable, Mapping, Sequence
 from dataclasses import dataclass
 from pathlib import Path
 
+from acumen.agents import AgentProvider, provider_for_model
 from acumen.config import Config
 from acumen.env import AuthMode, Target
 from acumen.paths import SPLITS, RunKey, Split, arm_name, is_complete, run_dir
+from acumen.prices import PriceTable
 from acumen.runner import RunOutcome, run_once
 from acumen.skills import Skill
 from acumen.tasks import Task
@@ -26,6 +28,30 @@ class PlannedRun:
     max_usd: float
 
 
+class BenchmarkInvalidError(RuntimeError):
+    """Raised when provider quota/credit exhaustion invalidates a benchmark pass."""
+
+    def __init__(self, outcomes: RunOutcome | Sequence[RunOutcome]):
+        values = (outcomes,) if isinstance(outcomes, RunOutcome) else tuple(outcomes)
+        if not values:
+            raise ValueError("BenchmarkInvalidError needs at least one invalid outcome")
+        self.outcome = values[0]
+        self.outcomes = values
+        details: list[str] = []
+        for outcome in values:
+            payload = outcome.payload
+            provider = "Claude" if payload.get("agent") == "claude" else "Codex"
+            mode = payload.get("auth_mode", "selected")
+            detail = payload.get("error") or "the provider reported exhausted usage or credit"
+            details.append(
+                f"{provider} {mode} authentication ran out of usage or credit during "
+                f"{outcome.key.arm}/{outcome.key.split}/{outcome.key.model}/"
+                f"{outcome.key.task_id}/rep_{outcome.key.rep}. Remaining {provider} cells were "
+                f"cancelled; other providers continued. Provider error: {detail}"
+            )
+        super().__init__("benchmark invalid: " + " | ".join(details))
+
+
 def models_for(cfg: Config, task: Task) -> list[str]:
     """Return the models a task runs on — its own override, else the config's list."""
     return [task.model] if task.model else list(cfg.models)
@@ -106,6 +132,8 @@ async def run_matrix(
     runs_root: Path,
     max_concurrency: int,
     auth_mode: AuthMode = "api",
+    auth_modes: Mapping[AgentProvider, AuthMode] | None = None,
+    prices: PriceTable | None = None,
     skill: Skill | None = None,
     skill_name: str | None = None,
     sandbox_base: Path | None = None,
@@ -117,8 +145,10 @@ async def run_matrix(
 ) -> list[RunOutcome]:
     """Run planned runs concurrently, bounded by ``max_concurrency``.
 
-    One failing run never takes down the pass — :func:`acumen.runner.run_once` records
-    agent errors as failed runs rather than raising.
+    Ordinary failing runs do not take down the pass. Provider quota/credit exhaustion is
+    different: it invalidates that provider's measurement, cancels only its remaining work,
+    lets other providers finish their queued cells, then raises :class:`BenchmarkInvalidError`
+    after preserving the diagnostic result.
 
     Parameters
     ----------
@@ -131,8 +161,13 @@ async def run_matrix(
     max_concurrency
         Ceiling on simultaneous agents.
     auth_mode
-        Which credential every run authenticates with; benchmark passes always use ``"api"``
-        so the recorded ``cost_usd`` reflects real metered spend.
+        Which credential every run authenticates with. Under ``"session"``, the recorded
+        Claude's SDK value is API-equivalent rather than necessarily metered spend;
+        Codex uses token inference against ``prices``.
+    prices
+        The rates every run in this pass is priced by, and which each records alongside its
+        cost. One table for the whole matrix, resolved once before any spend, so a pass is
+        never priced by two different sets of numbers. Defaults to the built-in table.
     skill
         The skill every run in this matrix installs, or ``None`` for the baseline. One
         matrix is one arm, so this is a property of the pass rather than of a run.
@@ -164,9 +199,17 @@ async def run_matrix(
     """
     semaphore = asyncio.Semaphore(max_concurrency)
     outcomes: list[RunOutcome] = []
+    exhausted: dict[AgentProvider, RunOutcome] = {}
+    tasks: list[asyncio.Task[RunOutcome | None]] = []
+    task_providers: dict[asyncio.Task[RunOutcome | None], AgentProvider] = {}
 
-    async def one(item: PlannedRun) -> RunOutcome:
+    async def one(item: PlannedRun) -> RunOutcome | None:
+        provider = provider_for_model(item.model)
         async with semaphore:
+            # A sibling cell may have exhausted this provider while this one waited for a
+            # concurrency slot. Do not submit fresh work to a credential known to be empty.
+            if provider in exhausted:
+                return None
             if on_start is not None:
                 on_start(item)
             outcome = await run_once(
@@ -177,20 +220,51 @@ async def one(item: PlannedRun) -> RunOutcome:
                 model=item.model,
                 max_turns=item.max_turns,
                 max_usd=item.max_usd,
-                auth_mode=auth_mode,
+                auth_mode=(auth_modes or {}).get(provider, auth_mode),
                 skill=skill,
                 skill_name=skill_name,
                 sandbox_base=sandbox_base,
                 keep_sandbox=keep_sandbox,
                 stderr=stderr,
                 env_passthrough=env_passthrough,
+                prices=prices,
             )
             if on_done is not None:
                 on_done(outcome)
+            if outcome.reason == "provider_exhausted" and provider not in exhausted:
+                exhausted[provider] = outcome
+                current = asyncio.current_task()
+                # Stop both queued and in-flight siblings for this provider. Tasks for the
+                # other provider retain their places in the shared concurrency pool.
+                for peer in tasks:
+                    if peer is not current and task_providers.get(peer) == provider and not peer.done():
+                        peer.cancel()
             return outcome
 
-    for coro in asyncio.as_completed([one(item) for item in planned]):
-        outcomes.append(await coro)
+    for item in planned:
+        task = asyncio.create_task(one(item))
+        tasks.append(task)
+        task_providers[task] = provider_for_model(item.model)
+    try:
+        remaining = set(tasks)
+        while remaining:
+            done, remaining = await asyncio.wait(remaining, return_when=asyncio.FIRST_COMPLETED)
+            for task in done:
+                if task.cancelled():
+                    continue
+                outcome = task.result()  # propagate unexpected per-cell harness exceptions
+                if outcome is not None:
+                    outcomes.append(outcome)
+    except BaseException:
+        # External cancellation or an unexpected harness exception still stops everything;
+        # provider exhaustion itself is handled above at provider scope.
+        for task in tasks:
+            if not task.done():
+                task.cancel()
+        await asyncio.gather(*tasks, return_exceptions=True)
+        raise
+    if exhausted:
+        raise BenchmarkInvalidError(tuple(exhausted.values()))
     return outcomes
 
 
diff --git a/src/acumen/cli.py b/src/acumen/cli.py
index 1a3d7e7..76348ed 100644
--- a/src/acumen/cli.py
+++ b/src/acumen/cli.py
@@ -6,23 +6,37 @@
 import asyncio
 import sys
 import time
-from dataclasses import replace
+from collections.abc import Sequence
+from dataclasses import dataclass, replace
+from datetime import date
 from pathlib import Path
 
-from acumen.bench import build_matrix, pending, run_matrix, summarize
-from acumen.config import ConfigError, load_config
+from acumen.agents import AgentError, AgentProvider, check_agent_cli, provider_for_model
+from acumen.bench import BenchmarkInvalidError, PlannedRun, build_matrix, pending, run_matrix, summarize
+from acumen.config import Config, ConfigError, load_config
 from acumen.draft import DraftError, draft_skill
 from acumen.env import DEFAULT_CACHE_ROOT, AuthMode, EnvError, prepare_target, resolve_auth_mode
 from acumen.improve import ImproveError, improve_skill
 from acumen.logs import LiveLog
-from acumen.paths import SPLITS
+from acumen.paths import SPLITS, arm_name
+from acumen.pricefeed import (
+    PRICE_SOURCES,
+    PRICE_TIER,
+    PriceFeedError,
+    diff_rates,
+    fetch_table,
+    refresh,
+    to_yaml_block,
+    try_fetch_table,
+)
+from acumen.prices import PriceTable, Rates
 from acumen.report import ReportError, build_report
 from acumen.runner import RunOutcome, StderrFilter
-from acumen.scaffold import InitError, scaffold
+from acumen.scaffold import InitError, is_scaffold_tasks, scaffold
 from acumen.ship import ShipError, ship_skill
-from acumen.skills import SkillError, available_versions, latest_version, load_skill
+from acumen.skills import Skill, SkillError, available_versions, latest_version, load_skill
 from acumen.taskgen import TaskGenError, generate_tasks
-from acumen.tasks import TaskError, load_tasks
+from acumen.tasks import Task, TaskError, load_tasks
 
 
 def _add_bench_args(parser: argparse.ArgumentParser) -> None:
@@ -30,8 +44,8 @@ def _add_bench_args(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("--tasks", type=Path, default=Path("tasks.yaml"), help="path to tasks.yaml")
     parser.add_argument("--runs", type=Path, default=Path("runs"), help="root of the run tree")
     arm = parser.add_mutually_exclusive_group()
-    arm.add_argument("--no-skill", action="store_true", help="run the baseline arm (the default)")
-    arm.add_argument("--skill", metavar="VERSION", help="run with a skill version, e.g. v1")
+    arm.add_argument("--no-skill", action="store_true", help="run the baseline arm alone")
+    arm.add_argument("--skill", metavar="VERSION", help="run one skill version alone, e.g. v1")
     parser.add_argument("--split", choices=SPLITS, action="append", help="restrict to a split (repeatable)")
     parser.add_argument("--task", metavar="ID", action="append", help="restrict to a task id (repeatable)")
     parser.add_argument("--max-concurrency", type=int, help="override config max_concurrency")
@@ -41,7 +55,12 @@ def _add_bench_args(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("--keep-sandboxes", action="store_true", help="leave run sandboxes on disk")
     parser.add_argument("--cache", type=Path, default=DEFAULT_CACHE_ROOT, help="target cache root")
     parser.add_argument("--skills", type=Path, default=Path("skills"), help="root of the skill tree")
-    parser.add_argument("--dry-run", action="store_true", help="print the matrix and exit without running agents")
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="print the matrix and exit without running agents, over the same arms the real pass would cover",
+    )
+    _add_auth_arg(parser)
 
 
 def _add_log_args(parser: argparse.ArgumentParser) -> None:
@@ -64,33 +83,100 @@ def _add_feedback_arg(parser: argparse.ArgumentParser, *, extra: str = "") -> No
 
 
 def _add_auth_arg(parser: argparse.ArgumentParser) -> None:
-    """Add the ``--auth`` flag to a single-agent subcommand.
+    """Add the ``--auth`` flag to a command that spawns agents.
 
-    These commands spawn one agent, so they default to the Claude subscription ("session")
-    when a subscription login is present and fall back to the API key otherwise. ``bench`` has
-    no such flag — it always bills the API so its recorded ``cost_usd`` is real.
+    Every agentic command defaults to the provider subscription ("session") when a login is
+    present and falls back to the API key otherwise — ``bench`` included, since it prices runs
+    from their token counts rather than from a billed figure only the API reports.
     """
     parser.add_argument(
         "--auth",
         choices=("auto", "session", "api"),
         default="auto",
-        help="which credential to bill: 'session' (Claude subscription), 'api' (Anthropic API), "
+        help="which credential to bill: 'session' (Claude/Codex subscription), 'api' (provider API), "
         "or 'auto' (default: session if you're logged in, else the API)",
     )
 
 
-def _print_auth(mode: AuthMode) -> None:
+def _print_auth(mode: AuthMode, provider: AgentProvider = "claude") -> None:
     """Report which credential the run will bill, so the choice is never silent."""
-    label = "Claude subscription (session)" if mode == "session" else "API key"
+    product = "Claude" if provider == "claude" else "Codex"
+    label = f"{product} subscription (session)" if mode == "session" else f"{product} API key"
     print(f"auth: {label}", flush=True)
 
 
+def _warn_codex_accounting(provider: AgentProvider) -> None:
+    """Say what a Codex cap can and cannot do before the spend, not after.
+
+    ``codex exec`` has no cap of its own, so acumen enforces both against the event stream.
+    That works exactly as advertised for turns, which stream. Usage does not: Codex reports it
+    once, when the turn ends, so ``max_usd`` can only be recognized after the money is spent.
+    It still records the run as a budget failure — the same outcome Claude would give it — but
+    the only cap that actually *bounds* a Codex run is ``max_turns``.
+    """
+    if provider == "codex":
+        print(
+            "note: Codex reports usage only when a turn ends, so max_usd marks an over-budget "
+            "run as a failure but cannot stop the spend — bound Codex runs with max_turns",
+            file=sys.stderr,
+        )
+
+
+def _warn_unpriced(models: set[str], prices: PriceTable) -> None:
+    """Name models with no rates before the spend, not after.
+
+    An unpriced model still records its tokens; only ``cost_usd`` is left unset. Saying so
+    up front is what stops a missing rate from reading as a free model in the report.
+    """
+    unpriced = sorted(model for model in models if prices.lookup(model) is None)
+    if unpriced:
+        print(
+            f"note: no token rates for {', '.join(unpriced)}. These runs record tokens but no "
+            "cost; add a 'prices:' entry in config.yaml to price them.",
+            file=sys.stderr,
+        )
+
+
+def _bench_prices(cfg: Config) -> PriceTable:
+    """Resolve the rates this pass will be priced by, before it spends anything.
+
+    Raises :class:`PriceFeedError` upward: cost is a headline metric of the report and is
+    frozen into every result, so a pass that cannot establish rates should not run.
+    """
+    for name, url in PRICE_SOURCES.items():
+        print(f"prices: fetching {name} ({url})", flush=True)
+    table = fetch_table(cfg.prices)
+    print(f"prices: {len(table.fetched)} model(s) resolved as of {table.fetched_as_of} ({PRICE_TIER})")
+    return table
+
+
+def _agent_prices(cfg: Config, *, model: str | None = None) -> PriceTable:
+    """Rates for one interactive agent command, degrading to unpriced if the pages are down.
+
+    Unlike a benchmark, these commands report cost as progress rather than storing it as
+    evidence, so a pricing outage should not stop the work. It is still said out loud, and
+    the Codex consequence is named: ``max_usd`` is enforced from these rates, so an
+    unpriced model has no budget cap at all.
+    """
+    table, failure = try_fetch_table(cfg.prices)
+    if failure is None:
+        return table
+    print(f"warning: could not fetch pricing ({failure}); this run reports no cost", file=sys.stderr)
+    if model is not None and provider_for_model(model) == "codex" and table.lookup(model) is None:
+        print(
+            f"warning: max_usd cannot be enforced for {model} without rates. Bound this run "
+            "with max_turns, or pin rates in config.yaml under 'prices:'.",
+            file=sys.stderr,
+        )
+    return table
+
+
 def _print_log_result(log: LiveLog) -> None:
     """Print where the rendered HTML log landed, once a run has finalized."""
     if log.html_rendered:
         print(f"log → {log.html_path}")
     else:
-        print("note: HTML log not rendered (claude-code-log missing?) — the jsonl log is complete", file=sys.stderr)
+        print("note: HTML log not rendered — the jsonl log is complete", file=sys.stderr)
 
 
 def _fmt_secs(seconds: float) -> str:
@@ -145,18 +231,21 @@ def on_done(self, outcome: RunOutcome) -> None:
         self.running -= 1
         if outcome.success:
             self.passed += 1
-        mark = "✓ pass" if outcome.success else "✗ FAIL"
+        mark = "⚠ INVALID" if outcome.reason == "provider_exhausted" else ("✓ pass" if outcome.success else "✗ FAIL")
         p = outcome.payload
         toks = int(p.get("input_tokens", 0)) + int(p.get("output_tokens", 0))
-        cost = float(p.get("cost_usd", 0.0))
         dur = _fmt_secs(float(p.get("duration_s", 0.0)))
-        stats = f"{_fmt_tokens(toks)}tok ${cost:.2f} {dur}"
+        cost_available = p.get("cost_available", True) and p.get("cost_usd") is not None
+        cost_label = f"${float(p['cost_usd']):.2f}" if cost_available else "cost n/a"
+        stats = f"{_fmt_tokens(toks)}tok {cost_label} {dur}"
         print(
             f"[{self._stamp()}] {mark} {_key_label(outcome.key)}"
             f"  ({outcome.reason})  {stats}"
             f"  [{self.done}/{self.total} done, {self.passed} passed]",
             flush=True,
         )
+        if outcome.reason == "provider_exhausted":
+            print(f"error: provider usage/credit exhausted: {p.get('error') or 'no provider detail'}", file=sys.stderr)
 
 
 def _fmt_tokens(value: int) -> str:
@@ -168,6 +257,106 @@ def _fmt_tokens(value: int) -> str:
     return str(value)
 
 
+def _fmt_cost(value: float | None) -> str:
+    """Format a known cost without presenting unavailable pricing as free."""
+    return f"${value:.2f}" if value is not None else "cost n/a"
+
+
+@dataclass(frozen=True)
+class _Arm:
+    """One arm of a pass: its version, its loaded skill, and its matrix."""
+
+    version: str | None  # None => the noskill baseline
+    skill: Skill | None
+    planned: list[PlannedRun]
+    todo: list[PlannedRun]
+
+    @property
+    def name(self) -> str:
+        return arm_name(self.version)
+
+
+def _resolve_arms(cfg: Config, tasks: Sequence[Task], args: argparse.Namespace) -> list[_Arm]:
+    """Build the arms this invocation covers, loading every skill before anything is spent.
+
+    Naming an arm (``--skill vN`` / ``--no-skill``) covers that one alone. Naming none covers
+    the whole project: the baseline plus every version in ``skills/``, which is the comparison
+    the report wants anyway. A version that will not load raises here, before target prep, so a
+    broken skill costs nothing rather than surfacing part-way through a paid pass.
+    """
+    if args.skill is not None:
+        versions: list[str | None] = [args.skill]
+    elif args.no_skill:
+        versions = [None]
+    else:
+        versions = [None, *available_versions(args.skills)]
+
+    arms = []
+    for version in versions:
+        skill = None if version is None else load_skill(args.skills, version, expect_name=cfg.skill_name)
+        planned = build_matrix(cfg, tasks, skill=version, splits=args.split or SPLITS, task_ids=args.task)
+        todo = pending(planned, args.runs, resume=not args.no_resume)
+        arms.append(_Arm(version=version, skill=skill, planned=planned, todo=todo))
+    return arms
+
+
+def _print_plan(arms: Sequence[_Arm]) -> None:
+    """Print what each arm holds, and the total when a pass spans several."""
+    width = max(len(f"arm {arm.name}:") for arm in arms) if len(arms) > 1 else 0
+    indent = "    " if len(arms) > 1 else ""
+    for arm in arms:
+        label = f"arm {arm.name}:".ljust(width)
+        complete = len(arm.planned) - len(arm.todo)
+        print(f"{label} {len(arm.planned)} runs planned, {complete} already complete, {len(arm.todo)} to run")
+        if arm.skill is not None:
+            print(f"{indent}skill {arm.skill.version}: {arm.skill.name} ({arm.skill.hash[:19]}…)")
+    if len(arms) > 1:
+        planned = sum(len(arm.planned) for arm in arms)
+        todo = sum(len(arm.todo) for arm in arms)
+        print(f"total: {planned} runs planned, {todo} to run across {len(arms)} arms")
+
+
+def _print_runs(todo: Sequence[PlannedRun]) -> None:
+    for item in todo:
+        k = item.key
+        print(f"  {k.arm}/{k.split}/{k.model}/{k.task_id}/rep_{k.rep}")
+
+
+def _print_run_summary(outcomes: Sequence[RunOutcome], elapsed: float, *, label: str = "") -> None:
+    """Print the pass tally: how many passed, how long, what it cost, why runs failed."""
+    passed = sum(1 for o in outcomes if o.success)
+    counts = summarize(outcomes)
+    breakdown = ", ".join(f"{reason}={n}" for reason, n in sorted(counts.items()))
+    priced = [
+        float(o.payload["cost_usd"])
+        for o in outcomes
+        if o.payload.get("cost_available", True) and o.payload.get("cost_usd") is not None
+    ]
+    total_cost = sum(priced)
+    unpriced = len(outcomes) - len(priced)
+    cost_summary = f"${total_cost:.2f}" if priced else "cost n/a"
+    if unpriced and priced:
+        cost_summary += f" + {unpriced} unpriced run(s)"
+    elif unpriced:
+        cost_summary += f" ({unpriced} unpriced run(s))"
+    prefix = f"{label}: " if label else ""
+    print(f"\n{prefix}{passed}/{len(outcomes)} passed in {_fmt_secs(elapsed)}  ({cost_summary}, {breakdown})")
+
+
+def _print_skill_loading(outcomes: Sequence[RunOutcome], arm: _Arm, skill_name: str) -> None:
+    """Say whether the skill reached the agent — the comparison means nothing otherwise."""
+    loaded = sum(1 for o in outcomes if o.payload.get("skill_loaded"))
+    if arm.skill is not None:
+        print(f"skill loaded in {loaded}/{len(outcomes)} runs")
+        if loaded == 0:
+            print(
+                f"warning: {arm.name} never loaded the skill — that arm is not measuring the skill",
+                file=sys.stderr,
+            )
+    elif loaded:
+        print(f"warning: {skill_name} loaded in {loaded} baseline runs", file=sys.stderr)
+
+
 def _cmd_bench(args: argparse.Namespace) -> int:
     cfg = load_config(args.config)
     tasks = load_tasks(args.tasks)
@@ -176,69 +365,90 @@ def _cmd_bench(args: argparse.Namespace) -> int:
     if args.replicates:
         cfg = replace(cfg, n_replicates=args.replicates)
 
-    version = args.skill  # None => the noskill baseline
-    skill = None
-    if version is not None:
-        skill = load_skill(args.skills, version, expect_name=cfg.skill_name)
-
-    planned = build_matrix(cfg, tasks, skill=version, splits=args.split or SPLITS, task_ids=args.task)
-    todo = pending(planned, args.runs, resume=not args.no_resume)
-
-    arm = "noskill" if version is None else f"skill_{version}"
-    print(f"arm {arm}: {len(planned)} runs planned, {len(planned) - len(todo)} already complete, {len(todo)} to run")
-    if skill is not None:
-        print(f"skill {skill.version}: {skill.name} ({skill.hash[:19]}…)")
+    arms = _resolve_arms(cfg, tasks, args)
+    _print_plan(arms)
     if args.dry_run:
-        for item in todo:
-            k = item.key
-            print(f"  {k.arm}/{k.split}/{k.model}/{k.task_id}/rep_{k.rep}")
+        for arm in arms:
+            _print_runs(arm.todo)
         return 0
+
+    todo = [item for arm in arms for item in arm.todo]
     if not todo:
         return 0
 
-    # bench records real per-run cost, so it must bill the API — never the subscription.
-    auth_mode = resolve_auth_mode("api", allow_session=False)
+    # One resolved mode per provider in the matrix, so a mixed pass bills each side correctly.
+    providers = {provider_for_model(item.model) for item in todo}
+    auth_modes = {provider: resolve_auth_mode(args.auth, provider=provider) for provider in providers}
+    for provider in sorted(providers):
+        check_agent_cli(provider)
+        _print_auth(auth_modes[provider], provider)
+        _warn_codex_accounting(provider)
+    if "session" in auth_modes.values():
+        print(
+            "note: cost_usd for session-billed runs is what they would have cost at API "
+            "rates, not metered spend; each run records its auth_mode",
+            file=sys.stderr,
+        )
+    # Before the target is built and before any agent runs: an unreachable pricing page
+    # must cost nothing, and a pass must never be priced by a table it cannot date.
+    try:
+        prices = _bench_prices(cfg)
+    except PriceFeedError as err:
+        print(f"error: {err}", file=sys.stderr)
+        print(
+            "Each run's cost is frozen into its result, so a pass that cannot establish "
+            "rates would store figures nothing backs. Retry when the pages are reachable, "
+            "or pin rates with a 'prices:' block in config.yaml.",
+            file=sys.stderr,
+        )
+        return 2
+    _warn_unpriced({item.model for item in todo}, prices)
     print(f"preparing target {cfg.repo}@{cfg.ref} ...", flush=True)
     target = prepare_target(cfg, args.cache, refresh=args.refresh_target)
     print(f"target ready: {target.fingerprint} @ {target.commit[:8]} (venv {target.venv_dir})", flush=True)
 
+    # Arms run one after another: every run in a matrix shares one skill, and a sequential
+    # pass keeps each arm's tally readable while the progress counter spans the whole thing.
+    running = [arm for arm in arms if arm.todo]
     print(f"running {len(todo)} runs, up to {cfg.max_concurrency} at a time:", flush=True)
     progress = _Progress(len(todo))
-    outcomes = asyncio.run(
-        run_matrix(
-            todo,
-            target=target,
-            runs_root=args.runs,
-            max_concurrency=cfg.max_concurrency,
-            auth_mode=auth_mode,
-            skill=skill,
-            skill_name=cfg.skill_name,
-            keep_sandbox=args.keep_sandboxes,
-            stderr=StderrFilter(),
-            on_start=progress.on_start,
-            on_done=progress.on_done,
-            env_passthrough=cfg.env_passthrough,
+    collected: list[RunOutcome] = []
+    try:
+        for arm in running:
+            if len(running) > 1:
+                print(f"\n=== arm {arm.name}: {len(arm.todo)} runs ===", flush=True)
+            started = time.monotonic()
+            outcomes = asyncio.run(
+                run_matrix(
+                    arm.todo,
+                    target=target,
+                    runs_root=args.runs,
+                    max_concurrency=cfg.max_concurrency,
+                    auth_modes=auth_modes,
+                    skill=arm.skill,
+                    skill_name=cfg.skill_name,
+                    keep_sandbox=args.keep_sandboxes,
+                    stderr=StderrFilter(),
+                    on_start=progress.on_start,
+                    on_done=progress.on_done,
+                    env_passthrough=cfg.env_passthrough,
+                    prices=prices,
+                )
+            )
+            collected.extend(outcomes)
+            _print_run_summary(outcomes, time.monotonic() - started, label=arm.name if len(running) > 1 else "")
+            _print_skill_loading(outcomes, arm, cfg.skill_name)
+    except BenchmarkInvalidError as err:
+        print(f"\nerror: {err}", file=sys.stderr)
+        print(
+            "Fix or replenish that credential, then rerun the same command; invalid and "
+            "cancelled cells remain pending.",
+            file=sys.stderr,
         )
-    )
-
-    passed = sum(1 for o in outcomes if o.success)
-    counts = summarize(outcomes)
-    breakdown = ", ".join(f"{reason}={n}" for reason, n in sorted(counts.items()))
-    total_cost = sum(float(o.payload.get("cost_usd", 0.0)) for o in outcomes)
-    print(f"\n{passed}/{len(outcomes)} passed in {_fmt_secs(progress.elapsed)}  (${total_cost:.2f}, {breakdown})")
+        return 2
 
-    # The comparison is only meaningful if the skill actually reached the agent, so say
-    # so rather than leaving it to be discovered later in the transcripts.
-    loaded = sum(1 for o in outcomes if o.payload.get("skill_loaded"))
-    if skill is not None:
-        print(f"skill loaded in {loaded}/{len(outcomes)} runs")
-        if loaded == 0:
-            print(
-                "warning: the skill never loaded — this arm is not measuring the skill",
-                file=sys.stderr,
-            )
-    elif loaded:
-        print(f"warning: {cfg.skill_name} loaded in {loaded} baseline runs", file=sys.stderr)
+    if len(running) > 1:
+        _print_run_summary(collected, progress.elapsed, label=f"all {len(running)} arms")
     print(f"runs written to {args.runs.resolve()}")
     return 0
 
@@ -258,8 +468,11 @@ def _cmd_draft(args: argparse.Namespace) -> int:
         )
         return 2
 
-    auth_mode = resolve_auth_mode(args.auth, allow_session=True)
-    _print_auth(auth_mode)
+    provider = provider_for_model(cfg.draft_model)
+    check_agent_cli(provider)
+    auth_mode = resolve_auth_mode(args.auth, provider=provider)
+    _print_auth(auth_mode, provider)
+    _warn_codex_accounting(provider)
     print(f"preparing target {cfg.repo}@{cfg.ref} ...", flush=True)
     target = prepare_target(cfg, args.cache, refresh=args.refresh_target)
     print(f"target ready: {target.fingerprint} @ {target.commit[:8]}", flush=True)
@@ -271,6 +484,7 @@ def _cmd_draft(args: argparse.Namespace) -> int:
         result = asyncio.run(
             draft_skill(
                 cfg=cfg,
+                prices=_agent_prices(cfg, model=cfg.draft_model),
                 target=target,
                 skills_root=args.skills,
                 auth_mode=auth_mode,
@@ -287,7 +501,7 @@ def _cmd_draft(args: argparse.Namespace) -> int:
     print(f"  description: {skill.description}")
     print(f"  hash:        {skill.hash}")
     print(f"  files:       {', '.join(files)}")
-    print(f"  cost:        ${result.cost_usd:.2f} over {result.turns} turns")
+    print(f"  cost:        {_fmt_cost(result.cost_usd)} over {result.turns} turns")
     _print_log_result(log)
     print(f"\nnext: acumen bench --skill {skill.version}")
     return 0
@@ -312,8 +526,11 @@ def _cmd_improve(args: argparse.Namespace) -> int:
     skill = load_skill(args.skills, parent, expect_name=cfg.skill_name)
     print(f"improving {skill.version} ({skill.name}, {skill.hash[:19]}…) with {cfg.improve_model}")
 
-    auth_mode = resolve_auth_mode(args.auth, allow_session=True)
-    _print_auth(auth_mode)
+    provider = provider_for_model(cfg.improve_model)
+    check_agent_cli(provider)
+    auth_mode = resolve_auth_mode(args.auth, provider=provider)
+    _print_auth(auth_mode, provider)
+    _warn_codex_accounting(provider)
     print(f"preparing target {cfg.repo}@{cfg.ref} ...", flush=True)
     target = prepare_target(cfg, args.cache, refresh=args.refresh_target)
     print(f"target ready: {target.fingerprint} @ {target.commit[:8]}", flush=True)
@@ -324,6 +541,7 @@ def _cmd_improve(args: argparse.Namespace) -> int:
         result = asyncio.run(
             improve_skill(
                 cfg=cfg,
+                prices=_agent_prices(cfg, model=cfg.improve_model),
                 target=target,
                 skills_root=args.skills,
                 runs_root=args.runs,
@@ -344,7 +562,7 @@ def _cmd_improve(args: argparse.Namespace) -> int:
     print(f"  hash:        {new.hash}")
     print(f"  files:       {', '.join(files)}")
     print(f"  evidence:    {result.n_train_runs} train runs ({result.n_train_failures} failing)")
-    print(f"  cost:        ${result.cost_usd:.2f} over {result.turns} turns")
+    print(f"  cost:        {_fmt_cost(result.cost_usd)} over {result.turns} turns")
     if new.hash == skill.hash:
         print(
             "warning: the new version is byte-identical to its parent — the improver changed nothing",
@@ -361,16 +579,24 @@ def _cmd_tasks(args: argparse.Namespace) -> int:
         cfg = replace(cfg, tasks_model=args.model)
 
     out = args.out
-    # Fail before the (costly) target prep and agent run if we'd have to clobber.
-    if out.exists() and not args.force:
+    # `acumen init` writes a placeholder here, and generating over it is the documented next
+    # step — so the untouched placeholder is not something to protect. Anything the user has
+    # actually edited still needs --force, and that is checked before the costly target prep.
+    overwrite = args.force or is_scaffold_tasks(out)
+    if out.exists() and not overwrite:
         print(
-            f"{out} already exists — pass --force to overwrite it (e.g. the placeholder from `acumen init`)",
+            f"{out} already exists — pass --force to overwrite it",
             file=sys.stderr,
         )
         return 2
+    if out.exists() and not args.force:
+        print(f"replacing the untouched placeholder at {out}")
 
-    auth_mode = resolve_auth_mode(args.auth, allow_session=True)
-    _print_auth(auth_mode)
+    provider = provider_for_model(cfg.tasks_model)
+    check_agent_cli(provider)
+    auth_mode = resolve_auth_mode(args.auth, provider=provider)
+    _print_auth(auth_mode, provider)
+    _warn_codex_accounting(provider)
     print(f"preparing target {cfg.repo}@{cfg.ref} ...", flush=True)
     target = prepare_target(cfg, args.cache, refresh=args.refresh_target)
     print(f"target ready: {target.fingerprint} @ {target.commit[:8]}", flush=True)
@@ -385,19 +611,20 @@ def _cmd_tasks(args: argparse.Namespace) -> int:
         result = asyncio.run(
             generate_tasks(
                 cfg=cfg,
+                prices=_agent_prices(cfg, model=cfg.tasks_model),
                 target=target,
                 out_path=out,
                 auth_mode=auth_mode,
                 max_turns=args.max_turns,
                 max_usd=args.max_usd,
-                force=args.force,
+                force=overwrite,
                 feedback=args.feedback,
                 log=log,
             )
         )
     print(f"\nwrote {result.out_path.resolve()}")
     print(f"  tasks: {len(result.tasks)} ({', '.join(t.id for t in result.tasks)})")
-    print(f"  cost:  ${result.cost_usd:.2f} over {result.turns} turns")
+    print(f"  cost:  {_fmt_cost(result.cost_usd)} over {result.turns} turns")
     _print_log_result(log)
     print("\nnext: review the tasks, then `acumen draft` and `acumen bench`")
     return 0
@@ -417,8 +644,11 @@ def _cmd_ship(args: argparse.Namespace) -> int:
         else ("a GitHub URL — the change is delivered as a pull request")
     )
     print(f"shipping {args.version} of {cfg.skill_name} into {cfg.repo} ({where})")
-    auth_mode = resolve_auth_mode(args.auth, allow_session=True)
-    _print_auth(auth_mode)
+    provider = provider_for_model(cfg.ship_model)
+    check_agent_cli(provider)
+    auth_mode = resolve_auth_mode(args.auth, provider=provider)
+    _print_auth(auth_mode, provider)
+    _warn_codex_accounting(provider)
     print(f"preparing target {cfg.repo}@{cfg.ref} ...", flush=True)
     target = prepare_target(cfg, args.cache, refresh=args.refresh_target)
     print(f"target ready: {target.fingerprint} @ {target.commit[:8]}", flush=True)
@@ -434,6 +664,7 @@ def _cmd_ship(args: argparse.Namespace) -> int:
         result = asyncio.run(
             ship_skill(
                 cfg=cfg,
+                prices=_agent_prices(cfg, model=cfg.ship_model),
                 target=target,
                 skills_root=args.skills,
                 version=args.version,
@@ -446,7 +677,7 @@ def _cmd_ship(args: argparse.Namespace) -> int:
         )
     print(f"\nshipped {result.skill.version} of {result.skill.name}")
     print(f"  mode:  {'pull request' if result.mode == 'github' else 'working tree (local)'}")
-    print(f"  cost:  ${result.cost_usd:.2f} over {result.turns} turns")
+    print(f"  cost:  {_fmt_cost(result.cost_usd)} over {result.turns} turns")
     _print_log_result(log)
     if result.summary:
         print("\nagent summary:")
@@ -499,13 +730,84 @@ def _cmd_init(args: argparse.Namespace) -> int:
     return 0
 
 
+def _cmd_prices(args: argparse.Namespace) -> int:
+    """Show the rates cost is computed from, or check pinned rates against the pages.
+
+    Both modes read the providers' pages, since that is the only place rates come from.
+    ``--refresh`` differs in what it prints: the models whose published price disagrees
+    with a ``prices:`` pin in ``config.yaml``, which are the only rates that can drift
+    unnoticed once everything else is read live.
+    """
+    overrides: dict[str, Rates] = {}
+    models: set[str] = set()
+    if args.config.is_file():
+        cfg = load_config(args.config)
+        overrides, models = cfg.prices, {m.strip().lower() for m in cfg.models}
+
+    for name, url in PRICE_SOURCES.items():
+        print(f"fetching {name}: {url}", flush=True)
+    try:
+        fetched = refresh(today=date.today())
+    except PriceFeedError as err:
+        print(f"error: {err}", file=sys.stderr)
+        return 2
+
+    if not args.refresh:
+        table = PriceTable(overrides=overrides, fetched=fetched, fetched_as_of=date.today().isoformat())
+        shown = sorted(set(fetched) | set(overrides)) if args.all else sorted(models | set(overrides))
+        print(f"\nrates (USD per million tokens) as of {table.fetched_as_of} — {PRICE_TIER}")
+        for model in shown:
+            found = table.lookup(model)
+            if found is None:
+                print(f"  {model:28} unpriced (not published; add it under 'prices:' to price it)")
+                continue
+            print(
+                f"  {model:28} in ${found.rates.input:<7} cached ${found.rates.cached_input:<7} "
+                f"write ${found.rates.cache_write:<7} out ${found.rates.output:<7} ({found.source})"
+            )
+        if not args.all:
+            print(f"\n{len(fetched)} model(s) published in total; show them all with --all")
+        return 0
+
+    # Only pinned rates can disagree with a page: everything else is read live each run.
+    if not overrides:
+        print("\nno 'prices:' pins in config.yaml, so nothing can drift — rates are read live each run")
+        return 0
+    changes = diff_rates(overrides, {m: r for m, r in fetched.items() if m in overrides})
+
+    if not changes:
+        print(f"\nup to date — all {len(overrides)} pinned rate(s) match what the providers publish")
+        return 0
+
+    print(f"\n{len(changes)} pinned rate(s) differ from the published price ({PRICE_TIER}):")
+    for change in changes:
+        print(change.describe())
+
+    block = to_yaml_block({change.model: change.after for change in changes})
+    if args.out is not None:
+        args.out.write_text(block)
+        print(f"\nwrote {args.out} — merge its 'prices:' block into config.yaml to adopt these")
+    else:
+        print("\nadopt by updating config.yaml (or re-run with --out PATH):\n")
+        print(block, end="")
+    # Never applied automatically: a pin is a deliberate statement, and a mis-parsed tier
+    # or context band would otherwise overwrite it with a plausible wrong number.
+    return 0
+
+
 def build_parser() -> argparse.ArgumentParser:
     """Build the ``acumen`` argument parser."""
     parser = argparse.ArgumentParser(
-        prog="acumen", description="Build, benchmark, and optimize Claude skills for Python packages."
+        prog="acumen", description="Build, benchmark, and optimize agentic skills for Python packages."
     )
     sub = parser.add_subparsers(dest="command", required=True)
-    bench = sub.add_parser("bench", help="run a benchmark pass")
+    bench = sub.add_parser(
+        "bench",
+        help="run a benchmark pass over every arm, or one named arm",
+        description="Bench every arm the project has (the baseline plus each version in skills/), "
+        "or a single arm with --no-skill / --skill vN. Completed runs are skipped, so rerunning "
+        "only costs the cells that are missing.",
+    )
     _add_bench_args(bench)
     bench.set_defaults(func=_cmd_bench)
 
@@ -585,6 +887,13 @@ def build_parser() -> argparse.ArgumentParser:
     )
     report.set_defaults(func=_cmd_report)
 
+    prices = sub.add_parser("prices", help="show the token rates cost is computed from, or re-check them")
+    prices.add_argument("--config", type=Path, default=Path("config.yaml"), help="path to config.yaml (for overrides)")
+    prices.add_argument("--refresh", action="store_true", help="fetch the providers' pricing pages and diff them")
+    prices.add_argument("--all", action="store_true", help="with --refresh, report every model, not just yours")
+    prices.add_argument("--out", type=Path, default=None, help="with --refresh, write the 'prices:' block here")
+    prices.set_defaults(func=_cmd_prices)
+
     init = sub.add_parser("init", help="scaffold a starter config.yaml and tasks.yaml")
     init.add_argument("--dir", type=Path, default=Path("."), dest="directory", help="directory to scaffold into")
     init.add_argument("--force", action="store_true", help="overwrite existing config.yaml / tasks.yaml")
@@ -607,6 +916,8 @@ def main(argv: list[str] | None = None) -> int:
         ConfigError,
         TaskError,
         EnvError,
+        AgentError,
+        PriceFeedError,
         SkillError,
         DraftError,
         ImproveError,
diff --git a/src/acumen/config.py b/src/acumen/config.py
index 01c77c3..3776d7f 100644
--- a/src/acumen/config.py
+++ b/src/acumen/config.py
@@ -9,6 +9,7 @@
 import yaml
 
 from .paths import PathError, slugify
+from .prices import Rates
 
 
 class ConfigError(ValueError):
@@ -22,7 +23,17 @@ class Config:
     repo: str
     skill_name: str
     ref: str = "main"
+    #: Extras from the target's ``[project.optional-dependencies]``. These are published in
+    #: package metadata, so they are what ``pip install pkg[name]`` resolves against.
     extras: list[str] = field(default_factory=list)
+    #: PEP 735 groups from the target's ``[dependency-groups]``. Unlike extras these never
+    #: reach package metadata — they exist only in the source tree — so they need uv's
+    #: ``--group`` rather than the ``pkg[name]`` syntax.
+    dependency_groups: list[str] = field(default_factory=list)
+    #: Packages the target's own ``pyproject.toml`` declares nowhere, installed into the
+    #: target venv alongside it. Passed to ``uv pip install`` verbatim, so PEP 508
+    #: specifiers (``numpy<2``) work.
+    pip_packages: list[str] = field(default_factory=list)
     python: str = "3.12"
     #: Names of environment variables to carry from the operator's shell into isolated
     #: agents (bench sandboxes and the draft/improve/tasks meta-agents), on top of the
@@ -42,6 +53,11 @@ class Config:
     improve_model: str = "claude-opus-5"
     tasks_model: str = "claude-opus-5"
     ship_model: str = "claude-opus-5"
+    #: Per-model token rates (USD per million), overriding or extending the built-in table
+    #: in :mod:`acumen.prices`. Name a model here when you are on negotiated rates, run
+    #: through a gateway, or use a model acumen does not ship a price for — an unpriced
+    #: model still records its tokens, but its ``cost_usd`` is left unset rather than zero.
+    prices: dict[str, Rates] = field(default_factory=dict)
 
     @property
     def is_local(self) -> bool:
@@ -55,6 +71,8 @@ def is_local(self) -> bool:
     "repo",
     "ref",
     "extras",
+    "dependency_groups",
+    "pip_packages",
     "python",
     "env_passthrough",
     "models",
@@ -67,6 +85,7 @@ def is_local(self) -> bool:
     "tasks_model",
     "ship_model",
     "skill_name",
+    "prices",
 }
 
 
@@ -129,6 +148,24 @@ def _str_list(raw: dict[str, Any], key: str, default: list[str]) -> list[str]:
     return list(value)
 
 
+def _prices(raw: dict[str, Any]) -> dict[str, Rates]:
+    """Validate the optional ``prices:`` block into rates keyed by model ID."""
+    if "prices" not in raw:
+        return {}
+    value = raw["prices"]
+    if not isinstance(value, dict):
+        raise ConfigError(f"'prices' must be a mapping of model to rates, got {value!r}")
+    table: dict[str, Rates] = {}
+    for model, rates in value.items():
+        if not isinstance(model, str) or not model.strip():
+            raise ConfigError(f"'prices' keys must be non-empty model IDs, got {model!r}")
+        try:
+            table[model.strip().lower()] = Rates.from_mapping(rates, model=model)
+        except ValueError as err:
+            raise ConfigError(f"'prices': {err}") from err
+    return table
+
+
 def parse_config(raw: Any) -> Config:
     """Validate an already-parsed ``config.yaml`` document.
 
@@ -164,6 +201,8 @@ def parse_config(raw: Any) -> Config:
         skill_name=skill_name,
         ref=_optional_str(raw, "ref", "main"),
         extras=_str_list(raw, "extras", []),
+        dependency_groups=_str_list(raw, "dependency_groups", []),
+        pip_packages=_str_list(raw, "pip_packages", []),
         python=_optional_str(raw, "python", "3.12"),
         env_passthrough=_str_list(raw, "env_passthrough", []),
         models=models,
@@ -175,6 +214,7 @@ def parse_config(raw: Any) -> Config:
         improve_model=_optional_str(raw, "improve_model", default_model),
         tasks_model=_optional_str(raw, "tasks_model", default_model),
         ship_model=_optional_str(raw, "ship_model", default_model),
+        prices=_prices(raw),
     )
 
 
diff --git a/src/acumen/draft.py b/src/acumen/draft.py
index 4b7553a..6deb900 100644
--- a/src/acumen/draft.py
+++ b/src/acumen/draft.py
@@ -17,11 +17,11 @@
 from dataclasses import dataclass
 from pathlib import Path
 
-from claude_agent_sdk import ClaudeAgentOptions, ResultMessage, query
-
+from acumen.agents import AgentOptions, AgentResult, provider_for_model, run_agent
 from acumen.config import Config
 from acumen.env import AuthMode, Target, build_agent_env
 from acumen.logs import LiveLog
+from acumen.prices import PriceTable, price_usage, pricer, resolve_cost
 from acumen.procs import label_env, reap
 from acumen.prompts import draft_prompt
 from acumen.skills import (
@@ -44,7 +44,7 @@ class DraftResult:
     """A drafted skill version and what it cost to produce."""
 
     skill: Skill
-    cost_usd: float
+    cost_usd: float | None
     turns: int
     #: Live log paths for this run, when a :class:`LiveLog` was attached.
     log_jsonl: Path | None = None
@@ -70,6 +70,7 @@ async def draft_skill(
     target: Target,
     skills_root: Path,
     auth_mode: AuthMode = "session",
+    prices: PriceTable | None = None,
     model: str | None = None,
     max_turns: int | None = None,
     max_usd: float | None = None,
@@ -119,7 +120,10 @@ async def draft_skill(
         work = holder / "work"
         staging = work / version
         home = holder / "home"
-        config_dir = home / ".claude"
+        selected_model = model or cfg.draft_model
+        table = prices if prices is not None else PriceTable(overrides=cfg.prices)
+        provider = provider_for_model(selected_model)
+        config_dir = home / (".claude" if provider == "claude" else ".codex")
         for path in (staging, home, config_dir, home / "tmp"):
             path.mkdir(parents=True, exist_ok=True)
 
@@ -131,6 +135,7 @@ async def draft_skill(
                 extra_path=[target.bin_dir],
                 auth_mode=auth_mode,
                 extra_allow=cfg.env_passthrough,
+                provider=provider,
             ),
             holder,
         )
@@ -144,29 +149,30 @@ async def draft_skill(
             skill_name=cfg.skill_name,
             feedback=feedback,
         )
-        options = ClaudeAgentOptions(
-            cwd=str(work),
+        options = AgentOptions(
+            cwd=work,
             env=env,
-            model=model or cfg.draft_model,
+            model=selected_model,
             # No default turn or budget cap: only bound the agent if the caller asked. The
             # config's ``max_turns``/``max_usd`` cap benchmark agents only.
             max_turns=max_turns,
-            max_budget_usd=max_usd,
+            max_usd=max_usd,
+            # Codex reports no billed figure, so a budget cap needs the run's own rate table.
+            price_usd=pricer(selected_model, table),
             # The drafter reads the target source; benchmark agents never do.
-            add_dirs=[str(target.src_dir)],
-            setting_sources=["project"],
-            permission_mode="bypassPermissions",
-            system_prompt={"type": "preset", "preset": "claude_code"},
+            read_dirs=(target.src_dir, target.venv_dir),
+            write_dirs=(work,),
+            discover_skills=True,
         )
 
-        result: ResultMessage | None = None
+        result: AgentResult | None = None
         agent_error: Exception | None = None
         try:
-            async for message in query(prompt=prompt, options=options):
-                if log is not None:
-                    log.append(message)
-                if isinstance(message, ResultMessage):
-                    result = message
+            result = await run_agent(
+                prompt,
+                options=options,
+                on_event=log.append if log is not None else None,
+            )
         except Exception as err:  # noqa: BLE001 - a failed draft is an error to report, re-raised below
             agent_error = err
         finally:
@@ -191,7 +197,15 @@ async def draft_skill(
         skill = load_skill(skills_root, version, expect_name=cfg.skill_name)
         return DraftResult(
             skill=skill,
-            cost_usd=result.total_cost_usd or 0.0,
+            cost_usd=resolve_cost(
+                result.total_cost_usd,
+                price_usage(
+                    result.usage,
+                    model=selected_model,
+                    provider=result.provider,
+                    prices=table,
+                ),
+            ).cost_usd,
             turns=result.num_turns,
             log_jsonl=log.jsonl_path if log is not None else None,
             log_html=log.html_path if log is not None and log.html_rendered else None,
diff --git a/src/acumen/env.py b/src/acumen/env.py
index 67dc0b3..e0a447d 100644
--- a/src/acumen/env.py
+++ b/src/acumen/env.py
@@ -4,7 +4,8 @@
 
 * :func:`prepare_target` — clone (or adopt a local path), build one venv with the target
   package installed, and record the resolved commit and package version. Cached by
-  (repo, ref) so a pass doesn't re-clone.
+  (repo, ref, dependency selection) so a pass doesn't re-clone, but changing what gets
+  installed does rebuild.
 * :func:`scrubbed_env` — the filtered environment benchmark agents run under: auth and
   PATH only, a throwaway ``HOME`` and ``CLAUDE_CONFIG_DIR``, and nothing that could leak
   the user's own settings or memories into a run.
@@ -24,6 +25,7 @@
 from pathlib import Path
 from typing import Literal
 
+from acumen.agents import AgentProvider
 from acumen.config import Config
 from acumen.paths import slugify
 
@@ -49,6 +51,9 @@
     "ANTHROPIC_VERTEX_PROJECT_ID",
     "CLOUD_ML_REGION",
     "GOOGLE_APPLICATION_CREDENTIALS",
+    "CODEX_API_KEY",
+    "OPENAI_API_KEY",
+    "OPENAI_BASE_URL",
     "HTTP_PROXY",
     "HTTPS_PROXY",
     "NO_PROXY",
@@ -102,9 +107,23 @@ def _run(cmd: list[str], *, cwd: Path | None = None) -> str:
     return proc.stdout.strip()
 
 
-def cache_key(repo: str, ref: str) -> str:
-    """Return the cache directory name for a (repo, ref) pair."""
-    digest = hashlib.sha256(f"{repo}\n{ref}".encode()).hexdigest()[:12]
+def cache_key(
+    repo: str,
+    ref: str,
+    *,
+    extras: Sequence[str] = (),
+    dependency_groups: Sequence[str] = (),
+    pip_packages: Sequence[str] = (),
+) -> str:
+    """Return the cache directory name for a target and its dependency selection.
+
+    The selection is part of the key because it changes what lands in the venv: editing
+    ``extras`` or ``dependency_groups`` has to rebuild rather than silently reuse a venv
+    built from the previous selection. Each list is sorted first, so reordering a config
+    list is not a rebuild.
+    """
+    selection = "\n".join(",".join(sorted(names)) for names in (extras, dependency_groups, pip_packages))
+    digest = hashlib.sha256(f"{repo}\n{ref}\n{selection}".encode()).hexdigest()[:12]
     stem = slugify(Path(repo.rstrip("/")).name.removesuffix(".git") or "target")
     return f"{stem}-{digest}"
 
@@ -124,20 +143,58 @@ def _resolve_commit(src_dir: Path) -> str:
         return "local"  # a local path that isn't a git checkout is still a valid target
 
 
-def _package_name(src_dir: Path) -> str:
+def _load_pyproject(src_dir: Path) -> dict:
     pyproject = src_dir / "pyproject.toml"
     if not pyproject.is_file():
         raise EnvError(f"{src_dir} has no pyproject.toml — acumen needs an installable package")
     try:
-        data = tomllib.loads(pyproject.read_text())
+        return tomllib.loads(pyproject.read_text())
     except (OSError, tomllib.TOMLDecodeError) as err:
         raise EnvError(f"cannot parse {pyproject}: {err}") from err
+
+
+def _package_name(src_dir: Path) -> str:
+    data = _load_pyproject(src_dir)
     name = data.get("project", {}).get("name")
     if not name:
-        raise EnvError(f"{pyproject} does not declare [project].name")
+        raise EnvError(f"{src_dir / 'pyproject.toml'} does not declare [project].name")
     return str(name)
 
 
+def _validate_deps(src_dir: Path, cfg: Config) -> None:
+    """Reject extras and dependency groups the target does not declare.
+
+    Both mechanisms fail quietly otherwise: uv only *warns* about an extra that a package
+    does not provide and still exits 0, so a typo — or an extra that is really a PEP 735
+    group — silently yields a venv missing everything that was asked for. The two are easy
+    to confuse, so when a name is declared as the other kind the error says which key to use.
+    """
+    data = _load_pyproject(src_dir)
+    extras = set(data.get("project", {}).get("optional-dependencies", {}))
+    groups = set(data.get("dependency-groups", {}))
+
+    def _available(declared: set[str], label: str) -> str:
+        return f"available {label}: {', '.join(sorted(declared))}" if declared else f"the target declares no {label}"
+
+    for name in cfg.extras:
+        if name in extras:
+            continue
+        if name in groups:
+            raise EnvError(
+                f"{name!r} is a dependency group, not an extra — use dependency_groups: [{name}]. "
+                "Extras live in [project.optional-dependencies] and are published in package "
+                "metadata; PEP 735 groups live in [dependency-groups] and never leave the source tree."
+            )
+        raise EnvError(f"{name!r} is not an extra of the target; {_available(extras, 'extras')}")
+
+    for name in cfg.dependency_groups:
+        if name in groups:
+            continue
+        if name in extras:
+            raise EnvError(f"{name!r} is an extra, not a dependency group — use extras: [{name}].")
+        raise EnvError(f"{name!r} is not a dependency group of the target; {_available(groups, 'dependency groups')}")
+
+
 def _installed_version(python: Path, pkg_name: str) -> str:
     code = f"import importlib.metadata as m; print(m.version({pkg_name!r}))"
     try:
@@ -152,9 +209,10 @@ def prepare_target(cfg: Config, cache_root: Path, *, refresh: bool = False) -> T
     Parameters
     ----------
     cfg
-        The pass config; supplies ``repo``, ``ref``, ``extras`` and ``python``.
+        The pass config; supplies ``repo``, ``ref``, ``python`` and the dependency
+        selection (``extras``, ``dependency_groups``, ``pip_packages``).
     cache_root
-        Directory to hold checkouts and venvs, keyed by (repo, ref).
+        Directory to hold checkouts and venvs, keyed by (repo, ref, dependency selection).
     refresh
         Rebuild even if a ready-marked cache entry exists.
 
@@ -164,7 +222,13 @@ def prepare_target(cfg: Config, cache_root: Path, *, refresh: bool = False) -> T
     """
     if shutil.which("uv") is None:
         raise EnvError("uv is not on PATH — acumen uses it to build the target venv")
-    entry = cache_root / cache_key(cfg.repo, cfg.ref)
+    entry = cache_root / cache_key(
+        cfg.repo,
+        cfg.ref,
+        extras=cfg.extras,
+        dependency_groups=cfg.dependency_groups,
+        pip_packages=cfg.pip_packages,
+    )
     venv_dir = entry / "venv"
     marker = entry / READY_MARKER
 
@@ -197,6 +261,9 @@ def prepare_target(cfg: Config, cache_root: Path, *, refresh: bool = False) -> T
     if not cfg.is_local:
         _clone(cfg.repo, cfg.ref, src_dir)
 
+    # Before the venv, so an unsatisfiable selection costs nothing but the checkout.
+    _validate_deps(src_dir, cfg)
+
     entry.mkdir(parents=True, exist_ok=True)
     if venv_dir.exists():
         shutil.rmtree(venv_dir)
@@ -207,7 +274,12 @@ def prepare_target(cfg: Config, cache_root: Path, *, refresh: bool = False) -> T
     if cfg.extras:
         spec = f"{src_dir}[{','.join(cfg.extras)}]"
     python = venv_dir / ("Scripts" if os.name == "nt" else "bin") / ("python.exe" if os.name == "nt" else "python")
-    _run(["uv", "pip", "install", "--python", str(python), spec])
+    install = ["uv", "pip", "install", "--python", str(python), spec, *cfg.pip_packages]
+    # Groups must be path-qualified: a bare --group resolves against the *cwd's* pyproject,
+    # and _run does not set one.
+    for group in cfg.dependency_groups:
+        install += ["--group", f"{src_dir / 'pyproject.toml'}:{group}"]
+    _run(install)
 
     target = Target(
         source=cfg.repo,
@@ -238,6 +310,17 @@ def claude_cli_dir() -> Path | None:
     return Path(found).parent if found else None
 
 
+def codex_cli_dir() -> Path | None:
+    """Return the directory holding the ``codex`` CLI."""
+    found = shutil.which("codex")
+    return Path(found).parent if found else None
+
+
+def agent_cli_dir(provider: AgentProvider) -> Path | None:
+    """Return the directory holding the selected provider's CLI."""
+    return claude_cli_dir() if provider == "claude" else codex_cli_dir()
+
+
 #: Allowlisted variables that, present and non-empty, let a run authenticate on their own:
 #: a direct Anthropic key/token, or a flag routing to a cloud provider whose own (AWS/GCP)
 #: credentials then apply. A subset of :data:`ENV_ALLOWLIST` — the entries that carry or
@@ -250,9 +333,9 @@ def claude_cli_dir() -> Path | None:
     "CLAUDE_CODE_USE_VERTEX",
 )
 
-#: A resolved authentication mode for an agent run. ``"session"`` bills the user's Claude
-#: subscription via an OAuth login; ``"api"`` bills the Anthropic API (or a cloud provider)
-#: per token — the only mode that yields the real ``cost_usd`` the benchmark records.
+#: A resolved authentication mode for an agent run. ``"session"`` uses the provider's stored
+#: account/subscription login; ``"api"`` uses a metered API credential. Acumen derives
+#: ``cost_usd`` from tokens in either mode, and records the mode so its meaning stays explicit.
 AuthMode = Literal["session", "api"]
 
 #: Allowlisted variables that carry *metered* (API/cloud) authentication, as distinct from a
@@ -270,6 +353,8 @@ def claude_cli_dir() -> Path | None:
 #: Kept in ``"session"`` mode and dropped in ``"api"`` mode so exactly one auth path is live.
 SESSION_AUTH_ENV_VAR = "CLAUDE_CODE_OAUTH_TOKEN"
 
+CODEX_API_AUTH_ENV_VARS = ("CODEX_API_KEY", "OPENAI_API_KEY")
+
 
 def _credentials_path() -> Path:
     """The user's Claude OAuth credentials file — what :func:`seed_credentials` copies."""
@@ -277,36 +362,36 @@ def _credentials_path() -> Path:
     return Path(base) / ".credentials.json"
 
 
-def auth_available() -> bool:
-    """Whether an agent run could authenticate to the Claude API.
+def _codex_home() -> Path:
+    """The user's real Codex home, which contains ``auth.json``."""
+    return Path(os.environ.get("CODEX_HOME") or Path.home() / ".codex")
 
-    A run gets its credential one of two ways: an allowlisted auth variable in the
-    environment (a direct Anthropic key/token, or a Bedrock/Vertex routing flag whose own
-    cloud credentials then apply), or a Claude credentials file that
-    :func:`seed_credentials` copies into the throwaway config dir (an OAuth login). An
-    empty variable does not count.
-    """
-    if any(os.environ.get(var) for var in AUTH_ENV_VARS):
-        return True
-    return _credentials_path().is_file()
 
+def _codex_credentials_path() -> Path:
+    return _codex_home() / "auth.json"
 
-def check_auth() -> None:
-    """Raise :class:`EnvError` if no credential is reachable for an agent run.
 
-    A preflight guard for the agentic commands. Without it an unauthenticated ``bench``
-    would run the whole matrix, record every run as an ``error``, and still exit 0, while
-    the meta-agents (``draft``/``improve``/``tasks``/``ship``) would fail deep in the SDK
-    with a raw message — so fail early, before the costly target prep, with a clear fix.
+def _codex_persisted_auth_mode() -> AuthMode | None:
+    """Classify the credential stored by ``codex login``, without exposing its value.
+
+    Both account and API-key logins write ``auth.json``. The file's existence therefore
+    cannot distinguish subscription usage from metered API usage: recent Codex versions
+    identify API-key login with ``auth_mode: apikey`` and account login with
+    ``auth_mode: chatgpt``. The payload shapes are retained as compatibility fallbacks.
+    Unknown or unreadable files are not guessed at.
     """
-    if auth_available():
-        return
-    raise EnvError(
-        "no Claude credentials found — an agent run cannot authenticate. Set "
-        "ANTHROPIC_API_KEY (or ANTHROPIC_AUTH_TOKEN / CLAUDE_CODE_OAUTH_TOKEN), enable a "
-        "provider with CLAUDE_CODE_USE_BEDROCK / CLAUDE_CODE_USE_VERTEX, or log in with "
-        "`claude` so ~/.claude/.credentials.json exists."
-    )
+    try:
+        data = json.loads(_codex_credentials_path().read_text())
+    except (OSError, ValueError):
+        return None
+    if not isinstance(data, dict):
+        return None
+    mode = data.get("auth_mode")
+    if mode == "apikey" or data.get("OPENAI_API_KEY"):
+        return "api"
+    if mode == "chatgpt" or isinstance(data.get("tokens"), dict):
+        return "session"
+    return None
 
 
 def _has_oauth_credentials() -> bool:
@@ -324,66 +409,68 @@ def _has_oauth_credentials() -> bool:
     return isinstance(data.get("claudeAiOauth"), dict)
 
 
-def session_auth_available() -> bool:
+def session_auth_available(provider: AgentProvider = "claude") -> bool:
     """Whether an agent run could bill the Claude subscription ("session usage").
 
-    True when a portable ``CLAUDE_CODE_OAUTH_TOKEN`` is set, or the user has a subscription
-    OAuth login on disk (:func:`_has_oauth_credentials`). An empty variable does not count.
+    For Claude, true when a portable ``CLAUDE_CODE_OAUTH_TOKEN`` is set or a subscription
+    OAuth login is on disk. For Codex, true only for an account login in ``auth.json``; a
+    persisted API-key login is deliberately not a session. An empty variable does not count.
     """
+    if provider == "codex":
+        return _codex_persisted_auth_mode() == "session"
     if os.environ.get(SESSION_AUTH_ENV_VAR):
         return True
     return _has_oauth_credentials()
 
 
-def api_auth_available() -> bool:
+def api_auth_available(provider: AgentProvider = "claude") -> bool:
     """Whether an agent run could bill the Anthropic API (or a cloud provider) per token.
 
     True when any metered auth variable is set (:data:`API_AUTH_ENV_VARS`): a direct
     Anthropic key/token, or a Bedrock/Vertex routing flag whose own cloud credentials then
-    apply. The subscription OAuth token is deliberately excluded — it bills the plan, not
-    the API. An empty variable does not count.
+    apply. A Codex API key persisted by ``codex login --with-api-key`` also counts. The
+    subscription OAuth token is deliberately excluded — it bills the plan, not the API.
     """
-    return any(os.environ.get(var) for var in API_AUTH_ENV_VARS)
+    variables = API_AUTH_ENV_VARS if provider == "claude" else CODEX_API_AUTH_ENV_VARS
+    available = any(os.environ.get(var) for var in variables)
+    return available or (provider == "codex" and _codex_persisted_auth_mode() == "api")
 
 
-def resolve_auth_mode(requested: str, *, allow_session: bool) -> AuthMode:
+def resolve_auth_mode(
+    requested: str,
+    *,
+    provider: AgentProvider = "claude",
+) -> AuthMode:
     """Resolve a requested auth choice to the concrete mode a run will use, or fail loudly.
 
-    A preflight guard that replaces :func:`check_auth` on the agentic commands: it both
-    validates that the chosen credential is actually reachable and reports which mode the
-    run will bill, so the choice is never silent.
+    A preflight guard for every agentic command: it both validates that the chosen credential
+    is actually reachable and reports which mode the run will bill, so the choice is never
+    silent.
+
+    ``bench`` used to be barred from ``"session"`` on the grounds that only metered API billing
+    yields a real per-run ``cost_usd``. That stopped being true when cost became a function of
+    the token counts both billing modes report (:mod:`acumen.prices`): a subscription run prices
+    exactly as accurately as a metered one. What the figure *means* does change — under
+    ``"session"`` it is what the run would have cost at API rates, not money billed — so the
+    mode is recorded in each ``result.json`` rather than the choice being taken away.
 
     Parameters
     ----------
     requested
         The user's choice: ``"auto"`` (prefer the subscription, else the API), ``"session"``
         (force the subscription), or ``"api"`` (force the API).
-    allow_session
-        Whether the subscription is a permitted mode. ``bench`` passes ``False`` because it
-        records real per-run ``cost_usd``, which only means anything under metered API
-        billing — so bench always resolves to ``"api"`` and rejects ``"session"``.
 
     Returns
     -------
     ``"session"`` or ``"api"``.
     """
-    if not allow_session:
-        if requested == "session":
-            raise EnvError(
-                "bench records real per-run cost and must bill the API, so --auth session is "
-                "not available for it — the Claude subscription does not meter per-run spend. "
-                "Run the single-agent commands (draft/improve/tasks/ship) on the session instead."
-            )
-        if not api_auth_available():
-            raise EnvError(
-                "no API credential found — bench must bill the API. Set ANTHROPIC_API_KEY (or "
-                "ANTHROPIC_AUTH_TOKEN), or enable a provider with CLAUDE_CODE_USE_BEDROCK / "
-                "CLAUDE_CODE_USE_VERTEX."
-            )
-        return "api"
-
     if requested == "session":
-        if not session_auth_available():
+        if not session_auth_available(provider):
+            if provider == "codex":
+                raise EnvError(
+                    "no Codex account login found for --auth session. Log in with `codex login` "
+                    "so ~/.codex/auth.json exists."
+                )
             raise EnvError(
                 "no Claude subscription login found for --auth session. Log in with `claude` so "
                 "~/.claude/.credentials.json exists, or set CLAUDE_CODE_OAUTH_TOKEN (from "
@@ -391,7 +478,9 @@ def resolve_auth_mode(requested: str, *, allow_session: bool) -> AuthMode:
             )
         return "session"
     if requested == "api":
-        if not api_auth_available():
+        if not api_auth_available(provider):
+            if provider == "codex":
+                raise EnvError("no API credential found for --auth api. Set CODEX_API_KEY (or OPENAI_API_KEY).")
             raise EnvError(
                 "no API credential found for --auth api. Set ANTHROPIC_API_KEY (or "
                 "ANTHROPIC_AUTH_TOKEN), or enable a provider with CLAUDE_CODE_USE_BEDROCK / "
@@ -401,10 +490,15 @@ def resolve_auth_mode(requested: str, *, allow_session: bool) -> AuthMode:
 
     # "auto": prefer the subscription (it's what the user is paying a flat rate for), fall
     # back to the metered API, and only then give up.
-    if session_auth_available():
+    if session_auth_available(provider):
         return "session"
-    if api_auth_available():
+    if api_auth_available(provider):
         return "api"
+    if provider == "codex":
+        raise EnvError(
+            "no Codex credentials found — log in with `codex login` (subscription), "
+            "or set CODEX_API_KEY / OPENAI_API_KEY (API)."
+        )
     raise EnvError(
         "no Claude credentials found — an agent run cannot authenticate. Log in with `claude` "
         "so ~/.claude/.credentials.json exists (subscription), or set ANTHROPIC_API_KEY (or "
@@ -435,13 +529,36 @@ def seed_credentials(config_dir: Path) -> bool:
     return True
 
 
-def _apply_auth_mode(env: dict[str, str], auth_mode: AuthMode | None) -> None:
-    """Neutralize the credential variables the chosen mode must not authenticate with.
+def seed_codex_credentials(config_dir: Path) -> bool:
+    """Copy only Codex's login token into an isolated ``CODEX_HOME``."""
+    real = _codex_credentials_path()
+    if not real.is_file():
+        return False
+    config_dir.mkdir(parents=True, exist_ok=True)
+    dest = config_dir / "auth.json"
+    shutil.copyfile(real, dest)
+    dest.chmod(0o600)
+    return True
+
+
+def _apply_auth_mode(
+    env: dict[str, str],
+    auth_mode: AuthMode | None,
+    provider: AgentProvider = "claude",
+) -> None:
+    """Neutralize the credential variables the chosen provider and mode must not authenticate with.
+
+    Two rules, in order. First, the *other* provider's credentials are blanked whatever the
+    mode: they can never authenticate this run, so allowlisting them would only carry the
+    operator's second API key into a web-enabled agent. Second, within the selected provider
+    exactly one auth path is left live: ``"session"`` neutralizes the metered API/cloud
+    variables and keeps the subscription login; ``"api"`` neutralizes the OAuth token and keeps
+    the metered ones. ``None`` leaves the selected provider's own credentials untouched (the
+    historical behavior, for callers that don't select a mode).
 
-    So exactly one auth path is live: ``"session"`` neutralizes the metered API/cloud variables
-    and keeps the subscription OAuth token; ``"api"`` neutralizes the OAuth token and keeps the
-    metered ones. ``None`` leaves the allowlisted credentials untouched (the historical
-    behavior, for callers that don't select a mode).
+    Codex has no session *variable* — its subscription login is the ``auth.json`` that
+    :func:`seed_codex_credentials` copies into the throwaway ``CODEX_HOME`` — so ``"session"``
+    there just blanks the API keys.
 
     The variables are set to ``""``, not deleted. The SDK builds the agent subprocess env as
     ``{**os.environ, **options.env}`` — it merges our mapping *over* the inherited environment —
@@ -449,14 +566,22 @@ def _apply_auth_mode(env: dict[str, str], auth_mode: AuthMode | None) -> None:
     silently authenticates with the wrong one. An explicit empty value overrides the inherited
     one, which the CLI reads as unset.
     """
-    if auth_mode == "session":
-        drop = API_AUTH_ENV_VARS
-    elif auth_mode == "api":
-        drop = (SESSION_AUTH_ENV_VAR,)
+    if provider == "claude":
+        drop = [*CODEX_API_AUTH_ENV_VARS]
+        if auth_mode == "session":
+            drop += API_AUTH_ENV_VARS
+        elif auth_mode == "api":
+            drop.append(SESSION_AUTH_ENV_VAR)
     else:
-        return
+        drop = [*API_AUTH_ENV_VARS, SESSION_AUTH_ENV_VAR]
+        if auth_mode == "session":
+            drop += CODEX_API_AUTH_ENV_VARS
     for var in drop:
         env[var] = ""
+    if provider == "codex" and auth_mode == "api":
+        # ``codex exec`` consumes CODEX_API_KEY. Accept the conventional OpenAI variable too
+        # and translate it here, without mutating the operator's shell.
+        env["CODEX_API_KEY"] = os.environ.get("CODEX_API_KEY") or os.environ.get("OPENAI_API_KEY", "")
 
 
 def scrubbed_env(
@@ -466,6 +591,7 @@ def scrubbed_env(
     extra_path: list[Path] | None = None,
     auth_mode: AuthMode | None = None,
     extra_allow: Sequence[str] | None = None,
+    provider: AgentProvider = "claude",
 ) -> dict[str, str]:
     """Build the environment an isolated agent runs under.
 
@@ -508,10 +634,10 @@ def scrubbed_env(
     """
     allow = (*ENV_ALLOWLIST, *(extra_allow or ()))
     env = {key: os.environ[key] for key in allow if key in os.environ}
-    _apply_auth_mode(env, auth_mode)
+    _apply_auth_mode(env, auth_mode, provider)
 
     path_parts = [str(p) for p in (extra_path or [])]
-    cli_dir = claude_cli_dir()
+    cli_dir = agent_cli_dir(provider)
     if cli_dir is not None:
         path_parts.append(str(cli_dir))
     node_dir = shutil.which("node")
@@ -526,6 +652,7 @@ def scrubbed_env(
     env["PATH"] = os.pathsep.join(seen)
     env["HOME"] = str(home)
     env["CLAUDE_CONFIG_DIR"] = str(config_dir)
+    env["CODEX_HOME"] = str(config_dir)
     # Skill discovery needs setting_sources=["project"], but project discovery
     # also walks UP from cwd and auto-loads every CLAUDE.md it passes. Verified: an agent
     # recited a canary planted in its sandbox's parent directory having made zero tool
@@ -557,24 +684,33 @@ def build_agent_env(
     extra_path: list[Path] | None = None,
     auth_mode: AuthMode,
     extra_allow: Sequence[str] | None = None,
+    provider: AgentProvider = "claude",
 ) -> dict[str, str]:
     """Prepare an isolated agent's environment for a resolved auth mode.
 
-    Pairs the two steps that must agree: in ``"session"`` mode the subscription OAuth login is
-    seeded into ``config_dir`` (only ``.credentials.json`` is copied — never settings, memories,
-    or skills, so isolation is unchanged), and the API/cloud variables are stripped from the
-    env; in ``"api"`` mode nothing is seeded and the OAuth token is stripped instead. Either
-    way exactly one credential reaches the run, so billing is deterministic.
+    Pairs the two steps that must agree. Claude seeds its subscription OAuth login only in
+    ``"session"`` mode. Codex stores both account and API-key logins in ``auth.json``, so the
+    file is seeded only when its classified mode matches ``auth_mode``. Environment credentials
+    for the other mode are stripped either way, keeping billing deterministic.
 
     Every isolated agent (bench sandboxes and the draft/improve/tasks meta-agents) builds its
     env through here, so the seed-and-scrub pairing lives in one place. ``extra_allow`` (the
     operator's ``env_passthrough``) names variables to carry through on top of the built-in
     allowlist, for a target that needs one at runtime.
     """
-    if auth_mode == "session":
+    if provider == "claude" and auth_mode == "session":
         seed_credentials(config_dir)
+    elif provider == "codex" and _codex_persisted_auth_mode() == auth_mode:
+        # Codex stores either account tokens or an API key in auth.json. Copy only the
+        # credential matching the resolved mode into the isolated CODEX_HOME.
+        seed_codex_credentials(config_dir)
     return scrubbed_env(
-        config_dir=config_dir, home=home, extra_path=extra_path, auth_mode=auth_mode, extra_allow=extra_allow
+        config_dir=config_dir,
+        home=home,
+        extra_path=extra_path,
+        auth_mode=auth_mode,
+        extra_allow=extra_allow,
+        provider=provider,
     )
 
 
@@ -588,13 +724,28 @@ def _default_cache_root() -> Path:
 
 
 def sdk_version() -> str:
-    """Return the installed ``claude-agent-sdk`` version, for the run fingerprint."""
+    """Return the installed ``claude-agent-sdk`` version, for the run fingerprint.
+
+    ``"unknown"`` on a Codex-only install, where the SDK is deliberately absent — the
+    fingerprint records what drove the run, and nothing Claude drove can be recorded here.
+    """
     from importlib.metadata import PackageNotFoundError, version
 
     try:
         return version("claude-agent-sdk")
-    except PackageNotFoundError:  # pragma: no cover - the SDK is a hard dependency
+    except PackageNotFoundError:
+        return "unknown"
+
+
+def agent_version(provider: AgentProvider) -> str:
+    """Return the installed provider runtime version for run fingerprints."""
+    if provider == "claude":
+        return sdk_version()
+    try:
+        output = _run(["codex", "--version"])
+    except EnvError:
         return "unknown"
+    return output.removeprefix("codex-cli ").strip()
 
 
 def python_version() -> str:
diff --git a/src/acumen/grade.py b/src/acumen/grade.py
index a5336fa..0a7cc24 100644
--- a/src/acumen/grade.py
+++ b/src/acumen/grade.py
@@ -16,7 +16,16 @@
 
 from acumen.paths import ANSWER_FILE
 
-Reason = Literal["ok", "wrong_answer", "format_error", "no_answer_file", "budget", "max_turns", "error"]
+Reason = Literal[
+    "ok",
+    "wrong_answer",
+    "format_error",
+    "no_answer_file",
+    "budget",
+    "max_turns",
+    "error",
+    "provider_exhausted",
+]
 
 _FENCE_RE = re.compile(r"^\s*```[^\n]*\n(?P<body>.*?)\n?\s*```\s*$", re.DOTALL)
 _HEADER_LINE_RE = re.compile(r"^\s*#+\s")
diff --git a/src/acumen/improve.py b/src/acumen/improve.py
index 9422a46..f64af0a 100644
--- a/src/acumen/improve.py
+++ b/src/acumen/improve.py
@@ -9,7 +9,7 @@
 
 1. **Structurally.** The agent's ``cwd`` is a throwaway work dir and its readable material
    is a *curated copy* of train-split runs. The real ``runs/`` tree is not on its ``cwd``,
-   not in ``add_dirs``, and not in scope — so there is no test directory to reach in the
+   not in the read-only roots, and not in scope — so there is no test directory to reach in the
    first place.
 2. **Belt-and-braces.** A ``PreToolUse`` hook denies any tool call whose path resolves under
    a ``runs/*/test/`` subtree, so even a call that names an absolute path back into the
@@ -25,10 +25,12 @@
 import tempfile
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
-from claude_agent_sdk import ClaudeAgentOptions, HookMatcher, ResultMessage, query
+if TYPE_CHECKING:
+    from claude_agent_sdk import HookMatcher
 
+from acumen.agents import AgentOptions, AgentResult, provider_for_model, run_agent
 from acumen.config import Config
 from acumen.env import AuthMode, Target, build_agent_env
 from acumen.logs import LiveLog
@@ -41,6 +43,7 @@
     arm_name,
     parse_run_dir,
 )
+from acumen.prices import PriceTable, price_usage, pricer, resolve_cost
 from acumen.procs import label_env, reap
 from acumen.prompts import improve_prompt
 from acumen.skills import (
@@ -101,7 +104,7 @@ class ImproveResult:
 
     skill: Skill
     parent: str
-    cost_usd: float
+    cost_usd: float | None
     turns: int
     n_train_runs: int
     n_train_failures: int
@@ -144,6 +147,11 @@ def collect_train_runs(runs_root: Path, arm: str, tasks: list[Task]) -> list[Tra
             data = json.loads(result_path.read_text())
         except (OSError, ValueError) as err:
             raise ImproveError(f"cannot read {result_path}: {err}") from err
+        if data.get("valid", True) is False:
+            raise ImproveError(
+                "cannot improve from an infrastructure-invalid benchmark result: "
+                f"{result_path}. Replenish the provider credential and resume the benchmark first."
+            )
         key = parse_run_dir(runs_root, result_path.parent)
         task = by_id.get(key.task_id)
         if task is None:
@@ -348,6 +356,10 @@ def make_test_guard(runs_root: Path) -> HookMatcher:
     ``matcher=None`` fires the hook for every tool. The hook resolves paths against the real
     project ``runs/`` root, so it holds regardless of the agent's ``cwd``.
     """
+    # Imported here, not at module scope: the Claude SDK is an optional dependency and a
+    # Codex-only install never builds an SDK hook.
+    from claude_agent_sdk import HookMatcher
+
     root = runs_root.resolve()
 
     async def guard(input_data: dict[str, Any], tool_use_id: str | None, context: Any) -> dict[str, Any]:
@@ -409,6 +421,7 @@ async def improve_skill(
     runs_root: Path,
     tasks: list[Task],
     auth_mode: AuthMode = "session",
+    prices: PriceTable | None = None,
     parent_version: str | None = None,
     model: str | None = None,
     max_turns: int | None = None,
@@ -475,7 +488,10 @@ async def improve_skill(
         train_dir = work / "train"
         rationale_path = work / "rationale.md"
         home = holder / "home"
-        config_dir = home / ".claude"
+        selected_model = model or cfg.improve_model
+        table = prices if prices is not None else PriceTable(overrides=cfg.prices)
+        provider = provider_for_model(selected_model)
+        config_dir = home / (".claude" if provider == "claude" else ".codex")
         for path in (work, home, config_dir, home / "tmp"):
             path.mkdir(parents=True, exist_ok=True)
 
@@ -490,6 +506,7 @@ async def improve_skill(
                 extra_path=[target.bin_dir],
                 auth_mode=auth_mode,
                 extra_allow=cfg.env_passthrough,
+                provider=provider,
             ),
             holder,
         )
@@ -506,30 +523,36 @@ async def improve_skill(
             new_version=new_version,
             feedback=feedback,
         )
-        options = ClaudeAgentOptions(
-            cwd=str(work),
+        options = AgentOptions(
+            cwd=work,
             env=env,
-            model=model or cfg.improve_model,
+            model=selected_model,
             # No default turn or budget cap: only bound the agent if the caller asked. The
             # config's ``max_turns``/``max_usd`` cap benchmark agents only.
             max_turns=max_turns,
-            max_budget_usd=max_usd,
-            setting_sources=["project"],
-            permission_mode="bypassPermissions",
-            system_prompt={"type": "preset", "preset": "claude_code"},
+            max_usd=max_usd,
+            # Codex reports no billed figure, so a budget cap needs the run's own rate table.
+            price_usd=pricer(selected_model, table),
+            read_dirs=(target.venv_dir,),
+            write_dirs=(work,),
+            discover_skills=True,
             # Belt-and-braces over the structural isolation: refuse any call that reaches a
-            # held-out test result, wherever the agent points it.
-            hooks={"PreToolUse": [make_test_guard(runs_root)]},
+            # held-out test result, wherever the agent points it. Built only for Claude — the
+            # hook is an SDK object, and Codex gets the equivalent from ``deny_paths`` below.
+            claude_hooks={"PreToolUse": [make_test_guard(runs_root)]} if provider == "claude" else None,
+            # Codex gets only the staged train evidence and is denied the original
+            # run tree wholesale, which includes every held-out test artifact.
+            deny_paths=(runs_root.resolve(),),
         )
 
-        result: ResultMessage | None = None
+        result: AgentResult | None = None
         agent_error: Exception | None = None
         try:
-            async for message in query(prompt=prompt, options=options):
-                if log is not None:
-                    log.append(message)
-                if isinstance(message, ResultMessage):
-                    result = message
+            result = await run_agent(
+                prompt,
+                options=options,
+                on_event=log.append if log is not None else None,
+            )
         except Exception as err:  # noqa: BLE001 - a failed improve is an error to report, re-raised below
             agent_error = err
         finally:
@@ -558,7 +581,15 @@ async def improve_skill(
         return ImproveResult(
             skill=skill,
             parent=parent.version,
-            cost_usd=result.total_cost_usd or 0.0,
+            cost_usd=resolve_cost(
+                result.total_cost_usd,
+                price_usage(
+                    result.usage,
+                    model=selected_model,
+                    provider=result.provider,
+                    prices=table,
+                ),
+            ).cost_usd,
             turns=result.num_turns,
             n_train_runs=len(train_runs),
             n_train_failures=n_failures,
@@ -580,7 +611,7 @@ def _latest_or_error(skills_root: Path) -> str:
     return latest
 
 
-def _read_rationale(path: Path, result: ResultMessage, parent: str, new_version: str) -> str:
+def _read_rationale(path: Path, result: AgentResult, parent: str, new_version: str) -> str:
     """Recover the agent's rationale for ``meta.json``.
 
     Prefers the ``rationale.md`` the prompt asks for; falls back to the agent's final
diff --git a/src/acumen/logs.py b/src/acumen/logs.py
index ecf73aa..e8bfd52 100644
--- a/src/acumen/logs.py
+++ b/src/acumen/logs.py
@@ -24,21 +24,32 @@
 import json
 from collections.abc import Callable
 from datetime import datetime
+from functools import cache
 from pathlib import Path
-from typing import Any, TextIO
+from types import ModuleType
+from typing import TYPE_CHECKING, Any, TextIO
 
-from claude_agent_sdk import (
-    AssistantMessage,
-    ResultMessage,
-    SystemMessage,
-    TextBlock,
-    ThinkingBlock,
-    ToolResultBlock,
-    ToolUseBlock,
-    UserMessage,
-)
+from acumen.agents import AgentResult
+from acumen.transcript import locate_transcript, render_codex_events, render_transcript
+
+if TYPE_CHECKING:
+    from claude_agent_sdk import AssistantMessage, ResultMessage, UserMessage
+
+
+@cache
+def _sdk() -> ModuleType | None:
+    """The Claude Agent SDK, or ``None`` on a Codex-only install.
+
+    The SDK's message classes are what a Claude run is normalized from, and there is no way to
+    recognize them without importing it — but a Codex-only install has no SDK and still logs.
+    Cached because :meth:`LiveLog.append` runs once per message.
+    """
+    try:
+        import claude_agent_sdk
+    except ModuleNotFoundError:
+        return None
+    return claude_agent_sdk
 
-from acumen.transcript import locate_transcript, render_transcript
 
 #: tool_input keys, in priority order, whose value best summarizes a tool call in one line.
 _SUMMARY_KEYS = ("command", "file_path", "path", "notebook_path", "pattern", "url", "query", "description", "prompt")
@@ -140,14 +151,21 @@ def append(self, message: Any) -> None:
             for line in self._render_lines(record):
                 self._echo(line)
 
-    def finalize(self, *, config_dir: Path, work_dir: Path, result: ResultMessage | None) -> bool:
-        """Locate the run's SDK-native transcript and render the HTML log from it.
+    def finalize(self, *, config_dir: Path, work_dir: Path, result: ResultMessage | AgentResult | None) -> bool:
+        """Render the HTML log from whatever transcript the run's provider produced.
 
-        Call before the throwaway config dir is removed — the native transcript still lives under
-        it at this point. A no-op that returns ``False`` if the run produced no result.
+        Call before the throwaway config dir is removed — a Claude run's native transcript still
+        lives under it at this point. Codex writes no transcript file of its own, so its HTML is
+        rendered from the event stream carried back on the result. A no-op that returns ``False``
+        if the run produced no result.
         """
         if result is None:
             return False
+        if getattr(result, "provider", "claude") == "codex":
+            self.html_rendered = render_codex_events(getattr(result, "transcript", []), self.html_path)
+            return self.html_rendered
+        if not result.session_id:
+            return False
         native = locate_transcript(config_dir, work_dir, result.session_id)
         if native is None or not native.is_file():
             return False
@@ -168,13 +186,20 @@ def __exit__(self, *exc: object) -> None:
     # ── Normalization ──────────────────────────────────────────────────────────────────
 
     def _normalize(self, message: Any) -> dict[str, Any] | None:
-        if isinstance(message, AssistantMessage):
+        # Codex events are plain dicts, so they are recognized without the SDK — which is what
+        # lets a Codex-only install log at all.
+        if isinstance(message, dict):
+            return self._codex_event(message)
+        sdk = _sdk()
+        if sdk is None:
+            return None
+        if isinstance(message, sdk.AssistantMessage):
             return self._assistant_event(message)
-        if isinstance(message, UserMessage):
+        if isinstance(message, sdk.UserMessage):
             return self._user_event(message)
-        if isinstance(message, SystemMessage):
+        if isinstance(message, sdk.SystemMessage):
             return {"type": "system", "subtype": message.subtype}
-        if isinstance(message, ResultMessage):
+        if isinstance(message, sdk.ResultMessage):
             return {
                 "type": "result",
                 "is_error": bool(message.is_error),
@@ -186,17 +211,84 @@ def _normalize(self, message: Any) -> dict[str, Any] | None:
             }
         return None
 
+    def _codex_event(self, message: dict[str, Any]) -> dict[str, Any] | None:
+        """Normalize one event from ``codex exec --json``."""
+        kind = message.get("type")
+        if kind == "thread.started":
+            return {"type": "system", "subtype": "thread.started", "session_id": message.get("thread_id")}
+        if kind == "turn.started":
+            return {"type": "system", "subtype": "turn.started"}
+        if kind == "turn.completed":
+            usage = message.get("usage")
+            return {
+                "type": "result",
+                "is_error": False,
+                "subtype": "turn.completed",
+                "turns": 1,
+                "cost_usd": None,
+                "duration_s": None,
+                "usage": usage,
+            }
+        if kind in {"error", "turn.failed"}:
+            return {
+                "type": "result",
+                "is_error": True,
+                "subtype": kind,
+                "error": message.get("message") or message.get("error"),
+            }
+        if kind not in {"item.started", "item.updated", "item.completed"}:
+            return None
+        item = message.get("item")
+        if not isinstance(item, dict):
+            return None
+        item_type = item.get("type")
+        if item_type == "agent_message":
+            text = item.get("text")
+            return {"type": "assistant", "text": text} if text else None
+        if item_type == "reasoning":
+            text = item.get("text")
+            return {"type": "assistant", "thinking": _truncate(str(text or ""), _THINKING_CAP)}
+        if item_type == "command_execution":
+            command = str(item.get("command") or "")
+            return {
+                "type": "assistant",
+                "tools": [
+                    {
+                        "id": item.get("id"),
+                        "name": "command_execution",
+                        "summary": _truncate(" ".join(command.split()), _SUMMARY_CAP),
+                        "status": item.get("status"),
+                    }
+                ],
+            }
+        if item_type == "file_change":
+            return {
+                "type": "assistant",
+                "tools": [
+                    {
+                        "id": item.get("id"),
+                        "name": "file_change",
+                        "summary": _truncate(str(item.get("changes") or ""), _SUMMARY_CAP),
+                        "status": item.get("status"),
+                    }
+                ],
+            }
+        return None
+
     def _assistant_event(self, message: AssistantMessage) -> dict[str, Any]:
+        # Only reached from _normalize, which has already established the SDK is importable.
+        sdk = _sdk()
+        assert sdk is not None
         text_parts: list[str] = []
         thinking_parts: list[str] = []
         tools: list[dict[str, Any]] = []
         for block in message.content:
-            if isinstance(block, TextBlock):
+            if isinstance(block, sdk.TextBlock):
                 if block.text.strip():
                     text_parts.append(block.text)
-            elif isinstance(block, ThinkingBlock):
+            elif isinstance(block, sdk.ThinkingBlock):
                 thinking_parts.append(block.thinking)
-            elif isinstance(block, ToolUseBlock):
+            elif isinstance(block, sdk.ToolUseBlock):
                 self._tool_names[block.id] = block.name
                 tools.append({"id": block.id, "name": block.name, "summary": _tool_summary(block.input)})
         event: dict[str, Any] = {"type": "assistant"}
@@ -212,12 +304,14 @@ def _assistant_event(self, message: AssistantMessage) -> dict[str, Any]:
         return event
 
     def _user_event(self, message: UserMessage) -> dict[str, Any] | None:
+        sdk = _sdk()
+        assert sdk is not None
         content = message.content
         if not isinstance(content, list):
             return None  # a plain user turn (our own prompt) — nothing worth an event
         results: list[dict[str, Any]] = []
         for block in content:
-            if isinstance(block, ToolResultBlock):
+            if isinstance(block, sdk.ToolResultBlock):
                 results.append(
                     {
                         "tool_use_id": block.tool_use_id,
@@ -247,9 +341,14 @@ def _render_lines(self, event: dict[str, Any]) -> list[str]:
                 name = res.get("name") or "tool"
                 lines.append(f"  {mark} {name} ({res['chars']} chars)")
         elif kind == "result":
-            mark = "✗ error" if event["is_error"] else "● done"
-            lines.append(
-                f"{mark}: {event['subtype']} · {event['turns']} turns · "
-                f"${event['cost_usd']:.2f} · {event['duration_s']}s"
-            )
+            is_error = bool(event.get("is_error"))
+            mark = "✗ error" if is_error else "● done"
+            parts = [str(event.get("subtype") or ("error" if is_error else "completed"))]
+            if event.get("turns") is not None:
+                parts.append(f"{event['turns']} turns")
+            cost = event.get("cost_usd")
+            parts.append(f"${cost:.2f}" if isinstance(cost, int | float) else "cost n/a")
+            if event.get("duration_s") is not None:
+                parts.append(f"{event['duration_s']}s")
+            lines.append(f"{mark}: {' · '.join(parts)}")
         return lines
diff --git a/src/acumen/paths.py b/src/acumen/paths.py
index 263d1a8..89ab440 100644
--- a/src/acumen/paths.py
+++ b/src/acumen/paths.py
@@ -7,6 +7,7 @@
 
 from __future__ import annotations
 
+import json
 import re
 from dataclasses import dataclass
 from pathlib import Path
@@ -154,11 +155,15 @@ def parse_run_dir(runs_root: Path, path: Path) -> RunKey:
 def is_complete(directory: Path) -> bool:
     """Return whether a run directory holds a complete run.
 
-    A readable ``result.json`` is what marks a run done — this is the check that makes
-    resuming a pass work.
+    A readable ``result.json`` is what normally marks a run done. Infrastructure-invalid
+    results explicitly carry ``valid: false`` and remain pending, so fixing the provider
+    quota and rerunning retries them without requiring ``--no-resume``.
     """
     result = directory / RESULT_FILE
     try:
-        return result.is_file() and result.stat().st_size > 0
-    except OSError:
+        if not result.is_file() or result.stat().st_size == 0:
+            return False
+        data = json.loads(result.read_text())
+        return isinstance(data, dict) and data.get("valid", True) is not False
+    except (OSError, ValueError):
         return False
diff --git a/src/acumen/pricefeed.py b/src/acumen/pricefeed.py
new file mode 100644
index 0000000..1df7017
--- /dev/null
+++ b/src/acumen/pricefeed.py
@@ -0,0 +1,321 @@
+"""Read per-model token rates from the providers' own pricing pages.
+
+This is where acumen's rates come from. Nothing is compiled into the package: prices drift
+— OpenAI cut one tier by 80% in July 2026, and Claude Sonnet 5's introductory rate expires
+2026-08-31 — so a baked-in table is wrong from some date nobody notices, and since each
+run's cost is frozen when it is written, that wrongness is stored rather than outgrown.
+
+Two callers, with deliberately different failure behaviour:
+
+- ``acumen bench`` calls :func:`fetch_table` before it spends anything and **fails the
+  pass** if the pages cannot be read. Cost is a headline metric of the report and is
+  frozen into every result, so a benchmark that cannot establish rates has not earned the
+  numbers it would print.
+- ``draft``, ``improve``, ``tasks`` and ``ship`` call :func:`try_fetch_table`, which
+  **degrades to unpriced**. Their dollar figure is progress reporting for one interactive
+  run, not stored evidence, so losing it is worth less than losing the run.
+
+Live rates do not make a pass unreproducible: each run records the rates it used, their
+source, and their date (:func:`~acumen.prices.price_provenance`), and nothing re-prices a
+stored result afterwards.
+
+Parsing has to choose a tier (standard, not batch/flex/fast), a context band (short — the
+long-context band is priced ~2x and its threshold is not stated per model), and, for dated
+rows, which side of the date we are on. Each is a place a silent mis-parse yields a
+plausible wrong number, which is why the parsers raise rather than return partial tables.
+
+Both providers publish Markdown alongside their HTML, which is what makes this tractable:
+these are documented tables, not scraped page furniture.
+"""
+
+from __future__ import annotations
+
+import re
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+from datetime import date, datetime
+
+from acumen.prices import PriceTable, Rates
+
+#: The Markdown pricing pages. Both are the ``.md`` twin of the human docs page — append
+#: ``.md`` to a docs URL on either site.
+PRICE_SOURCES = {
+    "anthropic": "https://platform.claude.com/docs/en/about-claude/pricing.md",
+    "openai": "https://developers.openai.com/api/docs/pricing.md",
+}
+
+#: What the parsed rates mean. Recorded alongside them so the choice is never implicit.
+PRICE_TIER = "standard, short-context"
+
+
+class PriceFeedError(RuntimeError):
+    """Raised when a pricing page cannot be fetched or yields no usable rows."""
+
+
+def fetch(url: str, *, timeout: float = 30.0) -> str:
+    """Fetch one pricing page as text."""
+    request = urllib.request.Request(url, headers={"User-Agent": "acumen-pricefeed"})
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            return response.read().decode("utf-8", errors="replace")
+    except (urllib.error.URLError, TimeoutError, OSError) as err:
+        raise PriceFeedError(f"could not fetch {url}: {err}") from err
+
+
+def _cells(line: str) -> list[str]:
+    """Split one Markdown table row into trimmed cells."""
+    return [cell.strip() for cell in line.strip().strip("|").split("|")]
+
+
+def _tables(markdown: str) -> list[tuple[list[str], list[list[str]]]]:
+    """Return every Markdown table as ``(header cells, body rows)``."""
+    tables: list[tuple[list[str], list[list[str]]]] = []
+    lines = markdown.splitlines()
+    for index, line in enumerate(lines):
+        if not line.lstrip().startswith("|") or index + 1 >= len(lines):
+            continue
+        separator = lines[index + 1].strip()
+        if not re.fullmatch(r"\|[\s:|-]+\|", separator):
+            continue
+        header = _cells(line)
+        rows = []
+        for row in lines[index + 2 :]:
+            if not row.lstrip().startswith("|"):
+                break
+            rows.append(_cells(row))
+        tables.append((header, rows))
+    return tables
+
+
+def _money(cell: str) -> float | None:
+    """Parse a price cell (``$6.25 / MTok``, ``$0.02``, ``-``) to a number."""
+    match = re.search(r"\$\s*([0-9]+(?:\.[0-9]+)?)", cell)
+    return float(match.group(1)) if match else None
+
+
+_LINK = re.compile(r"\[([^\]]*)\]\([^)]*\)")
+
+
+def _model_label(cell: str) -> str:
+    """Strip Markdown links and parenthetical qualifiers from a model cell."""
+    return re.sub(r"\s+", " ", re.sub(r"\([^)]*\)", " ", _LINK.sub(r"\1", cell))).strip()
+
+
+def _slug(label: str) -> str:
+    """Turn a display name into its API model ID (``Claude Haiku 4.5`` → ``claude-haiku-4-5``)."""
+    return re.sub(r"-+", "-", re.sub(r"[^a-z0-9]+", "-", label.lower())).strip("-")
+
+
+_THROUGH = re.compile(r"\bthrough\s+([A-Z][a-z]+ \d{1,2}, \d{4})")
+_STARTING = re.compile(r"\bstarting\s+([A-Z][a-z]+ \d{1,2}, \d{4})")
+
+
+def _dated_window(label: str, today: date) -> tuple[str, bool]:
+    """Split a dated row label into its model name and whether it applies on ``today``.
+
+    Anthropic prices a promotional rate as two rows — "… through August 31, 2026" and
+    "… starting September 1, 2026". Taking whichever row parses first would silently
+    pick up a rate that is not in effect.
+    """
+    applies = True
+    for pattern, active in ((_THROUGH, lambda d: today <= d), (_STARTING, lambda d: today >= d)):
+        match = pattern.search(label)
+        if match is None:
+            continue
+        boundary = datetime.strptime(match.group(1), "%B %d, %Y").date()
+        applies = active(boundary)
+        label = label[: match.start()].strip()
+    return label, applies
+
+
+def parse_anthropic(markdown: str, *, today: date) -> dict[str, Rates]:
+    """Parse Anthropic's per-model table (base input / cache writes / cache hits / output)."""
+    rates: dict[str, Rates] = {}
+    for header, rows in _tables(markdown):
+        lowered = [cell.lower() for cell in header]
+        if not (any("base input" in c for c in lowered) and any("cache hits" in c for c in lowered)):
+            continue
+        columns = {
+            "input": next(i for i, c in enumerate(lowered) if "base input" in c),
+            "cache_write": next(i for i, c in enumerate(lowered) if "5m cache" in c),
+            "cache_write_5m": next(i for i, c in enumerate(lowered) if "5m cache" in c),
+            "cache_write_1h": next(i for i, c in enumerate(lowered) if "1h cache" in c),
+            "cached_input": next(i for i, c in enumerate(lowered) if "cache hits" in c),
+            "output": next(i for i, c in enumerate(lowered) if "output" in c),
+        }
+        for row in rows:
+            if len(row) <= max(columns.values()):
+                continue
+            label, applies = _dated_window(_model_label(row[0]), today)
+            if not applies or not label.lower().startswith("claude"):
+                continue
+            values = {name: _money(row[index]) for name, index in columns.items()}
+            if any(value is None for value in values.values()):
+                continue
+            rates[_slug(label)] = Rates(**values)  # type: ignore[arg-type]
+    if not rates:
+        raise PriceFeedError("no Claude rates found — the pricing page layout may have changed")
+    return rates
+
+
+def parse_openai(markdown: str) -> dict[str, Rates]:
+    """Parse OpenAI's standard-tier table, short-context columns only."""
+    rates: dict[str, Rates] = {}
+    for header, rows in _tables(markdown):
+        lowered = [cell.lower() for cell in header]
+        wanted = {
+            "input": "short context input",
+            "cached_input": "short context cached input",
+            "cache_write": "short context cache writes",
+            "output": "short context output",
+        }
+        if not all(any(c == want for c in lowered) for want in wanted.values()):
+            continue
+        columns = {name: lowered.index(want) for name, want in wanted.items()}
+        for row in rows:
+            if len(row) <= max(columns.values()):
+                continue
+            model = _model_label(row[0])
+            if not model or " " in model:
+                continue
+            values = {name: _money(row[index]) for name, index in columns.items()}
+            if values["input"] is None or values["output"] is None:
+                continue
+            # A model can omit cache columns ("-"); fall back to the standard multiples.
+            rates.setdefault(
+                model.lower(),
+                Rates(
+                    input=values["input"],
+                    cached_input=values["cached_input"] or values["input"] * 0.1,
+                    cache_write=values["cache_write"] or values["input"] * 1.25,
+                    output=values["output"],
+                ),
+            )
+        # The standard table comes first; batch/flex/fast repeat the same headers.
+        break
+    if not rates:
+        raise PriceFeedError("no OpenAI rates found — the pricing page layout may have changed")
+    return rates
+
+
+@dataclass(frozen=True)
+class RateChange:
+    """One model's rates differing between the shipped table and the published page."""
+
+    model: str
+    before: Rates | None
+    after: Rates
+
+    @property
+    def kind(self) -> str:
+        """Whether the shipped table lacks this model entirely, or prices it differently."""
+        return "new" if self.before is None else "changed"
+
+    def describe(self) -> str:
+        """One reviewable line: what moved, from what, to what."""
+        if self.before is None:
+            return f"  + {self.model}: in ${self.after.input} out ${self.after.output} (new)"
+        # Name every field that moved — a cache rate can change while input/output hold,
+        # and on a cached workload that is most of the bill.
+        moved = [
+            f"{field} ${getattr(self.before, field)}→${getattr(self.after, field)}"
+            for field in (
+                "input",
+                "cached_input",
+                "cache_write",
+                "cache_write_5m",
+                "cache_write_1h",
+                "output",
+            )
+            if getattr(self.before, field) != getattr(self.after, field)
+        ]
+        return f"  ~ {self.model}: {', '.join(moved)}"
+
+
+def refresh(*, today: date, fetcher=None) -> dict[str, Rates]:
+    """Fetch and parse both providers' published rates.
+
+    ``fetcher`` defaults to :func:`fetch` at call time rather than in the signature, so a
+    test can replace the module's one network primitive and have every caller honour it.
+    """
+    get = fetcher or fetch
+    markdown = {name: get(url) for name, url in PRICE_SOURCES.items()}
+    return {**parse_anthropic(markdown["anthropic"], today=today), **parse_openai(markdown["openai"])}
+
+
+def fetch_table(
+    overrides: dict[str, Rates] | None = None,
+    *,
+    today: date | None = None,
+    fetcher=None,
+) -> PriceTable:
+    """The rate table a benchmark prices itself by, resolved against the live pages.
+
+    Raises :class:`PriceFeedError` if either page cannot be fetched or parsed. There is
+    nothing to fall back to by design, and a benchmark blocked on a docs-site outage is
+    recoverable in a way a stored cost that is quietly wrong is not.
+    """
+    when = today or date.today()
+    return PriceTable(
+        overrides=dict(overrides or {}),
+        fetched=refresh(today=when, fetcher=fetcher),
+        fetched_as_of=when.isoformat(),
+    )
+
+
+def try_fetch_table(
+    overrides: dict[str, Rates] | None = None,
+    *,
+    today: date | None = None,
+    fetcher=None,
+) -> tuple[PriceTable, str | None]:
+    """:func:`fetch_table`, degraded to config-only rates instead of raising.
+
+    Returns the table and, when the fetch failed, the reason — callers are expected to
+    surface it, since the visible consequence is a run reporting no cost. For the
+    interactive commands that is an acceptable trade: their cost line is progress
+    reporting, and refusing to draft a skill because a pricing page is down would be
+    stopping the work over a number nobody is depending on.
+
+    The caveat callers must weigh: an unpriced model cannot have a ``max_usd`` cap
+    enforced against it under Codex, whose budget cap is derived from these same rates.
+    """
+    try:
+        return fetch_table(overrides, today=today, fetcher=fetcher), None
+    except PriceFeedError as err:
+        return PriceTable(overrides=dict(overrides or {})), str(err)
+
+
+def diff_rates(current: dict[str, Rates], fetched: dict[str, Rates]) -> list[RateChange]:
+    """Models whose published rates differ from ``current``, plus ones it doesn't cover.
+
+    ``current`` is the operator's pinned ``prices:`` block: those are the only rates that
+    can silently disagree with a provider, since everything else is read live. A pin that
+    has drifted from the published price is worth seeing before the next pass uses it.
+
+    Only models present in the fetch are reported: a pin for a model that is no longer
+    published may well be deliberate, and is not something to nag about.
+    """
+    changes = [
+        RateChange(model=model, before=current.get(model), after=rates)
+        for model, rates in sorted(fetched.items())
+        if current.get(model) != rates
+    ]
+    return changes
+
+
+def to_yaml_block(rates: dict[str, Rates]) -> str:
+    """Render rates as a ``prices:`` block for ``config.yaml``."""
+    lines = ["prices:"]
+    for model, rate in sorted(rates.items()):
+        lines.append(f"  {model}:")
+        lines.append(f"    input: {rate.input}")
+        lines.append(f"    cached_input: {rate.cached_input}")
+        lines.append(f"    cache_write: {rate.cache_write}")
+        if rate.cache_write_5m is not None:
+            lines.append(f"    cache_write_5m: {rate.cache_write_5m}")
+        if rate.cache_write_1h is not None:
+            lines.append(f"    cache_write_1h: {rate.cache_write_1h}")
+        lines.append(f"    output: {rate.output}")
+    return "\n".join(lines) + "\n"
diff --git a/src/acumen/prices.py b/src/acumen/prices.py
new file mode 100644
index 0000000..dd291b7
--- /dev/null
+++ b/src/acumen/prices.py
@@ -0,0 +1,370 @@
+"""Per-model token rates and provider-first cost resolution.
+
+The Claude SDK reports an API-equivalent dollar cost while ``codex exec`` reports none.
+Acumen therefore preserves two measurements: the provider value when one exists and a
+reproducible inference from a rate table. The provider value is canonical; inference is
+the fallback and remains alongside it for comparison.
+
+Three properties this design depends on:
+
+**The breakdown must survive.** Cached input is billed at a tenth of the base rate and
+cache writes at 1.25x, so collapsing reads, writes, and fresh input into a single
+``input_tokens`` figure and multiplying by the base rate overcharges a cached run by up
+to 10x. Benchmark agents share a large prompt prefix, so most of their input *is* cache
+reads — the breakdown is the difference between a right answer and a wrong one.
+
+**Rates are frozen into the run.** Prices change; a benchmark comparing a January run
+against a July one must not silently re-price the old one. :func:`price_run` is called
+once, when the run finishes, and the rates it used are written into ``result.json``
+beside the figure they produced.
+
+**What was frozen must have been right when it froze.** Freezing is only worth doing if
+the rates were current at the time, so this module ships **no rate table of its own**.
+Rates come from the providers' live pricing pages (see :mod:`acumen.pricefeed`) or from
+the operator's ``prices:`` config, assembled into a :class:`PriceTable`. A baked-in table
+would only ever be right on the day it was written, and a wrong rate that has been frozen
+into a result is indistinguishable from a right one unless the provenance travels with it
+— so each run records where its rates came from and how old they were.
+
+A model no layer prices is recorded **unpriced**, which is a first-class state throughout:
+``cost_usd`` is ``None``, never ``0.0``, and reports show it as unknown rather than free.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+
+@dataclass(frozen=True)
+class Rates:
+    """What one model costs, in USD per million tokens.
+
+    All cache fields are absolute rates, not multipliers. ``cache_write`` is the legacy
+    aggregate rate; the optional duration-specific fields retain Claude's distinct
+    five-minute and one-hour write prices.
+    """
+
+    input: float
+    cached_input: float
+    cache_write: float
+    output: float
+    cache_write_5m: float | None = None
+    cache_write_1h: float | None = None
+
+    @classmethod
+    def from_mapping(cls, value: Any, *, model: str) -> Rates:
+        """Build rates from a config mapping, rejecting anything unusable.
+
+        Only ``input`` and ``output`` are required: a provider that does not price
+        caching separately (or a model a user is pricing by hand) can omit the cache
+        rates, which then default to the standard 0.1x / 1.25x of ``input``.
+        """
+        if not isinstance(value, dict):
+            raise ValueError(f"prices for {model!r} must be a mapping, got {type(value).__name__}")
+        unknown = set(value) - {
+            "input",
+            "cached_input",
+            "cache_write",
+            "cache_write_5m",
+            "cache_write_1h",
+            "output",
+        }
+        if unknown:
+            raise ValueError(f"prices for {model!r} has unknown keys: {sorted(unknown)}")
+        for key in ("input", "output"):
+            if key not in value:
+                raise ValueError(f"prices for {model!r} is missing required key {key!r}")
+        numbers: dict[str, float] = {}
+        for key, raw in value.items():
+            if isinstance(raw, bool) or not isinstance(raw, int | float) or raw < 0:
+                raise ValueError(f"prices for {model!r}: {key!r} must be a non-negative number, got {raw!r}")
+            numbers[key] = float(raw)
+        cache_write = numbers.get("cache_write", round(numbers["input"] * 1.25, _CENTS))
+        return cls(
+            input=numbers["input"],
+            cached_input=numbers.get("cached_input", round(numbers["input"] * 0.1, _CENTS)),
+            cache_write=cache_write,
+            output=numbers["output"],
+            cache_write_5m=numbers.get("cache_write_5m", cache_write),
+            cache_write_1h=numbers.get("cache_write_1h", round(numbers["input"] * 2, _CENTS)),
+        )
+
+
+#: Derived cache rates are rounded to this many decimals. Without it ``0.20 * 0.1`` is
+#: ``0.020000000000000004``, which never equals the ``$0.02`` a provider publishes — so
+#: every price refresh would report a change that isn't one.
+_CENTS = 6
+
+
+#: A trailing dated-snapshot suffix, e.g. the ``-20251001`` of ``claude-haiku-4-5-20251001``.
+_SNAPSHOT = re.compile(r"-\d{8}$")
+
+
+def _keys(model: str) -> tuple[str, ...]:
+    """The forms ``model`` may be keyed under, most specific first.
+
+    Two normalizations, each covering a way the same model gets named differently:
+
+    - A provider-qualified ID (``openai/gpt-5.6-sol``) falls back to its bare form, which
+      keeps proxy and gateway configurations priceable.
+    - A dated snapshot (``claude-haiku-4-5-20251001``) falls back to its family
+      (``claude-haiku-4-5``). Providers publish one rate per family and pin the snapshot
+      for reproducibility, so the pages never list the dated ID that a benchmark pins to.
+      Without this, pinning a snapshot — which is the right thing to do — would silently
+      leave every run unpriced.
+    """
+    bare = model.rsplit("/", 1)[-1].strip().lower()
+    return tuple(dict.fromkeys((model, model.strip().lower(), bare, _SNAPSHOT.sub("", bare))))
+
+
+#: Rate provenance, most authoritative first. ``config`` is a deliberate operator
+#: statement about their own billing and outranks a published page; ``fetched`` is what
+#: the provider published on the day of the run.
+CONFIG, FETCHED = "config", "fetched"
+
+
+@dataclass(frozen=True)
+class RateLookup:
+    """One model's rates together with where they came from and how current they are.
+
+    ``as_of`` is ``None`` for a ``config`` rate: an operator's own numbers carry no
+    verification date, and inventing one would claim currency nothing established.
+    """
+
+    rates: Rates
+    source: str
+    as_of: str | None
+
+
+@dataclass(frozen=True)
+class PriceTable:
+    """The rates one command prices its runs by.
+
+    Two layers: ``overrides`` from ``config.yaml``, then ``fetched`` from the providers'
+    live pricing pages. Config wins, because only the operator knows what they are
+    actually billed — a negotiated rate or a gateway's markup is not on any public page.
+
+    There is deliberately no third layer of built-in defaults. Published prices move, so a
+    table compiled into a release is wrong from some unknowable date onward, and because
+    each run's cost is frozen at write time that wrongness would be preserved rather than
+    corrected on the next run. An empty table prices nothing, which is the honest outcome
+    when no rates could be established.
+    """
+
+    overrides: dict[str, Rates] = field(default_factory=dict)
+    fetched: dict[str, Rates] = field(default_factory=dict)
+    fetched_as_of: str | None = None
+
+    def lookup(self, model: str) -> RateLookup | None:
+        """Resolve ``model`` through the layers, or ``None`` if no layer prices it."""
+        layers: tuple[tuple[str, dict[str, Rates], str | None], ...] = (
+            (CONFIG, self.overrides, None),
+            (FETCHED, self.fetched, self.fetched_as_of),
+        )
+        for source, table, as_of in layers:
+            for key in _keys(model):
+                if key in table:
+                    return RateLookup(rates=table[key], source=source, as_of=as_of)
+        return None
+
+    def rates(self, model: str) -> Rates | None:
+        """Just the rates, for callers that do not record provenance."""
+        found = self.lookup(model)
+        return None if found is None else found.rates
+
+
+@dataclass(frozen=True)
+class Usage:
+    """One run's token counts, normalized across providers.
+
+    ``input`` is the *total* input including both cached classes — the shape both
+    providers report — so the fresh-token count is ``input - cache_read - cache_write``.
+    """
+
+    input: int
+    cache_read: int
+    cache_write: int
+    output: int
+    cache_write_5m: int = 0
+    cache_write_1h: int = 0
+
+    @property
+    def total(self) -> int:
+        """Every token the run consumed, input and output together."""
+        return self.input + self.output
+
+    @property
+    def fresh_input(self) -> int:
+        """Input billed at the full rate.
+
+        Clamped at zero: a provider is free to redefine how the parts relate, and a
+        negative token count would silently become a negative cost.
+        """
+        return max(0, self.input - self.cache_read - self.cache_write)
+
+
+def _int(usage: dict, key: str) -> int:
+    return int(usage.get(key, 0) or 0)
+
+
+def normalize_usage(usage: dict | None, *, provider: str = "claude") -> Usage:
+    """Normalize a provider's usage block, keeping the cache split intact.
+
+    The two providers report the same information in different shapes. Codex's
+    ``input_tokens`` is the total with ``cached_input_tokens`` as a subset of it; the
+    Claude SDK reports the three classes side by side, so the total is their sum. Both
+    are normalized to :class:`Usage`, whose ``input`` is always the total.
+
+    The split is kept rather than collapsed because the classes are priced an order of
+    magnitude apart — see this module's docstring. Verified against a live ``turn.completed``
+    event, whose usage block is::
+
+        {
+            "input_tokens": 12051,
+            "cached_input_tokens": 8960,
+            "cache_write_input_tokens": 0,
+            "output_tokens": 5,
+            "reasoning_output_tokens": 0,
+        }
+
+    ``reasoning_output_tokens`` is a subset of ``output_tokens`` and billed as output, so
+    the total is the figure to use and the subset is ignored.
+    """
+    if not usage:
+        return Usage(input=0, cache_read=0, cache_write=0, output=0)
+    output = _int(usage, "output_tokens")
+    if provider == "codex":
+        return Usage(
+            input=_int(usage, "input_tokens"),
+            cache_read=_int(usage, "cached_input_tokens"),
+            cache_write=_int(usage, "cache_write_input_tokens"),
+            output=output,
+        )
+    cache_read = _int(usage, "cache_read_input_tokens")
+    cache_detail = usage.get("cache_creation")
+    if not isinstance(cache_detail, dict):
+        cache_detail = {}
+    cache_write_5m = _int(cache_detail, "ephemeral_5m_input_tokens") or _int(usage, "cache_creation_5m_input_tokens")
+    cache_write_1h = _int(cache_detail, "ephemeral_1h_input_tokens") or _int(usage, "cache_creation_1h_input_tokens")
+    cache_write = _int(usage, "cache_creation_input_tokens")
+    if cache_write == 0:
+        cache_write = cache_write_5m + cache_write_1h
+    return Usage(
+        input=_int(usage, "input_tokens") + cache_read + cache_write,
+        cache_read=cache_read,
+        cache_write=cache_write,
+        output=output,
+        cache_write_5m=cache_write_5m,
+        cache_write_1h=cache_write_1h,
+    )
+
+
+def price_usage(
+    usage: dict | None,
+    *,
+    model: str,
+    provider: str = "claude",
+    prices: PriceTable | None = None,
+) -> float | None:
+    """Price a provider usage payload through ``prices``, or the built-in table."""
+    rates = (prices or PriceTable()).rates(model)
+    return price_run(normalize_usage(usage, provider=provider), rates)
+
+
+def pricer(model: str, prices: PriceTable | None = None) -> Callable[[dict], float | None]:
+    """A usage→USD hook for a provider that reports no billed figure of its own.
+
+    Codex cannot enforce a budget cap without one: it reports tokens, so the cap has to be
+    applied to the same rate table the run is priced by, never a second one — otherwise a run
+    could be stopped at a budget it is not billed against. Returns ``None`` for an unpriced
+    model, which callers must read as "no cap can be enforced", never as "free".
+    """
+    return lambda usage: price_usage(usage, model=model, provider="codex", prices=prices)
+
+
+def price_run(usage: Usage, rates: Rates | None) -> float | None:
+    """Cost of one run in USD, or ``None`` when the model has no rates.
+
+    ``None`` is deliberately distinct from ``0.0``: an unpriced model must not be
+    reported as a free one, which is exactly the failure the provider-reported figure
+    produced for Codex.
+    """
+    if rates is None:
+        return None
+    per_token = 1_000_000
+    classified_writes = min(usage.cache_write, usage.cache_write_5m + usage.cache_write_1h)
+    aggregate_writes = usage.cache_write - classified_writes
+    write_5m_rate = rates.cache_write_5m if rates.cache_write_5m is not None else rates.cache_write
+    write_1h_rate = rates.cache_write_1h if rates.cache_write_1h is not None else rates.cache_write
+    return (
+        usage.fresh_input * rates.input
+        + usage.cache_read * rates.cached_input
+        + aggregate_writes * rates.cache_write
+        + usage.cache_write_5m * write_5m_rate
+        + usage.cache_write_1h * write_1h_rate
+        + usage.output * rates.output
+    ) / per_token
+
+
+@dataclass(frozen=True)
+class CostResolution:
+    """Canonical and comparative costs for one completed agent run."""
+
+    cost_usd: float | None
+    cost_source: str
+    provider_cost_usd: float | None
+    inferred_cost_usd: float | None
+    cost_delta_usd: float | None
+    cost_delta_pct: float | None
+
+    @property
+    def available(self) -> bool:
+        """Whether this run has any canonical dollar cost."""
+        return self.cost_usd is not None
+
+
+def resolve_cost(provider_cost_usd: float | None, inferred_cost_usd: float | None) -> CostResolution:
+    """Prefer a provider-reported cost while retaining reproducible inference."""
+    canonical = provider_cost_usd if provider_cost_usd is not None else inferred_cost_usd
+    source = (
+        "provider"
+        if provider_cost_usd is not None
+        else ("inferred" if inferred_cost_usd is not None else "unavailable")
+    )
+    delta = None
+    pct = None
+    if provider_cost_usd is not None and inferred_cost_usd is not None:
+        delta = inferred_cost_usd - provider_cost_usd
+        if provider_cost_usd != 0:
+            pct = delta / provider_cost_usd
+    return CostResolution(
+        cost_usd=canonical,
+        cost_source=source,
+        provider_cost_usd=provider_cost_usd,
+        inferred_cost_usd=inferred_cost_usd,
+        cost_delta_usd=delta,
+        cost_delta_pct=pct,
+    )
+
+
+def rates_payload(rates: Rates | None) -> dict[str, float] | None:
+    """The rates as they go into ``result.json`` — the run's frozen price provenance."""
+    return None if rates is None else asdict(rates)
+
+
+def price_provenance(lookup: RateLookup | None) -> dict[str, Any]:
+    """The ``result.json`` fields describing what a run was priced by.
+
+    Recorded per run rather than per pass because a matrix can mix models across layers:
+    one on negotiated config rates, another on what the page published that morning.
+    Without the source and date, two runs months apart are indistinguishable from two
+    priced by the same stale table, which is the whole reason for freezing rates at all.
+    """
+    return {
+        "price_rates": rates_payload(None if lookup is None else lookup.rates),
+        "price_source": None if lookup is None else lookup.source,
+        "price_rates_as_of": None if lookup is None else lookup.as_of,
+    }
diff --git a/src/acumen/procs.py b/src/acumen/procs.py
index b76778c..e491e5c 100644
--- a/src/acumen/procs.py
+++ b/src/acumen/procs.py
@@ -18,10 +18,9 @@
 it on the way out, before their directory is removed, on every exit path including
 cancellation.
 
-The marker is what makes this exact rather than a guess at which paths a run touches. The
-benchmark sandboxes do put their throwaway ``HOME`` and ``TMPDIR`` under the same directory,
-but ``ship``'s agent deliberately runs in the operator's real environment and real checkout,
-where no such path appears — one explicit variable covers both.
+The marker is what makes this exact rather than a guess at which paths a run touches. Every
+agent has a throwaway ``HOME`` and ``TMPDIR`` under its run directory, but the explicit marker
+still identifies descendants that change directory or sanitize part of their environment.
 
 Reading *another* process's environment is the one step with no portable stdlib spelling:
 it is a file read on Linux, a ``KERN_PROCARGS2`` sysctl on macOS, and a ``ReadProcessMemory``
diff --git a/src/acumen/prompts.py b/src/acumen/prompts.py
index 09116b0..3bfd881 100644
--- a/src/acumen/prompts.py
+++ b/src/acumen/prompts.py
@@ -103,7 +103,7 @@ def feedback_block(feedback: str | None) -> str:
 
 
 DRAFT_PROMPT = """\
-You are writing a Claude Skill for the Python package `{package}` (version {version}).
+You are writing an agent skill for the Python package `{package}` (version {version}).
 
 A skill is documentation written for an agent, not for a human. Its only purpose is to
 make an agent that has never used `{package}` succeed at real tasks with it on the first
@@ -179,7 +179,7 @@ def feedback_block(feedback: str | None) -> str:
 
 
 IMPROVE_PROMPT = """\
-You are improving a Claude Skill for the Python package `{package}` (version {version}).
+You are improving an agent skill for the Python package `{package}` (version {version}).
 
 A skill is documentation written for an agent, not a human. Its only purpose is to make an
 agent that has never used `{package}` succeed at real tasks with it on the first try.
@@ -294,7 +294,8 @@ def feedback_block(feedback: str | None) -> str:
 # Ignore any existing skills or agent instructions — deliberately hidden
 
 The package may ship skills or agent-instruction files written for it (`SKILL.md`,
-`.claude/skills/`, `CLAUDE.md`, `AGENTS.md`, `.cursor/`, Copilot instructions). These have
+`.agents/skills/`, `.claude/skills/`, `.codex/`, `CLAUDE.md`, `AGENTS.md`, `.cursor/`,
+Copilot instructions). These have
 been stripped from the source above, and any attempt to reach them — or the original
 unfiltered checkout — is BLOCKED. This is on purpose: reading pre-written guidance would bias
 which analyses you pick and how you phrase them, and this benchmark must be independent of it.
diff --git a/src/acumen/report.py b/src/acumen/report.py
index 599cfee..2945b94 100644
--- a/src/acumen/report.py
+++ b/src/acumen/report.py
@@ -55,18 +55,31 @@
 BAR = "#565149"  # a neutral tone, used where model hue does not apply
 ACCENT = "#b2ac9e"  # the light warm tone, for table tints and notes
 
-# The model is the hue: a single-hue ramp keyed to model "potency". The most capable model
-# (Fable) is the DARKEST / most saturated — the Claude orange — and each weaker tier is a
-# lighter tint of that same hue. The mapping is fixed by *tier* (parsed from the model id),
-# so a given tier always reads the same colour regardless of which — or how many — models a
-# pass happens to include. This is only the *default*: a caller can recolour any model by id
-# (see :func:`resolve_palette`), while the page and plot surfaces above stay fixed.
-_MODEL_ORDER = ("fable", "opus", "sonnet", "haiku")
+# The model is the hue, in two dimensions: the *provider* picks the hue family, and the tier
+# picks the step within it — darkest is most potent, each weaker tier a lighter step of the
+# same hue. The mapping is fixed by *tier* (parsed from the model id), so a given tier always
+# reads the same colour regardless of which — or how many — models a pass happens to include.
+# This is only the *default*: a caller can recolour any model by id (see
+# :func:`resolve_palette`), while the page and plot surfaces above stay fixed.
+#
+# The second family is teal, not green, and that is not a taste call. Orange and green are the
+# pair red-green colourblind readers cannot separate: a green ramp built parallel to the orange
+# one below scores ΔE 1.2 against it under simulated deuteranopia (OKLab ×100; ≥8 is the
+# target, and darkening the green only reaches 7.2). Teal is the nearest hue that clears the
+# gate — deuteranopia 14.9, protanopia 8.2, normal-vision 23.7 — so the two providers stay
+# distinguishable in every vision type. Train/test already spends the texture channel, so
+# colour is the only thing carrying provider identity here; it has to work on its own.
+_MODEL_ORDER = ("fable", "opus", "sonnet", "haiku", "sol", "terra", "luna")
 _MODEL_COLOR = {
+    # Anthropic — the warm ramp.
     "fable": "#d86f53",  # Claude orange — most potent, darkest/most saturated
     "opus": "#e18c74",  # a lighter tint
     "sonnet": "#e8a794",  # lighter still
     "haiku": "#eec0b0",  # lightest — least potent
+    # OpenAI — the cool ramp, stepped over the same lightness span.
+    "sol": "#005661",  # most potent, darkest
+    "terra": "#007782",
+    "luna": "#0099a3",  # lightest — least potent
 }
 _OTHER_MODEL_COLOR = "#8a8378"  # neutral fallback for an unrecognised model id
 
@@ -107,6 +120,11 @@
 #: held-out (test) performance.
 _REPORTED_SPLIT = "test"
 
+# Reports compare providers on one consistent basis: the frozen price table applied to
+# token usage.  Keep this separate from ``cost_usd``, whose result-schema meaning remains
+# provider-first for backwards compatibility and auditability.
+_REPORT_COST_COLUMN = "_report_cost_usd"
+
 
 #: Brand assets bundled with the package (see ``src/acumen/assets``). Inlined as ``data:``
 #: URIs so ``report.html`` stays self-contained — the favicon and the sidebar banner
@@ -213,19 +231,51 @@ def load_results(runs_root: Path) -> pd.DataFrame:
         raise ReportError(f"no runs directory: {runs_root}")
 
     rows: list[dict] = []
+    invalid: list[Path] = []
     for result_path in sorted(runs_root.rglob(RESULT_FILE)):
         try:
             data = json.loads(result_path.read_text())
         except (OSError, json.JSONDecodeError) as err:
             raise ReportError(f"cannot read {result_path}: {err}") from err
+        if data.get("valid", True) is False:
+            invalid.append(result_path)
+            continue
+        # Legacy results predate the dual-cost schema. Their sole ``cost_usd`` value was
+        # inferred from tokens, so it is a valid fallback only when the newer field is
+        # absent (not when a modern result explicitly records inference as unavailable).
+        data["_has_inferred_cost"] = "inferred_cost_usd" in data
         data["result_path"] = result_path.resolve()
         data["transcript_path"] = (result_path.parent / TRANSCRIPT_HTML).resolve()
         rows.append(data)
 
+    if invalid:
+        sample = ", ".join(str(path) for path in invalid[:3])
+        more = f" (+{len(invalid) - 3} more)" if len(invalid) > 3 else ""
+        raise ReportError(
+            "benchmark contains infrastructure-invalid provider quota/credit result(s); "
+            f"replenish the credential and resume the benchmark before reporting: {sample}{more}"
+        )
     if not rows:
         raise ReportError(f"no {RESULT_FILE} files under {runs_root} — run `acumen bench` first")
 
     df = pd.DataFrame(rows)
+    # New results carry an explicit availability flag; legacy results predate it and their
+    # numeric cost remains usable. An unavailable price is NaN inside pandas so every normal
+    # aggregation propagates "unknown" instead of silently treating the run as free.
+    available = df.get("cost_available", pd.Series(True, index=df.index)).astype("boolean").fillna(True).astype(bool)
+    df["cost_usd"] = pd.to_numeric(df["cost_usd"], errors="coerce")
+    df.loc[~available, "cost_usd"] = math.nan
+    if "provider_cost_usd" not in df.columns:
+        df["provider_cost_usd"] = math.nan
+    else:
+        df["provider_cost_usd"] = pd.to_numeric(df["provider_cost_usd"], errors="coerce")
+    if "inferred_cost_usd" not in df.columns:
+        df["inferred_cost_usd"] = math.nan
+    else:
+        df["inferred_cost_usd"] = pd.to_numeric(df["inferred_cost_usd"], errors="coerce")
+    legacy = ~df.pop("_has_inferred_cost").astype(bool)
+    df.loc[legacy, "inferred_cost_usd"] = df.loc[legacy, "cost_usd"]
+    df[_REPORT_COST_COLUMN] = df["inferred_cost_usd"]
     df["total_tokens"] = df["input_tokens"] + df["output_tokens"]
     df["arm_label"] = df["arm"].map(arm_label)
     df["_arm_order"] = df["arm"].map(_arm_sort_key)
@@ -256,7 +306,10 @@ def _loaded_flags(df: pd.DataFrame) -> pd.Series:
     """
     if "skill_loaded" not in df.columns:
         return pd.Series(False, index=df.index, dtype=bool)
-    return df["skill_loaded"].fillna(False).astype(bool)
+    # Convert to pandas' nullable BooleanDtype before filling. Filling an object-dtype
+    # bool/None series currently downcasts silently and emits a FutureWarning; making the
+    # conversion explicit is stable under pandas' future no-silent-downcasting behavior.
+    return df["skill_loaded"].astype("boolean").fillna(False).astype(bool)
 
 
 def arm_metrics(df: pd.DataFrame) -> pd.DataFrame:
@@ -285,7 +338,9 @@ def arm_metrics(df: pd.DataFrame) -> pd.DataFrame:
                 "rate": rate,
                 "stderr": stderr,
                 "tokens": float(group["total_tokens"].sum()),
-                "cost": float(group["cost_usd"].sum()),
+                "cost": (
+                    float(group[_REPORT_COST_COLUMN].sum()) if group[_REPORT_COST_COLUMN].notna().all() else math.nan
+                ),
                 "time": float(group["duration_s"].sum()),
                 "n": len(group),
             }
@@ -305,6 +360,10 @@ def arm_metrics(df: pd.DataFrame) -> pd.DataFrame:
 #: table, which is now the same unit — because a per-run mean can sit well under a cent.
 _COLUMNS = [
     ("Success rate", "rate", mticker.PercentFormatter(1.0), lambda v: f"{v:.0%}"),
+    # Directly right of the headline rate and on the same 0–1 axis, so the pair is read as one
+    # comparison: the same bar with the runs that never read the skill taken out. A missing bar
+    # here means nothing loaded in that cell, which is the finding, not a gap in the data.
+    ("Success when loaded", "rate_loaded", mticker.PercentFormatter(1.0), lambda v: f"{v:.0%}"),
     ("Skill loaded", "loaded", mticker.PercentFormatter(1.0), lambda v: f"{v:.0%}"),
     ("Tokens / run", "tokens", mticker.FuncFormatter(lambda v, _p: _fmt_tokens(v)), _fmt_tokens),
     ("Cost / run", "cost", mticker.FuncFormatter(lambda v, _p: f"${v:.3f}"), lambda v: f"${v:.3f}"),
@@ -315,8 +374,14 @@ def arm_metrics(df: pd.DataFrame) -> pd.DataFrame:
 #: it is a per-run mean like the rest; it differs only in being drawn on a fixed 0–1 axis.
 _PROPORTION_COLUMN = {"rate": "success", "loaded": "skill_loaded"}
 
+#: Keys drawn on the fixed 0–1 axis. A superset of :data:`_PROPORTION_COLUMN`: ``rate_loaded``
+#: is a proportion too, but of a *filtered* subset rather than of a whole column, so it is
+#: computed separately while still sharing the percentage axis — which is what lets it be read
+#: against the success rate beside it.
+_PROPORTION_KEYS = frozenset({*_PROPORTION_COLUMN, "rate_loaded"})
+
 #: Metric key → the resource column it averages (the proportions are handled separately).
-_MEAN_COLUMN = {"tokens": "total_tokens", "cost": "cost_usd", "time": "duration_s"}
+_MEAN_COLUMN = {"tokens": "total_tokens", "cost": _REPORT_COST_COLUMN, "time": "duration_s"}
 
 
 def _model_tier(model: str) -> str:
@@ -397,7 +462,11 @@ def resolve_palette(models: Sequence[str], overrides: Mapping[str, str] | None =
 
 
 def _models_in_order(df: pd.DataFrame) -> list[str]:
-    """Models present, most-potent first (fable, opus, sonnet, haiku), then any others."""
+    """Models present, grouped by provider and most-potent first, then any others.
+
+    Anthropic's tiers lead (fable, opus, sonnet, haiku), then OpenAI's (sol, terra, luna), so
+    each provider's ramp reads as a run of one hue rather than being interleaved with the other.
+    """
 
     def key(model: str) -> tuple[int, str]:
         tier = _model_tier(model)
@@ -441,11 +510,22 @@ def _cell_value(df: pd.DataFrame, arm: str, model: str, split: str, key: str) ->
     group = df[rows if model == _ALL_MODELS else rows & (df["model"] == model)]
     if group.empty:
         return 0.0, 0.0, False
+    if key == "rate_loaded":
+        # Success among the runs that actually read the skill. A cell with nothing loaded —
+        # every baseline cell, and any model whose description never fired — draws no bar
+        # rather than a zero, because "never measured" is not "measured zero".
+        loaded = group[_loaded_flags(group)]
+        if loaded.empty:
+            return math.nan, 0.0, False
+        rate, error = _rate_and_error(loaded["success"])
+        return rate, error, True
     if key in _PROPORTION_COLUMN:
         flags = _loaded_flags(group) if key == "loaded" else group[_PROPORTION_COLUMN[key]]
         rate, error = _rate_and_error(flags)
         return rate, error, True
     values = group[_MEAN_COLUMN[key]]
+    if key == "cost" and values.isna().any():
+        return math.nan, 0.0, False
     mean = float(values.mean())
     error = float(values.std(ddof=1)) / math.sqrt(len(values)) if len(values) > 1 else 0.0
     return mean, error, True
@@ -546,7 +626,13 @@ def metrics_figure(df: pd.DataFrame, *, split_hue: bool, colors: Mapping[str, st
         # per-row breathing room, not a fixed block, so few-model plots stay compact.
         row_h = 0.26 * max_bars + 0.22
         fig, axes = plt.subplots(
-            n_rows, len(_COLUMNS), sharex="col", squeeze=False, figsize=(10.0, n_rows * row_h + 0.6)
+            # Width scales with the column count so adding a metric widens the figure rather
+            # than squeezing every column's labels into the same 10 inches.
+            n_rows,
+            len(_COLUMNS),
+            sharex="col",
+            squeeze=False,
+            figsize=(2.0 * len(_COLUMNS), n_rows * row_h + 0.6),
         )
         for c, (title, key, formatter, value_label) in enumerate(_COLUMNS):
             for r, arm in enumerate(arms):
@@ -559,7 +645,7 @@ def metrics_figure(df: pd.DataFrame, *, split_hue: bool, colors: Mapping[str, st
                 if c == 0:
                     ax.set_ylabel(_skill_label(arm), rotation=0, ha="right", va="center", fontweight="bold")
             # sharex="col" ties the whole column together, so one xlim covers every row.
-            if key in _PROPORTION_COLUMN:
+            if key in _PROPORTION_KEYS:
                 axes[-1][c].set_xlim(0, 1.28)
             else:
                 reach = max(
@@ -915,7 +1001,8 @@ def _cluster_totals(df: pd.DataFrame, arms: Sequence[str]) -> tuple[np.ndarray,
     for ci, cluster in enumerate(clusters):
         for ai, arm in enumerate(arms):
             rows = test[(test[_CLUSTER_COLUMN] == cluster) & (test["arm"] == arm)]
-            cost[ci, ai] = rows["cost_usd"].sum()
+            report_cost = rows[_REPORT_COST_COLUMN]
+            cost[ci, ai] = report_cost.sum() if report_cost.notna().all() else math.nan
             successes[ci, ai] = rows["success"].sum()
             runs[ci, ai] = len(rows)
     return cost, successes, runs
@@ -1002,6 +1089,7 @@ class SkillTests:
     comparisons: pd.DataFrame
     baseline: str
     n_clusters: int
+    cost_unavailable: bool = False
 
     @property
     def usable(self) -> bool:
@@ -1035,8 +1123,16 @@ def skill_tests(df: pd.DataFrame, *, resamples: int = _BOOTSTRAP_RESAMPLES, seed
     cost, successes, runs = _cluster_totals(df, arms)
     n_clusters = len(cost)
     baseline = arms[0] if arms else NOSKILL_ARM  # noskill sorts first when it is present
+    empty = pd.DataFrame(columns=["challenger", "reference", "d_rate", "d_cost", "p", "p_adjusted"])
+    if np.isnan(cost).any():
+        return SkillTests(
+            arms=pd.DataFrame(columns=["arm", "rate", "cost", "frontier"]),
+            comparisons=empty,
+            baseline=baseline,
+            n_clusters=n_clusters,
+            cost_unavailable=True,
+        )
     if n_clusters < _MIN_CLUSTERS or len(arms) < 2:
-        empty = pd.DataFrame(columns=["challenger", "reference", "d_rate", "d_cost", "p", "p_adjusted"])
         return SkillTests(
             arms=pd.DataFrame(columns=["arm", "rate", "cost", "frontier"]),
             comparisons=empty,
@@ -1128,6 +1224,12 @@ def _best_cells(values: Sequence[float | None], *, highest: bool) -> set[int]:
 
 def _tests_table_html(tests: SkillTests) -> str:
     """The significance table: one row per arm, with the best value in each column set bold."""
+    if tests.cost_unavailable:
+        return (
+            '<div class="note">Cost comparison unavailable: at least one reported test run '
+            "has no configured model rate. Add a rate and rerun that benchmark before drawing "
+            "cost or Pareto conclusions.</div>"
+        )
     if not tests.usable:
         return (
             f'<div class="note">Not enough to test: a paired bootstrap needs at least {_MIN_CLUSTERS} '
@@ -1172,6 +1274,165 @@ def _tests_table_html(tests: SkillTests) -> str:
 </table></div>"""
 
 
+def loaded_only_rates(df: pd.DataFrame) -> pd.DataFrame:
+    """Success rate restricted to the runs that actually loaded the skill, per skill and model.
+
+    A skill-arm run where the skill never loaded is not evidence about the skill's *body*: the
+    agent never read it, so the run measures the baseline with extra steps. Pooling those runs
+    into the arm's headline rate drags a skill toward the baseline in exactly the case where
+    the thing to fix is the frontmatter ``description`` rather than the guidance — and the load
+    rate varies enormously by model, so the dilution is uneven across the matrix.
+
+    This is the overview's comparison with those runs held out instead of counted against the
+    skill. It is deliberately *not* the headline number: conditioning on load is conditioning on
+    something the agent chose, so the loaded runs are not a random subset and this cannot prove
+    a skill works. It answers the narrower question — when the guidance did reach the agent, did
+    it help? — and separates a description problem from a content problem.
+
+    Two pooled rows close each skill, and the pair is the point. ``all models`` pools every
+    model in the arm; ``models that loaded`` restricts **both sides** to the models that
+    contributed at least one loaded run. When they disagree, the gap is model mix rather than
+    skill effect — a model that fails every run (an outage, an unavailable id) sits in the
+    all-models baseline while contributing nothing to the loaded column, which on its own would
+    manufacture a gain out of an absence. Reporting only the matched row would hide that the
+    arm's headline moved; reporting only the raw row would credit the skill for it.
+
+    Returns
+    -------
+    One row per (arm, model) over the reported split, then the two pooled rows per arm.
+    Columns: ``arm``, ``model``, ``scope`` (``"model"``, ``"all"`` or ``"matched"``),
+    ``loaded``, ``runs``, ``load_rate``, ``baseline``, ``overall`` (the arm's rate over every
+    run, which is what the overview reports), ``rate`` (successes among loaded runs only), and
+    ``delta`` (``rate - baseline``). ``overall`` and ``rate`` are shown side by side because the
+    distance between them *is* the dilution the non-loading runs cause. ``rate`` is ``NaN``
+    where nothing loaded, and ``baseline`` is ``NaN`` where that model has no baseline runs.
+    """
+    test = df[df["split"] == _REPORTED_SPLIT]
+    arms = [arm for arm in _arms_in_order(test) if arm != NOSKILL_ARM]
+    base = test[test["arm"] == NOSKILL_ARM]
+    records: list[dict[str, object]] = []
+    for arm in arms:
+        subset = test[test["arm"] == arm]
+        contributing = {
+            model for model in subset["model"].unique() if _loaded_flags(subset[subset["model"] == model]).any()
+        }
+        plan: list[tuple[str, object, pd.DataFrame, pd.DataFrame]] = [
+            ("model", model, subset[subset["model"] == model], base[base["model"] == model])
+            for model in _models_in_order(subset)
+        ]
+        plan.append(("all", _ALL_MODELS, subset, base))
+        plan.append(
+            (
+                "matched",
+                _LOADED_MODELS,
+                subset[subset["model"].isin(contributing)],
+                base[base["model"].isin(contributing)],
+            )
+        )
+        for scope, model, runs, reference in plan:
+            if runs.empty:
+                continue
+            loaded = runs[_loaded_flags(runs)]
+            rate = float(loaded["success"].mean()) if len(loaded) else math.nan
+            overall = float(runs["success"].mean())
+            baseline = float(reference["success"].mean()) if len(reference) else math.nan
+            records.append(
+                {
+                    "arm": arm,
+                    "model": model,
+                    "scope": scope,
+                    "loaded": len(loaded),
+                    "runs": len(runs),
+                    "load_rate": len(loaded) / len(runs),
+                    "baseline": baseline,
+                    # The arm as it ran (what the overview reports) beside the arm with the
+                    # non-loading runs held out. The gap between them is the dilution.
+                    "overall": overall,
+                    "rate": rate,
+                    "delta": rate - baseline,
+                }
+            )
+    return pd.DataFrame.from_records(records, columns=_LOADED_COLUMNS)
+
+
+#: Column order for :func:`loaded_only_rates`, so an empty frame still has the right shape.
+_LOADED_COLUMNS = (
+    "arm",
+    "model",
+    "scope",
+    "loaded",
+    "runs",
+    "load_rate",
+    "baseline",
+    "overall",
+    "rate",
+    "delta",
+)
+
+#: Sentinel for the pooled row that restricts both sides to the models which loaded the skill,
+#: alongside :data:`_ALL_MODELS` for the row that pools the arm as it actually ran.
+_LOADED_MODELS = "\x00loaded-models"
+_LOADED_MODELS_LABEL = "models that loaded"
+
+#: Loaded runs below this count are reported without a direction. The rate is still shown —
+#: it is what was measured — but a delta off one or two runs is noise wearing a percentage,
+#: and colouring it green would read as a finding.
+_MIN_LOADED = 5
+
+
+def _loaded_table_html(df: pd.DataFrame) -> str:
+    """The loaded-only comparison: one row per model per skill, pooled row per skill."""
+    table = loaded_only_rates(df)
+    if table.empty:
+        return '<div class="note">No skill arm to compare — this report covers the baseline only.</div>'
+
+    def pct(value: float) -> str:
+        return "&mdash;" if pd.isna(value) else f"{value:.0%}"
+
+    def signed(value: float) -> str:
+        # A difference that rounds to nothing is written "0%", never "-0%": the sign would
+        # claim a direction the rounding just erased.
+        return "0%" if round(value, 2) == 0 else f"{value:+.0%}"
+
+    labels = {"all": _ALL_MODELS_LABEL, "matched": _LOADED_MODELS_LABEL}
+    thin = False
+    body = []
+    for row in table.itertuples():
+        pooled = row.scope != "model"
+        label = labels.get(row.scope) or _model_label(row.model)
+        if pd.isna(row.delta):
+            delta = "&mdash;"
+        elif row.loaded < _MIN_LOADED:
+            # Shown, but undressed: too few runs to read a direction from.
+            thin = True
+            delta = f"{signed(row.delta)}&#8203;<sup>†</sup>"
+        elif round(row.delta, 2) == 0:
+            delta = signed(row.delta)
+        else:
+            delta = f'<span class="{"gain" if row.delta > 0 else "loss"}">{signed(row.delta)}</span>'
+        cells = (
+            f"<td>{_skill_label(row.arm)}</td><td>{html.escape(label)}</td>"
+            f"<td>{row.loaded}/{row.runs}</td><td>{pct(row.load_rate)}</td>"
+            f"<td>{pct(row.baseline)}</td><td>{pct(row.overall)}</td>"
+            f"<td>{pct(row.rate)}</td><td>{delta}</td>"
+        )
+        body.append(f'<tr class="{"pooled" if pooled else ""}">{cells}</tr>')
+
+    footnote = (
+        f'<p class="task-desc">† fewer than {_MIN_LOADED} loaded runs — the rate is what was '
+        "measured, but the difference is not readable at that count.</p>"
+        if thin
+        else ""
+    )
+    return f"""<div class="table-center"><table class="tests loaded">
+<thead><tr>
+<th>Skill</th><th>Model</th><th>Loaded</th><th>Load rate</th>
+<th>Baseline</th><th>All runs</th><th>When loaded</th><th>&Delta; loaded</th>
+</tr></thead>
+<tbody>{"".join(body)}</tbody>
+</table>{footnote}</div>"""
+
+
 @dataclass(frozen=True)
 class Report:
     """A rendered report and the data behind it."""
@@ -1185,6 +1446,32 @@ def n_runs(self) -> int:
         return len(self.results)
 
 
+def _price_date_note(df: pd.DataFrame) -> str | None:
+    """Warn when the arms being compared were priced on different days.
+
+    Rates are resolved live and frozen per run, which keeps each figure true to what it
+    cost — but it also means arms benchmarked weeks apart carry different prices. The cost
+    comparison between them then mixes a skill effect with a price change, and the cheaper
+    arm may simply be the one that ran before a rise. Nothing here can separate the two,
+    so the report says so and leaves the reader to judge.
+
+    Only differences *between* arms are flagged. Resuming one arm across a price change
+    spreads the same ambiguity within it, which the per-run table already exposes.
+    """
+    if "price_rates_as_of" not in df.columns or "arm" not in df.columns:
+        return None
+    dated = df[df["price_rates_as_of"].notna()]
+    per_arm = {arm: set(group["price_rates_as_of"]) for arm, group in dated.groupby("arm")}
+    seen = set().union(*per_arm.values()) if per_arm else set()
+    if len(per_arm) < 2 or len(seen) < 2:
+        return None
+    spread = ", ".join(f"{arm_label(arm)} priced {'/'.join(sorted(dates))}" for arm, dates in sorted(per_arm.items()))
+    return (
+        f"arms were priced on different dates ({spread}); cost differences between them "
+        "include any change in provider pricing, not only the skill's effect"
+    )
+
+
 def _integrity_notes(df: pd.DataFrame) -> list[str]:
     """Flag arms whose ``skill_loaded`` disagrees with what the arm name claims.
 
@@ -1195,8 +1482,19 @@ def _integrity_notes(df: pd.DataFrame) -> list[str]:
 
     Occasional misses are normal and the per-run table already marks them, so a skill arm is
     only flagged once fewer than half its runs loaded the skill.
+
+    Cost carries its own comparability hazard, handled by :func:`_price_date_note`.
     """
     notes = []
+    unpriced = int(df[_REPORT_COST_COLUMN].isna().sum())
+    if unpriced:
+        notes.append(
+            f"cost unavailable for {unpriced}/{len(df)} runs; cost charts and comparisons omit "
+            "groups containing unpriced runs"
+        )
+    price_dates = _price_date_note(df)
+    if price_dates is not None:
+        notes.append(price_dates)
     if "skill_loaded" not in df.columns:
         return notes
     for arm in _arms_in_order(df):
@@ -1264,7 +1562,7 @@ def _runs_table_html(df: pd.DataFrame, out_dir: Path) -> str:
         "reason",
         "turns",
         "total tok",
-        "cost $",
+        "cost / run $",
         "time",
         "transcript",
     ]
@@ -1287,6 +1585,8 @@ def _runs_table_html(df: pd.DataFrame, out_dir: Path) -> str:
         else:
             link = "&mdash;"
         status = "pass" if row["success"] else "fail"
+        cost = row[_REPORT_COST_COLUMN]
+        cost_cell = ("&mdash;", None) if pd.isna(cost) else (f"{float(cost):.3f}", float(cost))
         cells: list[tuple[str, float | None]] = [
             (html.escape(str(row["arm_label"])), None),
             (html.escape(str(row["split"])), None),
@@ -1297,7 +1597,7 @@ def _runs_table_html(df: pd.DataFrame, out_dir: Path) -> str:
             (html.escape(str(row["reason"])), None),
             (str(int(row["turns"])), float(row["turns"])),
             (f"{int(row['total_tokens']):,}", float(row["total_tokens"])),
-            (f"{float(row['cost_usd']):.3f}", float(row["cost_usd"])),
+            cost_cell,
             (_fmt_seconds(float(row["duration_s"])), float(row["duration_s"])),
             (link, None),
         ]
@@ -1345,6 +1645,13 @@ def _runs_table_html(df: pd.DataFrame, out_dir: Path) -> str:
 thead th {{ background: {BAR}1a; }}
 tbody tr:nth-child(even) td {{ background: {INK}08; }}
 tr.fail td {{ background: {ACCENT}66; }}
+/* The loaded-only table names models in its second column, and closes each skill with a
+   pooled row summarising the ones above it. The delta's sign carries the direction; colour
+   only reinforces it, so the pair is never read by hue alone. */
+table.loaded td:nth-child(2) {{ text-align: left; }}
+table.loaded tr.pooled td {{ font-weight: 600; background: {BAR}1f; }}
+.gain {{ color: #3f6b4a; }}
+.loss {{ color: #a4553f; }}
 /* Sorting affordances appear only once the script has wired the table up, so with JS off
    nothing invites a click that would do nothing. The arrow is padded for, not floated over
    the label, so the heading does not shift when the column becomes the sorted one. */
@@ -1731,7 +2038,8 @@ def render_report(
 <div class="toc-title">acumen report</div>
 <ul>
 <li><a href="#overview">Overview</a><ul><li><a href="#tradeoff">Cost vs. success</a></li>
-<li><a href="#dominance">Is the difference real?</a></li></ul></li>
+<li><a href="#dominance">Is the difference real?</a></li>
+<li><a href="#loaded">Did it help when it actually loaded?</a></li></ul></li>
 <li><a href="#per-task">Per-task breakdown</a><ul>{"".join(toc_tasks)}</ul></li>
 {skills_toc}
 <li><a href="#runs">Runs</a></li>
@@ -1780,6 +2088,20 @@ def render_report(
  across resamples. Resampling is over the {tests.n_clusters} test tasks, paired across arms, so the
  unit is the task rather than the run.</p>
 {_tests_table_html(tests)}
+<h3 id="loaded">Did it help when it actually loaded?</h3>
+<p class="task-desc">A skill-arm run where the skill never loaded is not evidence about the
+ skill's body — the agent never read it, so the run measures the baseline with extra steps.
+ Those runs are held out here instead of counted against the skill, which separates a
+ <em>description</em> problem (the skill does not load) from a <em>content</em> problem (it
+ loads and does not help). Load rate varies widely by model, so the dilution is uneven across
+ the matrix. Two pooled rows close each skill, and the pair is the point: <em>all models</em>
+ pools the arm as it actually ran, while <em>models that loaded</em> restricts both sides to the
+ models that contributed a loaded run. Where the two disagree, the gap is model mix, not skill
+ effect — a model that fails every run sits in the all-models baseline while contributing
+ nothing to the loaded column. Read this as a diagnostic, not as the headline: conditioning on
+ load conditions on something the agent chose, so the loaded runs are not a random subset and a
+ gain here is not the same evidence as the test above.</p>
+{_loaded_table_html(df)}
 </section>
 <section id="per-task">
 <h2>Per-task breakdown</h2>
@@ -1842,8 +2164,8 @@ def build_report(
     # the numbers themselves. Drop the internal helper columns (Path objects and sort
     # keys) so it stays a clean, portable table.
     data_path = out_path.with_suffix(".csv")
-    internal = [c for c in ("result_path", "transcript_path", "_arm_order") if c in df.columns]
-    data = df.drop(columns=internal)
+    internal = [c for c in ("result_path", "transcript_path", "_arm_order", _REPORT_COST_COLUMN) if c in df.columns]
+    data = df.drop(columns=internal).rename(columns={"provider_cost_usd": "recorded_cost_usd"})
     if "skill_loaded" in data.columns:
         # The HTML table keeps '?' for a run whose transcript could not be read, but the CSV
         # is for counting: every row is True or False, so summing the column means what it
diff --git a/src/acumen/runner.py b/src/acumen/runner.py
index 64bdf3e..4c4abc9 100644
--- a/src/acumen/runner.py
+++ b/src/acumen/runner.py
@@ -1,4 +1,4 @@
-"""SDK invocation for a single benchmark run.
+"""Provider-neutral invocation for a single benchmark run.
 
 Runs one agent in one sandbox, captures its transcript, grades what it wrote, and emits
 ``result.json`` — the unit of record. Writing ``result.json`` last is deliberate: its
@@ -15,9 +15,8 @@
 from pathlib import Path
 from typing import TextIO
 
-from claude_agent_sdk import ClaudeAgentOptions, ResultMessage, query
-
-from acumen.env import AuthMode, Target, sdk_version
+from acumen.agents import AgentOptions, AgentResult, provider_for_model, run_agent
+from acumen.env import AuthMode, Target, agent_version
 from acumen.grade import Grade, Reason, grade_run
 from acumen.paths import (
     ANSWER_FILE,
@@ -27,11 +26,12 @@
     TRANSCRIPT_JSONL,
     RunKey,
 )
+from acumen.prices import PriceTable, normalize_usage, price_provenance, price_run, pricer, resolve_cost
 from acumen.prompts import benchmark_prompt
 from acumen.sandbox import Sandbox, sandbox
 from acumen.skills import Skill
 from acumen.tasks import Task
-from acumen.transcript import locate_transcript, render_transcript
+from acumen.transcript import locate_transcript, render_agent_transcript
 
 #: Result subtypes the CLI reports on a cap breach, mapped to our reason taxonomy.
 _SUBTYPE_REASONS: dict[str, Reason] = {
@@ -39,6 +39,29 @@
     "error_max_turns": "max_turns",
 }
 
+# Provider/account exhaustion is a failure of the benchmark infrastructure, not evidence
+# about the model. Keep these deliberately narrower than generic 429/rate-limit wording:
+# transient throttling is not proof that the account has no remaining usage or credit.
+_PROVIDER_EXHAUSTION_MARKERS = (
+    "usage limit",
+    "usage_limit",
+    "hit your limit",
+    "quota exceeded",
+    "quota_exceeded",
+    "exceeded your current quota",
+    "insufficient_quota",
+    "billing_hard_limit",
+    "credit balance",
+    "out of credits",
+    "no credits remaining",
+    "credits are exhausted",
+    "purchase more credits",
+    "payment required",
+    "spending limit",
+    "spend limit",
+    "token quota",
+)
+
 
 @dataclass(frozen=True)
 class RunOutcome:
@@ -50,7 +73,7 @@ class RunOutcome:
     payload: dict
 
 
-def _terminal_reason(message: ResultMessage) -> Reason | None:
+def _terminal_reason(message: AgentResult) -> Reason | None:
     """Map a cap breach or hard error onto a reason, or ``None`` if the agent finished.
 
     ``subtype`` is a free-form string from the CLI, so match defensively rather than
@@ -68,11 +91,30 @@ def _terminal_reason(message: ResultMessage) -> Reason | None:
     return None
 
 
+def _provider_exhaustion_error(message: AgentResult | None, error: str | None = None) -> str | None:
+    """Return provider quota/credit evidence, excluding Acumen's intentional caps.
+
+    Both adapters preserve provider error text, but their subtype vocabularies differ and
+    change over time. Matching the stable billing/quota concepts keeps the classification
+    provider-neutral while avoiding a false match on ordinary transient rate limiting.
+    """
+    if message is not None and (message.subtype or "").lower() in _SUBTYPE_REASONS:
+        return None
+    parts = [error or ""]
+    if message is not None:
+        parts.extend([message.subtype or "", *(message.errors or [])])
+    detail = "\n".join(str(part) for part in parts if part).strip()
+    lowered = detail.lower()
+    if any(marker in lowered for marker in _PROVIDER_EXHAUSTION_MARKERS):
+        return detail
+    return None
+
+
 def _find_transcript(box: Sandbox, session_id: str) -> Path | None:
     return locate_transcript(box.config_dir, box.root, session_id)
 
 
-def _skill_fired(jsonl: Path, name: str) -> bool | None:
+def _skill_fired(jsonl: Path, name: str, *, provider: str = "claude") -> bool | None:
     """Return whether the agent loaded the skill called ``name``, read from the transcript.
 
     This is the evidence the skill arm actually used the skill — the skill arm must show it
@@ -94,6 +136,18 @@ def _skill_fired(jsonl: Path, name: str) -> bool | None:
             record = json.loads(line)
         except json.JSONDecodeError:
             continue
+        if provider == "codex":
+            item = record.get("item")
+            if not isinstance(item, dict):
+                continue
+            # Codex loads repository skills from .agents/skills. The JSONL
+            # protocol exposes the command used to read the selected SKILL.md.
+            command = item.get("command")
+            if isinstance(command, str):
+                normalized = command.replace("\\", "/")
+                if f".agents/skills/{name}/SKILL.md" in normalized:
+                    return True
+            continue
         if record.get("type") != "assistant":
             continue
         content = record.get("message", {}).get("content")
@@ -115,15 +169,6 @@ def _collect_artifacts(box: Sandbox, run_dir: Path) -> None:
             shutil.copyfile(src, run_dir / name)
 
 
-def _usage_tokens(usage: dict | None) -> tuple[int, int]:
-    if not usage:
-        return 0, 0
-    inp = int(usage.get("input_tokens", 0) or 0)
-    inp += int(usage.get("cache_read_input_tokens", 0) or 0)
-    inp += int(usage.get("cache_creation_input_tokens", 0) or 0)
-    return inp, int(usage.get("output_tokens", 0) or 0)
-
-
 class StderrFilter:
     """Dedupe the CLI subprocess stderr the SDK forwards, keeping the first of each line.
 
@@ -159,8 +204,10 @@ def _build_options(
     model: str,
     max_turns: int,
     max_usd: float,
+    read_dirs: tuple[Path, ...] = (),
+    prices: PriceTable | None = None,
     stderr: Callable[[str], None] | None = None,
-) -> ClaudeAgentOptions:
+) -> AgentOptions:
     """Assemble the SDK options for one run.
 
     These options are **identical for every arm** — baseline parity means the
@@ -179,15 +226,15 @@ def _build_options(
     append ``Skill(<name>)`` to ``allowed_tools`` in the skill arm only — an options-level
     difference between arms, which is the one thing parity forbids.
     """
-    return ClaudeAgentOptions(
-        cwd=str(box.root),
+    return AgentOptions(
+        cwd=box.root,
         env=box.env,
         model=model,
         max_turns=max_turns,
-        max_budget_usd=max_usd,
-        setting_sources=["project"],
-        permission_mode="bypassPermissions",
-        system_prompt={"type": "preset", "preset": "claude_code"},
+        max_usd=max_usd,
+        discover_skills=True,
+        price_usd=pricer(model, prices),
+        read_dirs=read_dirs,
         stderr=stderr,
     )
 
@@ -208,6 +255,7 @@ async def run_once(
     keep_sandbox: bool = False,
     stderr: Callable[[str], None] | None = None,
     env_passthrough: Sequence[str] | None = None,
+    prices: PriceTable | None = None,
 ) -> RunOutcome:
     """Execute one benchmark run end to end and write its ``result.json``.
 
@@ -224,8 +272,9 @@ async def run_once(
     model, max_turns, max_usd
         Already resolved against per-task overrides by the caller.
     auth_mode
-        Which credential benchmark runs authenticate with; always ``"api"`` so the recorded
-        ``cost_usd`` reflects real metered spend.
+        Which credential the benchmark run authenticates with. Under ``"session"``, recorded
+        Claude's SDK cost is API-equivalent rather than necessarily an invoice charge;
+        Codex falls back to frozen-table token inference.
     skill
         The skill to install, or ``None`` for the baseline arm. Must agree with
         ``key.arm``, else the run would be filed under an arm it doesn't belong to.
@@ -259,7 +308,8 @@ async def run_once(
     run_dir.mkdir(parents=True, exist_ok=True)
     split = task.split(key.split)
 
-    result: ResultMessage | None = None
+    provider = provider_for_model(model)
+    result: AgentResult | None = None
     error: str | None = None
 
     with sandbox(
@@ -269,6 +319,7 @@ async def run_once(
         keep=keep_sandbox,
         skill=skill,
         env_passthrough=env_passthrough,
+        provider=provider,
     ) as box:
         prompt = benchmark_prompt(
             split.prompt,
@@ -276,30 +327,41 @@ async def run_once(
             python=target.python,
             package=target.pkg_name,
         )
-        options = _build_options(box=box, model=model, max_turns=max_turns, max_usd=max_usd, stderr=stderr)
+        options = _build_options(
+            box=box,
+            model=model,
+            max_turns=max_turns,
+            max_usd=max_usd,
+            read_dirs=(target.venv_dir,),
+            prices=prices,
+            stderr=stderr,
+        )
         try:
-            async for message in query(prompt=prompt, options=options):
-                if isinstance(message, ResultMessage):
-                    result = message
+            result = await run_agent(prompt, options=options)
         except Exception as err:  # noqa: BLE001 - a crashed agent is a recorded failure, not a crashed pass
             error = f"{type(err).__name__}: {err}"
 
         _collect_artifacts(box, run_dir)
-        if result is not None:
+        if result is not None and provider == "claude" and result.session_id is not None:
             jsonl = _find_transcript(box, result.session_id)
             if jsonl is not None:
                 shutil.copyfile(jsonl, run_dir / TRANSCRIPT_JSONL)
+        elif result is not None and provider == "codex":
+            (run_dir / TRANSCRIPT_JSONL).write_text("".join(f"{json.dumps(event)}\n" for event in result.transcript))
 
     rendered = False
     skill_loaded: bool | None = None
     expected_skill = skill.name if skill is not None else skill_name
     if (run_dir / TRANSCRIPT_JSONL).is_file():
-        rendered = render_transcript(run_dir / TRANSCRIPT_JSONL, run_dir / TRANSCRIPT_HTML)
+        rendered = render_agent_transcript(run_dir / TRANSCRIPT_JSONL, run_dir / TRANSCRIPT_HTML, provider=provider)
         if expected_skill is not None:
-            skill_loaded = _skill_fired(run_dir / TRANSCRIPT_JSONL, expected_skill)
+            skill_loaded = _skill_fired(run_dir / TRANSCRIPT_JSONL, expected_skill, provider=provider)
 
     grade: Grade = grade_run(run_dir, split.answer)
-    if error is not None or result is None:
+    exhaustion = _provider_exhaustion_error(result, error)
+    if exhaustion is not None:
+        success, reason = False, "provider_exhausted"
+    elif error is not None or result is None:
         success, reason = False, "error"
     else:
         terminal = _terminal_reason(result)
@@ -309,20 +371,47 @@ async def run_once(
         else:
             success, reason = grade.success, grade.reason
 
-    inp, out = _usage_tokens(result.usage if result else None)
+    usage = normalize_usage(result.usage if result else None, provider=provider)
+    # Preserve frozen-table inference for both providers, but prefer the SDK's value when it
+    # exists. For session authentication that provider figure is API-equivalent, not
+    # necessarily money charged on an invoice.
+    lookup = (prices or PriceTable()).lookup(model)
+    inferred = price_run(usage, None if lookup is None else lookup.rates)
+    provider_cost = result.total_cost_usd if result else None
+    cost = resolve_cost(provider_cost, inferred)
     payload = {
         "task_id": key.task_id,
         "split": key.split,
         "skill": key.skill,
         "arm": key.arm,
         "model": model,
+        "agent": provider,
+        "provider": "anthropic" if provider == "claude" else "openai",
+        "backend": "claude_agent_sdk" if provider == "claude" else "codex_cli",
+        # Which credential paid for the run. Under "session", provider cost is an
+        # API-equivalent SDK estimate rather than necessarily metered spend.
+        "auth_mode": auth_mode,
         "rep": key.rep,
         "success": success,
         "reason": reason,
+        # Provider quota/credit exhaustion invalidates the measurement. Keeping a diagnostic
+        # result is useful, but reports and resume must never treat it as benchmark evidence.
+        "valid": reason != "provider_exhausted",
         "turns": result.num_turns if result else 0,
-        "cost_usd": (result.total_cost_usd if result else None) or 0.0,
-        "input_tokens": inp,
-        "output_tokens": out,
+        "cost_usd": cost.cost_usd,
+        "cost_available": cost.available,
+        "cost_source": cost.cost_source,
+        "provider_cost_usd": cost.provider_cost_usd,
+        "inferred_cost_usd": cost.inferred_cost_usd,
+        "cost_delta_usd": cost.cost_delta_usd,
+        "cost_delta_pct": cost.cost_delta_pct,
+        **price_provenance(lookup),
+        "input_tokens": usage.input,
+        "output_tokens": usage.output,
+        "cache_read_tokens": usage.cache_read,
+        "cache_write_tokens": usage.cache_write,
+        "cache_write_5m_tokens": usage.cache_write_5m,
+        "cache_write_1h_tokens": usage.cache_write_1h,
         "duration_s": round((result.duration_ms if result else 0) / 1000, 2),
         "answer": grade.answer,
         "expected": split.answer.strip(),
@@ -332,12 +421,12 @@ async def run_once(
         "skill_name": skill.name if skill else None,
         # Evidence, not configuration: did the agent actually invoke the Skill tool?
         "skill_loaded": skill_loaded,
-        "sdk_version": sdk_version(),
+        "sdk_version": agent_version(provider),
         "session_id": result.session_id if result else None,
         "stop_reason": result.stop_reason if result else None,
         "subtype": result.subtype if result else None,
         "transcript_html": rendered,
-        "error": error or (result.errors if result else None),
+        "error": exhaustion or error or (result.errors if result else None),
     }
     (run_dir / RESULT_FILE).write_text(json.dumps(payload, indent=2) + "\n")
     return RunOutcome(key=key, success=success, reason=reason, payload=payload)
diff --git a/src/acumen/sandbox.py b/src/acumen/sandbox.py
index e6137f2..d178932 100644
--- a/src/acumen/sandbox.py
+++ b/src/acumen/sandbox.py
@@ -2,10 +2,10 @@
 
 The agent sees an installed package and nothing else — no repo source, no user
 settings, no memories. Each run gets its own sandbox, throwaway ``HOME`` and throwaway
-``CLAUDE_CONFIG_DIR``, so runs cannot see each other either.
+provider config directory, so runs cannot see each other either.
 
 A skill arm differs from the baseline in exactly one way: ``skills/v{n}/`` is
-copied into ``<sandbox>/.claude/skills/<name>/``, where the agent's own project settings
+copied into the selected provider's project skill directory, where the agent's own
 discovery finds it. Same prompt, same tools, same caps, same env otherwise.
 """
 
@@ -18,12 +18,15 @@
 from dataclasses import dataclass
 from pathlib import Path
 
+from acumen.agents import AgentProvider
 from acumen.env import AuthMode, Target, build_agent_env
 from acumen.procs import label_env, reap
 from acumen.skills import Skill, content_files
 
-#: Where the ``claude`` CLI looks for project skills, relative to the agent's cwd.
-SKILLS_SUBDIR = Path(".claude") / "skills"
+SKILLS_SUBDIRS = {
+    "claude": Path(".claude") / "skills",
+    "codex": Path(".agents") / "skills",
+}
 
 
 @dataclass(frozen=True)
@@ -35,17 +38,18 @@ class Sandbox:
     config_dir: Path
     env: dict[str, str]
     authenticated: bool
+    provider: AgentProvider = "claude"
     skill: Skill | None = None
 
     @property
     def transcript_root(self) -> Path:
-        """Where the ``claude`` CLI writes transcripts for this run."""
+        """Where Claude writes transcripts for this run (unused by Codex)."""
         return self.config_dir / "projects"
 
     @property
     def skills_dir(self) -> Path:
-        """The project skills directory the agent discovers, ``<root>/.claude/skills``."""
-        return self.root / SKILLS_SUBDIR
+        """The project skills directory the selected agent discovers."""
+        return self.root / SKILLS_SUBDIRS[self.provider]
 
     @property
     def skill_hash(self) -> str | None:
@@ -53,7 +57,7 @@ def skill_hash(self) -> str | None:
         return self.skill.hash if self.skill else None
 
 
-def install_skill(root: Path, skill: Skill) -> Path:
+def install_skill(root: Path, skill: Skill, *, provider: AgentProvider = "claude") -> Path:
     """Copy a skill's content into a sandbox as a discoverable project skill.
 
     ``meta.json`` is deliberately left behind: it is acumen's provenance record, and the
@@ -68,9 +72,9 @@ def install_skill(root: Path, skill: Skill) -> Path:
 
     Returns
     -------
-    The installed skill directory, ``<root>/.claude/skills/<name>``.
+    The selected provider's installed project-skill directory.
     """
-    dest = root / SKILLS_SUBDIR / skill.name
+    dest = root / SKILLS_SUBDIRS[provider] / skill.name
     dest.mkdir(parents=True, exist_ok=True)
     for src in content_files(skill.directory):
         target = dest / src.relative_to(skill.directory)
@@ -88,6 +92,7 @@ def sandbox(
     keep: bool = False,
     skill: Skill | None = None,
     env_passthrough: Sequence[str] | None = None,
+    provider: AgentProvider = "claude",
 ) -> Iterator[Sandbox]:
     """Create a fresh sandbox for one run and clean it up afterwards.
 
@@ -97,7 +102,9 @@ def sandbox(
         The prepared target; its venv ``bin`` goes on the sandbox PATH.
     auth_mode
         Which credential the run authenticates with (see :func:`acumen.env.build_agent_env`).
-        Benchmark runs always pass ``"api"`` so the recorded ``cost_usd`` is real.
+        Benchmark runs pass their resolved ``--auth`` mode. Under ``"session"``, recorded
+        Claude's SDK value is API-equivalent rather than necessarily metered spend;
+        Codex uses frozen-table token inference.
     base
         Parent directory for the sandbox. Defaults to the system temp dir.
     keep
@@ -118,11 +125,11 @@ def sandbox(
     try:
         root = holder / "work"
         home = holder / "home"
-        config_dir = home / ".claude"
+        config_dir = home / (".claude" if provider == "claude" else ".codex")
         for path in (root, home, config_dir, home / "tmp"):
             path.mkdir(parents=True, exist_ok=True)
         if skill is not None:
-            install_skill(root, skill)
+            install_skill(root, skill, provider=provider)
         # The marker is what lets the teardown below find whatever this agent leaves running.
         env = label_env(
             build_agent_env(
@@ -131,6 +138,7 @@ def sandbox(
                 extra_path=[target.bin_dir],
                 auth_mode=auth_mode,
                 extra_allow=env_passthrough,
+                provider=provider,
             ),
             holder,
         )
@@ -141,6 +149,7 @@ def sandbox(
             env=env,
             # Only session mode seeds the OAuth login into the throwaway config dir.
             authenticated=auth_mode == "session",
+            provider=provider,
             skill=skill,
         )
     finally:
diff --git a/src/acumen/scaffold.py b/src/acumen/scaffold.py
index 5804c5b..1d4ab0c 100644
--- a/src/acumen/scaffold.py
+++ b/src/acumen/scaffold.py
@@ -20,11 +20,13 @@
 
 repo: https://github.com/OWNER/REPO   # GitHub URL, or a local path to an installable package
 ref: main                             # branch, tag, or commit (ignored for local paths)
-extras: []                            # optional pip extras, e.g. [dev, test]
+extras: []                            # pip extras the target publishes, e.g. [test]
+dependency_groups: []                 # PEP 735 groups from the target's pyproject, e.g. [full]
+pip_packages: []                      # packages the target declares nowhere, e.g. [harmonypy]
 python: "3.12"                        # interpreter for the target's throwaway venv
 env_passthrough: []                   # extra env vars agents may keep (e.g. [OMP_NUM_THREADS]); the agent env is otherwise a clean allowlist
 
-models: [claude-opus-5, claude-sonnet-5, claude-haiku-4-5-20251001]   # benchmark models; a pass is models x tasks x reps x splits
+models: [claude-opus-5, claude-sonnet-5, claude-haiku-4-5-20251001, gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna]   # Claude + Codex benchmark models; a pass is models x tasks x reps x splits
 n_replicates: 3                       # runs per (model, task, split) cell
 max_concurrency: 4                    # simultaneous agents
 
@@ -81,6 +83,20 @@ class InitError(ValueError):
     """Raised when scaffolding cannot proceed — e.g. files exist and ``force`` is unset."""
 
 
+def is_scaffold_tasks(path: Path) -> bool:
+    """Whether ``path`` is still the untouched ``tasks.yaml`` placeholder from :func:`scaffold`.
+
+    ``acumen init`` writes a placeholder and ``acumen tasks`` generates the real thing, so the
+    documented first two steps of the loop collide: the generator would refuse to overwrite a
+    file the user never wrote. A byte-identical match to the template is the safe test — edit
+    one character and the file is yours again, and refusing to clobber it is correct.
+    """
+    try:
+        return path.read_text() == TASKS_TEMPLATE
+    except OSError:
+        return False
+
+
 def scaffold(directory: Path, *, force: bool = False) -> list[Path]:
     """Write starter ``config.yaml`` and ``tasks.yaml`` into ``directory``.
 
diff --git a/src/acumen/ship.py b/src/acumen/ship.py
index 0e8cdcc..54ae45d 100644
--- a/src/acumen/ship.py
+++ b/src/acumen/ship.py
@@ -13,11 +13,11 @@
 stages for it is a clean copy of the skill content (``SKILL.md`` + ``references/``, with acumen's
 ``meta.json`` bookkeeping stripped) to be copied verbatim into the wheel.
 
-**Deliberately NOT isolated.** Unlike every other agent, the shipper runs in the user's
-real environment — real network, real git/``gh`` credentials, real ``uv`` — because it builds,
-installs, pushes, and opens a PR. There is nothing to keep honest here: its output is a PR the
-maintainer reviews (or a working-tree diff), so isolation would only stop it doing its job. The
-correctness gate is therefore not env scrubbing but the **build-verify** the agent performs:
+The shipper retains the user's git/``gh`` environment and public network because it builds,
+installs, pushes, and opens a PR, but it still runs inside the same fail-closed filesystem
+sandbox as every other agent. Its writable roots are the target checkout and a temporary home;
+the staged skill and target environment are read-only. The **build-verify** the agent performs
+remains the correctness gate:
 build the wheel in a fresh venv, install it, run the entry point, confirm ``SKILL.md`` ships from
 the installed location — the only thing that catches a mis-wired backend shipping a wheel with no
 skill data. That gate lives in the agent's own turns; acumen trusts the agent's report.
@@ -32,11 +32,20 @@
 from dataclasses import dataclass
 from pathlib import Path
 
-from claude_agent_sdk import ClaudeAgentOptions, ResultMessage, query
-
+from acumen.agents import AgentOptions, AgentProvider, AgentResult, provider_for_model, run_agent
 from acumen.config import Config
-from acumen.env import API_AUTH_ENV_VARS, SESSION_AUTH_ENV_VAR, AuthMode, Target, claude_cli_dir
+from acumen.env import (
+    API_AUTH_ENV_VARS,
+    CODEX_API_AUTH_ENV_VARS,
+    SESSION_AUTH_ENV_VAR,
+    AuthMode,
+    Target,
+    agent_cli_dir,
+    seed_codex_credentials,
+    seed_credentials,
+)
 from acumen.logs import LiveLog
+from acumen.prices import PriceTable, price_usage, pricer, resolve_cost
 from acumen.procs import label_env, reap
 from acumen.prompts import ship_prompt
 from acumen.skills import Skill, content_files, load_skill
@@ -58,7 +67,7 @@ class ShipResult:
     mode: str
     #: The agent's final message — for a GitHub target it carries the PR URL.
     summary: str
-    cost_usd: float
+    cost_usd: float | None
     turns: int
     #: Live log paths for this run, when a :class:`LiveLog` was attached.
     log_jsonl: Path | None = None
@@ -124,8 +133,15 @@ def _stage_skill_payload(skill: Skill, dest: Path) -> Path:
     return dest
 
 
-def _ship_env(target: Target, auth_mode: AuthMode) -> dict[str, str]:
-    """The environment for the (unisolated) ship agent: the real env, target venv on PATH.
+def _ship_env(
+    target: Target,
+    auth_mode: AuthMode,
+    provider: AgentProvider = "claude",
+    *,
+    home: Path | None = None,
+    config_dir: Path | None = None,
+) -> dict[str, str]:
+    """Build the shipper environment, optionally rooted in a temporary home.
 
     Unlike the benchmark and meta-agents this is NOT scrubbed — the agent needs real
     git/``gh`` credentials, network, and ``uv``. The target venv's ``bin`` is prepended so
@@ -135,7 +151,9 @@ def _ship_env(target: Target, auth_mode: AuthMode) -> dict[str, str]:
     The one exception is the model credential: to bill the chosen ``auth_mode`` deterministically
     we neutralize the *other* mode's variables — ``"session"`` clears the metered API/cloud keys
     (the user's real ``~/.claude`` OAuth login then authenticates), ``"api"`` clears the
-    subscription OAuth token (the API key then wins). Everything non-credential is still carried
+    subscription OAuth token (the API key then wins). The other *provider's* credentials are
+    cleared too, whichever mode is chosen: they cannot authenticate this run, so carrying them
+    would only hand the agent a second API key. Everything non-credential is still carried
     through.
 
     The cleared variables are set to ``""``, not deleted: the SDK merges this mapping over
@@ -144,33 +162,40 @@ def _ship_env(target: Target, auth_mode: AuthMode) -> dict[str, str]:
     explicit empty value overrides the inherited one, which the CLI reads as unset.
     """
     env = dict(os.environ)
-    drop = API_AUTH_ENV_VARS if auth_mode == "session" else (SESSION_AUTH_ENV_VAR,)
+    if provider == "claude":
+        drop = [*CODEX_API_AUTH_ENV_VARS]
+        drop += API_AUTH_ENV_VARS if auth_mode == "session" else [SESSION_AUTH_ENV_VAR]
+    else:
+        drop = [*API_AUTH_ENV_VARS, SESSION_AUTH_ENV_VAR]
+        if auth_mode == "session":
+            drop += CODEX_API_AUTH_ENV_VARS
     for var in drop:
         env[var] = ""
+    if provider == "codex" and auth_mode == "api":
+        env["CODEX_API_KEY"] = os.environ.get("CODEX_API_KEY") or os.environ.get("OPENAI_API_KEY", "")
     parts = [str(target.bin_dir)]
-    cli_dir = claude_cli_dir()
+    cli_dir = agent_cli_dir(provider)
     if cli_dir is not None:
         parts.append(str(cli_dir))
     existing = env.get("PATH", "")
     if existing:
         parts.append(existing)
     env["PATH"] = os.pathsep.join(parts)
+    if home is not None:
+        env.update(
+            HOME=str(home),
+            TMPDIR=str(home / "tmp"),
+            XDG_CONFIG_HOME=str(home / ".config"),
+            XDG_CACHE_HOME=str(home / ".cache"),
+        )
+    if config_dir is not None:
+        env["CLAUDE_CONFIG_DIR"] = str(config_dir)
+        env["CODEX_HOME"] = str(config_dir)
+        if auth_mode == "session":
+            (seed_credentials if provider == "claude" else seed_codex_credentials)(config_dir)
     return env
 
 
-def _config_dir(env: dict[str, str]) -> Path:
-    """The ``CLAUDE_CONFIG_DIR`` the ship agent's transcript lands under.
-
-    The ship agent is unisolated, so it uses the user's real config dir — ``CLAUDE_CONFIG_DIR``
-    if set, else ``$HOME/.claude`` — never a throwaway.
-    """
-    explicit = env.get("CLAUDE_CONFIG_DIR")
-    if explicit:
-        return Path(explicit)
-    home = env.get("HOME") or str(Path.home())
-    return Path(home) / ".claude"
-
-
 async def ship_skill(
     *,
     cfg: Config,
@@ -178,6 +203,7 @@ async def ship_skill(
     skills_root: Path,
     version: str,
     auth_mode: AuthMode = "session",
+    prices: PriceTable | None = None,
     model: str | None = None,
     max_turns: int | None = None,
     max_usd: float | None = None,
@@ -200,8 +226,8 @@ async def ship_skill(
         The skill version to ship, e.g. ``v2``. Required — there is no implicit "latest"/"best".
     auth_mode
         Which credential the ship agent authenticates with — ``"session"`` (the Claude
-        subscription) or ``"api"``. Only the model credential is affected; the agent still runs
-        in the user's real environment with real git/``gh``/network access.
+        subscription) or ``"api"``. The agent retains git/``gh`` environment credentials and
+        public network access inside its filesystem sandbox.
     model
         Override for the ship model; defaults to ``cfg.ship_model``.
     max_turns, max_usd
@@ -230,6 +256,13 @@ async def ship_skill(
     holder = Path(tempfile.mkdtemp(prefix="acumen-ship-"))
     try:
         skill_src = _stage_skill_payload(skill, holder / "skill")
+        selected_model = model or cfg.ship_model
+        table = prices if prices is not None else PriceTable(overrides=cfg.prices)
+        provider = provider_for_model(selected_model)
+        home = holder / "home"
+        config_dir = home / (".claude" if provider == "claude" else ".codex")
+        for path in (home, config_dir, home / "tmp", home / ".config", home / ".cache"):
+            path.mkdir(parents=True, exist_ok=True)
 
         prompt = ship_prompt(
             package=target.pkg_name,
@@ -239,41 +272,44 @@ async def ship_skill(
             skill_src=skill_src,
             mode=mode,
         )
-        options = ClaudeAgentOptions(
+        options = AgentOptions(
             # The agent edits the checkout in place, so its cwd IS the checkout.
-            cwd=str(target.src_dir),
+            cwd=target.src_dir,
             # Real environment — NOT scrubbed: git/gh creds + network + uv. Marked with the
             # holder so the teardown below can find whatever the agent leaves running; the
             # holder path appears nowhere else in this agent's environment.
-            env=label_env(_ship_env(target, auth_mode), holder),
-            model=model or cfg.ship_model,
+            env=label_env(
+                _ship_env(target, auth_mode, provider, home=home, config_dir=config_dir),
+                holder,
+            ),
+            model=selected_model,
             # No default budget cap: only bound the agent if the caller asked.
             max_turns=max_turns,
-            max_budget_usd=max_usd,
+            max_usd=max_usd,
+            # Codex reports no billed figure, so a budget cap needs the run's own rate table.
+            price_usd=pricer(selected_model, table),
             # It reads the staged skill payload to copy into the wheel.
-            add_dirs=[str(skill_src)],
+            read_dirs=(skill_src, target.venv_dir),
+            write_dirs=(target.src_dir, holder),
             # No skill discovery: the shipper packages a skill, it does not consume one.
-            setting_sources=[],
-            permission_mode="bypassPermissions",
-            system_prompt={"type": "preset", "preset": "claude_code"},
+            discover_skills=False,
         )
 
-        result: ResultMessage | None = None
+        result: AgentResult | None = None
         agent_error: Exception | None = None
         try:
-            async for message in query(prompt=prompt, options=options):
-                if log is not None:
-                    log.append(message)
-                if isinstance(message, ResultMessage):
-                    result = message
+            result = await run_agent(
+                prompt,
+                options=options,
+                on_event=log.append if log is not None else None,
+            )
         except Exception as err:  # noqa: BLE001 - a failed ship is an error to report, re-raised below
             agent_error = err
         finally:
-            # The ship agent is unisolated, so its transcript lands under the user's real config
-            # dir (not a throwaway). Render the HTML log in a finally so an aborted run (the SDK
-            # raises on a cap breach, after yielding the result) is still inspectable.
+            # Render while the throwaway config still holds the native transcript. Keep this in
+            # a finally so a cap breach remains inspectable.
             if log is not None:
-                log.finalize(config_dir=_config_dir(options.env), work_dir=target.src_dir, result=result)
+                log.finalize(config_dir=config_dir, work_dir=target.src_dir, result=result)
 
         if agent_error is not None:
             raise ShipError(f"the shipping agent failed: {type(agent_error).__name__}: {agent_error}") from agent_error
@@ -286,7 +322,15 @@ async def ship_skill(
             skill=skill,
             mode=mode,
             summary=result.result or "",
-            cost_usd=result.total_cost_usd or 0.0,
+            cost_usd=resolve_cost(
+                result.total_cost_usd,
+                price_usage(
+                    result.usage,
+                    model=selected_model,
+                    provider=result.provider,
+                    prices=table,
+                ),
+            ).cost_usd,
             turns=result.num_turns,
             log_jsonl=log.jsonl_path if log is not None else None,
             log_html=log.html_path if log is not None and log.html_rendered else None,
diff --git a/src/acumen/taskgen.py b/src/acumen/taskgen.py
index 0fa0291..0c0e264 100644
--- a/src/acumen/taskgen.py
+++ b/src/acumen/taskgen.py
@@ -11,7 +11,8 @@
 ``HOME`` and ``CLAUDE_CONFIG_DIR``.
 
 **Existing skills must not bias task generation.** A target repo may already ship skills or
-agent-instruction files (``SKILL.md``, ``.claude/skills/``, ``CLAUDE.md``, ``AGENTS.md``,
+agent-instruction files (``SKILL.md``, ``.agents/skills/``, ``.claude/skills/``,
+``CLAUDE.md``, ``AGENTS.md``,
 ``.cursor/``, Copilot instructions). If the generator read them, it would mine the tasks the
 author already anticipated and phrase them the way the skill does — defeating the point of an
 independent benchmark. So, as with the test-split guard, this is enforced two ways: the agent
@@ -34,14 +35,18 @@
 import tempfile
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import yaml
-from claude_agent_sdk import ClaudeAgentOptions, HookMatcher, ResultMessage, query
 
+if TYPE_CHECKING:
+    from claude_agent_sdk import HookMatcher
+
+from acumen.agents import AgentOptions, AgentResult, provider_for_model, run_agent
 from acumen.config import Config
 from acumen.env import AuthMode, Target, build_agent_env
 from acumen.logs import LiveLog
+from acumen.prices import PriceTable, price_usage, pricer, resolve_cost
 from acumen.procs import label_env, reap
 from acumen.prompts import taskgen_prompt
 from acumen.tasks import Task, TaskError, load_tasks
@@ -55,8 +60,8 @@
 _ARTIFACT_BASENAMES = frozenset({"SKILL.md", "CLAUDE.md", "AGENTS.md", "copilot-instructions.md"})
 
 #: Directory names that hold agent guidance; dropped from the copy and denied wherever they
-#: appear on a resolved path (``.claude/skills``, ``.cursor/rules``, …).
-_ARTIFACT_DIRS = frozenset({".claude", ".cursor"})
+#: appear on a resolved path (``.agents/skills``, ``.claude/skills``, ``.cursor/rules``, …).
+_ARTIFACT_DIRS = frozenset({".agents", ".claude", ".codex", ".cursor"})
 
 #: tool_input keys carrying a filesystem path — the coarse set the improver's guard also uses.
 _PATH_KEYS = ("file_path", "path", "notebook_path", "filename")
@@ -75,7 +80,7 @@ class TaskGenResult:
 
     tasks: list[Task]
     out_path: Path
-    cost_usd: float
+    cost_usd: float | None
     turns: int
     #: Live log paths for this run, when a :class:`LiveLog` was attached.
     log_jsonl: Path | None = None
@@ -111,7 +116,7 @@ def ignore(dir_path: str, names: list[str]) -> set[str]:
 def build_filtered_source(src: Path, dest: Path) -> Path:
     """Copy ``src`` to ``dest`` with skills and agent-guidance stripped out.
 
-    This is the structural half of the skill-bias isolation: the generator's ``add_dirs`` points
+    This is the structural half of the skill-bias isolation: the generator's read policy points
     at the returned copy, not the real checkout, so existing skills are simply absent from what
     it can read.
 
@@ -194,6 +199,10 @@ def make_skill_guard(original_src: Path) -> HookMatcher:
     ``matcher=None`` fires the hook for every tool. Paths are resolved against the real source
     checkout, so the guard holds regardless of the agent's ``cwd``.
     """
+    # Imported here, not at module scope: the Claude SDK is an optional dependency and a
+    # Codex-only install never builds an SDK hook.
+    from claude_agent_sdk import HookMatcher
+
     root = original_src.resolve()
 
     async def guard(input_data: dict[str, Any], tool_use_id: str | None, context: Any) -> dict[str, Any]:
@@ -281,6 +290,7 @@ async def generate_tasks(
     target: Target,
     out_path: Path,
     auth_mode: AuthMode = "session",
+    prices: PriceTable | None = None,
     model: str | None = None,
     max_turns: int | None = None,
     max_usd: float | None = None,
@@ -333,7 +343,10 @@ async def generate_tasks(
     try:
         work = holder / "work"
         home = holder / "home"
-        config_dir = home / ".claude"
+        selected_model = model or cfg.tasks_model
+        table = prices if prices is not None else PriceTable(overrides=cfg.prices)
+        provider = provider_for_model(selected_model)
+        config_dir = home / (".claude" if provider == "claude" else ".codex")
         for path in (work, home, config_dir, home / "tmp"):
             path.mkdir(parents=True, exist_ok=True)
         staged = work / TASKS_FILE
@@ -350,6 +363,7 @@ async def generate_tasks(
                 extra_path=[target.bin_dir],
                 auth_mode=auth_mode,
                 extra_allow=cfg.env_passthrough,
+                provider=provider,
             ),
             holder,
         )
@@ -361,33 +375,37 @@ async def generate_tasks(
             out=staged,
             feedback=feedback,
         )
-        options = ClaudeAgentOptions(
-            cwd=str(work),
+        options = AgentOptions(
+            cwd=work,
             env=env,
-            model=model or cfg.tasks_model,
+            model=selected_model,
             # No default budget cap: only bound the agent if the caller asked.
             max_turns=max_turns,
-            max_budget_usd=max_usd,
+            max_usd=max_usd,
+            # Codex reports no billed figure, so a budget cap needs the run's own rate table.
+            price_usd=pricer(selected_model, table),
             # The generator reads the target source, like the drafter; benchmark agents
             # never do. It points at the *filtered* copy, not the real checkout.
-            add_dirs=[str(source_copy)],
+            read_dirs=(source_copy, target.venv_dir),
+            write_dirs=(work,),
             # No skill discovery at all — the generator must not load a skill that would bias it.
-            setting_sources=[],
-            permission_mode="bypassPermissions",
-            system_prompt={"type": "preset", "preset": "claude_code"},
+            discover_skills=False,
             # Belt-and-braces over the filtered copy: deny any call that reaches an existing
-            # skill/guidance artifact or the original unfiltered source, wherever pointed.
-            hooks={"PreToolUse": [make_skill_guard(target.src_dir)]},
+            # skill/guidance artifact or the original unfiltered source, wherever pointed. Built
+            # only for Claude — the hook is an SDK object, and Codex gets ``deny_paths`` below.
+            claude_hooks={"PreToolUse": [make_skill_guard(target.src_dir)]} if provider == "claude" else None,
+            # Codex reads the filtered copy and is denied the original checkout.
+            deny_paths=(target.src_dir.resolve(),),
         )
 
-        result: ResultMessage | None = None
+        result: AgentResult | None = None
         agent_error: Exception | None = None
         try:
-            async for message in query(prompt=prompt, options=options):
-                if log is not None:
-                    log.append(message)
-                if isinstance(message, ResultMessage):
-                    result = message
+            result = await run_agent(
+                prompt,
+                options=options,
+                on_event=log.append if log is not None else None,
+            )
         except Exception as err:  # noqa: BLE001 - a failed generation is an error to report, re-raised below
             agent_error = err
         finally:
@@ -413,7 +431,15 @@ async def generate_tasks(
         return TaskGenResult(
             tasks=generated,
             out_path=out_path,
-            cost_usd=result.total_cost_usd or 0.0,
+            cost_usd=resolve_cost(
+                result.total_cost_usd,
+                price_usage(
+                    result.usage,
+                    model=selected_model,
+                    provider=result.provider,
+                    prices=table,
+                ),
+            ).cost_usd,
             turns=result.num_turns,
             log_jsonl=log.jsonl_path if log is not None else None,
             log_html=log.html_path if log is not None and log.html_rendered else None,
diff --git a/src/acumen/transcript.py b/src/acumen/transcript.py
index b659945..7668240 100644
--- a/src/acumen/transcript.py
+++ b/src/acumen/transcript.py
@@ -1,4 +1,4 @@
-"""Locating and rendering SDK-native transcripts — shared by the runner and the meta-agents.
+"""Locating and rendering agent transcripts — shared by the runner and the meta-agents.
 
 The benchmark runner has always done this per run: after an agent finishes, find the
 transcript the ``claude`` CLI wrote (under ``<CLAUDE_CONFIG_DIR>/projects/<key>/<session>.jsonl``),
@@ -7,18 +7,25 @@
 can render an HTML log of their own agent the same way, instead of losing the transcript to the
 ``rmtree`` of a throwaway config dir.
 
-The transcript path is fully determined by the throwaway ``CLAUDE_CONFIG_DIR`` and the agent's
-``cwd`` (both of which acumen sets) plus the ``session_id`` on the ``ResultMessage``.
+The Claude transcript path is fully determined by the throwaway ``CLAUDE_CONFIG_DIR`` and the
+agent's ``cwd`` (both of which acumen sets) plus the ``session_id`` on the ``ResultMessage``.
+
+Codex is rendered here rather than handed to ``claude-code-log``: that tool reads the SDK-native
+format only, and given a Codex event stream it skips every line, **still exits 0**, and writes an
+empty page — a silent wrong answer. :func:`render_codex_transcript` renders the event stream
+acumen already captures, so both providers produce a readable HTML log from their own format.
 """
 
 from __future__ import annotations
 
+import json
 import shutil
 import subprocess
 import sys
+from collections.abc import Iterable
+from html import escape
 from pathlib import Path
-
-from claude_agent_sdk import project_key_for_directory
+from typing import Any
 
 
 def locate_transcript(config_dir: Path, work_dir: Path, session_id: str) -> Path | None:
@@ -33,7 +40,7 @@ def locate_transcript(config_dir: Path, work_dir: Path, session_id: str) -> Path
     ----------
     config_dir
         The ``CLAUDE_CONFIG_DIR`` the agent ran under (throwaway, for isolated agents; the
-        user's real one for the unisolated ship agent).
+        run-local one used by the agent).
     work_dir
         The agent's ``cwd`` — what the project key is computed from.
     session_id
@@ -43,6 +50,10 @@ def locate_transcript(config_dir: Path, work_dir: Path, session_id: str) -> Path
     -------
     The transcript path, or ``None`` if it could not be found.
     """
+    # Imported lazily: a Codex-only install has no Claude SDK, and this module is imported by
+    # the runner on every run regardless of provider.
+    from claude_agent_sdk import project_key_for_directory
+
     transcript_root = config_dir / "projects"
     key = project_key_for_directory(str(work_dir))
     direct = transcript_root / key / f"{session_id}.jsonl"
@@ -55,9 +66,10 @@ def locate_transcript(config_dir: Path, work_dir: Path, session_id: str) -> Path
 def claude_code_log() -> str | None:
     """Locate the ``claude-code-log`` CLI.
 
-    It is a dependency of acumen, so it lives next to the interpreter running us — look there
-    before PATH, which won't contain the venv's ``bin`` when acumen is invoked by absolute path
-    rather than through an activated venv.
+    It ships with acumen's ``claude`` extra, so it lives next to the interpreter running us —
+    look there before PATH, which won't contain the venv's ``bin`` when acumen is invoked by
+    absolute path rather than through an activated venv. ``None`` when it is not installed,
+    which is the normal state of a Codex-only install.
     """
     local = Path(sys.executable).parent / "claude-code-log"
     if local.is_file():
@@ -75,3 +87,143 @@ def render_transcript(jsonl: Path, html: Path) -> bool:
         return False
     proc = subprocess.run([cli, str(jsonl), "-o", str(html)], capture_output=True, text=True)
     return proc.returncode == 0 and html.is_file()
+
+
+_CODEX_CSS = """\
+:root { color-scheme: light dark; }
+body { font: 14px/1.5 ui-sans-serif, system-ui, sans-serif; margin: 0 auto; max-width: 60rem; padding: 2rem 1rem; }
+h1 { font-size: 1.25rem; margin: 0 0 .25rem; }
+.meta { color: #6b7280; font-size: .8rem; margin-bottom: 1.5rem; }
+.item { border-left: 3px solid #d1d5db; margin: 0 0 1rem; padding: .25rem 0 .25rem .75rem; }
+.item > .label { color: #6b7280; font-size: .7rem; letter-spacing: .04em; text-transform: uppercase; }
+.agent_message { border-left-color: #6b8f71; }
+.reasoning { border-left-color: #b6a8c9; color: #6b7280; }
+.command_execution { border-left-color: #7f9cb5; }
+.file_change { border-left-color: #d0a05a; }
+.failed { border-left-color: #c0685c; }
+pre { background: #00000010; border-radius: .25rem; margin: .35rem 0 0; overflow-x: auto; padding: .5rem .65rem; white-space: pre-wrap; word-break: break-word; }
+.text { white-space: pre-wrap; }
+.exit { color: #6b7280; font-size: .75rem; }
+table { border-collapse: collapse; font-size: .8rem; margin-top: .5rem; }
+td { border-top: 1px solid #d1d5db; padding: .2rem .75rem .2rem 0; }
+td.n { text-align: right; }
+"""
+
+#: How much of one command's captured output the page keeps. A benchmark agent can print a
+#: whole dataframe; the transcript is for reading, and the full output is in the JSONL beside it.
+_OUTPUT_CAP = 20_000
+
+
+def _codex_block(item: dict[str, Any], *, incomplete: bool) -> str:
+    """Render one Codex item as an HTML block."""
+    kind = str(item.get("type") or "item")
+    label = kind.replace("_", " ") + (" (unfinished)" if incomplete else "")
+    parts = [
+        f'<div class="item {escape(kind)}{" failed" if incomplete else ""}">',
+        f'<div class="label">{escape(label)}</div>',
+    ]
+    if kind in {"agent_message", "reasoning"}:
+        parts.append(f'<div class="text">{escape(str(item.get("text") or ""))}</div>')
+    elif kind == "command_execution":
+        parts.append(f"<pre>{escape(str(item.get('command') or ''))}</pre>")
+        output = str(item.get("aggregated_output") or "")
+        if output.strip():
+            clipped = output[:_OUTPUT_CAP]
+            suffix = "" if len(output) <= _OUTPUT_CAP else f"\n… {len(output) - _OUTPUT_CAP} more characters"
+            parts.append(f"<pre>{escape(clipped + suffix)}</pre>")
+        code = item.get("exit_code")
+        if code is not None:
+            parts.append(f'<div class="exit">exit {escape(str(code))}</div>')
+    else:
+        # file_change, mcp_tool_call, web_search, todo_list, and anything Codex adds later:
+        # dump the item verbatim rather than silently drop what we have no template for.
+        body = {key: value for key, value in item.items() if key not in {"id", "type"}}
+        parts.append(f"<pre>{escape(json.dumps(body, indent=2, default=str))}</pre>")
+    parts.append("</div>")
+    return "".join(parts)
+
+
+def _codex_usage_table(usage: dict[str, Any]) -> str:
+    rows = "".join(
+        f"<tr><td>{escape(str(key))}</td><td class='n'>{escape(str(value))}</td></tr>" for key, value in usage.items()
+    )
+    return f"<table>{rows}</table>"
+
+
+def render_codex_events(events: Iterable[dict[str, Any]], html: Path) -> bool:
+    """Render a ``codex exec --json`` event stream to a standalone HTML file.
+
+    Items are rendered in the order Codex completed them. An item that only ever ``started`` —
+    what a run terminated at its turn cap leaves behind — is rendered too, marked unfinished, so
+    a capped run still shows what it was doing when acumen stopped it.
+
+    Returns
+    -------
+    Whether the file was written.
+    """
+    started: dict[str, dict[str, Any]] = {}
+    blocks: list[str] = []
+    session = ""
+    usage: dict[str, Any] = {}
+    errors: list[str] = []
+    for event in events:
+        kind = event.get("type")
+        if kind == "thread.started":
+            session = str(event.get("thread_id") or "")
+        elif kind == "turn.completed":
+            raw = event.get("usage")
+            if isinstance(raw, dict):
+                usage = raw
+        elif kind in {"error", "turn.failed"}:
+            errors.append(str(event.get("message") or event.get("error") or event))
+        elif kind in {"item.started", "item.completed"}:
+            item = event.get("item")
+            if not isinstance(item, dict):
+                continue
+            key = str(item.get("id") or len(blocks))
+            if kind == "item.started":
+                started[key] = item
+            else:
+                started.pop(key, None)
+                blocks.append(_codex_block(item, incomplete=False))
+    blocks.extend(_codex_block(item, incomplete=True) for item in started.values())
+    if errors:
+        joined = escape("\n".join(errors))
+        blocks.append(f'<div class="item failed"><div class="label">error</div><pre>{joined}</pre></div>')
+
+    meta = f"thread {escape(session)}" if session else "no thread id"
+    body = "".join(blocks) or '<div class="item"><div class="label">no events</div></div>'
+    footer = _codex_usage_table(usage) if usage else ""
+    html.parent.mkdir(parents=True, exist_ok=True)
+    html.write_text(
+        "<!doctype html>\n"
+        '<html lang="en"><head><meta charset="utf-8">'
+        '<meta name="viewport" content="width=device-width, initial-scale=1">'
+        f"<title>codex transcript</title><style>{_CODEX_CSS}</style></head><body>"
+        f'<h1>codex transcript</h1><div class="meta">{meta}</div>{body}{footer}'
+        "</body></html>\n",
+        encoding="utf-8",
+    )
+    return html.is_file()
+
+
+def render_codex_transcript(jsonl: Path, html: Path) -> bool:
+    """Render a saved Codex event stream (one JSON object per line) to HTML."""
+    try:
+        lines = jsonl.read_text(encoding="utf-8").splitlines()
+    except OSError:
+        return False
+    events: list[dict[str, Any]] = []
+    for line in lines:
+        try:
+            event = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(event, dict):
+            events.append(event)
+    return render_codex_events(events, html)
+
+
+def render_agent_transcript(jsonl: Path, html: Path, *, provider: str) -> bool:
+    """Render a run's transcript with the renderer that understands its format."""
+    return render_codex_transcript(jsonl, html) if provider == "codex" else render_transcript(jsonl, html)
diff --git a/tests/conftest.py b/tests/conftest.py
index 4518751..df56c6a 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,8 +1,8 @@
 """Shared fixtures for the acumen test suite.
 
 The suite is deliberately small and offline: it covers the CLI's main commands and the
-pure helpers underneath them, and never spawns an agent. Anything that would call the
-Claude Agent SDK (``draft``, ``improve``, ``tasks``, ``ship``) is only exercised up to
+pure helpers underneath them, and never spawns an agent. Anything that would call a
+Claude or Codex agent (``draft``, ``improve``, ``tasks``, ``ship``) is only exercised up to
 the pre-flight checks that run *before* the agent — those are the parts a unit test can
 honestly assert.
 """
@@ -50,6 +50,23 @@
 MODEL = "claude-haiku-4-5-20251001"
 
 
+@pytest.fixture(autouse=True)
+def no_price_fetch(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Keep the suite honestly offline now that rates are only ever read live.
+
+    No rates ship with the package, so any command that prices anything reaches for the
+    providers' pricing pages. Without this a test would pass or fail on whether the
+    machine happened to have a network. Failing loudly instead forces each such test to
+    state which rates it means to run against, via the ``stub_prices`` fixture or its own
+    patch of ``pricefeed.refresh``.
+    """
+
+    def unavailable(url, **_kwargs):
+        raise AssertionError(f"test reached the network for {url}; stub the pricing fetch instead")
+
+    monkeypatch.setattr("acumen.pricefeed.fetch", unavailable)
+
+
 @pytest.fixture
 def target_pkg(tmp_path: Path) -> Path:
     """A minimal local package, so a config's local ``repo:`` path resolves."""
diff --git a/tests/test_cli.py b/tests/test_cli.py
index ed2de59..cd26e90 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -9,13 +9,19 @@
 from __future__ import annotations
 
 import csv
+from datetime import date
 from pathlib import Path
 
 import pytest
 
-from acumen.cli import build_parser, main
+from acumen.bench import BenchmarkInvalidError
+from acumen.cli import _agent_prices, _Progress, build_parser, main
 from acumen.config import load_config
+from acumen.env import Target
 from acumen.paths import RunKey
+from acumen.pricefeed import PriceFeedError
+from acumen.prices import Rates
+from acumen.runner import RunOutcome
 from acumen.tasks import load_tasks
 
 
@@ -35,18 +41,84 @@ def bench_args(project: Path, *extra: str) -> list[str]:
     ]
 
 
+@pytest.fixture
+def stub_prices(monkeypatch: pytest.MonkeyPatch) -> dict[str, Rates]:
+    """Stand in for the live pricing pages, which ``bench`` reads before every pass.
+
+    Returns the fetched table so a test can assert on what the pass was priced by, or
+    mutate it to model a price change between passes.
+    """
+    fetched = {"claude-haiku-4-5-20251001": Rates(input=1.0, cached_input=0.1, cache_write=1.25, output=5.0)}
+    monkeypatch.setattr("acumen.pricefeed.refresh", lambda **_kwargs: fetched)
+    return fetched
+
+
 def test_parser_requires_a_command() -> None:
     with pytest.raises(SystemExit):
         build_parser().parse_args([])
 
 
+def test_progress_prints_unavailable_cost_without_casting_null(capsys: pytest.CaptureFixture[str], model: str) -> None:
+    progress = _Progress(1)
+    progress.running = 1
+    progress.on_done(
+        RunOutcome(
+            key=RunKey(arm="noskill", split="test", model=model, task_id="task", rep=1),
+            success=True,
+            reason="ok",
+            payload={
+                "input_tokens": 10,
+                "output_tokens": 2,
+                "cost_usd": None,
+                "cost_available": False,
+                "duration_s": 0.1,
+            },
+        )
+    )
+
+    assert "cost n/a" in capsys.readouterr().out
+
+
+def test_progress_prints_provider_exhaustion_as_invalid(capsys: pytest.CaptureFixture[str], model: str) -> None:
+    progress = _Progress(1)
+    progress.running = 1
+    progress.on_done(
+        RunOutcome(
+            key=RunKey(arm="noskill", split="test", model=model, task_id="task", rep=1),
+            success=False,
+            reason="provider_exhausted",
+            payload={
+                "input_tokens": 0,
+                "output_tokens": 0,
+                "cost_usd": None,
+                "cost_available": False,
+                "duration_s": 0.1,
+                "error": "usage limit reached",
+            },
+        )
+    )
+
+    captured = capsys.readouterr()
+    assert "INVALID" in captured.out and "FAIL" not in captured.out
+    assert "usage limit reached" in captured.err
+
+
 def test_init_writes_files_the_loaders_accept(tmp_path: Path, capsys: pytest.CaptureFixture) -> None:
     assert main(["init", "--dir", str(tmp_path)]) == 0
 
     config, tasks = tmp_path / "config.yaml", tmp_path / "tasks.yaml"
     assert config.is_file() and tasks.is_file()
     # The scaffold is a placeholder, but it must still be a *valid* placeholder.
-    assert load_config(config).repo.startswith("https://")
+    loaded = load_config(config)
+    assert loaded.repo.startswith("https://")
+    assert loaded.models == [
+        "claude-opus-5",
+        "claude-sonnet-5",
+        "claude-haiku-4-5-20251001",
+        "gpt-5.6-sol",
+        "gpt-5.6-terra",
+        "gpt-5.6-luna",
+    ]
     assert [t.id for t in load_tasks(tasks)] == ["example_task"]
     assert "wrote" in capsys.readouterr().out
 
@@ -63,6 +135,38 @@ def test_init_refuses_to_clobber_without_force(tmp_path: Path, capsys: pytest.Ca
     assert "example_task" in (tmp_path / "tasks.yaml").read_text()
 
 
+def test_tasks_generates_over_the_untouched_scaffold_placeholder(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture
+) -> None:
+    """`acumen init` then `acumen tasks` is the documented start of the loop.
+
+    The placeholder `init` writes is not user content, so refusing to generate over it made
+    the first two steps of the quickstart contradict each other.
+    """
+    assert main(["init", "--dir", str(tmp_path)]) == 0
+    out = tmp_path / "tasks.yaml"
+    args = ["tasks", "--config", str(tmp_path / "config.yaml"), "--out", str(out)]
+
+    # Stop at the first step past the clobber check, so no target is prepared and nothing spent.
+    monkeypatch.setattr("acumen.cli.check_agent_cli", _boom)
+    with pytest.raises(RuntimeError, match="reached preflight"):
+        main(args)
+    assert "replacing the untouched placeholder" in capsys.readouterr().out
+
+    # An edited file is the user's, and is still protected.
+    out.write_text(out.read_text() + "\n# mine now\n")
+    assert main(args) == 2
+    assert "pass --force to overwrite" in capsys.readouterr().err
+
+    # …until --force, which reaches preflight again.
+    with pytest.raises(RuntimeError, match="reached preflight"):
+        main([*args, "--force"])
+
+
+def _boom(*_: object, **__: object) -> None:
+    raise RuntimeError("reached preflight")
+
+
 def test_bench_dry_run_plans_the_matrix(project: Path, model: str, capsys: pytest.CaptureFixture) -> None:
     assert main(bench_args(project, "--dry-run")) == 0
 
@@ -86,6 +190,46 @@ def test_bench_dry_run_skips_completed_runs(
     assert "1 already complete, 1 to run" in out
 
 
+def test_bench_dry_run_plans_every_arm_when_none_is_selected(
+    project: Path, skills_root: Path, model: str, capsys: pytest.CaptureFixture
+) -> None:
+    assert main(bench_args(project, "--dry-run")) == 0
+
+    out = capsys.readouterr().out
+    # The baseline and every version on disk, each with its own counts, plus the run list.
+    assert "arm noskill:" in out
+    assert "arm skill_v1:" in out
+    assert "skill v1: target" in out
+    assert "total: 4 runs planned, 4 to run across 2 arms" in out
+    assert f"noskill/train/{model}/example_task/rep_1" in out
+    assert f"skill_v1/train/{model}/example_task/rep_1" in out
+
+
+def test_bench_dry_run_stays_on_one_arm_when_the_baseline_is_explicit(
+    project: Path, skills_root: Path, capsys: pytest.CaptureFixture
+) -> None:
+    assert main(bench_args(project, "--no-skill", "--dry-run")) == 0
+
+    out = capsys.readouterr().out
+    assert "arm noskill:" in out
+    assert "skill_v1" not in out
+    assert "total:" not in out
+
+
+def test_bench_refuses_a_version_that_will_not_load_before_spending(
+    project: Path, skills_root: Path, capsys: pytest.CaptureFixture
+) -> None:
+    # A broken version in skills/ is an arm that cannot run, so the whole pass stops at
+    # planning rather than half-running and failing once money is on the line.
+    (skills_root / "v2").mkdir()
+    (skills_root / "v2" / "SKILL.md").write_text("no frontmatter here\n")
+    assert main(bench_args(project, "--dry-run")) == 2
+    assert "missing a non-empty 'name'" in capsys.readouterr().err
+
+    # The healthy arms are still benchable by naming them.
+    assert main(bench_args(project, "--skill", "v1", "--dry-run")) == 0
+
+
 def test_bench_with_a_skill_loads_that_version(project: Path, skills_root: Path, capsys: pytest.CaptureFixture) -> None:
     assert main(bench_args(project, "--skill", "v1", "--dry-run")) == 0
 
@@ -99,6 +243,115 @@ def test_bench_reports_a_missing_config(tmp_path: Path, capsys: pytest.CaptureFi
     assert "error:" in capsys.readouterr().err
 
 
+def test_bench_runs_every_arm_when_none_is_selected(
+    project: Path,
+    skills_root: Path,
+    model: str,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture,
+    stub_prices,
+) -> None:
+    seen: list[tuple[str | None, int]] = []
+
+    async def fake_matrix(todo, **kwargs) -> list[RunOutcome]:
+        skill = kwargs["skill"]
+        seen.append((None if skill is None else skill.version, len(todo)))
+        return [
+            RunOutcome(key=item.key, success=True, reason="ok", payload={"cost_usd": 0.5, "skill_loaded": True})
+            for item in todo
+        ]
+
+    target = Target(
+        source="target",
+        ref="main",
+        src_dir=project / "src",
+        venv_dir=project / "venv",
+        commit="abc",
+        pkg_name="target",
+        pkg_version="1",
+    )
+    monkeypatch.setattr("acumen.cli.resolve_auth_mode", lambda *_args, **_kwargs: "session")
+    monkeypatch.setattr("acumen.cli.check_agent_cli", lambda *_args, **_kwargs: None)
+    monkeypatch.setattr("acumen.cli.prepare_target", lambda *_args, **_kwargs: target)
+    monkeypatch.setattr("acumen.cli.run_matrix", fake_matrix)
+
+    assert main(bench_args(project)) == 0
+
+    # One matrix per arm, each carrying its own skill: the baseline, then v1.
+    assert seen == [(None, 2), ("v1", 2)]
+    out = capsys.readouterr().out
+    assert "total: 4 runs planned, 4 to run across 2 arms" in out
+    assert "=== arm skill_v1: 2 runs ===" in out
+    assert "all 2 arms: 4/4 passed" in out
+
+
+def test_bench_runs_only_the_named_arm(
+    project: Path, skills_root: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture, stub_prices
+) -> None:
+    seen: list[str | None] = []
+
+    async def fake_matrix(todo, **kwargs) -> list[RunOutcome]:
+        skill = kwargs["skill"]
+        seen.append(None if skill is None else skill.version)
+        return [RunOutcome(key=item.key, success=True, reason="ok", payload={}) for item in todo]
+
+    target = Target(
+        source="target",
+        ref="main",
+        src_dir=project / "src",
+        venv_dir=project / "venv",
+        commit="abc",
+        pkg_name="target",
+        pkg_version="1",
+    )
+    monkeypatch.setattr("acumen.cli.resolve_auth_mode", lambda *_args, **_kwargs: "session")
+    monkeypatch.setattr("acumen.cli.check_agent_cli", lambda *_args, **_kwargs: None)
+    monkeypatch.setattr("acumen.cli.prepare_target", lambda *_args, **_kwargs: target)
+    monkeypatch.setattr("acumen.cli.run_matrix", fake_matrix)
+
+    assert main(bench_args(project, "--no-skill")) == 0
+
+    assert seen == [None]
+    out = capsys.readouterr().out
+    assert "skill_v1" not in out
+    assert "total:" not in out
+
+
+def test_bench_exits_nonzero_and_prints_provider_exhaustion(
+    project: Path, model: str, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture, stub_prices
+) -> None:
+    key = RunKey(arm="noskill", split="test", model=model, task_id="example_task", rep=1)
+    outcome = RunOutcome(
+        key=key,
+        success=False,
+        reason="provider_exhausted",
+        payload={"agent": "claude", "auth_mode": "session", "error": "You've hit your usage limit"},
+    )
+
+    async def invalid_matrix(*_args: object, **_kwargs: object) -> list[RunOutcome]:
+        raise BenchmarkInvalidError(outcome)
+
+    target = Target(
+        source="target",
+        ref="main",
+        src_dir=project / "src",
+        venv_dir=project / "venv",
+        commit="abc",
+        pkg_name="target",
+        pkg_version="1",
+    )
+    monkeypatch.setattr("acumen.cli.resolve_auth_mode", lambda *_args, **_kwargs: "session")
+    monkeypatch.setattr("acumen.cli.check_agent_cli", lambda *_args, **_kwargs: None)
+    monkeypatch.setattr("acumen.cli.prepare_target", lambda *_args, **_kwargs: target)
+    monkeypatch.setattr("acumen.cli.run_matrix", invalid_matrix)
+
+    assert main(bench_args(project)) == 2
+    err = capsys.readouterr().err
+    assert "benchmark invalid" in err
+    assert "You've hit your usage limit" in err
+    assert "invalid and cancelled cells remain pending" in err
+
+
 def test_report_writes_html_and_csv(project: Path, runs_root: Path, capsys: pytest.CaptureFixture) -> None:
     out_path = project / "report.html"
     exit_code = main(
@@ -205,3 +458,178 @@ def test_ship_rejects_an_unknown_version(project: Path, skills_root: Path, capsy
 
     assert exit_code == 2
     assert "no such skill version" in capsys.readouterr().err
+
+
+def test_prices_reads_the_live_pages_because_nothing_ships_with_the_package(
+    project: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """There is no offline view to show: rates exist only on the providers' pages."""
+    fetched = {
+        "claude-haiku-4-5-20251001": Rates(input=1.0, cached_input=0.1, cache_write=1.25, output=5.0),
+        "gpt-5.6-sol": Rates(input=5.0, cached_input=0.5, cache_write=6.25, output=30.0),
+    }
+    monkeypatch.setattr("acumen.cli.refresh", lambda **_kwargs: fetched)
+
+    assert main(["prices", "--config", str(project / "config.yaml")]) == 0
+
+    out = capsys.readouterr().out
+    assert "claude-haiku-4-5-20251001" in out and "(fetched)" in out
+    assert date.today().isoformat() in out
+
+
+def test_prices_exits_nonzero_when_the_pages_cannot_be_read(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """With no shipped table there is nothing to print, so this is a failure, not a warning."""
+    monkeypatch.setattr(
+        "acumen.cli.refresh",
+        lambda **_kwargs: (_ for _ in ()).throw(PriceFeedError("could not fetch: timed out")),
+    )
+
+    assert main(["prices", "--config", str(tmp_path / "absent.yaml")]) == 2
+    assert "could not fetch" in capsys.readouterr().err
+
+
+def test_prices_refresh_flags_a_pin_that_has_drifted_from_the_published_price(
+    project: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """Pinned rates are the only ones that can go stale, so they are what --refresh checks."""
+    (project / "config.yaml").write_text(
+        (project / "config.yaml").read_text() + "prices:\n  gpt-5.6-sol:\n    input: 5.0\n    output: 30.0\n"
+    )
+    published = {"gpt-5.6-sol": Rates(input=8.0, cached_input=0.8, cache_write=10.0, output=48.0)}
+    monkeypatch.setattr("acumen.cli.refresh", lambda **_kwargs: published)
+
+    assert main(["prices", "--refresh", "--config", str(project / "config.yaml")]) == 0
+
+    out = capsys.readouterr().out
+    assert "1 pinned rate(s) differ" in out
+    assert "input $5.0→$8.0" in out
+
+
+def test_prices_refresh_says_nothing_can_drift_without_pins(
+    project: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """Unpinned rates are read live each run, so there is no drift to report."""
+    monkeypatch.setattr("acumen.cli.refresh", lambda **_kwargs: {})
+
+    assert main(["prices", "--refresh", "--config", str(project / "config.yaml")]) == 0
+    assert "nothing can drift" in capsys.readouterr().out
+
+
+def _stub_bench(project: Path, monkeypatch: pytest.MonkeyPatch, seen: list) -> None:
+    """Stand in for everything ``bench`` does after it has resolved its rates."""
+
+    async def fake_matrix(todo, **kwargs) -> list[RunOutcome]:
+        seen.append(kwargs["prices"])
+        return [
+            RunOutcome(key=item.key, success=True, reason="ok", payload={"cost_usd": 0.5, "skill_loaded": True})
+            for item in todo
+        ]
+
+    target = Target(
+        source="target",
+        ref="main",
+        src_dir=project / "src",
+        venv_dir=project / "venv",
+        commit="abc",
+        pkg_name="target",
+        pkg_version="1",
+    )
+    monkeypatch.setattr("acumen.cli.resolve_auth_mode", lambda *_a, **_k: "session")
+    monkeypatch.setattr("acumen.cli.check_agent_cli", lambda *_a, **_k: None)
+    monkeypatch.setattr("acumen.cli.prepare_target", lambda *_a, **_k: target)
+    monkeypatch.setattr("acumen.cli.run_matrix", fake_matrix)
+
+
+def test_bench_prices_its_runs_from_the_live_pages(
+    project: Path, skills_root: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """A pass takes its rates from what the providers publish on the day it runs.
+
+    Nothing ships with the package to fall back on, and the figure produced is frozen into
+    every result, so this fetch is the only thing standing between the report and a cost
+    column that means nothing.
+    """
+    fetched = {"claude-haiku-4-5-20251001": Rates(input=9.0, cached_input=0.9, cache_write=11.25, output=45.0)}
+    monkeypatch.setattr("acumen.pricefeed.refresh", lambda **_kwargs: fetched)
+    seen: list = []
+    _stub_bench(project, monkeypatch, seen)
+
+    assert main(bench_args(project)) == 0
+
+    assert seen and all(table is seen[0] for table in seen), "every arm must price by one table"
+    lookup = seen[0].lookup("claude-haiku-4-5-20251001")
+    assert lookup.rates.input == 9.0
+    assert lookup.source == "fetched"
+    assert lookup.as_of == date.today().isoformat()
+    assert "prices: 1 model(s) resolved" in capsys.readouterr().out
+
+
+def test_bench_refuses_to_run_when_the_pricing_pages_are_unreachable(
+    project: Path, skills_root: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """An unreachable feed stops the pass before it spends anything.
+
+    There is no table to fall back to, so continuing would store a run with no cost at all
+    while still charging for it — the benchmark would spend real money to produce a report
+    missing one of its headline columns.
+    """
+
+    def unreachable(**_kwargs):
+        raise PriceFeedError("could not fetch https://example.invalid: timed out")
+
+    monkeypatch.setattr("acumen.pricefeed.refresh", unreachable)
+    seen: list = []
+    _stub_bench(project, monkeypatch, seen)
+
+    assert main(bench_args(project)) == 2
+    assert seen == [], "no run may start once pricing is known to be unresolvable"
+    err = capsys.readouterr().err
+    assert "could not fetch" in err
+    assert "'prices:' block in config.yaml" in err, "the error must name the way forward"
+
+
+def test_bench_warns_when_a_benched_model_is_not_published(
+    project: Path, skills_root: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """A successful fetch that does not cover your model still leaves it unpriced.
+
+    The pass runs — tokens are still recorded — but it must say so before the spend rather
+    than let a blank cost column read as a free model afterwards.
+    """
+    monkeypatch.setattr("acumen.pricefeed.refresh", lambda **_kwargs: {"some-other-model": _RATE})
+    seen: list = []
+    _stub_bench(project, monkeypatch, seen)
+
+    assert main(bench_args(project)) == 0
+
+    assert seen[0].lookup("claude-haiku-4-5-20251001") is None
+    err = capsys.readouterr().err
+    assert "no token rates for claude-haiku-4-5-20251001" in err
+    assert "record tokens but no cost" in err
+
+
+_RATE = Rates(input=1.0, cached_input=0.1, cache_write=1.25, output=5.0)
+
+
+def test_agent_commands_keep_working_when_pricing_is_unavailable(
+    project: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """``draft`` and friends report cost as progress, so an outage must not stop the work.
+
+    It is still announced, and for Codex the real consequence is named: ``max_usd`` is
+    derived from these rates, so an unpriced model has no enforceable budget cap.
+    """
+    monkeypatch.setattr(
+        "acumen.pricefeed.refresh",
+        lambda **_kwargs: (_ for _ in ()).throw(PriceFeedError("could not fetch: timed out")),
+    )
+    cfg = load_config(project / "config.yaml")
+
+    table = _agent_prices(cfg, model="gpt-5.6-sol")
+
+    assert table.lookup("gpt-5.6-sol") is None, "unpriced, rather than guessed from a shipped default"
+    err = capsys.readouterr().err
+    assert "reports no cost" in err
+    assert "max_usd cannot be enforced" in err, "the Codex budget-cap consequence must be named"
diff --git a/tests/test_core.py b/tests/test_core.py
index 7cfbb48..27c768b 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -6,13 +6,19 @@
 
 from __future__ import annotations
 
+import ast
+import asyncio
 import json
 import os
 import re
+import shutil
 import subprocess
 import sys
 import time
+import warnings
+from contextlib import contextmanager
 from dataclasses import replace
+from datetime import date
 from pathlib import Path
 
 import pandas as pd
@@ -20,31 +26,59 @@
 from matplotlib import pyplot as plt
 from matplotlib.colors import to_hex
 
-from acumen.bench import build_matrix, pending
-from acumen.config import ConfigError, derive_skill_name, load_config, parse_config
+import acumen
+from acumen.agents import (
+    AgentError,
+    AgentOptions,
+    AgentResult,
+    _claude_settings,
+    _codex_command,
+    _codex_terminal,
+    _install_codex_guard,
+    check_agent_cli,
+    provider_for_model,
+    run_agent,
+)
+from acumen.bench import BenchmarkInvalidError, PlannedRun, build_matrix, pending, run_matrix
+from acumen.config import Config, ConfigError, derive_skill_name, load_config, parse_config
 from acumen.env import (
     AUTH_ENV_VARS,
     EnvError,
     Target,
+    _validate_deps,
     api_auth_available,
-    auth_available,
     build_agent_env,
-    check_auth,
+    cache_key,
     resolve_auth_mode,
     scrubbed_env,
     session_auth_available,
 )
 from acumen.grade import grade_answer, grade_run
-from acumen.improve import _write_material, collect_train_runs, load_rates
+from acumen.improve import ImproveError, _write_material, collect_train_runs, load_rates
+from acumen.logs import LiveLog
 from acumen.paths import RunKey, arm_name, is_complete, parse_run_dir, run_dir
+from acumen.pricefeed import PriceFeedError, diff_rates, fetch_table, parse_anthropic, parse_openai
+from acumen.prices import (
+    PriceTable,
+    Rates,
+    Usage,
+    normalize_usage,
+    price_provenance,
+    price_run,
+    price_usage,
+    pricer,
+    resolve_cost,
+)
 from acumen.procs import label_env, reap, supported, survivors
 from acumen.prompts import draft_prompt, feedback_block, improve_prompt
 from acumen.report import (
+    _REPORT_COST_COLUMN,
     ReportError,
     _arm_marker,
     _best_cells,
     _holm,
     _integrity_notes,
+    _loaded_flags,
     _loaded_rank,
     _pareto_front,
     _pareto_steps,
@@ -52,16 +86,21 @@
     _skill_diff_html,
     _split_diff_rows,
     _tests_table_html,
+    arm_metrics,
+    build_report,
     load_results,
+    loaded_only_rates,
     metrics_figure,
     resolve_palette,
     skill_tests,
     tradeoff_figure,
 )
-from acumen.runner import StderrFilter, _skill_fired
+from acumen.runner import RunOutcome, StderrFilter, _provider_exhaustion_error, _skill_fired, _terminal_reason, run_once
+from acumen.sandbox import Sandbox
 from acumen.ship import _ship_env
 from acumen.skills import SkillError, load_skill, read_meta, skill_hash, write_meta
-from acumen.tasks import TaskError, load_tasks, parse_tasks
+from acumen.tasks import Task, TaskError, TaskSplit, load_tasks, parse_tasks
+from acumen.transcript import render_agent_transcript, render_codex_transcript
 
 # --- grading ---------------------------------------------------------------------------
 
@@ -109,6 +148,9 @@ def test_is_complete_needs_a_result_file(tmp_path: Path) -> None:
     (tmp_path / "result.json").write_text("{}")
     assert is_complete(tmp_path)
 
+    (tmp_path / "result.json").write_text('{"valid": false}')
+    assert not is_complete(tmp_path)
+
 
 # --- config / tasks --------------------------------------------------------------------
 
@@ -132,6 +174,86 @@ def test_config_rejects_unknown_keys() -> None:
         parse_config({"repo": "https://example.com/pkg", "modles": ["x"]})
 
 
+def test_config_dependency_selection() -> None:
+    cfg = parse_config({"repo": "https://example.com/pkg"})
+    assert cfg.dependency_groups == []
+    assert cfg.pip_packages == []
+
+    cfg2 = parse_config({"repo": "https://example.com/pkg", "dependency_groups": ["full"], "pip_packages": ["numpy<2"]})
+    assert cfg2.dependency_groups == ["full"]
+    assert cfg2.pip_packages == ["numpy<2"]
+
+    with pytest.raises(ConfigError, match="list of non-empty strings"):
+        parse_config({"repo": "https://example.com/pkg", "dependency_groups": "full"})
+
+
+# --- target dependency selection -------------------------------------------------------
+
+
+def _target(tmp_path: Path, body: str) -> Path:
+    src = tmp_path / "src"
+    src.mkdir()
+    (src / "pyproject.toml").write_text(f'[project]\nname = "pkg"\n{body}')
+    return src
+
+
+def _cfg(**kwargs: list[str]) -> Config:
+    return parse_config({"repo": "https://example.com/pkg", **kwargs})
+
+
+def test_validate_deps_points_at_the_right_key(tmp_path: Path) -> None:
+    """A group asked for as an extra is the failure that silently empties the venv."""
+    src = _target(tmp_path, '\n[dependency-groups]\nfull = ["scanpy"]\n')
+
+    _validate_deps(src, _cfg(dependency_groups=["full"]))  # the correct spelling passes
+
+    with pytest.raises(EnvError, match=r"'full' is a dependency group, not an extra"):
+        _validate_deps(src, _cfg(extras=["full"]))
+
+
+def test_validate_deps_reports_what_is_declared(tmp_path: Path) -> None:
+    src = _target(tmp_path, '\n[project.optional-dependencies]\ntest = ["pytest"]\n')
+
+    with pytest.raises(EnvError, match="the target declares no dependency groups"):
+        _validate_deps(src, _cfg(dependency_groups=["nope"]))
+    with pytest.raises(EnvError, match="available extras: test"):
+        _validate_deps(src, _cfg(extras=["nope"]))
+    with pytest.raises(EnvError, match=r"'test' is an extra, not a dependency group"):
+        _validate_deps(src, _cfg(dependency_groups=["test"]))
+
+
+def test_validate_deps_ignores_pip_packages(tmp_path: Path) -> None:
+    """Arbitrary package names can't be checked against the source tree; uv rejects bad ones."""
+    src = _target(tmp_path, "")
+
+    _validate_deps(src, _cfg(pip_packages=["harmonypy", "numpy<2"]))
+
+
+def test_cache_key_tracks_the_dependency_selection() -> None:
+    base = cache_key("https://example.com/pkg", "main")
+
+    assert cache_key("https://example.com/pkg", "main", extras=["test"]) != base
+    assert cache_key("https://example.com/pkg", "main", dependency_groups=["test"]) != base
+    assert cache_key("https://example.com/pkg", "main", pip_packages=["test"]) != base
+    # ... and the three are distinct from each other, not just from the base
+    assert (
+        len(
+            {
+                cache_key("https://example.com/pkg", "main", extras=["x"]),
+                cache_key("https://example.com/pkg", "main", dependency_groups=["x"]),
+                cache_key("https://example.com/pkg", "main", pip_packages=["x"]),
+            }
+        )
+        == 3
+    )
+
+
+def test_cache_key_is_stable_under_reordering() -> None:
+    assert cache_key("https://example.com/pkg", "main", extras=["a", "b"]) == cache_key(
+        "https://example.com/pkg", "main", extras=["b", "a"]
+    )
+
+
 def test_load_config_resolves_a_local_repo(project: Path) -> None:
     cfg = load_config(project / "config.yaml")
 
@@ -193,6 +315,1179 @@ def transcript(*skills: str) -> Path:
     assert _skill_fired(tmp_path / "absent.jsonl", "target") is None
 
 
+def test_codex_skill_fired_matches_project_skill_read(tmp_path: Path) -> None:
+    path = tmp_path / "codex.jsonl"
+    path.write_text(
+        json.dumps(
+            {
+                "type": "item.completed",
+                "item": {
+                    "type": "command_execution",
+                    "command": "sed -n '1,200p' .agents/skills/target/SKILL.md",
+                },
+            }
+        )
+        + "\n"
+    )
+    assert _skill_fired(path, "target", provider="codex") is True
+    assert _skill_fired(path, "another", provider="codex") is False
+
+
+@pytest.mark.parametrize(
+    ("model", "provider"),
+    [
+        ("claude-opus-5", "claude"),
+        ("anthropic/claude-sonnet-5", "claude"),
+        ("gpt-5.6-sol", "codex"),
+        ("openai/gpt-5.6-terra", "codex"),
+        ("o4-mini", "codex"),
+    ],
+)
+def test_provider_for_model(model: str, provider: str) -> None:
+    assert provider_for_model(model) == provider
+
+
+def test_provider_for_model_rejects_ambiguous_ids() -> None:
+    with pytest.raises(AgentError, match="cannot infer"):
+        provider_for_model("custom-model")
+
+
+def test_codex_terminal_normalizes_jsonl() -> None:
+    result = _codex_terminal(
+        [
+            {"type": "thread.started", "thread_id": "thread-1"},
+            {"type": "turn.started"},
+            {
+                "type": "item.completed",
+                "item": {"type": "agent_message", "text": "done"},
+            },
+            {
+                "type": "turn.completed",
+                "usage": {
+                    "input_tokens": 100,
+                    "cached_input_tokens": 60,
+                    "output_tokens": 20,
+                },
+            },
+        ],
+        0,
+        1234,
+    )
+    assert result.provider == "codex"
+    assert result.session_id == "thread-1"
+    assert result.result == "done"
+    assert result.num_turns == 1
+    assert result.usage["input_tokens"] == 100
+    assert result.total_cost_usd is None
+    assert not result.is_error
+
+
+def test_codex_adapter_runs_jsonl_cli(tmp_path: Path) -> None:
+    fake = tmp_path / "codex"
+    fake.write_text(
+        """#!/bin/sh
+printf '%s\\n' \\
+  '{"type":"thread.started","thread_id":"thread-1"}' \\
+  '{"type":"turn.started"}' \\
+  '{"type":"item.completed","item":{"type":"agent_message","text":"done"}}' \\
+  '{"type":"turn.completed","usage":{"input_tokens":12,"output_tokens":3}}'
+"""
+    )
+    fake.chmod(0o755)
+    seen: list[dict] = []
+    result = asyncio.run(
+        run_agent(
+            "write the answer",
+            options=AgentOptions(
+                cwd=tmp_path,
+                env={"PATH": f"{tmp_path}:/usr/bin", "HOME": str(tmp_path)},
+                model="gpt-5.6-sol",
+            ),
+            on_event=seen.append,
+        )
+    )
+    assert result.result == "done"
+    assert result.usage == {"input_tokens": 12, "output_tokens": 3}
+    assert len(seen) == 4
+
+
+def test_agent_sandbox_policies_are_fail_closed_and_workspace_scoped(tmp_path: Path) -> None:
+    work = tmp_path / "work"
+    home = tmp_path / "home"
+    venv = tmp_path / "venv"
+    source = tmp_path / "source"
+    for path in (work, home / "tmp", home / ".codex", venv, source):
+        path.mkdir(parents=True)
+    options = AgentOptions(
+        cwd=work,
+        env={"PATH": os.environ["PATH"], "HOME": str(home), "CODEX_HOME": str(home / ".codex")},
+        model="gpt-5.6-sol",
+        read_dirs=(venv, source),
+    )
+
+    claude = _claude_settings(options)
+    assert claude["sandbox"]["enabled"] is True
+    assert claude["sandbox"]["failIfUnavailable"] is True
+    assert claude["sandbox"]["allowUnsandboxedCommands"] is False
+    assert claude["sandbox"]["filesystem"]["denyRead"] == ["/"]
+    assert str(venv.resolve()) in claude["sandbox"]["filesystem"]["allowRead"]
+    assert str(work.resolve()) in claude["sandbox"]["filesystem"]["allowWrite"]
+    assert str(source.resolve()) not in claude["sandbox"]["filesystem"]["allowWrite"]
+    assert "localhost" in claude["sandbox"]["network"]["deniedDomains"]
+    assert "127.*" in claude["sandbox"]["network"]["deniedDomains"]
+    assert claude["sandbox"]["network"]["allowLocalBinding"] is False
+
+    command = _codex_command(options, "do it")
+    overrides = [command[index + 1] for index, value in enumerate(command[:-1]) if value == "-c"]
+    assert 'default_permissions="acumen"' in overrides
+    assert 'web_search="disabled"' in overrides
+    assert "tools.web_search=false" in overrides
+    assert "features.browser_use=false" in overrides
+    assert "features.apps=false" in overrides
+    assert "features.network_proxy=true" in overrides
+    filesystem = next(value for value in overrides if value.startswith("permissions.acumen.filesystem="))
+    assert '":root"="deny"' in filesystem
+    assert '":minimal"="read"' in filesystem
+    assert f'{json.dumps(str(work.resolve()))}="write"' in filesystem
+    assert f'{json.dumps(str(venv.resolve()))}="read"' in filesystem
+    codex_dir = Path(shutil.which("codex", path=options.env["PATH"])).resolve().parent
+    assert f'{json.dumps(str(codex_dir))}="read"' in filesystem
+    assert '"/bin"="read"' in filesystem
+    assert "permissions.acumen.network.enabled=true" in overrides
+    assert 'permissions.acumen.network.mode="limited"' in overrides
+    domains = next(value for value in overrides if value.startswith("permissions.acumen.network.domains="))
+    assert '"*"="allow"' in domains
+    assert '"localhost"="deny"' in domains
+    assert '"127.0.0.1"="deny"' in domains
+    assert '"metadata.google.internal"="deny"' in domains
+    assert "permissions.acumen.network.allow_local_binding=false" in overrides
+    assert "--ignore-user-config" in command and "--ignore-rules" in command
+    assert str(Path.home() / ".codex" / "config.toml") not in "\n".join(command)
+    assert str(Path.home() / ".codex" / "rules") not in "\n".join(command)
+
+
+def test_claude_options_write_run_local_settings_file(tmp_path: Path) -> None:
+    pytest.importorskip("claude_agent_sdk")
+    from acumen.agents import _claude_options
+
+    work = tmp_path / "work"
+    config_dir = tmp_path / "claude-config"
+    work.mkdir()
+    options = AgentOptions(
+        cwd=work,
+        env={
+            "PATH": os.environ["PATH"],
+            "HOME": str(tmp_path / "home"),
+            "CLAUDE_CONFIG_DIR": str(config_dir),
+        },
+        model="claude-haiku-4-5",
+    )
+
+    sdk_options = _claude_options(options)
+
+    settings_path = Path(sdk_options.settings)
+    assert settings_path == config_dir / "acumen-settings.json"
+    settings = json.loads(settings_path.read_text())
+    assert settings == _claude_settings(options)
+
+
+def test_codex_guard_denies_isolated_paths(tmp_path: Path) -> None:
+    denied = tmp_path / "runs"
+    denied.mkdir()
+    work = tmp_path / "work"
+    work.mkdir()
+    codex_home = tmp_path / "codex-home"
+    options = AgentOptions(
+        cwd=work,
+        env={"CODEX_HOME": str(codex_home)},
+        model="gpt-5.6-sol",
+        deny_paths=(denied,),
+    )
+    _install_codex_guard(options)
+
+    hooks = json.loads((work / ".codex" / "hooks.json").read_text())
+    assert "acumen_guard.py" in hooks["hooks"]["PreToolUse"][0]["hooks"][0]["command"]
+    payload = json.dumps(
+        {
+            "cwd": str(work),
+            "tool_name": "Bash",
+            "tool_input": {"command": f"cat {denied / 'skill_v1/test/result.json'}"},
+        }
+    )
+    proc = subprocess.run(
+        [sys.executable, str(codex_home / "acumen_guard.py")],
+        input=payload,
+        text=True,
+        capture_output=True,
+        check=True,
+    )
+    decision = json.loads(proc.stdout)
+    assert decision["hookSpecificOutput"]["permissionDecision"] == "deny"
+
+
+def _fake_codex(path: Path, events: list[dict]) -> Path:
+    """Write a stub ``codex`` CLI that replays ``events`` as JSONL and exits 0."""
+    lines = "".join(f"  '{json.dumps(event)}' \\\n" for event in events).rstrip(" \\\n")
+    cli = path / "codex"
+    cli.write_text(f"#!/bin/sh\nprintf '%s\\n' \\\n{lines}\n")
+    cli.chmod(0o755)
+    return cli
+
+
+def _codex_options(tmp_path: Path, **kwargs: object) -> AgentOptions:
+    return AgentOptions(
+        cwd=tmp_path,
+        env={"PATH": f"{tmp_path}:/usr/bin", "HOME": str(tmp_path)},
+        model="gpt-5.6-sol",
+        **kwargs,  # type: ignore[arg-type]
+    )
+
+
+def test_codex_turns_count_model_actions_not_exec_invocations() -> None:
+    """`codex exec` is one turn however much work happens inside it.
+
+    Counting ``turn.started`` would record 1 for every Codex run, which makes the turns column
+    meaningless and leaves ``max_turns`` with nothing to bite on. Completed items are the unit.
+    """
+    result = _codex_terminal(
+        [
+            {"type": "turn.started"},
+            {"type": "item.completed", "item": {"type": "reasoning", "text": "thinking"}},
+            {"type": "item.completed", "item": {"type": "command_execution", "command": "echo one"}},
+            {"type": "item.completed", "item": {"type": "command_execution", "command": "echo two"}},
+            {"type": "item.completed", "item": {"type": "todo_list", "items": []}},
+            {"type": "item.completed", "item": {"type": "agent_message", "text": "done"}},
+            {"type": "turn.completed", "usage": {"input_tokens": 1}},
+        ],
+        0,
+        10,
+    )
+    # Two commands and the message; reasoning and bookkeeping are not actions.
+    assert result.num_turns == 3
+
+
+def test_codex_stops_at_the_turn_cap(tmp_path: Path) -> None:
+    _fake_codex(
+        tmp_path,
+        [
+            {"type": "thread.started", "thread_id": "t"},
+            {"type": "turn.started"},
+            {"type": "item.completed", "item": {"id": "a", "type": "command_execution", "command": "echo one"}},
+            {"type": "item.completed", "item": {"id": "b", "type": "command_execution", "command": "echo two"}},
+            {"type": "item.completed", "item": {"id": "c", "type": "agent_message", "text": "never reached"}},
+            {"type": "turn.completed", "usage": {"input_tokens": 999}},
+        ],
+    )
+    result = asyncio.run(run_agent("go", options=_codex_options(tmp_path, max_turns=2)))
+
+    assert result.is_error
+    assert result.subtype == "error_max_turns"
+    assert result.num_turns == 2
+    # The agent is stopped at the cap, so the events after it are never recorded…
+    assert result.result == ""
+    # …and the run is a cap breach, not a crashed CLI.
+    assert result.errors == ["acumen stopped the run at its turn cap"]
+
+
+def test_codex_stops_at_the_budget_cap(tmp_path: Path) -> None:
+    _fake_codex(
+        tmp_path,
+        [
+            {"type": "turn.started"},
+            {"type": "item.completed", "item": {"type": "agent_message", "text": "done"}},
+            {"type": "turn.completed", "usage": {"input_tokens": 1_000_000, "output_tokens": 0}},
+        ],
+    )
+    # gpt-5.6-sol bills $5/M input, so a million fresh input tokens is $5 against a $1 cap.
+    prices = PriceTable(
+        fetched={"gpt-5.6-sol": Rates(input=5.0, cached_input=0.5, cache_write=6.25, output=30.0)},
+        fetched_as_of="2026-08-04",
+    )
+    options = _codex_options(tmp_path, max_usd=1.0, price_usd=pricer("gpt-5.6-sol", prices))
+    result = asyncio.run(run_agent("go", options=options))
+
+    assert result.is_error
+    assert result.subtype == "error_max_budget_usd"
+
+
+def test_codex_budget_cap_is_inert_without_a_rate_for_the_model(tmp_path: Path) -> None:
+    """An unpriced model must not be capped as if it were free."""
+    _fake_codex(
+        tmp_path,
+        [
+            {"type": "item.completed", "item": {"type": "agent_message", "text": "done"}},
+            {"type": "turn.completed", "usage": {"input_tokens": 1_000_000}},
+        ],
+    )
+    options = _codex_options(tmp_path, max_usd=0.000_001, price_usd=pricer("gpt-unpriced-model"))
+    result = asyncio.run(run_agent("go", options=options))
+
+    assert not result.is_error
+    assert result.result == "done"
+
+
+@pytest.mark.parametrize(
+    ("subtype", "reason"),
+    [("error_max_turns", "max_turns"), ("error_max_budget_usd", "budget")],
+)
+def test_codex_cap_subtypes_map_onto_the_same_reasons_as_claude(subtype: str, reason: str) -> None:
+    """A cap breach must record the same reason whichever provider hit it."""
+    result = _codex_terminal([], -15, 10, subtype)
+    assert _terminal_reason(result) == reason
+
+
+@pytest.mark.parametrize(
+    "detail",
+    [
+        "You've hit your usage limit · resets at 5pm",
+        "insufficient_quota: exceeded your current quota",
+        "Your credit balance is too low to access the Anthropic API",
+        "HTTP 402 payment required; purchase more credits",
+    ],
+)
+def test_provider_quota_and_credit_exhaustion_is_infrastructure_invalid(detail: str) -> None:
+    result = AgentResult(
+        provider="codex",
+        is_error=True,
+        subtype="turn.failed",
+        errors=[detail],
+        session_id=None,
+        result="",
+        num_turns=0,
+        total_cost_usd=None,
+        duration_ms=1,
+        usage={},
+    )
+    assert _provider_exhaustion_error(result) is not None
+
+
+def test_transient_rate_limit_and_acumen_caps_are_not_provider_exhaustion() -> None:
+    throttled = AgentResult(
+        provider="claude",
+        is_error=True,
+        subtype="error",
+        errors=["429 rate limit exceeded; retry after 2 seconds"],
+        session_id=None,
+        result="",
+        num_turns=0,
+        total_cost_usd=None,
+        duration_ms=1,
+        usage={},
+    )
+    capped = replace(throttled, subtype="error_max_budget_usd", errors=["acumen stopped at its spending limit"])
+    assert _provider_exhaustion_error(throttled) is None
+    assert _provider_exhaustion_error(capped) is None
+
+
+def test_provider_exhaustion_result_is_diagnostic_not_complete(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    box_root = tmp_path / "box"
+    box_root.mkdir()
+    box = Sandbox(
+        root=box_root,
+        home=tmp_path / "home",
+        config_dir=tmp_path / "codex-home",
+        env={},
+        authenticated=True,
+        provider="codex",
+    )
+
+    @contextmanager
+    def fake_sandbox(*_args, **_kwargs):
+        yield box
+
+    async def exhausted(*_args, **_kwargs) -> AgentResult:
+        return AgentResult(
+            provider="codex",
+            is_error=True,
+            subtype="turn.failed",
+            errors=["insufficient_quota: purchase more credits"],
+            session_id=None,
+            result="",
+            num_turns=0,
+            total_cost_usd=None,
+            duration_ms=10,
+            usage={},
+        )
+
+    monkeypatch.setattr("acumen.runner.sandbox", fake_sandbox)
+    monkeypatch.setattr("acumen.runner.run_agent", exhausted)
+    monkeypatch.setattr("acumen.runner._collect_artifacts", lambda *_args: None)
+    monkeypatch.setattr("acumen.runner.agent_version", lambda _provider: "test")
+    directory = tmp_path / "run"
+    outcome = asyncio.run(
+        run_once(
+            key=RunKey(arm="noskill", split="test", model="gpt-5.6-sol", task_id="task", rep=1),
+            task=Task(id="task", train=TaskSplit("prompt", "OK"), test=TaskSplit("prompt", "OK")),
+            target=Target(
+                source="target",
+                ref="main",
+                src_dir=tmp_path / "src",
+                venv_dir=tmp_path / "venv",
+                commit="abc",
+                pkg_name="target",
+                pkg_version="1",
+            ),
+            run_dir=directory,
+            model="gpt-5.6-sol",
+            max_turns=1,
+            max_usd=1.0,
+        )
+    )
+
+    persisted = json.loads((directory / "result.json").read_text())
+    assert outcome.reason == "provider_exhausted"
+    assert persisted["valid"] is False
+    assert not is_complete(directory)
+
+
+def test_run_matrix_cancels_remaining_cells_when_provider_is_exhausted(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    task = Task(id="quota", train=TaskSplit("prompt", "OK"), test=TaskSplit("prompt", "OK"))
+    planned = [
+        PlannedRun(
+            key=RunKey(arm="noskill", split="test", model="gpt-5.6-sol", task_id=f"task_{index}", rep=1),
+            task=task,
+            model="gpt-5.6-sol",
+            max_turns=1,
+            max_usd=1.0,
+        )
+        for index in range(3)
+    ]
+    cancelled: list[str] = []
+
+    async def fake_run_once(*, key: RunKey, **_kwargs: object) -> RunOutcome:
+        if key.task_id == "task_0":
+            await asyncio.sleep(0)  # let sibling Codex cells become in-flight
+            return RunOutcome(
+                key=key,
+                success=False,
+                reason="provider_exhausted",
+                payload={"agent": "codex", "auth_mode": "session", "error": "usage limit reached"},
+            )
+        try:
+            await asyncio.Event().wait()
+        finally:
+            cancelled.append(key.task_id)
+
+    monkeypatch.setattr("acumen.bench.run_once", fake_run_once)
+    target = Target(
+        source="target",
+        ref="main",
+        src_dir=tmp_path / "src",
+        venv_dir=tmp_path / "venv",
+        commit="abc",
+        pkg_name="target",
+        pkg_version="1",
+    )
+
+    with pytest.raises(BenchmarkInvalidError, match="benchmark invalid"):
+        asyncio.run(run_matrix(planned, target=target, runs_root=tmp_path / "runs", max_concurrency=3))
+    assert set(cancelled) == {"task_1", "task_2"}
+
+
+def test_run_matrix_continues_other_provider_after_one_is_exhausted(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    task = Task(id="mixed", train=TaskSplit("prompt", "OK"), test=TaskSplit("prompt", "OK"))
+
+    def planned(model: str, task_id: str) -> PlannedRun:
+        return PlannedRun(
+            key=RunKey(arm="noskill", split="test", model=model, task_id=task_id, rep=1),
+            task=task,
+            model=model,
+            max_turns=1,
+            max_usd=1.0,
+        )
+
+    matrix = [
+        planned("gpt-5.6-sol", "codex_quota"),
+        planned("claude-opus-5", "claude_first"),
+        planned("gpt-5.6-sol", "codex_queued"),
+        planned("claude-opus-5", "claude_queued"),
+    ]
+    completed: list[str] = []
+    cancelled: list[str] = []
+
+    async def fake_run_once(*, key: RunKey, **_kwargs: object) -> RunOutcome:
+        if key.task_id == "codex_quota":
+            return RunOutcome(
+                key=key,
+                success=False,
+                reason="provider_exhausted",
+                payload={"agent": "codex", "auth_mode": "session", "error": "usage limit reached"},
+            )
+        if key.model.startswith("gpt-"):
+            try:
+                await asyncio.Event().wait()
+            finally:
+                cancelled.append(key.task_id)
+        await asyncio.sleep(0)
+        completed.append(key.task_id)
+        return RunOutcome(key=key, success=True, reason="ok", payload={})
+
+    monkeypatch.setattr("acumen.bench.run_once", fake_run_once)
+    target = Target(
+        source="target",
+        ref="main",
+        src_dir=tmp_path / "src",
+        venv_dir=tmp_path / "venv",
+        commit="abc",
+        pkg_name="target",
+        pkg_version="1",
+    )
+
+    with pytest.raises(BenchmarkInvalidError, match="other providers continued"):
+        asyncio.run(run_matrix(matrix, target=target, runs_root=tmp_path / "runs", max_concurrency=2))
+    assert completed == ["claude_first", "claude_queued"]
+    assert cancelled == []  # the queued Codex cell was cancelled before it was submitted
+
+
+def test_codex_transcript_renders_its_own_html(tmp_path: Path) -> None:
+    """`claude-code-log` reads the SDK format only — given Codex events it silently exits 0
+    and writes an empty page, so Codex is rendered here instead."""
+    jsonl = tmp_path / "transcript.jsonl"
+    jsonl.write_text(
+        "\n".join(
+            json.dumps(event)
+            for event in [
+                {"type": "thread.started", "thread_id": "thread-9"},
+                {"type": "item.completed", "item": {"id": "a", "type": "agent_message", "text": "<b>hi</b>"}},
+                {
+                    "type": "item.completed",
+                    "item": {
+                        "id": "b",
+                        "type": "command_execution",
+                        "command": "python -c 'print(1)'",
+                        "aggregated_output": "1\n",
+                        "exit_code": 0,
+                    },
+                },
+                # Started but never completed — what a turn-capped run leaves behind.
+                {"type": "item.started", "item": {"id": "c", "type": "command_execution", "command": "sleep 60"}},
+                {"type": "turn.completed", "usage": {"input_tokens": 41_214, "output_tokens": 122}},
+            ]
+        )
+        + "\n"
+    )
+    html = tmp_path / "transcript.html"
+    assert render_codex_transcript(jsonl, html) is True
+
+    body = html.read_text()
+    assert "thread-9" in body
+    assert "python -c &#x27;print(1)&#x27;" in body
+    assert "exit 0" in body
+    # Agent text is escaped, never injected as markup.
+    assert "&lt;b&gt;hi&lt;/b&gt;" in body and "<b>hi</b>" not in body
+    # The unfinished item survives, flagged as such.
+    assert "sleep 60" in body and "unfinished" in body
+    assert "41214" in body
+
+
+def test_codex_transcript_renders_without_events(tmp_path: Path) -> None:
+    jsonl = tmp_path / "empty.jsonl"
+    jsonl.write_text("not json\n")
+    html = tmp_path / "empty.html"
+    assert render_codex_transcript(jsonl, html) is True
+    assert "no events" in html.read_text()
+    assert render_codex_transcript(tmp_path / "missing.jsonl", tmp_path / "missing.html") is False
+
+
+def test_render_agent_transcript_dispatches_on_provider(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    jsonl = tmp_path / "t.jsonl"
+    jsonl.write_text(json.dumps({"type": "item.completed", "item": {"type": "agent_message", "text": "hi"}}) + "\n")
+    calls: list[str] = []
+    monkeypatch.setattr("acumen.transcript.render_transcript", lambda *_: calls.append("claude") or True)
+
+    assert render_agent_transcript(jsonl, tmp_path / "codex.html", provider="codex") is True
+    assert calls == []
+    assert render_agent_transcript(jsonl, tmp_path / "claude.html", provider="claude") is True
+    assert calls == ["claude"]
+
+
+def test_backends_are_optional_at_import_time() -> None:
+    """A Codex-only install has no Claude SDK, so nothing may import it at module scope.
+
+    This is the invariant that keeps ``import acumen`` working with either backend installed
+    alone; the SDK may only be reached inside a function or under ``TYPE_CHECKING``.
+    """
+    offenders: list[str] = []
+    package_root = Path(acumen.__file__).parent
+    for path in sorted(package_root.rglob("*.py")):
+        if any(part.startswith(".") for part in path.relative_to(package_root).parts):
+            continue  # editor caches and other hidden paths are not package source
+        for node in ast.parse(path.read_text()).body:
+            if isinstance(node, ast.If) and ast.unparse(node.test) == "TYPE_CHECKING":
+                continue  # annotations only — never executed
+            for child in ast.walk(node) if isinstance(node, ast.If | ast.Try) else [node]:
+                module = getattr(child, "module", None) if isinstance(child, ast.ImportFrom) else None
+                names = [alias.name for alias in getattr(child, "names", [])] if isinstance(child, ast.Import) else []
+                if (module or "").startswith("claude_agent_sdk") or any(
+                    name.startswith("claude_agent_sdk") for name in names
+                ):
+                    offenders.append(f"{path.name}:{child.lineno}")
+    assert offenders == []
+
+
+def test_missing_backend_fails_before_any_work(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Both backends are optional, so both are preflighted the same way."""
+    monkeypatch.setattr("acumen.agents.claude_sdk_available", lambda: False)
+    with pytest.raises(AgentError, match=r"acumen\[claude\]"):
+        check_agent_cli("claude")
+
+    monkeypatch.setattr("acumen.agents.claude_sdk_available", lambda: True)
+    check_agent_cli("claude")
+
+    monkeypatch.setattr("acumen.agents.shutil.which", lambda _: None)
+    with pytest.raises(AgentError, match="codex is not on PATH"):
+        check_agent_cli("codex")
+
+
+def test_live_log_records_codex_without_the_claude_sdk(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    """The live JSONL is provider-neutral: Codex events are dicts, recognized without the SDK."""
+    monkeypatch.setattr("acumen.logs._sdk", lambda: None)
+    with LiveLog(tmp_path / "log.jsonl") as log:
+        log.append({"type": "item.completed", "item": {"type": "agent_message", "text": "done"}})
+        log.append(object())  # an SDK message on an install that cannot recognize it
+    events = [json.loads(line) for line in (tmp_path / "log.jsonl").read_text().splitlines()]
+    assert [event["type"] for event in events] == ["assistant"]
+    assert events[0]["text"] == "done"
+
+
+def test_live_log_streams_codex_terminal_events_without_missing_field_crashes(tmp_path: Path) -> None:
+    lines: list[str] = []
+    with LiveLog(tmp_path / "log.jsonl", stream=True, echo=lines.append) as log:
+        log.append(
+            {
+                "type": "turn.completed",
+                "usage": {"input_tokens": 12, "cached_input_tokens": 3, "output_tokens": 4},
+            }
+        )
+        log.append({"type": "turn.failed", "error": {"message": "boom"}})
+
+    assert lines == [
+        "● done: turn.completed · 1 turns · cost n/a",
+        "✗ error: turn.failed · cost n/a",
+    ]
+
+
+def test_usage_normalizes_both_providers_without_collapsing_the_cache_split() -> None:
+    """The cache classes are priced up to 10x apart, so they must survive normalization.
+
+    The two providers report the same information differently: Codex's ``input_tokens``
+    is the total with ``cached_input_tokens`` inside it, while the Claude SDK reports the
+    three classes side by side. Both normalize to a total ``input`` plus its parts.
+    """
+    claude = normalize_usage(
+        {
+            "input_tokens": 5_000,
+            "cache_read_input_tokens": 180_000,
+            "cache_creation_input_tokens": 15_000,
+            "output_tokens": 4_000,
+        }
+    )
+    assert (claude.input, claude.cache_read, claude.cache_write, claude.output) == (200_000, 180_000, 15_000, 4_000)
+    assert claude.fresh_input == 5_000
+
+    # Captured verbatim from a live `codex exec --json` turn.completed event.
+    codex = normalize_usage(
+        {
+            "input_tokens": 12_051,
+            "cached_input_tokens": 8_960,
+            "cache_write_input_tokens": 0,
+            "output_tokens": 5,
+            "reasoning_output_tokens": 0,
+        },
+        provider="codex",
+    )
+    assert (codex.input, codex.cache_read, codex.cache_write, codex.output) == (12_051, 8_960, 0, 5)
+    # Cached input is a subset of input_tokens, not an addition to it.
+    assert codex.fresh_input == 3_091
+    # reasoning_output_tokens is a subset of output_tokens, so it must not be added on.
+    assert codex.total == 12_056
+
+    written = normalize_usage(
+        {"input_tokens": 12_051, "cached_input_tokens": 8_000, "cache_write_input_tokens": 960, "output_tokens": 5},
+        provider="codex",
+    )
+    assert (written.cache_write, written.fresh_input) == (960, 3_091)
+
+    empty = normalize_usage(None)
+    assert (empty.input, empty.output, empty.total) == (0, 0, 0)
+
+
+def test_claude_cache_writes_retain_five_minute_and_one_hour_classes() -> None:
+    usage = normalize_usage(
+        {
+            "input_tokens": 100,
+            "cache_creation_input_tokens": 3_000,
+            "cache_creation": {
+                "ephemeral_5m_input_tokens": 1_000,
+                "ephemeral_1h_input_tokens": 2_000,
+            },
+        }
+    )
+    rates = Rates(
+        input=4,
+        cached_input=0.4,
+        cache_write=5,
+        output=20,
+        cache_write_5m=5,
+        cache_write_1h=8,
+    )
+
+    assert usage.cache_write == 3_000
+    assert (usage.cache_write_5m, usage.cache_write_1h) == (1_000, 2_000)
+    assert price_run(usage, rates) == pytest.approx((100 * 4 + 1_000 * 5 + 2_000 * 8) / 1_000_000)
+
+
+def test_provider_cost_is_canonical_while_inference_and_nested_agent_delta_survive() -> None:
+    # The SDK total includes nested agents while the parent usage block can be smaller.
+    cost = resolve_cost(provider_cost_usd=1.25, inferred_cost_usd=0.40)
+    assert cost.cost_usd == 1.25
+    assert cost.cost_source == "provider"
+    assert cost.inferred_cost_usd == 0.40
+    assert cost.cost_delta_usd == pytest.approx(-0.85)
+    assert cost.cost_delta_pct == pytest.approx(-0.68)
+
+
+def test_cost_falls_back_to_inference_and_never_turns_unavailable_into_free() -> None:
+    inferred = resolve_cost(None, 0.40)
+    assert (inferred.cost_usd, inferred.cost_source, inferred.available) == (0.40, "inferred", True)
+
+    unavailable = resolve_cost(None, None)
+    assert unavailable.cost_usd is None
+    assert unavailable.cost_source == "unavailable"
+    assert unavailable.available is False
+
+
+def test_price_run_bills_each_cache_class_at_its_own_rate() -> None:
+    """Collapsing the split and billing it all at the base input rate overcharges ~3.6x.
+
+    That is the whole reason the breakdown is carried: a benchmark agent's input is
+    mostly cache reads, billed at a tenth of the base rate.
+    """
+    usage = Usage(input=200_000, cache_read=180_000, cache_write=15_000, output=4_000)
+    rates = Rates(input=5.0, cached_input=0.5, cache_write=6.25, output=25.0)
+    # 5k @ $5 + 180k @ $0.50 + 15k @ $6.25 + 4k @ $25, per million.
+    assert price_run(usage, rates) == pytest.approx(0.30875)
+    collapsed = (usage.input * rates.input + usage.output * rates.output) / 1_000_000
+    assert collapsed > price_run(usage, rates) * 3
+
+
+def test_price_usage_prices_codex_meta_agent_tokens_when_provider_cost_is_absent() -> None:
+    prices = PriceTable(
+        fetched={"gpt-5.6-sol": Rates(input=5.0, cached_input=0.5, cache_write=6.25, output=30.0)},
+        fetched_as_of="2026-08-04",
+    )
+    cost = price_usage(
+        {"input_tokens": 1_000_000, "cached_input_tokens": 0, "output_tokens": 1_000_000},
+        model="gpt-5.6-sol",
+        provider="codex",
+        prices=prices,
+    )
+
+    assert cost == pytest.approx(35.0)
+
+
+def test_price_run_leaves_an_unpriced_model_unpriced_rather_than_free() -> None:
+    """``None`` is not ``0.0`` — a model with no rates must not read as a free one."""
+    assert PriceTable().lookup("some-local-llm") is None
+    assert price_run(Usage(input=1, cache_read=0, cache_write=0, output=1), None) is None
+
+
+def test_benchmark_persists_unavailable_cost_as_null(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    box_root = tmp_path / "box"
+    box_root.mkdir()
+    box = Sandbox(
+        root=box_root,
+        home=tmp_path / "home",
+        config_dir=tmp_path / "codex-home",
+        env={},
+        authenticated=True,
+        provider="codex",
+    )
+
+    @contextmanager
+    def fake_sandbox(*_args, **_kwargs):
+        yield box
+
+    async def fake_run_agent(*_args, **_kwargs) -> AgentResult:
+        return AgentResult(
+            provider="codex",
+            is_error=False,
+            subtype="success",
+            errors=None,
+            session_id="thread-1",
+            result="done",
+            num_turns=1,
+            total_cost_usd=None,
+            duration_ms=100,
+            usage={"input_tokens": 10, "output_tokens": 2},
+        )
+
+    def collect(_box: Sandbox, directory: Path) -> None:
+        (directory / "answer.md").write_text("OK")
+
+    monkeypatch.setattr("acumen.runner.sandbox", fake_sandbox)
+    monkeypatch.setattr("acumen.runner.run_agent", fake_run_agent)
+    monkeypatch.setattr("acumen.runner._collect_artifacts", collect)
+    monkeypatch.setattr("acumen.runner.render_agent_transcript", lambda *_args, **_kwargs: False)
+    monkeypatch.setattr("acumen.runner.agent_version", lambda _provider: "test")
+
+    run_dir = tmp_path / "run"
+    outcome = asyncio.run(
+        run_once(
+            key=RunKey(arm="noskill", split="test", model="gpt-unpriced", task_id="task", rep=1),
+            task=Task(id="task", train=TaskSplit("prompt", "OK"), test=TaskSplit("prompt", "OK")),
+            target=Target(
+                source="target",
+                ref="main",
+                src_dir=tmp_path / "src",
+                venv_dir=tmp_path / "venv",
+                commit="abc",
+                pkg_name="target",
+                pkg_version="1",
+            ),
+            run_dir=run_dir,
+            model="gpt-unpriced",
+            max_turns=1,
+            max_usd=1.0,
+        )
+    )
+
+    persisted = json.loads((run_dir / "result.json").read_text())
+    assert outcome.payload["cost_usd"] is None
+    assert persisted["cost_usd"] is None
+    assert persisted["cost_available"] is False
+    assert persisted["cost_source"] == "unavailable"
+    assert persisted["provider_cost_usd"] is None
+    assert persisted["inferred_cost_usd"] is None
+    assert persisted["provider"] == "openai"
+    assert persisted["backend"] == "codex_cli"
+    assert persisted["agent"] == "codex"
+
+
+def test_benchmark_persists_provider_first_cost_for_nested_claude_agents(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    box_root = tmp_path / "box"
+    box_root.mkdir()
+    box = Sandbox(
+        root=box_root,
+        home=tmp_path / "home",
+        config_dir=tmp_path / "claude-home",
+        env={},
+        authenticated=True,
+        provider="claude",
+    )
+
+    @contextmanager
+    def fake_sandbox(*_args, **_kwargs):
+        yield box
+
+    async def fake_run_agent(*_args, **_kwargs) -> AgentResult:
+        return AgentResult(
+            provider="claude",
+            is_error=False,
+            subtype="success",
+            errors=None,
+            session_id=None,
+            result="done",
+            num_turns=3,
+            # SDK totals include nested agents; the parent usage block below does not.
+            total_cost_usd=1.25,
+            duration_ms=100,
+            usage={"input_tokens": 1_000, "output_tokens": 0},
+        )
+
+    def collect(_box: Sandbox, directory: Path) -> None:
+        (directory / "answer.md").write_text("OK")
+
+    monkeypatch.setattr("acumen.runner.sandbox", fake_sandbox)
+    monkeypatch.setattr("acumen.runner.run_agent", fake_run_agent)
+    monkeypatch.setattr("acumen.runner._collect_artifacts", collect)
+    monkeypatch.setattr("acumen.runner.agent_version", lambda _provider: "test")
+
+    run_dir = tmp_path / "run"
+    asyncio.run(
+        run_once(
+            key=RunKey(arm="noskill", split="test", model="claude-opus-5", task_id="task", rep=1),
+            task=Task(id="task", train=TaskSplit("prompt", "OK"), test=TaskSplit("prompt", "OK")),
+            target=Target(
+                source="target",
+                ref="main",
+                src_dir=tmp_path / "src",
+                venv_dir=tmp_path / "venv",
+                commit="abc",
+                pkg_name="target",
+                pkg_version="1",
+            ),
+            run_dir=run_dir,
+            model="claude-opus-5",
+            max_turns=5,
+            max_usd=2.0,
+            prices=PriceTable(
+                fetched={"claude-opus-5": Rates(input=5.0, cached_input=0.5, cache_write=6.25, output=25.0)},
+                fetched_as_of="2026-08-04",
+            ),
+        )
+    )
+
+    persisted = json.loads((run_dir / "result.json").read_text())
+    assert persisted["cost_usd"] == 1.25
+    assert persisted["cost_source"] == "provider"
+    assert persisted["provider_cost_usd"] == 1.25
+    assert persisted["inferred_cost_usd"] == pytest.approx(0.005)
+    assert persisted["cost_delta_usd"] == pytest.approx(-1.245)
+    assert persisted["cost_delta_pct"] == pytest.approx(-0.996)
+    assert persisted["provider"] == "anthropic"
+    assert persisted["backend"] == "claude_agent_sdk"
+    assert persisted["agent"] == "claude"
+
+
+def test_price_table_matches_provider_qualified_and_differently_cased_ids() -> None:
+    """A gateway or proxy names the same model differently; it is still that model."""
+    published = Rates(input=7.0, cached_input=0.7, cache_write=8.75, output=35.0)
+    table = PriceTable(fetched={"gpt-5.6-sol": published}, fetched_as_of="2026-09-15")
+
+    assert table.rates("openai/gpt-5.6-sol") is published
+    assert table.rates("GPT-5.6-Sol") is published
+    assert table.lookup("no-such-model") is None
+
+
+def test_price_table_prices_a_dated_snapshot_at_its_family_rate() -> None:
+    """Providers publish one rate per family and never list the dated snapshot IDs.
+
+    Pinning a snapshot is the reproducible thing to do, and ``acumen init`` scaffolds one,
+    so without this fallback a default project would bench an entirely unpriced model.
+    """
+    published = Rates(input=1.0, cached_input=0.1, cache_write=1.25, output=5.0)
+    table = PriceTable(fetched={"claude-haiku-4-5": published}, fetched_as_of="2026-09-15")
+
+    assert table.rates("claude-haiku-4-5-20251001") is published
+    assert table.rates("anthropic/claude-haiku-4-5-20251001") is published
+    # A version suffix that is not a date is part of the name, not a snapshot.
+    assert table.lookup("claude-haiku-4-5-turbo") is None
+
+
+def test_price_table_ranks_config_over_fetched() -> None:
+    """A pinned rate is the operator stating what *they* are billed, which no page knows.
+
+    With nothing baked into the package, these are the only two sources there are: what
+    the provider publishes today, and what the operator says overrides it.
+    """
+    negotiated = Rates(input=1.0, cached_input=0.1, cache_write=1.25, output=2.0)
+    published = Rates(input=7.0, cached_input=0.7, cache_write=8.75, output=35.0)
+    table = PriceTable(
+        overrides={"claude-opus-5": negotiated},
+        fetched={"claude-opus-5": published, "gpt-5.6-sol": published},
+        fetched_as_of="2026-09-15",
+    )
+
+    assert table.lookup("claude-opus-5").rates is negotiated
+    assert table.lookup("gpt-5.6-sol").rates is published
+    # A model no layer prices is unpriced, never guessed at from a shipped default.
+    assert table.lookup("claude-sonnet-4-6") is None
+
+
+def test_an_empty_price_table_prices_nothing_rather_than_guessing() -> None:
+    """No rates ship with the package, so an unfetched table is honestly empty.
+
+    The alternative — a compiled-in table — is wrong from whatever date the providers next
+    move their prices, and since each run's cost is frozen when written, that wrongness is
+    stored rather than corrected on the next run.
+    """
+    assert PriceTable().lookup("claude-opus-5") is None
+    assert price_usage({"input_tokens": 10_000, "output_tokens": 1_000}, model="claude-opus-5") is None
+
+
+def test_price_table_dates_a_fetched_rate_but_not_an_operators_own() -> None:
+    """A config rate has no verification date, and inventing one would claim currency."""
+    table = PriceTable(
+        overrides={"my-gateway": Rates(input=1.0, cached_input=0.1, cache_write=1.25, output=2.0)},
+        fetched={"gpt-5.6-sol": Rates(input=7.0, cached_input=0.7, cache_write=8.75, output=35.0)},
+        fetched_as_of="2026-09-15",
+    )
+
+    assert price_provenance(table.lookup("my-gateway")) == {
+        "price_rates": {
+            "input": 1.0,
+            "cached_input": 0.1,
+            "cache_write": 1.25,
+            "output": 2.0,
+            "cache_write_5m": None,
+            "cache_write_1h": None,
+        },
+        "price_source": "config",
+        "price_rates_as_of": None,
+    }
+    fetched = price_provenance(table.lookup("gpt-5.6-sol"))
+    assert (fetched["price_source"], fetched["price_rates_as_of"]) == ("fetched", "2026-09-15")
+    # An unpriced model still produces the keys, so results have one shape to read.
+    assert price_provenance(None) == {"price_rates": None, "price_source": None, "price_rates_as_of": None}
+
+
+def test_two_passes_months_apart_keep_the_rates_each_was_priced_by() -> None:
+    """The point of recording rates per run: a later pass must not restate an earlier one.
+
+    Same model, same tokens, two months and a price rise apart. Both figures stay valid
+    because each carries the rate that produced it, which is what lets one report mix them.
+    """
+    usage = {"input_tokens": 1_000_000, "output_tokens": 100_000}
+    august = PriceTable(
+        fetched={"gpt-5.6-sol": Rates(input=5.0, cached_input=0.5, cache_write=6.25, output=30.0)},
+        fetched_as_of="2026-08-04",
+    )
+    october = PriceTable(
+        fetched={"gpt-5.6-sol": Rates(input=8.0, cached_input=0.8, cache_write=10.0, output=48.0)},
+        fetched_as_of="2026-10-04",
+    )
+
+    then = price_usage(usage, model="gpt-5.6-sol", provider="codex", prices=august)
+    now = price_usage(usage, model="gpt-5.6-sol", provider="codex", prices=october)
+
+    assert then == pytest.approx(5.0 + 3.0)
+    assert now == pytest.approx(8.0 + 4.8)
+    assert price_provenance(august.lookup("gpt-5.6-sol"))["price_rates_as_of"] == "2026-08-04"
+    assert price_provenance(october.lookup("gpt-5.6-sol"))["price_rates_as_of"] == "2026-10-04"
+
+
+def test_fetch_table_dates_the_fetch_and_keeps_config_on_top() -> None:
+    """What ``bench`` builds: live rates, dated, with the operator's own still winning."""
+    pages = {"anthropic": _ANTHROPIC_MD, "openai": _OPENAI_MD}
+    mine = {"gpt-5.6-sol": Rates(input=1.0, cached_input=0.1, cache_write=1.25, output=2.0)}
+
+    table = fetch_table(
+        mine,
+        today=date(2026, 9, 15),
+        fetcher=lambda url: pages["anthropic" if "claude" in url else "openai"],
+    )
+
+    assert table.fetched_as_of == "2026-09-15"
+    # The page priced this one at $5 input; the operator's own rate still wins.
+    assert table.fetched["gpt-5.6-sol"].input == 5.0
+    assert table.lookup("gpt-5.6-sol").source == "config"
+    assert table.lookup("gpt-5.6-sol").rates.input == 1.0
+    # Everything else comes from the fetch, dated by it.
+    sonnet = table.lookup("claude-sonnet-5")
+    assert (sonnet.source, sonnet.as_of) == ("fetched", "2026-09-15")
+    # 2026-09-15 is past the introductory window, so the standard rate applies.
+    assert sonnet.rates.input == 3.0
+
+
+def test_fetch_table_raises_rather_than_pricing_a_pass_from_a_stale_table() -> None:
+    """Bench turns this into a refusal: a wrong cost, once frozen into a result, stays wrong."""
+
+    def unreachable(url, **_kwargs):
+        raise PriceFeedError(f"could not fetch {url}: timed out")
+
+    with pytest.raises(PriceFeedError, match="could not fetch"):
+        fetch_table({}, today=date(2026, 9, 15), fetcher=unreachable)
+
+
+def test_config_prices_block_validates_and_defaults_the_cache_rates() -> None:
+    cfg = parse_config(
+        {
+            "repo": "https://github.com/o/r",
+            "prices": {"my-gateway-model": {"input": 4.0, "output": 20.0}},
+        }
+    )
+    rates = cfg.prices["my-gateway-model"]
+    # Cache rates are optional; they default to the standard 0.1x / 1.25x of input.
+    assert (rates.input, rates.output, rates.cached_input, rates.cache_write) == (4.0, 20.0, 0.4, 5.0)
+
+    for bad in ({"input": 4.0}, {"input": -1.0, "output": 2.0}, {"input": 1.0, "output": 2.0, "nope": 3.0}, []):
+        with pytest.raises(ConfigError, match="prices"):
+            parse_config({"repo": "https://github.com/o/r", "prices": {"m": bad}})
+
+
+_ANTHROPIC_MD = """
+| Model | Base Input Tokens | 5m Cache Writes | 1h Cache Writes | Cache Hits & Refreshes | Output Tokens |
+|---|---|---|---|---|---|
+| Claude Opus 5 | $5 / MTok | $6.25 / MTok | $10 / MTok | $0.50 / MTok | $25 / MTok |
+| Claude Sonnet 5 [through August 31, 2026](/docs/pricing#intro) | $2 / MTok | $2.50 / MTok | $4 / MTok | $0.20 / MTok | $10 / MTok |
+| Claude Sonnet 5 starting September 1, 2026 | $3 / MTok | $3.75 / MTok | $6 / MTok | $0.30 / MTok | $15 / MTok |
+| Claude Haiku 4.5 | $1 / MTok | $1.25 / MTok | $2 / MTok | $0.10 / MTok | $5 / MTok |
+
+| Model | Batch input | Batch output |
+|---|---|---|
+| Claude Opus 5 | $2.50 / MTok | $12.50 / MTok |
+"""
+
+_OPENAI_MD = """
+### Standard pricing data
+
+| Model | Short context input | Short context cached input | Short context cache writes | Short context output | Long context input | Long context cached input | Long context cache writes | Long context output |
+|---|---|---|---|---|---|---|---|---|
+| gpt-5.6-sol | $5.00 | $0.50 | $6.25 | $30.00 | $10.00 | $1.00 | $12.50 | $45.00 |
+| gpt-5.6-luna | $0.20 | $0.02 | $0.25 | $1.20 | $0.40 | $0.04 | $0.50 | $1.80 |
+| gpt-5.5 (<272K context length) | $5.00 | $0.50 | - | $30.00 | $10.00 | $1.00 | - | $45.00 |
+
+### Batch pricing data
+
+| Model | Short context input | Short context cached input | Short context cache writes | Short context output | Long context input | Long context cached input | Long context cache writes | Long context output |
+|---|---|---|---|---|---|---|---|---|
+| gpt-5.6-sol | $2.50 | $0.25 | $3.125 | $15.00 | $5.00 | $0.50 | $6.25 | $22.50 |
+"""
+
+
+def test_price_feed_picks_the_rate_in_effect_on_a_dated_row() -> None:
+    """A promotional rate is published as two rows; taking the first would misprice runs."""
+    intro = parse_anthropic(_ANTHROPIC_MD, today=date(2026, 8, 3))
+    assert intro["claude-sonnet-5"] == Rates(
+        input=2.0,
+        cached_input=0.2,
+        cache_write=2.5,
+        output=10.0,
+        cache_write_5m=2.5,
+        cache_write_1h=4.0,
+    )
+
+    after = parse_anthropic(_ANTHROPIC_MD, today=date(2026, 9, 1))
+    assert after["claude-sonnet-5"] == Rates(
+        input=3.0,
+        cached_input=0.3,
+        cache_write=3.75,
+        output=15.0,
+        cache_write_5m=3.75,
+        cache_write_1h=6.0,
+    )
+
+    # Display names become API model IDs, and the batch table is not mistaken for the base one.
+    assert intro["claude-haiku-4-5"].input == 1.0
+    assert intro["claude-opus-5"].output == 25.0
+
+
+def test_price_feed_reads_standard_short_context_and_ignores_the_other_tiers() -> None:
+    """Batch is half price and long context roughly double — picking either misprices runs."""
+    rates = parse_openai(_OPENAI_MD)
+    assert rates["gpt-5.6-sol"] == Rates(input=5.0, cached_input=0.5, cache_write=6.25, output=30.0)
+    assert rates["gpt-5.6-luna"].output == 1.2
+    # A row whose cache columns are "-" falls back to the standard multiples of input.
+    assert rates["gpt-5.5"] == Rates(input=5.0, cached_input=0.5, cache_write=6.25, output=30.0)
+
+
+def test_price_feed_reports_a_changed_cache_rate_not_just_input_and_output() -> None:
+    """On a cached workload the cache rate is most of the bill, so a diff must surface it."""
+    current = {"claude-opus-5": Rates(input=5.0, cached_input=0.5, cache_write=6.25, output=25.0)}
+    same = diff_rates(current, {"claude-opus-5": current["claude-opus-5"]})
+    assert same == []
+
+    cheaper_cache = Rates(input=5.0, cached_input=0.25, cache_write=6.25, output=25.0)
+    (change,) = diff_rates(current, {"claude-opus-5": cheaper_cache})
+    assert change.kind == "changed"
+    assert "cached_input $0.5→$0.25" in change.describe()
+    assert "input $" not in change.describe().replace("cached_input $", "")
+
+
+def test_price_feed_parsers_fail_loudly_on_an_unrecognized_page() -> None:
+    """A silent empty parse would leave every model unpriced with no explanation."""
+    for parse in (lambda md: parse_anthropic(md, today=date(2026, 8, 3)), parse_openai):
+        with pytest.raises(PriceFeedError, match="layout may have changed"):
+            parse("# Pricing\n\nWe have moved our prices to a new page.\n")
+
+
 def test_stderr_filter_keeps_first_of_each_line() -> None:
     import io
 
@@ -293,6 +1588,14 @@ def test_collect_train_runs_carries_load_status(project: Path, make_result) -> N
     assert [r.skill_loaded for r in runs].count(None) == 1
 
 
+def test_improver_refuses_provider_exhaustion_evidence(project: Path, make_result) -> None:
+    key = RunKey(arm="skill_v1", split="train", model="gpt-5.6-sol", task_id="example_task", rep=1)
+    make_result(project / "runs", key, valid=False, reason="provider_exhausted", success=False)
+
+    with pytest.raises(ImproveError, match="infrastructure-invalid benchmark result"):
+        collect_train_runs(project / "runs", "skill_v1", load_tasks(project / "tasks.yaml"))
+
+
 def test_load_rates_split_by_model_and_count_undetermined(project: Path, make_result) -> None:
     """Rates are per model, since the load rate varies more by model than by skill version."""
     rates = load_rates(_train_evidence(project, make_result, [True, True, False, None]))
@@ -344,34 +1647,6 @@ def test_improve_prompt_separates_loading_from_the_body() -> None:
 # --- auth preflight --------------------------------------------------------------------
 
 
-def test_auth_preflight(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    # Point credential discovery at an empty throwaway dir and strip every auth variable,
-    # so the only auth in play is what the test sets.
-    monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(tmp_path))
-    for var in AUTH_ENV_VARS:
-        monkeypatch.delenv(var, raising=False)
-
-    # No variable and no credentials file → unauthenticated, and check_auth fails loudly.
-    assert auth_available() is False
-    with pytest.raises(EnvError, match="no Claude credentials"):
-        check_auth()
-
-    # An empty variable does not count.
-    monkeypatch.setenv("ANTHROPIC_API_KEY", "")
-    assert auth_available() is False
-
-    # A non-empty auth variable authenticates.
-    monkeypatch.setenv("ANTHROPIC_API_KEY", "sk-test")
-    assert auth_available() is True
-    check_auth()  # does not raise
-
-    # So does a seeded credentials file, even with no auth variable set.
-    monkeypatch.delenv("ANTHROPIC_API_KEY", raising=False)
-    (tmp_path / ".credentials.json").write_text("{}")
-    assert auth_available() is True
-    check_auth()
-
-
 def _clear_auth(monkeypatch: pytest.MonkeyPatch, config_dir: Path) -> None:
     """Isolate auth detection: empty credential dir, every auth variable stripped."""
     monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(config_dir))
@@ -417,41 +1692,140 @@ def test_resolve_auth_mode_for_meta_commands(tmp_path: Path, monkeypatch: pytest
 
     # No credentials at all → auto cannot resolve.
     with pytest.raises(EnvError, match="no Claude credentials"):
-        resolve_auth_mode("auto", allow_session=True)
+        resolve_auth_mode("auto")
 
     # auto prefers the subscription when a login exists.
     _write_oauth_credentials(tmp_path)
     monkeypatch.setenv("ANTHROPIC_API_KEY", "sk-test")
-    assert resolve_auth_mode("auto", allow_session=True) == "session"
+    assert resolve_auth_mode("auto") == "session"
 
     # auto falls back to the API when there is no subscription.
     (tmp_path / ".credentials.json").unlink()
-    assert resolve_auth_mode("auto", allow_session=True) == "api"
+    assert resolve_auth_mode("auto") == "api"
 
     # Forcing a mode requires that mode's credential.
-    assert resolve_auth_mode("api", allow_session=True) == "api"
+    assert resolve_auth_mode("api") == "api"
     with pytest.raises(EnvError, match="--auth session"):
-        resolve_auth_mode("session", allow_session=True)
+        resolve_auth_mode("session")
     _write_oauth_credentials(tmp_path)
     monkeypatch.delenv("ANTHROPIC_API_KEY", raising=False)
-    assert resolve_auth_mode("session", allow_session=True) == "session"
+    assert resolve_auth_mode("session") == "session"
     with pytest.raises(EnvError, match="--auth api"):
-        resolve_auth_mode("api", allow_session=True)
+        resolve_auth_mode("api")
 
 
-def test_resolve_auth_mode_for_bench(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    _clear_auth(monkeypatch, tmp_path)
+def test_bench_may_bill_the_subscription(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    """Cost comes from token counts, which both billing modes report.
 
-    # bench never bills the subscription, even when only a subscription is available.
+    bench used to reject ``session`` on the grounds that only metered API billing yields a
+    real per-run cost. Once cost became a function of tokens that stopped being true, so the
+    mode is a choice the run records rather than one it refuses.
+    """
+    _clear_auth(monkeypatch, tmp_path)
     _write_oauth_credentials(tmp_path)
-    with pytest.raises(EnvError, match="session is not available for it"):
-        resolve_auth_mode("session", allow_session=False)
-    with pytest.raises(EnvError, match="must bill the API"):
-        resolve_auth_mode("api", allow_session=False)
 
-    # With an API credential, bench resolves to api.
-    monkeypatch.setenv("ANTHROPIC_API_KEY", "sk-test")
-    assert resolve_auth_mode("api", allow_session=False) == "api"
+    assert resolve_auth_mode("auto") == "session"
+    assert resolve_auth_mode("session") == "session"
+    # Forcing the API still requires an API credential.
+    with pytest.raises(EnvError, match="--auth api"):
+        resolve_auth_mode("api")
+
+
+def test_codex_auth_resolution_and_isolated_env(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    real_home = tmp_path / "real-codex"
+    real_home.mkdir()
+    (real_home / "auth.json").write_text('{"tokens": {}}')
+    monkeypatch.setenv("CODEX_HOME", str(real_home))
+    monkeypatch.setenv("OPENAI_API_KEY", "sk-openai")
+    monkeypatch.delenv("CODEX_API_KEY", raising=False)
+
+    assert session_auth_available("codex")
+    assert api_auth_available("codex")
+    assert resolve_auth_mode("auto", provider="codex") == "session"
+    assert resolve_auth_mode("api", provider="codex") == "api"
+
+    isolated = tmp_path / "isolated-codex"
+    env = build_agent_env(
+        config_dir=isolated,
+        home=tmp_path / "home",
+        auth_mode="session",
+        provider="codex",
+    )
+    assert (isolated / "auth.json").is_file()
+    assert env["CODEX_HOME"] == str(isolated)
+    assert env["CODEX_API_KEY"] == ""
+    assert env["OPENAI_API_KEY"] == ""
+
+    api_home = tmp_path / "api-codex"
+    api_env = build_agent_env(
+        config_dir=api_home,
+        home=tmp_path / "api-home",
+        auth_mode="api",
+        provider="codex",
+    )
+    assert not (api_home / "auth.json").exists()
+    assert api_env["CODEX_API_KEY"] == "sk-openai"
+
+
+def test_codex_persisted_api_key_is_api_auth_not_a_subscription(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    real_home = tmp_path / "real-codex"
+    real_home.mkdir()
+    (real_home / "auth.json").write_text('{"auth_mode": "apikey", "OPENAI_API_KEY": "sk-stored"}')
+    monkeypatch.setenv("CODEX_HOME", str(real_home))
+    monkeypatch.delenv("CODEX_API_KEY", raising=False)
+    monkeypatch.delenv("OPENAI_API_KEY", raising=False)
+
+    assert not session_auth_available("codex")
+    assert api_auth_available("codex")
+    assert resolve_auth_mode("auto", provider="codex") == "api"
+    assert resolve_auth_mode("api", provider="codex") == "api"
+    with pytest.raises(EnvError, match="--auth session"):
+        resolve_auth_mode("session", provider="codex")
+
+    isolated = tmp_path / "isolated-codex"
+    env = build_agent_env(
+        config_dir=isolated,
+        home=tmp_path / "home",
+        auth_mode="api",
+        provider="codex",
+    )
+    assert json.loads((isolated / "auth.json").read_text())["auth_mode"] == "apikey"
+    assert env["CODEX_API_KEY"] == ""
+    assert not env.get("OPENAI_API_KEY")
+
+
+def test_scrubbed_env_never_carries_the_other_providers_credentials(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """A run authenticates with one provider, so the other's keys must not ride the allowlist in.
+
+    ``CODEX_API_KEY``/``OPENAI_API_KEY`` and the Anthropic variables are all allowlisted, so
+    without an explicit blank an operator with both configured hands every Claude agent their
+    OpenAI key and every Codex agent their Anthropic key — ambient secrets in a web-enabled
+    agent, and two live credentials where the module promises exactly one.
+    """
+    _clear_auth(monkeypatch, tmp_path)
+    monkeypatch.setenv("ANTHROPIC_API_KEY", "sk-ant")
+    monkeypatch.setenv("CLAUDE_CODE_OAUTH_TOKEN", "oauth-token")
+    monkeypatch.setenv("OPENAI_API_KEY", "sk-openai")
+    home = tmp_path / "home"
+
+    for mode in ("session", "api", None):
+        claude = scrubbed_env(config_dir=tmp_path / "cfg", home=home, auth_mode=mode, provider="claude")
+        assert claude["OPENAI_API_KEY"] == ""
+        assert claude["CODEX_API_KEY"] == ""
+
+        codex = scrubbed_env(config_dir=tmp_path / "cfg", home=home, auth_mode=mode, provider="codex")
+        assert codex["ANTHROPIC_API_KEY"] == ""
+        assert codex["CLAUDE_CODE_OAUTH_TOKEN"] == ""
+
+    # The selected provider's own credential still survives its mode.
+    api = scrubbed_env(config_dir=tmp_path / "cfg", home=home, auth_mode="api", provider="codex")
+    assert api["CODEX_API_KEY"] == "sk-openai"
+    session = scrubbed_env(config_dir=tmp_path / "cfg", home=home, auth_mode="session", provider="codex")
+    assert session["CODEX_API_KEY"] == ""
 
 
 def test_scrubbed_env_auth_mode_filters_credentials(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
@@ -570,6 +1944,14 @@ def test_build_agent_env_seeds_only_in_session_mode(tmp_path: Path, monkeypatch:
     assert not (api_cfg / ".credentials.json").exists()  # not seeded
 
 
+def test_reports_refuse_provider_exhaustion_results(runs_root: Path, model: str, make_result) -> None:
+    key = RunKey(arm="noskill", split="train", model=model, task_id="quota", rep=1)
+    make_result(runs_root, key, valid=False, reason="provider_exhausted", success=False)
+
+    with pytest.raises(ReportError, match="infrastructure-invalid provider quota/credit"):
+        load_results(runs_root)
+
+
 def test_resolve_palette_overrides_by_id_and_by_label() -> None:
     """An override wins over the tier default, keyed by the raw id or its display form."""
     models = ["claude-opus-5", "claude-haiku-4-5-20251001"]
@@ -658,6 +2040,17 @@ def test_skill_loaded_column_counts_undetermined_runs_as_not_loaded(runs_root: P
     assert widths == [0.0, 0.5]  # the baseline loaded nothing; one of two skill runs is determined
 
 
+def test_loaded_flags_fill_missing_values_without_object_downcast_warning() -> None:
+    values = pd.DataFrame({"skill_loaded": pd.Series([True, None, False], dtype=object)})
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", FutureWarning)
+        flags = _loaded_flags(values)
+
+    assert flags.dtype == bool
+    assert flags.tolist() == [True, False, False]
+
+
 @pytest.mark.parametrize(("loads", "warned"), [((True, True, False), False), ((True, False, False), True)])
 def test_load_warning_needs_most_of_the_arm_to_miss(
     runs_root: Path, model: str, make_result, loads: tuple[bool, ...], warned: bool
@@ -676,6 +2069,115 @@ def test_load_warning_needs_most_of_the_arm_to_miss(
     assert bool(notes) is warned
 
 
+def test_arms_priced_on_different_dates_are_flagged_as_not_cost_comparable(
+    runs_root: Path, model: str, make_result
+) -> None:
+    """Benching arms weeks apart confounds the skill's effect with a change in list price.
+
+    Rates are resolved live and frozen per run, so each figure is true to what it cost —
+    but the difference *between* arms then contains both effects, and nothing downstream
+    can separate them. The report says so rather than presenting the gap as the skill's.
+    """
+    for arm, as_of in (("noskill", "2026-08-04"), ("skill_v1", "2026-10-04")):
+        for split in ("train", "test"):
+            key = RunKey(arm=arm, split=split, model=model, task_id="example_task", rep=1)
+            make_result(runs_root, key, price_rates_as_of=as_of, price_source="fetched")
+
+    (note,) = [n for n in _integrity_notes(load_results(runs_root)) if "priced on different dates" in n]
+    assert "2026-08-04" in note and "2026-10-04" in note
+    assert "not only the skill's effect" in note
+
+
+def test_one_pass_priced_on_one_date_is_not_flagged(runs_root: Path, model: str, make_result) -> None:
+    """The note must stay quiet on the ordinary case, or it teaches people to ignore it."""
+    for arm in ("noskill", "skill_v1"):
+        for split in ("train", "test"):
+            key = RunKey(arm=arm, split=split, model=model, task_id="example_task", rep=1)
+            make_result(runs_root, key, price_rates_as_of="2026-08-04", price_source="fetched")
+
+    notes = _integrity_notes(load_results(runs_root))
+
+    assert not any("priced on different dates" in note for note in notes)
+
+
+def test_unpriced_runs_are_unknown_in_reports_not_zero_cost(
+    runs_root: Path, model: str, make_result, tmp_path: Path
+) -> None:
+    key = RunKey(arm="noskill", split="test", model=model, task_id="example_task", rep=1)
+    make_result(runs_root, key, cost_usd=0.0, cost_available=False)
+
+    df = load_results(runs_root)
+    test = df[df["split"] == "test"]
+    assert test["cost_usd"].isna().all()
+    assert pd.isna(arm_metrics(test).loc[0, "cost"])
+    assert any("cost unavailable" in note for note in _integrity_notes(df))
+    assert "&mdash;" in _runs_table_html(test, tmp_path)
+
+    tests = skill_tests(df)
+    assert tests.cost_unavailable
+    assert not tests.usable
+    assert "Cost comparison unavailable" in _tests_table_html(tests)
+
+    figure = tradeoff_figure(df)
+    try:
+        assert _pooled_marks(figure) == []
+        assert _model_marks(figure) == []
+    finally:
+        plt.close(figure)
+
+
+def test_reports_use_inferred_cost_and_csv_keeps_recorded_cost(
+    runs_root: Path, model: str, make_result, tmp_path: Path
+) -> None:
+    """Provider cost remains auditable without changing cross-provider comparisons."""
+    key = RunKey(arm="noskill", split="test", model=model, task_id="example_task", rep=1)
+    make_result(
+        runs_root,
+        key,
+        cost_usd=0.90,
+        cost_available=True,
+        cost_source="provider",
+        provider_cost_usd=0.90,
+        inferred_cost_usd=0.20,
+    )
+
+    df = load_results(runs_root)
+    test = df[df["split"] == "test"]
+    assert test.iloc[0]["cost_usd"] == pytest.approx(0.90)
+    assert test.iloc[0][_REPORT_COST_COLUMN] == pytest.approx(0.20)
+    assert arm_metrics(test).loc[0, "cost"] == pytest.approx(0.20)
+    assert "0.200" in _runs_table_html(test, tmp_path)
+    assert "0.900" not in _runs_table_html(test, tmp_path)
+
+    out_path = tmp_path / "results.html"
+    build_report(runs_root, out_path)
+    exported = pd.read_csv(out_path.with_suffix(".csv"))
+    test_row = exported[exported["split"] == "test"].iloc[0]
+    assert test_row["recorded_cost_usd"] == pytest.approx(0.90)
+    assert test_row["inferred_cost_usd"] == pytest.approx(0.20)
+    assert "provider_cost_usd" not in exported.columns
+    assert _REPORT_COST_COLUMN not in exported.columns
+
+
+def test_modern_result_without_inferred_cost_stays_unpriced_in_report(runs_root: Path, model: str, make_result) -> None:
+    """A recorded provider estimate must never substitute for missing inference."""
+    key = RunKey(arm="noskill", split="test", model=model, task_id="example_task", rep=1)
+    make_result(
+        runs_root,
+        key,
+        cost_usd=0.90,
+        cost_available=True,
+        cost_source="provider",
+        provider_cost_usd=0.90,
+        inferred_cost_usd=None,
+    )
+
+    test = load_results(runs_root).query("split == 'test'")
+    assert test.iloc[0]["cost_usd"] == pytest.approx(0.90)
+    assert pd.isna(test.iloc[0][_REPORT_COST_COLUMN])
+    assert pd.isna(arm_metrics(test).loc[0, "cost"])
+
+
 # --- the cost/success trade-off figure --------------------------------------------------
 
 #: The two markers matplotlib gives an error bar's caps; neither is a data point.
@@ -1104,7 +2606,7 @@ def test_runs_table_marks_every_column_sortable_but_the_transcript_link(runs_roo
     sortable = {text for attrs, text in headings if "data-sortable" in attrs}
     inert = {text for attrs, text in headings if "data-sortable" not in attrs}
     assert inert == {"transcript"}
-    assert "cost $" in sortable and "total tok" in sortable
+    assert "cost / run $" in sortable and "total tok" in sortable
 
 
 def test_runs_table_sorts_formatted_numbers_by_their_value(
@@ -1147,6 +2649,49 @@ def test_runs_table_ranks_a_skill_that_failed_to_load_above_one_that_loaded() ->
     assert ranks == sorted(ranks, reverse=True)
 
 
+def _run(arm: str, model: str, success: bool, loaded: object, split: str = "test") -> dict:
+    return {"arm": arm, "model": model, "split": split, "success": success, "skill_loaded": loaded}
+
+
+def test_loaded_only_rates_pools_over_one_model_mix_on_both_sides() -> None:
+    """A model that never loaded the skill must leave the pooled baseline too.
+
+    Otherwise a model that fails every run — an outage, an unavailable id — depresses the
+    baseline while contributing nothing to the loaded side, manufacturing a gain from nothing.
+    """
+    rows = (
+        # A working model: loads the skill, same rate in both arms.
+        [_run("noskill", "good", True, None) for _ in range(4)]
+        + [_run("skill_v1", "good", True, True) for _ in range(4)]
+        # A broken model: fails everything and never loads the skill.
+        + [_run("noskill", "broken", False, None) for _ in range(4)]
+        + [_run("skill_v1", "broken", False, False) for _ in range(4)]
+    )
+    table = loaded_only_rates(pd.DataFrame(rows))
+    pooled = table[table["scope"] == "matched"].iloc[0]
+    raw = table[table["scope"] == "all"].iloc[0]
+
+    # Only the loading model is pooled, on both sides — so the skill shows no gain…
+    assert pooled["loaded"] == 4 and pooled["runs"] == 4
+    assert pooled["baseline"] == 1.0 and pooled["rate"] == 1.0
+    assert pooled["delta"] == 0.0
+    # …while the raw all-models row keeps the mix as it ran, and shows the artifact the
+    # matched row exists to expose: a +50% that is entirely the broken model leaving.
+    assert raw["runs"] == 8 and raw["baseline"] == 0.5 and raw["rate"] == 1.0
+    assert raw["delta"] == 0.5
+
+
+def test_loaded_only_rates_reports_a_model_that_never_loaded() -> None:
+    """The row still appears — a 0% load rate is the finding, not a reason to hide the model."""
+    rows = [_run("noskill", "m", True, None), _run("skill_v1", "m", False, False)]
+    table = loaded_only_rates(pd.DataFrame(rows))
+
+    row = table[table["model"] == "m"].iloc[0]
+    assert row["loaded"] == 0
+    assert row["load_rate"] == 0.0
+    assert pd.isna(row["rate"]) and pd.isna(row["delta"])
+
+
 # --- split diff ------------------------------------------------------------------------