cdx-manager 0.21.6 → 0.23.0

package/src/commands/rescue.py

@@ -0,0 +1,207 @@
+"""cdx rescue: move a conversation stopped by a usage limit to an account that can go on.
+
+Everything it does already exists -- `status` knows which accounts are spent,
+the shared ranking knows which one is best, `handoff` carries a conversation
+over. This command only puts them in one step, and asks before it does.
+"""
+
+import json
+import os
+from datetime import datetime, timedelta, timezone
+
+from ..cli_helpers import _json_failure, _json_success, _write_json
+from ..cli_render import _info, _warn
+from ..errors import CdxError
+from ..session_ranking import rank_sessions
+from ..status_view import _now_timestamp, _priority_reset_timestamp
+from .launch import handle_handoff
+
+RESCUE_USAGE = "Usage: cdx rescue [<session>] [--to <target>] [--yes] [--dry-run] [--json]"
+#: A conversation stopped longer ago than this is history, not something to rescue.
+RECENT = timedelta(hours=24)
+
+
+def _parse(rest):
+    parsed = {"source": None, "target": None, "yes": False, "dry_run": False, "json": False}
+    index = 0
+    while index < len(rest):
+        arg = rest[index]
+        if arg == "--to" and index + 1 < len(rest):
+            parsed["target"] = rest[index + 1]
+            index += 1
+        elif arg in ("--yes", "-y"):
+            parsed["yes"] = True
+        elif arg == "--dry-run":
+            parsed["dry_run"] = True
+        elif arg == "--json":
+            parsed["json"] = True
+        elif not arg.startswith("-") and parsed["source"] is None:
+            parsed["source"] = arg
+        else:
+            raise CdxError(RESCUE_USAGE)
+        index += 1
+    return parsed
+
+
+def _recent(iso, now):
+    try:
+        when = datetime.fromisoformat(str(iso))
+    except (TypeError, ValueError):
+        return False
+    if when.tzinfo is None:
+        when = when.replace(tzinfo=timezone.utc)
+    return now - when <= RECENT
+
+
+#: How much of a transcript's end is read to find how it stopped.
+TAIL_BYTES = 256 * 1024
+
+
+def ended_on_limit(transcript):
+    """Whether the conversation's last word is a usage-limit error.
+
+    Claude writes an API error record (`isApiErrorMessage`, `error: rate_limit`);
+    Codex an `error` event with `codex_error_info: usage_limit_exceeded`. A normal
+    reply after it means the conversation went on, so only the last of the two
+    counts. This catches a stop before `cdx status` shows the account at 0%.
+    """
+    try:
+        with open(transcript, "rb") as handle:
+            handle.seek(max(0, os.path.getsize(transcript) - TAIL_BYTES))
+            lines = handle.read().decode("utf-8", errors="replace").splitlines()
+    except (OSError, TypeError):
+        return False
+    stopped = False
+    for line in lines:
+        try:
+            record = json.loads(line)
+        except ValueError:
+            continue
+        if not isinstance(record, dict):
+            continue
+        payload = record.get("payload") if isinstance(record.get("payload"), dict) else {}
+        if record.get("isApiErrorMessage") and record.get("error") == "rate_limit":
+            stopped = True
+        elif payload.get("type") == "error" and payload.get("codex_error_info") == "usage_limit_exceeded":
+            stopped = True
+        elif record.get("type") == "assistant" and not record.get("isApiErrorMessage"):
+            stopped = False
+        elif payload.get("type") == "message" and payload.get("role") == "assistant":
+            stopped = False
+    return stopped
+
+
+def stranded(service, rows, now=None):
+    """Sessions on a spent account whose last conversation can be handed off, newest first."""
+    now = now or datetime.now(timezone.utc)
+    found = []
+    for session in service["list_sessions"]():
+        row = rows.get(session["name"]) or {}
+        conversation = (session.get("conversation") or {}).get("id")
+        if not conversation or not _recent(row.get("last_launched_at"), now):
+            continue
+        if _rescued_since_launch(session, row):
+            continue
+        history = service["get_launch_history"](session["name"], limit=1)
+        last = history[0] if history else {}
+        cwd = last.get("cwd") or None
+        if not cwd or not os.path.isdir(cwd):
+            continue
+        spent = row.get("available_pct") == 0
+        if not spent and not ended_on_limit(last.get("provider_transcript_path")):
+            continue
+        found.append({
+            "session": session["name"], "provider": session["provider"], "conversation_id": conversation,
+            "cwd": cwd, "reset_at": row.get("reset_at"), "last_launched_at": row.get("last_launched_at"),
+        })
+    return sorted(found, key=lambda item: item["last_launched_at"] or "", reverse=True)
+
+
+def _rescued_since_launch(session, row):
+    """Already handed off, and not launched again since: rescuing it twice forks it."""
+    try:
+        rescued = datetime.fromisoformat(str((session.get("conversation") or {}).get("rescuedAt")))
+        launched = datetime.fromisoformat(str(row.get("last_launched_at")))
+        return rescued >= launched
+    except (TypeError, ValueError):
+        return False
+
+
+def pick_target(rows, source, provider):
+    """(target row, needs confirmation) for the best ready account, or (None, False).
+
+    `use` accounts first; an `ask-first` one only when no `use` account is
+    ready, and always behind a confirmation. `never` is not considered.
+    """
+    others = [row for row in rows.values() if row.get("session_name") != source]
+    ordered, _ = rank_sessions(others, _now_timestamp(), _priority_reset_timestamp,
+                               provider=provider, require_ready=True)
+    if ordered:
+        return ordered[0], False
+    asked = [{**row, "policy": "use"} for row in others if row.get("policy") == "ask-first"]
+    ordered, _ = rank_sessions(asked, _now_timestamp(), _priority_reset_timestamp,
+                               provider=provider, require_ready=True)
+    return (ordered[0], True) if ordered else (None, False)
+
+
+def handle_rescue(rest, ctx):
+    parsed = _parse(rest)
+    service = ctx["service"]
+    rows = {row["session_name"]: row for row in service["get_status_rows"](force_refresh=False)}
+    candidates = stranded(service, rows)
+    if parsed["source"]:
+        candidates = [c for c in candidates if c["session"] == parsed["source"]]
+    if not candidates:
+        message = "No conversation stopped by a usage limit in the last 24 hours."
+        if parsed["json"]:
+            _write_json(ctx, _json_success("rescue", message, plan=None, stranded=[]))
+        else:
+            ctx["out"](f"{message}\n")
+        return 0
+    source = candidates[0]
+    if parsed["target"]:
+        target = rows.get(parsed["target"])
+        if not target or target.get("policy") == "never":
+            raise CdxError(f"Cannot rescue onto {parsed['target']}: unknown account or policy never.")
+        confirm = target.get("policy") == "ask-first"
+    else:
+        target, confirm = pick_target(rows, source["session"], source["provider"])
+    if not target:
+        message = f"No ready {source['provider']} account to take over {source['session']}."
+        if parsed["json"]:
+            _write_json(ctx, _json_failure("rescue", "no_ready_account", message, stranded=candidates))
+            return 1
+        raise CdxError(message)
+    plan = {**source, "target": target["session_name"], "target_policy": target.get("policy", "use")}
+    if parsed["json"] or parsed["dry_run"]:
+        if parsed["json"]:
+            _write_json(ctx, _json_success("rescue", "Rescue plan", plan=plan, stranded=candidates))
+        else:
+            ctx["out"](_describe(plan, ctx) + "\n")
+        return 0
+    ctx["out"](_describe(plan, ctx) + "\n")
+    if confirm or not parsed["yes"]:
+        if not ctx["stdin_is_tty"]:
+            raise CdxError("cdx rescue needs a terminal to confirm; pass --yes (not enough for an ask-first account).")
+        ask = ctx.get("options", {}).get("input") or input
+        question = f"Hand {source['session']} over to {target['session_name']}"
+        question += " (policy ask-first)" if confirm else ""
+        if ask(f"{question}? [y/N] ").strip().lower() not in ("y", "yes"):
+            raise CdxError("Rescue cancelled.", exit_code=130)
+    code = handle_handoff(
+        [source["session"], target["session_name"], "--source-conversation", source["conversation_id"]],
+        {**ctx, "cwd": source["cwd"]},
+    )
+    if code == 0:
+        service["mark_conversation_rescued"](source["session"], source["conversation_id"])
+    return code
+
+
+def _describe(plan, ctx):
+    reset = f", back {plan['reset_at']}" if plan.get("reset_at") else ""
+    lines = [
+        _warn(f"{plan['session']} is out of usage{reset}", ctx["use_color"]),
+        f"  conversation {plan['conversation_id']} in {plan['cwd']}",
+        _info(f"-> {plan['target']}" + (" (ask-first)" if plan["target_policy"] == "ask-first" else ""), ctx["use_color"]),
+    ]
+    return "\n".join(lines)

