cdx-manager 0.20.4 → 0.20.6

package/README.md

@@ -4,7 +4,7 @@
 
 <br clear="left"/>
 
-[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.20.4-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
+[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.20.6-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
 
 **Stop guessing which AI account still has quota.** `cdx` tracks the rate-limit window of every Codex and Claude account you own, tells you which one is usable right now, and launches it with isolated auth — in one command.
 
@@ -725,13 +725,13 @@ Every usage record, whichever path produced it, uses one set of definitions:
 
 Cached input is counted once: it is excluded from `input_tokens` and reported in the cache fields, never in both. `null` means the provider did not report the figure, which is not the same as zero.
 
-`cdx stats` also shows a **`COST~`** column and ranks sessions by it. It weights each token class by what it costs relative to one uncached input token — cache read 0.1x, cache write 1.25x, output 5x — and reports the result in uncached-input-equivalent tokens. These are ratios rather than prices: across the current model lineup output is 5x input on every model and the cache multipliers do not vary by model either, so the figure needs no per-model price table and does not go stale when prices change. It is **not** a currency amount, and it is not comparable across providers whose own prices differ. The cache-write multiplier assumes the five-minute cache TTL; a one-hour TTL costs 2x and nothing in a transcript says which was used, so long-TTL writes are slightly under-weighted.
+`cdx stats` also shows a **`COST~`** column and ranks sessions by it. It weights each token class by what it costs relative to one uncached input token — cache read 0.1x, cache write 1.25x, and output at the recorded model's output/input ratio — and reports the result in uncached-input-equivalent tokens. These are ratios rather than prices. It is **not** a currency amount, and it is not comparable across providers whose own prices differ. The cache-write multiplier assumes the five-minute cache TTL; a one-hour TTL costs 2x and nothing in a transcript says which was used, so long-TTL writes are slightly under-weighted.
 
 Ranking on the raw total would put a session that mostly replayed a cache above one that spent far more on generation, because cache reads are typically the overwhelming majority of tokens consumed while costing a fiftieth of an output token.
 
 The **`USD~`** column turns that into money for runs whose serving model cdx recorded. It needs one number per model — the list price per million uncached input tokens — because `COST~` has already absorbed every other rate. Prices live in configuration, not in code: set `CDX_TOKEN_PRICES` to a JSON object mapping model id to dollars per million tokens to override the built-in table, whose last review date is printed with the totals. A run whose model cdx never saw stays unpriced rather than being charged at a default tier, and the totals line says how many runs were actually priced.
 
-The table carries two numbers per model — uncached input and output per million tokens — and derives the cache rates from the input rate: a cache read is 0.1x it and a cache write 1.25x, a relationship that holds on both vendors. Each token class is then priced at its own rate rather than through the weighted figure, because the weighted shortcut is only correct while every model shares one output ratio, and they do not: Anthropic bills output at 5x input, OpenAI at 6x.
+The table carries two numbers per model — uncached input and output per million tokens — and derives the cache rates from the input rate: a cache read is 0.1x it and a cache write 1.25x, a relationship that holds on the supported non-Pro model rows. Each token class is then priced at its own rate rather than through a weighted shortcut, because output/input ratios vary by model.
 
 Three caveats stated rather than hidden. A run is priced at the model serving its most recent record, so a run that switched models mid-way is priced at the newer one. The figure is an estimate at public list prices — not an invoice. And OpenAI's long-context tier, which roughly doubles both rates above a 272K-token request, is **not** modelled: cdx records tokens per run rather than per request, so it cannot tell which requests crossed that line, and long-context Codex work is under-costed.
 
@@ -742,7 +742,7 @@ Totals: 26 runs, ... ; no price for gpt-6-unreleased)
 CDX_TOKEN_PRICES='{"gpt-6-unreleased": {"input": 3, "output": 18}}' cdx stats
 ```
 
-**Prices are the only part of this that rots on its own.** A test fails once the table has gone 90 days without review, and `scripts/check_token_prices.py` compares it against published pricing — outside the test suite, since a check that needs the network fails for reasons nobody wants in CI. A row it cannot confirm is reported as unverified, never as passing. When it finds a difference, follow [`docs/token-prices-runbook.md`](docs/token-prices-runbook.md) — which also records where each vendor's numbers actually live, and which pages refuse to be read by a script.
+**Prices are the only part of this that rots on its own.** A test fails once the table has gone 90 days without review, and `scripts/check_token_prices.py` compares it against published pricing — outside the test suite, since a check that needs the network fails for reasons nobody wants in CI. A row it cannot confirm is reported as unverified, never as passing. When it finds a difference, follow [`logics/runbook/run_005_maintaining_the_token_price_table.md`](logics/runbook/run_005_maintaining_the_token_price_table.md) — which also records where each vendor's numbers actually live.
 
 Runs recorded before these definitions existed carry figures that are fictitious rather than imprecise — one real session reported 206.6M cached tokens for a period in which its own conversation consumed 33,608, because the old reader picked whichever transcript had the newest modification time and re-read all of it on every launch. They cannot be recomputed: a run's true usage is the increment its transcript gained while it ran, and nothing recorded that. They are therefore excluded from every total automatically, and the totals line says how many runs that covered — so a period containing only such runs reads as absent rather than as a session that spent nothing. The records themselves are left alone, which keeps them recoverable if the marker ever proves wrong; `cdx repair` clears them from the file for anyone who would rather they were gone:
 
@@ -1092,11 +1092,15 @@ For example, a user-owned daily cron entry can run:
 ```
 
 `locked` means an interactive session owns the profile refresh lock and was left
-untouched. `login_required` means the provider rejected the local refresh token;
-run the supplied `cdx login <name>` command interactively. Hosts keep independent
-rotating credentials, so copying an auth file is not ongoing credential sync.
-
-- **`cdx <name>` fails with "not authenticated"** — run `cdx login <name>` first.
+untouched. If every selected profile is locked, the command is non-zero because
+it verified no credential; a mix of valid and locked profiles remains successful.
+Bulk refresh skips disabled profiles, while `cdx auth refresh <name>` still lets
+an operator inspect one explicitly. `login_required` means the provider rejected
+the local refresh token; run the supplied `cdx login <name>` command interactively.
+Hosts keep independent rotating credentials, so copying an auth file is not ongoing
+credential sync.
+
+- **`cdx <name>` fails with "not authenticated"** — run `cdx login <name>` first. `cdx doctor` uses the same Codex app-server probe as `cdx auth refresh`, so a local auth file alone is never reported as live authentication; a rejected refresh token is reported as `login_required` with the matching login command.
 - **One of two Codex accounts keeps asking for login** — run `cdx doctor --json` and inspect each Codex session's `codex_auth_file`, `codex_live_auth`, and `codex_stale_auth_logs` checks. If recent logs mention expired auth, repair only that isolated profile with `cdx login <name>`. Codex Business profiles can share the same `tokens.account_id`; `cdx doctor` reports `codex_shared_account_id` as a workspace-level clue, not proof that two profiles use the same user. Newly created sessions seed from the current global `~/.codex/auth.json` when one exists. For two separate Codex accounts, create or repair each session by running `cdx login <name>` for that session; `cdx login` does not log out first, so use `cdx logout <name>` explicitly only when you want to clear that isolated profile.
 - **`cdx` says no compatible Python 3 interpreter was found** — install Python 3 and make `py -3`, `python`, or `python3` available on PATH.
 - **`cdx add` succeeds but the session does not appear** — check that `CDX_HOME` is consistent between calls; a mismatch creates two separate registries.

package/VERSION

@@ -1 +1 @@
-0.20.4
+0.20.6

package/changelogs/CHANGELOGS_0_20_5.md

@@ -0,0 +1,22 @@
+# CDX Manager 0.20.5
+
+## Fixes
+
+- `cdx doctor` now uses the live Codex app-server authentication probe instead
+  of trusting a local auth file, so an expired or rejected refresh token is
+  reported as `login_required` with an actionable `cdx login <name>` remedy.
+- `cdx auth refresh all` skips disabled Codex profiles, while an explicit
+  `cdx auth refresh <name>` still lets an operator inspect a disabled profile
+  deliberately.
+- A bulk Codex auth refresh where every selected profile is locked now exits
+  non-zero as `auth_refresh_indeterminate` instead of looking like a silent
+  success without verifying any credential.
+- Codex app-server diagnostics no longer keep an unread stderr pipe while
+  waiting for stdout, avoiding a possible deadlock or timeout from noisy
+  provider diagnostics.
+
+## Validation
+
+- Package smoke coverage now runs `cdx doctor --json` from both packed npm and
+  wheel installs with isolated local provider shims, so packaged doctor
+  regressions are caught outside the source checkout.

package/changelogs/CHANGELOGS_0_20_6.md

@@ -0,0 +1,14 @@
+# CDX Manager 0.20.6
+
+## Fixes
+
+- `cdx stats` now prices current Codex/OpenAI and Claude models that were
+  previously unpriced or stale, including `gpt-5.5`, `gpt-5.6-terra`, and the
+  current Claude Sonnet/Haiku snapshot ids seen in real usage history.
+- The token price review tooling now checks OpenAI's official pricing
+  documentation directly and points maintainers at the active Logics runbook.
+
+## Notes
+
+- Pro-only or credit-based Codex models without an official token price remain
+  unpriced rather than receiving a guessed USD estimate.

package/checksums/release-archives.json

@@ -353,6 +353,28 @@
         "x86_64-pc-windows-msvc": "1f9971c1aee7e92685370db1e6a4bcf37b6012fa7452fc14ca3dd545998af82e",
         "x86_64-unknown-linux-musl": "2aabbc00b0fa3a2c8862cc1a5425a074fec99f072bf7b695d31e6e96b9b08c5d"
       }
