cdx-manager 0.20.13 → 0.21.0

package/src/handoff.py

@@ -11,7 +11,6 @@ from uuid import uuid4
 from .context_store import get_context_path, read_context
 from .errors import CdxError
 from .fs_utils import atomic_write
-from .interactive_usage import conversation_transcript
 from .provider_runtime import _get_auth_home, _list_launch_transcript_paths
 
 CANDIDATE_LIMIT = 20
@@ -25,13 +24,19 @@ class HandoffSourceError(CdxError):
 
 def _native_paths(session):
     home = _get_auth_home(session)
+    root = os.path.realpath(home)
+    def owned(path):
+        try:
+            return os.path.commonpath((root, os.path.realpath(path))) == root
+        except ValueError:
+            return False
     if session['provider'] == 'codex':
-        paths = glob.glob(os.path.join(home, 'sessions', '**', '*.jsonl'), recursive=True)
-        return [p for p in paths if 'subagents' not in os.path.relpath(p, home).split(os.sep)]
+        paths = glob.glob(os.path.join(glob.escape(home), 'sessions', '**', '*.jsonl'), recursive=True)
+        return [p for p in paths if owned(p) and 'subagents' not in os.path.relpath(p, home).split(os.sep)]
     if session['provider'] == 'claude':
         return sorted(set(
-            p for root in (('.claude', 'projects'), ('projects',))
-            for p in glob.glob(os.path.join(home, *root, '*', '*.jsonl'))
+            p for layout in (('.claude', 'projects'), ('projects',))
+            for p in glob.glob(os.path.join(glob.escape(home), *layout, '*', '*.jsonl')) if owned(p)
         ))
     return []
 
@@ -119,7 +124,7 @@ def source_candidates(session, workspace):
     return sorted(candidates, key=lambda c: (c['last_event_at'] or '', c['path']), reverse=True)[:CANDIDATE_LIMIT]
 
 
-def resolve_source(session, workspace, conversation_id=None, terminal_path=None):
+def resolve_source(session, workspace, conversation_id=None, terminal_path=None, native_path=None):
     workspace = os.path.realpath(workspace)
     if terminal_path:
         path = os.path.realpath(terminal_path)
@@ -150,26 +155,37 @@ def resolve_source(session, workspace, conversation_id=None, terminal_path=None)
     reason = 'No recorded conversation identity.'
     if session['provider'] not in ('codex', 'claude'):
         raise HandoffSourceError('No supported native transcript for this provider. Select a known launch log with --source-transcript PATH for degraded recovery.')
+    paths = _native_paths(session)
+    if native_path:
+        path = os.path.realpath(native_path)
+        allowed = {os.path.realpath(p) for p in paths}
+        if path not in allowed:
+            raise HandoffSourceError('Native transcript must be a top-level source file in the source profile.')
+        try:
+            info = inspect_transcript(path, session['provider'])
+        except CdxError as error:
+            raise HandoffSourceError(str(error)) from error
+        if info['workspace'] != workspace:
+            raise HandoffSourceError('Native transcript workspace does not match the target workspace.')
+        info['provenance'] = 'explicit_native_path'
+        return info
     if selected:
         if not isinstance(selected, str) or not re.fullmatch(r'[A-Za-z0-9_-]+', selected):
             raise HandoffSourceError('Invalid source conversation ID.')
-        path = conversation_transcript(session['provider'], _get_auth_home(session), selected)
-        # The native resolver may walk nested subagent directories; only top-level
-        # conversations are eligible for handoff, even when explicitly named.
-        paths = _native_paths(session)
-        if not path:
-            matches = [p for p in paths if os.path.basename(p) == selected + '.jsonl']
-            path = matches[0] if len(matches) == 1 else None
         reason = f'Conversation {selected} is missing or is not a top-level source.'
-        if path in paths:
+        matches = []
+        for path in paths:
             try:
                 info = inspect_transcript(path, session['provider'])
