cdx-manager 0.7.2 → 0.7.4

package/src/cli_commands.py

@@ -8,7 +8,7 @@ import time
 from datetime import datetime, timedelta
 
 from .claude_refresh import _refresh_claude_sessions
-from .cli_render import _dim, _info, _success, _warn
+from .cli_render import _dim, _info, _style, _success, _warn
 from .config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDER_OLLAMA, PROVIDERS
 from .context_store import (
     clear_context,
@@ -40,8 +40,9 @@ from .provider_runtime import (
 )
 from .repair import format_repair_report, repair_health
 from .backup_bundle import read_bundle_meta
-from .run_usage import empty_usage, extract_run_usage
-from .status_view import _format_status_detail, _format_status_rows
+from .run_usage import extract_run_usage
+from .run_command import read_run_prompt, run_cdx_error_code, run_result_payload
+from .status_view import _format_status_detail, _format_status_rows, format_priority_instruction, recommend_priority_rows
 from .update_check import LatestReleaseCheckError, fetch_latest_release, fetch_latest_release_or_raise, is_newer_version
 from .update_manager import build_update_plan, format_update_failure, run_update_plan, verify_updated_command
 
@@ -58,10 +59,12 @@ SET_USAGE = "Usage: cdx set <name>|--sessions all|a,b|--provider PROVIDER [--pow
 UNSET_USAGE = "Usage: cdx unset <name>|--sessions all|a,b|--provider PROVIDER (--power|--permission|--fast|--rtk|--model|--priority|--all) [--json]"
 SETTING_ALIAS_USAGE = "Usage: cdx power|perm|fast|model <name|all|provider:PROVIDER|a,b> <value|default> [--json]"
 CONFIG_USAGE = "Usage: cdx config <name> [--json]"
+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]"
 SELECT_USAGE = "Usage: cdx select --provider PROVIDER [--min-reasoning-effort low|medium|high] [--min-power low|medium|high] [--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] [--reasoning-effort low|medium|high] [--power low|medium|high] [--permission review|default|auto|full|workspace-write|read-only|danger-full-access] [--timeout-seconds N] --json"
 API_SCHEMA_VERSION = 1
 HANDOFF_TRANSCRIPT_CHARS = 120000
@@ -180,15 +183,24 @@ def _make_export_progress(ctx):
 
 
 def _make_status_progress(ctx):
+    progress_state = {"checked": 0, "total": 0}
+
     def progress(event):
         kind = event.get("event")
         if kind == "status_started":
+            progress_state["checked"] = 0
+            progress_state["total"] = event.get("check_count", event.get("session_count", 0)) or 0
             message = f"Resolving status for {event.get('session_count', 0)} session(s)..."
             ctx["out"](f"{_info(message, ctx['use_color'])}\n")
         elif kind == "session_started":
             provider = event.get("provider") or "session"
             message = f"Checking {event.get('session_name')} ({provider})..."
             ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+        elif kind == "session_finished" and not event.get("cache_hit"):
+            progress_state["checked"] += 1
+            total = progress_state["total"] or progress_state["checked"]
+            message = f"Checked {event.get('session_name')} ({progress_state['checked']}/{total})."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
         elif kind == "status_finished":
             message = f"Resolved {event.get('row_count', 0)} status row(s)."
             ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
@@ -196,18 +208,27 @@ def _make_status_progress(ctx):
 
 
 def _make_notify_progress(ctx):
+    progress_state = {"checked": 0, "total": 0}
+
     def progress(event):
         kind = event.get("event")
         if kind == "notify_check_started":
             target = event.get("session_name") or "next ready session"
             ctx["out"](f"{_info(f'Checking notification target: {target}...', ctx['use_color'])}\n")
         elif kind == "status_started":
+            progress_state["checked"] = 0
+            progress_state["total"] = event.get("check_count", event.get("session_count", 0)) or 0
             message = f"Loading status for {event.get('session_count', 0)} session(s)..."
             ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
         elif kind == "session_started":
             provider = event.get("provider") or "session"
             message = f"Checking {event.get('session_name')} ({provider})..."
             ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+        elif kind == "session_finished" and not event.get("cache_hit"):
