cdx-manager 0.4.4 → 0.5.1

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.4.4-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
+[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.5.1-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.**
 
@@ -36,7 +36,9 @@ One command to launch any session. Zero auth juggling.
 - **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 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.** 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.
 
@@ -52,10 +54,12 @@ One command to launch any session. Zero auth juggling.
 - Persistence:
   - Session registry at `~/.cdx/sessions.json` (versioned JSON store).
   - Per-session state at `~/.cdx/state/<name>.json`.
+  - Per-workspace shared context at `~/.cdx/contexts/<workspace-hash>/context.md`.
   - 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.
+  - 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.
@@ -122,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.4.4 sh install.sh
+CDX_VERSION=v0.5.1 sh install.sh
 ```
 
 From source:
@@ -242,6 +246,10 @@ cdx status
 | `cdx ren <source> <dest> [--json]` | Rename a session and move its auth data |
 | `cdx login <name> [--json]` | Re-authenticate a session (logout + login) |
 | `cdx logout <name> [--json]` | Log out of a session |
+| `cdx disable <name> [--json]` | Disable a session without deleting it; disabled sessions stay visible and cannot launch |
+| `cdx enable <name> [--json]` | Re-enable a disabled session |
+| `cdx 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 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 |
@@ -277,6 +285,10 @@ Commands with machine-readable output:
 - `cdx import ... --json`
 - `cdx login ... --json`
 - `cdx logout ... --json`
+- `cdx disable ... --json`
+- `cdx enable ... --json`
+- `cdx context ... --json`
+- `cdx handoff ... --json`
 - `cdx doctor --json`
 - `cdx repair --json`
 - `cdx update --json`
@@ -435,7 +447,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_0.md

@@ -0,0 +1,45 @@
+# Changelog (`0.4.4 -> 0.5.0`)
+
+Release date: 2026-05-20
+
+## Major Highlights
+
+- Added session disable/enable controls so an assistant can be kept in the registry while temporarily removed from launch rotation.
+- Added shared workspace context commands to make provider/account handoff explicit when moving between Codex and Claude sessions.
+- Prepared the package metadata for the 0.5.0 release across npm, PyPI, CLI version output, and README install examples.
+
+## Session Disable Toggle
+
+- Added `cdx disable <name> [--json]` and `cdx enable <name> [--json]`.
+- Disabled sessions remain visible in the main list and status views with a `disabled` status.
+- Disabled sessions sort after enabled sessions and are excluded from status priority recommendations.
+- Launching a disabled session now fails with a clear `Session is disabled: <name>` error.
+- Claude live status refresh skips disabled sessions.
+
+## Shared Context Handoff
+
+- Added per-workspace shared context storage at `~/.cdx/contexts/<workspace-hash>/context.md`.
+- Added `cdx context show`, `path`, `init`, `edit`, `clear`, and `set`.
+- Added `cdx handoff <name>` to install the current workspace context into the target session as `shared-context.md` before launching it.
+- Added `cdx handoff <name> --json` for non-interactive integrations that only need to install the context and inspect the resulting paths.
+- Reserved `context` and `handoff` as session names to avoid command collisions.
+
+## Packaging
+
+- Bumped `package.json`, `package-lock.json`, `pyproject.toml`, and `src/cli.py` to `0.5.0`.
+- Updated the README version badge, pinned installer example, command table, JSON command list, and data layout notes.
+- Removed the accidental npm self-dependency from `package.json` and regenerated the lockfile.
+
+## Validation and Regression Coverage
+
+- Added CLI coverage for context storage, workspace isolation, and handoff installation.
+- Added session-service coverage for disabled-session ordering, launch blocking, and new reserved command names.
+- Kept the full Python test suite green.
+
+## Validation and Regression Evidence
+
+- `python -m pytest`
+- `npm run lint`
+- `npm test`
+- `node bin/cdx.js --version`
+- `npm pack --dry-run`

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.4.4",
+  "version": "0.5.1",
   "description": "Terminal session manager for Codex and Claude accounts.",
   "license": "MIT",
   "author": "Alexandre Agostini",
@@ -28,6 +28,8 @@
     "checksums",
     "changelogs",
     "src",
+    "!src/__pycache__",
+    "!src/**/*.pyc",
     "install.sh",
     "install.ps1",
     "pyproject.toml",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cdx-manager"
-version = "0.4.4"
+version = "0.5.1"
 description = "Terminal session manager for Codex and Claude accounts."
 readme = "README.md"
 requires-python = ">=3.9"

package/src/claude_refresh.py

@@ -36,6 +36,7 @@ def _refresh_claude_sessions(service, refresh_fn=None, target_names=None, force=
     claude_sessions = [
         s for s in sessions
         if s["provider"] == "claude"
+        and s.get("enabled", True) is not False
         and (not target_names or s["name"] in target_names)
         and (force or _is_stale(s, ttl_seconds=ttl_seconds))
     ]

package/src/cli.py

@@ -9,10 +9,14 @@ from .cli_commands import (
     STATUS_USAGE,
     handle_add,
     handle_clean,
+    handle_context,
     handle_copy,
     handle_doctor,
+    handle_disable,
+    handle_enable,
     handle_export,
     handle_import,
+    handle_handoff,
     handle_launch,
     handle_login,
     handle_logout,
@@ -45,7 +49,7 @@ from .status_view import (
 )
 from .update_check import check_for_update
 
-VERSION = "0.4.4"
+VERSION = "0.5.1"
 
 
 # ---------------------------------------------------------------------------
@@ -62,11 +66,15 @@ def _print_help(use_color=False):
         f"  {_style('cdx status [--json] [--refresh]', '36', use_color)}",
         f"  {_style('cdx status --small|-s [--refresh]', '36', use_color)}",
         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 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)}",
         f"  {_style('cdx login <name> [--json]', '36', use_color)}",
         f"  {_style('cdx logout <name> [--json]', '36', use_color)}",
+        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 export <file> [--include-auth] [--sessions a,b] [--passphrase-env VAR] [--force] [--json]', '36', use_color)}",
@@ -101,6 +109,8 @@ def format_json_error(error):
         code = "unknown_command"
     elif message.startswith("Session already exists:"):
         code = "session_exists"
+    elif message.startswith("Session is disabled:"):
+        code = "session_disabled"
     elif "requires an interactive terminal" in message or "requires confirmation" in message:
         code = "interactive_terminal_required"
     return json.dumps({
@@ -208,8 +218,9 @@ def main(argv, options=None):
         "spawn_sync": spawn_sync,
         "stdin_is_tty": stdin_is_tty,
         "version": VERSION,
+        "cwd": options.get("cwd") or os.getcwd(),
         "update_notice": _get_update_notice(service, env, options) if command not in (
-            "add", "cp", "ren", "rename", "mv", "rmv", "clean", "doctor", "repair", "update", "notify", "status", "login", "logout", "export", "import", "help", "version"
+            "add", "cp", "ren", "rename", "mv", "rmv", "clean", "doctor", "repair", "update", "notify", "status", "context", "handoff", "login", "logout", "disable", "enable", "export", "import", "help", "version"
         ) else None,
         "use_color": use_color,
     }
@@ -226,6 +237,12 @@ def main(argv, options=None):
     if command == "rmv":
         return handle_remove(rest, ctx)
 
+    if command == "disable":
+        return handle_disable(rest, ctx)
+
+    if command == "enable":
+        return handle_enable(rest, ctx)
+
     if command == "clean":
         return handle_clean(rest, ctx)
 
@@ -247,6 +264,12 @@ def main(argv, options=None):
     if command == "notify":
         return handle_notify(rest, ctx)
 
+    if command == "context":
+        return handle_context(rest, ctx)
+
+    if command == "handoff":
+        return handle_handoff(rest, ctx)
+
     if command == "status":
         return handle_status(rest, ctx)
 

package/src/cli_commands.py

@@ -2,10 +2,20 @@ import asyncio
 import getpass
 import json
 import os
+import sys
 from datetime import datetime
 
 from .claude_refresh import _refresh_claude_sessions
 from .cli_render import _dim, _info, _success, _warn
+from .context_store import (
+    clear_context,
+    edit_context,
+    get_context_path,
+    init_context,
+    install_context_for_session,
+    read_context,
+    write_context,
+)
 from .errors import CdxError
 from .health import collect_health_report, format_health_report
 from .notify import (
@@ -32,6 +42,8 @@ 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]"
 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]"
 API_SCHEMA_VERSION = 1
 
 
@@ -90,6 +102,13 @@ def _parse_remove_args(args):
     return {"name": names[0], "force": force}
 
 
+def _parse_toggle_args(args, usage):
+    json_flag, cleaned = _parse_json_flag(args)
+    if len(cleaned) != 1:
+        raise CdxError(usage)
+    return {"name": cleaned[0], "json": json_flag}
+
+
 def _read_option_value(args, index, usage):
     if index + 1 >= len(args):
         raise CdxError(usage)
@@ -371,6 +390,28 @@ def handle_remove(rest, ctx):
     return 0
 
 
+def handle_disable(rest, ctx):
+    parsed = _parse_toggle_args(rest, "Usage: cdx disable <name> [--json]")
+    session = ctx["service"]["set_session_enabled"](parsed["name"], False)
+    message = f"Disabled session {parsed['name']}"
+    if parsed["json"]:
+        _write_json(ctx, _json_success("disable", message, session=session))
+        return 0
+    ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    return 0
+
+
+def handle_enable(rest, ctx):
+    parsed = _parse_toggle_args(rest, "Usage: cdx enable <name> [--json]")
+    session = ctx["service"]["set_session_enabled"](parsed["name"], True)
+    message = f"Enabled session {parsed['name']}"
+    if parsed["json"]:
+        _write_json(ctx, _json_success("enable", message, session=session))
+        return 0
+    ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    return 0
+
+
 def handle_clean(rest, ctx):
     json_flag, args = _parse_json_flag(rest)
     service = ctx["service"]
@@ -507,6 +548,103 @@ def handle_notify(rest, ctx):
     return 0
 
 
+def handle_context(rest, ctx):
+    json_flag, args = _parse_json_flag(rest)
+    if not args:
+        args = ["show"]
+    action = args[0]
+    base_dir = ctx["service"]["base_dir"]
+    cwd = ctx.get("cwd")
+
+    if action == "show":
+        if len(args) != 1:
+            raise CdxError(CONTEXT_USAGE)
+        content = read_context(base_dir, cwd)
+        payload = {
+            "path": get_context_path(base_dir, cwd),
+            "exists": bool(content.strip()),
+            "content": content,
+        }
+        if json_flag:
+            _write_json(ctx, _json_success("context.show", "Loaded shared context", context=payload))
+            return 0
+        if content.strip():
+            ctx["out"](content if content.endswith("\n") else f"{content}\n")
+        else:
+            ctx["out"](f"{_dim('No shared context for this workspace. Run: cdx context init or cdx context set <text>', ctx['use_color'])}\n")
+        return 0
+
+    if action == "path":
+        if len(args) != 1:
+            raise CdxError(CONTEXT_USAGE)
+        path = get_context_path(base_dir, cwd)
+        if json_flag:
+            _write_json(ctx, _json_success("context.path", "Resolved shared context path", path=path))
+            return 0
+        ctx["out"](f"{path}\n")
+        return 0
+
+    if action == "init":
+        if len(args) != 1:
+            raise CdxError(CONTEXT_USAGE)
+        result = init_context(base_dir, cwd)
+        message = "Created shared context" if result.get("created") else "Shared context already exists"
+        if json_flag:
+            _write_json(ctx, _json_success("context.init", message, context=result))
+            return 0
+        text = f"{message}: {result['path']}"
+        ctx["out"](f"{_success(text, ctx['use_color'])}\n")
+        return 0
+
+    if action == "edit":
+        if len(args) != 1:
+            raise CdxError(CONTEXT_USAGE)
+        result = edit_context(
+            base_dir,
+            cwd,
+            env=ctx.get("env"),
+            spawn_sync=ctx.get("spawn_sync"),
+        )
+        if json_flag:
+            _write_json(ctx, _json_success("context.edit", "Edited shared context", context=result))
+            return 0
+        text = f"Edited shared context: {result['path']}"
+        ctx["out"](f"{_success(text, ctx['use_color'])}\n")
+        return 0
+
+    if action == "clear":
+        if len(args) != 1:
+            raise CdxError(CONTEXT_USAGE)
+        result = clear_context(base_dir, cwd)
+        message = "Cleared shared context" if result["removed"] else "No shared context to clear"
+        if json_flag:
+            _write_json(ctx, _json_success("context.clear", message, context=result))
+            return 0
+        ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+        return 0
+
+    if action == "set":
+        content_args = args[1:]
+        if content_args:
+            content = " ".join(content_args)
+        else:
+            stdin = ctx["options"].get("stdin_data")
+            if stdin is None and not ctx.get("stdin_is_tty"):
+                stdin = sys.stdin.read()
+            if stdin is None:
+                raise CdxError("Usage: cdx context set <text> [--json]")
+            content = stdin
+        result = write_context(base_dir, content, cwd)
+        if json_flag:
+            _write_json(ctx, _json_success("context.set", "Saved shared context", context=result))
+            return 0
+        text = f"Saved shared context: {result['path']}"
+        ctx["out"](f"{_success(text, ctx['use_color'])}\n")
+        return 0
+
+    raise CdxError(CONTEXT_USAGE)
+
+
 def handle_status(rest, ctx):
     json_flag = "--json" in rest
     small_flag = "--small" in rest or "-s" in rest
@@ -808,7 +946,7 @@ 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")
@@ -816,3 +954,26 @@ def handle_launch(command, ctx):
     if json_flag:
         _write_json(ctx, _json_success("launch", message, warnings=warnings, session=ctx["service"]["get_session"](session["name"])))
     return 0
+
+
+def handle_handoff(rest, ctx):
+    json_flag, args = _parse_json_flag(rest)
+    if len(args) != 1:
+        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 json_flag:
+        _write_json(ctx, _json_success(
+            "handoff",
+            f"Installed shared context for {name}",
+            context=install,
+            session=session,
+        ))
+        return 0
+    text = f"Shared context installed for {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)

package/src/cli_render.py

@@ -108,6 +108,7 @@ def _format_sessions(service, use_color=False):
     headers = ["SESSION"]
     if has_provider:
         headers.append("PROVIDER")
+    headers.append("STATUS")
     headers.append("UPDATED")
     headers = [_style(header, "1", use_color) for header in headers]
     table_rows = []
@@ -115,6 +116,8 @@ def _format_sessions(service, use_color=False):
         parts = [r["name"]]
         if has_provider:
             parts.append(r.get("provider") or "n/a")
+        status = r.get("enabled_status") or ("enabled" if r.get("enabled", True) else "disabled")
+        parts.append(_style(status, "2" if status == "disabled" else "32", use_color))
         parts.append(_dim(_format_relative_age(r.get("updated_at")), use_color))
         table_rows.append(parts)
     lines = [_style("Known sessions:", "1", use_color), _pad_table([headers] + table_rows), ""]
@@ -124,6 +127,10 @@ def _format_sessions(service, use_color=False):
         f"  {_style('cdx <name>', '36', use_color)}",
         f"  {_style('cdx login <name>', '36', use_color)}",
         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 disable <name>', '36', use_color)}",
+        f"  {_style('cdx enable <name>', '36', use_color)}",
         f"  {_style('cdx ren <source> <dest>', '36', use_color)}",
         f"  {_style('cdx rmv <name>', '36', use_color)}",
         f"  {_style('cdx status', '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/context_store.py

@@ -0,0 +1,127 @@
+import hashlib
+import os
+import shlex
+import subprocess
+from datetime import datetime
+
+from .errors import CdxError
+from .session_store import _ensure_dir
+
+
+DEFAULT_CONTEXT_TEMPLATE = """# Shared Context
+
+## Goal
+
+## Current State
+
+## Decisions
+
+## Files Changed
+
+## Open Questions
+
+## Next Steps
+"""
+
+
+def _local_now_iso():
+    return datetime.now().astimezone().isoformat()
+
+
+def _workspace_key(cwd):
+    normalized = os.path.realpath(cwd or os.getcwd())
+    digest = hashlib.sha256(normalized.encode("utf-8")).hexdigest()[:16]
+    return digest
+
+
+def _context_dir(base_dir, cwd):
+    return os.path.join(base_dir, "contexts", _workspace_key(cwd))
+
+
+def get_context_path(base_dir, cwd=None):
+    return os.path.join(_context_dir(base_dir, cwd), "context.md")
+
+
+def get_context_meta_path(base_dir, cwd=None):
+    return os.path.join(_context_dir(base_dir, cwd), "meta.json")
+
+
+def read_context(base_dir, cwd=None):
+    path = get_context_path(base_dir, cwd)
+    try:
+        with open(path, "r", encoding="utf-8") as handle:
+            return handle.read()
+    except FileNotFoundError:
+        return ""
+
+
+def write_context(base_dir, content, cwd=None):
+    path = get_context_path(base_dir, cwd)
+    _ensure_dir(os.path.dirname(path))
+    with open(path, "w", encoding="utf-8") as handle:
+        handle.write(content.rstrip() + "\n")
+    return {
+        "path": path,
+        "updated_at": _local_now_iso(),
+        "bytes": os.path.getsize(path),
+    }
+
+
+def init_context(base_dir, cwd=None):
+    current = read_context(base_dir, cwd)
+    if current.strip():
+        return {
+            "path": get_context_path(base_dir, cwd),
+            "created": False,
+            "bytes": len(current.encode("utf-8")),
+        }
+    result = write_context(base_dir, DEFAULT_CONTEXT_TEMPLATE, cwd)
+    return {**result, "created": True}
+
+
+def clear_context(base_dir, cwd=None):
+    path = get_context_path(base_dir, cwd)
+    try:
+        os.remove(path)
+        removed = True
+    except FileNotFoundError:
+        removed = False
+    return {"path": path, "removed": removed}
+
+
+def edit_context(base_dir, cwd=None, editor=None, env=None, spawn_sync=None):
+    result = init_context(base_dir, cwd)
+    path = result["path"]
+    env = env or os.environ
+    editor = editor or env.get("VISUAL") or env.get("EDITOR")
+    if not editor:
+        raise CdxError("Context edit requires VISUAL or EDITOR.")
+    spawn_sync = spawn_sync or subprocess.run
+    argv = shlex.split(editor) + [path]
+    if spawn_sync is subprocess.run:
+        completed = subprocess.run(argv)
+        returncode = completed.returncode
+    else:
+        completed = spawn_sync(argv[0], argv[1:], {"env": env})
+        returncode = completed.get("returncode", 0) if isinstance(completed, dict) else getattr(completed, "returncode", 0)
+    if returncode not in (0, None):
+        raise CdxError(f"Context editor exited with code {returncode}")
+    return {"path": path, "edited": True}
+
+
+def install_context_for_session(base_dir, session, cwd=None):
+    content = read_context(base_dir, cwd)
+    if not content.strip():
+        raise CdxError("No shared context for this workspace. Run: cdx context init or cdx context set <text>")
+    auth_home = session.get("authHome") or session.get("sessionRoot")
+    if not auth_home:
+        raise CdxError(f"Session auth home missing for {session['name']}")
+    target_path = os.path.join(auth_home, "shared-context.md")
+    _ensure_dir(os.path.dirname(target_path))
+    with open(target_path, "w", encoding="utf-8") as handle:
+        handle.write(content.rstrip() + "\n")
+    return {
+        "source_path": get_context_path(base_dir, cwd),
+        "target_path": target_path,
+        "bytes": os.path.getsize(target_path),
+    }

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
@@ -19,10 +20,14 @@ MAX_SESSION_NAME_LENGTH = 64
 RESERVED_SESSION_NAMES = {
     "add",
     "clean",
+    "context",
     "cp",
+    "disable",
     "doctor",
+    "enable",
     "export",
     "help",
+    "handoff",
     "import",
     "login",
     "logout",
@@ -241,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))
@@ -273,6 +279,7 @@ def create_session_service(options=None):
         return {
             "name": session["name"],
             "provider": session["provider"],
+            "enabled": session.get("enabled", True) is not False,
             "createdAt": session.get("createdAt"),
             "updatedAt": session.get("updatedAt"),
             "lastLaunchedAt": session.get("lastLaunchedAt"),
@@ -325,6 +332,7 @@ def create_session_service(options=None):
         session = {
             "name": name,
             "provider": normalized_provider,
+            "enabled": True,
             "sessionRoot": session_root,
             "authHome": auth_home,
             "createdAt": now,
@@ -399,6 +407,7 @@ def create_session_service(options=None):
         replacement = {
             "name": dest_name,
             "provider": source["provider"],
+            "enabled": True,
             "sessionRoot": dest_root,
             "authHome": dest_auth_home,
             "createdAt": now,
@@ -485,6 +494,8 @@ def create_session_service(options=None):
         session = store["get_session"](name)
         if not session:
             raise CdxError(f"Unknown session: {name}")
+        if session.get("enabled", True) is False:
+            raise CdxError(f"Session is disabled: {name}")
         state = store["read_session_state"](name)
         if not state:
             raise CdxError(f"Session state missing for {name}. Reconnect required.")
@@ -515,6 +526,17 @@ def create_session_service(options=None):
     def get_session(name):
         return store["get_session"](name)
 
+    def set_session_enabled(name, enabled):
+        session = store["get_session"](name)
+        if not session:
+            raise CdxError(f"Unknown session: {name}")
+        now = _local_now_iso()
+        return store["update_session"](name, lambda s: {
+            **s,
+            "enabled": bool(enabled),
+            "updatedAt": now,
+        })
+
     def record_status(name, payload):
         normalized = _normalize_status_payload(payload)
         updated = store["update_session"](name, lambda s: {
@@ -531,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"
@@ -605,10 +633,15 @@ def create_session_service(options=None):
 
         def sort_key(s):
             at = s.get("lastStatusAt") or ""
-            return ("" if at else "\xff", at, s["name"])
+            disabled_rank = 1 if s.get("enabled", True) is False else 0
+            return (disabled_rank, "" if at else "\xff", at, s["name"])
 
         resolved.sort(key=sort_key)
-        resolved.reverse()
+        enabled = [s for s in resolved if s.get("enabled", True) is not False]
+        disabled = [s for s in resolved if s.get("enabled", True) is False]
+        enabled.reverse()
+        disabled.sort(key=lambda s: s["name"])
+        resolved = enabled + disabled
 
         rows = []
         for s in resolved:
@@ -616,6 +649,8 @@ def create_session_service(options=None):
             rows.append({
                 "session_name": s["name"],
                 "provider": s["provider"],
+                "enabled": s.get("enabled", True) is not False,
+                "status": "disabled" if s.get("enabled", True) is False else "enabled",
                 "remaining_5h_pct": status.get("remaining_5h_pct") if status else None,
                 "remaining_week_pct": status.get("remaining_week_pct") if status else None,
                 "credits": status.get("credits") if status else None,
@@ -631,9 +666,18 @@ def create_session_service(options=None):
         sessions = list_sessions()
         providers = {s["provider"] for s in sessions}
         has_multiple = len(providers) > 1
+        sessions = sorted(
+            sessions,
+            key=lambda s: (
+                1 if s.get("enabled", True) is False else 0,
+                s.get("name", ""),
+            ),
+        )
         return [{
             "name": s["name"],
             "provider": s["provider"] if has_multiple else None,
+            "enabled": s.get("enabled", True) is not False,
+            "enabled_status": "disabled" if s.get("enabled", True) is False else "enabled",
             "status": s.get("lastStatus"),
             "updated_at": _to_local_iso(s.get("updatedAt")),
         } for s in sessions]
@@ -723,6 +767,7 @@ def create_session_service(options=None):
             session_record = {
                 **session_payload,
                 "provider": provider,
+                "enabled": session_payload.get("enabled", True) is not False,
                 "sessionRoot": session_root,
                 "authHome": auth_home,
             }
@@ -763,6 +808,7 @@ def create_session_service(options=None):
         "ensure_session_state": ensure_session_state,
         "list_sessions": list_sessions,
         "get_session": get_session,
+        "set_session_enabled": set_session_enabled,
         "record_status": record_status,
         "update_auth_state": update_auth_state,
         "get_status_rows": get_status_rows,

package/src/status_view.py

@@ -55,22 +55,29 @@ def _style_reset_time(value, use_color=False):
 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", "OK", "5H", "WEEK", "RESET 5H", "RESET WEEK"]
+        headers = ["SESSION", "STATUS", "OK", "5H", "WEEK", "RESET 5H", "RESET WEEK"]
     elif has_provider:
-        headers = ["SESSION", "PROV.", "OK", "5H", "WEEK", "BLOCK", "CR", "RESET 5H", "RESET WEEK", "UPDATED"]
+        headers = ["SESSION", "PROV.", "STATUS", "OK", "5H", "WEEK", "BLOCK", "CR", "RESET 5H", "RESET WEEK", "UPDATED"]
     else:
-        headers = ["SESSION", "OK", "5H", "WEEK", "BLOCK", "CR", "RESET 5H", "RESET WEEK", "UPDATED"]
+        headers = ["SESSION", "STATUS", "OK", "5H", "WEEK", "BLOCK", "CR", "RESET 5H", "RESET WEEK", "UPDATED"]
     if not rows:
         if small:
-            return "SESSION  OK  5H  WEEK  RESET 5H  RESET WEEK\nNo saved sessions yet."
-        return "SESSION  OK  5H  WEEK  BLOCK  CR  RESET 5H  RESET WEEK  UPDATED\nNo saved sessions yet."
+            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."
     headers = [_style(header, "1", use_color) for header in headers]
-    priority = _recommend_priority_sessions(rows)
+    active_rows = [r for r in rows if r.get("enabled", True) is not False]
+    disabled_rows = sorted(
+        [r for r in rows if r.get("enabled", True) is False],
+        key=lambda r: r.get("session_name") or "",
+    )
+    priority = _recommend_priority_sessions(active_rows)
     table_rows = []
-    for r in priority:
+    for r in priority + disabled_rows:
         base = [r["session_name"]]
         if has_provider:
             base.append(r.get("provider") or "n/a")
+        status = r.get("status") or ("enabled" if r.get("enabled", True) else "disabled")
+        base.append(_style(status, "2" if status == "disabled" else "32", use_color))
         usage_columns = [
             _style_pct(r.get("available_pct"), use_color),
             _style_pct(r.get("remaining_5h_pct"), use_color),
@@ -101,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),
     ])
 
 
@@ -258,6 +265,7 @@ def _format_status_detail(row, use_color=False):
     lines = [
         f"{_style('Session:', '1', use_color)} {row['session_name']}",
         f"{_style('Provider:', '1', use_color)} {row.get('provider') or 'n/a'}",
+        f"{_style('Status:', '1', use_color)} {_style(row.get('status') or ('enabled' if row.get('enabled', True) else 'disabled'), '2' if row.get('enabled', True) is False else '32', use_color)}",
         f"{_style('Available:', '1', use_color)} {_style_pct(row.get('available_pct'), use_color)}",
         f"{_style('5h left:', '1', use_color)} {_style_pct(row.get('remaining_5h_pct'), use_color)}",
         f"{_style('Week left:', '1', use_color)} {_style_pct(row.get('remaining_week_pct'), use_color)}",