cdx-manager 0.5.4 → 0.5.6

package/README.md

@@ -1,6 +1,6 @@
 # CDX Manager
 
-[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.5.4-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.5.6-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
 
 **Run multiple Codex and Claude sessions from one terminal. Switch between accounts instantly.**
 
@@ -35,7 +35,7 @@ One command to launch any session. Zero auth juggling.
 - **Multiple accounts, one tool.** Register as many Codex or Claude sessions as you need. Each one gets its own isolated auth environment — no cross-contamination between accounts.
 - **Instant launch.** `cdx work` opens your "work" session. `cdx personal` opens another. No config files to edit mid-flow.
 - **Auth guardrails.** `cdx` checks authentication before launching. If a session is not logged in, it tells you exactly what to run — no silent failures.
-- **Usage at a glance.** `cdx status` shows token usage, 5-hour window quota, weekly quota, and last-updated timestamps for every session in one aligned table.
+- **Usage at a glance.** `cdx status` shows token usage, 5-hour window quota, weekly quota, last-updated timestamps, priority guidance, and the last launched session in one aligned table.
 - **Session control.** Disable a session without deleting it when an account is temporarily out of credits; disabled sessions remain visible and sort last.
 - **Shared handoff context.** Keep a per-workspace Markdown context, or build one from a source session transcript, and install it into another assistant session before switching providers or accounts.
 - **Passive status resolution.** Codex status is read from the local Codex app-server rate-limit API when available, with legacy transcript/history parsing kept as a fallback.
@@ -126,7 +126,7 @@ For a specific version:
 
 ```bash
 curl -fsSL https://raw.githubusercontent.com/AlexAgo83/cdx-manager/main/install.sh -o install.sh
-CDX_VERSION=v0.5.4 sh install.sh
+CDX_VERSION=v0.5.6 sh install.sh
 ```
 
 From source:
@@ -258,8 +258,8 @@ cdx status
 | `cdx doctor [--json]` | Inspect CLI dependencies, CDX_HOME permissions, missing state, orphan profiles, and pending quarantines |
 | `cdx repair [--dry-run] [--force] [--json]` | Plan or apply safe repairs for missing state files, quarantines, and orphan profiles |
 | `cdx update [--check] [--yes] [--json] [--version TAG]` | Update cdx-manager using the installer that matches how it was installed |
-| `cdx notify <name> --at-reset [--poll seconds] [--once] [--json]` | Wait for a session reset time and send a desktop notification when due |
-| `cdx notify --next-ready [--poll seconds] [--once] [--json]` | Wait until the recommended session is usable or needs a refresh after reset |
+| `cdx notify <name> --at-reset [--poll seconds] [--once] [--refresh] [--json]` | Wait for a session reset time and send a desktop notification when due |
+| `cdx notify --next-ready [--poll seconds] [--once] [--refresh] [--json]` | Wait until the recommended session is usable or needs a refresh after reset |
 | `cdx status [--json] [--refresh]` | Show token usage table for all sessions; JSON returns a versioned payload with structured warnings |
 | `cdx status --small [--refresh]` / `cdx status -s [--refresh]` | Show compact token usage table without provider, blocking quota, credits, and updated columns |
 | `cdx status <name> [--json] [--refresh]` | Show detailed usage breakdown for one session |
@@ -349,7 +349,7 @@ cdx import backup-auth.cdx --passphrase-env CDX_BUNDLE_PASSPHRASE
 
 Notes:
 
-- `--include-auth` is encrypted and requires a passphrase.
+- `--include-auth` is encrypted, requires a passphrase, and exports only provider credential files rather than full profile caches or logs.
 - Without `--passphrase-env`, `cdx` prompts in an interactive terminal.
 - `--sessions work,perso` exports or imports only a subset.
 - `--force` allows overwriting existing destination sessions during import or replacing an existing bundle file during export.

package/changelogs/CHANGELOGS_0_5_5.md

@@ -0,0 +1,48 @@
+# Changelog (`0.5.4 -> 0.5.5`)
+
+Release date: 2026-05-24
+
+## Major Highlights
+
+- Fixed Claude usage probing for OAuth credentials by using bearer-token authentication.
+- Improved `cdx status` guidance with progress output, conservative reset timing, near-empty account handling, and last-launched session context.
+- Made encrypted auth exports lightweight by backing up provider credential files instead of full profile caches, logs, and runtime artifacts.
+
+## Usage and Status
+
+- Added progress output while `cdx status` resolves session statuses in text mode, while keeping `--json` output clean.
+- Added a `Current:` line under the priority recommendation showing the last launched session, useful before running a handoff.
+- Removed the older status tip line now that status output carries actionable priority and current-session context.
+- Treated sessions with `5%` or less availability as empty for priority recommendations, while preserving the true percentage in the table.
+- Added a conservative one-minute reset countdown margin so users are less likely to switch back before a reset is usable.
+
+## Claude Usage Handling
+
+- Fixed the Claude rate-limit probe to send OAuth access tokens as `Authorization: Bearer ...`.
+- Surfaced Claude HTTP failures without rate-limit headers as structured refresh warnings, including API error text when available.
+- Preserved existing fallback behavior for unavailable network probes and historical status data.
+
+## Export and Backup
+
+- Limited `cdx export --include-auth` to provider credential files:
+  - Codex: `auth.json`
+  - Claude: `claude-home/.claude/.credentials.json`, `claude-home/.claude.json`, and legacy `claude-home/auth.json`
+- Excluded profile caches, logs, SQLite usage databases, temporary files, and provider runtime artifacts from auth bundles.
+- Added export progress output in text mode and a final summary with bundle size, auth file count, and auth data size.
+- Kept `cdx export --json` clean and added bundle metrics to its JSON payload.
+
+## Documentation
+
+- Updated package metadata, CLI version output, README badge, and pinned installer example to `v0.5.5`.
+- Clarified that encrypted auth exports include credential files rather than full profile caches or logs.
+
+## Validation and Regression Coverage
+
+- Added regression coverage for Claude HTTP failures without usage headers.
+- Added status rendering tests for progress output, last-launched context, near-empty priority handling, and removed tip text.
+- Added export/import tests proving auth bundles exclude non-auth profile files such as `logs_2.sqlite`.
+
+## Validation and Regression Evidence
+
+- `python3 -m pytest test/test_cli_py.py test/test_session_service_py.py`
+- `python3 -m pytest test/test_runtime_py.py test/test_cli_py.py test/test_status_source_py.py`

package/changelogs/CHANGELOGS_0_5_6.md

@@ -0,0 +1,42 @@
+# Changelog (`0.5.5 -> 0.5.6`)
+
+Release date: 2026-05-24
+
+## Major Highlights
+
+- Reduced noisy `cdx status` progress output by respecting fresh cached status rows.
+- Stopped probing disabled sessions during status resolution and hid stale quota metrics for disabled rows.
+- Refined `cdx notify --next-ready` so it waits for the next blocked account reset instead of notifying for an account that is already usable.
+
+## Status Output
+
+- Added status-row cache handling so recently resolved rows do not print redundant `Checking ...` progress lines.
+- Kept Claude status cache behavior aligned with the Claude refresh TTL, avoiding unnecessary Claude checks while cached usage is still fresh.
+- Treated disabled sessions as display-only in `cdx status`; disabled sessions remain visible but are not refreshed or re-read from status artifacts.
+- Rendered disabled-session quota columns as `-` for `OK`, `5H`, `WEEK`, `BLOCK`, `CR`, `RESET 5H`, and `RESET WEEK`.
+- Preserved the stored last status internally so re-enabled sessions can resume normal status behavior.
+
+## Notifications
+
+- Added `--refresh` support to `cdx notify` so notification checks can force status refreshes when requested.
+- Added text-mode progress output for notification checks while keeping `--json` output clean.
+- Made `cdx notify --next-ready` ignore disabled sessions.
+- Made `cdx notify --next-ready` ignore sessions that are already usable and instead target the next currently blocked session with a known reset.
+- Returned `No upcoming session reset available` when there is no blocked session with a reset to wait for.
+
+## Documentation
+
+- Updated package metadata, CLI version output, README badge, and pinned installer example to `v0.5.6`.
+- Documented `--refresh` for `cdx notify` command examples.
+
+## Validation and Regression Coverage
+
+- Added regression coverage for cached Codex status rows suppressing redundant checking progress.
+- Added regression coverage for Claude cache TTL behavior.
+- Added regression coverage for disabled sessions skipping refresh and hiding public status metrics.
+- Added regression coverage for `notify --next-ready` ignoring already-available and disabled sessions.
+
+## Validation and Regression Evidence
+
+- `npm run test:py`
+- `./bin/cdx status`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "Terminal session manager for Codex and Claude accounts.",
   "license": "MIT",
   "author": "Alexandre Agostini",
@@ -25,6 +25,8 @@
   },
   "files": [
     "bin",
+    "!bin/__pycache__",
+    "!bin/**/*.pyc",
     "checksums",
     "changelogs",
     "src",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cdx-manager"
-version = "0.5.4"
+version = "0.5.6"
 description = "Terminal session manager for Codex and Claude accounts."
 readme = "README.md"
 requires-python = ">=3.9"

package/src/claude_usage.py

@@ -4,6 +4,8 @@ import urllib.request
 import urllib.error
 from datetime import datetime, timezone
 
+from .errors import CdxError
+
 MONTH_ABBR = ["Jan", "Feb", "Mar", "Apr", "May", "Jun",
               "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
 CLAUDE_STATUS_PROBE_MODEL = os.environ.get("CDX_CLAUDE_STATUS_MODEL", "claude-haiku-4-5-20251001")
@@ -24,6 +26,29 @@ def _format_reset_date(unix_seconds):
     return f"{MONTH_ABBR[dt.month - 1]} {dt.day} {str(dt.hour).zfill(2)}:{str(dt.minute).zfill(2)}"
 
 
+def _read_http_error_message(error):
+    try:
+        body = error.read().decode("utf-8", errors="replace")
+    except (AttributeError, OSError, UnicodeDecodeError):
+        body = ""
+    if not body:
+        return ""
+    try:
+        payload = json.loads(body)
+    except json.JSONDecodeError:
+        return body.strip()
+    detail = payload.get("error") if isinstance(payload, dict) else None
+    if isinstance(detail, dict):
+        message = detail.get("message") or detail.get("type")
+        if message:
+            return str(message)
+    if isinstance(payload, dict):
+        message = payload.get("message") or payload.get("detail")
+        if message:
+            return str(message)
+    return body.strip()
+
+
 def fetch_claude_rate_limit_headers(access_token):
     body = json.dumps({
         "model": CLAUDE_STATUS_PROBE_MODEL,
@@ -35,7 +60,7 @@ def fetch_claude_rate_limit_headers(access_token):
         "https://api.anthropic.com/v1/messages",
         data=body,
         headers={
-            "x-api-key": access_token,
+            "Authorization": f"Bearer {access_token}",
             "anthropic-version": "2023-06-01",
             "content-type": "application/json",
         },
@@ -47,6 +72,13 @@ def fetch_claude_rate_limit_headers(access_token):
             headers = {k.lower(): v for k, v in resp.getheaders()}
     except urllib.error.HTTPError as e:
         headers = {k.lower(): v for k, v in e.headers.items()}
+        if (
+            "anthropic-ratelimit-unified-5h-utilization" not in headers
+            and "anthropic-ratelimit-unified-7d-utilization" not in headers
+        ):
+            message = _read_http_error_message(e)
+            suffix = f": {message}" if message else ""
+            raise CdxError(f"Claude usage unavailable (HTTP {e.code}{suffix})") from e
     except urllib.error.URLError:
         return None
 

package/src/cli.py

@@ -49,7 +49,7 @@ from .status_view import (
 )
 from .update_check import check_for_update
 
-VERSION = "0.5.4"
+VERSION = "0.5.6"
 
 
 # ---------------------------------------------------------------------------
@@ -83,8 +83,8 @@ def _print_help(use_color=False):
         f"  {_style('cdx doctor [--json]', '36', use_color)}",
         f"  {_style('cdx repair [--dry-run] [--force] [--json]', '36', use_color)}",
         f"  {_style('cdx update [--check] [--yes] [--json] [--version TAG]', '36', use_color)}",
-        f"  {_style('cdx notify <name> --at-reset [--json]', '36', use_color)}",
-        f"  {_style('cdx notify --next-ready [--json]', '36', use_color)}",
+        f"  {_style('cdx notify <name> --at-reset [--refresh] [--json]', '36', use_color)}",
+        f"  {_style('cdx notify --next-ready [--refresh] [--json]', '36', use_color)}",
         f"  {_style('cdx <name> [--json]', '36', use_color)}",
         f"  {_style('cdx --help', '36', use_color)}",
         f"  {_style('cdx --version', '36', use_color)}",

package/src/cli_commands.py

@@ -69,6 +69,95 @@ def _write_json(ctx, payload):
     ctx["out"](f"{json.dumps(payload, indent=2)}\n")
 
 
+def _format_bytes(value):
+    if value is None:
+        return "n/a"
+    try:
+        amount = float(value)
+    except (TypeError, ValueError):
+        return str(value)
+    units = ["B", "KB", "MB", "GB", "TB"]
+    unit = units[0]
+    for unit in units:
+        if amount < 1024 or unit == units[-1]:
+            break
+        amount /= 1024
+    if unit == "B":
+        return f"{int(amount)} B"
+    return f"{amount:.1f} {unit}"
+
+
+def _format_export_report(result):
+    lines = [
+        f"Path: {result['path']}",
+        f"Sessions: {', '.join(result['session_names']) or '-'}",
+        f"Auth: {'included and encrypted' if result['include_auth'] else 'not included'}",
+        f"Bundle size: {_format_bytes(result.get('bundle_size_bytes'))}",
+    ]
+    if result.get("include_auth"):
+        lines.extend([
+            f"Auth files: {result.get('profile_file_count', 0)}",
+            f"Auth data: {_format_bytes(result.get('profile_bytes'))}",
+        ])
+    return "\n".join(lines)
+
+
+def _make_export_progress(ctx):
+    def progress(event):
+        kind = event.get("event")
+        if kind == "export_started":
+            auth = " with auth" if event.get("include_auth") else ""
+            message = f"Exporting {event.get('session_count', 0)} session(s){auth}..."
+            ctx["out"](f"{_info(message, ctx['use_color'])}\n")
+        elif kind == "session_started":
+            message = f"Collecting {event.get('session_name')}..."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+        elif kind == "profile_progress":
+            message = f"  {event.get('session_name')}: {event.get('file_count', 0)} files, {_format_bytes(event.get('bytes'))}"
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+        elif kind == "encoding_started":
+            ctx["out"](f"{_dim('Encoding and encrypting bundle...', ctx['use_color'])}\n")
+        elif kind == "writing_started":
+            message = f"Writing {_format_bytes(event.get('bundle_size_bytes'))}..."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+    return progress
+
+
+def _make_status_progress(ctx):
+    def progress(event):
+        kind = event.get("event")
+        if kind == "status_started":
+            message = f"Resolving status for {event.get('session_count', 0)} session(s)..."
+            ctx["out"](f"{_info(message, ctx['use_color'])}\n")
+        elif kind == "session_started":
+            provider = event.get("provider") or "session"
+            message = f"Checking {event.get('session_name')} ({provider})..."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+        elif kind == "status_finished":
+            message = f"Resolved {event.get('row_count', 0)} status row(s)."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+    return progress
+
+
+def _make_notify_progress(ctx):
+    def progress(event):
+        kind = event.get("event")
+        if kind == "notify_check_started":
+            target = event.get("session_name") or "next ready session"
+            ctx["out"](f"{_info(f'Checking notification target: {target}...', ctx['use_color'])}\n")
+        elif kind == "status_started":
+            message = f"Loading status for {event.get('session_count', 0)} session(s)..."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+        elif kind == "session_started":
+            provider = event.get("provider") or "session"
+            message = f"Checking {event.get('session_name')} ({provider})..."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+        elif kind == "notify_waiting":
+            message = f"{event.get('message')}; checking again in {event.get('poll')}s..."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+    return progress
+
+
 def _latest_launch_transcript_path(session):
     paths = _list_launch_transcript_paths(session)
     if not paths:
@@ -556,6 +645,7 @@ def handle_notify(rest, ctx):
         notifier=notifier,
         sleep_fn=ctx["options"].get("sleep"),
         now_fn=ctx["options"].get("now"),
+        progress_callback=None if parsed["json"] else _make_notify_progress(ctx),
     )
     if parsed["json"]:
         _write_json(ctx, _json_success("notify", "Resolved notification event", event=event))
@@ -696,7 +786,11 @@ def handle_status(rest, ctx):
         for item in refresh_errors
     ]
 
-    rows = ctx["service"]["get_status_rows"]()
+    status_progress = None if parsed["json"] else _make_status_progress(ctx)
+    rows = ctx["service"]["get_status_rows"](
+        progress_callback=status_progress,
+        force_refresh=parsed["refresh"],
+    )
     if len(args) == 0:
         if parsed["json"]:
             _write_json(ctx, _json_success("status", "Collected session status rows", warnings=warnings, rows=rows))
@@ -740,6 +834,7 @@ def handle_export(rest, ctx):
         session_names=parsed["session_names"],
         passphrase=passphrase,
         force=parsed["force"],
+        progress_callback=None if parsed["json"] else _make_export_progress(ctx),
     )
     session_count = len(result["session_names"])
     auth_suffix = " with auth" if result["include_auth"] else ""
@@ -753,6 +848,7 @@ def handle_export(rest, ctx):
         _write_json(ctx, payload)
         return 0
     ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    ctx["out"](f"{_format_export_report(result)}\n")
     return 0
 
 
@@ -961,9 +1057,6 @@ def handle_launch(command, ctx, initial_prompt=None):
             if update_notice.get("url"):
                 text = f"{text} {update_notice['url']}"
             ctx["out"](f"{_warn(text, ctx['use_color'])}\n")
-    if session["provider"] == PROVIDER_CODEX:
-        if not json_flag:
-            ctx["out"](f"{_dim('Tip: cdx status reads Codex rate limits from the local app-server when available.', ctx['use_color'])}\n")
     _run_interactive_provider_command(
         session, "launch", spawn=ctx.get("spawn"), env_override=ctx.get("env"),
         signal_emitter=ctx.get("signal_emitter"), initial_prompt=initial_prompt,

package/src/notify.py

@@ -4,7 +4,12 @@ import subprocess
 import time
 
 from .errors import CdxError
-from .status_view import _parse_reset_timestamp, _recommend_priority_sessions
+from .status_view import (
+    PRIORITY_EMPTY_AVAILABLE_THRESHOLD,
+    _parse_reset_timestamp,
+    _priority_reset_timestamp,
+    _recommend_priority_sessions,
+)
 
 
 def parse_notify_args(args):
@@ -12,17 +17,18 @@ def parse_notify_args(args):
     once = "--once" in args
     at_reset = "--at-reset" in args
     next_ready = "--next-ready" in args
+    refresh = "--refresh" in args
     poll = 60
     cleaned = []
     i = 0
     while i < len(args):
         arg = args[i]
-        if arg in ("--json", "--once", "--at-reset", "--next-ready"):
+        if arg in ("--json", "--once", "--at-reset", "--next-ready", "--refresh"):
             i += 1
             continue
         if arg == "--poll":
             if i + 1 >= len(args):
-                raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] | cdx notify --next-ready [--poll seconds] [--once]")
+                raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] [--refresh] | cdx notify --next-ready [--poll seconds] [--once] [--refresh]")
             try:
                 poll = max(1, int(args[i + 1]))
             except ValueError as error:
