cdx-manager 0.9.3 → 0.9.5

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.1-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.9.5-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.**
 
@@ -69,6 +69,7 @@ One command to launch any session. Zero auth juggling.
   - 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.
+- Status latency controls: use `cdx status --cached` to skip live probes, `cdx status --timeout SECONDS` for one command, or `CDX_STATUS_TIMEOUT_SECONDS` to lower the default Codex live-probe timeout.
 - Claude status refreshes are cached briefly by default; pass `--refresh` to force a live rate-limit probe.
 - On Linux, transcript capture uses the `util-linux` `script -c` command form.
 - If `script` is unavailable, Codex launch falls back to running without transcript capture.
@@ -329,6 +330,7 @@ cdx history --summary --from 2026-05-01 --to 2026-05-28
 | `cdx --json` | List all sessions as a machine-readable JSON payload |
 | `cdx <name>` | Launch a session (checks auth first) |
 | `cdx <name> [--json]` | Launch a session; `--json` returns a structured success payload after the interactive run ends |
+| `cdx <name> -r` / `cdx <name> --resume` | Resume the provider-native conversation for a session when supported |
 | `cdx add [provider] <name> [--model MODEL] [--json]` | Register a new session (`provider`: `codex`, `claude`, `antigravity`, or `ollama`; Ollama requires `--model`) |
 | `cdx cp <source> <dest> [--json]` | Copy a session into another session name, overwriting the destination if it exists |
 | `cdx ren <source> <dest> [--json]` | Rename a session and move its auth data |
@@ -343,6 +345,8 @@ cdx history --summary --from 2026-05-01 --to 2026-05-28
 | `cdx unset <name>\|--sessions all\|a,b\|--provider PROVIDER (--power\|--permission\|--fast\|--rtk\|--logics\|--model\|--priority\|--all) [--json]` | Remove persisted launch settings and fall back to provider defaults |
 | `cdx history [name] [--limit N] [--summary] [--since 7d\|today\|DATE] [--from DATE] [--to DATE] [--json]` | Show recent launch history or aggregate total launch time per assistant, optionally filtered by period |
 | `cdx last [--json]` | Launch the most recent existing session from launch history |
