cdx-manager 0.9.16 → 0.10.0

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.9.16-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.10.0-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
 
 **Run multiple Codex, Claude, Antigravity, and Ollama sessions from one terminal. Switch between accounts instantly.**
 
@@ -41,10 +41,12 @@ One command to launch any session. Zero auth juggling.
 - **Session control.** Disable a session without deleting it when an account is temporarily out of credits; disabled sessions remain visible and sort last.
 - **Persistent launch settings.** Pin per-session power, permission, and fast-mode preferences once; `cdx` reapplies them on every launch until you unset them.
 - **Launch history.** Inspect recent launches with provider, result, duration, working directory, launch settings, and transcript path.
+- **Disk usage and cleanup.** `cdx disk` reports `CDX_HOME` usage, `cdx disk profiles --candidates` identifies reclaimable profile caches/logs with evidence, and `cdx clean profiles ...` applies explicit cleanup actions.
 - **Update prompts.** Periodic update checks surface `cdx update` directly in the `cdx`, `cdx status`, and launch output when a newer release is available. When `logics-manager` is installed, `cdx` can also suggest `logics-manager self-update`.
 - **Logics viewer shortcut.** `cdx view` opens the Logics browser/focus viewer through `logics-manager view` when the companion CLI is installed. All viewer flags are forwarded: `--lan`, `--lan-rw`, `--focus <ref>`, `--read`, `--port`, `--host`, `--refresh-interval`, `--tls`, `--tls-cert`, `--tls-key`, `--open`, `--no-open`. `cdx view --json` reports availability and update diagnostics without opening the viewer.
 - **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.
+- **Banked reset visibility.** Eligible Codex accounts show the number of manually redeemable bonus resets in `cdx status` and expose reset details in JSON output.
 - **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.
 
@@ -265,6 +267,10 @@ cdx next
 
 # Notify when the next cooling-down assistant is ready
 cdx ready
