cdx-manager 0.20.12 → 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.12-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.
 
@@ -164,7 +164,7 @@ or turn historical tool output into new authorization.
 - **Disk usage and cleanup.** `cdx disk` reports `CDX_HOME` usage, `cdx disk profiles --candidates` identifies reclaimable profile caches/logs with evidence, and `cdx clean profiles ...` applies explicit cleanup actions.
 - **Health and repair.** `cdx doctor` inspects dependencies, permissions, and orphan profiles; `cdx repair` plans or applies safe fixes.
 - **Portable bundles.** `cdx export` / `cdx import` move sessions between machines, with passphrase-encrypted auth data when you ask for it.
-- **Update prompts.** Periodic update checks surface `cdx update` directly in the `cdx`, `cdx status`, and launch output when a newer release is available. When `logics-manager` is installed, `cdx` can also suggest `logics-manager self-update`.
+- **Update prompts.** Periodic update checks surface `cdx update` directly in the `cdx`, `cdx status`, and launch output when a newer release is available. When `logics-manager` is installed, `cdx` can also suggest `logics-manager update`.
 - **Logics viewer shortcut.** `cdx view` opens the Logics browser/focus viewer through `logics-manager view` when the companion CLI is installed. All viewer flags are forwarded: `--lan`, `--lan-rw`, `--focus <ref>`, `--read`, `--port`, `--host`, `--refresh-interval`, `--tls`, `--tls-cert`, `--tls-key`, `--open`, `--no-open`. `cdx view --json` reports availability and update diagnostics without opening the viewer.
 
 ---