+    },
+    "v0.20.4": {
+      "github_tarball_sha256": "55323fe428d6d297f14a210a590757443080dc55a87bb6fae4d967fddb505af3",
+      "github_zip_sha256": "37f4abb392b372d0f5fe5d5eb7c46e1e81a30b319d1961b5518f20e776f59b75",
+      "tray_assets": {
+        "aarch64-apple-darwin": "6d61a45ab6f310a83aefbb80d77dc31b1f3a738640197bcca1264c6ca7b70d26",
+        "aarch64-unknown-linux-musl": "f2f3a2c45c7deb2ea69cdc7c7b68524e6b5db5d1eda0ff902bda49d875636402",
+        "x86_64-apple-darwin": "93d3d9180588edcf573ffa8f9f2e870e8dff9659e198cde531bec0acfc37184f",
+        "x86_64-pc-windows-msvc": "7508e04ee07adb7a500b346be1d3891d93aec54dc0ff53643bd8c57e4e411118",
+        "x86_64-unknown-linux-musl": "47a1c8cff60c896db659d30d74496045d8c343e74a00f826e608f3973e735532"
+      }
+    },
+    "v0.20.5": {
+      "github_tarball_sha256": "6360b48c4e7c3e79f213174d55fa6679ea2e94b016e0de3ebe77a39cdac98856",
+      "github_zip_sha256": "6fed447ed9facf353205745265935fd5c7d73b877e7b933cc53b08656fb1b32a",
+      "tray_assets": {
+        "aarch64-apple-darwin": "5f2bf81fc17f49479e2880d0312e8f60bcd23a87b7d4978c7161015f75783f03",
+        "aarch64-unknown-linux-musl": "76a5a362f5a2c41cab23165760f7d9d3fb5bfbe5a2e9d5b9643afb30e6d65e0d",
+        "x86_64-apple-darwin": "ecc05376dd93c043b36dad6e9a27e129c00898227f204e0c8f050ee834138239",
+        "x86_64-pc-windows-msvc": "208064f2bfee19914ca72edb527966a9966154179d6d040f0dae4a647a61f9f4",
+        "x86_64-unknown-linux-musl": "9fa01d3b71daed98c9234ddb0cf7b6345b3d757edff910ece4e3bd9f5eb8eb6b"
+      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.20.4",
+  "version": "0.20.6",
   "description": "Terminal session manager for Codex and Claude accounts.",
   "license": "MIT",
   "author": "Alexandre Agostini",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cdx-manager"
-version = "0.20.4"
+version = "0.20.6"
 description = "Terminal session manager for Codex and Claude accounts."
 readme = "README.md"
 requires-python = ">=3.9"

package/src/codex_usage.py

@@ -199,6 +199,15 @@ def fetch_codex_rate_limit_diagnostic(session, timeout=5, popen_factory=None):
         return _probe_codex_rate_limit_diagnostic(session, auth_home, timeout, popen_factory)
 
 
+def diagnostic_needs_codex_login(diagnostic):
+    """Classify known auth failures without returning provider text."""
+    text = json.dumps(diagnostic.get("response") or {}).lower()
+    return any(marker in text for marker in (
+        "not logged in", "unauthorized", "authentication token is expired",
+        "token_expired", "invalid_grant", "http 401",
+    ))
+
+
 def _probe_codex_rate_limit_diagnostic(session, auth_home, timeout=5, popen_factory=None):
     diagnostic = _request_codex_app_server(
         auth_home,
@@ -236,7 +245,7 @@ def _request_codex_app_server(auth_home, method, params, failure_reason, timeout
             ["codex", "app-server", "--listen", "stdio://"],
             stdin=subprocess.PIPE,
             stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
             env=env,
             text=True,
             bufsize=1,

package/src/commands/auth.py

@@ -3,7 +3,6 @@
 Split out of cli_commands.py. Moved verbatim; re-exported by cli_commands.
 """
 
-import json
 import time
 import uuid
 
@@ -18,7 +17,11 @@ from ..cli_helpers import (
     _write_json,
 )
 from ..cli_render import _success, _warn
-from ..codex_usage import consume_codex_rate_limit_reset_credit, fetch_codex_rate_limit_diagnostic
+from ..codex_usage import (
+    consume_codex_rate_limit_reset_credit,
+    diagnostic_needs_codex_login,
+    fetch_codex_rate_limit_diagnostic,
+)
 from ..config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDER_OLLAMA
 from ..errors import CdxError
 from ..notify import (
@@ -36,21 +39,12 @@ def _confirm_reset(name):
     return answer.strip().lower() in ("y", "yes")
 
 
-def _refresh_needs_login(diagnostic):
-    """Classify known provider auth failures without returning provider text."""
-    text = json.dumps(diagnostic.get("response") or {}).lower()
-    return any(marker in text for marker in (
-        "not logged in", "unauthorized", "authentication token is expired",
-        "token_expired", "invalid_grant", "http 401",
-    ))
-
-
 def _refresh_result(session, diagnostic):
     if diagnostic.get("ok"):
         return {"session": session["name"], "provider": PROVIDER_CODEX, "outcome": "valid"}
     if diagnostic.get("reason") == "auth_locked":
         return {"session": session["name"], "provider": PROVIDER_CODEX, "outcome": "locked"}
-    if _refresh_needs_login(diagnostic):
+    if diagnostic_needs_codex_login(diagnostic):
         return {
             "session": session["name"], "provider": PROVIDER_CODEX,
             "outcome": "login_required", "login_command": f"cdx login {session['name']}",
@@ -63,7 +57,7 @@ def handle_auth(rest, ctx):
     target = parsed["target"]
     if target == "all":
         sessions = [session for session in ctx["service"]["list_sessions"]()
-                    if session["provider"] == PROVIDER_CODEX]
+                    if session["provider"] == PROVIDER_CODEX and session.get("enabled", True)]
     else:
         session = ctx["service"]["get_session"](target)
         if not session:
@@ -71,24 +65,32 @@ def handle_auth(rest, ctx):
         if session["provider"] != PROVIDER_CODEX:
             raise CdxError("Authentication refresh is only available for Codex sessions.")
         sessions = [session]
-    if not sessions:
+    if not sessions and target != "all":
         raise CdxError("No managed Codex sessions to refresh.")
 
     probe = ctx["options"].get("fetchCodexRateLimitDiagnostic") or fetch_codex_rate_limit_diagnostic
     results = [_refresh_result(session, probe(session)) for session in sessions]
     failures = [result for result in results if result["outcome"] in ("login_required", "failed")]
-    message = "Codex authentication probe completed" if not failures else "Codex authentication probe needs attention"
+    all_locked = bool(results) and all(result["outcome"] == "locked" for result in results)
+    message = (
+        "Codex authentication probe needs attention" if failures
+        else "Codex authentication probe could not verify any session" if all_locked
+        else "No enabled Codex sessions to refresh" if not results
+        else "Codex authentication probe completed"
+    )
     if parsed["json"]:
         payload = (
             _json_failure("auth.refresh", "auth_refresh_failed", message, results=results)
             if failures else _json_success("auth.refresh", message, results=results)
         )
+        if all_locked:
+            payload = _json_failure("auth.refresh", "auth_refresh_indeterminate", message, results=results)
         _write_json(ctx, payload)
     else:
         for result in results:
             suffix = f"; run {result['login_command']}" if result.get("login_command") else ""
             ctx["out"](f"{result['session']}: {result['outcome']}{suffix}\n")
-    return 1 if failures else 0
+    return 1 if failures or all_locked else 0
 
 def handle_ready(rest, ctx):
     """`cdx ready`: schedule an OS notification for the next session to come back.

package/src/health.py

@@ -337,11 +337,16 @@ def _codex_auth_issues(session, diag):
     ]
     live_status = diag.get("live_status")
     live_ok = live_status == "authenticated"
-    live_warn = live_status in ("logged_out", "error")
+    live_warn = live_status in ("logged_out", "login_required", "error")
+    live_message = (
+        f"session {name} Codex authentication requires login; run cdx login {name}"
+        if live_status == "login_required"
+        else f"session {name} live Codex auth status: {live_status}"
+    )
     issues.append(_issue(
         "OK" if live_ok else "WARN" if live_warn else "WARN",
         "codex_live_auth",
-        f"session {name} live Codex auth status: {live_status}",
+        live_message,
         {
             "session": name,
             "auth_home": diag.get("auth_home"),

package/src/provider_runtime.py

@@ -13,7 +13,7 @@ from datetime import datetime, timezone
 
 from .agent_notify import launch_notify_env, notifications_enabled
 from .claude_usage import _clean_oauth_token, _decode_jwt_claims
-from .codex_usage import codex_auth_lock
+from .codex_usage import codex_auth_lock, diagnostic_needs_codex_login, fetch_codex_rate_limit_diagnostic
 from .config import (
     PROVIDER_ANTIGRAVITY,
     PROVIDER_CLAUDE,
@@ -294,19 +294,21 @@ def codex_auth_diagnostic(session, spawn_sync=None, env_override=None):
         "live_status": "unknown",
         "live_error": None,
     }
-    try:
-        status = _probe_provider_auth_status(
-            session,
-            spawn_sync=spawn_sync,
-            env_override=env_override,
-            trust_local_credentials=False,
-        )
-        result["live_status"] = status
-        if status == AUTH_PROBE_DEGRADED:
-            result["live_error"] = _auth_probe_degraded_message(session)
-    except CdxError as error:
+    if not result["local_tokens_present"]:
+        result["live_status"] = AUTH_PROBE_LOGGED_OUT
+        return result
+    diagnostic = fetch_codex_rate_limit_diagnostic(session)
+    if diagnostic["ok"]:
+        result["live_status"] = AUTH_PROBE_AUTHENTICATED
+    elif diagnostic["reason"] == "auth_locked":
+        result["live_status"] = AUTH_PROBE_DEGRADED
+        result["live_error"] = "Codex authentication probe is locked by an active session."
+    elif diagnostic_needs_codex_login(diagnostic):
+        result["live_status"] = "login_required"
+        result["live_error"] = f"Codex authentication requires login; run cdx login {session['name']}."
+    else:
         result["live_status"] = "error"
-        result["live_error"] = str(error)
+        result["live_error"] = f"Codex app-server authentication probe failed ({diagnostic['reason']})."
     return result
 
 

package/src/run_usage.py

@@ -99,9 +99,8 @@ CACHE_READ_MULTIPLIER = 0.1
 CACHE_WRITE_MULTIPLIER = 1.25
 
 #: What an output token costs relative to an uncached input one, when the model
-#: is unknown. Anthropic bills 5x and OpenAI 6x, so an unknown model is priced
-#: at the lower of the two: understating a cost cdx is guessing at is the safer
-#: direction.
+#: is unknown. Current model ratios vary, so an unknown model is priced at the
+#: low known ratio: understating a cost cdx is guessing at is the safer direction.
 DEFAULT_OUTPUT_MULTIPLIER = 5.0
 
 
@@ -155,13 +154,11 @@ def weighted_usage(usage, model=None, prices=None):
 #: rather than editing code, and treat an unknown model as unpriced instead of
 #: assuming a tier. `scripts/check_token_prices.py` re-checks this table
 #: against published pricing and a staleness test fails when nobody has;
-#: `docs/token-prices-runbook.md` records where the numbers live and which
+#: `logics/runbook/run_005_maintaining_the_token_price_table.md` records where the numbers live and which
 #: vendor pages refuse to be read.
 #:
-#: Anthropic figures come from the vendor's own reference. OpenAI figures were
-#: taken from third-party aggregators on 2026-08-14 because openai.com refuses
-#: automated fetches; four sources agreed on $2.50/$15 for Terra and one
-#: outlier said $2/$12, so these carry more doubt than the Anthropic rows.
+#: Anthropic and OpenAI figures come from the vendors' own references, checked
+#: on the review date below.
 #:
 #: Not modelled: OpenAI's long-context tier, which roughly doubles both rates
 #: above a 272K-token request. cdx records tokens per run, not per request, so
@@ -175,15 +172,29 @@ DEFAULT_TOKEN_PRICES = {
     "claude-opus-4-8": {"input": 5.0, "output": 25.0},
     "claude-opus-4-7": {"input": 5.0, "output": 25.0},
     "claude-opus-4-6": {"input": 5.0, "output": 25.0},
-    "claude-sonnet-5": {"input": 3.0, "output": 15.0},
+    "claude-opus-4-5": {"input": 5.0, "output": 25.0},
+    "claude-sonnet-5": {"input": 2.0, "output": 10.0},
     "claude-sonnet-4-6": {"input": 3.0, "output": 15.0},
+    "claude-sonnet-4-5": {"input": 3.0, "output": 15.0},
+    "claude-sonnet-4-5-20250929": {"input": 3.0, "output": 15.0},
     "claude-haiku-4-5": {"input": 1.0, "output": 5.0},
+    "claude-haiku-4-5-20251001": {"input": 1.0, "output": 5.0},
     # OpenAI
-    "gpt-5.6-sol": {"input": 5.0, "output": 30.0},
-    "gpt-5.6-terra": {"input": 2.5, "output": 15.0},
-    "gpt-5.6-luna": {"input": 1.0, "output": 6.0},
+    "gpt-5.6": {"input": 4.0, "output": 20.0},
+    "gpt-5.6-sol": {"input": 4.0, "output": 20.0},
+    "gpt-5.6-terra": {"input": 2.0, "output": 12.0},
+    "gpt-5.6-luna": {"input": 0.2, "output": 1.2},
+    "gpt-5.5": {"input": 5.0, "output": 30.0},
+    "gpt-5.5-2026-04-23": {"input": 5.0, "output": 30.0},
+    "gpt-5.4": {"input": 2.5, "output": 15.0},
+    "gpt-5.4-2026-03-05": {"input": 2.5, "output": 15.0},
+    "gpt-5.4-mini": {"input": 0.75, "output": 4.5},
+    "gpt-5.4-mini-2026-03-17": {"input": 0.75, "output": 4.5},
+    "gpt-5.4-nano": {"input": 0.2, "output": 1.25},
+    "gpt-5.4-nano-2026-03-17": {"input": 0.2, "output": 1.25},
+    "gpt-5.3-codex": {"input": 1.75, "output": 14.0},
 }
-TOKEN_PRICES_REVIEWED = "2026-08-14"
+TOKEN_PRICES_REVIEWED = "2026-08-22"
 #: How long a review stays fresh before the staleness test asks for another.
 TOKEN_PRICES_MAX_AGE_DAYS = 90
 TOKEN_PRICES_ENV = "CDX_TOKEN_PRICES"
@@ -215,8 +226,7 @@ def estimate_cost(usage, model, prices=None):
 
     Each token class is priced directly rather than through the weighted
     figure. That shortcut was only correct while every model shared one
-    output-to-input ratio, and it does not: Anthropic bills 5x, OpenAI 6x, so
-    it under-costed Codex output by a fifth.
+    output-to-input ratio, and they do not.
 
     ponytail: a run is priced at one model -- the one serving its most recent
     record -- rather than split per model. A session that switches models