cdx-manager 0.26.5 → 0.26.7

package/README.md

@@ -4,7 +4,7 @@
 
 <br clear="left"/>
 
-[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.26.5-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
+[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.26.7-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
 
 **The right AI coding account, when you need it.** CDX Manager keeps your Codex and Claude accounts in separate profiles, shows which ones have quota, and helps you pick the next usable session from your terminal.
 
@@ -42,6 +42,41 @@ cdx work
 
 CDX checks authentication before interactive launches. Handoff keeps the source transcript in place and asks the receiving agent to verify the conversation and workspace before acting. No account switch or prompt submission happens just because you run `cdx next`.
 
+## Quota provenance in status JSON
+
+Every profile in `cdx status --json` (including `--cached` and a named profile)
+includes `quota_windows.5h` and `quota_windows.weekly` alongside the existing
+percentage, reset and timestamp fields. Each window contains:
+
+- `source`: `codex_rate_limits` for the existing `account/rateLimits/read`
+  reader, `claude_probe` for the existing one-token Claude probe,
+  `claude_statusline` for explicitly identified Claude statusline evidence,
+  `cache` for legacy/local evidence without a known provider origin, or
+  `unknown` when the window has no measurement. A cached reading retains its
+  known original source; no extra probe is performed for this metadata.
+- `observed_at`: the ISO 8601 measurement time for this profile and window,
+  or `null` when absent or unknown. Reading a cache never advances this time.
+- `availability`: `measured` below the freshness threshold, `stale` at or
+  beyond it (or when a value has no valid observation time), or `unavailable`
+  when no value exists or the current read/authentication attempt failed.
+- `reason`: `null` unless unavailable; otherwise a stable explanation such
+  as `missing_window`, `login_required`, `login_expired`, `quota_read_failed`,
+  `probe_timeout`, `auth_probe_failed`, `profile_disabled`, or the Codex
+  diagnostic reason (`auth_locked`, `initialize_failed`,
+  `rate_limits_read_failed`, `missing_rate_limits`, `codex_cli_not_found`,
+  `missing_auth_home`, `probe_failed`). Provider error bodies are not copied.
+
+Freshness thresholds match the existing cache TTLs: Codex **300 seconds**,
+Claude **600 seconds**, and other providers **60 seconds** for these generic
+window fields. Provider-specific fields such as Antigravity's quota freshness
+retain their existing semantics. Missing windows remain `null`, never an
+assumed 0% or 100%. On a failed refresh, existing cached percentages and reset
+times remain available for compatibility, but the new availability is
+`unavailable` with the failure reason and the original observation time.
+Transient read errors describe the current command; `--cached` evaluates the
+stored evidence and authentication state without making a new read attempt.
+Reset times describe the quota window, not when it was measured.
+
 ## Automatic mission concurrency per profile
 
 ```bash
@@ -358,3 +393,41 @@ next_page = read_conversation(
     cursor=page["next_cursor"], limit=100,
 )
 ```
+
+### Claude quota status line
+
+cdx installs a cache-only `statusLine` command in each new Claude profile's
+`.claude/settings.json` and updates it on copy, rename, import, interactive launch/resume or `cdx set` /
+`cdx unset`. Existing profiles pick it up at their next interactive launch.
+The line uses the launcher's eight-cell remaining-capacity gauge, for example:
+
+```text
+█▁▁▁▁▁▁▁  5h 25% · wk 16% (reset Nov 07 09:30) · grif
+```
+
+The gauge follows the lowest known window. Each window below 20% includes its
+cached reset time when available. `stale` marks observations at least ten minutes
+old, missing an observation timestamp, or dated in the future. Missing, unreadable,
+malformed, or unknown quota data produces only `quota ?`, with no error output.
+The status command reads `sessions.json` directly without taking a store lock,
+refreshing authentication, starting a provider, or making a network call. Refresh
+quota separately with `cdx status --refresh` or the tray's normal refresh cycle.
+It targets less than 100 ms per render; Claude's input JSON is not used.
+
+The command pins the cdx store path and resolves the profile from the session's
+`HOME` / `USERPROFILE`, with `CDX_SESSION_NAME` as fallback when no home is set.
+It does not follow the launcher's currently selected account. Operator-defined
+`statusLine` values and unrelated settings are preserved; cdx reports a conflict
+in launch/settings output (also in JSON `warnings`). Invalid settings are skipped.
+
+```bash
+cdx set grif --status-line off  # Remove only cdx's command and keep it disabled.
+cdx set grif --status-line on   # Reinstall without replacing an operator command.
+cdx unset grif --status-line   # Return to the default (enabled for Claude).
+cdx set --provider claude --status-line on  # Update existing Claude profiles now.
+```
+
+Codex has a built-in status line configured with `tui.status_line`, an ordered list
+of built-in footer item identifiers, rather than Claude's shell-command setting
+([official configuration reference](https://learn.chatgpt.com/docs/config-file/config-reference)).
+cdx does not change Codex configuration for this feature.

package/VERSION

@@ -1 +1 @@
-0.26.5
+0.26.7

package/changelogs/CHANGELOGS_0_26_6.md

@@ -0,0 +1,17 @@
+# CDX Manager 0.26.6
+
+Release date: 2026-11-06
+
+## Fixes
+
+- Unwrap matching Claude `pasted_content` tags in conversation views so pasted
+  text appears without its wrapper (#116,
+  `84cb0de57407e4568b8d9918787a8d370ec76d10`). Preserve literal text with
+  unmatched tags.
+
+## Maintenance
+
+- Record tray companion checksums for v0.26.5
+  (`0bd3af61dbb1c848c9a14cbd10ce4b6af439b3c9`).
+- Record release archive checksums for v0.26.5
+  (`19d2d3c7443dc5573afce982086fd0d38d89fad2`).

package/changelogs/CHANGELOGS_0_26_7.md

@@ -0,0 +1,20 @@
+# CDX Manager 0.26.7
+
+Release date: 2026-11-07
+
+## Improvements
+
+- Expose per-profile quota provenance and freshness in status JSON (#118,
+  `3a7a30b4c9b0dce099027be1a6874c2b87d574b6`). Add `quota_windows.5h` and
+  `quota_windows.weekly` with the source, observation time, availability and
+  unavailable reason while preserving existing fields and reset times.
+- Reuse existing quota readers without additional requests. Preserve observation
+  times for cached evidence and mark old or undated readings stale rather than
+  inventing fresh measurements.
+
+## Maintenance
+
+- Record tray companion checksums for v0.26.6
+  (`8e006ca40c942115cac99fd998b6f885358f17f3`).
+- Record release archive checksums for v0.26.6
+  (`0f0c53d2991ef84f368e73b60cb293a94ce4af4d`).

package/changelogs/CHANGELOGS_UNRELEASED.md

@@ -1,5 +1,18 @@
 # Unreleased
 
+## Claude profile quota status line
+
+- Install a fast cache-only status line for Claude profiles at creation, settings updates and interactive launch/resume. Show the shared launcher gauge, both remaining windows, profile name, low-quota resets and a stale marker; use `quota ?` when data is unavailable.
+- Preserve and report operator-defined status lines. Add `cdx set --status-line on|off` and `cdx unset --status-line` for reversible profile control; leave Codex settings unchanged and document its built-in footer equivalent.
+- Write the standalone status line as UTF-8 when piped, including on Windows, and read repository contract fixtures explicitly as UTF-8.
+
+
+## Quota provenance and profile freshness
+
+- Add `quota_windows.5h` and `quota_windows.weekly` to status JSON with `source`, per-profile/window ISO `observed_at`, `availability` (`measured`, `stale`, `unavailable`) and a nullable unavailable `reason`. Keep existing fields and reset times compatible.
+- Reuse the existing Codex rate-limit reader and Claude one-token probe without adding requests; distinguish login/read failures and missing windows without inventing percentages. Preserve older window timestamps during backfill.
+- Mark Codex evidence stale at 300 seconds and Claude evidence at 600 seconds (60 seconds for generic other-provider windows); unknown measurement times are stale. Cached evidence retains known provenance and never receives a new observation time.
+
 ## Find and resume interactive sessions
 
 - Add exact resolved `cdx history --cwd PATH` and `--interactive` filters before the result limit, preserving the JSON envelope and period/summary support.

package/checksums/release-archives.json

@@ -848,6 +848,28 @@
         "x86_64-pc-windows-msvc": "40e0a2e7d72cacbf2fa5fc241484e901228e44214f053c1c1defede62045624b",
         "x86_64-unknown-linux-musl": "f24dea41496fa347b64873066b6b57fbbca6480c4bef1769a3bcd47e3dcb6b34"
       }
+    },
+    "v0.26.5": {
+      "github_tarball_sha256": "45bae3e2dccc49ac47c4c0c3fa57053b391ce3ddf8c56f002f10b56a989d4c1b",
+      "github_zip_sha256": "3bdfc7c87beb1a3903e979ec5680d7b18f089cd0ff11728ae895faac472b2759",
+      "tray_assets": {
+        "aarch64-apple-darwin": "df17b304e0442f5a2f71d18ed754a98d0151b48708117f47a6cb8106055a77b3",
+        "aarch64-unknown-linux-musl": "792948a0c48f8221fbf87b6c77e5d4c9e29aac0cf0738857a5ae3346794b5c01",
+        "x86_64-apple-darwin": "18923fe1f9bda34ef52b972002845aa914a404beff0de9963f6f9fb0a4c2f0b1",
+        "x86_64-pc-windows-msvc": "1ea355b54e05ea6d78a3a23757a9ad5dd2228aa1d939fb7992082e16da579abb",
+        "x86_64-unknown-linux-musl": "770fabb26784efb607d2cce6d6bee51c3d7121283c55cf4cacb9b54ac75e4450"
+      }
+    },
+    "v0.26.6": {
+      "github_tarball_sha256": "ac54b4e9cb3ab6eb232d31806fcccb9a56720a3d75ee26cb3b81bd9923dd4ca0",
+      "github_zip_sha256": "6a195d19ee29ef568d43b6edbf23980b29c9fc35f295269b82e1f32ce5b7b490",
+      "tray_assets": {
+        "aarch64-apple-darwin": "4d9be82842365447f4d34ddc577b0571e620c0d900da9f751f50337d3362ff68",
+        "aarch64-unknown-linux-musl": "0c13305e28348578fd7437e319dc53aecc0f1e4b3ff21db25e19a70b2fdc6e8b",
+        "x86_64-apple-darwin": "b7a8d7ea2b3f0e2b8eba08d845eeb7c41e06b8dbfc1915257c920577e23e01d7",
+        "x86_64-pc-windows-msvc": "82fcceda389ba33ef60bc01ccce62249c0a1866479611192761778646ad33880",
+        "x86_64-unknown-linux-musl": "a1194dc6e672729e7d6ba079b7c1a393e7098e83edd6ab3b6fd63832a7dad136"
+      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.26.5",
+  "version": "0.26.7",
   "description": "Terminal session manager for Codex and Claude accounts.",
   "license": "MIT",
   "author": "Alexandre Agostini",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cdx-manager"
-version = "0.26.5"
+version = "0.26.7"
 description = "Terminal session manager for Codex and Claude accounts."
 readme = "README.md"
 requires-python = ">=3.9.2"
@@ -55,6 +55,9 @@ cdx = "cdx_manager.cli:cli_entry"
 # of which ship the source tree wholesale — worked fine.
 packages = ["cdx_manager", "cdx_manager.commands"]
 
+[tool.setuptools.package-data]
+cdx_manager = ["quota_gauge.txt"]
+
 [tool.setuptools.package-dir]
 cdx_manager = "src"
 "cdx_manager.commands" = "src/commands"

package/src/claude_refresh.py

@@ -2,7 +2,7 @@ import inspect
 import threading
 from datetime import datetime, timezone
 
-from .claude_usage import refresh_claude_session_status
+from .claude_usage import ClaudeAuthInvalidError, refresh_claude_session_status
 from .config import PROVIDER_CLAUDE
 from .errors import CdxError
 
@@ -48,6 +48,7 @@ def _refresh_claude_sessions(service, refresh_fn=None, target_names=None, force=
 
     errors = []
     results = {}
+    completed = set()
 
     threads = []
 
@@ -61,15 +62,22 @@ def _refresh_claude_sessions(service, refresh_fn=None, target_names=None, force=
             # refresh_fn is the real default, since a caller-injected
             # refresh_fn (tests, mocks) may not accept auth_refresher.
             if refresh_fn is refresh_claude_session_status and s["name"] in already_auth_refreshed:
-                usage = refresh_fn(s, auth_refresher=lambda _auth_home: None)
+                usage = refresh_fn(s, auth_refresher=lambda _auth_home: None, diagnostic=True)
+            elif refresh_fn is refresh_claude_session_status:
+                usage = refresh_fn(s, diagnostic=True)
             else:
                 usage = refresh_fn(s)
             if inspect.isawaitable(usage):
                 raise CdxError("Claude refresh function returned an awaitable from a sync callable.")
-            if usage:
+            if usage and usage.get("_quota_error"):
+                errors.append({"session": s["name"], "error": CdxError("Claude quota unavailable"), "reason": usage["_quota_error"]})
+            elif usage:
                 results[s["name"]] = usage
         except Exception as e:
-            errors.append({"session": s["name"], "error": e})
+            errors.append({"session": s["name"], "error": e,
+                           "reason": "login_expired" if isinstance(e, ClaudeAuthInvalidError) else "quota_read_failed"})
+        finally:
+            completed.add(s["name"])
 
     for s in claude_sessions:
         t = threading.Thread(target=fetch, args=(s,), daemon=True)
@@ -83,6 +91,11 @@ def _refresh_claude_sessions(service, refresh_fn=None, target_names=None, force=
     results = dict(results)
     errors = list(errors)
 
+    completed = set(completed)
+    for session in claude_sessions:
+        if session["name"] not in completed:
+            errors.append({"session": session["name"], "error": CdxError("Claude quota read timed out"), "reason": "probe_timeout"})
+
     recorded = []
     for name, usage in results.items():
         try:

package/src/claude_status_line.py

@@ -0,0 +1,139 @@
+"""Fast, cache-only Claude status line; executable without importing the CLI."""
+
+import json
+import math
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+MARKER = "--cdx-claude-status"
+CACHE_TTL_SECONDS = 10 * 60  # Same freshness window as Claude's cached status.
+
+
+def _read(path):
+    try:
+        with open(path, encoding="utf-8") as handle:
+            return json.load(handle)
+    except (OSError, ValueError):
+        return None
+
+
+def _pct(value):
+    return value if isinstance(value, (int, float)) and not isinstance(value, bool) and 0 <= value <= 100 and math.isfinite(value) else None
+
+
+def gauge(value):
+    # The tray menu embeds this same eight-cell glyph strip at build time.
+    full, empty = Path(__file__).with_name("quota_gauge.txt").read_text(encoding="utf-8").splitlines()
+    filled = int(math.floor((value or 0) / 100 * len(full) + 0.5))
+    return full[:filled] + empty[filled:]
+
+
+def _clean(value):
+    return "".join(c for c in str(value) if c.isprintable())
+
+
+def render(base_dir, env=None, now=None):
+    env = os.environ if env is None else env
+    data = _read(os.path.join(base_dir, "sessions.json"))
+    if not isinstance(data, dict) or not isinstance(data.get("sessions"), list):
+        return "quota ?"
+    home = env.get("HOME") or env.get("USERPROFILE")
+    name = env.get("CDX_SESSION_NAME")
+    matches = [s for s in data["sessions"] if isinstance(s, dict) and s.get("provider") == "claude" and (
+        os.path.realpath(s.get("authHome") or "") == os.path.realpath(home) if home else s.get("name") == name
+    )]
+    if len(matches) != 1:
+        return "quota ?"
+    session = matches[0]
+    status = session.get("lastStatus")
+    if not isinstance(status, dict):
+        return "quota ?"
+    values = [_pct(status.get(f"remaining_{window}_pct")) for window in ("5h", "week")]
+    known = [v for v in values if v is not None]
+    if not known:
+        return "quota ?"
+    now = now or datetime.now(timezone.utc)
+    evidence = status.get("quota_windows") or {}
+    stale = False
+    for window, value in zip(("5h", "weekly"), values):
+        if value is None:
+            continue
+        reading = evidence.get(window, {}) if isinstance(evidence, dict) else {}
+        if not isinstance(reading, dict):
+            reading = {}
+        timestamp = reading.get("observed_at", status.get("updated_at") or session.get("lastStatusAt"))
+        try:
+            observed = datetime.fromisoformat(str(timestamp).replace("Z", "+00:00"))
+            stale |= observed.tzinfo is None or not 0 <= (now - observed).total_seconds() < CACHE_TTL_SECONDS
+        except (ValueError, TypeError):
+            stale = True
+        stale |= reading.get("availability") in ("stale", "unavailable")
+    parts = []
+    for window, label, value in zip(("5h", "week"), ("5h", "wk"), values):
+        text = f"{label} {value:g}%" if value is not None else f"{label} ?"
+        reset = status.get(f"reset_{window}_at")
+        if value is not None and value < 20 and reset:
+            text += f" (reset {_clean(reset)})"
+        parts.append(text)
+    parts.append(_clean(session.get("name", "?")))
+    if stale:
+        parts.append("stale")
+    return f"{gauge(min(known))}  " + " · ".join(parts)
+
+
+def provision(session, base_dir):
+    """Return a report on conflicts; never replace an operator's status line."""
+    if session.get("provider") != "claude":
+        return None
+    import shlex
+    import subprocess
+
+    from .agent_notify import _read_json, _write_json
+
+    path = os.path.join(session["authHome"], ".claude", "settings.json")
+    settings = _read_json(path)
+    if settings is None:
+        return f"{session['name']}: statusLine skipped (unreadable settings.json)"
+    current = settings.get("statusLine")
+    own = False
+    if isinstance(current, dict) and isinstance(current.get("command"), str):
+        try:
+            parts = shlex.split(current["command"], posix=os.name != "nt")
+            own = len(parts) == 4 and os.path.basename(parts[1].strip('"')) == "claude_status_line.py" and parts[2] == MARKER
+        except ValueError:
+            pass
+    if "statusLine" in settings and not own:
+        return f"{session['name']}: operator-defined statusLine preserved"
+    if (session.get("launch") or {}).get("status_line") is False:
+        if not own:
+            return None
+        del settings["statusLine"]
+    else:
+        args = [sys.executable, os.path.abspath(__file__), MARKER, os.path.abspath(base_dir)]
+        command = subprocess.list2cmdline(args) if os.name == "nt" else shlex.join(args)
+        desired = {**(current or {}), "type": "command", "command": command}
+        if current == desired:
+            return None
+        settings["statusLine"] = desired
+    if not _write_json(path, settings):
+        return f"{session['name']}: statusLine skipped (settings.json is not writable)"
+    return None
+
+
+def main(argv=None, stdout=None, env=None):
+    argv = sys.argv[1:] if argv is None else argv
+    stdout = sys.stdout if stdout is None else stdout
+    try:
+        text = render(argv[1], env=env) if len(argv) == 2 and argv[0] == MARKER else "quota ?"
+    except (OSError, ValueError, TypeError, AttributeError):
+        text = "quota ?"
+    stdout.write(text + "\n")
+    return 0
+
+
+if __name__ == "__main__":
+    # Claude reads UTF-8 from a pipe; Windows otherwise uses its ANSI code page.
+    sys.stdout.reconfigure(encoding="utf-8")
+    raise SystemExit(main())

package/src/claude_usage.py

@@ -15,6 +15,7 @@ except ImportError:  # pragma: no cover - Windows
 
 from .claude_credentials import read_keychain_credentials
 from .errors import CdxError
+from .quota_provenance import quota_windows
 
 MONTH_ABBR = ["Jan", "Feb", "Mar", "Apr", "May", "Jun",
               "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
@@ -368,7 +369,7 @@ def fetch_claude_rate_limit_headers(access_token):
     reset_week_at = _format_reset_date(_parse_reset_epoch(reset_7d)) if reset_7d else None
     reset_at = reset_week_at or reset_5h_at
 
-    return {
+    status = {
         "remaining_5h_pct": _remaining_from_utilization(utilization_5h),
         "remaining_week_pct": _remaining_from_utilization(utilization_7d),
         "reset_5h_at": reset_5h_at,
@@ -378,20 +379,22 @@ def fetch_claude_rate_limit_headers(access_token):
         "raw_status_text": None,
         "source_ref": "api:anthropic-ratelimit-headers",
     }
+    status["quota_windows"] = quota_windows(status, "claude")
+    return status
 
 
-def refresh_claude_session_status(session, auth_refresher=None):
+def refresh_claude_session_status(session, auth_refresher=None, diagnostic=False):
     auth_home = session.get("authHome", "")
     refresher = auth_refresher or _refresh_claude_cli_credentials
     refresher(auth_home)
     creds = _read_claude_credentials(auth_home)
     if not creds or not creds.get("accessToken"):
-        return None
+        return {"_quota_error": "login_required"} if diagnostic else None
     if _access_token_expired(creds):
         # ponytail: `claude auth status` doesn't refresh an expired access
         # token (verified no-op) and only a real Claude Code invocation does.
         # Probing anyway just reproduces a 401 we can already predict
-        # offline, so skip it like the "no credentials" case above and leave
-        # the cached quota as stale rather than raising a false alert.
-        return None
-    return fetch_claude_rate_limit_headers(creds["accessToken"])
+        # offline, so skip it and retain the cached observation time.
+        return {"_quota_error": "login_expired"} if diagnostic else None
+    status = fetch_claude_rate_limit_headers(creds["accessToken"])
+    return status or ({"_quota_error": "quota_read_failed"} if diagnostic else None)

package/src/cli.py

@@ -266,7 +266,7 @@ def _print_help(use_color=False):
         f"  {_style('cdx configs [--json]', '36', use_color)}",
         f"  {_style('cdx power|perm|fast|model <name|all|provider:PROVIDER|a,b> <value|default> [--json]', '36', use_color)}",
         f"  {_style(SET_USAGE[len('Usage: '):], '36', use_color)}",
-        f"  {_style('cdx unset <name>|--sessions all|a,b|--provider PROVIDER (--power|--permission|--fast|--rtk|--logics|--notify|--notify-preview|--model|--priority|--max-parallel|--all) [--json]', '36', use_color)}",
+        f"  {_style('cdx unset <name>|--sessions all|a,b|--provider PROVIDER (--power|--permission|--fast|--rtk|--logics|--notify|--status-line|--notify-preview|--model|--priority|--max-parallel|--all) [--json]', '36', use_color)}",
         f"  {_style('cdx start <name> [--dir PATH] [--resume] [--json]', '36', use_color)}",
         f"  {_style('cdx history backfill-projects [--mapping FILE] [--dry-run|--apply] [--json]', '36', use_color)}",
         f"  {_style('cdx history [name] [--cwd PATH] [--interactive] [--limit N] [--summary] [--since 7d|today|DATE] [--from DATE] [--to DATE] [--json]', '36', use_color)}",

package/src/cli_args.py

@@ -35,8 +35,8 @@ CONTEXT_USAGE = "Usage: cdx context show|path|init|edit|clear|set|append [text..
 MEMORY_USAGE = "Usage: cdx memory [--global|--project NAME_OR_PATH] [show|view|path|init|edit|clear|set|append|list] [text...] [--json]"
 HANDOFF_USAGE = "Usage: cdx handoff <name> [--json] | cdx handoff <source> <target> [--source-conversation ID | --source-native-transcript PATH | --source-transcript PATH] [--json]"
 LABEL_USAGE = "Usage: cdx label <name> <label> [--json] | cdx label <name> --clear [--json]"
-SET_USAGE = "Usage: cdx set <name>|--sessions all|a,b|--provider PROVIDER [--power minimal|low|medium|high|xhigh] [--permission review|default|auto|full] [--fast on|off] [--rtk on|off] [--logics on|off] [--notify on|off] [--agent-state on|off] [--notify-preview on|off] [--scrub-env on|off] [--shared-memory on|off] [--retro on|off] [--policy use|ask-first|never] [--model MODEL] [--fallback-model MODEL[,MODEL...]] [--budget USD] [--extra-args 'ARGS'] [--priority 0..100] [--max-parallel 0..5] [--json]"
-UNSET_USAGE = "Usage: cdx unset <name>|--sessions all|a,b|--provider PROVIDER (--power|--reasoning-effort|--permission|--fast|--rtk|--logics|--notify|--agent-state|--notify-preview|--scrub-env|--shared-memory|--retro|--policy|--model|--fallback-model|--budget|--extra-args|--priority|--max-parallel|--all) [--json]"
+SET_USAGE = "Usage: cdx set <name>|--sessions all|a,b|--provider PROVIDER [--power minimal|low|medium|high|xhigh] [--permission review|default|auto|full] [--fast on|off] [--rtk on|off] [--logics on|off] [--notify on|off] [--agent-state on|off] [--status-line on|off] [--notify-preview on|off] [--scrub-env on|off] [--shared-memory on|off] [--retro on|off] [--policy use|ask-first|never] [--model MODEL] [--fallback-model MODEL[,MODEL...]] [--budget USD] [--extra-args 'ARGS'] [--priority 0..100] [--max-parallel 0..5] [--json]"
+UNSET_USAGE = "Usage: cdx unset <name>|--sessions all|a,b|--provider PROVIDER (--power|--reasoning-effort|--permission|--fast|--rtk|--logics|--notify|--agent-state|--status-line|--notify-preview|--scrub-env|--shared-memory|--retro|--policy|--model|--fallback-model|--budget|--extra-args|--priority|--max-parallel|--all) [--json]"
 SETTING_ALIAS_USAGE = "Usage: cdx power|perm|fast|model <name|all|provider:PROVIDER|a,b> <value|default> [--json]"
 CONFIG_USAGE = "Usage: cdx config <name> [--json]"
 CONFIGS_USAGE = "Usage: cdx configs [--json]"
@@ -278,6 +278,7 @@ def _parse_set_args(args):
         "--logics": {"key": "logics", "type": "str", "default": None, "transform": _on_off("logics")},
         "--notify": {"key": "notify", "type": "str", "default": None, "transform": _on_off("notify")},
         "--agent-state": {"key": "agent_state", "type": "str", "default": None, "transform": _on_off("agent state")},
+        "--status-line": {"key": "status_line", "type": "str", "default": None, "transform": _on_off("status line")},
         "--notify-preview": {"key": "notify_preview", "type": "str", "default": None, "transform": _on_off("notify preview")},
         "--scrub-env": {"key": "scrub_env", "type": "str", "default": None, "transform": _on_off("scrub env")},
         "--shared-memory": {"key": "shared_memory", "type": "str", "default": None, "transform": _on_off("shared memory")},
@@ -305,7 +306,7 @@ def _parse_set_args(args):
         raise CdxError(SET_USAGE)
     settings = {
         key: parsed[key]
-        for key in ("power", "permission", "fast", "rtk", "logics", "notify", "agent_state", "notify_preview", "scrub_env", "shared_memory", "retro", "model", "fallback_model", "budget", "extra_args", "priority", "policy", "max_parallel")
+        for key in ("power", "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")
         if parsed[key] is not None
     }
     if not settings:
@@ -329,6 +330,7 @@ def _parse_unset_args(args):
         "--logics": {"key": "logics", "type": "bool", "default": False},
         "--notify": {"key": "notify", "type": "bool", "default": False},
         "--agent-state": {"key": "agent_state", "type": "bool", "default": False},
+        "--status-line": {"key": "status_line", "type": "bool", "default": False},
         "--notify-preview": {"key": "notify_preview", "type": "bool", "default": False},
         "--scrub-env": {"key": "scrub_env", "type": "bool", "default": False},
         "--shared-memory": {"key": "shared_memory", "type": "bool", "default": False},
@@ -356,7 +358,7 @@ def _parse_unset_args(args):
     if not parsed["names"] and not parsed["sessions"] and not parsed["provider"]:
         raise CdxError(UNSET_USAGE)
     _UNSET_KEYS = (
-        "power", "reasoning_effort", "permission", "fast", "rtk", "logics", "notify", "agent_state", "notify_preview", "scrub_env", "shared_memory", "retro",
+        "power", "reasoning_effort", "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",
     )
     keys = list(_UNSET_KEYS) if parsed["all"] else [key for key in _UNSET_KEYS if parsed[key]]

package/src/cli_helpers.py

@@ -313,6 +313,7 @@ def _format_launch_config(session, use_color=False):
         ("logics", "Logics"),
         ("notify", "Agent alerts"),
         ("agent_state", "Agent state"),
+        ("status_line", "Claude quota status line"),
         ("notify_preview", "Response preview"),
         ("scrub_env", "Scrub agent env"),
         ("shared_memory", "Shared memory"),
@@ -325,6 +326,8 @@ def _format_launch_config(session, use_color=False):
         ("policy", "Policy"),
         ("max_parallel", "Max parallel"),
     ]:
+        if key == "status_line" and session["provider"] != "claude":
+            continue
         rows.append([
             _dim(label, use_color),
             _format_launch_setting_value(launch, key, use_color=use_color),
@@ -345,14 +348,16 @@ def _format_launch_settings_hint(name="<name>"):
     )
 
 def _format_launch_setting_value(launch, key, use_color=False):
-    if key in ("fast", "rtk", "logics", "notify", "agent_state", "notify_preview", "scrub_env", "shared_memory", "retro"):
+    if key in ("fast", "rtk", "logics", "notify", "agent_state", "status_line", "notify_preview", "scrub_env", "shared_memory", "retro"):
         if launch.get(key) is True:
             return _style("on", "32", use_color)
         if launch.get(key) is False:
             return _style("off", "2", use_color)
+        if key == "status_line":
+            return _dim("on (Claude)", use_color)
         if key == "logics":
             return _dim("auto", use_color)
-        if key in ("notify", "agent_state", "notify_preview", "scrub_env", "shared_memory", "retro"):
+        if key in ("notify", "agent_state", "status_line", "notify_preview", "scrub_env", "shared_memory", "retro"):
             return _style("off", "2", use_color)
         return _dim("default", use_color)
     value = launch.get(key)

package/src/codex_usage.py

@@ -7,6 +7,7 @@ import threading
 import time
 from datetime import datetime, timezone
 
+from .quota_provenance import quota_windows
 from .status_source import _is_zero_credit_balance
 
 try:
@@ -139,7 +140,7 @@ def normalize_codex_rate_limit_snapshot(snapshot, reset_credits=None):
         })
 
     raw_status_text = json.dumps(snapshot, sort_keys=True)
-    return {
+    status = {
         "remaining_5h_pct": _remaining_from_used_percent(
             five_hour.get("usedPercent", five_hour.get("used_percent"))
         ),
@@ -156,6 +157,8 @@ def normalize_codex_rate_limit_snapshot(snapshot, reset_credits=None):
         "raw_status_text": raw_status_text,
         "source_ref": "api:codex-app-server-rate-limits",
     }
+    status["quota_windows"] = quota_windows(status, "codex")
+    return status
 
 
 def _reader_thread(stream, output):
@@ -305,13 +308,18 @@ def _request_codex_app_server(auth_home, method, params, failure_reason, timeout
                     pass
 
 
-def fetch_codex_rate_limits(session, timeout=5, popen_factory=None):
-    diagnostic = fetch_codex_rate_limit_diagnostic(
+def fetch_codex_rate_limits(session, timeout=5, popen_factory=None, diagnostic=False):
+    result = fetch_codex_rate_limit_diagnostic(
         session,
         timeout=timeout,
         popen_factory=popen_factory,
     )
-    return diagnostic.get("status") if diagnostic.get("ok") else None
+    if result.get("ok"):
+        return result.get("status")
+    if diagnostic:
+        reason = "login_expired" if diagnostic_needs_codex_login(result) else result.get("reason")
+        return {"_quota_error": reason or "probe_failed"}
+    return None
 
 
 def consume_codex_rate_limit_reset_credit(session, idempotency_key, credit_id=None, timeout=5, popen_factory=None):

package/src/commands/backup.py

@@ -103,12 +103,15 @@ def handle_import(rest, ctx):
     payload = _json_success(
         "import",
         message,
+        warnings=result.get("status_line_warnings", []),
         bundle=result,
     )
     if parsed["json"]:
         _write_json(ctx, payload)
         return 0
     ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    for warning in result.get("status_line_warnings", []):
+        ctx["out"](f"{warning}\n")
     retained = result.get("retained_local_credentials") or []
     if retained:
         # Merge keeps local values, so say which sessions kept their own login

package/src/commands/launch.py

@@ -308,6 +308,13 @@ def handle_launch(command, ctx, initial_prompt=None, resume=False, force_json=No
     if not json_flag:
         ctx["out"](f"{_info(message, ctx['use_color'])}\n")
         _write_update_notice(ctx)
+    from ..claude_status_line import provision as provision_status_line
+
+    status_line_notice = provision_status_line(session, ctx["service"]["base_dir"])
+    if status_line_notice:
+        warnings.append(status_line_notice)
+        if not json_flag:
+            ctx["out"](f"{status_line_notice}\n")
     alerts_allowed = _notification_provisioning_enabled(session, ctx, json_flag)
     keep_state = agent_state_enabled(session)
     installed = provision(

package/src/commands/lifecycle.py

@@ -3,6 +3,7 @@
 Split out of cli_commands.py. Moved verbatim; re-exported by cli_commands.
 """
 
+from ..claude_status_line import provision as provision_status_line
 from ..cli_args import (
     _parse_add_args,
     _parse_copy_args,
@@ -70,6 +71,7 @@ def handle_copy(rest, ctx):
     json_flag, args = _parse_json_flag(rest)
     parsed = _parse_copy_args(args)
     result = ctx["service"]["copy_session"](parsed["source"], parsed["dest"])
+    warning = provision_status_line(result["session"], ctx["service"]["base_dir"])
     overwritten = " (overwritten)" if result["overwritten"] else ""
     message = f"Copied session {parsed['source']} to {parsed['dest']}{overwritten}"
     if json_flag:
@@ -78,20 +80,26 @@ def handle_copy(rest, ctx):
             message,
             session=result["session"],
             overwritten=result["overwritten"],
+            warnings=[warning] if warning else [],
         ))
         return 0
     ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    if warning:
+        ctx["out"](f"{warning}\n")
     return 0
 
 def handle_rename(rest, ctx):
     json_flag, args = _parse_json_flag(rest)
     parsed = _parse_rename_args(args)
     session = ctx["service"]["rename_session"](parsed["source"], parsed["dest"])
+    warning = provision_status_line(session, ctx["service"]["base_dir"])
     message = f"Renamed session {parsed['source']} to {parsed['dest']}"
     if json_flag:
-        _write_json(ctx, _json_success("rename", message, session=session))
+        _write_json(ctx, _json_success("rename", message, session=session, warnings=[warning] if warning else []))
         return 0
     ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    if warning:
+        ctx["out"](f"{warning}\n")
     return 0
 
 def handle_label(rest, ctx):

package/src/commands/settings.py

@@ -4,6 +4,7 @@ Split out of cli_commands.py. Moved verbatim; re-exported by cli_commands.
 """
 
 from ..agent_notify import supports_agent_alerts
+from ..claude_status_line import provision as provision_status_line
 from ..cli_args import _parse_launch_setting_alias_args, _parse_set_args, _parse_unset_args
 from ..cli_helpers import _format_launch_config, _json_success, _write_json
 from ..cli_render import _success
@@ -70,6 +71,7 @@ def _apply_launch_settings(parsed, ctx, action="set"):
         ctx["service"]["set_launch_settings"](session["name"], parsed["settings"])
         for session in targets
     ]
+    warnings = [notice for session in sessions if (notice := provision_status_line(session, ctx["service"]["base_dir"]))]
     if len(sessions) == 1:
         session = sessions[0]
         message = f"Updated launch settings for {session['name']}"
@@ -80,6 +82,7 @@ def _apply_launch_settings(parsed, ctx, action="set"):
             action,
             message,
             updated_count=len(sessions),
+            warnings=warnings,
             session=sessions[0] if len(sessions) == 1 else None,
             sessions=sessions,
             launch=sessions[0].get("launch") or {} if len(sessions) == 1 else None,
@@ -87,6 +90,8 @@ def _apply_launch_settings(parsed, ctx, action="set"):
         _write_json(ctx, payload)
         return 0
     ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    for warning in warnings:
+        ctx["out"](f"{warning}\n")
     notice = _notification_setting_notice(parsed["settings"], sessions, action)
     if notice:
         ctx["out"](f"{notice}\n")
@@ -100,6 +105,7 @@ def _clear_launch_settings(parsed, ctx, action="unset"):
         ctx["service"]["unset_launch_settings"](session["name"], parsed["keys"])
         for session in targets
     ]
+    warnings = [notice for session in sessions if (notice := provision_status_line(session, ctx["service"]["base_dir"]))]
     if len(sessions) == 1:
         session = sessions[0]
         message = f"Cleared launch settings for {session['name']}"
@@ -110,6 +116,7 @@ def _clear_launch_settings(parsed, ctx, action="unset"):
             action,
             message,
             updated_count=len(sessions),
+            warnings=warnings,
             session=sessions[0] if len(sessions) == 1 else None,
             sessions=sessions,
             launch=sessions[0].get("launch") or {} if len(sessions) == 1 else None,
@@ -117,6 +124,8 @@ def _clear_launch_settings(parsed, ctx, action="unset"):
         _write_json(ctx, payload)
         return 0
     ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    for warning in warnings:
+        ctx["out"](f"{warning}\n")
     notice = _notification_setting_notice({key: False for key in parsed["keys"]}, sessions, action)
     if notice:
         ctx["out"](f"{notice}\n")

package/src/commands/status.py

@@ -51,6 +51,7 @@ from ..provider_runtime import (
     _has_local_claude_auth,
     _probe_provider_auth_status,
 )
+from ..quota_provenance import mark_quota_unavailable
 from ..rtk_savings import rtk_saved
 from ..run_usage import (
     TOKEN_USAGE_KEYS,
@@ -856,6 +857,8 @@ def handle_status(rest, ctx):
         }
         for item in refresh_result.get("errors", [])
     ]
+    quota_errors = {item["session"]: item.get("reason") or "quota_read_failed" for item in refresh_result.get("errors", [])}
+    quota_errors.update({item["session"]: "auth_probe_failed" for item in auth_refresh.get("errors", [])})
     status_progress = None if parsed["json"] else _make_status_progress(ctx)
     if len(args) == 1:
         row = ctx["service"]["get_status_row"](
@@ -865,6 +868,8 @@ def handle_status(rest, ctx):
             cache_only=parsed["cached"],
             status_timeout_seconds=parsed["timeout"],
         )
+        if row.get("session_name") in quota_errors:
+            mark_quota_unavailable(row, quota_errors[row["session_name"]])
         output_warnings = [
             *warnings,
             *_refresh_warning_payloads(refresh_errors, [row]),
@@ -885,6 +890,9 @@ def handle_status(rest, ctx):
         cache_only=parsed["cached"],
         status_timeout_seconds=parsed["timeout"],
     )
+    for row in rows:
+        if row.get("session_name") in quota_errors:
+            mark_quota_unavailable(row, quota_errors[row["session_name"]])
     output_warnings = [
         *warnings,
         *_refresh_warning_payloads(refresh_errors, rows),

package/src/conversation.py

@@ -66,6 +66,8 @@ _CLAUDE_HARNESS = re.compile(
     r"\s*(?:<(?P<tag>task-notification|local-command-stdout|local-command-stderr|command-name|command-message|command-args|system-reminder)>"
     r"(?:(?!</(?P=tag)>).)*</(?P=tag)>\s*)+", re.S,
 )
+# Claude Code wraps long pasted text in matching tags; show only the pasted text.
+_CLAUDE_PASTED = re.compile(r'<pasted_content id="([0-9A-Za-z]{1,32})">\n?(.*?)\n?</pasted_content id="\1">', re.S)
 _CLAUDE_MID_TURN_START = "The user sent a new message while you were working:\n"
 _CLAUDE_MID_TURN_END = re.compile(
     r"\n+This is how Claude Code surfaces messages the user sends mid-turn[^\n]*"
@@ -81,6 +83,8 @@ def _claude_user_content(content):
     blocks = [dict(block) if isinstance(block, dict) else block for block in blocks]
     texts = [block for block in blocks if isinstance(block, dict)
              and block.get("type") == "text" and isinstance(block.get("text"), str)]
+    for block in texts:
+        block["text"] = _CLAUDE_PASTED.sub(r"\2", block["text"])
     # Require both anchored boundaries; a quoted sentence alone is user content.
     if texts and texts[0]["text"].startswith(_CLAUDE_MID_TURN_START):
         end = _CLAUDE_MID_TURN_END.search(texts[-1]["text"])

package/src/quota_gauge.txt

@@ -0,0 +1,2 @@
+████████
+▁▁▁▁▁▁▁▁

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