cdx-manager 0.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alexandre Agostini
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,243 @@
+# CDX Manager
+
+**Run multiple Codex and Claude sessions from one terminal. Switch between accounts instantly.**
+
+If you use AI coding tools at scale ; multiple accounts, multiple providers : you know the friction: re-authenticating, losing context, juggling environment variables. `cdx` removes all of that.
+
+One command to launch any session. Zero auth juggling.
+
+[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.2.1-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
+
+---
+
+## Table of Contents
+
+- [What it does](#what-it-does)
+- [Technical Overview](#technical-overview)
+- [Getting Started](#getting-started)
+- [All Commands](#all-commands)
+- [Available Scripts](#available-scripts)
+- [Project Structure](#project-structure)
+- [Data Layout](#data-layout)
+- [Troubleshooting](#troubleshooting)
+- [Contributing](#contributing)
+- [License](#license)
+
+---
+
+## What it does
+
+- **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.
+- **Passive status resolution.** If a session has no recorded status, `cdx` reads it directly from the provider's session logs and JSONL history — no manual sync required.
+- **Session transcript capture.** Every launch is recorded to a local log file via `script`, giving you a full terminal transcript for each session.
+- **Clean removal.** `cdx rmv` wipes a session and its entire auth directory. No orphaned files, no stale credentials.
+
+---
+
+## Technical Overview
+
+- Python 3.9+, zero runtime dependencies.
+- Environment isolation per session:
+  - Codex sessions override `CODEX_HOME` to a dedicated profile directory.
+  - Claude sessions override `HOME` to a dedicated profile directory.
+- Persistence:
+  - Session registry at `~/.cdx/sessions.json` (versioned JSON store).
+  - Per-session state at `~/.cdx/state/<name>.json`.
+  - Auth and provider data under `~/.cdx/profiles/<name>/`.
+  - All paths are URL-encoded to support arbitrary session names.
+- Status resolution pipeline:
+  - Primary source: recorded status fields on the session record.
+  - Fallback: `status-source` scans provider JSONL history files and terminal log transcripts, strips ANSI/OSC sequences, and extracts `usage%`, `5h remaining%`, and `week remaining%` via pattern matching.
+- Claude status refreshes are cached briefly by default; pass `--refresh` to force a live rate-limit probe.
+- If `script` is unavailable, Codex launch falls back to running without transcript capture.
+- Auth probe: synchronous subprocess call to `codex login status` or `claude auth status` before any interactive launch.
+- Signal forwarding: `SIGINT`, `SIGTERM`, and `SIGHUP` are forwarded to the child process and produce clean exit codes.
+- Test stack: Python built-in `unittest` runner with no test framework dependency.
+
+---
+
+## Getting Started
+
+### Prerequisites
+
+- Python 3.9+
+- npm
+- `codex` and/or `claude` CLI installed and available in your PATH
+
+### Install
+
+```bash
+git clone <repo>
+cd cdx-manager
+make install
+```
+
+`cdx` is now available globally. Changes to the source take effect immediately — no reinstall needed.
+
+To uninstall:
+
+```bash
+make uninstall
+```
+
+Alternatively, for a non-symlinked global install:
+
+```bash
+npm install -g .
+```
+
+Once published to npm:
+
+```bash
+npm install -g cdx-manager
+```
+
+### Environment
+
+By default, `cdx` stores all data under `~/.cdx/`. Override with:
+
+```bash
+export CDX_HOME=/path/to/custom/dir
+```
+
+Optional runtime knobs:
+
+```bash
+export CDX_CLAUDE_STATUS_MODEL=claude-haiku-4-5-20251001
+export CDX_SCRIPT_BIN=script
+export CDX_SCRIPT_ARGS='-q -F {transcript}'
+```
+
+### Quick Start
+
+```bash
+# Register a Codex session
+cdx add work
+
+# Register a Claude session
+cdx add claude personal
+
+# List all sessions
+cdx
+
+# Launch a session
+cdx work
+
+# Check usage across all sessions
+cdx status
+```
+
+---
+
+## All Commands
+
+| Command | Description |
+|---|---|
+| `cdx` | List all sessions with last-updated timestamps |
+| `cdx <name>` | Launch a session (checks auth first) |
+| `cdx add [provider] <name>` | Register a new session (`provider`: `codex` or `claude`, default: `codex`) |
+| `cdx cp <source> <dest>` | Copy a session into another session name, overwriting the destination if it exists |
+| `cdx ren <source> <dest>` | Rename a session and move its auth data |
+| `cdx login <name>` | Re-authenticate a session (logout + login) |
+| `cdx logout <name>` | Log out of a session |
+| `cdx rmv <name> [--force]` | Remove a session and its auth data (prompts for confirmation unless `--force`) |
+| `cdx clean [name]` | Clear launch transcript logs for one session or all sessions |
+| `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 notify <name> --at-reset [--poll seconds] [--once]` | Wait for a session reset time and send a desktop notification when due |
+| `cdx notify --next-ready [--poll seconds] [--once]` | 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 keeps the same row-array shape and writes live Claude refresh warnings to stderr |
+| `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 |
+| `cdx --help` | Show usage |
+| `cdx --version` | Show version |
+
+---
+
+## Available Scripts
+
+- `npm test`: run the Python test suite
+- `npm run test:py`: run the Python unit tests directly
+- `npm run lint`: byte-compile the Python sources and tests
+- `npm run link`: link `cdx` globally for local development (`npm link`)
+- `npm run unlink`: remove the global link
+
+---
+
+## Project Structure
+
+```text
+bin/
+  cdx                   # Entry point — shebang + main() call
+
+src/
+  cli.py                # Top-level command router
+  cli_commands.py       # Command handlers and argument handling
+  cli_render.py         # Terminal formatting, tables, colors, and errors
+  status_view.py        # Status table/detail rendering and priority ranking
+  provider_runtime.py   # Provider launch/auth commands, transcripts, signals
+  claude_refresh.py     # Claude usage refresh orchestration
+  session_service.py    # Session lifecycle: create, copy, rename, launch, remove, status
+                        # resolution, auth state management
+  session_store.py      # JSON persistence layer: sessions.json + per-session
+                        # state files
+  status_source.py      # Status artifact discovery: scans JSONL history files
+                        # and terminal log transcripts, strips ANSI sequences,
+                        # extracts usage metrics via pattern matching
+  config.py             # CDX_HOME resolution (env override or ~/.cdx)
+  errors.py             # CdxError with optional exit code
+  __init__.py           # Public Python exports
+
+test/
+  test_cli_py.py            # CLI command dispatch tests
+  test_session_service_py.py  # Session service unit tests
+```
+
+---
+
+## Data Layout
+
+All session data lives under `CDX_HOME` (default: `~/.cdx/`):
+
+```text
+~/.cdx/
+  sessions.json             # Session registry (versioned, all sessions)
+  state/
+    <encoded-name>.json     # Per-session rehydration state
+  profiles/
+    <encoded-name>/         # Codex session: CODEX_HOME points here
+      log/
+        cdx-session.log     # Terminal transcript (written by script(1))
+    <encoded-name>/
+      claude-home/          # Claude session: HOME points here
+        log/
+          cdx-session.log
+```
+
+Session names are URL-encoded when used as directory or file names. CLI command names such as `add`, `status`, and `login` are reserved and cannot be used as session names.
+
+---
+
+## Troubleshooting
+
+- **`cdx <name>` fails with "not authenticated"** — run `cdx login <name>` first.
+- **`cdx add` succeeds but the session does not appear** — check that `CDX_HOME` is consistent between calls; a mismatch creates two separate registries.
+- **Status shows `n/a` for all fields** — the session has not been launched yet, or the provider has not written any status output to its history files. Launch the session and run `/status` inside it at least once.
+- **`cdx rmv` says "Removal requires confirmation in an interactive terminal"** — pass `--force` to bypass the prompt in non-interactive environments (scripts, CI).
+- **`cdx login` hangs** — the provider's login flow requires a browser or device code. Follow the on-screen instructions in the terminal that opened.
+- **`make install` says `npm link` is not found** — ensure Node.js and npm are installed and in your PATH.
+
+---
+
+## Contributing
+
+Contribution guidelines are available in [`CONTRIBUTING.md`](CONTRIBUTING.md).
+
+---
+
+## License
+
+This project is licensed under the MIT License. See [`LICENSE`](LICENSE).

package/bin/cdx

@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+
+import sys
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parent.parent
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from src.cli import format_error, main  # noqa: E402
+from src.errors import CdxError  # noqa: E402
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main(sys.argv[1:]))
+    except CdxError as error:
+        sys.stderr.write(f"{format_error(error)}\n")
+        raise SystemExit(error.exit_code)

package/changelogs/CHANGELOGS_0_1_1.md

@@ -0,0 +1,98 @@
+# CHANGELOGS_0_1_1
+
+Release date: 2026-04-16
+
+## CDX Manager 0.1.1
+
+CDX Manager 0.1.1 is the first packaged release of the multi-provider terminal session manager for Codex and Claude accounts.
+
+It turns the initial Logics-scoped idea into a usable CLI: isolated per-session auth homes, interactive provider launch, status extraction from local artifacts, Claude usage refresh through Anthropic rate-limit headers, log capture, cleanup commands, and release-ready package metadata.
+
+### At a glance
+
+- Added the `cdx` CLI entrypoint with conventional `--help`, `--version`, session listing, creation, launch, copy, removal, login, logout, clean, and status commands
+- Added persistent session storage under `CDX_HOME`, with URL-encoded session names and per-session rehydration state
+- Added explicit Codex and Claude provider support with isolated `CODEX_HOME` / `HOME` environments
+- Added auth bootstrap and guardrails before launch, including provider-specific status checks and interactive login/logout commands
+- Added terminal signal forwarding so launched provider CLIs receive interrupts and exits cleanly
+- Added global and per-session status views with 5-hour, weekly, available, reset, and updated fields
+- Added fallback status parsing from provider JSONL history and terminal transcript logs
+- Added Claude automatic usage refresh from Anthropic API rate-limit headers
+- Added terminal transcript capture through `script`, rotated launch logs, and the `cdx clean` command
+- Migrated the implementation to Python while keeping npm-based install and validation scripts
+- Added root packaging metadata, MIT license, README, contribution guidance, and release notes
+
+### Session management
+
+- `cdx add <name>` creates Codex sessions by default.
+- `cdx add claude <name>` creates Claude sessions with a dedicated `claude-home`.
+- `cdx <name>` launches the selected provider in an isolated environment.
+- `cdx cp <source> <dest>` copies a session while preserving provider isolation.
+- `cdx rmv <name> [--force]` removes the session registry entry and its auth directory.
+- Session state is stored in a versioned JSON registry and per-session state files under `CDX_HOME`.
+
+### Authentication and launch flow
+
+- Codex sessions use `codex login status`, `codex login`, and `codex logout`.
+- Claude sessions use `claude auth status`, `claude auth login`, and `claude auth logout`.
+- Launches are blocked when a session is not authenticated, with clear recovery instructions.
+- Signals from the wrapper process are forwarded to the child provider process.
+- Codex launches show a reminder to run `/status` inside Codex when usage data needs refreshing.
+
+### Usage and status reporting
+
+- `cdx status` renders an aligned table for all sessions.
+- `cdx status <name>` renders a detailed view for one session.
+- `--json` is supported for both global and detail status views.
+- Status rows include `AVAILABLE`, `5H LEFT`, `WEEK LEFT`, `RESET 5H`, `RESET WEEK`, and `UPDATED`.
+- Available percentage is computed from the stricter remaining quota window.
+- Cached statuses are enriched from newer or more detailed local artifacts when available.
+
+### Codex status extraction
+
+- Parses Codex `/status` blocks from logs and JSONL history.
+- Handles ANSI / terminal control sequences and narrow terminal layouts.
+- Extracts 5-hour and weekly reset values independently.
+- Uses account identity in Codex status blocks to avoid accepting pasted status output from another account.
+- Prefers direct launch logs over noisier conversational rollout JSONL artifacts.
+
+### Claude status extraction
+
+- Parses `Current session` and `Current week` blocks from Claude transcripts.
+- Extracts 5-hour reset values from `Current session`, including AM/PM formats such as `Resets at 5:00 AM`.
+- Extracts weekly reset values from `Current week`.
+- Keeps Claude 5-hour and weekly reset values separate in status output.
+- Refreshes Claude usage automatically from Anthropic rate-limit headers when credentials are available.
+
+### Local time behavior
+
+- Claude API reset timestamps are formatted in the machine's local timezone.
+- Log-derived time-only reset values are inferred in the local timezone.
+- Status `updated_at` values from API, JSONL, and file metadata are normalized to local ISO timestamps.
+
+### Logging and cleanup
+
+- Provider launches are captured to local transcript logs via `script`.
+- Launch logs include unique timestamped filenames to avoid overwriting active or recent transcripts.
+- Logs are rotated around the 10 MB threshold.
+- `cdx clean [name]` clears launch transcript logs for one session or all sessions.
+
+### Packaging
+
+- Published package version is `0.1.1`.
+- The npm tarball is restricted to the CLI entrypoint, source package, README, license, and release changelogs.
+- Local project-only files such as `.claude`, Logics workflow docs, and tests are excluded from the package tarball.
+
+### Validation
+
+```bash
+npm run lint
+npm test
+python3 bin/cdx --version
+npm --cache /tmp/cdx-npm-cache pack --dry-run
+```
+
+### Notes
+
+- This is the first release changelog, so it summarizes the full history from the initial Logics bootstrap through the 0.1.1 release preparation.
+- The package remains marked `private` in `package.json`; publication requires intentionally changing that release policy.

package/changelogs/CHANGELOGS_0_2_0.md

@@ -0,0 +1,68 @@
+# CHANGELOGS_0_2_0
+
+Release date: 2026-04-16
+
+## CDX Manager 0.2.0
+
+CDX Manager 0.2.0 focuses on operational reliability. It adds health checks, safe repair workflows, reset notifications, stronger session-store behavior, and clearer status output for choosing the best account.
+
+### At a glance
+
+- Added `cdx doctor` to inspect local CLI dependencies, `CDX_HOME` writability, missing session state, orphan profiles, and pending quarantines.
+- Added `cdx repair` with dry-run-by-default behavior and `--force` for safe repairs.
+- Added `cdx notify` to wait for reset events or the next recommended usable session.
+- Added compact status output with `cdx status --small` / `cdx status -s`.
+- Improved `cdx status` ranking so rows are sorted by practical availability.
+- Added priority guidance that explains which session to use first and which one comes next.
+- Added countdown reset formatting for reset times under 24 hours.
+- Decorated CLI output with terminal-native color support while respecting `NO_COLOR`, `CLICOLOR`, and TTY behavior.
+- Split the CLI implementation into smaller modules for status rendering, provider runtime, commands, and storage.
+
+### Doctor and repair
+
+- `cdx doctor [--json]` reports installation and data-layout health.
+- `cdx repair [--dry-run] [--force] [--json]` plans repairs by default.
+- Missing per-session state files can be recreated safely.
+- Pending quarantine profile directories can be cleaned up.
+- Orphan profiles are moved to quarantine with `--force` instead of being deleted directly.
+
+### Notifications
+
+- `cdx notify <name> --at-reset` waits for the selected session reset time.
+- `cdx notify --next-ready` waits for the recommended session to become usable or due for refresh.
+- `--poll seconds`, `--once`, and `--json` are supported.
+- macOS desktop notifications are sent through `osascript` when available, with terminal output as the consistent fallback.
+
+### Status improvements
+
+- `cdx status` now includes a direct priority line before the usage tip.
+- The priority line prefers immediately usable accounts, accounts with earlier relevant resets, and accounts without credit fallback when appropriate.
+- Reset columns use countdowns such as `in 2h 30m` under 24 hours.
+- The main `cdx` session list now formats updated timestamps as relative ages.
+- JSON status output keeps a stable shape even when live Claude refresh fails; refresh warnings are written to stderr.
+
+### Reliability and safety
+
+- Session names now reject reserved command names including `doctor`, `repair`, and `notify`.
+- Session removal uses a quarantine flow and surfaces cleanup failures instead of silently ignoring them.
+- Session-store writes fsync the containing directory after atomic replacement.
+- Session-store locking now fails explicitly when file locks cannot be acquired.
+- Codex transcript launch now supports quoted `CDX_SCRIPT_ARGS` with a `{transcript}` placeholder.
+- Codex launch falls back without transcript capture when the `script` wrapper is unavailable or fails before producing a transcript.
+- Signal interruptions no longer trigger transcript fallback relaunches.
+
+### Validation
+
+```bash
+npm run lint
+npm test
+./bin/cdx doctor
+./bin/cdx repair --dry-run
+./bin/cdx notify --next-ready --once
+./bin/cdx --version
+```
+
+### Notes
+
+- The package remains marked `private` in `package.json`; npm publication still requires an explicit policy change.
+- No Git remote is configured in the current local repository, so this release is prepared locally and tagged locally only.

package/changelogs/CHANGELOGS_0_2_1.md

@@ -0,0 +1,29 @@
+# CHANGELOGS_0_2_1
+
+Release date: 2026-04-16
+
+## CDX Manager 0.2.1
+
+CDX Manager 0.2.1 prepares the package for npm publication.
+
+### Packaging
+
+- Removed the private package flag so npm publication is possible.
+- Added npm package metadata: license, author, repository, bugs, homepage, keywords, and Node engine declaration.
+- Added `prepublishOnly` so `npm publish` runs lint and tests before publication.
+- Normalized the `bin.cdx` path with `npm pkg fix`.
+- Documented the future npm install command in the README.
+
+### Validation
+
+```bash
+npm run lint
+npm test
+npm --cache /tmp/cdx-npm-cache publish --dry-run
+npm view cdx-manager name version --registry https://registry.npmjs.org/
+```
+
+### Notes
+
+- `npm view cdx-manager` currently returns `E404`, so the package name appears available on the npm registry.
+- This release is prepared for npm publication but has not been published yet.

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "cdx-manager",
+  "version": "0.2.1",
+  "description": "Terminal session manager for Codex and Claude accounts.",
+  "license": "MIT",
+  "author": "Alexandre Agostini",
+  "homepage": "https://github.com/AlexAgo83/cdx-manager#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AlexAgo83/cdx-manager.git"
+  },
+  "bugs": {
+    "url": "https://github.com/AlexAgo83/cdx-manager/issues"
+  },
+  "keywords": [
+    "codex",
+    "claude",
+    "cli",
+    "terminal",
+    "session-manager",
+    "ai-tools"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin",
+    "changelogs",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "cdx": "bin/cdx"
+  },
+  "scripts": {
+    "test": "npm run test:py",
+    "test:py": "PYTHONPYCACHEPREFIX=/tmp/pycache python3 -m unittest discover -s test -p 'test_*_py.py'",
+    "lint": "PYTHONPYCACHEPREFIX=/tmp/pycache python3 -m py_compile bin/cdx src/*.py test/test_*_py.py",
+    "prepublishOnly": "npm run lint && npm test",
+    "link": "npm link",
+    "unlink": "npm unlink -g cdx-manager"
+  }
+}

package/src/__init__.py

@@ -0,0 +1,17 @@
+from .cli import main
+from .errors import CdxError
+from .session_service import (
+    ALLOWED_PROVIDERS,
+    DEFAULT_PROVIDER,
+    create_session_service,
+)
+from .session_store import create_session_store
+
+__all__ = [
+    "ALLOWED_PROVIDERS",
+    "CdxError",
+    "DEFAULT_PROVIDER",
+    "create_session_service",
+    "create_session_store",
+    "main",
+]

package/src/claude_refresh.py

@@ -0,0 +1,72 @@
+import inspect
+import threading
+from datetime import datetime, timezone
+
+from .claude_usage import refresh_claude_session_status
+from .errors import CdxError
+
+CLAUDE_REFRESH_TTL_SECONDS = 10 * 60
+
+
+def _parse_timestamp(value):
+    if not value:
+        return None
+    try:
+        parsed = datetime.fromisoformat(str(value).replace("Z", "+00:00"))
+    except (TypeError, ValueError):
+        return None
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=timezone.utc)
+    return parsed
+
+
+def _is_stale(session, now=None, ttl_seconds=CLAUDE_REFRESH_TTL_SECONDS):
+    status = session.get("lastStatus") or {}
+    updated_at = _parse_timestamp(status.get("updated_at") or session.get("lastStatusAt"))
+    if not updated_at:
+        return True
+    now = now or datetime.now(timezone.utc).astimezone()
+    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):
+    refresh_fn = refresh_fn or refresh_claude_session_status
+    target_names = set(target_names or [])
+    sessions = service["list_sessions"]()
+    claude_sessions = [
+        s for s in sessions
+        if s["provider"] == "claude"
+        and (not target_names or s["name"] in target_names)
+        and (force or _is_stale(s, ttl_seconds=ttl_seconds))
+    ]
+    if not claude_sessions:
+        return {"refreshed": [], "errors": []}
+
+    errors = []
+    results = {}
+    threads = []
+
+    def fetch(s):
+        try:
+            usage = refresh_fn(s)
+            if inspect.isawaitable(usage):
+                import asyncio
+                usage = asyncio.run(usage)
+            if usage:
+                results[s["name"]] = usage
+        except Exception as e:
+            errors.append({"session": s["name"], "error": e})
+
+    for s in claude_sessions:
+        t = threading.Thread(target=fetch, args=(s,))
+        threads.append(t)
+        t.start()
+    for t in threads:
+        t.join()
+
+    for name, usage in results.items():
+        try:
+            service["record_status"](name, usage)
+        except CdxError:
+            errors.append({"session": name, "error": CdxError(f"Failed to record Claude status for {name}")})
+    return {"refreshed": sorted(results), "errors": errors}