cdx-manager 0.26.6 → 0.26.8

package/src/quota_provenance.py

@@ -0,0 +1,45 @@
+"""Additive quota evidence; never infer a measurement from a missing value."""
+
+from datetime import datetime, timezone
+
+SOURCES = {"codex_rate_limits", "claude_probe", "claude_statusline", "cache", "unknown"}
+
+
+def quota_windows(status, provider, reason=None, now=None):
+    status = status or {}
+    now = now or datetime.now(timezone.utc)
+    ttl = {"codex": 300, "claude": 600}.get(provider, 60)
+    source = {
+        "api:codex-app-server-rate-limits": "codex_rate_limits",
+        "api:anthropic-ratelimit-headers": "claude_probe",
+        "claude:statusline": "claude_statusline",
+    }.get(status.get("source_ref"), "cache")
+    windows = {}
+    for name, field in (("5h", "remaining_5h_pct"), ("weekly", "remaining_week_pct")):
+        evidence = (status.get("quota_windows") or {}).get(name, {})
+        value = status.get(field)
+        observed_at = evidence.get("observed_at", status.get("updated_at")) if value is not None else None
+        try:
+            observed = datetime.fromisoformat(str(observed_at).replace("Z", "+00:00"))
+            if observed.tzinfo is None:
+                observed = observed.replace(tzinfo=timezone.utc)
+            observed_at = observed.isoformat()
+        except (TypeError, ValueError):
+            observed, observed_at = None, None
+        window_reason = reason or ("missing_window" if value is None else None)
+        availability = "unavailable" if window_reason else "measured"
+        if not window_reason and (observed is None or (now - observed).total_seconds() >= ttl):
+            availability = "stale"
+        window_source = evidence.get("source", source) if value is not None else "unknown"
+        windows[name] = {
+            "source": window_source if window_source in SOURCES else "unknown",
+            "observed_at": observed_at,
+            "availability": availability,
+            "reason": window_reason,
+        }
+    return windows
+
+
+def mark_quota_unavailable(row, reason):
+    for window in row.get("quota_windows", {}).values():
+        window.update(availability="unavailable", reason=reason)

package/src/session_backup.py