@@ -37,48 +43,68 @@ def parse_notify_args(args):
             i += 1
             continue
         if arg.startswith("-"):
-            raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] | cdx notify --next-ready [--poll seconds] [--once]")
+            raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] [--refresh] | cdx notify --next-ready [--poll seconds] [--once] [--refresh]")
         cleaned.append(arg)
         i += 1
     if at_reset == next_ready:
-        raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] | cdx notify --next-ready [--poll seconds] [--once]")
+        raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] [--refresh] | cdx notify --next-ready [--poll seconds] [--once] [--refresh]")
     if at_reset and len(cleaned) != 1:
-        raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once]")
+        raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] [--refresh]")
     if next_ready and cleaned:
-        raise CdxError("Usage: cdx notify --next-ready [--poll seconds] [--once]")
+        raise CdxError("Usage: cdx notify --next-ready [--poll seconds] [--once] [--refresh]")
     return {
         "name": cleaned[0] if cleaned else None,
         "mode": "at-reset" if at_reset else "next-ready",
         "poll": poll,
         "once": once,
         "json": json_flag,
+        "refresh": refresh,
     }
 
 
-def wait_for_notification_event(service, parsed, notifier=None, sleep_fn=None, now_fn=None):
+def wait_for_notification_event(service, parsed, notifier=None, sleep_fn=None, now_fn=None, progress_callback=None):
     notifier = notifier or send_desktop_notification
     sleep_fn = sleep_fn or time.sleep
     now_fn = now_fn or time.time
     while True:
-        event = resolve_notify_event(service["get_status_rows"](), parsed, now_fn())
+        if progress_callback:
+            progress_callback({"event": "notify_check_started", "mode": parsed["mode"], "session_name": parsed["name"]})
+        event = resolve_notify_event(
+            service["get_status_rows"](
+                progress_callback=progress_callback,
+                force_refresh=parsed.get("refresh", False),
+            ),
+            parsed,
+            now_fn(),
+        )
         if event["ready"] or parsed["once"]:
             if event["ready"]:
                 notifier(event["title"], event["message"])
             return event
+        if progress_callback:
+            progress_callback({
+                "event": "notify_waiting",
+                "message": event["message"],
+                "poll": parsed["poll"],
+                "session_name": event.get("session"),
+                "target_timestamp": event.get("target_timestamp"),
+            })
         sleep_fn(parsed["poll"])
 
 
 def resolve_notify_event(rows, parsed, now_ts=None):
     now_ts = time.time() if now_ts is None else now_ts
     if parsed["mode"] == "next-ready":
-        priority = _recommend_priority_sessions(rows)
+        active_rows = [row for row in rows if row.get("enabled", True) is not False]
+        priority = _recommend_priority_sessions([
+            row for row in active_rows
+            if not _is_usable_now(row) and _priority_reset_timestamp(row) is not None
+        ])
         if not priority:
-            return _event(False, "cdx", "No session status available", None)
+            return _event(False, "cdx", "No upcoming session reset available", None)
         first = priority[0]
-        if _is_available(first):
-            return _event(True, "cdx", f"{first['session_name']} is ready", first["session_name"])
-        timestamp = _next_reset_timestamp(first)
-        if timestamp is not None and timestamp <= now_ts:
+        timestamp = _priority_reset_timestamp(first)
+        if _needs_refresh(first, timestamp, now_ts):
             return _event(True, "cdx", f"{first['session_name']} reset is due; refresh status", first["session_name"])
         return _event(False, "cdx", f"Waiting for {first['session_name']}", first["session_name"], timestamp)
 
@@ -93,9 +119,16 @@ def resolve_notify_event(rows, parsed, now_ts=None):
     return _event(False, "cdx", f"Waiting for {row['session_name']} reset", row["session_name"], timestamp)
 
 
-def _is_available(row):
+def _is_usable_now(row):
+    value = row.get("available_pct")
+    return value is not None and value > PRIORITY_EMPTY_AVAILABLE_THRESHOLD
+
+
+def _needs_refresh(row, reset_timestamp, now_ts):
     value = row.get("available_pct")
-    return value is not None and value > 0
+    if value is None or value > PRIORITY_EMPTY_AVAILABLE_THRESHOLD:
+        return False
+    return reset_timestamp is not None and reset_timestamp < now_ts
 
 
 def _next_reset_timestamp(row):