+            progress_state["checked"] += 1
+            total = progress_state["total"] or progress_state["checked"]
+            message = f"Checked {event.get('session_name')} ({progress_state['checked']}/{total})."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
         elif kind == "notify_waiting":
             message = f"{event.get('message')}; checking again in {event.get('poll')}s..."
             ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
@@ -580,6 +601,13 @@ def _parse_config_args(args):
     return {"name": parsed["names"][0], "json": parsed["json"]}
 
 
+def _parse_configs_args(args):
+    parsed = _parse_flag_args(args, {
+        "--json": {"key": "json", "type": "bool", "default": False},
+    }, CONFIGS_USAGE)
+    return {"json": parsed["json"]}
+
+
 def _parse_select_args(args):
     parsed = _parse_flag_args(args, {
         "--provider": {"key": "provider", "type": "str", "default": None, "transform": lambda value: _parse_provider_filter(value, SELECT_USAGE)},
@@ -605,6 +633,14 @@ def _parse_select_args(args):
     }
 
 
+def _parse_next_args(args):
+    parsed = _parse_flag_args(args, {
+        "--refresh": {"key": "refresh", "type": "bool", "default": False},
+        "--json": {"key": "json", "type": "bool", "default": False},
+    }, NEXT_USAGE)
+    return {"json": parsed["json"], "refresh": parsed["refresh"]}
+
+
 def _parse_timeout_seconds(value):
     try:
         parsed = float(value)
@@ -1211,70 +1247,73 @@ def handle_select(rest, ctx):
     return 0
 
 
-def _read_run_prompt(parsed):
-    if parsed.get("prompt") is not None:
-        return parsed["prompt"]
-    try:
-        with open(parsed["prompt_file"], "r", encoding="utf-8") as handle:
-            return handle.read()
-    except OSError as error:
-        raise CdxError(f"Unable to read prompt file: {parsed['prompt_file']}") from error
-
-
-def _run_cdx_error_code(error):
-    message = str(error)
-    if message.startswith("Usage:"):
-        return "invalid_request"
-    if message.startswith("Invalid cwd:"):
-        return "invalid_cwd"
-    if message.startswith("Session is disabled:"):
-        return "session_disabled"
-    if "CLI not found on PATH" in message:
-        return "provider_cli_not_found"
-    if message.startswith("Failed to start "):
-        return "provider_start_failed"
-    if (
-        message.startswith("Unsupported reasoning effort:")
-        or message.startswith("Unsupported power:")
-        or "--reasoning-effort and --power must match" in message
-    ):
-        return "invalid_reasoning_effort"
-    return "cdx_error"
-
-
-def _run_result_payload(ok, parsed, session, run_info=None, error=None, error_source=None, error_code=None):
-    run_info = run_info or {}
-    usage = run_info.get("usage") if isinstance(run_info.get("usage"), dict) else (
-        extract_run_usage(session.get("provider"), run_info.get("stdout_path"))
-        if session else
-        empty_usage()
-    )
-    return {
-        "schema_version": API_SCHEMA_VERSION,
-        "ok": bool(ok),
-        "action": "run",
-        "launcher": "cdx",
-        "session": session.get("name") if session else None,
-        "provider": session.get("provider") if session else parsed.get("provider"),
-        "model": parsed.get("model") or ((session.get("launch") or {}).get("model") if session else None),
-        "reasoning_effort": parsed.get("reasoning_effort") or ((session.get("launch") or {}).get("reasoning_effort") if session else None),
-        "power": parsed.get("power") or ((session.get("launch") or {}).get("power") if session else None),
-        "cwd": os.path.abspath(parsed.get("cwd") or os.getcwd()),
-        "run_id": run_info.get("run_id"),
-        "exit_code": run_info.get("returncode"),
-        "duration_seconds": (run_info.get("duration_ms") / 1000.0) if run_info.get("duration_ms") is not None else None,
-        "transcript_path": run_info.get("transcript_path"),
-        "stdout_path": run_info.get("stdout_path"),
-        "stderr_path": run_info.get("stderr_path"),
-        "usage": usage,
-        "warnings": [],
-        "error": None if ok else {
-            "source": error_source or "cdx",
-            "code": error_code or "cdx_error",
-            "message": str(error) if error else "Run failed.",
-            "provider_code": run_info.get("returncode") if error_source == "provider" else None,
-        },
-    }
+def _format_next_pct(value):
+    return "n/a" if value is None else f"{value}%"
+
+
+def _next_action(row):
+    instruction = format_priority_instruction(row, "first")
+    return "refresh" if instruction.startswith("refresh ") else "use"
+
+
+def _format_next_selection(session, row, use_color=False):
+    from .cli_render import _pad_table
+
+    action = _next_action(row)
+    command = f"cdx status {session['name']} --refresh" if action == "refresh" else f"cdx {session['name']}"
+    rows = [[_style(value, "1", use_color) for value in ["SESSION", "PROVIDER", "OK", "5H", "WEEK", "REASON"]]]
+    rows.append([
+        _style(session["name"], "36", use_color),
+        _dim(session.get("provider") or "-", use_color),
+        _format_next_pct(row.get("available_pct")),
+        _format_next_pct(row.get("remaining_5h_pct")),
+        _format_next_pct(row.get("remaining_week_pct")),
+        format_priority_instruction(row, "first"),
+    ])
+    return "\n".join([
+        _style("Next assistant:", "1", use_color),
+        _pad_table(rows),
+        "",
+        f"{_style('Run:', '1', use_color)} {_style(command, '36', use_color)}",
+    ])
+
+
+def handle_next(rest, ctx):
+    parsed = _parse_next_args(rest)
+    rows = ctx["service"]["get_status_rows"](force_refresh=parsed["refresh"])
+    priority = recommend_priority_rows(rows)
+    if not priority:
+        message = "No usable session status yet."
+        if parsed["json"]:
+            _write_json(ctx, _json_failure("next", "no_suitable_session", message, selection_policy="status_priority"))
+            return 1
+        ctx["out"](f"{_warn(message, ctx['use_color'])}\n")
+        return 1
+    row = priority[0]
+    session_name = row.get("session_name")
+    session = ctx["service"]["get_session"](session_name)
+    if not session:
+        message = f"Selected status row has no matching session: {session_name}"
+        if parsed["json"]:
+            _write_json(ctx, _json_failure("next", "missing_session", message, selection_policy="status_priority", row=row))
+            return 1
+        raise CdxError(message)
+    action = _next_action(row)
+    message = f"Selected next session {session['name']}"
+    if parsed["json"]:
+        _write_json(ctx, _json_success(
+            "next",
+            message,
+            session=session,
+            row=row,
+            recommended_action=action,
+            command=f"cdx status {session['name']} --refresh" if action == "refresh" else f"cdx {session['name']}",
+            reason=format_priority_instruction(row, "first"),
+            selection_policy="status_priority",
+        ))
+        return 0
+    ctx["out"](f"{_format_next_selection(session, row, ctx['use_color'])}\n")
+    return 0
 
 
 def handle_run(rest, ctx):
@@ -1309,7 +1348,7 @@ def handle_run(rest, ctx):
         cwd = os.path.abspath(parsed["cwd"])
         if not os.path.isdir(cwd):
             raise CdxError(f"Invalid cwd: {parsed['cwd']}")
-        prompt = _read_run_prompt(parsed)
+        prompt = read_run_prompt(parsed)
         launch_updates = {}
         if parsed.get("model"):
             launch_updates["model"] = parsed["model"]
@@ -1334,6 +1373,7 @@ def handle_run(rest, ctx):
             stdin_is_tty=False,
             behavior="launch",
             signal_emitter=ctx.get("signal_emitter"),
+            trust_local_credentials=False,
         )
         run_info = _run_headless_provider_command(
             run_session,
@@ -1353,7 +1393,7 @@ def handle_run(rest, ctx):
                 "exit_code": 0,
                 **run_info,
             })
