cdx-manager 0.24.7 → 0.24.9

package/src/commands/runs.py

@@ -5,8 +5,10 @@ Split out of cli_commands.py. Moved verbatim; re-exported by cli_commands.
 
 import importlib.util
 import os
+import shutil
 import subprocess
 import sys
+import time
 
 from ..cli_args import (
     RUN_REPORT_USAGE,
@@ -21,7 +23,9 @@ from ..cli_args import (
     cdx_schema,
 )
 from ..cli_helpers import API_SCHEMA_VERSION, _json_failure, _json_success, _write_json
+from ..config import split_extra_args
 from ..errors import CdxError
+from ..interactive_usage import MEASURED_KEYS, extract_interactive_usage, usage_delta
 from ..provider_background import (
     BACKGROUND_PATH_CDX,
     BACKGROUND_PATH_PROVIDER,
@@ -39,12 +43,22 @@ from ..provider_runtime import (
     _build_launch_spec,
     _ensure_session_authentication,
     _headless_artifact_paths,
+    _launch_power,
+    _restore_signal_handlers,
+    _route_termination_to_interrupt,
     _run_headless_provider_command,
+    with_requested_conversation,
 )
 from ..run_command import read_run_prompt, run_cdx_error_code, run_launch_payload, run_result_payload
-from ..run_failover import MAX_FAILOVER_TRANSITIONS, failover_reason
+from ..run_failover import (
+    CAPACITY_RETRY_DELAYS,
+    MAX_FAILOVER_TRANSITIONS,
+    capacity_models,
+    failover_reason,
+    looks_model_at_capacity,
+)
 from ..run_registry import RunRegistry, build_code_review_report, final_message
-from ..run_usage import extract_run_observation
+from ..run_usage import empty_usage, extract_run_conversation_id, extract_run_observation
 from ..session_ranking import FACTOR_DESCRIPTIONS, rank_sessions, selection_policy
 from ..status_view import _now_timestamp, _priority_reset_timestamp
 
@@ -190,6 +204,7 @@ def _detached_child_argv(parsed, prompt_path, session_name, cwd):
     # from the package root, so a relative "--cwd ." would resolve there.
     argv = ["run", session_name, "--cwd", cwd, "--prompt-file", prompt_path]
     for flag, key in (
+        ("--continue-run", "continue_run"),
         ("--model", "model"),
         ("--kind", "kind"),
         ("--permission", "permission"),
@@ -527,6 +542,77 @@ def _env_max_runs(ctx):
     return limit if limit > 0 else None
 
 
+def _observe_headless_usage(session, run_info, baseline=None):
+    usage, model = extract_run_observation(session.get("provider"), run_info.get("stdout_path"), session.get("authHome"))
+    observation = {"usage": usage, "usage_model": model}
+    if baseline is not None:
+        cumulative, path, match, transcript_model = extract_interactive_usage(
+            session["provider"], session.get("authHome"), conversation_id=(session.get("conversation") or {}).get("id"))
+        before, before_path, _before_match, _before_model = baseline
+        comparable = (cumulative and before and path == before_path
+                      and all((cumulative.get(key) is None) == (before.get(key) is None) for key in MEASURED_KEYS))
+        # A newly reported split includes unknown pre-launch usage; losing a
+        # split also prevents a comparable measurement across the boundary.
+        delta = usage_delta(cumulative, before, provider=session.get("provider")) if comparable else None
+        # Exec resume can emit conversation totals. Only exact launch boundaries
+        # establish this run's share; stdout cannot replace a missing boundary.
+        observation.update(usage=delta if delta is not None else empty_usage(), usage_cumulative=cumulative,
+                           usage_attribution="launch_boundary" if delta is not None else "continuation_usage_unavailable",
+                           provider_transcript_path=path, provider_transcript_match=match,
+                           usage_model=model or transcript_model)
+    return observation
+
+
+def _continue_run_session(parsed, ctx):
+    """Resolve only the parent's profile and exact persisted conversation."""
+    previous = _run_registry(ctx).get(parsed["continue_run"])
+    if not previous:
+        raise CdxError(f"Cannot continue unknown run: {parsed['continue_run']}. Start a normal run instead.",
+                       code="continue_run_not_found")
+    name, provider = previous.get("session"), previous.get("provider")
+    if (parsed.get("name") and parsed["name"] != name) or (parsed.get("provider") and parsed["provider"] != provider):
+        raise CdxError("Cannot continue a run from another profile or provider. Start a normal run instead.",
+                       code="continue_run_mismatch")
+    session = ctx["service"]["get_session"](name) if name else None
+    if not session or session.get("provider") != provider:
+        raise CdxError("The previous run's profile or provider is no longer available. Start a normal run instead.",
+                       code="continue_run_mismatch")
+    if provider not in ("claude", "codex") or previous.get("status") not in ("succeeded", "failed", "timed_out", "cancelled"):
+        raise CdxError("Only a finished Claude or Codex run can be continued. Start a normal run instead.",
+                       code="continue_run_unavailable")
+    conversation = previous.get("conversation_id")
+    resumed = with_requested_conversation(session, conversation)
+    if not resumed:
+        raise CdxError("The previous run's provider session expired or its transcript is missing. Start a normal run instead.",
+                       code="continue_run_unavailable")
+    model = previous.get("usage_model") or previous.get("model")
+    effort = previous.get("reasoning_effort")
+    if not isinstance(model, str) or not model or model.startswith("<") or not effort or not previous.get("launch"):
+        raise CdxError("The previous run's model and effort cannot be pinned. Start a normal run instead.",
+                       code="continue_run_unavailable")
+    if ((parsed.get("model") and parsed["model"] != model)
+            or (parsed.get("reasoning_effort") and parsed["reasoning_effort"] != effort)):
+        raise CdxError("--continue-run requires the previous run's model and reasoning effort.",
+                       code="continue_run_settings_mismatch")
+    if parsed.get("failover") or parsed.get("isolate_workspace"):
+        raise CdxError("--continue-run cannot be combined with --failover or --isolate-workspace.",
+                       code="continue_run_settings_mismatch")
+    if provider == "claude":
+        # Passthrough options are appended last and can override the pinned settings.
+        pinned_options = {"--model", "--effort", "--fallback-model", "--resume", "--continue",
+                          "--session-id", "--fork-session", "--resume-session-at", "--from-pr",
+                          "--settings", "--agent", "--agents"}
+        for arg in split_extra_args((session.get("launch") or {}).get("extra_args")) or []:
+            if arg.split("=", 1)[0] in pinned_options or arg.startswith(("-r", "-c")):
+                raise CdxError("--continue-run cannot use Claude extra_args that override model, effort, or conversation.",
+                               code="continue_run_settings_mismatch")
+    parsed.update(name=name, model=model, reasoning_effort=effort, power=effort)
+    launch = {**(session.get("launch") or {}), "model": model, "reasoning_effort": effort, "power": effort}
+    # A provider fallback would break the model pin even though cdx stayed on this profile.
+    launch.pop("fallback_model", None)
+    return {**resumed, "launch": launch, "continue_run": parsed["continue_run"]}
+
+
 def handle_run(rest, ctx):
     registry = None
     run_id = None
@@ -538,8 +624,11 @@ def handle_run(rest, ctx):
     detached_run_id = os.environ.pop(DETACHED_RUN_ID_ENV, None) or None
     try:
         parsed = _parse_run_args(rest)
-        session = None
-        if parsed["name"]:
+        session = _continue_run_session(parsed, ctx) if parsed.get("continue_run") else None
+        if session:
+            if session.get("enabled", True) is False:
+                raise CdxError(f"Session is disabled: {session['name']}", code="session_disabled")
+        elif parsed["name"]:
             session = ctx["service"]["get_session"](parsed["name"])
             if not session:
                 raise CdxError(f"Unknown session: {parsed['name']}")
@@ -594,7 +683,8 @@ def handle_run(rest, ctx):
         # records its own afterwards, from the rollout. Without this a headless
         # Claude run left the session with no identity and `cdx resume` fell
         # back to recency for Claude while working by id for Codex.
-        session = ctx["service"]["begin_conversation"](session["name"])
+        if not parsed.get("continue_run"):
+            session = ctx["service"]["begin_conversation"](session["name"])
         run_session = {
             **session,
             "launch": {
@@ -636,6 +726,10 @@ def handle_run(rest, ctx):
             },
             label=parsed.get("label"),
             max_parallel=max_parallel,
+            parent_run_id=parsed.get("continue_run"),
+            conversation_id=(run_session.get("conversation") or {}).get("id") if run_session["provider"] == "claude" or parsed.get("continue_run") else None,
+            launch=run_session.get("launch"),
+            reasoning_effort=_launch_power(run_session),
         )
         if parsed.get("detach"):
             # Delegate where the installed CLI can both start a background
@@ -644,7 +738,7 @@ def handle_run(rest, ctx):
             launch = None
             # A provider's own background agent has no cdx process watching it,
             # so nothing could fail it over; --failover keeps the in-house child.
-            if not parsed.get("isolate_workspace") and not parsed.get("network_access") and not parsed.get("failover") and supports_native_background(
+            if not parsed.get("continue_run") and not parsed.get("isolate_workspace") and not parsed.get("network_access") and not parsed.get("failover") and supports_native_background(
                 run_session.get("provider"),
                 env=ctx.get("env"),
                 spawn_sync=ctx.get("spawn_text"),
@@ -670,13 +764,24 @@ def handle_run(rest, ctx):
                 cwd=cwd,
                 pid=launch.get("pid"),
                 launch_log_path=launch.get("launch_log_path"),
+                conversation_id=launch.get("provider_session_id"),
                 selection_row=selection_row,
             ))
             return 0
 
         attempted = [run_session["name"]]
         failover_error_code = None
+        recovery_events = []
+        attempt = 0
+        models = capacity_models(run_session)
+        model_index = 0
+        capacity_retries = 0
         while True:
+            attempt += 1
+            baseline = extract_interactive_usage(
+                run_session["provider"], run_session.get("authHome"),
+                conversation_id=(run_session.get("conversation") or {}).get("id"),
+            ) if parsed.get("continue_run") and run_session["provider"] == "codex" else None
             run_info = _run_headless_provider_command(
                 run_session,
                 cwd=cwd,
@@ -686,20 +791,78 @@ def handle_run(rest, ctx):
                 spawn=ctx.get("spawn_headless") or ctx.get("spawn"),
                 run_id=run_id,
             )
-            usage, usage_model = extract_run_observation(
-                run_session.get("provider"), run_info.get("stdout_path"),
-                run_session.get("authHome"),
-            )
-            run_info = {**run_info, "usage": usage, "usage_model": usage_model}
+            observation = _observe_headless_usage(run_session, run_info, baseline)
+            run_info = {**run_info, **observation,
+                        "parent_run_id": parsed.get("continue_run"),
+                        "conversation_id": extract_run_conversation_id(run_session.get("provider"), run_info.get("stdout_path"))
+                        or ((run_session.get("conversation") or {}).get("id") if run_session["provider"] == "claude" or parsed.get("continue_run") else None),
+                        "launch": run_session.get("launch"),
+                        "reasoning_effort": _launch_power(run_session),
+                        "effective_model": (run_session.get("launch") or {}).get("model"),
+                        "recovery_events": recovery_events}
             ctx["service"]["record_launch_history"](run_session["name"], {
                 "status": "success" if run_info.get("returncode") == 0 else "failed",
                 "action": "run",
                 "run_id": run_id,
-                "attempt": len(attempted),
+                "attempt": attempt,
                 "cwd": cwd,
                 "exit_code": run_info.get("returncode"),
                 **run_info,
             })
+            if parsed.get("continue_run"):
+                break
+            if looks_model_at_capacity(run_session.get("provider"), run_info):
+                event = {"reason": "model_at_capacity", "attempt": attempt,
+                         "session": run_session["name"], "model": models[model_index]}
+                if capacity_retries < len(CAPACITY_RETRY_DELAYS):
+                    delay = CAPACITY_RETRY_DELAYS[capacity_retries]
+                    capacity_retries += 1
+                    event.update(action="retry", retry=capacity_retries, delay_seconds=delay)
+                elif model_index + 1 < len(models):
+                    model_index += 1
+                    capacity_retries = 0
+                    run_session["launch"]["model"] = models[model_index]
+                    event.update(action="fallback_model", target_model=models[model_index])
+                else:
+                    successor = None if len(attempted) > MAX_FAILOVER_TRANSITIONS else _select_headless_session(
+                        ctx, "codex", min_reasoning_effort=parsed["reasoning_effort"],
+                        require_ready=True, exclude=attempted,
+                    )
+                    if not successor:
+                        failover_error_code = "capacity_recovery_exhausted"
+                        event.update(action="exhausted")
+                    else:
+                        selection_row = successor.get("row") or {}
+                        next_session = successor["session"]
+                        run_session = {**next_session, "launch": {**(next_session.get("launch") or {}), **launch_updates}}
+                        # Each new profile starts with the requested model, or its own default.
+                        models = capacity_models(run_session)
+                        model_index = capacity_retries = 0
+                        attempted.append(run_session["name"])
+                        event.update(action="fallback_profile", target_session=run_session["name"], target_model=models[0])
+                _record_capacity_recovery(ctx, registry, run_id, event, run_info, recovery_events)
+                if failover_error_code:
+                    break
+                if event["action"] == "retry":
+                    previous_handlers = _route_termination_to_interrupt()
+                    try:
+                        time.sleep(event["delay_seconds"])
+                    except KeyboardInterrupt as interrupt:
+                        error = CdxError("Codex capacity recovery was cancelled.", 130)
+                        error.cancelled = True
+                        error.history_recorded = True
+                        error.run_info = {**run_info, "returncode": 130}
+                        raise error from interrupt
+                    finally:
+                        _restore_signal_handlers(previous_handlers)
+                elif event["action"] == "fallback_profile":
+                    _ensure_session_authentication(
+                        run_session, ctx["service"], spawn=ctx.get("spawn"), spawn_sync=ctx.get("spawn_sync"),
+                        env_override=ctx.get("env"), stdin_is_tty=False, behavior="launch",
+                        signal_emitter=ctx.get("signal_emitter"), trust_local_credentials=False,
+                    )
+                    registry.migrate(run_id, session=run_session["name"], provider="codex", reason="model_at_capacity")
+                continue
             if run_info.get("returncode") == 0 or not parsed.get("failover"):
                 break
             reason = failover_reason(
@@ -731,6 +894,8 @@ def handle_run(rest, ctx):
                 "launch": {**(successor["session"].get("launch") or {}), **launch_updates},
             }
             attempted.append(run_session["name"])
+            models = capacity_models(run_session)
+            model_index = capacity_retries = 0
             # A different account means different credentials; an unauthenticated
             # successor would fail for a reason unrelated to the task.
             _ensure_session_authentication(
@@ -769,7 +934,9 @@ def handle_run(rest, ctx):
             )
             _write_json(ctx, final_payload)
             return 0
-        if failover_error_code == "failover_exhausted":
+        if failover_error_code == "capacity_recovery_exhausted":
+            message = "Codex model capacity recovery exhausted its retry, model, or profile budget."
+        elif failover_error_code == "failover_exhausted":
             message = f"Every eligible session was rate limited: {', '.join(attempted)}."
         elif failover_error_code == "failover_limit_reached":
             message = f"Failover stopped after {MAX_FAILOVER_TRANSITIONS} transitions: {', '.join(attempted)}."
@@ -806,17 +973,20 @@ def handle_run(rest, ctx):
     except CdxError as error:
         run_info = getattr(error, "run_info", None)
         cancelled = bool(getattr(error, "cancelled", False))
-        if run_info and run_id:
-            usage, usage_model = extract_run_observation(
-                run_session.get("provider"), run_info.get("stdout_path"),
-                run_session.get("authHome"),
-            )
-            run_info = {**run_info, "usage": usage, "usage_model": usage_model}
+        if run_info is not None:
+            run_info = {**run_info, "recovery_events": locals().get("recovery_events", [])}
+        if run_info and run_id and not getattr(error, "history_recorded", False):
+            observation = _observe_headless_usage(run_session, run_info, locals().get("baseline"))
+            run_info = {**run_info, **observation,
+                        "parent_run_id": parsed.get("continue_run"),
+                        "conversation_id": extract_run_conversation_id(run_session.get("provider"), run_info.get("stdout_path"))
+                        or ((run_session.get("conversation") or {}).get("id") if run_session["provider"] == "claude" or parsed.get("continue_run") else None),
+                        "launch": run_session.get("launch"), "reasoning_effort": _launch_power(run_session)}
             ctx["service"]["record_launch_history"](run_session["name"], {
                 "status": "failed",
                 "action": "run",
                 "run_id": run_id,
-                "attempt": len(attempted) if "attempted" in locals() else 1,
+                "attempt": locals().get("attempt", 1),
                 "cwd": cwd,
                 "exit_code": error.exit_code,
                 **run_info,
@@ -825,13 +995,14 @@ def handle_run(rest, ctx):
             API_SCHEMA_VERSION,
             False,
             locals().get("parsed", {}) or {},
-            locals().get("session"),
+            locals().get("run_session", locals().get("session")),
             run_info=run_info,
             error=error,
             error_source="provider" if cancelled else "cdx",
             error_code="run_cancelled" if cancelled else run_cdx_error_code(error),
             selection_row=selection_row,
         )
+        final_payload["recovery_events"] = locals().get("recovery_events", [])
         if registry and run_id:
             registry.finish(
                 run_id,
@@ -845,6 +1016,22 @@ def handle_run(rest, ctx):
         _write_json(ctx, final_payload)
         return error.exit_code
 
+def _record_capacity_recovery(ctx, registry, run_id, event, run_info, events):
+    # Subsequent attempts reuse the run's paths; retain the failed output first.
+    artifacts = {}
+    for key in ("stdout_path", "stderr_path", "transcript_path"):
+        path = run_info.get(key)
+        if path and os.path.isfile(path):
+            archived = f"{path}.attempt-{event['attempt']}"
+            shutil.copyfile(path, archived)
+            artifacts[key] = archived
+    event["artifacts"] = artifacts
+    events.append(event)
+    registry.record_recovery(run_id, event)
+    details = ", ".join(f"{key}={value}" for key, value in event.items() if key != "artifacts")
+    ctx["err"](f"cdx capacity recovery: {details}\n")
+
+
 def _select_headless_session(
     ctx, provider, min_reasoning_effort=None, require_ready=False, force_refresh=False, exclude=None,
 ):

package/src/commands/status.py

@@ -53,10 +53,13 @@ from ..provider_runtime import (
 )
 from ..rtk_savings import rtk_saved
 from ..run_usage import (
-    USAGE_KEYS,
+    TOKEN_USAGE_KEYS,
+    cache_hit_ratio,
     estimate_cost,
+    format_cache_ratio,
     is_vouched,
     normalize_usage,
+    summarize_cache_usage,
     token_prices,
     weighted_usage,
 )
@@ -294,7 +297,9 @@ def _summarize_stats(entries):
             "reasoning_tokens": 0,
             "total_tokens": 0,
             "last_started_at": None,
+            "_entries": [],
         })
+        row["_entries"].append(entry)
         row["launches"] += 1
         if entry.get("provider"):
             row["provider"].add(entry["provider"])
@@ -315,7 +320,7 @@ def _summarize_stats(entries):
             usage = {}
         parsed_usage = {
             key: _token_value(usage, key)
-            for key in USAGE_KEYS
+            for key in TOKEN_USAGE_KEYS
         }
         if any(value is not None for value in parsed_usage.values()):
             row["usage_runs"] += 1
@@ -361,6 +366,16 @@ def _summarize_stats(entries):
         # overwhelming majority of cached tokens are, and weighting the whole
         # of it at the creation rate would overstate legacy sessions by more
         # than reading it as reads understates them.
+        group_entries = row.pop("_entries")
+        row["cache_usage"] = summarize_cache_usage(group_entries)
+        row["cache_hit_ratio"] = row["cache_usage"]["cache_hit_ratio"]
+        row["run_types"] = {
+            kind: {"runs": len(subset), **summarize_cache_usage(subset)}
+            for kind, subset in (
+                ("continued", [e for e in group_entries if e.get("parent_run_id")]),
+                ("cold", [e for e in group_entries if not e.get("parent_run_id")]),
+            )
+        }
         split = row["cache_creation_tokens"] + row["cache_read_tokens"]
         legacy_cache = max(0, row["cached_input_tokens"] - split)
         derived = normalize_usage(
@@ -381,15 +396,34 @@ def _summarize_stats(entries):
         reverse=True,
     )
 
+def _merge_cache_usage(summaries):
+    totals = {}
+    for key in ("input_tokens", "cache_creation_tokens", "cache_read_tokens", "output_tokens",
+                "measured_runs", "measured_input_tokens", "measured_cache_read_tokens"):
+        values = [s[key] for s in summaries if s[key] is not None]
+        totals[key] = sum(values) if values else (0 if key.startswith("measured_") else None)
+    inputs = totals["measured_input_tokens"]
+    totals["cache_hit_ratio"] = totals["measured_cache_read_tokens"] / inputs if inputs else None
+    return totals
+
+
 def _stats_totals(rows):
+    cache = _merge_cache_usage([row["cache_usage"] for row in rows])
     return {
+        "cache_usage": cache,
+        "cache_hit_ratio": cache["cache_hit_ratio"],
+        "run_types": {
+            kind: {"runs": sum(row["run_types"][kind]["runs"] for row in rows),
+                   **_merge_cache_usage([row["run_types"][kind] for row in rows])}
+            for kind in ("cold", "continued")
+        },
         "sessions": len(rows),
         "launches": sum(row["launches"] for row in rows),
         "successes": sum(row["successes"] for row in rows),
         "failures": sum(row["failures"] for row in rows),
         "duration_ms": sum(row["duration_ms"] for row in rows),
         "usage_runs": sum(row["usage_runs"] for row in rows),
-        **{key: sum(row[key] for row in rows) for key in USAGE_KEYS},
+        **{key: sum(row[key] for row in rows) for key in TOKEN_USAGE_KEYS},
         "weighted_tokens": sum(row["weighted_tokens"] for row in rows),
         "weighted_runs": sum(row["weighted_runs"] for row in rows),
         "unweighted_runs": sum(row["unweighted_runs"] for row in rows),
@@ -448,7 +482,7 @@ def _format_history(entries, use_color=False, active_sessions=None):
     active_sessions = active_sessions or set()
     if not entries:
         return "No launch history."
-    rows = [[_style(value, "1", use_color) for value in ["SESSION", "PROV.", "RESULT", "DURATION", "WHEN", "TRANSCRIPT"]]]
+    rows = [[_style(value, "1", use_color) for value in ["SESSION", "PROV.", "RESULT", "DURATION", "WHEN", "TOKENS", "TRANSCRIPT"]]]
     for entry in entries:
         transcript_path = entry.get("transcript_path")
         session_name = entry.get("session_name") or "-"
@@ -461,6 +495,8 @@ def _format_history(entries, use_color=False, active_sessions=None):
             _style(status, status_color, use_color),
             _style(_format_duration_ms(entry.get("duration_ms")), "33" if entry.get("duration_ms") else "2", use_color),
             _dim(_format_relative_age(entry.get("started_at")), use_color),
+            _dim(f"{_format_token_count((entry.get('usage') or {}).get('total_tokens'))} "
+                 f"{format_cache_ratio((entry.get('usage') or {}).get('cache_hit_ratio'))}", use_color),
             _dim(os.path.basename(transcript_path) if transcript_path else "-", use_color),
         ])
     return "\n".join([
@@ -529,10 +565,12 @@ def _format_stats(rows, totals, period=None, use_color=False, active_sessions=No
             _style(str(row["launches"]), "1", use_color),
             _style(str(row["usage_runs"]), "32" if row["usage_runs"] else "2", use_color),
             _style(_format_token_count(row["input_tokens"]), "96" if row["input_tokens"] else "2", use_color),
-            _style(_format_token_count(row["cached_input_tokens"]), "96" if row["cached_input_tokens"] else "2", use_color),
+            _style(_format_token_count(row["cached_input_tokens"]) if row["cache_usage"]["cache_read_tokens"] is not None
+                   or row["cache_usage"]["cache_creation_tokens"] is not None else "n/d",
+                   "96" if row["cached_input_tokens"] else "2", use_color),
             _style(_format_token_count(row["output_tokens"]), "96" if row["output_tokens"] else "2", use_color),
             _style(_format_token_count(row["reasoning_tokens"]), "95" if row["reasoning_tokens"] else "2", use_color),
-            _style(_format_token_count(row["total_tokens"]), "96" if row["total_tokens"] else "2", use_color),
+            _style(f"{_format_token_count(row['total_tokens'])} {format_cache_ratio(row.get('cache_hit_ratio'))}", "96" if row["total_tokens"] else "2", use_color),
             _style(_format_token_count(row["weighted_tokens"]) if row["weighted_runs"] else "-",
                    "1;95" if row["weighted_runs"] else "2", use_color),
             _style(_format_usd(row["cost_usd"]) if row["priced_runs"] else "-",
@@ -550,7 +588,7 @@ def _format_stats(rows, totals, period=None, use_color=False, active_sessions=No
         _dim(
             "Totals: "
             f"{totals['launches']} runs, {totals['usage_runs']} with usage, "
-            f"{_format_token_count(totals['total_tokens'])} tokens "
+            f"{_format_token_count(totals['total_tokens'])} tokens {format_cache_ratio(totals.get('cache_hit_ratio'))} "
             f"({_format_token_count(totals['weighted_tokens']) if totals['weighted_runs'] else '-'} cost-equivalent"
             + (f" on {totals['weighted_runs']}/{totals['usage_runs']} measured runs"
                if totals["usage_runs"] else "")
@@ -633,6 +671,9 @@ def handle_history(rest, ctx):
     limit = 0 if parsed["summary"] or has_period else parsed["limit"]
     entries = ctx["service"]["get_launch_history"](parsed["name"], limit=limit)
     entries = _filter_history_period(entries, parsed["period"])
+    entries = [{**entry, "parent_run_id": entry.get("parent_run_id"),
+                "usage": {**entry["usage"], "cache_hit_ratio": cache_hit_ratio(entry["usage"], provider=entry.get("provider")) if is_vouched(entry["usage"]) else None}
+                if isinstance(entry.get("usage"), dict) else entry.get("usage")} for entry in entries]
     if has_period and not parsed["summary"]:
         entries = entries[:parsed["limit"]]
     message = (

package/src/interactive_usage.py

@@ -261,9 +261,13 @@ def _codex_usage(handle):
             # larger than the input count is not a subset, so that record is
             # left alone rather than forced to zero.
             reported_input = _number(usage.get("input_tokens"))
-            cache_read = _number(usage.get("cached_input_tokens"))
+            cache_read = _number(usage["cached_input_tokens"]) if usage.get("cached_input_tokens") is not None else None
+            cache_write = _number(usage["cache_write_input_tokens"]) if usage.get("cache_write_input_tokens") is not None else None
+            cached = (cache_read or 0) + (cache_write or 0)
             latest = normalize_usage(
-                input_tokens=reported_input - cache_read if cache_read <= reported_input else reported_input,
+                provider="codex",
+                input_tokens=reported_input - cached if cached <= reported_input else reported_input,
+                cache_creation_tokens=cache_write,
                 cache_read_tokens=cache_read,
                 output_tokens=_number(usage.get("output_tokens")),
                 reasoning_tokens=_number(usage.get("reasoning_output_tokens")) or None,
@@ -286,6 +290,7 @@ def _claude_usage(handle):
     inside `output_tokens` -- so that field stays absent by design.
     """
     totals = {"input_tokens": 0, "cache_creation_tokens": 0, "cache_read_tokens": 0, "output_tokens": 0}
+    missing = set(totals)
     long_ttl = None
     seen = set()
     model = None
@@ -301,6 +306,11 @@ def _claude_usage(handle):
                 if identifier in seen:
                     continue
                 seen.add(identifier)
+            for source, target in (("input_tokens", "input_tokens"), ("output_tokens", "output_tokens"),
+                                   ("cache_creation_input_tokens", "cache_creation_tokens"),
+                                   ("cache_read_input_tokens", "cache_read_tokens")):
+                if usage.get(source) is not None:
+                    missing.discard(target)
             totals["input_tokens"] += _number(usage.get("input_tokens"))
             totals["cache_creation_tokens"] += _number(usage.get("cache_creation_input_tokens"))
             totals["cache_read_tokens"] += _number(usage.get("cache_read_input_tokens"))
@@ -316,7 +326,8 @@ def _claude_usage(handle):
             continue
     if not seen and not any(totals.values()):
         return None, model
-    return normalize_usage(**totals, cache_creation_1h_tokens=long_ttl), model
+    return normalize_usage(**{k: None if k in missing else v for k, v in totals.items()},
+                           cache_creation_1h_tokens=long_ttl), model
 
 
 def _number(value):
@@ -326,7 +337,7 @@ def _number(value):
         return 0
 
 
-#: The quantities a provider actually reports. The other two fields of a usage
+#: The quantities a provider actually reports. The other fields of a usage
 #: record are derived by `normalize_usage` and must never be differenced.
 MEASURED_KEYS = (
     "input_tokens",
@@ -338,7 +349,7 @@ MEASURED_KEYS = (
 )
 
 
-def usage_delta(cumulative, previous):
+def usage_delta(cumulative, previous, provider=None):
     """What this run added to a transcript that already held `previous`.
 
     Both readers return a *cumulative* figure: Claude's is the sum over the
@@ -372,7 +383,7 @@ def usage_delta(cumulative, previous):
         if difference < 0:
             return None
         parts[key] = difference
-    return normalize_usage(**parts)
+    return normalize_usage(**parts, provider=provider)
 
 
 def transcript_predates_run(path, started_at):

package/src/provider_background.py

@@ -224,6 +224,7 @@ def read_transcript_outcome(path):
     if not path:
         return outcome
     totals = {"input_tokens": 0, "cache_creation_tokens": 0, "cache_read_tokens": 0, "output_tokens": 0}
+    missing = set(totals)
     long_ttl = None
     # This path had no de-duplication at all, so a transcript that records the
     # same billed response more than once inflated the total outright.
@@ -266,6 +267,11 @@ def read_transcript_outcome(path):
                     seen = True
                     if isinstance(message.get("model"), str) and message["model"]:
                         models.add(message["model"])
+                    for source, target in (("input_tokens", "input_tokens"), ("output_tokens", "output_tokens"),
+                                           ("cache_creation_input_tokens", "cache_creation_tokens"),
+                                           ("cache_read_input_tokens", "cache_read_tokens")):
+                        if usage.get(source) is not None:
+                            missing.discard(target)
                     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
@@ -276,7 +282,8 @@ def read_transcript_outcome(path):
     except OSError:
         return outcome
     if seen:
-        outcome["usage"] = normalize_usage(**totals, cache_creation_1h_tokens=long_ttl)
+        outcome["usage"] = normalize_usage(**{k: None if k in missing else v for k, v in totals.items()},
+                                           cache_creation_1h_tokens=long_ttl)
         if len(models) == 1:
             outcome["usage_model"] = next(iter(models))
     return outcome

package/src/provider_runtime.py

@@ -1006,7 +1006,7 @@ def _build_headless_launch_spec(session, cwd=None, env_override=None, initial_pr
         args = ["--print", "--output-format", "json"]
         conversation_id = _conversation_id(session)
         if conversation_id:
-            args += ["--session-id", conversation_id]
+            args += ["--resume" if session.get("continue_run") else "--session-id", conversation_id]
         if model:
             args += ["--model", _claude_cli_model(model)]
         # --max-budget-usd and --fallback-model are --print-only in the claude
@@ -1045,6 +1045,8 @@ def _build_headless_launch_spec(session, cwd=None, env_override=None, initial_pr
         if permission:
             args += HEADLESS_CODEX_PERMISSION_ARGS.get(permission, [])
         args += preference_args
+        if session.get("continue_run"):
+            args += ["resume", _conversation_id(session)]
         if initial_prompt:
             # `--` keeps a prompt that starts with `-` from being read as an option.
             args += ["--", initial_prompt]