cdx-manager 0.20.2 → 0.20.4

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.20.2-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.20.4-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
 
 **Stop guessing which AI account still has quota.** `cdx` tracks the rate-limit window of every Codex and Claude account you own, tells you which one is usable right now, and launches it with isolated auth — in one command.
 
@@ -500,6 +500,7 @@ cdx history --summary --from 2026-05-01 --to 2026-05-28
 | `cdx label <name> --clear [--json]` | Clear a session label |
 | `cdx login <name> [--json]` | Re-authenticate a session (logout + login) |
 | `cdx logout <name> [--json]` | Log out of a session |
+| `cdx auth refresh <name\|all> [--json]` | Make a locked, non-generation Codex auth probe; reports `login_required` when interactive login is needed |
 | `cdx disable <name> [--json]` | Disable a session without deleting it; disabled sessions stay visible and cannot launch |
 | `cdx enable <name> [--json]` | Re-enable a disabled session |
 | `cdx config <name> [--json]` | Show persistent launch settings for a session |
@@ -1077,6 +1078,24 @@ Without `--yes`, an interactive confirmation is required. `cdx` sends an idempot
 
 ## Troubleshooting
 
+### Codex credential refresh
+
+`cdx auth refresh work` makes a provider-native, non-generation request for one
+managed Codex profile. It can refresh an expiring access token, but never starts
+an agent or submits a prompt. Use `cdx auth refresh all --json` when a scheduler
+needs a stable result; CDX never installs or enables that scheduler for you.
+
+For example, a user-owned daily cron entry can run:
+
+```sh
+0 6 * * * cdx auth refresh all --json
+```
+
+`locked` means an interactive session owns the profile refresh lock and was left
+untouched. `login_required` means the provider rejected the local refresh token;
+run the supplied `cdx login <name>` command interactively. Hosts keep independent
+rotating credentials, so copying an auth file is not ongoing credential sync.
+
 - **`cdx <name>` fails with "not authenticated"** — run `cdx login <name>` first.
 - **One of two Codex accounts keeps asking for login** — run `cdx doctor --json` and inspect each Codex session's `codex_auth_file`, `codex_live_auth`, and `codex_stale_auth_logs` checks. If recent logs mention expired auth, repair only that isolated profile with `cdx login <name>`. Codex Business profiles can share the same `tokens.account_id`; `cdx doctor` reports `codex_shared_account_id` as a workspace-level clue, not proof that two profiles use the same user. Newly created sessions seed from the current global `~/.codex/auth.json` when one exists. For two separate Codex accounts, create or repair each session by running `cdx login <name>` for that session; `cdx login` does not log out first, so use `cdx logout <name>` explicitly only when you want to clear that isolated profile.
 - **`cdx` says no compatible Python 3 interpreter was found** — install Python 3 and make `py -3`, `python`, or `python3` available on PATH.

package/VERSION

@@ -1 +1 @@
-0.20.2
+0.20.4

package/changelogs/CHANGELOGS_0_20_3.md

@@ -0,0 +1,23 @@
+# CDX Manager 0.20.3
+
+## Fixes
+
+- Playwright, npm, pip, and uv now share one cache under `<CDX_HOME>/shared-cache`
+  instead of each isolated profile re-downloading its own copy, since profile
+  isolation redirects `HOME` per profile and those tools resolve their cache
+  dir from it.
+- A session now prints a short line when it ends, cleanly or by Ctrl-C/a
+  forwarded signal: the session name, how long it ran, and this run's own
+  cost (or token count when the model isn't priced). A genuine provider
+  crash still gets no line.
+
+## Performance
+
+- `cdx status --refresh` is faster: ~2.5s → ~2.2s on a 15-profile fleet,
+  verified to return identical data before and after. The Claude auth probe
+  now runs concurrently across sessions instead of one at a time, and no
+  longer spawns `claude auth status` twice per session (the probe and the
+  usage refresh were each independently running the exact same command).
+- `cdx disk profiles --candidates` is faster too: ~5.1s → ~4.6s, same
+  before/after verification. Per-profile `du` calls now run concurrently
+  instead of one profile at a time.

package/changelogs/CHANGELOGS_0_20_4.md

@@ -0,0 +1,12 @@
+# CDX Manager 0.20.4
+
+## Authentication
+
+- Added `cdx auth refresh <name|all> [--json]`, a locked, no-generation Codex
+  authentication probe. It can refresh an active provider session when the
+  upstream CLI supports it, but never opens a browser, prompts for credentials,
+  or fabricates a token.
+- The result distinguishes `valid`, `locked`, `login_required`, and `failed`
+  without exposing credential material.
+- Documented manual use and an opt-in cron example. CDX never installs or
+  enables a scheduler on its own.

package/checksums/release-archives.json

@@ -331,6 +331,28 @@
         "x86_64-pc-windows-msvc": "3513680e96fd5f669c2f2868b3a195899e48ed4d5f3dce080289f90648e60199",
         "x86_64-unknown-linux-musl": "ee86688537638671ceec1d805d23124d8511c11ab62836f14fa2545b418741d2"
       }