+
+# Inspect CDX_HOME and profile disk usage
+cdx disk
+cdx disk profiles --candidates
 ```
 
 ### Next-Ready Notifications
@@ -358,7 +364,10 @@ cdx history --summary --from 2026-05-01 --to 2026-05-28
 | `cdx handoff <name> [--json]` | Install the current workspace context into a target session and launch it unless `--json` is used |
 | `cdx handoff <source> <target> [--json]` | Build shared context from the source session's latest launch transcript, install it into the target session, and launch the target unless `--json` is used; supports cross-provider handoff |
 | `cdx rmv <name> [--force] [--json]` | Remove a session and its auth data (prompts for confirmation unless `--force`) |
-| `cdx clean [name] [--json]` | Clear launch transcript logs for one session or all sessions |
+| `cdx clean [name] [--yes] [--json]` | Clear launch transcript logs for one session or all sessions after confirmation |
+| `cdx clean profiles (--tmp\|--old-logs DAYS) [--yes] [--json]` | Remove explicit profile cleanup candidates after confirmation: temporary marketplace/plugin staging caches or old `.log` files |
+| `cdx disk [profiles] [--candidates] [--json]` | Measure `CDX_HOME`; `profiles` includes per-profile breakdown, and `--candidates` reports reclaimable temporary caches and old logs with evidence |
+| `cdx reset <name> [--yes] [--json]` | Explicitly consume one available banked Codex rate-limit reset; confirmation is required unless `--yes` is supplied |
 | `cdx export <file> [--include-auth] [--sessions a,b] [--passphrase-env VAR\|--passphrase-stdin] [--force] [--json]` | Export sessions to a portable bundle; `--include-auth` encrypts auth data with a passphrase |
 | `cdx import <file> [--sessions a,b] [--passphrase-env VAR\|--passphrase-stdin] [--force] [--json]` | Import sessions from a bundle into the current `CDX_HOME` |
 | `cdx doctor [--json]` | Inspect CLI dependencies, CDX_HOME permissions, missing state, orphan profiles, and pending quarantines |
@@ -394,6 +403,8 @@ Commands with machine-readable output:
 - `cdx ren ... --json`
 - `cdx rmv ... --json`
 - `cdx clean ... --json`
+- `cdx disk ... --json`
+- `cdx reset ... --json`
 - `cdx export ... --json`
 - `cdx import ... --json`
 - `cdx login ... --json`
@@ -602,7 +613,68 @@ All session data lives under `CDX_HOME` (default: `~/.cdx/`):
           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.
+Session names are URL-encoded when used as directory or file names. CLI command names such as `add`, `disk`, `status`, and `login` are reserved and cannot be used as new session names.
+
+### Disk maintenance
+
+Use `cdx disk` for a total `CDX_HOME` measurement, and `cdx disk profiles` for the `profiles/` total plus a per-profile breakdown.
+
+In an interactive terminal, long scans report their current stage and per-profile progress on stderr. JSON and redirected output remain free of progress messages.
+
+Text output uses aligned summary tables with profile size, share of total space, and reclaimable space. Candidate details are grouped by profile with separate size, type, risk, and evidence columns.
+
+```bash
+cdx disk
+cdx disk profiles
+```
+
+To find cleanup candidates without deleting anything:
+
+```bash
+cdx disk profiles --candidates
+cdx disk profiles --candidates --json
+```
+
+Candidate evidence includes profile name, path, size, risk, reason, and metadata such as modified time or old-log file counts. The current cleanup candidates are intentionally limited to:
+
+- temporary marketplace/plugin staging caches under `profiles/*/.tmp/`
+- `.log` files older than the requested age inside profile `log/` directories
+
+`cdx` also runs a passive disk cleanup check at most once per day on advisory commands such as `cdx` and `cdx status`. It writes the check timestamp and latest measurements to `~/.cdx/state/disk-cleanup-check.json`. A warning is shown only when at least one threshold is met:
+
+- `CDX_HOME` uses 10 GB or more
+- cleanup candidates can reclaim 1 GB or more
+- temporary cache candidates can reclaim 500 MB or more
+- old log candidates can reclaim 500 MB or more
+- one profile is 2 GB or more, or one profile is at least 25% of `profiles/` when `profiles/` is already 1 GB or more
+
+The passive warning is read-only and points to `cdx disk profiles --candidates`; it never deletes files.
+
+Apply cleanup only with explicit actions:
+
+```bash
+cdx clean profiles --tmp
+cdx clean profiles --old-logs 30d
+```
+
+`--tmp` removes temporary marketplace/plugin clone/backup staging directories. `--old-logs 30d` removes only `.log` files older than 30 days. The commands do not remove `auth.json`, `config.toml`, `sessions/`, SQLite state, installed `plugins/`, `skills/`, or credentials.
+
+All `cdx clean` actions require interactive confirmation before any deletion or log truncation begins. Non-interactive scripts must pass `--yes` explicitly.
+
+The cleanup action is selected only when `--tmp` or `--old-logs` is present. This keeps `cdx clean profiles` available for an existing session named `profiles`. If any candidate or old log cannot be removed, cleanup stops with a non-zero error that identifies the affected path; it does not report the operation as successful.
+
+### Banked Codex resets
+
+Eligible Codex accounts expose manually redeemable rate-limit resets through the Codex app-server. `cdx status` shows their available count in the `RESETS` column; `cdx status <name>` also shows the nearest known expiration, and JSON status includes the available reset details supplied by Codex.
+
+Activation is always explicit:
+
+```bash
+cdx reset <name>
+cdx reset <name> --yes --json
+```
+
+Without `--yes`, an interactive confirmation is required. `cdx` sends an idempotency key, consumes at most one available reset, and refreshes the session status after a successful activation. It never activates a reset from `cdx status` or any background check.
 
 ---
 

package/changelogs/CHANGELOGS_0_10_0.md

@@ -0,0 +1,43 @@
+# CDX Manager 0.10.0
+
+## Highlights
+
+- Inspect `CDX_HOME` and per-profile disk usage with readable, progress-aware reports.
+- Find evidence-backed cleanup candidates and reclaim space through confirmed actions.
+- Display and explicitly activate banked Codex rate-limit resets.
+
+## Changes
+
+### Disk usage and cleanup
+
+`cdx disk` measures total `CDX_HOME` usage. `cdx disk profiles` adds an aligned per-profile table with size and share of total space, while `--candidates` adds reclaimable totals and evidence grouped by profile.
+
+Interactive scans report their current stage and profile count on stderr so large profiles no longer appear stalled. JSON and redirected output remain unchanged.
+
+Cleanup candidates are intentionally limited to temporary marketplace/plugin staging directories and old `.log` files. `cdx clean profiles --tmp` and `cdx clean profiles --old-logs DAYS` require confirmation before deletion; all other `cdx clean` log-truncation actions now require confirmation as well. Non-interactive automation must opt in with `--yes`.
+
+A passive read-only check runs at most once per day and warns when documented total, reclaimable, category, or large-profile thresholds are reached. It never removes files automatically.
+
+### Banked Codex resets
+
+Eligible Codex accounts now show banked rate-limit reset counts in `cdx status`. Detailed JSON includes reset identifiers, labels, grant timestamps, and expiration timestamps when Codex provides them.
+
+`cdx reset <name>` consumes one reset through Codex's idempotent reset-credit endpoint, requires confirmation unless `--yes` is supplied, and refreshes status after activation. Status checks never consume resets automatically.
+
+### Compatibility and safeguards
+
+`disk` and `reset` are reserved for new session names. Existing sessions named `profiles` remain compatible with `cdx clean profiles`; profile-wide cleanup is selected only when `--tmp` or `--old-logs` is present.
+
+Cleanup failures now stop with a non-zero error naming the affected path instead of silently reporting zero bytes removed.
+
+## Validation
+
+- `npm run release:validate`
+- `npm run lint`
+- `npm test`
+- `logics-manager lint --require-status`
+- `logics-manager audit`
+- `git diff --check`
+- `npm --cache /private/tmp/cdx-npm-cache pack --dry-run`
+- `python -m build`
+- `python -m twine check dist/*`

package/checksums/release-archives.json

@@ -128,6 +128,10 @@
     "v0.9.15": {
       "github_tarball_sha256": "08e6c5a3459fdd65d1f6085ca03a3614f07b4bf44c57a995a3ef47446aa70482",
       "github_zip_sha256": "c8ac01f4a65e85b417f5eba5139868ab17b8f0952bf99f17f0a79f73ef0f36d6"
+    },
+    "v0.9.16": {
+      "github_tarball_sha256": "0876509c201485824f6e5fe7b4a96ceb41cc68279fbe6dda4891864cf5be93ec",
+      "github_zip_sha256": "08072957a0421d257cecfa8bed73cceee80d1c8857c59ac45378ac8ce3e0362d"
     }
   }
 }

package/package.json

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

package/src/cli.py

@@ -3,10 +3,14 @@
 import json
 import os
 import sys
+from datetime import datetime, timezone
 
 from .cli_commands import (
     API_SCHEMA_VERSION,
     STATUS_USAGE,
+    _collect_profile_cleanup_candidates,
+    _directory_child_sizes,
+    _directory_size_bytes,
     handle_add,
     handle_can_resume,
     handle_clean,
@@ -15,6 +19,7 @@ from .cli_commands import (
     handle_context,
     handle_copy,
     handle_disable,
+    handle_disk,
     handle_doctor,
     handle_enable,
     handle_export,
@@ -31,6 +36,7 @@ from .cli_commands import (
     handle_remove,
     handle_rename,
     handle_repair,
+    handle_reset,
     handle_resume,
     handle_run,
     handle_run_report,
@@ -44,6 +50,9 @@ from .cli_commands import (
     handle_update,
     handle_view,
 )
+from .cli_commands import (
+    _format_bytes as _format_disk_bytes,
+)
 from .cli_render import (
     _format_sessions,
     _pad_table,
@@ -66,7 +75,7 @@ from .status_view import (
 )
 from .update_check import check_for_update, check_logics_manager_for_update
 
-VERSION = "0.9.16"
+VERSION = "0.10.0"
 
 # Public surface: this module is a facade. Names below are imported above
 # purely to be re-exported (consumed by tests and external callers); listing
@@ -94,6 +103,7 @@ _COMMAND_HANDLERS = {
     "config": handle_config,
     "configs": handle_configs,
     "context": handle_context,
+    "disk": handle_disk,
     "doctor": handle_doctor,
     "disable": handle_disable,
     "enable": handle_enable,
@@ -107,6 +117,7 @@ _COMMAND_HANDLERS = {
     "next": handle_next,
     "notify": handle_notify,
     "repair": handle_repair,
+    "reset": handle_reset,
     "rename": handle_rename,
     "resume": handle_resume,
     "can-resume": handle_can_resume,
@@ -165,12 +176,14 @@ def _print_help(use_color=False):
         f"  {_style('cdx status --small|-s [--refresh|--cached] [--timeout SECONDS]', '36', use_color)}",
         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 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) [--provider PROVIDER] [--model MODEL] [--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] --json', '36', use_color)}",
         f"  {_style('cdx runs [--limit N] --json', '36', use_color)}",
         f"  {_style('cdx run-status <run_id> --json', '36', use_color)}",
         f"  {_style('cdx run-report <run_id> --json', '36', use_color)}",
         f"  {_style('cdx context show|path|init|edit|clear|set [text...] [--json]', '36', use_color)}",
+        f"  {_style('cdx disk [profiles] [--candidates] [--json]', '36', use_color)}",
         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)}",
@@ -191,7 +204,8 @@ def _print_help(use_color=False):
         f"  {_style('cdx disable <name> [--json]', '36', use_color)}",
         f"  {_style('cdx enable <name> [--json]', '36', use_color)}",
         f"  {_style('cdx rmv <name> [--force] [--json]', '36', use_color)}",
-        f"  {_style('cdx clean [name] [--json]', '36', use_color)}",
+        f"  {_style('cdx clean [name] [--yes] [--json]', '36', use_color)}",
+        f"  {_style('cdx clean profiles (--tmp|--old-logs DAYS) [--yes] [--json]', '36', use_color)}",
         f"  {_style('cdx export <file> [--include-auth] [--sessions a,b] [--passphrase-env VAR|--passphrase-stdin] [--force] [--json]', '36', use_color)}",
         f"  {_style('cdx import <file> [--sessions a,b] [--passphrase-env VAR|--passphrase-stdin] [--force|--merge] [--json]', '36', use_color)}",
         f"  {_style('cdx doctor [--json]', '36', use_color)}",
@@ -264,9 +278,154 @@ def _get_update_notices(service, env, options):
     )
     if logics_notice:
         notices.append(logics_notice)
+    disk_notice = _get_disk_cleanup_notice(service, options)
+    if disk_notice:
+        notices.append(disk_notice)
     return notices
 
 
+_DISK_CHECK_INTERVAL_SECONDS = 24 * 60 * 60
+_DISK_HOME_THRESHOLD_BYTES = 10 * 1024 * 1024 * 1024
+_DISK_RECLAIMABLE_THRESHOLD_BYTES = 1 * 1024 * 1024 * 1024
+_DISK_CATEGORY_THRESHOLD_BYTES = 500 * 1024 * 1024
+_DISK_PROFILE_THRESHOLD_BYTES = 2 * 1024 * 1024 * 1024
+
+
+def _now_utc(options):
+    now_fn = options.get("now")
+    value = now_fn() if callable(now_fn) else None
+    if isinstance(value, datetime):
+        return value.astimezone(timezone.utc)
+    return datetime.now(timezone.utc)
+
+
+def _read_json_file(path):
+    try:
+        with open(path, encoding="utf-8") as handle:
+            return json.load(handle)
+    except (OSError, ValueError):
+        return {}
+
+
+def _write_json_file(path, payload):
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    tmp_path = f"{path}.tmp"
+    with open(tmp_path, "w", encoding="utf-8") as handle:
+        json.dump(payload, handle, indent=2, sort_keys=True)
+        handle.write("\n")
+    os.replace(tmp_path, path)
+
+
+def _parse_iso_datetime(value):
+    if not value:
+        return None
+    try:
+        return datetime.fromisoformat(str(value).replace("Z", "+00:00")).astimezone(timezone.utc)
+    except ValueError:
+        return None
+
+
+def _get_disk_cleanup_notice(service, options):
+    checker = options.get("checkDiskCleanup")
+    if callable(checker):
+        return checker(service, options)
+
+    base_dir = service["base_dir"]
+    state_path = os.path.join(base_dir, "state", "disk-cleanup-check.json")
+    now = _now_utc(options)
+    state = _read_json_file(state_path)
+    last_checked = _parse_iso_datetime(state.get("last_checked_at"))
+    if last_checked and (now - last_checked).total_seconds() < _DISK_CHECK_INTERVAL_SECONDS:
+        return None
+
+    runner = options.get("diskUsageRunner")
+    try:
+        home_bytes = _directory_size_bytes(base_dir, runner=runner)
+        profiles_dir = os.path.join(base_dir, "profiles")
+        profile_rows = _directory_child_sizes(profiles_dir, runner=runner)
+        profile_total = sum(row["bytes"] for row in profile_rows)
+        candidates = _collect_profile_cleanup_candidates(base_dir, runner=runner, now=now.timestamp())
+    except Exception:
+        return None
+
+    reclaimable_bytes = sum(item["bytes"] for item in candidates)
+    tmp_bytes = sum(item["bytes"] for item in candidates if item["kind"].startswith("tmp-"))
+    old_log_bytes = sum(item["bytes"] for item in candidates if item["kind"].startswith("old-logs-"))
+    large_profiles = [
+        {
+            "name": row["name"],
+            "bytes": row["bytes"],
+            "size": _format_disk_bytes(row["bytes"]),
+            "share_pct": round((row["bytes"] / profile_total) * 100, 1) if profile_total else 0,
+        }
+        for row in profile_rows
+        if row["bytes"] >= _DISK_PROFILE_THRESHOLD_BYTES
+        or (
+            profile_total >= _DISK_RECLAIMABLE_THRESHOLD_BYTES
+            and row["bytes"] / profile_total >= 0.25
+        )
+    ]
+    triggered = (
+        home_bytes >= _DISK_HOME_THRESHOLD_BYTES
+        or reclaimable_bytes >= _DISK_RECLAIMABLE_THRESHOLD_BYTES
+        or tmp_bytes >= _DISK_CATEGORY_THRESHOLD_BYTES
+        or old_log_bytes >= _DISK_CATEGORY_THRESHOLD_BYTES
+        or bool(large_profiles)
+    )
+    state_payload = {
+        "last_checked_at": now.isoformat(),
+        "home_bytes": home_bytes,
+        "reclaimable_bytes": reclaimable_bytes,
+        "tmp_bytes": tmp_bytes,
+        "old_log_bytes": old_log_bytes,
+        "large_profiles": large_profiles,
+    }
+    try:
+        _write_json_file(state_path, state_payload)
+    except OSError:
+        pass
+    if not triggered:
+        return None
+
+    if reclaimable_bytes > 0:
+        message = (
+            f"Disk cleanup available: {_format_disk_bytes(reclaimable_bytes)} reclaimable "
+            f"in CDX profiles. Inspect: cdx disk profiles --candidates"
+        )
+    else:
+        message = (
+            f"CDX_HOME uses {_format_disk_bytes(home_bytes)}. "
+            "Inspect: cdx disk profiles --candidates"
+        )
+    if tmp_bytes >= _DISK_CATEGORY_THRESHOLD_BYTES:
+        message = (
+            f"{message}. Safe temp cleanup: {_format_disk_bytes(tmp_bytes)} "
+            "with cdx clean profiles --tmp"
+        )
+    if old_log_bytes >= _DISK_CATEGORY_THRESHOLD_BYTES:
+        message = (
+            f"{message}. Old logs: {_format_disk_bytes(old_log_bytes)} "
+            "with cdx clean profiles --old-logs 30d"
+        )
+    return {
+        "tool": "cdx-disk",
+        "code": "disk_cleanup_available",
+        "message": message,
+        "reclaimable_bytes": reclaimable_bytes,
+        "reclaimable_size": _format_disk_bytes(reclaimable_bytes),
+        "home_bytes": home_bytes,
+        "home_size": _format_disk_bytes(home_bytes),
+        "tmp_bytes": tmp_bytes,
+        "tmp_size": _format_disk_bytes(tmp_bytes),
+        "old_log_bytes": old_log_bytes,
+        "old_log_size": _format_disk_bytes(old_log_bytes),
+        "large_profiles": large_profiles,
+        "inspect_command": "cdx disk profiles --candidates",
+        "cleanup_tmp_command": "cdx clean profiles --tmp" if tmp_bytes >= _DISK_CATEGORY_THRESHOLD_BYTES else None,
+        "cleanup_old_logs_command": "cdx clean profiles --old-logs 30d" if old_log_bytes >= _DISK_CATEGORY_THRESHOLD_BYTES else None,
+    }
+
+
 def _update_warning_payload(notices):
     if isinstance(notices, dict):
         notices = [notices]
@@ -274,6 +433,13 @@ def _update_warning_payload(notices):
         return []
     warnings = []
     for notice in notices:
+        if notice.get("code") == "disk_cleanup_available":
+            warnings.append({
+                "code": "disk_cleanup_available",
+                "message": notice["message"],
+                **{key: value for key, value in notice.items() if key not in ("code", "message")},
+            })
+            continue
         tool = notice.get("tool") or "cdx-manager"
         current = notice.get("current_version") or VERSION
         command = notice.get("update_command") or ("cdx update" if tool == "cdx-manager" else None)

package/src/cli_args.py

@@ -13,6 +13,7 @@ from .provider_runtime import _normalize_reasoning_effort
 
 STATUS_USAGE = "Usage: cdx status [--json] [--refresh|--cached] [--timeout SECONDS] | cdx status --small|-s [--refresh|--cached] [--timeout SECONDS] | cdx status <name> [--json] [--refresh|--cached] [--timeout SECONDS]"
 DOCTOR_USAGE = "Usage: cdx doctor [--json]"
+DISK_USAGE = "Usage: cdx disk [profiles] [--candidates] [--json]"
 REPAIR_USAGE = "Usage: cdx repair [--dry-run] [--force] [--json]"
 UPDATE_USAGE = "Usage: cdx update [--check] [--yes] [--json] [--version TAG]"
 EXPORT_USAGE = "Usage: cdx export <file> [--include-auth] [--force] [--json] [--sessions name1,name2] [--passphrase-env VAR|--passphrase-stdin]"

package/src/cli_commands.py

@@ -4,8 +4,11 @@ import json
 import os
 import re
 import shlex
+import shutil
+import subprocess
 import sys
 import time
+import uuid
 from datetime import datetime
 
 from .backup_bundle import read_bundle_meta
@@ -13,6 +16,7 @@ from .claude_refresh import _refresh_claude_sessions
 from .cli_args import (
     CAN_RESUME_USAGE,
     CONTEXT_USAGE,
+    DISK_USAGE,
     DOCTOR_USAGE,
     HANDOFF_USAGE,
     LAST_USAGE,
@@ -66,9 +70,10 @@ from .cli_helpers import (
     _write_json,
     _write_update_notice,
 )
-from .cli_render import _dim, _info, _style, _success, _warn
+from .cli_render import _dim, _info, _pad_table, _style, _success, _warn
 from .cli_view import handle_view as handle_view  # re-export for cli.py / tests
-from .config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_OLLAMA
+from .codex_usage import consume_codex_rate_limit_reset_credit
+from .config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDER_OLLAMA
 from .context_store import (
     clear_context,
     edit_context,
@@ -140,6 +145,21 @@ def _confirm_removal(name):
     return answer.strip().lower() in ("y", "yes")
 
 
+def _confirm_reset(name):
+    answer = input(f"Consume one banked Codex reset for {name}? [y/N] ")
+    return answer.strip().lower() in ("y", "yes")
+
+
+def _confirm_profile_cleanup(action):
+    answer = input(f"Delete matching profile {action} candidates? [y/N] ")
+    return answer.strip().lower() in ("y", "yes")
+
+
+def _confirm_log_cleanup(target):
+    answer = input(f"Clear launch transcript logs for {target}? [y/N] ")
+    return answer.strip().lower() in ("y", "yes")
+
+
 def _resolve_confirmation(confirm_fn, name):
     confirmed = (
         asyncio.get_event_loop().run_until_complete(confirm_fn(name))
@@ -151,6 +171,412 @@ def _resolve_confirmation(confirm_fn, name):
     return confirmed
 
 
+def _format_bytes(value):
+    size = float(value)
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if size < 1024 or unit == "TB":
+            return f"{int(size)} {unit}" if unit == "B" or size.is_integer() else f"{size:.1f} {unit}"
+        size /= 1024
+
+
+def _directory_size_bytes(path, runner=None):
+    if not os.path.exists(path):
+        raise CdxError(f"CDX home does not exist: {path}")
+    runner = runner or subprocess.check_output
+    try:
+        output = runner(["du", "-sk", path], text=True, stderr=subprocess.DEVNULL)
+        return int(str(output).split()[0]) * 1024
+    except (OSError, subprocess.CalledProcessError, ValueError, IndexError):
+        total = 0
+        for root, _, files in os.walk(path):
+            for name in files:
+                try:
+                    total += os.path.getsize(os.path.join(root, name))
+                except OSError:
+                    pass
+        return total
+
+
+def _directory_child_sizes(path, runner=None, progress=None):
+    rows = []
+    try:
+        names = os.listdir(path)
+    except OSError:
+        return rows
+    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):
+        if progress:
+            progress("profile", name, index, len(children))
+        rows.append({
+            "name": name,
+            "path": child_path,
+            "bytes": _directory_size_bytes(child_path, runner=runner),
+        })
+    rows.sort(key=lambda row: row["bytes"], reverse=True)
+    for row in rows:
+        row["size"] = _format_bytes(row["bytes"])
+    return rows
+
+
+def _parse_days(value, usage):
+    match = re.fullmatch(r"(\d+)(?:d)?", str(value or "").strip())
+    if not match or int(match.group(1)) <= 0:
+        raise CdxError(usage)
+    return int(match.group(1))
+
+
+def _candidate(profile, kind, path, bytes_used, reason, risk="safe", evidence=None):
+    return {
+        "profile": profile,
+        "kind": kind,
+        "path": path,
+        "bytes": bytes_used,
+        "size": _format_bytes(bytes_used),
+        "reason": reason,
+        "risk": risk,
+        "evidence": evidence or {},
+    }
+
+
+def _iter_profile_dirs(base_dir):
+    profiles_dir = os.path.join(base_dir, "profiles")
+    try:
+        names = sorted(os.listdir(profiles_dir))
+    except OSError:
+        return
+    for name in names:
+        path = os.path.join(profiles_dir, name)
+        if os.path.isdir(path):
+            yield name, path
+
+
+def _collect_old_logs(profile_name, profile_path, days, now=None):
+    cutoff = (time.time() if now is None else now) - (days * 86400)
+    paths = []
+    bytes_used = 0
+    latest_mtime = 0
+    for root, _, files in os.walk(profile_path):
+        if os.path.basename(root) != "log":
+            continue
+        for filename in files:
+            if not filename.endswith(".log"):
+                continue
+            path = os.path.join(root, filename)
+            try:
+                stat = os.stat(path)
+            except OSError:
+                continue
+            if stat.st_mtime >= cutoff:
+                continue
+            paths.append(path)
+            bytes_used += stat.st_size
+            latest_mtime = max(latest_mtime, stat.st_mtime)
+    if not paths:
+        return None
+    return _candidate(
+        profile_name,
+        f"old-logs-{days}d",
+        profile_path,
+        bytes_used,
+        f"{len(paths)} .log files older than {days}d",
+        risk="review",
+        evidence={
+            "days": days,
+            "file_count": len(paths),
+            "newest_old_log_mtime": datetime.fromtimestamp(latest_mtime).isoformat() if latest_mtime else None,
+            "sample_paths": paths[:5],
+        },
+    )
+
+
+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))
+        tmp_dir = os.path.join(profile_path, ".tmp")
+        tmp_targets = [
+            ("tmp-marketplaces", os.path.join(tmp_dir, "marketplaces"), "temporary marketplace cache/staging"),
+        ]
+        try:
+            tmp_names = os.listdir(tmp_dir)
+        except OSError:
+            tmp_names = []
+        for name in tmp_names:
+            if name.startswith("plugins-clone-"):
+                tmp_targets.append(("tmp-plugin-clone", os.path.join(tmp_dir, name), "temporary plugin clone"))
+            elif name.startswith("plugins-backup-"):
+                tmp_targets.append(("tmp-plugin-backup", os.path.join(tmp_dir, name), "temporary plugin backup"))
+        for kind, path, reason in tmp_targets:
+            if not os.path.exists(path):
+                continue
+            bytes_used = _directory_size_bytes(path, runner=runner)
+            if bytes_used <= 0:
+                continue
+            try:
+                mtime = datetime.fromtimestamp(os.path.getmtime(path)).isoformat()
+            except OSError:
+                mtime = None
+            candidates.append(_candidate(
+                profile_name,
+                kind,
+                path,
+                bytes_used,
+                reason,
+                evidence={"modified_at": mtime},
+            ))
+        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)
+    candidates.sort(key=lambda item: item["bytes"], reverse=True)
+    return candidates
+
+
+def _format_cleanup_candidates(candidates, use_color=False):
+    if not candidates:
+        return _dim("No cleanup candidates found.", use_color)
+    reclaimable = sum(item["bytes"] for item in candidates)
+    lines = [
+        _style("Cleanup candidates", "1", use_color),
+        f"{_style(_format_bytes(reclaimable), '33', use_color)} reclaimable across {len({item['profile'] for item in candidates})} profile(s)",
+    ]
+    by_profile = {}
+    for item in candidates:
+        by_profile.setdefault(item["profile"], []).append(item)
+    for profile, items in sorted(by_profile.items(), key=lambda row: sum(i["bytes"] for i in row[1]), reverse=True):
+        total = sum(item["bytes"] for item in items)
+        lines.extend(["", f"{_style(profile, '1', use_color)}  {_style(_format_bytes(total), '33', use_color)}"])
+        rows = [[
+            _style("SIZE", "1", use_color),
+            _style("TYPE", "1", use_color),
+            _style("RISK", "1", use_color),
+            _style("EVIDENCE", "1", use_color),
+        ]]
+        for item in items:
+            risk_color = "32" if item["risk"] == "safe" else "33"
+            rows.append([
+                _style(item["size"], "36", use_color),
+                item["kind"],
+                _style(item["risk"], risk_color, use_color),
+                item["reason"],
+            ])
+        lines.append(_pad_table(rows))
+    return "\n".join(lines)
+
+
+def _format_disk_report(payload, use_color=False):
+    title = "CDX profiles" if payload["target"] == "profiles" else "CDX home"
+    lines = [
+        _style(title, "1", use_color),
+        f"Path:  {_dim(payload['path'], use_color)}",
+        f"Total: {_style(payload['size'], '36', use_color)}",
+    ]
+    children = payload.get("children") or []
+    if children:
+        reclaimable_by_profile = {}
+        for item in payload.get("candidates") or []:
+            reclaimable_by_profile[item["profile"]] = reclaimable_by_profile.get(item["profile"], 0) + item["bytes"]
+        headers = ["PROFILE", "SIZE", "SHARE"]
+        if "candidates" in payload:
+            headers.append("RECLAIMABLE")
+        rows = [[_style(header, "1", use_color) for header in headers]]
+        for child in children:
+            share = (child["bytes"] / payload["bytes"] * 100) if payload["bytes"] else 0
+            row = [
+                _style(child["name"], "1", use_color),
+                _style(child["size"], "36", use_color),
+                f"{share:.1f}%",
+            ]
+            if "candidates" in payload:
+                reclaimable = reclaimable_by_profile.get(child["name"], 0)
+                row.append(_style(_format_bytes(reclaimable), "33", use_color) if reclaimable else _dim("-", use_color))
+            rows.append(row)
+        lines.extend(["", _style(f"Profiles ({len(children)})", "1", use_color), _pad_table(rows)])
+    if "candidates" in payload:
+        lines.extend(["", _format_cleanup_candidates(payload["candidates"], use_color=use_color)])
+    return "\n".join(lines)
+
+
+def _remove_path(path):
+    try:
+        if os.path.isdir(path):
+            size = _directory_size_bytes(path)
+            shutil.rmtree(path)
+        else:
+            size = os.path.getsize(path)
+            os.remove(path)
+        return size
+    except OSError as error:
+        raise CdxError(f"Failed to remove cleanup candidate {path}: {error}") from error
+
+
+def _clean_profile_tmp(profile_path):
+    tmp_dir = os.path.join(profile_path, ".tmp")
+    targets = [os.path.join(tmp_dir, "marketplaces")]
+    try:
+        names = os.listdir(tmp_dir)
+    except OSError:
+        names = []
+    targets.extend(os.path.join(tmp_dir, name) for name in names if name.startswith(("plugins-clone-", "plugins-backup-")))
+    freed = 0
+    removed = []
+    for path in targets:
+        if os.path.exists(path):
+            size = _remove_path(path)
+            if size:
+                freed += size
+                removed.append(path)
+    return freed, removed
+
+
+def _clean_profile_old_logs(profile_path, days, now=None):
+    cutoff = (time.time() if now is None else now) - (days * 86400)
+    freed = 0
+    removed = []
+    for root, _, files in os.walk(profile_path):
+        if os.path.basename(root) != "log":
+            continue
+        for filename in files:
+            if not filename.endswith(".log"):
+                continue
+            path = os.path.join(root, filename)
+            try:
+                stat = os.stat(path)
+            except OSError:
+                continue
+            if stat.st_mtime >= cutoff:
+                continue
+            try:
+                os.remove(path)
+            except OSError as error:
+                raise CdxError(f"Failed to remove old log {path}: {error}") from error
+            freed += stat.st_size
+            removed.append(path)
+    return freed, removed
+
+
+def _handle_clean_profiles(args, ctx, json_flag):
+    usage = "Usage: cdx clean profiles (--tmp|--old-logs DAYS) [--yes] [--json]"
+    yes = "--yes" in args
+    args = [arg for arg in args if arg != "--yes"]
+    clean_tmp = "--tmp" in args
+    old_logs = None
+    if "--old-logs" in args:
+        index = args.index("--old-logs")
+        if index + 1 >= len(args):
+            raise CdxError(usage)
+        old_logs = _parse_days(args[index + 1], usage)
+        args = [arg for i, arg in enumerate(args) if i not in (index, index + 1)]
+    args = [arg for arg in args if arg != "--tmp"]
+    if args or clean_tmp == (old_logs is not None):
+        raise CdxError(usage)
+
+    action = "temporary cache" if clean_tmp else f"logs older than {old_logs}d"
+    if not yes:
+        confirm_fn = ctx["options"].get("confirmProfileCleanup")
+        if confirm_fn:
+            confirmed = _resolve_confirmation(confirm_fn, action)
+        elif not ctx["stdin_is_tty"]:
+            raise CdxError("Profile cleanup requires an interactive terminal or --yes in non-interactive mode.")
+        else:
+            confirmed = _confirm_profile_cleanup(action)
+        if not confirmed:
+            if json_flag:
+                _write_json(ctx, _json_success("clean.profiles", "Cancelled.", cancelled=True, freed_bytes=0, freed_size="0 B", profiles=[]))
+                return 0
+            ctx["out"](f"{_warn('Cancelled.', ctx['use_color'])}\n")
+            return 0
+
+    results = []
+    now = ctx["options"].get("now")() if callable(ctx["options"].get("now")) else None
+    for profile_name, profile_path in _iter_profile_dirs(ctx["service"]["base_dir"]):
+        if clean_tmp:
+            freed, removed = _clean_profile_tmp(profile_path)
+            result_action = "tmp"
+        else:
+            freed, removed = _clean_profile_old_logs(profile_path, old_logs, now=now)
+            result_action = f"old-logs-{old_logs}d"
+        if not freed and not removed:
+            continue
+        results.append({
+            "profile": profile_name,
+            "action": result_action,
+            "freed_bytes": freed,
+            "freed_size": _format_bytes(freed),
+            "removed_count": len(removed),
+            "removed_paths": removed,
+        })
+    total = sum(item["freed_bytes"] for item in results)
+    if json_flag:
+        _write_json(ctx, _json_success("clean.profiles", f"Cleaned profiles ({_format_bytes(total)} freed)", cancelled=False, freed_bytes=total, freed_size=_format_bytes(total), profiles=results))
+        return 0
+    if not results:
+        ctx["out"](f"{_dim('No matching profile cleanup candidates found.', ctx['use_color'])}\n")
+        return 0
+    for item in results:
+        message = f"Cleaned {item['profile']} {item['action']} ({item['freed_size']} freed)"
+        ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    ctx["out"](f"{_success(f'Total freed: {_format_bytes(total)}', ctx['use_color'])}\n")
+    return 0
+
+
+def handle_disk(rest, ctx):
+    parsed = _parse_flag_args(rest, {
+        "--candidates": {"key": "candidates", "type": "bool", "default": False},
+        "--json": {"key": "json", "type": "bool", "default": False},
+    }, DISK_USAGE, positionals_key="targets", max_positionals=1)
+    target = parsed["targets"][0] if parsed["targets"] else "home"
+    if target == "home":
+        path = ctx["service"]["base_dir"]
+    elif target == "profiles":
+        path = os.path.join(ctx["service"]["base_dir"], "profiles")
+    else:
+        raise CdxError(DISK_USAGE)
+    stderr = ctx["options"].get("stderr", sys.stderr)
+    show_progress = not parsed["json"] and hasattr(stderr, "isatty") and stderr.isatty()
+
+    def progress(stage, name=None, index=None, total=None):
+        if not show_progress:
+            return
+        if stage == "total":
+            label = "CDX profiles" if target == "profiles" else "CDX home"
+            ctx["err"](f"Measuring {label} disk usage...\n")
+        elif stage == "profile":
+            ctx["err"](f"Measuring profile {name} ({index}/{total})...\n")
+        elif stage == "candidates":
+            ctx["err"](f"Scanning cleanup candidates in {name} ({index}/{total})...\n")
+
+    progress("total")
+    bytes_used = _directory_size_bytes(path, runner=ctx["options"].get("diskUsageRunner"))
+    payload = {
+        "target": target,
+        "path": path,
+        "bytes": bytes_used,
+        "size": _format_bytes(bytes_used),
+    }
+    if target == "profiles":
+        payload["children"] = _directory_child_sizes(path, runner=ctx["options"].get("diskUsageRunner"), progress=progress)
+    if parsed["candidates"]:
+        if target != "profiles":
+            raise CdxError(DISK_USAGE)
+        candidates = _collect_profile_cleanup_candidates(
+            ctx["service"]["base_dir"],
+            runner=ctx["options"].get("diskUsageRunner"),
+            now=ctx["options"].get("now")() if callable(ctx["options"].get("now")) else None,
+            progress=progress,
+        )
+        payload["candidates"] = candidates
+        payload["reclaimable_bytes"] = sum(item["bytes"] for item in candidates)
+        payload["reclaimable_size"] = _format_bytes(payload["reclaimable_bytes"])
+    if parsed["json"]:
+        label = "CDX profiles" if target == "profiles" else "CDX home"
+        _write_json(ctx, _json_success("disk", f"Measured {label} disk usage: {payload['size']}", disk=payload))
+        return 0
+    ctx["out"](f"{_format_disk_report(payload, use_color=ctx['use_color'])}\n")
+    return 0
+
+
 def _extract_claude_oauth_token(text):
     if not text:
         return None
@@ -1309,6 +1735,10 @@ def handle_last(rest, ctx):
 
 def handle_clean(rest, ctx):
     json_flag, args = _parse_json_flag(rest)
+    if args[:1] == ["profiles"] and any(arg in ("--tmp", "--old-logs") for arg in args[1:]):
+        return _handle_clean_profiles(args[1:], ctx, json_flag)
+    yes = "--yes" in args
+    args = [arg for arg in args if arg != "--yes"]
     service = ctx["service"]
     if len(args) == 0:
         targets = service["list_sessions"]()
@@ -1318,7 +1748,23 @@ def handle_clean(rest, ctx):
             raise CdxError(f"Unknown session: {args[0]}")
         targets = [session]
     else:
-        raise CdxError("Usage: cdx clean [name] [--json]")
+        raise CdxError("Usage: cdx clean [name] [--yes] [--json]")
+
+    if not yes:
+        target = targets[0]["name"] if len(targets) == 1 else f"all {len(targets)} sessions"
+        confirm_fn = ctx["options"].get("confirmClean")
+        if confirm_fn:
+            confirmed = _resolve_confirmation(confirm_fn, target)
+        elif not ctx["stdin_is_tty"]:
+            raise CdxError("Log cleanup requires an interactive terminal or --yes in non-interactive mode.")
+        else:
+            confirmed = _confirm_log_cleanup(target)
+        if not confirmed:
+            if json_flag:
+                _write_json(ctx, _json_success("clean", "Cancelled.", cancelled=True, sessions=[]))
+                return 0
+            ctx["out"](f"{_warn('Cancelled.', ctx['use_color'])}\n")
+            return 0
 
     cleaned_sessions = []
     for session in targets:
@@ -1373,7 +1819,7 @@ def handle_clean(rest, ctx):
                 continue
             ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
     if json_flag:
-        _write_json(ctx, _json_success("clean", "Cleaned session logs", sessions=cleaned_sessions))
+        _write_json(ctx, _json_success("clean", "Cleaned session logs", cancelled=False, sessions=cleaned_sessions))
     return 0
 
 
@@ -1667,6 +2113,69 @@ def handle_status(rest, ctx):
     return 0
 
 
+def handle_reset(rest, ctx):
+    parsed = _parse_flag_args(rest, {
+        "--json": {"key": "json", "type": "bool", "default": False},
+        "--yes": {"key": "yes", "type": "bool", "default": False},
+    }, "Usage: cdx reset <name> [--yes] [--json]", positionals_key="args", max_positionals=1)
+    if len(parsed["args"]) != 1:
+        raise CdxError("Usage: cdx reset <name> [--yes] [--json]")
+    name = parsed["args"][0]
+    session = ctx["service"]["get_session"](name)
+    if not session:
+        raise CdxError(f"Unknown session: {name}")
+    if session["provider"] != PROVIDER_CODEX:
+        raise CdxError("Banked rate-limit resets are only available for Codex sessions.")
+
+    status = ctx["service"]["get_status_row"](name, force_refresh=True)
+    if status.get("reset_credits_available") == 0:
+        raise CdxError(f"No banked Codex reset is available for {name}.")
+    if not parsed["yes"]:
+        confirm_fn = ctx["options"].get("confirmReset")
+        if confirm_fn:
+            confirmed = _resolve_confirmation(confirm_fn, name)
+        elif not ctx["stdin_is_tty"]:
+            raise CdxError("Reset activation requires an interactive terminal or --yes in non-interactive mode.")
+        else:
+            confirmed = _confirm_reset(name)
+        if not confirmed:
+            if parsed["json"]:
+                _write_json(ctx, _json_success("reset", "Cancelled.", cancelled=True, session=name))
+                return 0
+            ctx["out"](f"{_warn('Cancelled.', ctx['use_color'])}\n")
+            return 0
+
+    credit_rows = status.get("reset_credits") or []
+    credit_id = credit_rows[0].get("id") if credit_rows else None
+    consumer = ctx["options"].get("consumeCodexReset") or consume_codex_rate_limit_reset_credit
+    result = consumer(
+        session,
+        ctx["options"].get("resetIdempotencyKey") or str(uuid.uuid4()),
+        credit_id=credit_id,
+    )
+    if not result.get("ok"):
+        if result.get("reason") == "reset_consume_failed":
+            raise CdxError(
+                f"Unable to activate Codex reset for {name}. "
+                "The installed Codex version or account may not support reset activation."
+            )
+        raise CdxError(f"Unable to activate Codex reset for {name}: {result.get('reason') or 'unknown error'}")
+    outcome = result.get("outcome")
+    if outcome == "noCredit":
+        raise CdxError(f"No banked Codex reset is available for {name}.")
+    if outcome == "nothingToReset":
+        raise CdxError(f"No current Codex rate-limit window is eligible for reset on {name}.")
+    if outcome not in ("reset", "alreadyRedeemed"):
+        raise CdxError(f"Unexpected Codex reset outcome for {name}: {outcome or 'missing'}")
+    refreshed = ctx["service"]["get_status_row"](name, force_refresh=True)
+    message = f"Activated banked Codex reset for {name}"
+    if parsed["json"]:
+        _write_json(ctx, _json_success("reset", message, cancelled=False, outcome=outcome, session=refreshed))
+        return 0
+    ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    return 0
+
+
 def _refresh_claude_auth_states(service, target_names=None, spawn_sync=None, env_override=None):
     target_names = set(target_names or [])
     errors = []

package/src/cli_helpers.py

@@ -68,6 +68,13 @@ def _update_notice_warning(ctx):
 def _update_notice_warnings(ctx):
     warnings = []
     for notice in ctx.get("update_notices") or []:
+        if notice.get("code") == "disk_cleanup_available":
+            warnings.append({
+                "code": "disk_cleanup_available",
+                "message": notice["message"],
+                **{key: value for key, value in notice.items() if key not in ("code", "message")},
+            })
+            continue
         tool = notice.get("tool") or "cdx-manager"
         current = notice.get("current_version") or ctx.get("version")
         command = notice.get("update_command") or ("cdx update" if tool == "cdx-manager" else None)

package/src/codex_usage.py

@@ -65,6 +65,15 @@ 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 _format_timestamp(unix_seconds):
+    if unix_seconds is None:
+        return None
+    try:
+        return datetime.fromtimestamp(int(unix_seconds), tz=timezone.utc).astimezone().isoformat()
+    except (TypeError, ValueError, OSError):
+        return None
+
+
 def _remaining_from_used_percent(value):
     if value is None:
         return None
@@ -84,7 +93,7 @@ def _get_window(snapshot, duration_mins):
     return {}
 
 
-def normalize_codex_rate_limit_snapshot(snapshot):
+def normalize_codex_rate_limit_snapshot(snapshot, reset_credits=None):
     if not snapshot:
         return None
 
@@ -101,6 +110,23 @@ def normalize_codex_rate_limit_snapshot(snapshot):
 
     reset_5h_at = _format_reset_date(five_hour.get("resetsAt") or five_hour.get("resets_at"))
     reset_week_at = _format_reset_date(weekly.get("resetsAt") or weekly.get("resets_at"))
+    reset_credits = reset_credits or {}
+    available_count = reset_credits.get("availableCount", reset_credits.get("available_count"))
+    try:
+        available_count = max(0, int(available_count)) if available_count is not None else None
+    except (TypeError, ValueError):
+        available_count = None
+    credit_rows = []
+    for credit in reset_credits.get("credits") or []:
+        if not isinstance(credit, dict) or credit.get("status") not in (None, "available"):
+            continue
+        credit_rows.append({
+            "id": credit.get("id"),
+            "title": credit.get("title"),
+            "description": credit.get("description"),
+            "granted_at": _format_timestamp(credit.get("grantedAt", credit.get("granted_at"))),
+            "expires_at": _format_timestamp(credit.get("expiresAt", credit.get("expires_at"))),
+        })
 
     raw_status_text = json.dumps(snapshot, sort_keys=True)
     return {
@@ -111,6 +137,8 @@ def normalize_codex_rate_limit_snapshot(snapshot):
             weekly.get("usedPercent", weekly.get("used_percent"))
         ),
         "credits": credit_balance,
+        "reset_credits_available": available_count,
+        "reset_credits": credit_rows,
         "reset_5h_at": reset_5h_at,
         "reset_week_at": reset_week_at,
         "reset_at": reset_week_at or reset_5h_at,
@@ -166,6 +194,32 @@ def fetch_codex_rate_limit_diagnostic(session, timeout=5, popen_factory=None):
 
 
 def _probe_codex_rate_limit_diagnostic(session, auth_home, timeout=5, popen_factory=None):
+    diagnostic = _request_codex_app_server(
+        auth_home,
+        "account/rateLimits/read",
+        None,
+        "rate_limits_read_failed",
+        timeout=timeout,
+        popen_factory=popen_factory,
+    )
+    if not diagnostic["ok"]:
+        return diagnostic
+    response = diagnostic["response"]
+    result = response.get("result") or {}
+    by_limit = result.get("rateLimitsByLimitId") or {}
+    snapshot = by_limit.get("codex") or result.get("rateLimits")
+    status = normalize_codex_rate_limit_snapshot(snapshot, result.get("rateLimitResetCredits"))
+    if not status:
+        return {
+            "ok": False,
+            "reason": "missing_rate_limits",
+            "status": None,
+            "response": response,
+        }
+    return {"ok": True, "reason": None, "status": status, "response": response}
+
+
+def _request_codex_app_server(auth_home, method, params, failure_reason, timeout=5, popen_factory=None):
     env = os.environ.copy()
     env["CODEX_HOME"] = auth_home
     popen_factory = popen_factory or subprocess.Popen
@@ -204,29 +258,18 @@ def _probe_codex_rate_limit_diagnostic(session, auth_home, timeout=5, popen_fact
         _write_json_line(process, {
             "jsonrpc": "2.0",
             "id": 2,
-            "method": "account/rateLimits/read",
-            "params": None,
+            "method": method,
+            "params": params,
         })
         response = _read_response(output, 2, timeout)
         if not response or response.get("error"):
             return {
                 "ok": False,
-                "reason": "rate_limits_read_failed",
-                "status": None,
-                "response": response,
-            }
-        result = response.get("result") or {}
-        by_limit = result.get("rateLimitsByLimitId") or {}
-        snapshot = by_limit.get("codex") or result.get("rateLimits")
-        status = normalize_codex_rate_limit_snapshot(snapshot)
-        if not status:
-            return {
-                "ok": False,
-                "reason": "missing_rate_limits",
+                "reason": failure_reason,
                 "status": None,
                 "response": response,
             }
-        return {"ok": True, "reason": None, "status": status, "response": response}
+        return {"ok": True, "reason": None, "status": None, "response": response}
     except FileNotFoundError as error:
         return {"ok": False, "reason": "codex_cli_not_found", "status": None, "error": str(error)}
     except (OSError, ValueError, BrokenPipeError) as error:
@@ -250,3 +293,25 @@ def fetch_codex_rate_limits(session, timeout=5, popen_factory=None):
         popen_factory=popen_factory,
     )
     return diagnostic.get("status") if diagnostic.get("ok") else None
+
+
+def consume_codex_rate_limit_reset_credit(session, idempotency_key, credit_id=None, timeout=5, popen_factory=None):
+    auth_home = session.get("authHome")
+    if not auth_home:
+        return {"ok": False, "reason": "missing_auth_home", "outcome": None}
+    with codex_auth_lock(auth_home) as acquired:
+        if not acquired:
+            return {"ok": False, "reason": "auth_locked", "outcome": None}
+        params = {"idempotencyKey": idempotency_key}
+        if credit_id:
+            params["creditId"] = credit_id
+        diagnostic = _request_codex_app_server(
+            auth_home,
+            "account/rateLimitResetCredit/consume",
+            params,
+            "reset_consume_failed",
+            timeout=timeout,
+            popen_factory=popen_factory,
+        )
+        result = (diagnostic.get("response") or {}).get("result") or {}
+        return {**diagnostic, "outcome": result.get("outcome")}

package/src/session_service.py

@@ -29,6 +29,7 @@ RESERVED_SESSION_NAMES = {
     "configs",
     "cp",
     "disable",
+    "disk",
     "doctor",
     "enable",
     "export",
@@ -48,6 +49,7 @@ RESERVED_SESSION_NAMES = {
     "power",
     "ready",
     "repair",
+    "reset",
     "resume",
     "ren",
     "rename",
@@ -260,6 +262,8 @@ def _normalize_status_payload(payload=None):
         "remaining_5h_pct": _normalize_pct_value(payload.get("remaining_5h_pct")),
         "remaining_week_pct": _normalize_pct_value(payload.get("remaining_week_pct")),
         "credits": payload.get("credits"),
+        "reset_credits_available": payload.get("reset_credits_available"),
+        "reset_credits": payload.get("reset_credits"),
         "reset_5h_at": payload.get("reset_5h_at"),
         "reset_week_at": payload.get("reset_week_at"),
         "reset_at": payload.get("reset_at") or payload.get("reset_week_at") or payload.get("reset_5h_at"),
@@ -337,6 +341,8 @@ def _status_has_more_detail(candidate, current):
         "remaining_5h_pct",
         "remaining_week_pct",
         "credits",
+        "reset_credits_available",
+        "reset_credits",
         "reset_5h_at",
         "reset_week_at",
         "reset_at",
@@ -358,6 +364,8 @@ def _merge_status_payload(current, candidate):
         "remaining_5h_pct",
         "remaining_week_pct",
         "credits",
+        "reset_credits_available",
+        "reset_credits",
         "reset_5h_at",
         "reset_week_at",
         "reset_at",
@@ -1101,6 +1109,8 @@ def create_session_service(options=None):
             "remaining_5h_pct": _normalize_pct_value(row_status.get("remaining_5h_pct")) if row_status else None,
             "remaining_week_pct": _normalize_pct_value(row_status.get("remaining_week_pct")) if row_status else None,
             "credits": row_status.get("credits") if row_status else None,
+            "reset_credits_available": row_status.get("reset_credits_available") if row_status else None,
+            "reset_credits": row_status.get("reset_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,

package/src/status_view.py

@@ -76,15 +76,15 @@ def _format_credits(value, empty="n/a"):
 def _format_status_rows(rows, use_color=False, small=False):
     has_provider = len({r["provider"] for r in rows}) > 1 and not small
     if small:
-        headers = ["SESSION", "STATUS", "OK", "5H", "WEEK", "RESET 5H", "RESET WEEK"]
+        headers = ["SESSION", "STATUS", "OK", "5H", "WEEK", "RESETS", "RESET 5H", "RESET WEEK"]
     elif has_provider:
-        headers = ["SESSION", "PROV.", "STATUS", "AUTH", "OK", "5H", "WEEK", "BLOCK", "CR", "RESET 5H", "RESET WEEK", "UPDATED"]
+        headers = ["SESSION", "PROV.", "STATUS", "AUTH", "OK", "5H", "WEEK", "BLOCK", "CR", "RESETS", "RESET 5H", "RESET WEEK", "UPDATED"]
     else:
-        headers = ["SESSION", "STATUS", "AUTH", "OK", "5H", "WEEK", "BLOCK", "CR", "RESET 5H", "RESET WEEK", "UPDATED"]
+        headers = ["SESSION", "STATUS", "AUTH", "OK", "5H", "WEEK", "BLOCK", "CR", "RESETS", "RESET 5H", "RESET WEEK", "UPDATED"]
     if not rows:
         if small:
-            return "SESSION  STATUS  OK  5H  WEEK  RESET 5H  RESET WEEK\nNo saved sessions yet."
-        return "SESSION  STATUS  OK  5H  WEEK  BLOCK  CR  RESET 5H  RESET WEEK  UPDATED\nNo saved sessions yet."
+            return "SESSION  STATUS  OK  5H  WEEK  RESETS  RESET 5H  RESET WEEK\nNo saved sessions yet."
+        return "SESSION  STATUS  OK  5H  WEEK  BLOCK  CR  RESETS  RESET 5H  RESET WEEK  UPDATED\nNo saved sessions yet."
     headers = [_style(header, "1", use_color) for header in headers]
     active_rows = [r for r in rows if r.get("enabled", True) is not False]
     priority = recommend_priority_rows(rows)
@@ -109,12 +109,13 @@ def _format_status_rows(rows, use_color=False, small=False):
             auth_color = "32" if auth == "logged" else "31" if auth == "logged out" else "2"
             base.append(_style(auth, auth_color, use_color))
         if r.get("enabled", True) is False:
-            usage_columns = [_style("-", "2", use_color)] * 5
+            usage_columns = [_style("-", "2", use_color)] * 6
         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(str(r["reset_credits_available"]), "33", use_color) if r.get("reset_credits_available") is not None else _style("-", "2", use_color),
                 _style_reset_time(r.get("reset_5h_at"), use_color),
                 _style_reset_time(r.get("reset_week_at"), use_color),
             ]
@@ -367,8 +368,15 @@ def _format_status_detail(row, use_color=False):
         f"{_style('Week left:', '1', use_color)} {_style_pct(row.get('remaining_week_pct'), use_color)}",
         f"{_style('Block:', '1', use_color)} {_style(_format_blocking_quota(row), '33', use_color)}",
         f"{_style('Credits:', '1', use_color)} {_style(_format_credits(row.get('credits')), '33' if row.get('credits') is not None else '2', use_color)}",
+        f"{_style('Bonus resets:', '1', use_color)} {_style(str(row['reset_credits_available']), '33', use_color) if row.get('reset_credits_available') is not None else _style('-', '2', use_color)}",
+        f"{_style('Reset expiry:', '1', use_color)} {_style_reset_time(_nearest_reset_expiry(row), use_color)}",
         f"{_style('5h reset:', '1', use_color)} {_style_reset_time(row.get('reset_5h_at'), use_color)}",
         f"{_style('Week reset:', '1', use_color)} {_style_reset_time(row.get('reset_week_at'), use_color)}",
         f"{_style('Updated:', '1', use_color)} {_dim(_format_relative_age(row.get('updated_at')), use_color)}",
     ]
     return "\n".join(lines)
+
+
+def _nearest_reset_expiry(row):
+    values = [credit.get("expires_at") for credit in row.get("reset_credits") or [] if credit.get("expires_at")]
+    return min(values, key=lambda value: _parse_reset_timestamp(value) or float("inf")) if values else None