+| `cdx resume <name> [--json]` | Resume the provider-native conversation for a session using the named command form |
+| `cdx can-resume <name> [--json]` | Check whether a session supports native resume without launching the provider |
 | `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; supports cross-provider handoff |
@@ -361,9 +365,9 @@ cdx history --summary --from 2026-05-01 --to 2026-05-28
 | `cdx select --provider PROVIDER [--min-reasoning-effort minimal\|low\|medium\|high\|xhigh] [--min-power minimal\|low\|medium\|high\|xhigh] [--require-ready] [--refresh] --json` | Select a suitable session for headless automation |
 | `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 MODE] [--timeout-seconds N] --json` | Run one headless task and return a stable JSON result |
 | `cdx stats [name] [--since 7d\|today\|DATE] [--from DATE] [--to DATE] [--json]` | Aggregate launch counts, duration, and known headless token usage by session |
-| `cdx status [--json] [--refresh]` | Show token usage table for all sessions; JSON returns a versioned payload with structured warnings |
-| `cdx status --small [--refresh]` / `cdx status -s [--refresh]` | Show compact token usage table without provider, blocking quota, credits, and updated columns |
-| `cdx status <name> [--json] [--refresh]` | Show detailed usage breakdown for one session |
+| `cdx status [--json] [--refresh\|--cached] [--timeout SECONDS]` | Show token usage table for all sessions; `--cached` skips live provider probes and returns only stored status |
+| `cdx status --small [--refresh\|--cached] [--timeout SECONDS]` / `cdx status -s [--refresh\|--cached] [--timeout SECONDS]` | Show compact token usage table without provider, blocking quota, credits, and updated columns |
+| `cdx status <name> [--json] [--refresh\|--cached] [--timeout SECONDS]` | Show detailed usage breakdown for one session; `--cached` avoids live provider refreshes |
 | `cdx --help` | Show usage |
 | `cdx --version` | Show version |
 
@@ -426,7 +430,7 @@ Most commands use a shared stderr JSON envelope for errors whenever `--json` is
   "ok": false,
   "error": {
     "code": "invalid_usage",
-    "message": "Usage: cdx status [--json] [--refresh] | ...",
+    "message": "Usage: cdx status [--json] [--refresh|--cached] [--timeout SECONDS] | ...",
     "exit_code": 1
   }
 }

package/changelogs/CHANGELOGS_0_9_4.md

@@ -0,0 +1,43 @@
+# CDX Manager 0.9.4
+
+## Highlights
+
+- Added provider-native resume commands for named sessions.
+- Added a non-launching capability check for resume support.
+- Closed the Logics workflow for the resume command delivery.
+
+## Changes
+
+### Provider-native resume commands
+
+`cdx` can now resume supported provider conversations without requiring users to remember provider-specific commands:
+
+```
+cdx main -r
+cdx main --resume
+cdx resume main
+```
+
+Codex sessions resume with `codex resume --last --cd <cwd>` inside the named session's isolated `CODEX_HOME`. Claude sessions resume with `claude --continue --name <name>` inside the named session's isolated `HOME`.
+
+Providers without a verified native resume mode, currently Antigravity and Ollama, return a clear unsupported result instead of falling back to a normal launch.
+
+### Resume capability checks
+
+`cdx can-resume <name>` reports whether a session can resume without launching an interactive provider. JSON mode exposes a provider-neutral payload with the session name, provider, resumable state, strategy, reason, and command preview.
+
+### Workflow traceability
+
+The Logics request, backlog item, task, and ADR for provider-native resume are complete, with validation evidence attached to the delivery task.
+
+## Validation
+
+- `python -m unittest discover -s test -p 'test_runtime_py.py' -k resume`
+- `python -m unittest discover -s test -p 'test_cli_py.py' -k resume`
+- `python -m unittest discover -s test -p 'test_cli_py.py' -k help`
+- `python -m unittest discover -s test -p 'test_*_py.py' -k resume`
+- `npm run lint`
+- `npm test`
+- `logics-manager lint --require-status`
+- `logics-manager audit`
+- `git diff --check`

package/changelogs/CHANGELOGS_0_9_5.md

@@ -0,0 +1,45 @@
+# CDX Manager 0.9.5
+
+## Highlights
+
+- Made per-session status lookup targeted instead of resolving every configured session.
+- Added fast status controls for automation-heavy workspaces.
+- Added a Logics release contract for the `cdx-manager` release workflow.
+
+## Changes
+
+### Faster per-session status
+
+`cdx status <name>` now resolves only the named session. Previously the command collected all status rows and filtered afterward, so a detail lookup could still trigger live probes for every configured session.
+
+### Cached and bounded status probes
+
+`cdx status --cached` reads stored status only and skips live provider probes. This is intended for AGENTS prompts, health checks, and project scripts that need a quick snapshot without risking provider timeouts.
+
+Live Codex status probes can also be bounded with:
+
+```
+cdx status --timeout 1
+CDX_STATUS_TIMEOUT_SECONDS=1 cdx status
+```
+
+The timeout applies to Codex live rate-limit probes while preserving the existing cached and fallback behavior.
+
+### Release workflow contract
+
+The repository now includes `logics/release/contract.json` and `logics/release/release-contract.v1.schema.json`. The contract records the expected version sources, changelog path, checksum gate, validation commands, GitHub release gate, npm publication, and PyPI publication checks.
+
+## Validation
+
+- `python -m unittest discover -s test -p 'test_session_service_py.py'`
+- `python -m unittest discover -s test -p 'test_cli_py.py' -k 'status'`
+- `npm run lint`
+- JSON Schema validation for `logics/release/contract.json`
+- `logics-manager lint --require-status`
+- `logics-manager audit`
+- `git diff --check`
+- `node bin/cdx.js --version`
+- `python3 bin/cdx --version`
+- `npm --cache /private/tmp/cdx-npm-cache pack --dry-run`
+- `python -m build`
+- `python -m twine check dist/*`

package/checksums/release-archives.json

@@ -76,6 +76,14 @@
     "v0.9.2": {
       "github_tarball_sha256": "3e3ae4e4efc63a97dc6623ae8ddff36f04f4b7a0b531878a28c041298223d0b8",
       "github_zip_sha256": "09acd2866770f4dc7f9aaba6aff8308766bb211dabddd7f28bdfde9ace427e78"
+    },
+    "v0.9.3": {
+      "github_tarball_sha256": "cb3cfd9134447d1049b510836014001fb6c38a89de588adc8cdbb1fe5deb4d6d",
+      "github_zip_sha256": "056eb2d1a3f0fa721a7a0e597cd0409e496618cfa35791a78d4e184397596754"
+    },
+    "v0.9.4": {
+      "github_tarball_sha256": "fe1c96e612392130a98ec6d9856ec41fb0c055c1a274ee77f143b5e4b8c1fb2f",
+      "github_zip_sha256": "494b84aef93f796d78ef164c7b7670ba3dec1d81f66be966cb7a84d77d5ed6e3"
     }
   }
 }

package/package.json

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

package/src/cli.py

@@ -11,6 +11,7 @@ from .cli_commands import (
     handle_clean,
     handle_config,
     handle_configs,
+    handle_can_resume,
     handle_context,
     handle_copy,
     handle_doctor,
@@ -30,6 +31,7 @@ from .cli_commands import (
     handle_remove,
     handle_repair,
     handle_rename,
+    handle_resume,
     handle_run,
     handle_run_report,
     handle_run_status,
@@ -64,7 +66,7 @@ from .status_view import (
 )
 from .update_check import check_for_update, check_logics_manager_for_update
 
-VERSION = "0.9.3"
+VERSION = "0.9.5"
 
 
 # ---------------------------------------------------------------------------
@@ -78,9 +80,9 @@ def _print_help(use_color=False):
         _style("Usage:", "1", use_color),
         f"  {_style('cdx', '36', use_color)}",
         f"  {_style('cdx --json', '36', use_color)}",
-        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 status [--json] [--refresh|--cached] [--timeout SECONDS]', '36', use_color)}",
+        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 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)}",
@@ -96,6 +98,8 @@ def _print_help(use_color=False):
         f"  {_style('cdx history [name] [--limit N] [--summary] [--since 7d|today|DATE] [--from DATE] [--to DATE] [--json]', '36', use_color)}",
         f"  {_style('cdx stats [name] [--since 7d|today|DATE] [--from DATE] [--to DATE] [--json]', '36', use_color)}",
         f"  {_style('cdx last [--json]', '36', use_color)}",
+        f"  {_style('cdx resume <name> [--json]', '36', use_color)}",
+        f"  {_style('cdx can-resume <name> [--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> [--model MODEL] [--json]', '36', use_color)}",
@@ -283,7 +287,7 @@ def main(argv, options=None):
         "version": VERSION,
         "cwd": options.get("cwd") or os.getcwd(),
         "update_notices": _get_update_notices(service, env, options) if command not in (
-            "add", "cp", "ren", "rename", "mv", "rmv", "clean", "doctor", "repair", "view", "update", "ready", "notify", "next", "context", "config", "configs", "set", "unset", "power", "perm", "fast", "model", "history", "stats", "handoff", "login", "logout", "disable", "enable", "export", "import", "select", "run", "help", "version"
+            "add", "cp", "ren", "rename", "mv", "rmv", "clean", "doctor", "repair", "view", "update", "ready", "notify", "next", "context", "config", "configs", "set", "unset", "power", "perm", "fast", "model", "history", "stats", "resume", "can-resume", "handoff", "login", "logout", "disable", "enable", "export", "import", "select", "run", "help", "version"
         ) else None,
         "use_color": use_color,
     }
@@ -365,6 +369,12 @@ def main(argv, options=None):
     if command == "last":
         return handle_last(rest, ctx)
 
+    if command == "resume":
+        return handle_resume(rest, ctx)
+
+    if command == "can-resume":
+        return handle_can_resume(rest, ctx)
+
     if command == "handoff":
         return handle_handoff(rest, ctx)
 
@@ -400,8 +410,8 @@ def main(argv, options=None):
         out(f"{_print_version()}\n")
         return 0
 
-    if not rest or rest == ["--json"]:
-        return handle_launch(command, ctx)
+    if all(arg in ("--json", "-r", "--resume") for arg in rest):
+        return handle_launch(command, ctx, resume=("-r" in rest or "--resume" in rest))
 
     raise CdxError(f"Unknown command: {command}. Use cdx --help.")
 

package/src/cli_commands.py

@@ -3,6 +3,7 @@ import getpass
 import json
 import os
 import re
+import shlex
 import sys
 import time
 from datetime import datetime, timedelta
@@ -37,6 +38,7 @@ from .provider_runtime import (
     _list_launch_transcript_paths,
     _normalize_reasoning_effort,
     _probe_provider_auth,
+    get_resume_capability,
     _run_headless_provider_command,
     _run_interactive_provider_command,
 )
@@ -50,7 +52,7 @@ from .update_check import LatestReleaseCheckError, fetch_latest_release, fetch_l
 from .update_manager import build_update_plan, format_update_failure, run_update_plan, verify_updated_command
 
 
-STATUS_USAGE = "Usage: cdx status [--json] [--refresh] | cdx status --small|-s [--refresh] | cdx status <name> [--json] [--refresh]"
+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]"
 REPAIR_USAGE = "Usage: cdx repair [--dry-run] [--force] [--json]"
 UPDATE_USAGE = "Usage: cdx update [--check] [--yes] [--json] [--version TAG]"
@@ -66,6 +68,8 @@ CONFIGS_USAGE = "Usage: cdx configs [--json]"
 HISTORY_USAGE = "Usage: cdx history [name] [--limit N] [--summary] [--since 7d|today|DATE] [--from DATE] [--to DATE] [--json]"
 STATS_USAGE = "Usage: cdx stats [name] [--since 7d|today|DATE] [--from DATE] [--to DATE] [--json]"
 LAST_USAGE = "Usage: cdx last [--json]"
+RESUME_USAGE = "Usage: cdx resume <name> [--json]"
+CAN_RESUME_USAGE = "Usage: cdx can-resume <name> [--json]"
 SELECT_USAGE = "Usage: cdx select --provider PROVIDER [--min-reasoning-effort minimal|low|medium|high|xhigh] [--min-power minimal|low|medium|high|xhigh] [--require-ready] [--refresh] --json"
 NEXT_USAGE = "Usage: cdx next [--json] [--refresh]"
 RUN_USAGE = "Usage: cdx run [session] --cwd PATH (--prompt-file PATH|--prompt TEXT) [--provider PROVIDER] [--model MODEL] [--kind assistant|code-review] [--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"
@@ -668,13 +672,13 @@ def _parse_next_args(args):
     return {"json": parsed["json"], "refresh": parsed["refresh"]}
 
 
-def _parse_timeout_seconds(value):
+def _parse_timeout_seconds(value, usage=RUN_USAGE):
     try:
         parsed = float(value)
     except (TypeError, ValueError) as error:
-        raise CdxError(RUN_USAGE) from error
+        raise CdxError(usage) from error
     if parsed <= 0:
-        raise CdxError(RUN_USAGE)
+        raise CdxError(usage)
     return parsed
 
 
@@ -2483,18 +2487,26 @@ def handle_status(rest, ctx):
         "--small": {"key": "small", "type": "bool", "default": False},
         "-s": {"key": "small", "type": "bool", "default": False},
         "--refresh": {"key": "refresh", "type": "bool", "default": False},
+        "--cached": {"key": "cached", "type": "bool", "default": False},
+        "--timeout": {"key": "timeout", "type": "str", "default": None, "transform": lambda value: _parse_timeout_seconds(value, STATUS_USAGE)},
     }, STATUS_USAGE, positionals_key="args", max_positionals=1)
     if parsed["json"] and parsed["small"]:
         raise CdxError(STATUS_USAGE)
+    if parsed["refresh"] and parsed["cached"]:
+        raise CdxError(STATUS_USAGE)
     args = parsed["args"]
     if len(args) == 1 and parsed["small"]:
         raise CdxError(STATUS_USAGE)
 
-    auth_refresh = _refresh_claude_auth_states(
-        ctx["service"],
-        target_names=args if len(args) == 1 else None,
-        spawn_sync=ctx.get("spawn_sync"),
-        env_override=ctx.get("env"),
+    auth_refresh = (
+        {"errors": []}
+        if parsed["cached"]
+        else _refresh_claude_auth_states(
+            ctx["service"],
+            target_names=args if len(args) == 1 else None,
+            spawn_sync=ctx.get("spawn_sync"),
+            env_override=ctx.get("env"),
+        )
     )
     warnings = [
         {
@@ -2504,11 +2516,15 @@ def handle_status(rest, ctx):
         }
         for item in auth_refresh.get("errors", [])
     ]
-    refresh_result = _refresh_claude_sessions(
-        ctx["service"],
-        ctx.get("refresh_fn"),
-        target_names=args if len(args) == 1 else None,
-        force=parsed["refresh"],
+    refresh_result = (
+        {"errors": []}
+        if parsed["cached"]
+        else _refresh_claude_sessions(
+            ctx["service"],
+            ctx.get("refresh_fn"),
+            target_names=args if len(args) == 1 else None,
+            force=parsed["refresh"],
+        )
     )
     refresh_errors = [
         {
@@ -2528,26 +2544,32 @@ def handle_status(rest, ctx):
     warnings.extend(_update_notice_warnings(ctx))
 
     status_progress = None if parsed["json"] else _make_status_progress(ctx)
-    rows = ctx["service"]["get_status_rows"](
-        progress_callback=status_progress,
-        force_refresh=parsed["refresh"],
-    )
-    if len(args) == 0:
+    if len(args) == 1:
+        row = ctx["service"]["get_status_row"](
+            args[0],
+            progress_callback=status_progress,
+            force_refresh=parsed["refresh"],
+            cache_only=parsed["cached"],
+            status_timeout_seconds=parsed["timeout"],
+        )
         if parsed["json"]:
-            _write_json(ctx, _json_success("status", "Collected session status rows", warnings=warnings, rows=rows))
+            _write_json(ctx, _json_success("status", f"Collected status for {args[0]}", warnings=warnings, session=row))
             return 0
-        ctx["out"](f"{_format_status_rows(rows, use_color=ctx['use_color'], small=parsed['small'])}\n")
+        ctx["out"](f"{_format_status_detail(row, use_color=ctx['use_color'])}\n")
         _write_refresh_warnings(refresh_errors, ctx)
         _write_update_notice(ctx)
         return 0
 
-    row = next((r for r in rows if r["session_name"] == args[0]), None)
-    if not row:
-        raise CdxError(f"Unknown session: {args[0]}")
+    rows = ctx["service"]["get_status_rows"](
+        progress_callback=status_progress,
+        force_refresh=parsed["refresh"],
+        cache_only=parsed["cached"],
+        status_timeout_seconds=parsed["timeout"],
+    )
     if parsed["json"]:
-        _write_json(ctx, _json_success("status", f"Collected status for {args[0]}", warnings=warnings, session=row))
+        _write_json(ctx, _json_success("status", "Collected session status rows", warnings=warnings, rows=rows))
         return 0
-    ctx["out"](f"{_format_status_detail(row, use_color=ctx['use_color'])}\n")
+    ctx["out"](f"{_format_status_rows(rows, use_color=ctx['use_color'], small=parsed['small'])}\n")
     _write_refresh_warnings(refresh_errors, ctx)
     _write_update_notice(ctx)
     return 0
@@ -2844,10 +2866,83 @@ def handle_update(rest, ctx):
     return 0
 
 
-def handle_launch(command, ctx, initial_prompt=None):
+def _resume_capability_for_session(session, ctx):
+    capability = get_resume_capability(session, cwd=ctx.get("cwd") or os.getcwd())
+    return {
+        "session": session["name"],
+        "provider": session["provider"],
+        "resumable": bool(capability.get("resumable")),
+        "strategy": capability.get("strategy"),
+        "reason": capability.get("reason"),
+        "command_preview": capability.get("command_preview") or [],
+    }
+
+
+def _format_resume_capability(capability, use_color=False):
+    name = capability["session"]
+    provider = capability["provider"]
+    if capability["resumable"]:
+        preview = shlex.join(capability.get("command_preview") or [])
+        detail = f"({provider}, {capability['strategy']})"
+        return (
+            f"{_success(f'{name} can resume', use_color)} "
+            f"{_dim(detail, use_color)}\n"
+            f"{_dim(preview, use_color)}"
+        )
+    reason = capability.get("reason") or "not_supported"
+    return (
+        f"{_warn(f'{name} cannot resume', use_color)} "
+        f"{_dim(f'({provider}, {reason})', use_color)}"
+    )
+
+
+def handle_can_resume(rest, ctx):
+    json_flag, args = _parse_json_flag(rest)
+    if len(args) != 1:
+        raise CdxError(CAN_RESUME_USAGE)
+    session = ctx["service"]["get_session"](args[0])
+    if not session:
+        raise CdxError(f"Unknown session: {args[0]}")
+    if session.get("enabled", True) is False:
+        capability = {
+            "session": session["name"],
+            "provider": session["provider"],
+            "resumable": False,
+            "strategy": "session_disabled",
+            "reason": "session_disabled",
+            "command_preview": [],
+        }
+    else:
+        capability = _resume_capability_for_session(session, ctx)
+    if json_flag:
+        _write_json(ctx, {
+            "schema_version": API_SCHEMA_VERSION,
+            "ok": True,
+            **capability,
+        })
+        return 0
+    ctx["out"](f"{_format_resume_capability(capability, ctx['use_color'])}\n")
+    return 0
+
+
+def handle_resume(rest, ctx):
+    json_flag, args = _parse_json_flag(rest)
+    if len(args) != 1:
+        raise CdxError(RESUME_USAGE)
+    return handle_launch(args[0], ctx, resume=True, force_json=json_flag)
+
+
+def handle_launch(command, ctx, initial_prompt=None, resume=False, force_json=None):
     json_flag = "--json" in ctx.get("raw_args", ctx["options"].get("raw_args", []))
+    if force_json is not None:
+        json_flag = force_json
     warnings = _update_notice_warnings(ctx)
     session = ctx["service"]["launch_session"](command)
+    capability = _resume_capability_for_session(session, ctx) if resume else None
+    if capability and not capability["resumable"]:
+        raise CdxError(
+            f"Provider {session['provider']} does not support native resume through cdx."
+        )
     _ensure_session_authentication(
         session,
         ctx["service"],
@@ -2859,7 +2954,11 @@ def handle_launch(command, ctx, initial_prompt=None):
         signal_emitter=ctx.get("signal_emitter"),
         trust_local_credentials=False,
     )
-    message = f"Launching {session['provider']} session {session['name']}"
+    message = (
+        f"Resuming {session['provider']} session {session['name']}"
+        if resume else
+        f"Launching {session['provider']} session {session['name']}"
+    )
     if not json_flag:
         ctx["out"](f"{_info(message, ctx['use_color'])}\n")
         _write_update_notice(ctx)
@@ -2880,7 +2979,7 @@ def handle_launch(command, ctx, initial_prompt=None):
 
     try:
         run_info = _run_interactive_provider_command(
-            session, "launch", spawn=ctx.get("spawn"), cwd=cwd, env_override=ctx.get("env"),
+            session, "resume" if resume else "launch", spawn=ctx.get("spawn"), cwd=cwd, env_override=ctx.get("env"),
             signal_emitter=ctx.get("signal_emitter"), initial_prompt=initial_prompt,
             lifecycle_callback=runtime_lifecycle,
         )
@@ -2903,12 +3002,16 @@ def handle_launch(command, ctx, initial_prompt=None):
         raise
     ctx["service"]["record_launch_history"](session["name"], {
         "status": "success",
+        "action": "resume" if resume else "launch",
         "cwd": cwd,
         "exit_code": 0,
         **run_info,
     })
     if json_flag:
-        _write_json(ctx, _json_success("launch", message, warnings=warnings, session=ctx["service"]["get_session"](session["name"])))
+        extra = {"session": ctx["service"]["get_session"](session["name"])}
+        if capability:
+            extra["resume"] = capability
+        _write_json(ctx, _json_success("resume" if resume else "launch", message, warnings=warnings, **extra))
     return 0
 
 

package/src/provider_runtime.py

@@ -511,6 +511,90 @@ def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None
     }, capture_transcript=capture_transcript, env=env)
 
 
+def _redacted_resume_command_preview(session, cwd=None):
+    capability = get_resume_capability(session, cwd=cwd)
+    return capability.get("command_preview")
+
+
+def get_resume_capability(session, cwd=None):
+    provider = session.get("provider")
+    cwd = cwd or os.getcwd()
+    if provider == PROVIDER_CODEX:
+        return {
+            "resumable": True,
+            "provider": provider,
+            "strategy": "provider_last",
+            "reason": "supported",
+            "command_preview": ["codex", "resume", "--last", "--cd", cwd],
+        }
+    if provider == PROVIDER_CLAUDE:
+        return {
+            "resumable": True,
+            "provider": provider,
+            "strategy": "provider_continue",
+            "reason": "supported",
+            "command_preview": ["claude", "--continue"],
+        }
+    return {
+        "resumable": False,
+        "provider": provider,
+        "strategy": "not_supported",
+        "reason": "not_supported",
+        "command_preview": [],
+    }
+
+
+def _build_resume_spec(session, cwd=None, env_override=None, capture_transcript=True):
+    cwd = cwd or os.getcwd()
+    env_override = env_override or {}
+    env = {**os.environ, **env_override}
+    capability = get_resume_capability(session, cwd=cwd)
+    if not capability["resumable"]:
+        raise CdxError(f"Provider {session.get('provider')} does not support native resume through cdx.")
+
+    resume_prompt = _with_launch_preferences(session, env=env)
+    _validate_initial_prompt(resume_prompt)
+
+    if session["provider"] == PROVIDER_CLAUDE:
+        launch = session.get("launch") or {}
+        args = ["--continue", "--name", session["name"]]
+        if launch.get("model"):
+            args += ["--model", _claude_cli_model(launch["model"])]
+        args += _launch_config_args(session)
+        if resume_prompt:
+            args.append(resume_prompt)
+        auth_home = _get_auth_home(session)
+        claude_env = _claude_env(env, auth_home)
+        oauth_token = _read_claude_launch_oauth_token(auth_home)
+        if oauth_token:
+            claude_env["CLAUDE_CODE_OAUTH_TOKEN"] = oauth_token
+        return _wrap_launch_with_transcript(session, {
+            "command": "claude",
+            "args": args,
+            "options": {
+                "cwd": cwd,
+                "env": claude_env,
+            },
+            "label": "claude resume",
+        }, capture_transcript=capture_transcript, env=env)
+
+    launch = session.get("launch") or {}
+    args = ["resume", "--last", "--cd", cwd]
+    if launch.get("model"):
+        args += ["--model", launch["model"]]
+    args += _launch_config_args(session)
+    if resume_prompt:
+        args.append(resume_prompt)
+    return _wrap_launch_with_transcript(session, {
+        "command": "codex",
+        "args": args,
+        "options": {
+            "env": {**env, "CODEX_HOME": _get_auth_home(session)},
+        },
+        "label": "codex resume",
+    }, capture_transcript=capture_transcript, env=env)
+
+
 def _validate_initial_prompt(initial_prompt):
     if initial_prompt is not None:
         if not isinstance(initial_prompt, str):
@@ -846,11 +930,14 @@ def _run_interactive_provider_command(session, action, spawn=None, cwd=None,
                                       env_override=None, signal_emitter=None,
                                       initial_prompt=None, lifecycle_callback=None):
     spawn = spawn or subprocess.Popen
-    spec = (
-        _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)
-    )
+    if action == "launch":
+        spec = _build_launch_spec(session, cwd=cwd, env_override=env_override, initial_prompt=initial_prompt)
+    elif action == "resume":
+        if initial_prompt is not None:
+            raise CdxError("initial_prompt is not supported for resume.")
+        spec = _build_resume_spec(session, cwd=cwd, env_override=env_override)
+    else:
+        spec = _build_auth_action_spec(session, action, cwd=cwd, env_override=env_override)
     def start_child(current_spec):
         command = current_spec["command"]
         if spawn is subprocess.Popen:

package/src/session_service.py

@@ -21,6 +21,7 @@ ALLOWED_PROVIDERS = set(PROVIDERS)
 MAX_SESSION_NAME_LENGTH = 64
 RESERVED_SESSION_NAMES = {
     "add",
+    "can-resume",
     "clean",
     "context",
     "configs",
@@ -45,6 +46,7 @@ RESERVED_SESSION_NAMES = {
     "power",
     "ready",
     "repair",
+    "resume",
     "ren",
     "rename",
     "rmv",
@@ -65,6 +67,7 @@ RESERVED_SESSION_NAMES = {
 }
 STATUS_CACHE_TTL_SECONDS = 60
 CLAUDE_STATUS_CACHE_TTL_SECONDS = 10 * 60
+STATUS_PROBE_TIMEOUT_SECONDS = 5
 MAX_STATUS_WORKERS = 8
 LAUNCH_POWER_VALUES = {"minimal", "low", "medium", "high", "xhigh"}
 LAUNCH_REASONING_EFFORT_VALUES = {"minimal", "low", "medium", "high", "xhigh"}
@@ -276,6 +279,18 @@ def _status_cache_ttl_seconds(session, ttl_seconds=STATUS_CACHE_TTL_SECONDS):
     return ttl_seconds
 
 
+def _parse_status_timeout_seconds(value):
+    if value in (None, ""):
+        return None
+    try:
+        parsed = float(value)
+    except (TypeError, ValueError):
+        return None
+    if parsed <= 0:
+        return None
+    return parsed
+
+
 def _is_status_cache_fresh(session, ttl_seconds=STATUS_CACHE_TTL_SECONDS):
     status = session.get("lastStatus") or {}
     if _is_low_confidence_status_source(status):
@@ -431,7 +446,19 @@ 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
+    custom_codex_status_fetcher = options.get("fetchCodexRateLimits")
+    codex_status_fetcher = custom_codex_status_fetcher or fetch_codex_rate_limits
+    default_status_timeout_seconds = (
+        _parse_status_timeout_seconds(options.get("statusTimeoutSeconds"))
+        or _parse_status_timeout_seconds(env.get("CDX_STATUS_TIMEOUT_SECONDS"))
+        or STATUS_PROBE_TIMEOUT_SECONDS
+    )
+
+    def _fetch_codex_status(session, timeout_seconds=None):
+        if custom_codex_status_fetcher:
+            return custom_codex_status_fetcher(session)
+        timeout = timeout_seconds or default_status_timeout_seconds
+        return codex_status_fetcher(session, timeout=timeout)
 
     def _get_session_root(name):
         return os.path.join(base_dir, "profiles", _encode(name))
@@ -905,17 +932,28 @@ def create_session_service(options=None):
             raise CdxError(f"Unknown session: {name}")
         return store["list_launch_history"](session_name=name, limit=limit)
 
-    def _resolve_session_status(session, force_refresh=False, cache_ttl_seconds=STATUS_CACHE_TTL_SECONDS):
+    def _resolve_session_status(
+        session,
+        force_refresh=False,
+        cache_ttl_seconds=STATUS_CACHE_TTL_SECONDS,
+        cache_only=False,
+        status_timeout_seconds=None,
+    ):
         current_status = session.get("lastStatus")
         if session.get("enabled", True) is False:
             return current_status
+        if cache_only:
+            return current_status
         if current_status and not force_refresh and _is_status_cache_fresh(session, ttl_seconds=cache_ttl_seconds):
             return current_status
         source_root = session.get("authHome") or _get_session_auth_home(
             session["name"], session["provider"]
         )
         if session["provider"] == PROVIDER_CODEX and codex_status_fetcher:
-            live_status = codex_status_fetcher({**session, "authHome": source_root})
+            live_status = _fetch_codex_status(
+                {**session, "authHome": source_root},
+                timeout_seconds=status_timeout_seconds,
+            )
             if live_status:
                 record_status(session["name"], live_status)
                 return live_status
@@ -981,41 +1019,133 @@ def create_session_service(options=None):
             raise CdxError(f"Unknown session: {name}")
         return updated
 
-    def get_status_rows(progress_callback=None, force_refresh=False, cache_ttl_seconds=STATUS_CACHE_TTL_SECONDS):
-        sessions = list_sessions()
-
-        def _status_cache_hit(s):
-            return (
-                s.get("enabled", True) is False
-                or (
-                    s.get("lastStatus")
-                    and not force_refresh
-                    and _is_status_cache_fresh(s, ttl_seconds=cache_ttl_seconds)
-                )
+    def _status_cache_hit(s, force_refresh=False, cache_ttl_seconds=STATUS_CACHE_TTL_SECONDS, cache_only=False):
+        return (
+            cache_only
+            or s.get("enabled", True) is False
+            or (
+                s.get("lastStatus")
+                and not force_refresh
+                and _is_status_cache_fresh(s, ttl_seconds=cache_ttl_seconds)
             )
+        )
 
-        cache_hits = {
-            s["name"]: _status_cache_hit(s)
-            for s in sessions
+    def _resolve_row_session(
+        s,
+        force_refresh=False,
+        cache_ttl_seconds=STATUS_CACHE_TTL_SECONDS,
+        cache_only=False,
+        status_timeout_seconds=None,
+    ):
+        status = _resolve_session_status(
+            s,
+            force_refresh=force_refresh,
+            cache_ttl_seconds=cache_ttl_seconds,
+            cache_only=cache_only,
+            status_timeout_seconds=status_timeout_seconds,
+        )
+        return {
+            **s,
+            "lastStatus": status,
+            "lastStatusAt": (status and status.get("updated_at")) or s.get("lastStatusAt"),
         }
+
+    def _status_row_from_session(s):
+        status = s.get("lastStatus")
+        enabled = s.get("enabled", True) is not False
+        row_status = status if enabled else None
+        return {
+            "session_name": s["name"],
+            "provider": s["provider"],
+            "enabled": enabled,
+            "active": bool(_session_runtime(s["name"])) if enabled else False,
+            "status": "enabled" if enabled else "disabled",
+            "auth_status": (s.get("auth") or {}).get("status") or "unknown",
+            "auth_checked_at": _to_local_iso((s.get("auth") or {}).get("lastCheckedAt")),
+            "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,
+            "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,
+            "reset_at": row_status.get("reset_at") if row_status else None,
+            "updated_at": _to_local_iso(s.get("lastStatusAt")),
+            "last_launched_at": _to_local_iso(s.get("lastLaunchedAt")),
+        }
+
+    def get_status_row(
+        name,
+        progress_callback=None,
+        force_refresh=False,
+        cache_ttl_seconds=STATUS_CACHE_TTL_SECONDS,
+        cache_only=False,
+        status_timeout_seconds=None,
+    ):
+        session = store["get_session"](name)
+        if not session:
+            raise CdxError(f"Unknown session: {name}")
+        cache_hit = _status_cache_hit(
+            session,
+            force_refresh=force_refresh,
+            cache_ttl_seconds=cache_ttl_seconds,
+            cache_only=cache_only,
+        )
         if progress_callback:
             progress_callback({
                 "event": "status_started",
-                "session_count": len(sessions),
-                "check_count": sum(1 for cache_hit in cache_hits.values() if not cache_hit),
+                "session_count": 1,
+                "check_count": 0 if cache_hit else 1,
+            })
+            if not cache_hit:
+                progress_callback({
+                    "event": "session_started",
+                    "session_name": session["name"],
+                    "provider": session["provider"],
+                })
+        resolved = _resolve_row_session(
+            session,
+            force_refresh=force_refresh,
+            cache_ttl_seconds=cache_ttl_seconds,
+            cache_only=cache_only,
+            status_timeout_seconds=status_timeout_seconds,
+        )
+        if progress_callback:
+            progress_callback({
+                "event": "session_finished",
+                "session_name": session["name"],
+                "has_status": bool(resolved.get("lastStatus")),
+                "cache_hit": cache_hit,
+            })
+            progress_callback({
+                "event": "status_finished",
+                "row_count": 1,
             })
+        return _status_row_from_session(resolved)
+
+    def get_status_rows(
+        progress_callback=None,
+        force_refresh=False,
+        cache_ttl_seconds=STATUS_CACHE_TTL_SECONDS,
+        cache_only=False,
+        status_timeout_seconds=None,
+    ):
+        sessions = list_sessions()
 
-        def _resolve_row_session(s):
-            status = _resolve_session_status(
+        cache_hits = {
+            s["name"]: _status_cache_hit(
                 s,
                 force_refresh=force_refresh,
                 cache_ttl_seconds=cache_ttl_seconds,
+                cache_only=cache_only,
             )
-            return {
-                **s,
-                "lastStatus": status,
-                "lastStatusAt": (status and status.get("updated_at")) or s.get("lastStatusAt"),
-            }
+            for s in sessions
+        }
+        if progress_callback:
+            progress_callback({
+                "event": "status_started",
+                "session_count": len(sessions),
+                "check_count": sum(1 for cache_hit in cache_hits.values() if not cache_hit),
+            })
 
         resolved_by_name = {}
         if sessions:
@@ -1030,7 +1160,14 @@ def create_session_service(options=None):
                             "session_name": s["name"],
                             "provider": s["provider"],
                         })
-                    futures[executor.submit(_resolve_row_session, s)] = s
+                    futures[executor.submit(
+                        _resolve_row_session,
+                        s,
+                        force_refresh=force_refresh,
+                        cache_ttl_seconds=cache_ttl_seconds,
+                        cache_only=cache_only,
+                        status_timeout_seconds=status_timeout_seconds,
+                    )] = s
                 for future in as_completed(futures):
                     s = futures[future]
                     resolved = future.result()
@@ -1058,27 +1195,7 @@ def create_session_service(options=None):
 
         rows = []
         for s in resolved:
-            status = s.get("lastStatus")
-            enabled = s.get("enabled", True) is not False
-            row_status = status if enabled else None
-            rows.append({
-                "session_name": s["name"],
-                "provider": s["provider"],
-                "enabled": enabled,
-                "active": bool(_session_runtime(s["name"])) if enabled else False,
-                "status": "enabled" if enabled else "disabled",
-                "auth_status": (s.get("auth") or {}).get("status") or "unknown",
-                "auth_checked_at": _to_local_iso((s.get("auth") or {}).get("lastCheckedAt")),
-                "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,
-                "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,
-                "reset_at": row_status.get("reset_at") if row_status else None,
-                "updated_at": _to_local_iso(s.get("lastStatusAt")),
-                "last_launched_at": _to_local_iso(s.get("lastLaunchedAt")),
-            })
+            rows.append(_status_row_from_session(s))
         if progress_callback:
             progress_callback({
                 "event": "status_finished",
@@ -1293,6 +1410,7 @@ def create_session_service(options=None):
         "record_launch_history": record_launch_history,
         "get_launch_history": get_launch_history,
         "update_auth_state": update_auth_state,
+        "get_status_row": get_status_row,
         "get_status_rows": get_status_rows,
         "format_list_rows": format_list_rows,
         "get_session_auth_home": get_session_auth_home,