@@ -504,7 +504,7 @@ cdx power all default
 cdx model provider:ollama default
 ```
 
-`--model` maps to Codex `--model`, Claude `--model`, and Ollama `ollama run <model>`. `--power` maps to Codex `model_reasoning_effort` and Claude `--effort`; supported values are `minimal`, `low`, `medium`, `high`, and `xhigh`. `--permission` maps to provider-native permission flags. Codex Fast mode is separate from reasoning effort: `--fast on` opts a Codex session into the Codex Fast service tier, while new sessions, `--fast off`, and default launches force the non-Fast `flex` tier. Use `--power low` when you want low reasoning effort without enabling Codex Fast credits. Existing legacy sessions that stored `fast=on` before this split continue to behave as low effort unless the user explicitly sets `--fast on` again. `--priority` is a 0..100 selector preference used as a tie-breaker after readiness and availability. `--rtk on` injects a launch instruction that encourages assistants to use RTK (`rtk <command>`) for noisy terminal commands when RTK is available, while keeping raw commands for exact output. Logics guidance is auto-enabled when `logics-manager` is available; use `--logics off` to disable that guidance for a session, or `--logics on` to pin it explicitly.
+`--model` maps to Codex `--model`, Claude `--model`, and Ollama `ollama run <model>`. `--power` maps to Codex `model_reasoning_effort` and Claude `--effort`; supported values are `minimal`, `low`, `medium`, `high`, and `xhigh`. `--permission` maps to provider-native permission flags. Codex Fast mode is separate from reasoning effort: `--fast on` opts a Codex session into the Codex Fast service tier, while new sessions, `--fast off`, and default launches force the non-Fast `flex` tier. Use `--power low` when you want low reasoning effort without enabling Codex Fast credits. Existing legacy sessions that stored `fast=on` before this split continue to behave as low effort unless the user explicitly sets `--fast on` again. `--priority` is a 0..100 selector preference used as a tie-breaker after readiness and availability. `--rtk on` adds standing guidance that encourages assistants to use RTK (`rtk <command>`) for noisy terminal commands when RTK is available, while keeping raw commands for exact output. Logics guidance is auto-enabled when `logics-manager` is available; use `--logics off` to disable that guidance for a session, or `--logics on` to pin it explicitly. This guidance is passed as instructions, never as a first message: Claude receives it through `--append-system-prompt` and Codex through `-c developer_instructions=...`, appended after any `developer_instructions` already set in the profile's `config.toml` (on Python older than 3.11 without `tomli`, a profile that sets its own is left untouched and gets no cdx guidance). Launching or resuming a session therefore never submits a turn on your behalf. Antigravity and Ollama have no instruction channel and receive no guidance. If you also pass `--append-system-prompt` through `--extra-args`, Claude receives the option twice; prefer putting your own text in the profile's `CLAUDE.md`.
 
 ### Terminal Titles
 
@@ -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.12
+0.20.14

package/changelogs/CHANGELOGS_0_20_13.md

@@ -0,0 +1,32 @@
+# CDX Manager 0.20.13
+
+## Launches no longer open with a message you never typed
+
+- RTK and Logics guidance used to be passed as the provider's positional prompt,
+  which Claude Code and Codex submit as a user turn: a bare `cdx <session>`
+  opened with that guidance shown as your message plus a model reply to it, and
+  every resume sent it again as a new message.
+- Claude now receives the guidance through `--append-system-prompt`, and Codex
+  through `-c developer_instructions=...`. Launch, resume, and headless runs are
+  all covered, and no turn is ever submitted on your behalf.
+- Codex guidance is appended after any `developer_instructions` already set in
+  the profile's `config.toml` rather than replacing it. When that value cannot be
+  read (Python older than 3.11 without `tomli`), cdx leaves it untouched and adds
+  no guidance.
+- Antigravity has no instruction channel and, like Ollama, no longer receives
+  the guidance.
+- `cdx doctor --check-provider-flags` now verifies the options used to pass it.
+
+## Logics update hint
+
+- The update notice now suggests `logics-manager update` instead of the legacy
+  `logics-manager self-update` alias.
+
+## Validation
+
+- 1055 Python tests and project lint pass.
+- Verified against real CLIs on macOS, Linux (WSL), and Windows: Claude Code
+  (2.1.177, 2.1.283) and Codex CLI (0.156.1, 0.157.1) receive the guidance, and
+  interactive launches and resumes no longer add a user turn to the provider
+  transcript, where 0.20.12 added one. Codex guidance also survives a resumed
+  thread and merges with a profile's own `developer_instructions`.

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

@@ -441,6 +441,28 @@
         "x86_64-pc-windows-msvc": "183d28516f764e9a9d494feeab4406de9ad8159330082e12bf88f360f65158ac",
         "x86_64-unknown-linux-musl": "25274c81ccb3048e4e7c96e7e6fd236bb03486dcf5b429be5c31e8dd6d841c5e"
       }
+    },
+    "v0.20.12": {
+      "github_tarball_sha256": "463efdea19f037c6e4f04d30d3cc34649ef84e18019f23ecf1752a131437ecba",
+      "github_zip_sha256": "43ddd669cac5ab0fc7aef146d18e84670710128bba56ec39911d179f6b98abdf",
+      "tray_assets": {
+        "aarch64-apple-darwin": "14bef88f478dda41ba8af4fbe54859ff5a9c420ab58cad0168b563d00cfa1385",
+        "aarch64-unknown-linux-musl": "0d78ef10ec531a02a43c5bd059b49142721059daf2803e3d36829886b478ab0c",
+        "x86_64-apple-darwin": "0ae9b837573e35144a7a9f871f030c5445044ba66e09f1d1958d635c2efb6d8f",
+        "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.12",
+  "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.12"
+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/health.py

@@ -14,6 +14,7 @@ from .provider_runtime import (
     HEADLESS_CODEX_PERMISSION_ARGS,
     LAUNCH_FEATURE_ARGS,
     LAUNCH_PERMISSION_ARGS,
+    PREFERENCE_INSTRUCTION_ARGS,
     codex_auth_diagnostic,
 )
 from .status_source import _extract_account_identity
@@ -195,6 +196,8 @@ def _mapped_provider_flags(provider):
     for flag in LAUNCH_FEATURE_ARGS.get(provider, []):
         if flag.startswith("-"):
             mappings.setdefault("cdx feature flags", set()).add(flag)
+    for flag in PREFERENCE_INSTRUCTION_ARGS.get(provider, []):
+        mappings.setdefault("cdx feature flags", set()).add(flag)
     for permission, args in interactive.items():
         mappings.setdefault(permission, set()).update(
             arg for arg in args if arg.startswith("-")

package/src/provider_runtime.py

@@ -71,6 +71,15 @@ LAUNCH_FEATURE_ARGS = {
     PROVIDER_OLLAMA: [OLLAMA_USAGE_FLAG],
 }
 
+#: How each provider receives cdx's standing guidance (RTK, logics-manager) as
+#: instructions rather than as a first user message. A provider absent here
+#: gets no guidance. Declared as a table so the provider-flag health check can
+#: verify these options exist in the installed CLI.
+PREFERENCE_INSTRUCTION_ARGS = {
+    PROVIDER_CLAUDE: ["--append-system-prompt"],
+    PROVIDER_CODEX: ["-c"],
+}
+
 LAUNCH_PERMISSION_ARGS = {
     PROVIDER_CLAUDE: {
         "review": ["--permission-mode", "plan"],
@@ -575,19 +584,71 @@ def _logics_enabled(session, env=None):
     return _logics_manager_available(path=env.get("PATH"))
 
 
-def _with_launch_preferences(session, initial_prompt=None, env=None):
-    if session["provider"] == PROVIDER_OLLAMA:
-        return initial_prompt
+def _launch_preferences(session, env=None):
+    """The standing guidance cdx adds to a session, or None.
+
+    It goes to the provider as instructions, never as the conversation's
+    first message: a positional prompt is submitted as a user turn, so a bare
+    `cdx <session>` used to open with guidance the user never typed and a
+    model reply to it. Ollama has no instruction channel and gets none;
+    Antigravity has none either (`--prompt-interactive` is a user turn).
+    """
+    if session["provider"] not in PREFERENCE_INSTRUCTION_ARGS:
+        return None
     prompts = []
     if _rtk_enabled(session):
         prompts.append(RTK_PROMPT)
     if _logics_enabled(session, env=env):
         prompts.append(LOGICS_PROMPT)
-    if not prompts:
-        return initial_prompt
-    if initial_prompt:
-        prompts.append(initial_prompt)
-    return "\n\n".join(prompts)
+    return "\n\n".join(prompts) or None
+
+
+def _codex_configured_developer_instructions(auth_home):
+    """(readable, value) for `developer_instructions` in the profile's config.
+
+    A `-c developer_instructions=...` override replaces the configured value
+    outright, so cdx has to know it to append rather than erase it. `readable`
+    is False only when the key is present but cannot be parsed (no TOML reader
+    on Python < 3.11 without tomli): the caller then leaves it alone.
+    """
+    try:
+        with open(os.path.join(auth_home, "config.toml"), encoding="utf-8") as handle:
+            text = handle.read()
+    except OSError:
+        return True, None
+    if "developer_instructions" not in text:
+        return True, None
+    try:
+        import tomllib
+    except ImportError:
+        try:
+            import tomli as tomllib
+        except ImportError:
+            return False, None
+    try:
+        value = tomllib.loads(text).get("developer_instructions")
+    except ValueError:
+        # Codex refuses an unparsable config itself; there is nothing to keep.
+        return True, None
+    return True, value if isinstance(value, str) and value.strip() else None
+
+
+def _launch_preference_args(session, env=None):
+    preferences = _launch_preferences(session, env=env)
+    _validate_initial_prompt(preferences, label="launch guidance")
+    if not preferences:
+        return []
+    if session["provider"] == PROVIDER_CLAUDE:
+        return ["--append-system-prompt", preferences]
+    readable, configured = _codex_configured_developer_instructions(_get_auth_home(session))
+    if not readable:
+        # Better to go without cdx's guidance than to erase the user's own.
+        return []
+    if configured:
+        preferences = f"{configured.rstrip()}\n\n{preferences}"
+    # json.dumps yields a valid TOML basic string, which is how codex parses
+    # a `-c` value.
+    return ["-c", f"developer_instructions={json.dumps(preferences)}"]
 
 
 def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None, capture_transcript=True):
@@ -598,8 +659,7 @@ def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None
     for key, value in _shared_tool_cache_overrides(env).items():
         env.setdefault(key, value)
     env.update(launch_notify_env(session, notifications_enabled(session)))
-    initial_prompt = _with_launch_preferences(session, initial_prompt, env=env)
-    _validate_initial_prompt(initial_prompt)
+    preference_args = _launch_preference_args(session, env=env)
     if session["provider"] == PROVIDER_CLAUDE:
         launch = session.get("launch") or {}
         args = ["--name", session["name"]]
@@ -609,6 +669,7 @@ def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None
         if launch.get("model"):
             args += ["--model", _claude_cli_model(launch["model"])]
         args += _launch_config_args(session)
+        args += preference_args
         args += _extra_args(session)
         if initial_prompt:
             args.append(initial_prompt)
@@ -665,6 +726,7 @@ def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None
     if launch.get("model"):
         args += ["--model", launch["model"]]
     args += _launch_config_args(session)
+    args += preference_args
     if initial_prompt:
         args.append(initial_prompt)
     return _wrap_launch_with_transcript(session, {
@@ -772,8 +834,7 @@ def _build_resume_spec(session, cwd=None, env_override=None, capture_transcript=
     if not capability["resumable"]:
         raise CdxError(f"Provider {session.get('provider')} does not support native resume through cdx.")
 
-    resume_prompt = _with_launch_preferences(session, env=env)
-    _validate_initial_prompt(resume_prompt)
+    preference_args = _launch_preference_args(session, env=env)
 
     if session["provider"] == PROVIDER_CLAUDE:
         launch = session.get("launch") or {}
@@ -792,9 +853,8 @@ def _build_resume_spec(session, cwd=None, env_override=None, capture_transcript=
         if launch.get("model"):
             args += ["--model", _claude_cli_model(launch["model"])]
         args += _launch_config_args(session)
+        args += preference_args
         args += _extra_args(session)
-        if resume_prompt:
-            args.append(resume_prompt)
         auth_home = _get_auth_home(session)
         claude_env = _claude_env(env, auth_home, own_terminal_title=True)
         oauth_token = _read_claude_launch_oauth_token(auth_home)
@@ -822,9 +882,8 @@ def _build_resume_spec(session, cwd=None, env_override=None, capture_transcript=
     if launch.get("model"):
         args += ["--model", launch["model"]]
     args += _launch_config_args(session)
+    args += preference_args
     args += _extra_args(session)
-    if resume_prompt:
-        args.append(resume_prompt)
     return _wrap_launch_with_transcript(session, {
         "command": "codex",
         "args": args,
@@ -835,12 +894,12 @@ def _build_resume_spec(session, cwd=None, env_override=None, capture_transcript=
     }, capture_transcript=capture_transcript, env=env)
 
 
-def _validate_initial_prompt(initial_prompt):
+def _validate_initial_prompt(initial_prompt, label="initial_prompt"):
     if initial_prompt is not None:
         if not isinstance(initial_prompt, str):
-            raise CdxError("initial_prompt must be a string.")
+            raise CdxError(f"{label} must be a string.")
         if len(initial_prompt) > 32768:
-            raise CdxError("initial_prompt exceeds maximum allowed length.")
+            raise CdxError(f"{label} exceeds maximum allowed length.")
 
 
 def _build_headless_launch_spec(session, cwd=None, env_override=None, initial_prompt=None):
@@ -850,8 +909,7 @@ def _build_headless_launch_spec(session, cwd=None, env_override=None, initial_pr
     # Headless runs read the same home, and so the same hooks, as an interactive
     # launch. Their caller already learns of completion from the return value.
     env.update(launch_notify_env(session, enabled=False))
-    initial_prompt = _with_launch_preferences(session, initial_prompt, env=env)
-    _validate_initial_prompt(initial_prompt)
+    preference_args = _launch_preference_args(session, env=env)
     launch = session.get("launch") or {}
     power = _launch_power(session)
     permission = launch.get("permission")
@@ -872,6 +930,7 @@ def _build_headless_launch_spec(session, cwd=None, env_override=None, initial_pr
         if launch.get("fallback_model"):
             args += ["--fallback-model", _claude_fallback_model(launch["fallback_model"])]
         args += _launch_config_args(session)
+        args += preference_args
         args += _extra_args(session)
         if initial_prompt:
             args.append(initial_prompt)
@@ -897,6 +956,7 @@ def _build_headless_launch_spec(session, cwd=None, env_override=None, initial_pr
         args += _codex_fast_config_args(launch)
         if permission:
             args += HEADLESS_CODEX_PERMISSION_ARGS.get(permission, [])
+        args += preference_args
         if initial_prompt:
             args.append(initial_prompt)
         return {

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"],
     }

package/src/update_check.py

@@ -229,7 +229,7 @@ def check_logics_manager_for_update(base_dir, env=None, now_fn=None, runner=None
                 "tool": "logics-manager",
                 "latest_version": latest_version,
                 "current_version": current_version,
-                "update_command": "logics-manager self-update",
+                "update_command": "logics-manager update",
                 "url": cached.get("url"),
                 "cached": True,
             }
@@ -255,7 +255,7 @@ def check_logics_manager_for_update(base_dir, env=None, now_fn=None, runner=None
             "tool": "logics-manager",
             "latest_version": latest_version,
             "current_version": current_version,
-            "update_command": "logics-manager self-update",
+            "update_command": "logics-manager update",
             "url": payload["url"],
             "cached": False,
         }