cdx-manager 0.24.8 → 0.25.0

package/src/commands/runs.py

@@ -23,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 MATCH_CONVERSATION_ID, MEASURED_KEYS, extract_interactive_usage, usage_delta
 from ..provider_background import (
     BACKGROUND_PATH_CDX,
     BACKGROUND_PATH_PROVIDER,
@@ -41,9 +43,11 @@ 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 (
@@ -54,7 +58,7 @@ from ..run_failover import (
     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, estimate_cost, extract_run_conversation_id, extract_run_observation, token_prices
 from ..session_ranking import FACTOR_DESCRIPTIONS, rank_sessions, selection_policy
 from ..status_view import _now_timestamp, _priority_reset_timestamp
 
@@ -200,6 +204,8 @@ 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 (
+        ("--budget", "budget"),
+        ("--continue-run", "continue_run"),
         ("--model", "model"),
         ("--kind", "kind"),
         ("--permission", "permission"),
@@ -537,6 +543,99 @@ 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 _budget_observation(session, paths, baseline):
+    observation = _observe_headless_usage(session, paths, baseline if session["provider"] == "codex" else None)
+    identifier = (extract_run_conversation_id(session["provider"], paths.get("stdout_path"))
+                  or ((session.get("conversation") or {}).get("id")
+                      if session["provider"] == "claude" or session.get("continue_run") else None))
+    if not identifier:
+        return observation
+    usage, path, match, model = extract_interactive_usage(
+        session["provider"], session.get("authHome"), conversation_id=identifier)
+    if usage is None or match != MATCH_CONVERSATION_ID:
+        return observation
+    if baseline is not None:
+        before, before_path, _match, _model = baseline
+        comparable = (before and path == before_path
+                      and all((usage.get(key) is None) == (before.get(key) is None) for key in MEASURED_KEYS))
+        usage = usage_delta(usage, before, provider=session["provider"]) if comparable else None
+    if usage is not None:
+        return {**observation, "usage": usage, "usage_model": model, "provider_transcript_path": path,
+                "provider_transcript_match": match}
+    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
@@ -548,8 +647,12 @@ 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"]:
+        budget_prices = token_prices()[0] if parsed.get("budget") is not None else None
+        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']}")
@@ -604,7 +707,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": {
@@ -646,6 +750,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
@@ -654,7 +762,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("budget") and 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"),
@@ -680,6 +788,7 @@ 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
@@ -688,11 +797,29 @@ def handle_run(rest, ctx):
         failover_error_code = None
         recovery_events = []
         attempt = 0
+        spent_usd = 0.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" or parsed.get("budget")) else None
+            attempt_cost = None
+            budget_observation = None
+
+            def check_budget(paths, session=run_session, before=baseline, already_spent=spent_usd):
+                nonlocal attempt_cost, budget_observation
+                observation = _budget_observation(session, paths, before)
+                cost = estimate_cost(observation["usage"], observation["usage_model"], budget_prices)
+                if cost is not None:
+                    if attempt_cost is None or cost >= attempt_cost:
+                        attempt_cost = cost
+                        budget_observation = observation
+                return attempt_cost is not None and already_spent + attempt_cost >= parsed["budget"]
+
             run_info = _run_headless_provider_command(
                 run_session,
                 cwd=cwd,
@@ -701,14 +828,23 @@ def handle_run(rest, ctx):
                 timeout_seconds=parsed.get("timeout_seconds"),
                 spawn=ctx.get("spawn_headless") or ctx.get("spawn"),
                 run_id=run_id,
+                **({"budget_check": check_budget} if parsed.get("budget") is not None else {}),
             )
-            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 if run_session["provider"] == "codex" else None)
+            if run_info.get("budget_exceeded") and budget_observation is not None:
+                observation = budget_observation
+            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}
+            cost = estimate_cost(observation["usage"], observation["usage_model"], budget_prices)
+            spent_usd += max(attempt_cost or 0.0, cost or 0.0)
+            if parsed.get("budget") is not None and (run_info.get("budget_exceeded") or spent_usd >= parsed["budget"]):
+                run_info.update(budget_exceeded=True, returncode=125, cost_usd=spent_usd)
             ctx["service"]["record_launch_history"](run_session["name"], {
                 "status": "success" if run_info.get("returncode") == 0 else "failed",
                 "action": "run",
@@ -718,6 +854,8 @@ def handle_run(rest, ctx):
                 "exit_code": run_info.get("returncode"),
                 **run_info,
             })
+            if run_info.get("budget_exceeded") or 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]}
@@ -841,7 +979,10 @@ def handle_run(rest, ctx):
             )
             _write_json(ctx, final_payload)
             return 0
-        if failover_error_code == "capacity_recovery_exhausted":
+        if run_info.get("budget_exceeded"):
+            failover_error_code = "budget_exceeded"
+            message = "Run exceeded its estimated USD budget."
+        elif 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)}."
@@ -859,7 +1000,7 @@ def handle_run(rest, ctx):
             run_session,
             run_info=run_info,
             error=error,
-            error_source="provider",
+            error_source="cdx" if run_info.get("budget_exceeded") else "provider",
             # Running out of accounts is a different outcome from the task
             # failing, and a caller has to be able to branch on which happened.
             error_code=failover_error_code or (
@@ -869,7 +1010,7 @@ def handle_run(rest, ctx):
         )
         registry.finish(
             run_id,
-            status="timed_out" if run_info.get("timed_out") else "failed",
+            status="timed_out" if run_info.get("timed_out") and not run_info.get("budget_exceeded") else "failed",
             final_payload=final_payload,
             run_info=run_info,
             error=final_payload.get("error"),
@@ -883,11 +1024,12 @@ def handle_run(rest, ctx):
         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):
-            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, 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",

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,10 @@ 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"),
+                "cost_usd": estimate_cost(entry.get("usage"), entry.get("usage_model")) if is_vouched(entry.get("usage")) else None,
+                "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

@@ -8,6 +8,7 @@ import signal
 import subprocess
 import sys
 import threading
+import time
 import uuid
 from datetime import datetime, timezone
 
@@ -1006,7 +1007,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 +1046,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]
@@ -1202,7 +1205,7 @@ def _read_permission_denials(stdout_path):
 
 
 def _run_headless_provider_command(session, cwd=None, env_override=None, initial_prompt=None,
-                                   timeout_seconds=None, spawn=None, run_id=None):
+                                   timeout_seconds=None, spawn=None, run_id=None, budget_check=None):
     spawn = spawn or subprocess.Popen
     spec = _build_headless_launch_spec(
         session,
@@ -1260,6 +1263,7 @@ def _run_headless_provider_command(session, cwd=None, env_override=None, initial
     child = None
     timed_out = False
     cancelled = False
+    budget_exceeded = False
     with open(paths["stdout_path"], "w", encoding="utf-8", errors="replace") as stdout_file, \
             open(paths["stderr_path"], "w", encoding="utf-8", errors="replace") as stderr_file:
         options = {k: v for k, v in spec.get("options", {}).items() if k not in ("stdio", "stdout", "stderr")}
@@ -1288,7 +1292,23 @@ def _run_headless_provider_command(session, cwd=None, env_override=None, initial
         # this supervisor and keep its run "running" forever.
         previous_handlers = _route_termination_to_interrupt()
         try:
-            if timeout_seconds is None:
+            if budget_check is not None:
+                deadline = time.monotonic() + timeout_seconds if timeout_seconds is not None else None
+                while True:
+                    if budget_check(paths):
+                        budget_exceeded = True
+                        _terminate_child_tree(child)
+                        break
+                    remaining = deadline - time.monotonic() if deadline is not None else None
+                    if remaining is not None and remaining <= 0:
+                        raise subprocess.TimeoutExpired(command, timeout_seconds)
+                    try:
+                        child.wait(timeout=min(0.25, remaining) if remaining is not None else 0.25)
+                        budget_exceeded = budget_check(paths)
+                        break
+                    except subprocess.TimeoutExpired:
+                        continue
+            elif timeout_seconds is None:
                 child.wait()
             else:
                 child.wait(timeout=timeout_seconds)
@@ -1335,6 +1355,7 @@ def _run_headless_provider_command(session, cwd=None, env_override=None, initial
         "pid": getattr(child, "pid", None),
         "returncode": returncode,
         "timed_out": timed_out,
+        "budget_exceeded": budget_exceeded,
         "permission_denials": (
             _read_permission_denials(paths["stdout_path"])
             if session.get("provider") == PROVIDER_CLAUDE else []