cdx-manager 0.5.0 → 0.5.2

package/README.md

@@ -1,6 +1,6 @@
 # CDX Manager
 
-[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.5.0-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
+[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.5.2-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
 
 **Run multiple Codex and Claude sessions from one terminal. Switch between accounts instantly.**
 
@@ -37,8 +37,8 @@ One command to launch any session. Zero auth juggling.
 - **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.
 - **Session control.** Disable a session without deleting it when an account is temporarily out of credits; disabled sessions remain visible and sort last.
-- **Shared handoff context.** Keep a per-workspace Markdown context and install it into another assistant session before switching providers or accounts.
-- **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.
+- **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.
 - **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.
 
@@ -59,6 +59,7 @@ One command to launch any session. Zero auth juggling.
   - All paths are URL-encoded to support arbitrary session names.
 - Status resolution pipeline:
   - Primary source: recorded status fields on the session record.
+  - Codex live source: `codex app-server` JSON-RPC `account/rateLimits/read`, normalized into 5-hour, weekly, reset, credit, and plan fields.
   - 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.
@@ -125,7 +126,7 @@ For a specific version:
 
 ```bash
 curl -fsSL https://raw.githubusercontent.com/AlexAgo83/cdx-manager/main/install.sh -o install.sh
-CDX_VERSION=v0.5.0 sh install.sh
+CDX_VERSION=v0.5.2 sh install.sh
 ```
 
 From source:
@@ -249,6 +250,7 @@ cdx status
 | `cdx enable <name> [--json]` | Re-enable a disabled session |
 | `cdx context show\|path\|init\|edit\|clear\|set [text...] [--json]` | Manage the shared Markdown context for the current workspace |
 | `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 |
 | `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 export <file> [--include-auth] [--sessions a,b] [--passphrase-env VAR] [--force] [--json]` | Export sessions to a portable bundle; `--include-auth` encrypts auth data with a passphrase |
@@ -446,7 +448,7 @@ Session names are URL-encoded when used as directory or file names. CLI command
 - **`cdx <name>` fails with "not authenticated"** — run `cdx login <name>` first.
 - **`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.
-- **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.
+- **Status shows `n/a` for all fields** — the Codex app-server rate-limit probe may be unavailable, the session may not be authenticated, and no legacy transcript/history status has been captured yet.
 - **`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.

package/changelogs/CHANGELOGS_0_5_1.md

@@ -0,0 +1,33 @@
+# Changelog (`0.5.0 -> 0.5.1`)
+
+Release date: 2026-05-22
+
+## Major Highlights
+
+- Replaced Codex status scraping with a structured local Codex app-server rate-limit probe.
+- Kept transcript and JSONL status parsing as a legacy fallback when the local Codex app-server is unavailable.
+- Prepared the package metadata for the 0.5.1 release across npm, PyPI, CLI version output, and README install examples.
+
+## Codex Status Resolution
+
+- Added a Codex app-server JSON-RPC client that calls `account/rateLimits/read` for each isolated Codex session profile.
+- Normalized app-server rate-limit snapshots into the existing `cdx status` output fields: 5-hour remaining percentage, weekly remaining percentage, reset times, credits, and source metadata.
+- Preserved multi-account isolation by running each probe with the session-specific `CODEX_HOME`.
+- Updated status and launch tips so `/status` transcript capture is no longer presented as the normal Codex refresh path.
+
+## Packaging
+
+- Bumped `package.json`, `package-lock.json`, `pyproject.toml`, and `src/cli.py` to `0.5.1`.
+- Updated the README version badge and pinned installer example for `v0.5.1`.
+
+## Validation and Regression Coverage
+
+- Added runtime coverage for Codex app-server JSON-RPC probing and rate-limit normalization.
+- Added session-service coverage proving app-server status is preferred over legacy transcript artifacts.
+- Updated CLI coverage for the revised Codex status guidance.
+
+## Validation and Regression Evidence
+
+- `python3 -m unittest discover -s test -p 'test_*_py.py'`
+- `python logics/skills/logics.py lint --require-status`
+- `python3 bin/cdx status --json`

package/changelogs/CHANGELOGS_0_5_2.md

@@ -0,0 +1,42 @@
+# Changelog (`0.5.1 -> 0.5.2`)
+
+Release date: 2026-05-22
+
+## Major Highlights
+
+- Added transcript-based handoff between two sessions of the same provider.
+- Added automatic launch prompting so the target Codex session reads `shared-context.md` and resumes without a manual instruction.
+- Prepared the package metadata for the 0.5.2 release across npm, PyPI, CLI version output, and README install examples.
+
+## Transcript-Based Session Handoff
+
+- Added `cdx handoff <source> <target> [--json]`.
+- Builds a shared context from the source session's latest captured launch transcript.
+- Installs the generated context into the target session as `shared-context.md`.
+- Preserves target account authentication and does not copy source credentials.
+- Rejects same-session and cross-provider handoffs with explicit errors.
+- Truncates very large transcripts to the most recent tail before writing the handoff context.
+
+## Launch and JSON Output
+
+- Passes an initial Codex prompt during handoff launch so the target session is told to read `$CODEX_HOME/shared-context.md`.
+- Adds `launch_prompt` to `cdx handoff ... --json` output for non-interactive integrations.
+- Keeps `--json` handoff mode non-launching while exposing source transcript, generated context, and installed target context paths.
+
+## Documentation
+
+- Updated CLI help and session-list command hints for `cdx handoff <source> <target>`.
+- Updated the README feature summary and command table for transcript-based handoff.
+- Updated the README badge and pinned installer example to `v0.5.2`.
+
+## Validation and Regression Coverage
+
+- Added CLI coverage for source-to-target handoff context generation.
+- Added CLI coverage proving non-JSON handoff launches the target Codex session with the resume prompt.
+- Kept full Python test coverage and Logics lint green.
+
+## Validation and Regression Evidence
+
+- `python -m pytest test -q`
+- `python logics/skills/logics.py lint --require-status`
+- `git diff --check`

package/package.json

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

package/src/cli.py

@@ -49,7 +49,7 @@ from .status_view import (
 )
 from .update_check import check_for_update
 
-VERSION = "0.5.0"
+VERSION = "0.5.2"
 
 
 # ---------------------------------------------------------------------------
@@ -68,6 +68,7 @@ def _print_help(use_color=False):
         f"  {_style('cdx status <name> [--json] [--refresh]', '36', use_color)}",
         f"  {_style('cdx context show|path|init|edit|clear|set [text...] [--json]', '36', use_color)}",
         f"  {_style('cdx handoff <name> [--json]', '36', use_color)}",
+        f"  {_style('cdx handoff <source> <target> [--json]', '36', use_color)}",
         f"  {_style('cdx add [provider] <name> [--json]', '36', use_color)}",
         f"  {_style('cdx cp <source> <dest> [--json]', '36', use_color)}",
         f"  {_style('cdx ren <source> <dest> [--json]', '36', use_color)}",

package/src/cli_commands.py

@@ -43,8 +43,9 @@ 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]"
 IMPORT_USAGE = "Usage: cdx import <file> [--force] [--json] [--sessions name1,name2] [--passphrase-env VAR]"
 CONTEXT_USAGE = "Usage: cdx context show|path|init|edit|clear|set [text...] [--json]"
-HANDOFF_USAGE = "Usage: cdx handoff <name> [--json]"
+HANDOFF_USAGE = "Usage: cdx handoff <name> [--json] | cdx handoff <source> <target> [--json]"
 API_SCHEMA_VERSION = 1
+HANDOFF_TRANSCRIPT_CHARS = 120000
 
 
 def _local_now_iso():
@@ -67,6 +68,56 @@ def _write_json(ctx, payload):
     ctx["out"](f"{json.dumps(payload, indent=2)}\n")
 
 
+def _latest_launch_transcript_path(session):
+    paths = _list_launch_transcript_paths(session)
+    if not paths:
+        return None
+    return max(paths, key=lambda path: (os.path.getmtime(path), path))
+
+
+def _read_handoff_transcript(path):
+    with open(path, "r", encoding="utf-8", errors="replace") as handle:
+        content = handle.read()
+    if len(content) <= HANDOFF_TRANSCRIPT_CHARS:
+        return content, False
+    return content[-HANDOFF_TRANSCRIPT_CHARS:], True
+
+
+def _build_handoff_context(source, target, transcript_path, transcript, truncated=False):
+    truncation_note = (
+        "Only the tail of the previous transcript is included because the log was large."
+        if truncated else
+        "The previous transcript is included below."
+    )
+    return "\n".join([
+        "# Shared Context",
+        "",
+        "## Goal",
+        f"Resume the work from `{source['name']}` in `{target['name']}` because the source account has no usage left.",
+        "",
+        "## Current State",
+        f"- Source session: `{source['name']}` ({source['provider']})",
+        f"- Target session: `{target['name']}` ({target['provider']})",
+        f"- Transcript source: `{transcript_path}`",
+        f"- {truncation_note}",
+        "",
+        "## Previous Session Transcript",
+        transcript.rstrip(),
+        "",
+        "## Next Steps",
+        "- Read the transcript above.",
+        "- Continue the task from the latest actionable state.",
+        "- Preserve the target account authentication; do not copy source credentials.",
+    ])
+
+
+def _handoff_launch_prompt():
+    return (
+        "Read $CODEX_HOME/shared-context.md first, then resume the previous session "
+        "from the latest actionable state. Do not ask me to paste the context again."
+    )
+
+
 def _parse_json_flag(args):
     json_flag = "--json" in args
     cleaned = [arg for arg in args if arg != "--json"]
@@ -914,7 +965,7 @@ def handle_update(rest, ctx):
     return 0
 
 
-def handle_launch(command, ctx):
+def handle_launch(command, ctx, initial_prompt=None):
     json_flag = "--json" in ctx["options"].get("raw_args", [])
     update_notice = ctx.get("update_notice")
     warnings = []
@@ -946,10 +997,10 @@ def handle_launch(command, ctx):
             ctx["out"](f"{_warn(text, ctx['use_color'])}\n")
     if session["provider"] == "codex":
         if not json_flag:
-            ctx["out"](f"{_dim('Tip: run /status once the Codex session opens.', ctx['use_color'])}\n")
+            ctx["out"](f"{_dim('Tip: cdx status reads Codex rate limits from the local app-server when available.', ctx['use_color'])}\n")
     _run_interactive_provider_command(
         session, "launch", spawn=ctx.get("spawn"), env_override=ctx.get("env"),
-        signal_emitter=ctx.get("signal_emitter")
+        signal_emitter=ctx.get("signal_emitter"), initial_prompt=initial_prompt,
     )
     if json_flag:
         _write_json(ctx, _json_success("launch", message, warnings=warnings, session=ctx["service"]["get_session"](session["name"])))
@@ -958,22 +1009,57 @@ def handle_launch(command, ctx):
 
 def handle_handoff(rest, ctx):
     json_flag, args = _parse_json_flag(rest)
-    if len(args) != 1:
+    if len(args) not in (1, 2):
         raise CdxError(HANDOFF_USAGE)
-    name = args[0]
-    session = ctx["service"]["get_session"](name)
-    if not session:
-        raise CdxError(f"Unknown session: {name}")
-    install = install_context_for_session(ctx["service"]["base_dir"], session, ctx.get("cwd"))
+    if len(args) == 1:
+        name = args[0]
+        session = ctx["service"]["get_session"](name)
+        if not session:
+            raise CdxError(f"Unknown session: {name}")
+        install = install_context_for_session(ctx["service"]["base_dir"], session, ctx.get("cwd"))
+        if json_flag:
+            _write_json(ctx, _json_success(
+                "handoff",
+                f"Installed shared context for {name}",
+                context=install,
+                launch_prompt=_handoff_launch_prompt(),
+                session=session,
+            ))
+            return 0
+        text = f"Shared context installed for {name}: {install['target_path']}"
+        ctx["out"](f"{_info(text, ctx['use_color'])}\n")
+        return handle_launch(name, ctx, initial_prompt=_handoff_launch_prompt())
+
+    source_name, target_name = args
+    if source_name == target_name:
+        raise CdxError("Source and target sessions must be different")
+    source = ctx["service"]["get_session"](source_name)
+    if not source:
+        raise CdxError(f"Unknown session: {source_name}")
+    target = ctx["service"]["get_session"](target_name)
+    if not target:
+        raise CdxError(f"Unknown session: {target_name}")
+    if source["provider"] != target["provider"]:
+        raise CdxError("Source and target sessions must use the same provider for handoff.")
+    transcript_path = _latest_launch_transcript_path(source)
+    if not transcript_path:
+        raise CdxError(f"No launch transcript found for session: {source_name}")
+    transcript, truncated = _read_handoff_transcript(transcript_path)
+    context = _build_handoff_context(source, target, transcript_path, transcript, truncated=truncated)
+    write_result = write_context(ctx["service"]["base_dir"], context, ctx.get("cwd"))
+    install = install_context_for_session(ctx["service"]["base_dir"], target, ctx.get("cwd"))
     if json_flag:
         _write_json(ctx, _json_success(
             "handoff",
-            f"Installed shared context for {name}",
+            f"Prepared handoff from {source_name} to {target_name}",
             context=install,
-            session=session,
+            source_session=source,
+            target_session=target,
+            source_transcript=transcript_path,
+            shared_context=write_result,
+            launch_prompt=_handoff_launch_prompt(),
         ))
         return 0
-    text = f"Shared context installed for {name}: {install['target_path']}"
+    text = f"Handoff prepared from {source_name} to {target_name}: {install['target_path']}"
     ctx["out"](f"{_info(text, ctx['use_color'])}\n")
-    ctx["out"](f"{_dim('Ask the assistant to read shared-context.md if it does not pick it up automatically.', ctx['use_color'])}\n")
-    return handle_launch(name, ctx)
+    return handle_launch(target_name, ctx, initial_prompt=_handoff_launch_prompt())

package/src/cli_render.py

@@ -129,6 +129,7 @@ def _format_sessions(service, use_color=False):
         f"  {_style('cdx logout <name>', '36', use_color)}",
         f"  {_style('cdx context show', '36', use_color)}",
         f"  {_style('cdx handoff <name>', '36', use_color)}",
+        f"  {_style('cdx handoff <source> <target>', '36', use_color)}",
         f"  {_style('cdx disable <name>', '36', use_color)}",
         f"  {_style('cdx enable <name>', '36', use_color)}",
         f"  {_style('cdx ren <source> <dest>', '36', use_color)}",

package/src/codex_usage.py

@@ -0,0 +1,168 @@
+import json
+import os
+import queue
+import subprocess
+import threading
+from datetime import datetime, timezone
+
+MONTH_ABBR = ["Jan", "Feb", "Mar", "Apr", "May", "Jun",
+              "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+
+
+def _format_reset_date(unix_seconds):
+    if unix_seconds is None:
+        return None
+    try:
+        dt = datetime.fromtimestamp(int(unix_seconds), tz=timezone.utc).astimezone()
+    except (TypeError, ValueError, OSError):
+        return None
+    return f"{MONTH_ABBR[dt.month - 1]} {dt.day} {str(dt.hour).zfill(2)}:{str(dt.minute).zfill(2)}"
+
+
+def _remaining_from_used_percent(value):
+    if value is None:
+        return None
+    try:
+        return max(0, min(100, round(100 - float(value))))
+    except (TypeError, ValueError):
+        return None
+
+
+def _get_window(snapshot, duration_mins):
+    for key in ("primary", "secondary"):
+        window = snapshot.get(key) or {}
+        if window.get("windowDurationMins") == duration_mins:
+            return window
+        if window.get("window_minutes") == duration_mins:
+            return window
+    return {}
+
+
+def normalize_codex_rate_limit_snapshot(snapshot):
+    if not snapshot:
+        return None
+
+    five_hour = _get_window(snapshot, 300)
+    weekly = _get_window(snapshot, 10080)
+    credits = snapshot.get("credits")
+    credit_balance = None
+    if isinstance(credits, dict):
+        credit_balance = credits.get("balance")
+        if not credits.get("hasCredits") and not credits.get("unlimited") and str(credit_balance or "0") == "0":
+            credit_balance = None
+    elif credits is not None:
+        credit_balance = credits
+
+    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"))
+
+    raw_status_text = json.dumps(snapshot, sort_keys=True)
+    return {
+        "remaining_5h_pct": _remaining_from_used_percent(
+            five_hour.get("usedPercent", five_hour.get("used_percent"))
+        ),
+        "remaining_week_pct": _remaining_from_used_percent(
+            weekly.get("usedPercent", weekly.get("used_percent"))
+        ),
+        "credits": credit_balance,
+        "reset_5h_at": reset_5h_at,
+        "reset_week_at": reset_week_at,
+        "reset_at": reset_week_at or reset_5h_at,
+        "updated_at": datetime.now().astimezone().isoformat(),
+        "raw_status_text": raw_status_text,
+        "source_ref": "api:codex-app-server-rate-limits",
+    }
+
+
+def _reader_thread(stream, output):
+    try:
+        for line in stream:
+            output.put(line)
+    finally:
+        output.put(None)
+
+
+def _read_response(output, request_id, timeout):
+    deadline = datetime.now().timestamp() + timeout
+    while datetime.now().timestamp() < deadline:
+        remaining = max(0.01, deadline - datetime.now().timestamp())
+        try:
+            line = output.get(timeout=remaining)
+        except queue.Empty:
+            break
+        if line is None:
+            break
+        try:
+            message = json.loads(line)
+        except (TypeError, json.JSONDecodeError):
+            continue
+        if message.get("id") == request_id:
+            return message
+    return None
+
+
+def _write_json_line(process, payload):
+    process.stdin.write(json.dumps(payload, separators=(",", ":")) + "\n")
+    process.stdin.flush()
+
+
+def fetch_codex_rate_limits(session, timeout=5, popen_factory=None):
+    auth_home = session.get("authHome")
+    if not auth_home:
+        return None
+
+    env = os.environ.copy()
+    env["CODEX_HOME"] = auth_home
+    popen_factory = popen_factory or subprocess.Popen
+    process = None
+    output = queue.Queue()
+    try:
+        process = popen_factory(
+            ["codex", "app-server", "--listen", "stdio://"],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            env=env,
+            text=True,
+            bufsize=1,
+        )
+        thread = threading.Thread(target=_reader_thread, args=(process.stdout, output), daemon=True)
+        thread.start()
+        _write_json_line(process, {
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": "initialize",
+            "params": {
+                "clientInfo": {"name": "cdx-manager", "version": "0"},
+                "capabilities": {"experimentalApi": True},
+            },
+        })
+        initialized = _read_response(output, 1, timeout)
+        if not initialized or initialized.get("error"):
+            return None
+
+        _write_json_line(process, {
+            "jsonrpc": "2.0",
+            "id": 2,
+            "method": "account/rateLimits/read",
+            "params": None,
+        })
+        response = _read_response(output, 2, timeout)
+        if not response or response.get("error"):
+            return None
+        result = response.get("result") or {}
+        by_limit = result.get("rateLimitsByLimitId") or {}
+        snapshot = by_limit.get("codex") or result.get("rateLimits")
+        return normalize_codex_rate_limit_snapshot(snapshot)
+    except (OSError, ValueError, BrokenPipeError):
+        return None
+    finally:
+        if process is not None:
+            try:
+                process.terminate()
+                process.wait(timeout=1)
+            except (OSError, subprocess.TimeoutExpired):
+                try:
+                    process.kill()
+                except OSError:
+                    pass

package/src/provider_runtime.py

@@ -98,7 +98,7 @@ def _wrap_launch_with_transcript(session, spec, capture_transcript=True, env=Non
     }
 
 
-def _build_launch_spec(session, cwd=None, env_override=None):
+def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None):
     cwd = cwd or os.getcwd()
     env_override = env_override or {}
     env = {**os.environ, **env_override}
@@ -112,9 +112,12 @@ def _build_launch_spec(session, cwd=None, env_override=None):
             },
             "label": "claude",
         }
+    args = ["--no-alt-screen", "--cd", cwd]
+    if initial_prompt:
+        args.append(initial_prompt)
     return _wrap_launch_with_transcript(session, {
         "command": "codex",
-        "args": ["--no-alt-screen", "--cd", cwd],
+        "args": args,
         "options": {
             "env": {**env, "CODEX_HOME": _get_auth_home(session)},
         },
@@ -221,10 +224,11 @@ def _signal_name(sig):
 
 
 def _run_interactive_provider_command(session, action, spawn=None, cwd=None,
-                                      env_override=None, signal_emitter=None):
+                                      env_override=None, signal_emitter=None,
+                                      initial_prompt=None):
     spawn = spawn or subprocess.Popen
     spec = (
-        _build_launch_spec(session, cwd=cwd, env_override=env_override)
+        _build_launch_spec(session, cwd=cwd, env_override=env_override, initial_prompt=initial_prompt)
         if action == "launch"
         else _build_auth_action_spec(session, action, cwd=cwd, env_override=env_override)
     )

package/src/session_service.py

@@ -9,6 +9,7 @@ from urllib.parse import quote
 
 from .backup_bundle import decode_bundle, encode_bundle
 from .config import get_cdx_home
+from .codex_usage import fetch_codex_rate_limits
 from .errors import CdxError
 from .session_store import create_session_store
 from .status_source import find_latest_status_artifact
@@ -245,6 +246,7 @@ def create_session_service(options=None):
     env = options.get("env", os.environ)
     base_dir = options.get("base_dir") or get_cdx_home(env)
     store = options.get("store") or create_session_store(base_dir)
+    codex_status_fetcher = options.get("fetchCodexRateLimits") or fetch_codex_rate_limits
 
     def _get_session_root(name):
         return os.path.join(base_dir, "profiles", _encode(name))
@@ -551,6 +553,12 @@ def create_session_service(options=None):
         source_root = session.get("authHome") or _get_session_auth_home(
             session["name"], session["provider"]
         )
+        if session["provider"] == "codex" and codex_status_fetcher:
+            live_status = codex_status_fetcher({**session, "authHome": source_root})
+            if live_status:
+                record_status(session["name"], live_status)
+                return live_status
+
         expected_account_email = (
             _read_expected_account_email(source_root)
             if session["provider"] == "codex"

package/src/status_view.py

@@ -108,7 +108,7 @@ def _format_status_rows(rows, use_color=False, small=False):
         _pad_table([headers] + table_rows),
         "",
         _style(priority_line, "1", use_color),
-        _style("Tip: run /status in codex to refresh. Claude sessions auto-refresh; use --refresh to force.", "2", use_color),
+        _style("Tip: Codex status uses the local app-server rate-limit API when available; Claude sessions auto-refresh, use --refresh to force.", "2", use_color),
     ])