package/src/session_service.py

@@ -45,6 +45,8 @@ RESERVED_SESSION_NAMES = {
     "--version",
     "-v",
 }
+STATUS_CACHE_TTL_SECONDS = 60
+CLAUDE_STATUS_CACHE_TTL_SECONDS = 10 * 60
 
 
 def _encode(name):
@@ -133,6 +135,24 @@ def _parse_status_timestamp(value):
         return None
 
 
+def _status_cache_ttl_seconds(session, ttl_seconds=STATUS_CACHE_TTL_SECONDS):
+    if session.get("provider") == PROVIDER_CLAUDE and ttl_seconds == STATUS_CACHE_TTL_SECONDS:
+        return CLAUDE_STATUS_CACHE_TTL_SECONDS
+    return ttl_seconds
+
+
+def _is_status_cache_fresh(session, ttl_seconds=STATUS_CACHE_TTL_SECONDS):
+    status = session.get("lastStatus") or {}
+    if _is_low_confidence_status_source(status):
+        return False
+    updated_at = _parse_status_timestamp(status.get("updated_at") or session.get("lastStatusAt"))
+    if not updated_at:
+        return False
+    now = datetime.now(timezone.utc).astimezone()
+    ttl_seconds = _status_cache_ttl_seconds(session, ttl_seconds)
+    return (now - updated_at.astimezone(now.tzinfo)).total_seconds() < ttl_seconds
+
+
 def _is_status_newer(candidate, current):
     if not candidate:
         return False