-                if info['conversation_id'] != selected or info['workspace'] != workspace:
-                    raise CdxError(f'Conversation identity or workspace mismatch: {selected}')
-                info['provenance'] = 'explicit_identity' if conversation_id else 'recorded_identity'
-                return info
-            except CdxError as error:
-                reason = str(error)
+            except CdxError:
+                continue
+            if info['conversation_id'] == selected and info['workspace'] == workspace:
+                matches.append(info)
+        if len(matches) > 1:
+            raise HandoffSourceError(f'Conversation {selected} has multiple native transcripts; select --source-native-transcript PATH.', matches)
+        if matches:
+            matches[0]['provenance'] = 'explicit_identity' if conversation_id else 'recorded_identity'
+            return matches[0]
     candidates = source_candidates(session, workspace)
     raise HandoffSourceError(
         reason + ' Select the intended ID with --source-conversation ID; no recency fallback is used.',

package/src/provider_background.py

@@ -219,13 +219,14 @@ def read_transcript_outcome(path):
     records the same facts here. Usage is summed across assistant messages
     because a session can hold several turns.
     """
-    outcome = {"result": None, "usage": None}
+    outcome = {"result": None, "usage": None, "usage_model": None}
     if not path:
         return outcome
     totals = {"input_tokens": 0, "cache_creation_tokens": 0, "cache_read_tokens": 0, "output_tokens": 0}
     # This path had no de-duplication at all, so a transcript that records the
     # same billed response more than once inflated the total outright.
     counted = set()
+    models = set()
     seen = False
     try:
         with open(path, encoding="utf-8", errors="replace") as handle:
@@ -261,6 +262,8 @@ def read_transcript_outcome(path):
                     # interactive one filled the same column under opposite
                     # definitions.
                     seen = True
+                    if isinstance(message.get("model"), str) and message["model"]:
+                        models.add(message["model"])
                     totals["input_tokens"] += usage.get("input_tokens") or 0
                     totals["cache_creation_tokens"] += usage.get("cache_creation_input_tokens") or 0
                     totals["cache_read_tokens"] += usage.get("cache_read_input_tokens") or 0
@@ -269,4 +272,6 @@ def read_transcript_outcome(path):
         return outcome
     if seen:
         outcome["usage"] = normalize_usage(**totals)
+        if len(models) == 1:
+            outcome["usage_model"] = next(iter(models))
     return outcome

package/src/provider_runtime.py

@@ -515,7 +515,7 @@ def _list_launch_transcript_paths(session, glob_fn=None):
     log_dir = _get_launch_transcript_dir(session)
     if not os.path.isdir(log_dir):
         return []
-    paths = set(glob_fn(os.path.join(log_dir, "cdx-session*.log")))
+    paths = set(glob_fn(os.path.join(glob.escape(log_dir), "cdx-session*.log")))
     legacy = _get_launch_transcript_path(session)
     if os.path.exists(legacy):
         paths.add(legacy)

package/src/run_registry.py

@@ -28,7 +28,7 @@ REGISTRY_LOCK_TIMEOUT_SECONDS = 120
 _LOCK_RETRY_SECONDS = 0.05
 
 
-def _acquire_windows_lock(handle, timeout_seconds):
+def _acquire_windows_lock(handle, timeout_seconds, label="run registry"):
     """Block until the byte is locked, or give up with a nameable error.
 
     Uses the non-blocking form and does the waiting here, so the wait is
@@ -47,14 +47,14 @@ def _acquire_windows_lock(handle, timeout_seconds):
         except OSError:
             if time.monotonic() >= deadline:
                 raise CdxError(
-                    "Timed out waiting for the run registry lock after "
+                    f"Timed out waiting for the {label} lock after "
                     f"{timeout_seconds}s. Another cdx process may be stuck holding it.",
                     75,
                 ) from None
             time.sleep(_LOCK_RETRY_SECONDS)
 
 
-def _acquire_posix_lock(handle, timeout_seconds):
+def _acquire_posix_lock(handle, timeout_seconds, label="run registry"):
     """Acquire a POSIX advisory lock within the same bounded wait as Windows."""
     import fcntl
 
@@ -66,7 +66,7 @@ def _acquire_posix_lock(handle, timeout_seconds):
         except OSError:
             if time.monotonic() >= deadline:
                 raise CdxError(
-                    "Timed out waiting for the run registry lock after "
+                    f"Timed out waiting for the {label} lock after "
                     f"{timeout_seconds}s. Another cdx process may be stuck holding it.",
                     75,
                 ) from None
@@ -74,12 +74,12 @@ def _acquire_posix_lock(handle, timeout_seconds):
 
 
 @contextmanager
-def _registry_lock(path, timeout_seconds=REGISTRY_LOCK_TIMEOUT_SECONDS):
+def _registry_lock(path, timeout_seconds=REGISTRY_LOCK_TIMEOUT_SECONDS, label="run registry"):
     os.makedirs(os.path.dirname(path), exist_ok=True)
     with open(path + ".lock", "a") as handle:
         if sys.platform == "win32":
             import msvcrt
-            _acquire_windows_lock(handle, timeout_seconds)
+            _acquire_windows_lock(handle, timeout_seconds, label)
             try:
                 yield
             finally:
@@ -87,7 +87,7 @@ def _registry_lock(path, timeout_seconds=REGISTRY_LOCK_TIMEOUT_SECONDS):
                 msvcrt.locking(handle.fileno(), msvcrt.LK_UNLCK, 1)
         else:
             import fcntl
-            _acquire_posix_lock(handle, timeout_seconds)
+            _acquire_posix_lock(handle, timeout_seconds, label)
             try:
                 yield
             finally:

package/src/run_usage.py

@@ -40,6 +40,9 @@ caller can invent a fourth arithmetic.
 """
 
 import json
+import math
+
+from .errors import CdxError
 
 #: Order matters only for readability; every consumer addresses these by name.
 USAGE_KEYS = (
@@ -89,8 +92,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 --
@@ -109,7 +112,19 @@ def output_multiplier(model, prices=None):
     entry = (prices if prices is not None else token_prices()[0]).get(model or "")
     if not entry:
         return DEFAULT_OUTPUT_MULTIPLIER
-    return entry["output"] / entry["input"]
+    return entry["output"] / entry["input"] if entry["input"] else None
+
+
+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:
+        return CACHE_READ_MULTIPLIER
+    if not entry["input"]:
+        return None
+    if "cache_read" not in entry:
+        return CACHE_READ_MULTIPLIER
+    return entry["cache_read"] / entry["input"] if entry["input"] else None
 
 
 def weighted_usage(usage, model=None, prices=None):
@@ -120,9 +135,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,14 +146,16 @@ 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 = [
-        weight * usage[key]
-        for key, weight in weights.items()
-        if usage.get(key) is not None
-    ]
+    present = []
+    for key, weight in weights.items():
+        value = usage.get(key)
+        if value is not None:
+            if weight is None and value:
+                return None
+            present.append((weight or 0) * value)
     if not present:
         return None
     return int(round(sum(present)))
@@ -160,12 +176,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 +200,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 +218,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"
@@ -210,15 +233,26 @@ def token_prices(env=None):
     if raw:
         try:
             overrides = json.loads(raw)
-        except ValueError:
-            return dict(DEFAULT_TOKEN_PRICES), f"built-in, reviewed {TOKEN_PRICES_REVIEWED} ({TOKEN_PRICES_ENV} ignored: not JSON)"
-        if isinstance(overrides, dict):
-            merged = {**DEFAULT_TOKEN_PRICES}
-            for name, entry in overrides.items():
-                if isinstance(entry, dict) and "input" in entry and "output" in entry:
-                    merged[str(name)] = {
-                        "input": float(entry["input"]), "output": float(entry["output"])}
-            return merged, TOKEN_PRICES_ENV
+        except ValueError as error:
+            raise CdxError(f"{TOKEN_PRICES_ENV} must be a JSON object of model rates.") from error
+        if not isinstance(overrides, dict):
+            raise CdxError(f"{TOKEN_PRICES_ENV} must be a JSON object of model rates.")
+        merged = {**DEFAULT_TOKEN_PRICES}
+        for name, entry in overrides.items():
+            if not isinstance(entry, dict) or not {"input", "output"} <= entry.keys():
+                raise CdxError(f"{TOKEN_PRICES_ENV}: {name} requires input and output rates.")
+            rates = {}
+            for key in ("input", "output", "cache_read"):
+                if key not in entry:
+                    continue
+                value = entry[key]
+                if isinstance(value, bool) or not isinstance(value, (int, float)):
+                    value = float("nan")
+                if not math.isfinite(value) or value < 0:
+                    raise CdxError(f"{TOKEN_PRICES_ENV}: {name}.{key} must be a finite nonnegative rate.")
+                rates[key] = value
+            merged[str(name)] = rates
+        return merged, TOKEN_PRICES_ENV
     return dict(DEFAULT_TOKEN_PRICES), f"built-in, reviewed {TOKEN_PRICES_REVIEWED}"
 
 
@@ -229,10 +263,8 @@ def estimate_cost(usage, model, prices=None):
     figure. That shortcut was only correct while every model shared one
     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
-    mid-run is priced at the newer one. Upgrade path if that matters: have the
-    readers return a per-model breakdown and difference each model separately.
+    A run with mixed observed models and no measured per-model breakdown has
+    no usage_model, so its usage remains visible but unpriced.
 
     An unknown or absent model yields None. Pricing it at a default tier would
     turn "cdx does not know" into a number someone might believe.
@@ -244,7 +276,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"],
     }
@@ -341,26 +373,41 @@ def _sum_present(*values):
 
 
 def extract_run_usage(provider, stdout_path):
+    return extract_run_observation(provider, stdout_path)[0]
+
+
+def extract_run_observation(provider, stdout_path):
     if not stdout_path or not provider:
-        return empty_usage()
+        return empty_usage(), None
     if provider not in SUPPORTED_PROVIDERS:
-        return empty_usage()
+        return empty_usage(), None
     try:
         with open(stdout_path, encoding="utf-8", errors="replace") as handle:
             text = handle.read()
     except OSError:
-        return empty_usage()
+        return empty_usage(), None
     if not text.strip():
-        return empty_usage()
+        return empty_usage(), None
 
     records = _parse_json_records(text)
     if not records:
-        return empty_usage()
+        return empty_usage(), None
 
     usage = _extract_usage_from_records(records)
     if not _has_usage(usage):
-        return empty_usage()
-    return usage
+        return empty_usage(), None
+    models = set()
+    for record in records:
+        if not isinstance(record, dict):
+            continue
+        message = record.get("message")
+        model = record.get("model") or (message.get("model") if isinstance(message, dict) else None)
+        if isinstance(model, str) and model and _has_usage(_find_usage(record)):
+            models.add(model)
+        model_usage = record.get("modelUsage")
+        if isinstance(model_usage, dict):
+            models.update(model_usage)
+    return usage, next(iter(models)) if len(models) == 1 else None
 
 
 def _parse_json_records(text):

package/src/session_backup.py

@@ -306,12 +306,20 @@ def import_bundle(base_dir, store, file_path,
         old_record = None
         old_state = None
         preserved_profile_paths = []
+        # Read the live credential before moving its profile: a denied keychain
+        # read must leave the registered session untouched.
+        local_credential = None
         if is_existing and (force or merge):
             old_record = store["get_session"](name)
             old_state = store["read_session_state"](name)
             if merge:
                 provider = old_record["provider"]
                 auth_home = old_record["authHome"]
+            bundle_carries_credential = provider == PROVIDER_CLAUDE and any(
+                item["path"] == CLAUDE_CREDENTIALS_BUNDLE_PATH for item in decoded_profiles.get(name, [])
+            )
+            if bundle_carries_credential:
+                local_credential = read_keychain_credentials(old_record["authHome"])
             recovery_dir = tempfile.mkdtemp(prefix=f".{_encode(name)}.import.", dir=os.path.dirname(session_root))
             backup_root = os.path.join(recovery_dir, "profile")
             try:
@@ -335,13 +343,6 @@ def import_bundle(base_dir, store, file_path,
         # bundle credential exists at the credential-backend level and has to be
         # resolved there. Read it strictly: refusing an unreadable keychain is
         # better than importing over a credential we could not preserve.
-        bundle_carries_credential = provider == PROVIDER_CLAUDE and any(
-            item["path"] == CLAUDE_CREDENTIALS_BUNDLE_PATH for item in decoded_profiles.get(name, [])
-        )
-        local_credential = None
-        if bundle_carries_credential and old_record is not None:
-            local_credential = read_keychain_credentials(auth_home)
-
         existing_state_before = None
         try:
             _ensure_private_dir(session_root)