package/src/commands/runs.py

@@ -43,7 +43,7 @@ from ..provider_runtime import (
 )
 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_registry import RunRegistry, build_code_review_report
+from ..run_registry import RunRegistry, build_code_review_report, final_message
 from ..run_usage import extract_run_observation
 from ..session_ranking import FACTOR_DESCRIPTIONS, rank_sessions, selection_policy
 from ..status_view import _now_timestamp, _priority_reset_timestamp
@@ -193,6 +193,7 @@ def _detached_child_argv(parsed, prompt_path, session_name, cwd):
         ("--model", "model"),
         ("--kind", "kind"),
         ("--permission", "permission"),
+        ("--label", "label"),
     ):
         value = parsed.get(key)
         if value:
@@ -414,7 +415,7 @@ def handle_runs(rest, ctx):
         raise CdxError(RUNS_USAGE)
     since = parsed.get("since")
     _reconcile_background_runs(ctx)
-    runs = _run_registry(ctx).list(limit=parsed["limit"], since=since)
+    runs = _run_registry(ctx).list(limit=parsed["limit"], since=since, running=parsed.get("running", False))
     warnings = []
     if since is not None and parsed.get("limit_given"):
         warnings.append({
@@ -502,6 +503,7 @@ def handle_run_report(rest, ctx):
     _write_json(ctx, _json_success("run-report", "Run report loaded.", report={
         "run": run,
         "final_payload": run.get("final_payload"),
+        "final_message": final_message(run),
         "task_report": run.get("task_report"),
         "artifacts": run.get("artifacts") or {},
         "usage": run.get("usage"),
@@ -509,6 +511,17 @@ def handle_run_report(rest, ctx):
     }))
     return 0
 
+def _env_max_runs(ctx):
+    """CDX_MAX_RUNS as the default --max-parallel; unset, invalid or <= 0 means no limit."""
+    value = {**os.environ, **(ctx.get("env") or {})}.get("CDX_MAX_RUNS")
+    try:
+        limit = int(value) if value else 0
+    except ValueError:
+        return None
+    # 0 or negative reads as "no limit", like unset, rather than a cap of 1.
+    return limit if limit > 0 else None
+
+
 def handle_run(rest, ctx):
     registry = None
     run_id = None
@@ -563,6 +576,15 @@ def handle_run(rest, ctx):
         if parsed.get("reasoning_effort"):
             launch_updates["reasoning_effort"] = parsed["reasoning_effort"]
             launch_updates["power"] = parsed["reasoning_effort"]
+        # A detached child runs in the slot its parent already took.
+        max_parallel = None if detached_run_id else (parsed.get("max_parallel") or _env_max_runs(ctx))
+        if max_parallel:
+            # Before anything changes the session: a refused run must not leave
+            # Claude on a fresh conversation id that resume and rescue then
+            # point at. Finished native background runs are closed out first,
+            # since nothing else frees their slot.
+            _reconcile_background_runs(ctx)
+            _run_registry(ctx).check_capacity(max_parallel)
         # Claude needs its conversation id before the spec is built; Codex
         # records its own afterwards, from the rollout. Without this a headless
         # Claude run left the session with no identity and `cdx resume` fell
@@ -607,6 +629,8 @@ def handle_run(rest, ctx):
                 "stdout_path": artifacts.get("stdout_path"),
                 "stderr_path": artifacts.get("stderr_path"),
             },
+            label=parsed.get("label"),
+            max_parallel=max_parallel,
         )
         if parsed.get("detach"):
             # Delegate where the installed CLI can both start a background