@@ -295,22 +315,39 @@ def create_session_service(options=None):
             "auth": session.get("auth"),
         }
 
-    def _collect_profile_files(session_root):
-        excluded_dirs = {"log", "tmp", "cache", "__pycache__", "shell_snapshots"}
+    def _auth_bundle_paths(provider):
+        if provider == PROVIDER_CLAUDE:
+            return [
+                "claude-home/.claude/.credentials.json",
+                "claude-home/.claude.json",
+                "claude-home/auth.json",
+            ]
+        return [
+            "auth.json",
+        ]
+
+    def _collect_auth_files(session_root, provider, session_name=None, progress_callback=None):
         files = []
+        total_bytes = 0
         if not os.path.isdir(session_root):
-            return files
-        for dirpath, dirnames, filenames in os.walk(session_root):
-            dirnames[:] = [name for name in dirnames if name not in excluded_dirs]
-            for filename in filenames:
-                full_path = os.path.join(dirpath, filename)
-                if not os.path.isfile(full_path):
-                    continue
-                rel_path = os.path.relpath(full_path, session_root)
-                with open(full_path, "rb") as handle:
-                    content = base64.b64encode(handle.read()).decode("ascii")
-                files.append({"path": rel_path.replace(os.sep, "/"), "data_b64": content})
-        return files
+            return {"files": files, "file_count": 0, "bytes": 0}
+        for rel_path in _auth_bundle_paths(provider):
+            full_path = os.path.join(session_root, rel_path)
+            if not os.path.isfile(full_path):
+                continue
+            with open(full_path, "rb") as handle:
+                raw_content = handle.read()
+                total_bytes += len(raw_content)
+                content = base64.b64encode(raw_content).decode("ascii")
+            files.append({"path": rel_path.replace(os.sep, "/"), "data_b64": content})
+            if progress_callback:
+                progress_callback({
+                    "event": "profile_progress",
+                    "session_name": session_name,
+                    "file_count": len(files),
+                    "bytes": total_bytes,
+                })
+        return {"files": files, "file_count": len(files), "bytes": total_bytes}
 
     def _resolve_session_subset(session_names):
         if not session_names:
@@ -555,8 +592,12 @@ def create_session_service(options=None):
             raise CdxError(f"Unknown session: {name}")
         return updated
 
-    def _resolve_session_status(session):
+    def _resolve_session_status(session, force_refresh=False, cache_ttl_seconds=STATUS_CACHE_TTL_SECONDS):
         current_status = session.get("lastStatus")
+        if session.get("enabled", True) is False:
+            return current_status
+        if current_status and not force_refresh and _is_status_cache_fresh(session, ttl_seconds=cache_ttl_seconds):
+            return current_status
         source_root = session.get("authHome") or _get_session_auth_home(
             session["name"], session["provider"]
         )
@@ -627,11 +668,40 @@ def create_session_service(options=None):
             raise CdxError(f"Unknown session: {name}")
         return updated
 
-    def get_status_rows():
+    def get_status_rows(progress_callback=None, force_refresh=False, cache_ttl_seconds=STATUS_CACHE_TTL_SECONDS):
         sessions = list_sessions()
+        if progress_callback:
+            progress_callback({
+                "event": "status_started",
+                "session_count": len(sessions),
+            })
         resolved = []
         for s in sessions:
