cdx-manager 0.21.4 → 0.21.6

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.21.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.21.6-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.
 

package/VERSION

@@ -1 +1 @@
-0.21.4
+0.21.6

package/changelogs/CHANGELOGS_0_21_5.md

@@ -0,0 +1,26 @@
+# CDX Manager 0.21.5
+
+## Claude logins
+
+- `cdx status` shows each Claude profile's auth type in a TYPE column: `setup-token` or `full-login` (a `/login` run inside the profile). It also appears in the single-session view and as `auth_type` in `--json`. Within 30 days of a setup-token's one-year expiry, the column shows `setup-token 12d`, or `setup-token expired` once it has lapsed, and `cdx doctor` warns with the `cdx login` command to run. Based on work by Nicolas Rigaudy (#15, #16, #21).
+- The operations guide explains why a setup-token never loads claude.ai connectors such as Microsoft 365, and how to switch with `/login`.
+- On macOS, `cdx login` on a Claude profile now also removes the profile's keychain `/login`, so the new setup-token is the one used at launch. Before, the keychain login kept winning. The misleading "falling back to claude setup-token" message is reworded (#18).
+
+## Fixes
+
+- `cdx ready` never showed its notification: the scheduled job ran `cdx notify`, which now only serves agent hooks. On macOS the job was also written under the profile home inside a cdx session, where launchd never reads it (#18, #21).
+- Windows:
+  - the session store lock now waits up to 120 seconds instead of failing after 10;
+  - the process-alive check no longer sends Ctrl+C to the process it probes (#18).
+- Agent alert hooks work when the cdx path contains a space. Claude's `settings.json` is written atomically, through symlinks, and keeps its permissions (#18).
+- Token prices reviewed on 2026-10-22:
+  - `claude-sonnet-5-5` cache reads are $0.10/MTok;
+  - `claude-haiku-5-5` is added;
+  - context variants such as `claude-opus-5-5[1m]` are priced at the base model's rates (#20).
+
+## Housekeeping
+
+- `runs.json` keeps every running run plus the newest 500 finished ones.
+- Handoff entries older than 7 days are deleted when a new one is prepared.
+- Dead log-rotation code and duplicated helpers are removed.
+- New tests cover the state-changing `cdx tray` commands (#17, #19).

package/changelogs/CHANGELOGS_0_21_6.md

@@ -0,0 +1,33 @@
+# CDX Manager 0.21.6
+
+## Security
+
+- **Windows toasts.** PowerShell also ends a single-quoted string on the typographic quotes ‘ ’ ‚ ‛, so those are now escaped too, in cdx and in the tray. A crafted folder name or response preview could run code. French text such as "l’agent" no longer drops the toast (#23).
+- **Tray over WSL.** The tray no longer passes its commands through the WSL shell, which expanded `$(...)` and split arguments containing spaces. It also finds the user's own `cdx` instead of a stale system-wide one (#23).
+- **`cdx set <name> --scrub-env on`** launches Claude with `CLAUDE_CODE_SUBPROCESS_ENV_SCRUB=1`. The Bash commands, hooks and MCP servers the agent starts then no longer receive credentials, including the setup-token. It is off by default; `docs/operations.md` explains the trade-off (#26).
+- **Backup bundles that include auth** use a stronger key derivation (scrypt N=2^17, or PBKDF2 at 600k iterations) and record its cost. Older bundles still import, and a crafted cost is refused (#25).
+- **Claude profile creation** no longer replaces an unparseable or symlinked `settings.json`, and keeps its permissions (#23).
+- **PyPI** releases are published with Trusted Publishing, without a stored API token (#27).
+
+## Fixes
+
+- **Windows:**
+  - `cdx.cmd` now returns the real exit code; it always returned 0;
+  - `cdx ready` schedules its task on any Windows language, where `schtasks` refused the date on non-US systems;
+  - provider output is read as UTF-8;
+  - `cdx -v` and `--help` work without a home directory;
+  - the check after `cdx update` no longer prints "Could not determine home directory" (#22, #23).
+- **`cdx run`** stops the provider when it receives SIGTERM or SIGHUP (a `kill`, a `systemctl stop` or a closed SSH session), not only on Ctrl+C (#24).
+- **No more lost writes when two commands overlap:**
+  - tray events published while another is being acknowledged are kept;
+  - `cdx context set` and `clear` no longer race with an append (#24).
+- **`cdx set`:**
+  - the usage line, help and docs list every flag;
+  - a bad on/off value names the flag, for example "Unsupported notify value: maybe (on|off)" (#25).
+- **`cdx schema --json`** publishes every run error code and warning code. `cdx run` sets its error codes at the source instead of reading the message text (#25).
+
+## Housekeeping
+
+- CI also tests Python 3.9, the minimum version declared in pyproject.
+- The tray builds with `cargo --locked`.
+- The test suite no longer touches the developer's real macOS keychain (#24, #25).

package/checksums/release-archives.json

@@ -518,6 +518,28 @@
         "x86_64-pc-windows-msvc": "9729f245b46420ae4b11c1a50d3ba9cba682854866ef37a3f334dccbdd70ac89",
         "x86_64-unknown-linux-musl": "182fb651dab29a6a21b3b8ef56c196e954fd75230891f8532c21b09ff5fbacee"
       }
+    },
+    "v0.21.4": {
+      "github_tarball_sha256": "265936ceb35ffd43679e916f7ac2572b73e3a499803b86dfa8e87029a4188394",
+      "github_zip_sha256": "f9a648c4cba0d8c3204cac151f695d6fc4f86316d6dbdb6a1e8daf471dcd042b",
+      "tray_assets": {
+        "aarch64-apple-darwin": "b17aa8631acdcfa3e0de94ef8282b5b35791fd74d1e0be321bad42b20e7450ea",
+        "aarch64-unknown-linux-musl": "45eefeeb0d6c71269a24bece05780db98eaaa0e33630366f31cdb006f1dea946",
+        "x86_64-apple-darwin": "c10294583e88373570c7c5ad9094b711d57499d73358e9a1fa397bf5b76a12e3",
+        "x86_64-pc-windows-msvc": "0d4e6c736a789d8fddaf688cd61d899a305171fa6d7e856735b2cd7d2daef21c",
+        "x86_64-unknown-linux-musl": "8320025507801fd549b8c8dd4196a9378ddb25f137e48945e61e429bf2a864aa"
+      }
+    },
+    "v0.21.5": {
+      "github_tarball_sha256": "5a45b3ba4df72a4bba5bbd8c8c28728f7e804c67a4a7201d927f350d0276f432",
+      "github_zip_sha256": "b53d281da3540b85745a9b1e8abbdec797a0e97c1e1ec098d8c98753ffc334c2",
+      "tray_assets": {
+        "aarch64-apple-darwin": "e97c99054653a209b84190c2f08d3b1739527dc8e1d4795dd4b51271096fcdc7",
+        "aarch64-unknown-linux-musl": "04cfad61af12263eaa82f3b1fec12c8fad87762dc7a95b42e170f868156829e1",
+        "x86_64-apple-darwin": "b7a3beb55f34a9fae182ec164152d3295bf078a354c2788296c63c7c268c686e",
+        "x86_64-pc-windows-msvc": "d107e75e7700c2fcc7138d6bc14cdf6929fb3ad3e3d7a5b8648f44828f4ab4bb",
+        "x86_64-unknown-linux-musl": "00d93b4f16b58c203fbdc8cf80b15f1402ebf3fef8568162505142a3adb20272"
+      }
     }
   }
 }

package/docs/cli.md

@@ -23,8 +23,8 @@
 | `cdx config <name> [--json]` | Show persistent launch settings for a session |
 | `cdx configs [--json]` | Show persistent launch settings for all sessions in one table |
 | `cdx power\|perm\|fast\|model <name\|all\|provider:PROVIDER\|a,b> <value\|default> [--json]` | Shortcut commands for setting or clearing one launch setting |
-| `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] [--model MODEL] [--fallback-model MODEL[,MODEL...]] [--budget USD] [--extra-args 'ARGS'] [--priority 0..100] [--json]` | Persist launch settings for one or more sessions |
-| `cdx unset <name>\|--sessions all\|a,b\|--provider PROVIDER (--power\|--permission\|--fast\|--rtk\|--logics\|--model\|--fallback-model\|--budget\|--extra-args\|--priority\|--all) [--json]` | Remove persisted launch settings and fall back to provider defaults |
+| `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] [--notify-preview on\|off] [--scrub-env on\|off] [--model MODEL] [--fallback-model MODEL[,MODEL...]] [--budget USD] [--extra-args 'ARGS'] [--priority 0..100] [--json]` | Persist launch settings for one or more sessions |
+| `cdx unset <name>\|--sessions all\|a,b\|--provider PROVIDER (--power\|--reasoning-effort\|--permission\|--fast\|--rtk\|--logics\|--notify\|--notify-preview\|--scrub-env\|--model\|--fallback-model\|--budget\|--extra-args\|--priority\|--all) [--json]` | Remove persisted launch settings and fall back to provider defaults |
 | `cdx history [name] [--limit N] [--summary] [--since 7d\|today\|DATE] [--from DATE] [--to DATE] [--json]` | Show recent launch history or aggregate total launch time per assistant, optionally filtered by period |
 | `cdx last [--json]` | Launch the most recent existing session from launch history |
 | `cdx resume <name> [--json]` | Resume the provider-native conversation for a session using the named command form |
@@ -56,7 +56,7 @@
 | `cdx runs [--limit N] [--since 7d\|today\|DATE] --json` | List recent runs; `--since` returns every run completed after the cursor and ignores `--limit` |
 | `cdx schema --json` | Publish the enums, mutually-exclusive argument groups, and error codes programmatic callers should validate against |
 | `cdx stats [name] [--since 7d\|today\|DATE] [--from DATE] [--to DATE] [--json]` | Aggregate launch counts, duration, and known token usage by session, for headless and interactive runs alike |
-| `cdx status [--json] [--refresh\|--cached] [--timeout SECONDS]` | Show token usage table for all sessions; empty credits, block, and reset columns are omitted; `--cached` skips live provider probes and returns only stored status |
+| `cdx status [--json] [--refresh\|--cached] [--timeout SECONDS]` | Show token usage table for all sessions; empty credits, block, and reset columns are omitted; `--cached` skips live provider probes and returns only stored status; Claude rows also report the auth type (`setup-token` or `full-login`) in a TYPE column and as `auth_type` in JSON. |
 | `cdx status --small [--refresh\|--cached] [--timeout SECONDS]` / `cdx status -s [--refresh\|--cached] [--timeout SECONDS]` | Show compact token usage table without provider, blocking quota, credits, and updated columns |
 | `cdx status <name> [--json] [--refresh\|--cached] [--timeout SECONDS]` | Show detailed usage breakdown for one session; `--cached` avoids live provider refreshes |
 | `cdx tray status [--json] [--refresh]` | Emit the tray snapshot: one icon state, one line per enabled session, and how fresh each figure is. Reads stored status by default; `--refresh` is the only path that probes a provider |

package/docs/operations.md

@@ -151,6 +151,8 @@ Hosts keep independent rotating credentials, so copying an auth file is not ongo
 credential sync.
 
 - **`cdx <name>` fails with "not authenticated"** — run `cdx login <name>` first. `cdx doctor` uses the same Codex app-server probe as `cdx auth refresh`, so a local auth file alone is never reported as live authentication; a rejected refresh token is reported as `login_required` with the matching login command.
+- **A Claude session has no claude.ai connectors (Microsoft 365, ...) in `/mcp`** — `cdx login <name>` stores a setup-token for Claude profiles, and Claude Code can only make model requests with it: it never loads claude.ai connectors. `cdx status` shows each Claude profile's auth type (`setup-token` or `full-login`; `auth_type` in `--json`). To switch, start the session and run `/login` inside it. Once the profile holds its own claude.ai login (its `.claude/.credentials.json`, or its profile-specific `Claude Code-credentials-<hash>` keychain entry on macOS), cdx stops passing the setup-token on later launches. If that login later expires, run `/login` again, or go back to a setup-token with `cdx login <name>`, which removes the profile's `/login`.
+- **Keep credentials away from what a Claude agent runs** — by default Claude Code passes its credentials, including the setup-token cdx injects, to the Bash commands, hooks and stdio MCP servers it starts. `cdx set <name> --scrub-env on` launches that session with `CLAUDE_CODE_SUBPROCESS_ENV_SCRUB=1`, which strips credential-looking variables from those subprocesses (GitHub tokens and proxy settings stay). It is off by default: it also removes other secrets an agent may need (`NPM_TOKEN`, a `DATABASE_URL` with a password), and on Linux it isolates Bash from host processes, so `ps` and `kill` no longer see them. Worth turning on for unattended sessions that read untrusted content.
 - **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.
 - **`cdx add` succeeds but the session does not appear** — check that `CDX_HOME` is consistent between calls; a mismatch creates two separate registries.

package/install.ps1

@@ -90,15 +90,18 @@ try {
     Copy-Item -Path (Join-Path $sourceDir.FullName "*") -Destination $targetDir -Recurse -Force
 
     $launcherPath = Join-Path $binDir "cdx.cmd"
+    # No parenthesized block: cmd expands %ERRORLEVEL% when it parses a block,
+    # before py runs, so `exit /b %ERRORLEVEL%` inside one always returned 0.
     $launcher = @"
 @echo off
 set SCRIPT=%~dp0..\versions\$versionDir\bin\cdx
 where py >nul 2>nul
-if %ERRORLEVEL%==0 (
-  py -3 "%SCRIPT%" %*
-  exit /b %ERRORLEVEL%
-)
+if errorlevel 1 goto nopy
+py -3 "%SCRIPT%" %*
+exit /b %ERRORLEVEL%
+:nopy
 python "%SCRIPT%" %*
+exit /b %ERRORLEVEL%
 "@
     Set-Content -Path $launcherPath -Value $launcher -Encoding ascii
 

package/package.json

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

package/src/agent_notify.py

@@ -15,6 +15,7 @@ import shutil
 import subprocess
 
 from .config import get_cdx_home
+from .fs_utils import atomic_write
 from .notify import notification_channel, send_desktop_notification
 from .tray_alerts import alerts_enabled
 from .tray_events import publish
@@ -71,7 +72,11 @@ def resolve_hook_command(env=None):
     the provider inherits.
     """
     env = env or os.environ
-    return env.get("CDX_BIN") or shutil.which("cdx", path=env.get("PATH")) or "cdx"
+    path = env.get("CDX_BIN") or shutil.which("cdx", path=env.get("PATH")) or "cdx"
+    # Hooks run through a shell, so a space in the path ("C:\\Users\\Jean Dupont",
+    # a macOS home with a space) would split it. Double quotes read the same in
+    # sh, Git Bash and cmd.exe; a path without whitespace stays as it was.
+    return f'"{path}"' if any(ch.isspace() for ch in path) else path
 
 
 def read_hook_payload(args, stdin_text=None):
@@ -481,7 +486,7 @@ def _subprocess_spawn_sync(command, args, options):
         [command, *args],
         env=options.get("env"),
         capture_output=True,
-        text=True,
+        text=True, encoding="utf-8", errors="replace",
         timeout=60,
     )
 
@@ -547,11 +552,16 @@ def _read_json(path):
 
 
 def _write_json(path, document):
+    # Atomic, because Claude Code may rewrite the same settings file at the same
+    # moment. Through realpath so a symlinked settings.json stays a symlink, and
+    # with the file's own mode so a user-tightened file is not loosened.
     try:
-        os.makedirs(os.path.dirname(path), exist_ok=True)
-        with open(path, "w", encoding="utf-8") as handle:
-            json.dump(document, handle, indent=2)
-            handle.write("\n")
+        target = os.path.realpath(path)
+        try:
+            mode = os.stat(target).st_mode & 0o777
+        except FileNotFoundError:
+            mode = 0o644
+        atomic_write(target, json.dumps(document, indent=2) + "\n", mode=mode)
     except OSError:
         # An unwritable home is a skipped provisioning step, not a failed launch.
         return False

package/src/backup_bundle.py

@@ -11,10 +11,16 @@ BUNDLE_SCHEMA_VERSION = 1
 _SALT_BYTES = 16
 _NONCE_BYTES = 16
 _AEAD_NONCE_BYTES = 12
-_SCRYPT_N = 2 ** 14
-_SCRYPT_R = 8
-_SCRYPT_P = 1
-_PBKDF2_ITERATIONS = 200000
+# New bundles record their KDF cost in `kdf_params`, at OWASP-level costs
+# (scrypt N=2^17, PBKDF2-SHA256 600k). Bundles without the field were written
+# at the earlier costs, which stay readable. Recorded costs are capped so a
+# crafted bundle cannot make an import burn minutes of CPU or gigabytes of RAM.
+_SCRYPT_PARAMS = {"n": 2 ** 17, "r": 8, "p": 1}
+_PBKDF2_PARAMS = {"iterations": 600000}
+_LEGACY_SCRYPT_PARAMS = {"n": 2 ** 14, "r": 8, "p": 1}
+_LEGACY_PBKDF2_PARAMS = {"iterations": 200000}
+_MAX_SCRYPT_N = 2 ** 20
+_MAX_PBKDF2_ITERATIONS = 10_000_000
 _AEAD_ALGORITHM = "aes-256-gcm"
 _LEGACY_ALGORITHM = "sha256-xor-hmac"
 _KDF_SCRYPT = "scrypt"
@@ -78,19 +84,49 @@ def _bundle_kdf_candidates(wrapper):
     return [recorded]
 
 
-def _derive_key_material(passphrase, salt, kdf):
+def _default_params(kdf):
+    return dict(_SCRYPT_PARAMS if kdf == _KDF_SCRYPT else _PBKDF2_PARAMS)
+
+
+def _bundle_kdf_params(wrapper, kdf):
+    """The recorded cost, or the pre-`kdf_params` cost for older bundles."""
+    recorded = wrapper.get("kdf_params")
+    if recorded is None:
+        return dict(_LEGACY_SCRYPT_PARAMS if kdf == _KDF_SCRYPT else _LEGACY_PBKDF2_PARAMS)
+    if not isinstance(recorded, dict) or ("n" in recorded) != (kdf == _KDF_SCRYPT):
+        return None  # recorded for the other KDF: not this candidate
+    try:
+        if kdf == _KDF_SCRYPT:
+            params = {key: int(recorded[key]) for key in ("n", "r", "p")}
+            valid = (2 <= params["n"] <= _MAX_SCRYPT_N and params["n"] & (params["n"] - 1) == 0
+                     and 1 <= params["r"] <= 32 and 1 <= params["p"] <= 16)
+        else:
+            params = {"iterations": int(recorded["iterations"])}
+            valid = 1 <= params["iterations"] <= _MAX_PBKDF2_ITERATIONS
+    except (TypeError, ValueError, KeyError):
+        valid = False
+    if not valid:
+        raise CdxError("Unsupported bundle key derivation parameters.")
+    return params
+
+
+def _derive_key_material(passphrase, salt, kdf, params=None):
+    params = params or _default_params(kdf)
     if kdf == _KDF_SCRYPT:
         if not _available_kdf(_KDF_SCRYPT):
             raise CdxError(
                 "This bundle records the scrypt key derivation function, which this Python runtime "
                 "does not provide. Decode it with a Python built against OpenSSL scrypt support."
             )
+        n, r, p = params["n"], params["r"], params["p"]
         return hashlib.scrypt(
             passphrase,
             salt=salt,
-            n=_SCRYPT_N,
-            r=_SCRYPT_R,
-            p=_SCRYPT_P,
+            n=n,
+            r=r,
+            p=p,
+            # scrypt needs 128*r*n bytes; OpenSSL's 32 MiB default refuses N=2^17.
+            maxmem=2 * 128 * r * n * p + 1024 * 1024,
             dklen=64,
         )
     if kdf == _KDF_PBKDF2:
@@ -98,23 +134,23 @@ def _derive_key_material(passphrase, salt, kdf):
             "sha256",
             passphrase,
             salt,
-            _PBKDF2_ITERATIONS,
+            params["iterations"],
             dklen=64,
         )
     raise CdxError("Unsupported bundle key derivation function.")
 
 
-def _derive_keys(passphrase, salt, kdf=None):
+def _derive_keys(passphrase, salt, kdf=None, params=None):
     if not passphrase:
         raise CdxError("A non-empty passphrase is required for bundles that include auth data.")
     if isinstance(passphrase, str):
         passphrase = passphrase.encode("utf-8")
-    key_material = _derive_key_material(passphrase, salt, kdf or _default_kdf())
+    key_material = _derive_key_material(passphrase, salt, kdf or _default_kdf(), params)
     return key_material[:32], key_material[32:]
 
 
-def _derive_aead_key(passphrase, salt, kdf=None):
-    enc_key, _mac_key = _derive_keys(passphrase, salt, kdf)
+def _derive_aead_key(passphrase, salt, kdf=None, params=None):
+    enc_key, _mac_key = _derive_keys(passphrase, salt, kdf, params)
     return enc_key
 
 
@@ -152,11 +188,13 @@ def encode_bundle(payload, include_auth=False, passphrase=None):
         salt = os.urandom(_SALT_BYTES)
         nonce = os.urandom(_AEAD_NONCE_BYTES)
         kdf = _default_kdf()
-        aesgcm = _load_aesgcm()(_derive_aead_key(passphrase, salt, kdf))
+        params = _default_params(kdf)
+        aesgcm = _load_aesgcm()(_derive_aead_key(passphrase, salt, kdf, params))
         ciphertext = aesgcm.encrypt(nonce, payload_bytes, None)
         wrapper.update({
             "encryption": _AEAD_ALGORITHM,
             "kdf": kdf,
+            "kdf_params": params,
             "salt": _b64_encode(salt),
             "nonce": _b64_encode(nonce),
             "payload": _b64_encode(ciphertext),
@@ -186,9 +224,12 @@ def decode_bundle(data, passphrase=None):
             payload_bytes = None
             failure = None
             for kdf in kdf_candidates:
+                params = _bundle_kdf_params(wrapper, kdf)
+                if params is None:
+                    continue
                 # Derivation errors are about the bundle, not the passphrase, so
                 # they must escape rather than be retried as a bad secret.
-                cipher = aead(_derive_aead_key(passphrase, salt, kdf))
+                cipher = aead(_derive_aead_key(passphrase, salt, kdf, params))
                 try:
                     payload_bytes = cipher.decrypt(nonce, ciphertext, None)
                     break
@@ -200,7 +241,10 @@ def decode_bundle(data, passphrase=None):
             expected_mac = _b64_decode(wrapper.get("hmac_sha256", ""))
             payload_bytes = None
             for kdf in kdf_candidates:
-                enc_key, mac_key = _derive_keys(passphrase, salt, kdf)
+                params = _bundle_kdf_params(wrapper, kdf)
+                if params is None:
+                    continue
+                enc_key, mac_key = _derive_keys(passphrase, salt, kdf, params)
                 actual_mac = hmac.new(mac_key, nonce + ciphertext, hashlib.sha256).digest()
                 if hmac.compare_digest(actual_mac, expected_mac):
                     payload_bytes = _xor_keystream(ciphertext, enc_key, nonce)

package/src/claude_credentials.py

@@ -81,6 +81,91 @@ def peek_keychain_credentials(auth_home):
         return None
 
 
+INFERENCE_SCOPE = "user:inference"
+
+
+def is_full_claude_login(credentials):
+    """True for a claude.ai login, False for an inference-only credential.
+
+    A setup-token can only make model requests, so Claude Code never loads
+    claude.ai connectors with it. A real `/login` stores a refresh token and
+    scopes beyond inference. Only the shape is inspected, never the values.
+    """
+    oauth = credentials.get("claudeAiOauth") if isinstance(credentials, dict) else None
+    if not isinstance(oauth, dict) or not oauth.get("accessToken"):
+        return False
+    scopes = oauth.get("scopes")
+    extra_scopes = isinstance(scopes, list) and any(
+        isinstance(scope, str) and scope != INFERENCE_SCOPE for scope in scopes
+    )
+    return bool(oauth.get("refreshToken")) or extra_scopes
+
+
+def read_claude_login_file(auth_home):
+    try:
+        with open(os.path.join(auth_home, ".claude", ".credentials.json"), encoding="utf-8") as handle:
+            data = json.load(handle)
+    except (OSError, ValueError):
+        return None
+    return data if isinstance(data, dict) else None
+
+
+def has_full_claude_login(auth_home):
+    """Whether the profile holds a claude.ai login: the profile's
+    `.credentials.json` (Linux, Windows) or its keychain entry (macOS)."""
+    if not auth_home:
+        return False
+    return is_full_claude_login(read_claude_login_file(auth_home)) or is_full_claude_login(
+        peek_keychain_credentials(auth_home)
+    )
+
+
+def claude_auth_type(auth_home):
+    """`full-login`, `setup-token`, or None when the profile holds neither."""
+    if has_full_claude_login(auth_home):
+        return "full-login"
+    try:
+        with open(os.path.join(auth_home, "credentials", "default.json"), encoding="utf-8") as handle:
+            token = json.load(handle).get("access_token")
+    except (OSError, ValueError, AttributeError):
+        return None
+    return "setup-token" if token else None
+
+
+# `claude setup-token` mints a token valid for one year. Tokens minted before
+# cdx recorded `created_at` fall back to the file's mtime, which a copy or a
+# backup import resets, so their date can read later than it really is.
+SETUP_TOKEN_LIFETIME_SECONDS = 365 * 24 * 3600
+SETUP_TOKEN_WARN_DAYS = 30
+
+
+def setup_token_expires_at(auth_home):
+    """Epoch seconds when the profile's setup-token expires, or None."""
+    path = os.path.join(auth_home or "", "credentials", "default.json")
+    try:
+        with open(path, encoding="utf-8") as handle:
+            data = json.load(handle)
+        if not isinstance(data, dict) or not data.get("access_token"):
+            return None
+        created = data.get("created_at")
+        if isinstance(created, str):
+            from datetime import datetime
+            created = datetime.fromisoformat(created.replace("Z", "+00:00")).timestamp()
+        elif not isinstance(created, (int, float)):
+            created = os.path.getmtime(path)
+    except (OSError, ValueError):
+        return None
+    return created + SETUP_TOKEN_LIFETIME_SECONDS
+
+
+def setup_token_days_left(auth_home, now=None):
+    expires = setup_token_expires_at(auth_home)
+    if expires is None:
+        return None
+    import time
+    return int((expires - (time.time() if now is None else now)) // 86400)
+
+
 def write_keychain_credentials(auth_home, data):
     _reject_custom_oauth()
     user, service = _keychain_identity(auth_home)

package/src/claude_usage.py

@@ -214,7 +214,7 @@ def _refresh_claude_cli_credentials(auth_home, runner=None, env=None):
             command,
             env=run_env,
             capture_output=True,
-            text=True,
+            text=True, encoding="utf-8", errors="replace",
             timeout=CLAUDE_AUTH_STATUS_TIMEOUT_SECONDS,
             check=False,
         )

package/src/cli.py

@@ -6,6 +6,7 @@ import sys
 from datetime import datetime, timezone
 
 from .agent_notify import handle_notify
+from .cli_args import SET_USAGE
 from .cli_commands import (
     API_SCHEMA_VERSION,
     STATUS_USAGE,
@@ -72,10 +73,6 @@ from .cli_render import (
 )
 from .config import PROVIDER_OLLAMA
 from .errors import CdxError
-from .provider_runtime import (
-    LOG_ROTATE_BYTES,
-    _rotate_log_if_needed,
-)
 from .session_service import create_session_service
 from .status_view import (
     _format_blocking_quota,
@@ -138,13 +135,11 @@ VERSION = _resolve_version()
 # them here documents that and stops F401 from treating them as dead imports.
 __all__ = [
     "STATUS_USAGE",
-    "LOG_ROTATE_BYTES",
     "_format_blocking_quota",
     "_format_reset_time",
     "_format_status_detail",
     "_format_status_rows",
     "_pad_table",
-    "_rotate_log_if_needed",
     "_visible_len",
     "cli_entry",
     "format_json_error",
@@ -253,7 +248,7 @@ def _print_help(use_color=False):
         f"  {_style('cdx config <name> [--json]', '36', use_color)}",
         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('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] [--notify-preview on|off] [--model MODEL] [--priority 0..100] [--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|--all) [--json]', '36', use_color)}",
         f"  {_style('cdx history [name] [--limit N] [--summary] [--since 7d|today|DATE] [--from DATE] [--to DATE] [--json]', '36', use_color)}",
         f"  {_style('cdx stats [name] [--since 7d|today|DATE] [--from DATE] [--to DATE] [--json]', '36', use_color)}",
@@ -539,7 +534,6 @@ def main(argv, options=None):
     stderr = options.get("stderr", sys.stderr)
     stdin_is_tty = options.get("stdin", {}).get("isTTY", hasattr(sys.stdin, "isatty") and sys.stdin.isatty())
     use_color = _should_use_color(env, stdout)
-    service = options.get("service") or create_session_service({"env": env})
     spawn = options.get("spawn")
     spawn_sync = options.get("spawn_sync")
     refresh_fn = options.get("refreshClaudeSessionStatus")
@@ -565,6 +559,10 @@ def main(argv, options=None):
         out(f"{_print_version()}\n")
         return 0
 
+    # Built after --help/--version: those must answer even where the home
+    # directory cannot be resolved (a service or task with a minimal environment).
+    service = options.get("service") or create_session_service({"env": env})
+
     if argv == ["--json"]:
         rows = service["format_list_rows"]()
         notices = _get_update_notices(service, env, options)