-            _write_json(ctx, _run_result_payload(True, parsed, run_session, run_info=run_info))
+            _write_json(ctx, run_result_payload(API_SCHEMA_VERSION, True, parsed, run_session, run_info=run_info))
             return 0
         message = "Provider process timed out." if run_info.get("timed_out") else "Provider process exited with a non-zero status."
         error = CdxError(message, run_info.get("returncode") or 1)
@@ -1364,7 +1404,8 @@ def handle_run(rest, ctx):
             "exit_code": error.exit_code,
             **run_info,
         })
-        _write_json(ctx, _run_result_payload(
+        _write_json(ctx, run_result_payload(
+            API_SCHEMA_VERSION,
             False,
             parsed,
             run_session,
@@ -1376,28 +1417,102 @@ def handle_run(rest, ctx):
         return error.exit_code or 1
     except CdxError as error:
         run_info = getattr(error, "run_info", None)
-        _write_json(ctx, _run_result_payload(
+        _write_json(ctx, run_result_payload(
+            API_SCHEMA_VERSION,
             False,
             locals().get("parsed", {}) or {},
             locals().get("session"),
             run_info=run_info,
             error=error,
             error_source="cdx",
-            error_code=_run_cdx_error_code(error),
+            error_code=run_cdx_error_code(error),
         ))
         return error.exit_code
 
 
-def _format_launch_config(session):
+def _format_launch_config(session, use_color=False):
+    from .cli_render import _dim, _pad_table, _style
+
     launch = session.get("launch") or {}
+    rows = [[_style("SETTING", "1", use_color), _style("VALUE", "1", use_color)]]
+    for key, label in [
+        ("power", "Power"),
+        ("permission", "Permission"),
+        ("fast", "Fast"),
+        ("rtk", "RTK"),
+        ("model", "Model"),
+        ("priority", "Priority"),
+    ]:
+        rows.append([
+            _dim(label, use_color),
+            _format_launch_setting_value(launch, key, use_color=use_color),
+        ])
+    provider_label = f"({session['provider']})"
     return "\n".join([
-        f"{session['name']} ({session['provider']})",
-        f"power:      {launch.get('power') or 'default'}",
-        f"permission: {launch.get('permission') or 'default'}",
-        f"fast:       {'on' if launch.get('fast') is True else 'off' if launch.get('fast') is False else 'default'}",
-        f"rtk:        {'on' if launch.get('rtk') is True else 'off' if launch.get('rtk') is False else 'default'}",
-        f"model:      {launch.get('model') or 'default'}",
-        f"priority:   {launch.get('priority') if launch.get('priority') is not None else 'default'}",
+        _style("Launch settings:", "1", use_color),
+        f"{_style(session['name'], '36', use_color)} {_dim(provider_label, use_color)}",
+        _pad_table(rows),
+        "",
+        _dim(_format_launch_settings_hint(session["name"]), use_color),
+    ])
+
+
+def _format_launch_settings_hint(name="<name>"):
+    return (
+        f"Set a value: cdx set {name} --power medium --permission auto "
+        "--fast on --rtk on --model MODEL --priority 80"
+    )
+
+
+def _format_launch_setting_value(launch, key, use_color=False):
+    if key == "fast" or key == "rtk":
+        if launch.get(key) is True:
+            return _style("on", "32", use_color)
+        if launch.get(key) is False:
+            return _style("off", "2", use_color)
+        return _dim("default", use_color)
+    value = launch.get(key)
+    if value is None or value == "":
+        return _dim("default", use_color)
+    if key == "priority":
+        return _style(str(value), "33", use_color)
+    if key == "power":
+        return _style(str(value), "96", use_color)
+    if key == "permission":
+        return _style(str(value), "32", use_color)
+    return str(value)
+
+
+def _format_launch_configs(sessions, use_color=False):
+    from .cli_render import _dim, _pad_table, _style
+
+    if not sessions:
+        return "\n".join([
+            _style("Launch settings:", "1", use_color),
+            "No sessions.",
+            "",
+            _dim(_format_launch_settings_hint(), use_color),
+        ])
+    rows = [[_style(value, "1", use_color) for value in [
+        "SESSION", "PROVIDER", "POWER", "PERMISSION", "FAST", "RTK", "MODEL", "PRIORITY"
+    ]]]
+    for session in sessions:
+        launch = session.get("launch") or {}
+        rows.append([
+            _style(session["name"], "36", use_color),
+            _dim(session.get("provider") or "-", use_color),
+            _format_launch_setting_value(launch, "power", use_color),
+            _format_launch_setting_value(launch, "permission", use_color),
+            _format_launch_setting_value(launch, "fast", use_color),
+            _format_launch_setting_value(launch, "rtk", use_color),
+            _format_launch_setting_value(launch, "model", use_color),
+            _format_launch_setting_value(launch, "priority", use_color),
+        ])
+    return "\n".join([
+        _style("Launch settings:", "1", use_color),
+        _pad_table(rows),
+        "",
+        _dim(_format_launch_settings_hint(), use_color),
     ])
 
 
@@ -1529,7 +1644,15 @@ def _format_duration_ms(value):
         return f"{seconds:.1f}s"
     minutes = int(seconds // 60)
     remaining = int(seconds % 60)
-    return f"{minutes}m{remaining:02d}s"
+    if minutes < 60:
+        return f"{minutes}m {remaining:02d}s"
+    hours = minutes // 60
+    remaining_minutes = minutes % 60
+    if hours < 24:
+        return f"{hours}h {remaining_minutes:02d}m"
+    days = hours // 24
+    remaining_hours = hours % 24
+    return f"{days}d {remaining_hours:02d}h"
 
 
 def _summarize_history(entries):
@@ -1656,49 +1779,57 @@ def _format_period_display(value):
     return parsed.strftime("%Y-%m-%d %H:%M")
 
 
-def _format_history_summary(entries, period=None, use_color=False):
+def _format_history_summary(entries, period=None, use_color=False, active_sessions=None):
     from .cli_render import _format_relative_age, _pad_table
 
+    active_sessions = active_sessions or set()
     summary = _summarize_history(entries)
     if not summary:
         return "No launch history for this period." if _has_history_period(period or {}) else "No launch history."
-    rows = [["SESSION", "PROV.", "LAUNCHES", "OK", "FAIL", "TIME", "LAST"]]
+    rows = [[_style(value, "1", use_color) for value in ["SESSION", "PROV.", "LAUNCHES", "OK", "FAIL", "TIME", "LAST"]]]
     for row in summary:
+        session_name = row["session_name"]
+        display_name = f"{session_name}*" if session_name in active_sessions else session_name
         rows.append([
-            row["session_name"],
-            row["provider"],
-            str(row["launches"]),
-            str(row["successes"]),
-            str(row["failures"]),
-            _format_duration_ms(row["duration_ms"]),
-            _format_relative_age(row.get("last_started_at")),
+            _style(display_name, "36", use_color),
+            _dim(row["provider"], use_color),
+            _style(str(row["launches"]), "1", use_color),
+            _style(str(row["successes"]), "32" if row["successes"] else "2", use_color),
+            _style(str(row["failures"]), "31" if row["failures"] else "2", use_color),
+            _style(_format_duration_ms(row["duration_ms"]), "33" if row["duration_ms"] else "2", use_color),
+            _dim(_format_relative_age(row.get("last_started_at")), use_color),
         ])
-    lines = ["Assistant time:"]
+    lines = [_style("Assistant time:", "1", use_color)]
     period_line = _format_history_period(period or {})
     if period_line:
-        lines.extend([period_line, ""])
+        lines.extend([_dim(period_line, use_color), ""])
     lines.append(_pad_table(rows))
     return "\n".join(lines)
 
 
-def _format_history(entries, use_color=False):
+def _format_history(entries, use_color=False, active_sessions=None):
     from .cli_render import _format_relative_age, _pad_table
 
+    active_sessions = active_sessions or set()
     if not entries:
         return "No launch history."
-    rows = [["SESSION", "PROV.", "RESULT", "DURATION", "WHEN", "TRANSCRIPT"]]
+    rows = [[_style(value, "1", use_color) for value in ["SESSION", "PROV.", "RESULT", "DURATION", "WHEN", "TRANSCRIPT"]]]
     for entry in entries:
         transcript_path = entry.get("transcript_path")
+        session_name = entry.get("session_name") or "-"
+        display_name = f"{session_name}*" if session_name in active_sessions else session_name
+        status = entry.get("status") or "-"
+        status_color = "32" if status == "success" else "31" if status == "failed" else "2"
         rows.append([
-            entry.get("session_name") or "-",
-            entry.get("provider") or "-",
-            entry.get("status") or "-",
-            _format_duration_ms(entry.get("duration_ms")),
-            _format_relative_age(entry.get("started_at")),
-            os.path.basename(transcript_path) if transcript_path else "-",
+            _style(display_name, "36", use_color),
+            _dim(entry.get("provider") or "-", use_color),
+            _style(status, status_color, use_color),
+            _style(_format_duration_ms(entry.get("duration_ms")), "33" if entry.get("duration_ms") else "2", use_color),
+            _dim(_format_relative_age(entry.get("started_at")), use_color),
+            _dim(os.path.basename(transcript_path) if transcript_path else "-", use_color),
         ])
     return "\n".join([
-        "Recent launches:",
+        _style("Recent launches:", "1", use_color),
         _pad_table(rows),
         "",
         _dim("Full transcript paths and cwd are available with --json.", use_color),
@@ -1717,29 +1848,34 @@ def _format_token_count(value):
     return str(amount)
 
 
-def _format_stats(rows, totals, period=None, use_color=False):
+def _format_stats(rows, totals, period=None, use_color=False, active_sessions=None):
     from .cli_render import _format_relative_age, _pad_table
 
+    active_sessions = active_sessions or set()
     if not rows:
         return "No launch stats for this period." if _has_history_period(period or {}) else "No launch stats."
-    table = [["SESSION", "PROV.", "RUNS", "USAGE", "IN", "OUT", "REASON", "TOTAL", "TIME", "LAST"]]
+    table = [[_style(value, "1", use_color) for value in [
+        "SESSION", "PROV.", "RUNS", "USAGE", "IN", "OUT", "REASON", "TOTAL", "TIME", "LAST"
+    ]]]
     for row in rows:
+        session_name = row["session_name"]
+        display_name = f"{session_name}*" if session_name in active_sessions else session_name
         table.append([
-            row["session_name"],
-            row["provider"],
-            str(row["launches"]),
-            str(row["usage_runs"]),
-            _format_token_count(row["input_tokens"]),
-            _format_token_count(row["output_tokens"]),
-            _format_token_count(row["reasoning_tokens"]),
-            _format_token_count(row["total_tokens"]),
-            _format_duration_ms(row["duration_ms"]),
-            _format_relative_age(row.get("last_started_at")),
+            _style(display_name, "36", use_color),
+            _dim(row["provider"], use_color),
+            _style(str(row["launches"]), "1", use_color),
+            _style(str(row["usage_runs"]), "32" if row["usage_runs"] else "2", use_color),
+            _style(_format_token_count(row["input_tokens"]), "96" if row["input_tokens"] else "2", use_color),
+            _style(_format_token_count(row["output_tokens"]), "96" if row["output_tokens"] else "2", use_color),
+            _style(_format_token_count(row["reasoning_tokens"]), "95" if row["reasoning_tokens"] else "2", use_color),
+            _style(_format_token_count(row["total_tokens"]), "1;96" if row["total_tokens"] else "2", use_color),
+            _style(_format_duration_ms(row["duration_ms"]), "33" if row["duration_ms"] else "2", use_color),
+            _dim(_format_relative_age(row.get("last_started_at")), use_color),
         ])
-    lines = ["Assistant stats:"]
+    lines = [_style("Assistant stats:", "1", use_color)]
     period_line = _format_history_period(period or {})
     if period_line:
-        lines.extend([period_line, ""])
+        lines.extend([_dim(period_line, use_color), ""])
     lines.append(_pad_table(table))
     lines.extend([
         "",
@@ -1754,6 +1890,14 @@ def _format_stats(rows, totals, period=None, use_color=False):
     return "\n".join(lines)
 
 
+def _active_session_names(ctx):
+    return {
+        row["name"]
+        for row in ctx["service"]["format_list_rows"]()
+        if row.get("active")
+    }
+
+
 def _apply_launch_settings(parsed, ctx, action="set"):
     targets = _resolve_bulk_launch_targets(parsed, ctx["service"])
     sessions = [
@@ -1778,7 +1922,7 @@ def _apply_launch_settings(parsed, ctx, action="set"):
         return 0
     ctx["out"](f"{_success(message, ctx['use_color'])}\n")
     if len(sessions) == 1:
-        ctx["out"](f"{_format_launch_config(sessions[0])}\n")
+        ctx["out"](f"{_format_launch_config(sessions[0], ctx['use_color'])}\n")
     return 0
 
 
@@ -1806,7 +1950,7 @@ def _clear_launch_settings(parsed, ctx, action="unset"):
         return 0
     ctx["out"](f"{_success(message, ctx['use_color'])}\n")
     if len(sessions) == 1:
-        ctx["out"](f"{_format_launch_config(sessions[0])}\n")
+        ctx["out"](f"{_format_launch_config(sessions[0], ctx['use_color'])}\n")
     return 0
 
 
@@ -1834,7 +1978,18 @@ def handle_config(rest, ctx):
     if parsed["json"]:
         _write_json(ctx, _json_success("config", message, session=session, launch=session.get("launch") or {}))
         return 0
-    ctx["out"](f"{_format_launch_config(session)}\n")
+    ctx["out"](f"{_format_launch_config(session, ctx['use_color'])}\n")
+    return 0
+
+
+def handle_configs(rest, ctx):
+    parsed = _parse_configs_args(rest)
+    sessions = ctx["service"]["list_sessions"]()
+    message = f"Listed launch settings for {len(sessions)} session{'s' if len(sessions) != 1 else ''}"
+    if parsed["json"]:
+        _write_json(ctx, _json_success("configs", message, count=len(sessions), sessions=sessions))
+        return 0
+    ctx["out"](f"{_format_launch_configs(sessions, ctx['use_color'])}\n")
     return 0
 
 
@@ -1859,10 +2014,11 @@ def handle_history(rest, ctx):
             payload["summary"] = _summarize_history(entries)
         _write_json(ctx, _json_success("history", message, **payload))
         return 0
+    active_sessions = _active_session_names(ctx)
     if parsed["summary"]:
-        ctx["out"](f"{_format_history_summary(entries, period=parsed['period'], use_color=ctx['use_color'])}\n")
+        ctx["out"](f"{_format_history_summary(entries, period=parsed['period'], use_color=ctx['use_color'], active_sessions=active_sessions)}\n")
         return 0
-    ctx["out"](f"{_format_history(entries, use_color=ctx['use_color'])}\n")
+    ctx["out"](f"{_format_history(entries, use_color=ctx['use_color'], active_sessions=active_sessions)}\n")
     return 0
 
 
@@ -1888,7 +2044,8 @@ def handle_stats(rest, ctx):
             totals=totals,
         ))
         return 0
-    ctx["out"](f"{_format_stats(rows, totals, period=parsed['period'], use_color=ctx['use_color'])}\n")
+    active_sessions = _active_session_names(ctx)
+    ctx["out"](f"{_format_stats(rows, totals, period=parsed['period'], use_color=ctx['use_color'], active_sessions=active_sessions)}\n")
     return 0
 
 

package/src/cli_render.py

@@ -146,6 +146,9 @@ def _format_sessions(service, use_color=False):
     lines += [
         _style("Next actions:", "1", use_color),
         f"  {_style('cdx status', '36', use_color)}",
+        f"  {_style('cdx next', '36', use_color)}",
+        f"  {_style('cdx configs', '36', use_color)}",
+        f"  {_style('cdx stats', '36', use_color)}",
         f"  {_style('cdx ready', '36', use_color)}",
         f"  {_style('cdx perm all default', '36', use_color)}",
         f"  {_style('cdx handoff <source> <target>', '36', use_color)}",