-            status = _resolve_session_status(s)
+            cache_hit = (
+                s.get("enabled", True) is False
+                or (
+                    s.get("lastStatus")
+                    and not force_refresh
+                    and _is_status_cache_fresh(s, ttl_seconds=cache_ttl_seconds)
+                )
+            )
+            if progress_callback and not cache_hit:
+                progress_callback({
+                    "event": "session_started",
+                    "session_name": s["name"],
+                    "provider": s["provider"],
+                })
+            status = _resolve_session_status(
+                s,
+                force_refresh=force_refresh,
+                cache_ttl_seconds=cache_ttl_seconds,
+            )
+            if progress_callback:
+                progress_callback({
+                    "event": "session_finished",
+                    "session_name": s["name"],
+                    "has_status": bool(status),
+                })
             resolved.append({
                 **s,
                 "lastStatus": status,
@@ -653,19 +723,27 @@ def create_session_service(options=None):
         rows = []
         for s in resolved:
             status = s.get("lastStatus")
+            enabled = s.get("enabled", True) is not False
+            row_status = status if enabled else None
             rows.append({
                 "session_name": s["name"],
                 "provider": s["provider"],
-                "enabled": s.get("enabled", True) is not False,
-                "status": "disabled" if s.get("enabled", True) is False else "enabled",
-                "remaining_5h_pct": status.get("remaining_5h_pct") if status else None,
-                "remaining_week_pct": status.get("remaining_week_pct") if status else None,
-                "credits": status.get("credits") if status else None,
-                "available_pct": _compute_available_pct(status),
-                "reset_5h_at": status.get("reset_5h_at") if status else None,
-                "reset_week_at": status.get("reset_week_at") if status else None,
-                "reset_at": status.get("reset_at") if status else None,
+                "enabled": enabled,
+                "status": "enabled" if enabled else "disabled",
+                "remaining_5h_pct": row_status.get("remaining_5h_pct") if row_status else None,
+                "remaining_week_pct": row_status.get("remaining_week_pct") if row_status else None,
+                "credits": row_status.get("credits") if row_status else None,
+                "available_pct": _compute_available_pct(row_status),
+                "reset_5h_at": row_status.get("reset_5h_at") if row_status else None,
+                "reset_week_at": row_status.get("reset_week_at") if row_status else None,
+                "reset_at": row_status.get("reset_at") if row_status else None,
                 "updated_at": _to_local_iso(s.get("lastStatusAt")),
+                "last_launched_at": _to_local_iso(s.get("lastLaunchedAt")),
+            })
+        if progress_callback:
+            progress_callback({
+                "event": "status_finished",
+                "row_count": len(rows),
             })
         return rows
 
@@ -695,7 +773,7 @@ def create_session_service(options=None):
     def get_session_root(name):
         return _get_session_root(name)
 
-    def export_bundle(file_path, include_auth=False, session_names=None, passphrase=None, force=False):
+    def export_bundle(file_path, include_auth=False, session_names=None, passphrase=None, force=False, progress_callback=None):
         if not file_path:
             raise CdxError("Export path is required.")
         if os.path.exists(file_path) and not force:
@@ -710,16 +788,36 @@ def create_session_service(options=None):
             "states": {},
             "profiles": {},
         }
+        profile_file_count = 0
+        profile_bytes = 0
+        if progress_callback:
+            progress_callback({
+                "event": "export_started",
+                "include_auth": bool(include_auth),
+                "session_count": len(sessions),
+                "session_names": [session["name"] for session in sessions],
+            })
         for session in sessions:
+            if progress_callback:
+                progress_callback({"event": "session_started", "session_name": session["name"]})
             payload["sessions"].append(_build_export_session_record(session))
             state = store["read_session_state"](session["name"])
             if state is not None:
                 payload["states"][session["name"]] = state
             if include_auth:
                 session_root = session.get("sessionRoot") or _get_session_root(session["name"])
-                payload["profiles"][session["name"]] = _collect_profile_files(session_root)
-
+                profile = _collect_auth_files(session_root, session["provider"], session["name"], progress_callback)
+                payload["profiles"][session["name"]] = profile["files"]
+                profile_file_count += profile["file_count"]
+                profile_bytes += profile["bytes"]
+            if progress_callback:
+                progress_callback({"event": "session_finished", "session_name": session["name"]})
+
+        if progress_callback:
+            progress_callback({"event": "encoding_started"})
         bundle_bytes = encode_bundle(payload, include_auth=include_auth, passphrase=passphrase)
+        if progress_callback:
+            progress_callback({"event": "writing_started", "path": file_path, "bundle_size_bytes": len(bundle_bytes)})
         _ensure_private_dir(os.path.dirname(os.path.abspath(file_path)) or ".")
         with open(file_path, "wb") as handle:
             handle.write(bundle_bytes)
@@ -732,6 +830,10 @@ def create_session_service(options=None):
             "path": file_path,
             "include_auth": include_auth,
             "session_names": [session["name"] for session in sessions],
+            "session_count": len(sessions),
+            "profile_file_count": profile_file_count if include_auth else None,
+            "profile_bytes": profile_bytes if include_auth else None,
+            "bundle_size_bytes": len(bundle_bytes),
         }
 
     def import_bundle(file_path, passphrase=None, session_names=None, force=False):