+    },
+    "v0.20.2": {
+      "github_tarball_sha256": "aeadbd180438862b7b1c0cdb31aece5c3ddbfbf2f20631733ffc48e1fd0a9fb7",
+      "github_zip_sha256": "79043ee3366f4e3006a51038d011416d510acd29e1cb35038519a3c4ff91571f",
+      "tray_assets": {
+        "aarch64-apple-darwin": "3da1c5b786fffe757e2d763cf36a5bf6dd9baf6bec06c3f4ba1d521a9919fbe9",
+        "aarch64-unknown-linux-musl": "8f9b0181b95d010ea3a13154d0a41fe150e32982847e43a3bba6c5674a8dea6e",
+        "x86_64-apple-darwin": "e35682db7adc4c6b4e2a9c112124411726f522423180c3a753bfb8aa7aa1008a",
+        "x86_64-pc-windows-msvc": "5ceff82ecd907fda949dfc27835112ad9e3597da78191a0ede4f7d9db82607a8",
+        "x86_64-unknown-linux-musl": "db70bb77f08fd954a7378561954d00ad3084b4ada99a4930aa8f021978439e65"
+      }
+    },
+    "v0.20.3": {
+      "github_tarball_sha256": "40990d89ea7130452a95b6cf6a3a63c804f36f08250cf3c325ce7fb63601f875",
+      "github_zip_sha256": "be334f6b23145a61d936d50d9609d6a9e6ba2e0749233aede0ed9ce8ff20df8e",
+      "tray_assets": {
+        "aarch64-apple-darwin": "5ec913f779c11df19aab1f09e8c68dcb4ec54d4a66b3dfbda43d73d67c597797",
+        "aarch64-unknown-linux-musl": "d59f41e9521175e22200b38638896d76c2d27f538e52a1f123e1dfdd6521cf4a",
+        "x86_64-apple-darwin": "1ec60ca652a18f3991b5d42c64cdf090eb19a658a88005d82642cb6ea9b6455e",
+        "x86_64-pc-windows-msvc": "1f9971c1aee7e92685370db1e6a4bcf37b6012fa7452fc14ca3dd545998af82e",
+        "x86_64-unknown-linux-musl": "2aabbc00b0fa3a2c8862cc1a5425a074fec99f072bf7b695d31e6e96b9b08c5d"
+      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.20.2",
+  "version": "0.20.4",
   "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.20.2"
+version = "0.20.4"
 description = "Terminal session manager for Codex and Claude accounts."
 readme = "README.md"
 requires-python = ">=3.9"

package/src/claude_refresh.py

@@ -30,8 +30,9 @@ def _is_stale(session, now=None, ttl_seconds=CLAUDE_REFRESH_TTL_SECONDS):
     return (now - updated_at.astimezone(now.tzinfo)).total_seconds() >= ttl_seconds
 
 
-def _refresh_claude_sessions(service, refresh_fn=None, target_names=None, force=False, ttl_seconds=CLAUDE_REFRESH_TTL_SECONDS):
+def _refresh_claude_sessions(service, refresh_fn=None, target_names=None, force=False, ttl_seconds=CLAUDE_REFRESH_TTL_SECONDS, already_auth_refreshed=None):
     refresh_fn = refresh_fn or refresh_claude_session_status
+    already_auth_refreshed = already_auth_refreshed or set()
     target_names = set(target_names or [])
     sessions = service["list_sessions"]()
     claude_sessions = [
@@ -52,7 +53,17 @@ def _refresh_claude_sessions(service, refresh_fn=None, target_names=None, force=
 
     def fetch(s):
         try:
-            usage = refresh_fn(s)
+            # The auth-probe phase right before this one already ran
+            # `claude auth status` for this session (see
+            # commands/status.py:_refresh_claude_auth_states), which is the
+            # exact side effect this refresh needs before reading
+            # credentials from disk. Skip re-running it - but only when
+            # 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)
+            else:
+                usage = refresh_fn(s)
             if inspect.isawaitable(usage):
                 raise CdxError("Claude refresh function returned an awaitable from a sync callable.")
             if usage:

package/src/cli.py

@@ -13,6 +13,7 @@ from .cli_commands import (
     _directory_child_sizes,
     _directory_size_bytes,
     handle_add,
+    handle_auth,
     handle_can_resume,
     handle_clean,
     handle_config,
@@ -151,6 +152,7 @@ __all__ = [
 
 
 _COMMAND_HANDLERS = {
+    "auth": handle_auth,
     "add": handle_add,
     "cp": handle_copy,
     "clean": handle_clean,
@@ -236,6 +238,7 @@ def _print_help(use_color=False):
         f"  {_style('cdx status <name> [--json] [--refresh|--cached] [--timeout SECONDS]', '36', use_color)}",
         f"  {_style('cdx next [--json] [--refresh]', '36', use_color)}",
         f"  {_style('cdx reset <name> [--yes] [--json]', '36', use_color)}",
+        f"  {_style('cdx auth refresh <name|all> [--json]', '36', use_color)}",
         f"  {_style('cdx select --provider PROVIDER [--min-reasoning-effort minimal|low|medium|high|xhigh] [--min-power minimal|low|medium|high|xhigh] [--require-ready] [--refresh] --json', '36', use_color)}",
         f"  {_style('cdx run [session] --cwd PATH (--prompt-file PATH|--prompt TEXT|--prompt-file -) [--provider PROVIDER] [--model MODEL] [--kind assistant|code-review] [--reasoning-effort minimal|low|medium|high|xhigh] [--power minimal|low|medium|high|xhigh] [--permission review|default|auto|full|workspace-write|read-only|danger-full-access] [--timeout-seconds N] [--detach] [--refresh] --json', '36', use_color)}",
         f"  {_style('cdx runs [--limit N] [--since 7d|today|DATE] --json', '36', use_color)}",

package/src/cli_args.py

@@ -25,6 +25,7 @@ DOCTOR_USAGE = "Usage: cdx doctor [--severity OK|WARN|FAIL[,OK|WARN|FAIL...]] [-
 DISK_USAGE = "Usage: cdx disk [profiles] [--candidates] [--json]"
 REPAIR_USAGE = "Usage: cdx repair [--dry-run] [--force] [--json]"
 UPDATE_USAGE = "Usage: cdx update [all] [--check] [--yes] [--json] [--version TAG]"
+AUTH_USAGE = "Usage: cdx auth refresh <name|all> [--json]"
 EXPORT_USAGE = "Usage: cdx export <file> [--include-auth] [--force] [--json] [--sessions name1,name2] [--passphrase-env VAR|--passphrase-stdin]"
 IMPORT_USAGE = "Usage: cdx import <file> [--force|--merge] [--allow-authless-force] [--json] [--sessions name1,name2] [--passphrase-env VAR|--passphrase-stdin]"
 CONTEXT_USAGE = "Usage: cdx context show|path|init|edit|clear|set|append [text...] [--json]"
@@ -909,6 +910,18 @@ def _parse_update_args(args):
     return parsed
 
 
+def _parse_auth_args(args):
+    parsed = _parse_flag_args(args, {
+        "--json": {"key": "json", "type": "bool", "default": False},
+    }, AUTH_USAGE, positionals_key="values", max_positionals=2)
+    if len(parsed["values"]) != 2 or parsed["values"][0] != "refresh":
+        raise CdxError(AUTH_USAGE)
+    target = parsed["values"][1]
+    if not target.strip():
+        raise CdxError(AUTH_USAGE)
+    return {"target": target, "json": parsed["json"]}
+
+
 def _parse_export_args(args):
     parsed = _parse_flag_args(args, {
         "--include-auth": {"key": "include_auth", "type": "bool", "default": False},

package/src/cli_commands.py

@@ -41,6 +41,9 @@ from .cli_view import handle_view as handle_view  # re-export for cli.py / tests
 from .commands.auth import (  # re-export for cli.py / tests
     _confirm_reset as _confirm_reset,
 )
+from .commands.auth import (
+    handle_auth as handle_auth,
+)
 from .commands.auth import (
     handle_login as handle_login,
 )
@@ -276,4 +279,3 @@ from .commands.tray import (
     handle_tray as handle_tray,
 )
 
-

package/src/commands/auth.py

@@ -3,12 +3,14 @@
 Split out of cli_commands.py. Moved verbatim; re-exported by cli_commands.
 """
 
+import json
 import time
 import uuid
 
-from ..cli_args import _parse_flag_args, _parse_json_flag
+from ..cli_args import _parse_auth_args, _parse_flag_args, _parse_json_flag
 from ..cli_helpers import (
     _bootstrap_claude_setup_token,
+    _json_failure,
     _json_success,
     _local_now_iso,
     _make_notify_progress,
@@ -16,7 +18,7 @@ from ..cli_helpers import (
     _write_json,
 )
 from ..cli_render import _success, _warn
-from ..codex_usage import consume_codex_rate_limit_reset_credit
+from ..codex_usage import consume_codex_rate_limit_reset_credit, fetch_codex_rate_limit_diagnostic
 from ..config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDER_OLLAMA
 from ..errors import CdxError
 from ..notify import (
@@ -33,6 +35,61 @@ def _confirm_reset(name):
     answer = input(f"Consume one banked Codex reset for {name}? [y/N] ")
     return answer.strip().lower() in ("y", "yes")
 
+
+def _refresh_needs_login(diagnostic):
+    """Classify known provider auth failures without returning provider text."""
+    text = json.dumps(diagnostic.get("response") or {}).lower()
+    return any(marker in text for marker in (
+        "not logged in", "unauthorized", "authentication token is expired",
+        "token_expired", "invalid_grant", "http 401",
+    ))
+
+
+def _refresh_result(session, diagnostic):
+    if diagnostic.get("ok"):
+        return {"session": session["name"], "provider": PROVIDER_CODEX, "outcome": "valid"}
+    if diagnostic.get("reason") == "auth_locked":
+        return {"session": session["name"], "provider": PROVIDER_CODEX, "outcome": "locked"}
+    if _refresh_needs_login(diagnostic):
+        return {
+            "session": session["name"], "provider": PROVIDER_CODEX,
+            "outcome": "login_required", "login_command": f"cdx login {session['name']}",
+        }
+    return {"session": session["name"], "provider": PROVIDER_CODEX, "outcome": "failed"}
+
+
+def handle_auth(rest, ctx):
+    parsed = _parse_auth_args(rest)
+    target = parsed["target"]
+    if target == "all":
+        sessions = [session for session in ctx["service"]["list_sessions"]()
+                    if session["provider"] == PROVIDER_CODEX]
+    else:
+        session = ctx["service"]["get_session"](target)
+        if not session:
+            raise CdxError(f"Unknown session: {target}")
+        if session["provider"] != PROVIDER_CODEX:
+            raise CdxError("Authentication refresh is only available for Codex sessions.")
+        sessions = [session]
+    if not sessions:
+        raise CdxError("No managed Codex sessions to refresh.")
+
+    probe = ctx["options"].get("fetchCodexRateLimitDiagnostic") or fetch_codex_rate_limit_diagnostic
+    results = [_refresh_result(session, probe(session)) for session in sessions]
+    failures = [result for result in results if result["outcome"] in ("login_required", "failed")]
+    message = "Codex authentication probe completed" if not failures else "Codex authentication probe needs attention"
+    if parsed["json"]:
+        payload = (
+            _json_failure("auth.refresh", "auth_refresh_failed", message, results=results)
+            if failures else _json_success("auth.refresh", message, results=results)
+        )
+        _write_json(ctx, payload)
+    else:
+        for result in results:
+            suffix = f"; run {result['login_command']}" if result.get("login_command") else ""
+            ctx["out"](f"{result['session']}: {result['outcome']}{suffix}\n")
+    return 1 if failures else 0
+
 def handle_ready(rest, ctx):
     """`cdx ready`: schedule an OS notification for the next session to come back.
 

package/src/commands/launch.py

@@ -26,7 +26,14 @@ from ..config import PROVIDER_CODEX
 from ..context_store import install_context_for_session, write_context
 from ..errors import CdxError
 from ..interactive_usage import extract_interactive_usage, transcript_predates_run, usage_delta
-from ..provider_runtime import _conversation_id, _ensure_session_authentication, _get_auth_home, _run_interactive_provider_command
+from ..provider_runtime import (
+    INTERRUPT_EXIT_CODES,
+    _conversation_id,
+    _ensure_session_authentication,
+    _get_auth_home,
+    _run_interactive_provider_command,
+)
+from ..run_usage import estimate_cost
 
 
 def _parse_launch_args(args):
@@ -268,6 +275,8 @@ def handle_launch(command, ctx, initial_prompt=None, resume=False, force_json=No
         run_info = _attach_interactive_usage(
             session, run_info, ctx["service"]["get_launch_history"](session["name"], limit=50)
         )
+        if not json_flag and error.exit_code in INTERRUPT_EXIT_CODES:
+            ctx["out"](f"{_goodbye_line(session, run_info, ctx['use_color'])}\n")
         if runtime_run_id:
             ctx["service"]["finish_session_runtime"](
                 session["name"],
@@ -283,15 +292,18 @@ def handle_launch(command, ctx, initial_prompt=None, resume=False, force_json=No
                 **run_info,
             })
         raise
+    success_run_info = _attach_interactive_usage(
+        session, run_info, ctx["service"]["get_launch_history"](session["name"], limit=50)
+    )
     ctx["service"]["record_launch_history"](session["name"], {
         "status": "success",
         "action": "resume" if resume else "launch",
         "cwd": cwd,
         "exit_code": 0,
-        **_attach_interactive_usage(
-            session, run_info, ctx["service"]["get_launch_history"](session["name"], limit=50)
-        ),
+        **success_run_info,
     })
+    if not json_flag:
+        ctx["out"](f"{_goodbye_line(session, success_run_info, ctx['use_color'])}\n")
     if json_flag:
         extra = {"session": ctx["service"]["get_session"](session["name"]), "cwd": cwd}
         if capability:
@@ -300,6 +312,29 @@ def handle_launch(command, ctx, initial_prompt=None, resume=False, force_json=No
     return 0
 
 
+def _goodbye_line(session, run_info, use_color):
+    """One line printed when a session ends: cleanly, or by SIGINT/SIGTERM/SIGHUP.
+
+    Not printed for a genuine provider crash (a nonzero exit that isn't one
+    of those signals) - that path already gets its own error message.
+
+    Local import: `commands.status` imports `handle_launch` from this module,
+    so importing it back at module scope would be circular.
+    """
+    from .status import _format_duration_ms, _format_token_count, _format_usd
+
+    parts = [f"Session {session['name']} ended", _format_duration_ms(run_info.get("duration_ms"))]
+    usage = run_info.get("usage")
+    cost = estimate_cost(usage, run_info.get("usage_model"))
+    if cost is not None:
+        parts.append(_format_usd(cost))
+    elif isinstance(usage, dict):
+        total_tokens = sum(v for v in usage.values() if isinstance(v, (int, float)))
+        if total_tokens:
+            parts.append(f"{_format_token_count(total_tokens)} tokens")
+    return _dim(" · ".join(parts), use_color)
+
+
 def _attach_interactive_usage(session, run_info, history=None):
     """Attach this run's own token usage without affecting launch outcome.
 

package/src/commands/maintenance.py

@@ -9,6 +9,7 @@ import shlex
 import shutil
 import subprocess
 import sys
+import threading
 import time
 from datetime import datetime
 
@@ -83,20 +84,35 @@ def _directory_size_bytes(path, runner=None):
         return total
 
 def _directory_child_sizes(path, runner=None, progress=None):
-    rows = []
     try:
         names = os.listdir(path)
     except OSError:
-        return rows
+        return []
     children = [(name, os.path.join(path, name)) for name in names if os.path.isdir(os.path.join(path, name))]
-    for index, (name, child_path) in enumerate(children, start=1):
+    # `du` per profile is I/O-bound (a subprocess spawn + directory walk), so
+    # one profile's measurement doesn't block the next - same reasoning as
+    # the auth-probe fix in commands/status.py. Progress is announced from
+    # the main thread, in listing order, before dispatch: du itself only
+    # runs concurrently, so the printed order still matches `len(children)`.
+    sizes = [None] * len(children)
+    threads = []
+
+    def measure(index, child_path):
+        sizes[index] = _directory_size_bytes(child_path, runner=runner)
+
+    for index, (name, child_path) in enumerate(children):
         if progress:
-            progress("profile", name, index, len(children))
-        rows.append({
-            "name": name,
-            "path": child_path,
-            "bytes": _directory_size_bytes(child_path, runner=runner),
-        })
+            progress("profile", name, index + 1, len(children))
+        t = threading.Thread(target=measure, args=(index, child_path), daemon=True)
+        threads.append(t)
+        t.start()
+    for t in threads:
+        t.join()
+
+    rows = [
+        {"name": name, "path": child_path, "bytes": sizes[index]}
+        for index, (name, child_path) in enumerate(children)
+    ]
     rows.sort(key=lambda row: row["bytes"], reverse=True)
     for row in rows:
         row["size"] = _format_bytes(row["bytes"])
@@ -170,11 +186,15 @@ def _collect_old_logs(profile_name, profile_path, days, now=None):
     )
 
 def _collect_profile_cleanup_candidates(base_dir, *, old_log_days=30, runner=None, now=None, progress=None):
-    candidates = []
     profiles = list(_iter_profile_dirs(base_dir))
-    for index, (profile_name, profile_path) in enumerate(profiles, start=1):
-        if progress:
-            progress("candidates", profile_name, index, len(profiles))
+    # Same reasoning as _directory_child_sizes: each profile's du calls and
+    # log walk are independent I/O, so profiles scan concurrently. Each
+    # thread only appends to its own slot in `per_profile`, never a shared list.
+    per_profile = [None] * len(profiles)
+    threads = []
+
+    def scan(index, profile_name, profile_path):
+        local = []
         tmp_dir = os.path.join(profile_path, ".tmp")
         tmp_targets = [
             ("tmp-marketplaces", os.path.join(tmp_dir, "marketplaces"), "temporary marketplace cache/staging"),
@@ -198,7 +218,7 @@ def _collect_profile_cleanup_candidates(base_dir, *, old_log_days=30, runner=Non
                 mtime = datetime.fromtimestamp(os.path.getmtime(path)).isoformat()
             except OSError:
                 mtime = None
-            candidates.append(_candidate(
+            local.append(_candidate(
                 profile_name,
                 kind,
                 path,
@@ -208,7 +228,19 @@ def _collect_profile_cleanup_candidates(base_dir, *, old_log_days=30, runner=Non
             ))
         old_logs = _collect_old_logs(profile_name, profile_path, old_log_days, now=now)
         if old_logs and old_logs["bytes"] > 0:
-            candidates.append(old_logs)
+            local.append(old_logs)
+        per_profile[index] = local
+
+    for index, (profile_name, profile_path) in enumerate(profiles):
+        if progress:
+            progress("candidates", profile_name, index + 1, len(profiles))
+        t = threading.Thread(target=scan, args=(index, profile_name, profile_path), daemon=True)
+        threads.append(t)
+        t.start()
+    for t in threads:
+        t.join()
+
+    candidates = [item for local in per_profile for item in (local or [])]
     candidates.sort(key=lambda item: item["bytes"], reverse=True)
     return candidates
 

package/src/commands/status.py

@@ -4,6 +4,7 @@ Split out of cli_commands.py. Moved verbatim; re-exported by cli_commands.
 """
 
 import os
+import threading
 import time
 from datetime import datetime
 
@@ -40,7 +41,14 @@ from ..cli_render import _dim, _info, _pad_table, _style, _warn
 from ..commands.launch import handle_launch
 from ..config import PROVIDER_CLAUDE
 from ..errors import CdxError
-from ..provider_runtime import AUTH_PROBE_AUTHENTICATED, AUTH_PROBE_DEGRADED, _probe_provider_auth_status
+from ..provider_runtime import (
+    AUTH_PROBE_AUTHENTICATED,
+    AUTH_PROBE_DEGRADED,
+    AUTH_PROBE_TIMEOUT_SECONDS,
+    _get_auth_home,
+    _has_local_claude_auth,
+    _probe_provider_auth_status,
+)
 from ..run_usage import (
     USAGE_KEYS,
     estimate_cost,
@@ -692,6 +700,7 @@ def handle_status(rest, ctx):
             ctx.get("refresh_fn"),
             target_names=args if len(args) == 1 else None,
             force=parsed["refresh"],
+            already_auth_refreshed=auth_refresh.get("probed"),
         )
     )
     refresh_errors = [
@@ -746,40 +755,84 @@ def handle_status(rest, ctx):
 
 def _refresh_claude_auth_states(service, target_names=None, spawn_sync=None, env_override=None):
     target_names = set(target_names or [])
+    candidates = [
+        session for session in service["list_sessions"]()
+        if session["provider"] == PROVIDER_CLAUDE
+        and session.get("enabled", True) is not False
+        and (not target_names or session["name"] in target_names)
+        and (session.get("auth") or {}).get("status") in ("authenticated", "logged_out")
+    ]
+    if not candidates:
+        return {"updated": [], "errors": [], "probed": set()}
+
     errors = []
-    updated = []
-    for session in service["list_sessions"]():
-        if session["provider"] != PROVIDER_CLAUDE:
-            continue
-        if session.get("enabled", True) is False:
-            continue
-        if target_names and session["name"] not in target_names:
-            continue
-        if (session.get("auth") or {}).get("status") not in ("authenticated", "logged_out"):
-            continue
+    results = {}
+    threads = []
+    # Sessions without a local credentials file are the ones whose probe
+    # below actually spawns `claude auth status` (see _probe_provider_auth_status);
+    # the Claude usage refresh right after this call spawns that exact same
+    # command again to refresh its own on-disk copy before reading it. Track
+    # them so the caller can skip that second, redundant spawn.
+    probed = {
+        session["name"] for session in candidates
+        if not _has_local_claude_auth(_get_auth_home(session))
+    }
+
+    # The probe itself is the slow part (a subprocess spawn per session on a
+    # cache miss); it doesn't touch shared state, so it's safe to run
+    # concurrently, same as the sibling Claude usage refresh right after this
+    # call. Side effects (service["update_auth_state"]) still run serially,
+    # after every thread has joined.
+    def probe(session):
         try:
-            auth_status = _probe_provider_auth_status(
+            results[session["name"]] = _probe_provider_auth_status(
                 session,
                 spawn_sync=spawn_sync,
                 env_override=env_override,
             )
-            if auth_status == AUTH_PROBE_DEGRADED:
-                errors.append({
-                    "session": session["name"],
-                    "error": "Auth probe timed out; authentication status is degraded.",
-                })
-                continue
-            now = _local_now_iso()
-            service["update_auth_state"](session["name"], lambda auth, auth_status=auth_status, now=now: {
-                **auth,
-                "status": "authenticated" if auth_status == AUTH_PROBE_AUTHENTICATED else "logged_out",
-                "lastCheckedAt": now,
-                **({"lastAuthenticatedAt": now} if auth_status == AUTH_PROBE_AUTHENTICATED else {}),
-            })
-            updated.append(session["name"])
         except Exception as error:
             errors.append({"session": session["name"], "error": str(error)})
-    return {"updated": updated, "errors": errors}
+
+    for session in candidates:
+        t = threading.Thread(target=probe, args=(session,), daemon=True)
+        threads.append(t)
+        t.start()
+    for t in threads:
+        t.join(timeout=AUTH_PROBE_TIMEOUT_SECONDS + 1)
+
+    results = dict(results)
+    errors = list(errors)
+
+    updated = []
+    now = _local_now_iso()
+    for session in candidates:
+        auth_status = results.get(session["name"])
+        if auth_status is None:
+            continue
+        if auth_status == AUTH_PROBE_DEGRADED:
+            errors.append({
+                "session": session["name"],
+                "error": "Auth probe timed out; authentication status is degraded.",
+            })
+            # A timed-out probe never finished running `claude auth status`,
+            # so its on-disk credentials aren't necessarily fresh - don't
+            # tell the caller this session's auth refresh can be skipped.
+            probed.discard(session["name"])
+            continue
+        service["update_auth_state"](session["name"], lambda auth, auth_status=auth_status, now=now: {
+            **auth,
+            "status": "authenticated" if auth_status == AUTH_PROBE_AUTHENTICATED else "logged_out",
+            "lastCheckedAt": now,
+            **({"lastAuthenticatedAt": now} if auth_status == AUTH_PROBE_AUTHENTICATED else {}),
+        })
+        updated.append(session["name"])
+    for session in candidates:
+        if session["name"] not in results:
+            # Probe raised/never completed for this session (exception or a
+            # join() that outran an unresponsive thread); same reasoning as
+            # the degraded case above.
+            probed.discard(session["name"])
+    return {"updated": updated, "errors": errors, "probed": probed}
 
 def _rows_by_session(rows):
     return {

package/src/provider_runtime.py

@@ -20,6 +20,7 @@ from .config import (
     PROVIDER_CODEX,
     PROVIDER_OLLAMA,
     REASONING_EFFORT_VALUES,
+    get_cdx_home,
     split_extra_args,
 )
 from .errors import CdxError
@@ -158,6 +159,25 @@ def _home_env_overrides(auth_home):
     return overrides
 
 
+def _shared_tool_cache_overrides(env):
+    """Pin tool download/build caches to one shared dir, outside any profile home.
+
+    Profile isolation redirects HOME to a per-profile auth_home (see
+    `_home_env_overrides`), and several dev tools resolve their cache dir from
+    HOME. Left alone, that means every profile re-downloads its own copy of
+    Playwright's browsers, npm/pip/uv packages, etc. `env` here is the ambient
+    env, before HOME gets swapped, so `get_cdx_home(env)` resolves the same
+    real per-user location regardless of which profile is launching.
+    """
+    shared_cache = os.path.join(get_cdx_home(env), "shared-cache")
+    return {
+        "PLAYWRIGHT_BROWSERS_PATH": os.path.join(shared_cache, "playwright"),
+        "NPM_CONFIG_CACHE": os.path.join(shared_cache, "npm"),
+        "PIP_CACHE_DIR": os.path.join(shared_cache, "pip"),
+        "UV_CACHE_DIR": os.path.join(shared_cache, "uv"),
+    }
+
+
 def _anthropic_profile_name():
     return "default"
 
@@ -562,6 +582,8 @@ def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None
     cwd = cwd or os.getcwd()
     env_override = env_override or {}
     env = {**os.environ, **env_override}
+    for key, value in _shared_tool_cache_overrides(env).items():
+        env.setdefault(key, value)
     env.update(launch_notify_env(session, notifications_enabled(session)))
     initial_prompt = _with_launch_preferences(session, initial_prompt, env=env)
     _validate_initial_prompt(initial_prompt)
@@ -1190,11 +1212,17 @@ def _probe_provider_auth(session, spawn_sync=None, env_override=None, trust_loca
     ) == AUTH_PROBE_AUTHENTICATED
 
 
+_SIGNAL_EXIT_CODES = {signal.SIGINT: 130, signal.SIGTERM: 143}
+if hasattr(signal, "SIGHUP"):
+    _SIGNAL_EXIT_CODES[signal.SIGHUP] = 129
+
+# The exit codes above, on their own: what a caller checks to tell "the user
+# killed this session" apart from "the provider process crashed on its own".
+INTERRUPT_EXIT_CODES = frozenset(_SIGNAL_EXIT_CODES.values())
+
+
 def _signal_exit_code(sig):
-    mapping = {signal.SIGINT: 130, signal.SIGTERM: 143}
-    if hasattr(signal, "SIGHUP"):
-        mapping[signal.SIGHUP] = 129
-    return mapping.get(sig, 1)
+    return _SIGNAL_EXIT_CODES.get(sig, 1)
 
 
 def _signal_name(sig):