cdx-manager 0.9.3 → 0.9.4

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.4-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.**
 
@@ -329,6 +329,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 +344,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 |

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/checksums/release-archives.json

@@ -76,6 +76,10 @@
     "v0.9.2": {
       "github_tarball_sha256": "3e3ae4e4efc63a97dc6623ae8ddff36f04f4b7a0b531878a28c041298223d0b8",
       "github_zip_sha256": "09acd2866770f4dc7f9aaba6aff8308766bb211dabddd7f28bdfde9ace427e78"
+    },
+    "v0.9.3": {
+      "github_tarball_sha256": "cb3cfd9134447d1049b510836014001fb6c38a89de588adc8cdbb1fe5deb4d6d",
+      "github_zip_sha256": "056eb2d1a3f0fa721a7a0e597cd0409e496618cfa35791a78d4e184397596754"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.9.3",
+  "version": "0.9.4",
   "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.4"
 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.4"
 
 
 # ---------------------------------------------------------------------------
@@ -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,
 )
@@ -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"
@@ -2844,10 +2848,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 +2936,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 +2961,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 +2984,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",