@@ -441,7 +441,11 @@ def import_bundle(base_dir, store, file_path,
             if recovery_dir:
                 remove_tree(recovery_dir, ignore_errors=True)
 
+    from .claude_status_line import provision
+
+    status_line_warnings = [notice for name in names if (notice := provision(store["get_session"](name), base_dir))]
     return {
+        "status_line_warnings": status_line_warnings,
         "path": file_path,
         "session_names": names,
         "include_auth": bool(decoded["meta"].get("include_auth")),

package/src/session_service.py

@@ -149,7 +149,7 @@ def _seed_codex_auth_from_global(auth_home, env=None):
     return True
 
 
-_ON_OFF_SETTINGS = {"fast": "fast", "rtk": "rtk", "logics": "logics", "notify": "notify", "agent_state": "agent state", "notify_preview": "notify preview", "scrub_env": "scrub env", "shared_memory": "shared memory", "retro": "retro"}
+_ON_OFF_SETTINGS = {"fast": "fast", "rtk": "rtk", "logics": "logics", "notify": "notify", "agent_state": "agent state", "status_line": "status line", "notify_preview": "notify preview", "scrub_env": "scrub env", "shared_memory": "shared memory", "retro": "retro"}
 
 
 def _has_control_chars(text):
@@ -284,7 +284,7 @@ def _normalize_session_label(label):
     return text
 
 
-def set_launch_settings(store, name, settings):
+def set_launch_settings(store, name, settings, base_dir=None):
     session = store["get_session"](name)
     if not session:
         raise CdxError(f"Unknown session: {name}")
@@ -317,16 +317,21 @@ def set_launch_settings(store, name, settings):
             "updatedAt": now,
         }
 
-    return store["update_session"](name, updater)
+    updated = store["update_session"](name, updater)
+    if base_dir is not None:
+        from .claude_status_line import provision
+
+        provision(updated, base_dir)
+    return updated
 
-def unset_launch_settings(store, name, keys):
+def unset_launch_settings(store, name, keys, base_dir=None):
     session = store["get_session"](name)
     if not session:
         raise CdxError(f"Unknown session: {name}")
     if not keys:
         raise CdxError("At least one launch setting is required.")
     allowed = {
-        "power", "reasoning_effort", "reasoningEffort", "permission", "fast", "rtk", "logics", "notify", "agent_state", "notify_preview",
+        "power", "reasoning_effort", "reasoningEffort", "permission", "fast", "rtk", "logics", "notify", "agent_state", "status_line", "notify_preview",
         "scrub_env", "shared_memory", "retro", "model", "fallback_model", "budget", "extra_args", "priority", "policy", "max_parallel",
     }
     unknown = [key for key in keys if key not in allowed]
@@ -345,7 +350,12 @@ def unset_launch_settings(store, name, keys):
             updated.pop("launch", None)
         return updated
 
-    return store["update_session"](name, updater)
+    updated = store["update_session"](name, updater)
+    if base_dir is not None:
+        from .claude_status_line import provision
+
+        provision(updated, base_dir)
+    return updated
 
 def update_auth_state(store, name, updater):
     now = _local_now_iso()
@@ -555,6 +565,9 @@ def copy_session(base_dir, store, source_name, dest_name):
             remove_tree(backup_root, ignore_errors=True)
     finally:
         remove_tree(temp_parent, ignore_errors=True)
+    from .claude_status_line import provision
+
+    provision(result["session"], base_dir)
     return {"session": result["session"], "overwritten": overwritten}
 
 
@@ -604,6 +617,9 @@ def rename_session(base_dir, store, source_name, dest_name):
             delete_keychain_credentials(source_auth_home)
         except CdxError:
             raise CdxError(f"Renamed session to {dest_name}, but old keychain credential cleanup failed; the new session is usable and the old entry was retained.") from None
+    from .claude_status_line import provision
+
+    provision(result["session"], base_dir)
     return result["session"]
 
 
@@ -647,6 +663,9 @@ def create_session(base_dir, env, store, name, provider=DEFAULT_PROVIDER):
         _seed_codex_auth_from_global(auth_home, env=env)
     if normalized_provider == PROVIDER_CLAUDE:
         _ensure_claude_attribution_disabled(auth_home)
+        from .claude_status_line import provision
+
+        provision({"provider": normalized_provider, "authHome": auth_home, "name": name}, base_dir)
     if normalized_provider == "antigravity":
         from .antigravity_status import install
 
@@ -1034,8 +1053,8 @@ def create_session_service(options=None):
         "set_session_enabled": partial(set_session_enabled, store),
         "set_session_label": partial(set_session_label, store),
         "clear_session_label": partial(clear_session_label, store),
-        "set_launch_settings": partial(set_launch_settings, store),
-        "unset_launch_settings": partial(unset_launch_settings, store),
+        "set_launch_settings": partial(set_launch_settings, store, base_dir=base_dir),
+        "unset_launch_settings": partial(unset_launch_settings, store, base_dir=base_dir),
         "record_status": partial(record_status, store),
         "record_launch_history": partial(record_launch_history, store),
         "get_launch_history": partial(get_launch_history, store),

package/src/session_status.py

@@ -13,6 +13,7 @@ from .claude_credentials import claude_auth_type, setup_token_days_left
 from .claude_usage import _decode_jwt_claims
 from .config import PROVIDER_CLAUDE, PROVIDER_CODEX, get_cdx_home
 from .errors import CdxError
+from .quota_provenance import quota_windows
 from .session_helpers import (
     _get_global_codex_home,
     _get_session_auth_home,
@@ -158,6 +159,7 @@ def _normalize_status_payload(payload=None):
         "raw_status_text": payload.get("raw_status_text"),
         "source_ref": payload.get("source_ref"),
         "structured": bool(payload.get("structured")),
+        "quota_windows": payload.get("quota_windows"),
     }
 
 def _parse_status_timestamp(value):
@@ -240,6 +242,11 @@ def _merge_status_payload(current, candidate):
         return current
 
     merged = dict(current)
+    merged["quota_windows"] = dict(current.get("quota_windows") or quota_windows(current, "unknown"))
+    candidate_windows = candidate.get("quota_windows") or quota_windows(candidate, "unknown")
+    for name, field in (("5h", "remaining_5h_pct"), ("weekly", "remaining_week_pct")):
+        if current.get(field) is None and candidate.get(field) is not None:
+            merged["quota_windows"][name] = candidate_windows[name]
     for field in [
         "usage_pct",
         "remaining_5h_pct",
@@ -336,7 +343,7 @@ def _fetch_codex_status(codex_status_fetcher, custom_codex_status_fetcher, defau
     if custom_codex_status_fetcher:
         return custom_codex_status_fetcher(session)
     timeout = timeout_seconds or default_status_timeout_seconds
-    return codex_status_fetcher(session, timeout=timeout)
+    return codex_status_fetcher(session, timeout=timeout, diagnostic=True)
 
 def session_paths(session):
     """Where a session's files live, so a caller never rebuilds cdx's layout.
@@ -415,6 +422,12 @@ def _status_row_from_session(store, s):
         )})
         if enabled and antigravity["quota_stale"]:
             row["status"] = "stale"
+    reason = s.get("_quota_error")
+    if not enabled:
+        reason = "profile_disabled"
+    elif row["auth_status"] == "logged_out":
+        reason = "login_required"
+    row["quota_windows"] = quota_windows(row_status, s["provider"], reason=reason)
     row["runs_out_at_iso"] = _runs_out(row)
     return row
 
@@ -465,9 +478,13 @@ def _resolve_session_status(store, base_dir, env, fetch_codex_status, session,
             {**session, "authHome": source_root},
             timeout_seconds=status_timeout_seconds,
         )
-        if live_status:
+        if live_status and live_status.get("_quota_error"):
+            session["_quota_error"] = live_status["_quota_error"]
+        elif live_status:
             record_status(store, session["name"], live_status)
             return live_status
+        else:
+            session["_quota_error"] = "quota_read_failed"
 
     expected_account_email = (
         _read_expected_account_email(source_root)
@@ -494,6 +511,12 @@ def _resolve_session_status(store, base_dir, env, fetch_codex_status, session,
                 # structured payloads there cannot be attributed to ours.
                 trust_unattributed_structured=False,
             )
+            if artifact and (artifact.get("structured") or not expected_account_email):
+                # Shared artifacts without verified identity cannot date this profile.
+                artifact["quota_windows"] = {
+                    name: {"source": "cache", "observed_at": None}
+                    for name in ("5h", "weekly")
+                }
     if not artifact:
         if _is_low_confidence_status_source(current_status):
             return None
@@ -511,6 +534,7 @@ def _resolve_session_status(store, base_dir, env, fetch_codex_status, session,
         "raw_status_text": artifact.get("raw_status_text"),
         "source_ref": artifact.get("source_ref"),
         "structured": artifact.get("structured"),
+        "quota_windows": artifact.get("quota_windows"),
     })
     if _is_low_confidence_status_source(current_status) and not _is_low_confidence_status_source(resolved):
         record_status(store, session["name"], resolved)

package/src/status_source.py

@@ -4,6 +4,7 @@ import re
 from datetime import datetime, timezone
 
 from .config import PROVIDER_CLAUDE, PROVIDER_CODEX
+from .quota_provenance import quota_windows
 
 _ANSI_ESCAPE = re.compile(r"\x1b\[[0-9;]*m")
 _ANSI_TERMINAL_CONTROL = re.compile(r"\x1b\[[0-9;?]*[ -/]*[@-~]")
@@ -513,11 +514,6 @@ def extract_named_statuses_from_text(text):
         if "remaining_week_pct" not in result and week_used is not None:
             result["remaining_week_pct"] = max(0, 100 - week_used)
 
-    if re.search(r"No stats available yet\.?\s+Start using Claude Code", normalized, re.I):
-        result.setdefault("usage_pct", 0)
-        result.setdefault("remaining_5h_pct", 100)
-        result.setdefault("remaining_week_pct", 100)
-
     # Table header row
     header_idx = next(
         (i for i, l in enumerate(lines)
@@ -722,6 +718,9 @@ def _backfill_missing_fields(target, source):
             continue
         if target.get(field) is None and source.get(field) is not None:
             target[field] = source[field]
+            name = {"remaining_5h_pct": "5h", "remaining_week_pct": "weekly"}.get(field)
+            if name:
+                target.setdefault("quota_windows", {})[name] = (source.get("quota_windows") or quota_windows(source, "unknown"))[name]
 
 
 def _record_timestamp_epoch(value):
@@ -792,9 +791,9 @@ def find_latest_status_artifact(
             score = stat.st_mtime
         else:
             score = 0
-        # Each record producer stamps "trusted" where it knows the source kind.
-        # Untrusted records are text scraped from jsonl payloads: they can be
-        # conversational noise quoting an old status block.
+        parsed["updated_at"] = datetime.fromtimestamp(score, tz=timezone.utc).isoformat() if score else None
+        parsed["quota_windows"] = quota_windows(parsed, provider)
+        # Trust comes from the record producer, not conversational text.
         trusted = bool(candidate.get("trusted"))
         # Structured payloads carry no account identity, so the email guard
         # above cannot filter them. In roots shared by several accounts the