package/src/status_view.py

@@ -9,6 +9,9 @@ from .cli_render import (
     _style_pct,
 )
 
+RESET_COUNTDOWN_SAFETY_SECONDS = 60
+PRIORITY_EMPTY_AVAILABLE_THRESHOLD = 5
+
 
 def _format_reset_time(value):
     if not value:
@@ -27,6 +30,7 @@ def _format_reset_time(value):
         if hours_ago < 24:
             return f"passed {hours_ago}h ago"
         return value
+    delta_s = delta_s + RESET_COUNTDOWN_SAFETY_SECONDS
     if delta_s < 60:
         return "now"
     if delta_s < 24 * 60 * 60:
@@ -78,17 +82,20 @@ def _format_status_rows(rows, use_color=False, small=False):
             base.append(r.get("provider") or "n/a")
         status = r.get("status") or ("enabled" if r.get("enabled", True) else "disabled")
         base.append(_style(status, "2" if status == "disabled" else "32", use_color))
-        usage_columns = [
-            _style_pct(r.get("available_pct"), use_color),
-            _style_pct(r.get("remaining_5h_pct"), use_color),
-            _style_pct(r.get("remaining_week_pct"), use_color),
-            _style_reset_time(r.get("reset_5h_at"), use_color),
-            _style_reset_time(r.get("reset_week_at"), use_color),
-        ]
+        if r.get("enabled", True) is False:
+            usage_columns = [_style("-", "2", use_color)] * 5
+        else:
+            usage_columns = [
+                _style_pct(r.get("available_pct"), use_color),
+                _style_pct(r.get("remaining_5h_pct"), use_color),
+                _style_pct(r.get("remaining_week_pct"), use_color),
+                _style_reset_time(r.get("reset_5h_at"), use_color),
+                _style_reset_time(r.get("reset_week_at"), use_color),
+            ]
         if small:
             base += usage_columns
         else:
-            block = _format_blocking_quota(r)
+            block = "-" if r.get("enabled", True) is False else _format_blocking_quota(r)
             credits = str(r["credits"]) if r.get("credits") is not None else "-"
             base += usage_columns[:3] + [
                 _style(block, "33" if block not in ("?", "-") else "2", use_color),
@@ -104,14 +111,28 @@ def _format_status_rows(rows, use_color=False, small=False):
             if len(priority) > 1 else "."
         )
     ) if priority else "Priority: no usable session status yet."
+    current_line = _format_current_session_line(rows)
     return "\n".join([
         _pad_table([headers] + table_rows),
         "",
         _style(priority_line, "1", use_color),
-        _style("Tip: Codex status uses the local app-server rate-limit API when available; Claude sessions auto-refresh, use --refresh to force.", "2", use_color),
+        _style(current_line, "2", use_color),
     ])
 
 
+def _format_current_session_line(rows):
+    launched = []
+    for row in rows:
+        timestamp = _parse_reset_timestamp(row.get("last_launched_at"))
+        if timestamp is not None:
+            launched.append((timestamp, row))
+    if not launched:
+        return "Current: no launched session known yet."
+    timestamp, row = max(launched, key=lambda item: (item[0], item[1].get("session_name") or ""))
+    label = _format_relative_age(row.get("last_launched_at"))
+    return f"Current: last launched {row['session_name']} ({label})."
+
+
 def _recommend_priority_sessions(rows):
     if not rows:
         return []
@@ -120,7 +141,7 @@ def _recommend_priority_sessions(rows):
         has_credits = row.get("credits") is not None
         credit_rank = 0 if has_credits else 1
         available = row.get("available_pct")
-        usable_now = available is not None and available > 0
+        usable_now = available is not None and available > PRIORITY_EMPTY_AVAILABLE_THRESHOLD
         known_available = available is not None
         reset_timestamp = _priority_reset_timestamp(row)
         reset_is_future = reset_timestamp is not None and reset_timestamp >= _now_timestamp()
@@ -165,7 +186,7 @@ def _priority_instruction(row, position):
 
 def _priority_needs_refresh(row):
     available = row.get("available_pct")
-    if available is None or available > 0:
+    if available is None or available > PRIORITY_EMPTY_AVAILABLE_THRESHOLD:
         return False
     _label, is_past = _priority_reset_info(row)
     return is_past
@@ -175,7 +196,7 @@ def _priority_reason(row):
     available = row.get("available_pct")
     if available is None:
         return "status unknown"
-    if available > 0:
+    if available > PRIORITY_EMPTY_AVAILABLE_THRESHOLD:
         return f"{_format_pct(available)} OK"
     label, is_past = _priority_reset_info(row)
     if label: