cdx-manager 0.20.13 → 0.20.14

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.13-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.14-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.
 
@@ -773,15 +773,17 @@ 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, 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.
+`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 at the recorded model's ratio (0.1x by default), 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 **`USD~`** column turns that into money for runs whose serving model cdx recorded. It prices each token class directly using the built-in model table. To customize prices: 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 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.
+The table requires `input` and `output` prices in USD per million tokens and accepts an optional `cache_read` price in the same units. Without it, cache reads cost 0.1x input; cache writes assume 1.25x input. GPT-6.1 Sol and Claude Opus 5.5 use 0.05x cache reads, while Claude Fable/Mythos 5.1 use 0.025x. Both `COST~` and `USD~` honor those rates. `CDX_TOKEN_PRICES` replaces the supplied model row: a two-field override keeps the legacy 0.1x fallback; include `cache_read` to override it (including zero).
 
-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.
+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 uses standard public list prices, excluding Fast/priority, Batch/Flex, regional premiums, and tool fees — not an invoice. And OpenAI's long-context tier, which increases 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.
+
+The built-in price table ships with **cdx-manager**. Run `cdx update` to receive new model prices; updating Codex or Claude alone does not refresh it. Then check `cdx --version` and `cdx stats --json`. Existing runs with a recorded model are recalculated using the new table when stats are read. `CDX_TOKEN_PRICES` overrides still take precedence. Maintainers: follow [the model and pricing update runbook](logics/runbook/run_005_maintaining_the_token_price_table.md) for source checks, tests, release preparation and installed-version verification.
 
 A model absent from the table stays unpriced rather than being charged a default tier, and the totals line names it — which is exactly the key `CDX_TOKEN_PRICES` wants:
 

package/VERSION

@@ -1 +1 @@
-0.20.13
+0.20.14

package/changelogs/CHANGELOGS_0_20_14.md

@@ -0,0 +1,34 @@
+# CDX Manager 0.20.14
+
+## Current model prices in stats
+
+- Add GPT-6.1 Sol, GPT-6 Sol, GPT-6 Luna, Claude Fable 5.1, Claude Mythos 5.1,
+  Claude Opus 5.5 and Claude Sonnet 5.5 to the built-in token price table,
+  reviewed against official provider documentation on 2026-10-04.
+- Honor model-specific cache-read prices in both `USD~` and weighted `COST~`
+  stats: 5% of input for GPT-6.1 Sol and Opus 5.5, and 2.5% for Fable/Mythos 5.1.
+- `CDX_TOKEN_PRICES` accepts an optional `cache_read` price in USD per million
+  tokens, including zero. Existing two-field overrides keep the 10% fallback.
+- Recorded runs using these models are priced when stats are read. Unknown
+  models remain unpriced; account model selections are unchanged.
+
+## Updating the price table
+
+- Run `cdx update` after publication to receive the new table. Updating only
+  Codex or Claude does not update cdx-manager's built-in prices.
+- Document the complete maintainer and installed-machine workflow in the
+  pricing runbook: exact IDs, official sources, helper limitations, regression
+  tests, release preparation and version/stats verification.
+- Costs remain estimates at standard short-context list prices. Fast/priority,
+  Batch/Flex, regional premiums, tool fees, one-hour cache writes and per-request
+  long-context premiums are not modelled.
+
+## Validation
+
+- All 1058 Python tests pass; project lint and Logics lint pass.
+- npm package contents, Python sdist/wheel build and Twine metadata checks pass.
+
+- Regression coverage includes the seven model rates, mixed token classes,
+  cache overrides, backwards compatibility and stats ranking.
+- Local history recognizes all eight recorded models, including 30 Opus 5.5
+  runs that were previously unpriced.

package/checksums/release-archives.json

@@ -452,6 +452,17 @@
         "x86_64-pc-windows-msvc": "0dad961e2f5e79970645db96ed14ef7a7fcb8b7ce0a4441a06310a3ab16b65a4",
         "x86_64-unknown-linux-musl": "b317cf53c0c502321662538aef083690e7673d789d91d55181b1bcffbb6d0a2f"
       }
+    },
+    "v0.20.13": {
+      "github_tarball_sha256": "009d4bfd6ea139fe2968f16c49dd21ca4b5f675637eeea2e2b23b77216adeb3a",
+      "github_zip_sha256": "425d9cd004d6aa282596f754a4afa04615b8954f022d4479e3840ccf5b0a81e6",
+      "tray_assets": {
+        "aarch64-apple-darwin": "313b7e39cd2c18dfd0a0f0cc7ea31ff7a30bea7df0b678dea777802413888650",
+        "aarch64-unknown-linux-musl": "fabfd1e1ab12c6c7c7f014258d70b73f269e046b56f46e55f49f7545c5a6ada6",
+        "x86_64-apple-darwin": "d8cf73b4cd1f89d883dc0e029d38f777d8e99da5c0db1d9853437ecfe05ebd42",
+        "x86_64-pc-windows-msvc": "9c55cab41d489afa77279de219dbc3ad861ad23d3ee50cee55d995033acb0c20",
+        "x86_64-unknown-linux-musl": "04794bc12fd5e367cb44af579aa70464f12680945dc92bbe6b0eda275a88141a"
+      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.20.13",
+  "version": "0.20.14",
   "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.13"
+version = "0.20.14"
 description = "Terminal session manager for Codex and Claude accounts."
 readme = "README.md"
 requires-python = ">=3.9"

package/src/commands/status.py

@@ -316,9 +316,8 @@ def _summarize_stats(entries):
             # model cdx never saw stays unpriced rather than being charged at a
             # default tier, and `priced_runs` says how much of the figure is
             # actually covered.
-            # Weighted per entry, not on the summed row: the output ratio is
-            # the one multiplier that differs between vendors, and a session's
-            # runs can span models.
+            # Weighted per entry, not on the summed row: output and cache-read
+            # ratios vary by model, and a session's runs can span models.
             row["weighted_tokens"] += weighted_usage(
                 entry.get("usage"), entry.get("usage_model")) or 0
             cost = estimate_cost(entry.get("usage"), entry.get("usage_model"))

package/src/run_usage.py

@@ -89,8 +89,8 @@ def normalize_usage(input_tokens=None, cache_creation_tokens=None, cache_read_to
 
 #: What a cached token costs relative to one uncached input token.
 #:
-#: Verified against both vendors on 2026-08-14 and identical on each: a cache
-#: read is a 90% discount on the input rate, and a cache write is 1.25x it.
+#: Defaults for rows without an explicit cache-read price. Newer models can
+#: discount reads further; both stats and currency use the table's rate.
 #: Anthropic's one-hour cache TTL costs 2x instead; nothing in a transcript
 #: says which TTL was used, so long-TTL writes are under-weighted. Cache writes
 #: are a small share of a cache-heavy session, so that error is bounded --
@@ -112,6 +112,14 @@ def output_multiplier(model, prices=None):
     return entry["output"] / entry["input"]
 
 
+def cache_read_multiplier(model, prices=None):
+    """This model's cache-read/input ratio, with the legacy fallback."""
+    entry = (prices if prices is not None else token_prices()[0]).get(model or "")
+    if not entry or "cache_read" not in entry:
+        return CACHE_READ_MULTIPLIER
+    return entry["cache_read"] / entry["input"]
+
+
 def weighted_usage(usage, model=None, prices=None):
     """Consumption in uncached-input-equivalent tokens, or None if unknown.
 
@@ -120,9 +128,8 @@ def weighted_usage(usage, model=None, prices=None):
     tokens -- so a raw total is very nearly a measure of cache reads alone.
     That is not the ranking anyone reading `cdx stats` is looking for.
 
-    The output ratio comes from the model that served the run, because it is
-    the one multiplier that differs between vendors. The cache multipliers do
-    not, so they are constants.
+    Output and cache-read ratios come from the model that served the run.
+    Cache writes retain the five-minute TTL assumption.
 
     `reasoning_tokens` is deliberately excluded: Codex reports it as a subset
     of its output, and counting it would bill those tokens twice.
@@ -132,7 +139,7 @@ def weighted_usage(usage, model=None, prices=None):
     weights = {
         "input_tokens": 1.0,
         "cache_creation_tokens": CACHE_WRITE_MULTIPLIER,
-        "cache_read_tokens": CACHE_READ_MULTIPLIER,
+        "cache_read_tokens": cache_read_multiplier(model, prices),
         "output_tokens": output_multiplier(model, prices),
     }
     present = [
@@ -160,12 +167,16 @@ def weighted_usage(usage, model=None, prices=None):
 #: 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
+#: Not modelled: OpenAI's long-context tier, which increases the rates
 #: above a 272K-token request. cdx records tokens per run, not per request, so
 #: it cannot tell which requests crossed that line -- long-context Codex work
 #: is therefore under-costed here, and knowingly so.
 DEFAULT_TOKEN_PRICES = {
     # Anthropic
+    "claude-fable-5-1": {"input": 10.0, "output": 50.0, "cache_read": 0.25},
+    "claude-mythos-5-1": {"input": 10.0, "output": 50.0, "cache_read": 0.25},
+    "claude-opus-5-5": {"input": 4.0, "output": 20.0, "cache_read": 0.2},
+    "claude-sonnet-5-5": {"input": 2.0, "output": 10.0},
     "claude-fable-5": {"input": 10.0, "output": 50.0},
     "claude-mythos-5": {"input": 10.0, "output": 50.0},
     "claude-opus-5": {"input": 5.0, "output": 25.0},
@@ -180,6 +191,9 @@ DEFAULT_TOKEN_PRICES = {
     "claude-haiku-4-5": {"input": 1.0, "output": 5.0},
     "claude-haiku-4-5-20251001": {"input": 1.0, "output": 5.0},
     # OpenAI
+    "gpt-6.1-sol": {"input": 2.0, "output": 10.0, "cache_read": 0.1},
+    "gpt-6-sol": {"input": 2.0, "output": 10.0},
+    "gpt-6-luna": {"input": 0.1, "output": 0.5},
     "gpt-6-astra": {"input": 10.0, "output": 50.0},
     "gpt-5.6": {"input": 4.0, "output": 20.0},
     "gpt-5.6-sol": {"input": 4.0, "output": 20.0},
@@ -195,7 +209,7 @@ DEFAULT_TOKEN_PRICES = {
     "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-09-05"
+TOKEN_PRICES_REVIEWED = "2026-10-04"
 #: 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"
@@ -218,6 +232,8 @@ def token_prices(env=None):
                 if isinstance(entry, dict) and "input" in entry and "output" in entry:
                     merged[str(name)] = {
                         "input": float(entry["input"]), "output": float(entry["output"])}
+                    if "cache_read" in entry:
+                        merged[str(name)]["cache_read"] = float(entry["cache_read"])
             return merged, TOKEN_PRICES_ENV
     return dict(DEFAULT_TOKEN_PRICES), f"built-in, reviewed {TOKEN_PRICES_REVIEWED}"
 
@@ -244,7 +260,7 @@ def estimate_cost(usage, model, prices=None):
         return None
     per_million = {
         "input_tokens": rate["input"],
-        "cache_read_tokens": rate["input"] * CACHE_READ_MULTIPLIER,
+        "cache_read_tokens": rate.get("cache_read", rate["input"] * CACHE_READ_MULTIPLIER),
         "cache_creation_tokens": rate["input"] * CACHE_WRITE_MULTIPLIER,
         "output_tokens": rate["output"],
     }