package/src/commands/status.py

@@ -4,6 +4,7 @@ Split out of cli_commands.py. Moved verbatim; re-exported by cli_commands.
 """
 
 import os
+import re
 import threading
 import time
 from datetime import datetime
@@ -11,6 +12,7 @@ from datetime import datetime
 from ..claude_refresh import _refresh_claude_sessions
 from ..cli_args import (
     LAST_USAGE,
+    SESSIONS_USAGE,
     STATUS_USAGE,
     _filter_history_period,
     _has_history_period,
@@ -49,6 +51,7 @@ from ..provider_runtime import (
     _has_local_claude_auth,
     _probe_provider_auth_status,
 )
+from ..rtk_savings import rtk_saved
 from ..run_usage import (
     USAGE_KEYS,
     estimate_cost,
@@ -57,6 +60,7 @@ from ..run_usage import (
     token_prices,
     weighted_usage,
 )
+from ..session_status import session_paths
 from ..status_view import _format_status_detail, _format_status_rows, format_priority_instruction, recommend_priority_rows
 
 
@@ -268,7 +272,7 @@ def _summarize_stats(entries):
         name = entry.get("session_name") or "-"
         row = rows.setdefault(name, {
             "session_name": name,
-            "provider": entry.get("provider") or "-",
+            "provider": set(),
             "launches": 0,
             "successes": 0,
             "failures": 0,
@@ -284,6 +288,7 @@ def _summarize_stats(entries):
             "input_tokens": 0,
             "cached_input_tokens": 0,
             "cache_creation_tokens": 0,
+            "cache_creation_1h_tokens": 0,
             "cache_read_tokens": 0,
             "output_tokens": 0,
             "reasoning_tokens": 0,
@@ -291,6 +296,8 @@ def _summarize_stats(entries):
             "last_started_at": None,
         })
         row["launches"] += 1
+        if entry.get("provider"):
+            row["provider"].add(entry["provider"])
         if entry.get("status") == "success":
             row["successes"] += 1
         elif entry.get("status") == "failed":
@@ -338,8 +345,10 @@ def _summarize_stats(entries):
         started = entry.get("started_at")
         if started and (not row["last_started_at"] or started > row["last_started_at"]):
             row["last_started_at"] = started
-            row["provider"] = entry.get("provider") or row["provider"]
     for row in rows.values():
+        # Every provider seen, not the last one: a project or model row often
+        # spans several.
+        row["provider"] = "+".join(sorted(row["provider"])) or "-"
         # Derive from the summed parts rather than summing each run's stored
         # total. Records written before the definition was settled carry a
         # total that excluded cache, and adding those to correct ones produced
@@ -472,14 +481,43 @@ def _format_token_count(value):
         return f"{amount / 1000:.1f}K"
     return str(amount)
 
-def _format_stats(rows, totals, period=None, use_color=False, active_sessions=None):
+def _format_rtk_saved(rtk):
+    saved = _format_token_count(rtk["saved_tokens"])
+    share = f" ({rtk['saved_tokens'] * 100 // rtk['input_tokens']}% of their output)" if rtk["input_tokens"] else ""
+    return f"rtk saved {saved} tokens on {rtk['commands']:,} commands{share}."
+
+
+def _stats_group(entry, by):
+    """The project (launch folder) or the model a run is counted under."""
+    if by == "project":
+        return str(entry.get("cwd") or "").rstrip("/\\") or "-"
+    return entry.get("usage_model") or "-"
+
+
+def _project_labels(paths):
+    """The shortest trailing part of each folder that still tells it apart, so
+    /a/app and /b/app read as a/app and b/app rather than both as app."""
+    parts = {path: [p for p in re.split(r"[/\\]", path) if p] for path in paths}
+    labels = {}
+    for path, segments in parts.items():
+        for n in range(1, len(segments) + 1):
+            label = "/".join(segments[-n:])
+            if not any(other != path and "/".join(rest[-n:]) == label for other, rest in parts.items()):
+                break
+        else:
+            label = path
+        labels[path] = label
+    return labels
+
+
+def _format_stats(rows, totals, period=None, use_color=False, active_sessions=None, group_label="SESSION"):
     from ..cli_render import _format_relative_age
 
     active_sessions = active_sessions or set()
     if not rows:
         return "No launch stats for this period." if _has_history_period(period or {}) else "No launch stats."
     table = [[_style(value, "1", use_color) for value in [
-        "SESSION", "PROV.", "RUNS", "USAGE", "IN", "CACHE", "OUT", "REASON", "TOTAL", "COST~", "USD~", "TIME", "LAST"
+        group_label, "PROV.", "RUNS", "USAGE", "IN", "CACHE", "OUT", "REASON", "TOTAL", "COST~", "USD~", "TIME", "LAST"
     ]]]
     for row in rows:
         session_name = row["session_name"]
@@ -596,8 +634,18 @@ def handle_stats(rest, ctx):
     parsed = _parse_stats_args(rest, now=now)
     entries = ctx["service"]["get_launch_history"](parsed["name"], limit=0)
     entries = _filter_history_period(entries, parsed["period"])
+    if parsed["by"] != "session":
+        # Same accounting, another key: each run is regrouped, never re-priced.
+        entries = [{**entry, "session_name": _stats_group(entry, parsed["by"])} for entry in entries]
     rows = _summarize_stats(entries)
+    if parsed["by"] == "project":
+        labels = _project_labels([row["session_name"] for row in rows])
+        for row in rows:
+            row["project"] = row["session_name"]
+            row["session_name"] = labels[row["project"]]
     totals = _stats_totals(rows)
+    # rtk cannot tell which session a command ran in, so only the unfiltered view shows it.
+    rtk = None if parsed["name"] else rtk_saved(ctx["service"]["base_dir"], parsed["period"], env=ctx.get("env"))
     message = (
         f"Calculated stats for {parsed['name']}"
         if parsed["name"]
@@ -610,6 +658,8 @@ def handle_stats(rest, ctx):
             period=_public_history_period(parsed["period"]),
             stats=rows,
             totals=totals,
+            group_by=parsed["by"],
+            rtk=rtk,
             accounting={
                 "launches_unit": "history_attempts",
                 "period_policy": "whole_run_overlap",
@@ -619,8 +669,10 @@ def handle_stats(rest, ctx):
             },
         ))
         return 0
-    active_sessions = _active_session_names(ctx)
-    ctx["out"](f"{_format_stats(rows, totals, period=parsed['period'], use_color=ctx['use_color'], active_sessions=active_sessions)}\n")
+    active_sessions = _active_session_names(ctx) if parsed["by"] == "session" else set()
+    ctx["out"](f"{_format_stats(rows, totals, period=parsed['period'], use_color=ctx['use_color'], active_sessions=active_sessions, group_label=parsed['by'].upper())}\n")
+    if rows and rtk and rtk["commands"]:
+        ctx["out"](f"{_dim(_format_rtk_saved(rtk), ctx['use_color'])}\n")
     return 0
 
 def _resolve_last_launch_session(ctx):
@@ -876,3 +928,39 @@ def _write_refresh_warnings(refresh_errors, ctx, stream="out", rows=None):
     rows_by_name = _rows_by_session(rows)
     for item in refresh_errors:
         write(f"{_warn(_format_refresh_warning(item, rows_by_name), ctx['use_color'])}\n")
+
+
+def handle_sessions(rest, ctx):
+    """Interactive sessions cdx launched that are still running, or every account.
+
+    Read from the runtime cdx records at launch, so a provider started outside
+    cdx is not listed. A runtime whose process has died is reported stale and
+    dropped by the same check `cdx status` uses for `active`. `--all` adds the
+    idle enabled accounts, so a caller can resolve any account's directories.
+    """
+    json_flag, args = _parse_json_flag(rest)
+    include_all = "--all" in args
+    args = [arg for arg in args if arg != "--all"]
+    if not json_flag or args:
+        raise CdxError(SESSIONS_USAGE)
+    service = ctx["service"]
+    rows = []
+    for session in service["list_sessions"]():
+        if session.get("enabled", True) is False:
+            continue
+        runtime = service["active_session_runtime"](session["name"]) or {}
+        if not runtime and not include_all:
+            continue
+        rows.append({
+            "session": session["name"],
+            "provider": session["provider"],
+            "active": bool(runtime),
+            "pid": runtime.get("pid"),
+            "cwd": runtime.get("cwd"),
+            "started_at": runtime.get("startedAt"),
+            "runtime_id": runtime.get("runId"),
+            "conversation_id": (session.get("conversation") or {}).get("id"),
+            **session_paths(session),
+        })
+    _write_json(ctx, _json_success("sessions", "Sessions loaded.", sessions=rows))
+    return 0

package/src/handoff.py

@@ -48,7 +48,7 @@ def inspect_transcript(path, provider, extent=None):
     Never flatten messages: the descriptor points to the original tool evidence.
     The digest binds that evidence to the preparation boundary, even after append.
     """
-    ids, workspaces = set(), set()
+    ids, workspaces = set(), []
     last_event = None
     digest = hashlib.sha256()
     consumed = 0
@@ -88,7 +88,9 @@ def inspect_transcript(path, provider, extent=None):
                 if cwd:
                     if not isinstance(cwd, str) or not os.path.isabs(cwd):
                         raise ValueError('invalid workspace')
-                    workspaces.add(os.path.realpath(cwd))
+                    real = os.path.realpath(cwd)
+                    if real not in workspaces:
+                        workspaces.append(real)
                 stamp = record.get('timestamp')
                 if isinstance(stamp, str):
                     try:
@@ -102,24 +104,33 @@ def inspect_transcript(path, provider, extent=None):
                 consumed = handle.tell()
     except (OSError, ValueError) as error:
         raise CdxError(f'Cannot use transcript {path}: {error}') from error
-    if len(ids) != 1 or len(workspaces) != 1:
+    if len(ids) != 1 or not workspaces:
         raise CdxError(f'Transcript needs one conversation identity and workspace: {path}')
+    # A session that moved between folders (a worktree, a subfolder) keeps
+    # every one of them; it starts in the first, and may be handed off in any.
     return {
         'path': os.path.abspath(path), 'provider': provider, 'conversation_id': ids.pop(),
-        'workspace': workspaces.pop(), 'last_event_at': last_event,
+        'workspace': workspaces[0], 'workspaces': workspaces, 'last_event_at': last_event,
         'extent_bytes': consumed, 'sha256': digest.hexdigest(), 'format': 'jsonl',
         'mode': 'native',
     }
 
 
+def _in_workspace(info, workspace):
+    """The transcript as seen from `workspace`, or None if it never worked there."""
+    if workspace not in info['workspaces']:
+        return None
+    return {**info, 'workspace': workspace}
+
+
 def source_candidates(session, workspace):
     candidates = []
     for path in _native_paths(session):
         try:
-            info = inspect_transcript(path, session['provider'])
+            info = _in_workspace(inspect_transcript(path, session['provider']), workspace)
         except CdxError:
             continue
-        if info['workspace'] == workspace:
+        if info:
             candidates.append(info)
     # Event time helps humans choose; it is never an automatic selection rule.
     return sorted(candidates, key=lambda c: (c['last_event_at'] or '', c['path']), reverse=True)[:CANDIDATE_LIMIT]
@@ -163,11 +174,11 @@ def resolve_source(session, workspace, conversation_id=None, terminal_path=None,
         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'])
+            info = _in_workspace(inspect_transcript(path, session['provider']), workspace)
         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.')
+        if not info:
+            raise HandoffSourceError('Native transcript never worked in the target workspace.')
         info['provenance'] = 'explicit_native_path'
         return info
     if selected:
@@ -177,10 +188,10 @@ def resolve_source(session, workspace, conversation_id=None, terminal_path=None,
         matches = []
         for path in paths:
             try:
-                info = inspect_transcript(path, session['provider'])
+                info = _in_workspace(inspect_transcript(path, session['provider']), workspace)
             except CdxError:
                 continue
-            if info['conversation_id'] == selected and info['workspace'] == workspace:
+            if info and info['conversation_id'] == selected:
                 matches.append(info)
         if len(matches) > 1:
             raise HandoffSourceError(f'Conversation {selected} has multiple native transcripts; select --source-native-transcript PATH.', matches)

package/src/interactive_usage.py

@@ -268,7 +268,9 @@ def _codex_usage(handle):
                 output_tokens=_number(usage.get("output_tokens")),
                 reasoning_tokens=_number(usage.get("reasoning_output_tokens")) or None,
             )
-        except (TypeError, ValueError):
+        except (AttributeError, TypeError, ValueError):
+            # AttributeError: a line that is valid JSON but not an object
+            # ([], "x", "message": "x") is skipped like any malformed line.
             continue
     return latest, model
 
@@ -277,12 +279,14 @@ def _claude_usage(handle):
     """Sum Claude's per-message usage across the transcript.
 
     Cache creation and cache read are kept apart rather than summed on the way
-    in: they cost 1.25x and 0.1x of uncached input, so fusing them here would
-    destroy the only information a cost-aware figure needs. Claude reports no
+    in: they cost 1.25x (2x for one-hour writes) and 0.1x of uncached input, so
+    fusing them here would destroy the only information a cost-aware figure
+    needs. Claude reports no
     separate reasoning count -- thinking is billed as output and is already
     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}
+    long_ttl = None
     seen = set()
     model = None
     for line in handle:
@@ -301,13 +305,18 @@ def _claude_usage(handle):
             totals["cache_creation_tokens"] += _number(usage.get("cache_creation_input_tokens"))
             totals["cache_read_tokens"] += _number(usage.get("cache_read_input_tokens"))
             totals["output_tokens"] += _number(usage.get("output_tokens"))
+            split = usage.get("cache_creation")
+            if isinstance(split, dict) and "ephemeral_1h_input_tokens" in split:
+                long_ttl = (long_ttl or 0) + _number(split["ephemeral_1h_input_tokens"])
             if isinstance(message.get("model"), str) and not message["model"].startswith("<"):
                 model = message["model"]
-        except (TypeError, ValueError):
+        except (AttributeError, TypeError, ValueError):
+            # AttributeError: a line that is valid JSON but not an object
+            # ([], "x", "message": "x") is skipped like any malformed line.
             continue
     if not seen and not any(totals.values()):
         return None, model
-    return normalize_usage(**totals), model
+    return normalize_usage(**totals, cache_creation_1h_tokens=long_ttl), model
 
 
 def _number(value):
@@ -322,6 +331,7 @@ def _number(value):
 MEASURED_KEYS = (
     "input_tokens",
     "cache_creation_tokens",
+    "cache_creation_1h_tokens",
     "cache_read_tokens",
     "output_tokens",
     "reasoning_tokens",
@@ -353,6 +363,11 @@ def usage_delta(cumulative, previous):
         if now is None:
             parts[key] = None
             continue
+        if before is None and key == "cache_creation_1h_tokens" and previous.get("cache_creation_tokens"):
+            # The previous figure predates the split: its writes are unknown,
+            # not zero, so this run's share cannot be told apart.
+            parts[key] = None
+            continue
         difference = now - (before or 0)
         if difference < 0:
             return None