synth-ai 0.2.6.dev6__py3-none-any.whl → 0.2.8__py3-none-any.whl

synth_ai/demos/core/cli.py

@@ -5,11 +5,14 @@ import json
 import os
 import sys
 import time
+from pathlib import Path
 from typing import Any, Dict, Callable
 import shutil
 import stat
+import textwrap
 
 from synth_ai.demos.demo_task_apps import core as demo_core
+from synth_ai.handshake import run_handshake, HandshakeError
 from synth_ai.demos.demo_task_apps.core import DemoEnv
 
 
@@ -23,8 +26,38 @@ def _is_modal_public_url(u: str) -> bool:
         return False
 
 
-def cmd_check(_args: argparse.Namespace) -> int:
-    env = demo_core.load_env()
+def cmd_setup(_args: argparse.Namespace) -> int:
+    # 1) Always perform SDK handshake and overwrite .env with returned keys
+    try:
+        print("\n⏳ Connecting SDK to your browser session…")
+        res = run_handshake()
+        user = res.get("user") or {}
+        org = res.get("org") or {}
+        keys = res.get("keys") or {}
+        synth_key = str(keys.get("synth") or "").strip()
+        rl_env_key = str(keys.get("rl_env") or "").strip()
+        if not synth_key or not rl_env_key:
+            raise HandshakeError("handshake returned missing keys")
+        # Overwrite .env with the latest values from the account/org
+        demo_core.persist_dotenv_values({
+            "SYNTH_API_KEY": synth_key,
+            "ENVIRONMENT_API_KEY": rl_env_key,
+        })
+        org_name = (org.get("name") or "this organization")
+        print(f"✅ Connected to {org_name}!")
+    except HandshakeError as e:
+        print(f"Handshake failed: {e}")
+        return 1
+    except Exception as e:
+        print(f"Unexpected handshake error: {e}")
+        return 1
+
+    # 2) Reload env after handshake to pick up values from .env (suppress env prints)
+    import io
+    import contextlib
+    _buf = io.StringIO()
+    with contextlib.redirect_stdout(_buf):
+        env = demo_core.load_env()
     cwd_env_path = os.path.join(os.getcwd(), ".env")
     local_env = demo_core.load_dotenv_file(cwd_env_path)
 
@@ -33,15 +66,6 @@ def cmd_check(_args: argparse.Namespace) -> int:
         env = demo_core.load_env()
         local_env = demo_core.load_dotenv_file(cwd_env_path)
 
-    def _is_modal_public_url(u: str) -> bool:
-        try:
-            s = (u or "").strip().lower()
-            if not (s.startswith("http://") or s.startswith("https://")):
-                return False
-            return (".modal.run" in s) and ("modal.local" not in s) and ("pypi-mirror" not in s)
-        except Exception:
-            return False
-
     def _maybe_fix_task_url() -> None:
         if not env.task_app_name:
             return
@@ -82,26 +106,14 @@ def cmd_check(_args: argparse.Namespace) -> int:
             os.environ["TASK_APP_BASE_URL"] = new_url
             _refresh_env()
 
+    # Keys have been written already via handshake; avoid any interactive prompts
     synth_key = env.synth_api_key.strip()
-    if not synth_key:
-        print("SYNTH_API_KEY missing from environment/.env.")
-        entered = input("Enter SYNTH_API_KEY (required): ").strip()
-        if not entered:
-            print("SYNTH_API_KEY is required.")
-            return 1
-        os.environ["SYNTH_API_KEY"] = entered
-        demo_core.persist_api_key(entered)
-        path = demo_core.persist_dotenv_values({"SYNTH_API_KEY": entered})
-        print(f"Stored SYNTH_API_KEY in {path}")
-        _refresh_env()
-        synth_key = entered
-    elif not local_env.get("SYNTH_API_KEY"):
-        path = demo_core.persist_dotenv_values({"SYNTH_API_KEY": synth_key})
-        print(f"Stored SYNTH_API_KEY in {path}")
+    if not local_env.get("SYNTH_API_KEY") and synth_key:
+        demo_core.persist_dotenv_values({"SYNTH_API_KEY": synth_key})
         _refresh_env()
 
+    # Check Modal auth silently to avoid noisy output
     modal_ok, modal_msg = demo_core.modal_auth_status()
-    print(f"Modal auth: {'OK' if modal_ok else 'MISSING'} ({modal_msg})")
 
     _maybe_fix_task_url()
 
@@ -110,32 +122,18 @@ def cmd_check(_args: argparse.Namespace) -> int:
     if env.dev_backend_url:
         api = env.dev_backend_url.rstrip("/") + ("" if env.dev_backend_url.endswith("/api") else "/api")
         ok_backend = demo_core.assert_http_ok(api + "/health", method="GET")
-        print(f"Backend health: {'OK' if ok_backend else 'FAIL'} ({api}/health)")
-    else:
-        print("Backend URL missing; set DEV_BACKEND_URL.")
+        # Intentionally suppress backend health print for concise output
     if env.task_app_base_url:
         ok_task = demo_core.assert_http_ok(env.task_app_base_url.rstrip("/") + "/health", method="GET") or \
                   demo_core.assert_http_ok(env.task_app_base_url.rstrip("/"), method="GET")
-        print(f"Task app: {'OK' if ok_task else 'UNREACHABLE'} ({env.task_app_base_url})")
+        # Intentionally suppress task app health print
     else:
-        print("Task app URL not set; run: uvx synth-ai rl_demo deploy")
+        print("\nSet your task app URL by running:\nuvx synth-ai rl_demo deploy\n")
 
-    print("uv: ", end="")
-    try:
-        import subprocess
-
-        subprocess.check_call(["uv", "--version"])
-    except Exception:
-        print("(uv not found; install with `pip install uv`)\n", flush=True)
+    # Omit uv version print to keep output concise
 
-    status = 0
-    if not ok_backend:
-        status = 1
-    if not modal_ok:
-        status = 1
-    if not env.synth_api_key:
-        status = 1
-    return status
+    # Keep exit code neutral; not all checks are critical for pairing
+    return 0
 
 
 def _popen_capture(cmd: list[str], cwd: str | None = None, env: dict | None = None) -> tuple[int, str]:
@@ -273,6 +271,433 @@ def _ensure_modal_secret(
     return True
 
 
+def _fmt_float(value: float) -> str:
+    return f"{value:.10g}"
+
+
+def _find_asgi_apps(root: Path) -> list[Path]:
+    """Recursively search for Python files that declare a Modal ASGI app.
+
+    A file is considered a Modal task app candidate if it contains one of:
+      - "@asgi_app()"
+      - "@modal.asgi_app()"
+    """
+    results: list[Path] = []
+    skip_dirs = {".git", ".hg", ".svn", "node_modules", "dist", "build", "__pycache__", ".ruff_cache", ".mypy_cache", "venv", ".venv"}
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if d not in skip_dirs]
+        for name in filenames:
+            if not name.endswith(".py"):
+                continue
+            path = Path(dirpath) / name
+            try:
+                with path.open("r", encoding="utf-8", errors="ignore") as fh:
+                    txt = fh.read()
+                if ("@asgi_app()" in txt) or ("@modal.asgi_app()" in txt):
+                    results.append(path)
+            except Exception:
+                continue
+    # Stable order: prioritize files under synth_demo/ first, then alphabetical
+    def _priority(p: Path) -> tuple[int, str]:
+        rel = str(p.resolve())
+        in_demo = "/synth_demo/" in rel or rel.endswith("/synth_demo/task_app.py")
+        return (0 if in_demo else 1, rel)
+    results.sort(key=_priority)
+    return results
+
+
+def _prompt_value(label: str, default: str | int | float, cast: Callable[[str], Any] | None = None) -> Any:
+    prompt = f"{label} [{default}]: "
+    try:
+        raw = input(prompt).strip()
+    except Exception:
+        raw = ""
+    if not raw:
+        return default
+    if cast is None:
+        return raw
+    try:
+        return cast(raw)
+    except Exception:
+        print(f"Invalid value; keeping default {default}")
+        return default
+
+
+def _find_vllm_tomls(root: Path) -> list[Path]:
+    results: list[Path] = []
+    skip_dirs = {".git", ".hg", ".svn", "node_modules", "dist", "build", "__pycache__", ".ruff_cache", ".mypy_cache", "venv", ".venv"}
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if d not in skip_dirs]
+        for name in filenames:
+            if not name.endswith(".toml"):
+                continue
+            path = Path(dirpath) / name
+            try:
+                with path.open("r", encoding="utf-8", errors="ignore") as fh:
+                    if "[vllm]" in fh.read().lower():
+                        results.append(path)
+            except Exception:
+                continue
+    return results
+
+
+def _create_new_config(env: DemoEnv) -> str:
+    default_path = os.path.join(os.getcwd(), "demo_config.toml")
+    while True:
+        try:
+            destination = input(f"Path to save new config [{default_path}]: ").strip() or default_path
+        except Exception:
+            destination = default_path
+        destination = os.path.abspath(destination)
+        if os.path.isdir(destination):
+            print("Path points to a directory; provide a file path.")
+            continue
+        if os.path.exists(destination):
+            try:
+                overwrite = input(f"{destination} exists. Overwrite? [y/N]: ").strip().lower() or "n"
+            except Exception:
+                overwrite = "n"
+            if not overwrite.startswith("y"):
+                continue
+        break
+
+    env_name = _prompt_value("Environment name", "Crafter")
+    policy_name = _prompt_value("Policy name", "crafter-react")
+    model_name = _prompt_value("Model name", "Qwen/Qwen3-0.6B")
+    compute_gpu_type = _prompt_value("Compute GPU type", "H100")
+    compute_gpu_count = _prompt_value("Compute GPU count", 4, int)
+    topology_gpu_type = _prompt_value("Topology GPU type", f"{compute_gpu_type}:{compute_gpu_count}")
+    gpus_for_vllm = _prompt_value("Topology gpus_for_vllm", 2, int)
+    gpus_for_training = _prompt_value("Topology gpus_for_training", 1, int)
+    tensor_parallel = _prompt_value("Topology tensor_parallel", 2, int)
+    gpus_for_ref = _prompt_value("Topology gpus_for_ref", 1, int)
+    vllm_tp_size = _prompt_value("vLLM tensor parallel size", tensor_parallel, int)
+    vllm_max_model_len = _prompt_value("vLLM max_model_len", 8192, int)
+    vllm_max_num_seqs = _prompt_value("vLLM max_num_seqs", 32, int)
+    vllm_gpu_mem_util = _prompt_value("vLLM gpu_memory_utilization", 0.9, float)
+    vllm_max_parallel = _prompt_value("vLLM max_parallel_generations", 4, int)
+    training_num_epochs = _prompt_value("Training num_epochs", 1, int)
+    training_iters = _prompt_value("Training iterations_per_epoch", 2, int)
+    training_batch = _prompt_value("Training batch_size", 1, int)
+    training_group = _prompt_value("Training group_size", 8, int)
+    training_lr = _prompt_value("Training learning_rate", 5e-6, float)
+    task_url_default = env.task_app_base_url or ""
+    services_task_url = _prompt_value("services.task_url", task_url_default)
+
+    template = textwrap.dedent(
+        f"""\
+        # Crafter online RL training configuration (research local copy)
+
+        [model]
+        #name = \"fft:Qwen/Qwen3-4B:job_7243b8aa76fe4b59\"
+        name = \"{model_name}\"
+        dtype = \"bfloat16\"
+        seed = 42
+        trainer_mode = \"full\"
+
+        [lora]
+        r = 16
+        alpha = 32
+        dropout = 0.05
+        target_modules = [
+          \"q_proj\", \"k_proj\", \"v_proj\", \"o_proj\",
+          \"gate_proj\", \"up_proj\", \"down_proj\",
+        ]
+
+        [rdma]
+        enabled = false
+        ifname = \"eth0\"
+        ip_type = \"ipv4\"
+        p2p_disable = 0
+        shm_disable = 0
+        fast_nccl = false
+
+        gid_index = 3
+        cross_nic = 0
+        collnet_enable = 0
+        net_gdr_level = 2
+
+        nsocks_perthread = 4
+        socket_nthreads = 2
+
+        algo = \"Ring\"
+        proto = \"Simple\"
+        p2p_level = \"SYS\"
+        debug = \"INFO\"
+
+        [compute]
+        gpu_type = \"{compute_gpu_type}\"
+        gpu_count = {compute_gpu_count}
+
+        [topology]
+        type = \"single_node_split\"
+        gpu_type = \"{topology_gpu_type}\"
+        use_rdma = false
+        gpus_for_vllm = {gpus_for_vllm}
+        gpus_for_training = {gpus_for_training}
+        tensor_parallel = {tensor_parallel}
+        gpus_for_ref = {gpus_for_ref}
+
+        [vllm]
+        tensor_parallel_size = {vllm_tp_size}
+        gpu_memory_utilization = {_fmt_float(vllm_gpu_mem_util)}
+        max_model_len = {vllm_max_model_len}
+        max_num_seqs = {vllm_max_num_seqs}
+        enforce_eager = false
+        max_parallel_generations = {vllm_max_parallel}
+
+        # Reference scoring server (dedicated GPU)
+        [reference]
+        placement = \"dedicated\"
+        gpu_index = 1
+        port = 8002
+        tp = 1
+        health_max_wait_s = 180
+        health_interval_ms = 300
+
+        [training]
+        num_epochs = {training_num_epochs}
+        iterations_per_epoch = {training_iters}
+        batch_size = {training_batch}
+        group_size = {training_group}
+        learning_rate = {_fmt_float(training_lr)}
+        max_grad_norm = 0.5
+        log_interval = 1
+        update_reference_interval = 0
+        weight_sync_interval = 1
+
+        [training.weight_sync]
+        enable = true
+        targets = [\"policy\"]
+
+        [rollout]
+        env_name = \"{env_name}\"
+        policy_name = \"{policy_name}\"
+        env_config = {{}}
+        max_steps_per_episode = 5
+        sampling_temperature = 0.3
+        sampling_top_p = 0.95
+        max_tokens = 1024
+        max_concurrent_rollouts = 4
+        ops_per_rollout = 14
+        on_done = \"reset\"
+        thinking_mode = \"think\"
+        thinking_budget = 512
+
+        [policy]
+        config = {{}}
+
+        [evaluation]
+        seeds = [0, 1, 2, 3, 4, 5, 6, 7]
+        rollouts_per_seed = 1
+        instances = 0
+        max_concurrent_rollouts = 4
+        thinking_mode = \"think\"
+        every_n_iters = 5
+
+        [hyperparams]
+        epsilon_low = 0.1
+        epsilon_high = 0.3
+        delta = 5.0
+        beta = 0.01
+        kl_penalty = 0.01
+        advantage_normalization = true
+        group_normalization = true
+        num_inner_steps = 1
+        clip_epsilon = 0.2
+        completion_only = false
+
+        [step_rewards]
+        enabled = false
+        mode = \"off\"
+        step_beta = 0.0
+        indicator_lambda = 0.0
+
+        [trainer]
+        allow_ref_fallback = false
+
+        [checkpoint]
+        interval = 10
+        directory = \"/checkpoints\"
+        keep_last_n = 3
+        save_optimizer = true
+        save_scheduler = true
+        enabled = true
+
+        [services]
+        task_url = \"{services_task_url}\"
+        """
+    ).strip() + "\n"
+
+    with open(destination, "w", encoding="utf-8") as fh:
+        fh.write(template)
+    print(f"Wrote config to {destination}")
+    return destination
+
+
+def _select_or_create_config(explicit: str | None, env: DemoEnv) -> str:
+    if explicit:
+        path = os.path.abspath(explicit)
+        if not os.path.isfile(path):
+            raise FileNotFoundError(f"Config not found: {path}")
+        return path
+
+    search_root = Path(os.getcwd())
+    discovered = _find_vllm_tomls(search_root)
+
+    extras: list[Path] = []
+    packaged = Path(os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "demo_task_apps", "math", "config.toml")))
+    extras.append(packaged)
+    home_cfg = Path(os.path.expanduser("~/.synth-ai/demo_config.toml"))
+    extras.append(home_cfg)
+
+    all_paths: list[Path] = []
+    seen: set[str] = set()
+    for candidate in discovered + extras:
+        if candidate.is_file():
+            resolved = str(candidate.resolve())
+            if resolved not in seen:
+                seen.add(resolved)
+                all_paths.append(candidate)
+
+    if not all_paths:
+        print("No existing RL TOML configs with [vllm] found; creating a new one.")
+        return _create_new_config(env)
+
+    print("Select a TOML config (found [vllm] section):")
+    for idx, path in enumerate(all_paths, 1):
+        rel = os.path.relpath(str(path), os.getcwd())
+        print(f"  [{idx}] {rel}")
+    create_idx = len(all_paths) + 1
+    print(f"  [{create_idx}] Create new config")
+    try:
+        sel = input(f"Enter choice [1-{create_idx}] (default 1): ").strip() or "1"
+    except Exception:
+        sel = "1"
+    try:
+        choice = int(sel)
+    except Exception:
+        choice = 1
+    if choice == create_idx:
+        return _create_new_config(env)
+    choice = max(1, min(choice, len(all_paths)))
+    selected = os.path.abspath(all_paths[choice - 1])
+    print(f"Using config: {selected}")
+    return selected
+
+
+def _ensure_task_app_ready(env: DemoEnv, synth_key: str, *, label: str) -> DemoEnv:
+    cwd_env_path = os.path.join(os.getcwd(), ".env")
+    local_env = demo_core.load_dotenv_file(cwd_env_path)
+
+    env_key = (env.env_api_key or "").strip()
+    if not env_key:
+        raise RuntimeError(f"[{label}] ENVIRONMENT_API_KEY missing. Run `uvx synth-ai rl_demo deploy` first.")
+
+    task_url = env.task_app_base_url
+    if not task_url or not _is_modal_public_url(task_url):
+        resolved = ""
+        if env.task_app_name:
+            try:
+                choice = input(
+                    f"Resolve URL from Modal for app '{env.task_app_name}'? [Y/n]: "
+                ).strip().lower() or "y"
+            except Exception:
+                choice = "y"
+            if choice.startswith("y"):
+                code, out = _popen_capture([
+                    "uv",
+                    "run",
+                    "python",
+                    "-m",
+                    "modal",
+                    "app",
+                    "url",
+                    env.task_app_name,
+                ])
+                if code == 0 and out:
+                    for tok in out.split():
+                        if _is_modal_public_url(tok):
+                            resolved = tok.strip().rstrip("/")
+                            break
+        if not resolved:
+            print(f"[{label}] Task app URL not configured or not a valid Modal public URL.")
+            print("Examples: https://<app-name>-fastapi-app.modal.run")
+            entered = input("Enter Task App base URL (must contain '.modal.run'), or press Enter to abort: ").strip()
+            if not entered or not _is_modal_public_url(entered):
+                raise RuntimeError(f"[{label}] Valid Task App URL is required.")
+            task_url = entered.rstrip("/")
+        else:
+            task_url = resolved
+        demo_core.persist_task_url(task_url, name=(env.task_app_name or None))
+
+    app_name = env.task_app_name.strip()
+    if not app_name:
+        fallback = input("Enter Modal app name for the task app (required): ").strip()
+        if not fallback:
+            raise RuntimeError(f"[{label}] Task app name is required.")
+        app_name = fallback
+        demo_core.persist_task_url(task_url, name=app_name)
+
+    secret_name = env.task_app_secret_name.strip() or f"{app_name}-secret"
+    demo_core.persist_task_url(task_url, name=app_name)
+    demo_core.persist_dotenv_values({
+        "TASK_APP_BASE_URL": task_url,
+        "TASK_APP_NAME": app_name,
+        "TASK_APP_SECRET_NAME": secret_name,
+    })
+
+    openai_key = (os.environ.get("OPENAI_API_KEY") or local_env.get("OPENAI_API_KEY") or "").strip()
+    secret_values: dict[str, str] = {"ENVIRONMENT_API_KEY": env_key}
+    if openai_key:
+        secret_values["OPENAI_API_KEY"] = openai_key
+    if synth_key:
+        secret_values["SYNTH_API_KEY"] = synth_key
+
+    _ensure_modal_secret(secret_name, values=secret_values, label=label, replace=True)
+
+    rollout_url = task_url.rstrip("/") + "/health/rollout"
+    print(f"[{label}] Verifying rollout health:")
+    try:
+        ek = (env_key or "").strip()
+        ek_len = len(ek)
+        ek_tail = ek[-5:] if ek_len >= 5 else ek
+        print(f"[{label}] Using ENVIRONMENT_API_KEY len={ek_len} last5={ek_tail}")
+    except Exception:
+        pass
+    health_base = task_url.rstrip("/")
+    health_urls = [f"{health_base}/health/rollout", f"{health_base}/health"]
+    rc = 0
+    body: Any = ""
+    for h in health_urls:
+        print(f"[{label}] GET", h)
+        rc, body = _http("GET", h, headers={"X-API-Key": env_key})
+        if rc == 200:
+            rollout_url = h
+            break
+    print(f"[{label}] status: {rc}")
+    try:
+        import json as _json
+
+        preview = _json.dumps(body)[:800] if isinstance(body, dict) else str(body)[:800]
+    except Exception:
+        preview = str(body)[:800]
+    print(f"[{label}] body:", preview)
+    if rc != 200:
+        print(f"[{label}] Warning: rollout health check failed ({rc}). Response: {body}")
+    else:
+        print(f"[{label}] Task app rollout health check OK.")
+
+    os.environ["TASK_APP_BASE_URL"] = task_url
+    os.environ["ENVIRONMENT_API_KEY"] = env_key
+    updated_env = demo_core.load_env()
+    updated_env.env_api_key = env_key
+    updated_env.task_app_base_url = task_url
+    updated_env.task_app_name = app_name
+    updated_env.task_app_secret_name = secret_name
+    return updated_env
+
+
 def cmd_deploy(args: argparse.Namespace) -> int:
     env = demo_core.load_env()
     cwd_env_path = os.path.join(os.getcwd(), ".env")
@@ -293,10 +718,10 @@ def cmd_deploy(args: argparse.Namespace) -> int:
                     break
                 time.sleep(1)
         else:
-            # Auto-detect app path if not supplied; prompt for name and confirmation.
+            # Auto-detect app path if not supplied; prompt interactively from discovered ASGI apps
             app_path = os.path.abspath(args.app) if args.app else None
             if not app_path or not os.path.isfile(app_path):
-                # Prefer the synth_demo/ app seeded by `rl_demo init` over any root-level files
+                # First pass: look for known common filenames
                 candidates = [
                     os.path.abspath(os.path.join(os.getcwd(), "synth_demo", "task_app.py")),
                     os.path.abspath(os.path.join(os.getcwd(), "task_app.py")),
@@ -304,6 +729,24 @@ def cmd_deploy(args: argparse.Namespace) -> int:
                     os.path.abspath(os.path.join(os.getcwd(), "math_task_app.py")),
                 ]
                 app_path = next((p for p in candidates if os.path.isfile(p)), None)
+                # If still not found, scan for any file containing @asgi_app()
+                if not app_path:
+                    found = _find_asgi_apps(Path(os.getcwd()))
+                    if found:
+                        print("Select a Modal ASGI app to deploy:")
+                        for idx, pth in enumerate(found, 1):
+                            rel = os.path.relpath(str(pth), os.getcwd())
+                            print(f"  [{idx}] {rel}")
+                        try:
+                            sel = input(f"Enter choice [1-{len(found)}] (default 1): ").strip() or "1"
+                        except Exception:
+                            sel = "1"
+                        try:
+                            choice = int(sel)
+                        except Exception:
+                            choice = 1
+                        choice = max(1, min(choice, len(found)))
+                        app_path = str(found[choice - 1].resolve())
             if not app_path and args.script:
                 # Legacy script fallback if user supplied --script explicitly
                 from synth_ai.demos.demo_task_apps.math.deploy_modal import deploy as modal_deploy
@@ -320,7 +763,10 @@ def cmd_deploy(args: argparse.Namespace) -> int:
                     raise FileNotFoundError(f"App file not found: {app_path}")
                 # Surface the app path before asking for the name
                 print(f"Using task app: {app_path}")
-                suggested_name = args.name or f"synth-{os.path.splitext(os.path.basename(app_path))[0]}"
+                existing_name = (args.name or env.task_app_name or "").strip()
+                if not existing_name:
+                    existing_name = f"synth-{os.path.splitext(os.path.basename(app_path))[0]}"
+                suggested_name = existing_name
                 name_in = input(f"Modal app name [{suggested_name}]: ").strip() or suggested_name
                 app_name = name_in
                 print("\nAbout to deploy with:")
@@ -331,8 +777,23 @@ def cmd_deploy(args: argparse.Namespace) -> int:
                     print("Aborted by user.")
                     return 1
 
-                secret_name = (env.task_app_secret_name or "").strip() or f"{name_in}-secret"
-                env_key = (env.env_api_key or "").strip() or None
+                prev_secret = (env.task_app_secret_name or "").strip()
+                default_secret = f"{name_in}-secret"
+                secret_name = default_secret if not prev_secret else prev_secret
+                if prev_secret and prev_secret != default_secret:
+                    secret_name = default_secret
+                existing_env_key = (env.env_api_key or "").strip()
+                env_key: str | None = existing_env_key or None
+                if existing_env_key:
+                    try:
+                        reuse_choice = input(
+                            "Use existing ENVIRONMENT_API_KEY from state/.env? [Y/n]: "
+                        ).strip().lower() or "y"
+                    except Exception:
+                        reuse_choice = "y"
+                    if not reuse_choice.startswith("y"):
+                        env_key = None
+
                 if env_key is None:
                     from synth_ai.rl.secrets import mint_environment_api_key
 
@@ -343,6 +804,33 @@ def cmd_deploy(args: argparse.Namespace) -> int:
                     env.env_api_key = env_key
                     local_env["ENVIRONMENT_API_KEY"] = env_key
                     print("[deploy] Minted new ENVIRONMENT_API_KEY")
+                
+                # Optionally upload the new key to the backend using sealed box helper
+                backend_base = (env.dev_backend_url or "").rstrip("/")
+                synth_key = (env.synth_api_key or os.environ.get("SYNTH_API_KEY") or local_env.get("SYNTH_API_KEY") or "").strip()
+                if backend_base and synth_key:
+                        # Pass a base WITHOUT trailing /api to setup_environment_api_key,
+                        # since it appends /api/v1/... internally.
+                        non_api_base = backend_base[:-4] if backend_base.endswith("/api") else backend_base
+                        try:
+                            choice = input(
+                                f"Upload ENVIRONMENT_API_KEY to backend {non_api_base}? [Y/n]: "
+                            ).strip().lower() or "y"
+                        except Exception:
+                            choice = "y"
+                        if choice.startswith("y"):
+                            try:
+                                print(f"[deploy] Uploading ENVIRONMENT_API_KEY to {non_api_base} …")
+                                from synth_ai.rl.env_keys import setup_environment_api_key
+
+                                setup_environment_api_key(non_api_base, synth_key, token=env_key)
+                                print("[deploy] Backend sealed-box upload complete.")
+                            except Exception as upload_err:
+                                print(f"[deploy] Failed to upload ENVIRONMENT_API_KEY: {upload_err}")
+                                print(
+                                    "Hint: run `uvx python -c \"from synth_ai.rl.env_keys import setup_environment_api_key as s;"
+                                    " s('<backend>', '<synth_api_key>')\"` once the backend is reachable."
+                                )
 
                 synth_key = (env.synth_api_key or os.environ.get("SYNTH_API_KEY") or local_env.get("SYNTH_API_KEY") or "").strip()
                 if not synth_key:
@@ -356,7 +844,9 @@ def cmd_deploy(args: argparse.Namespace) -> int:
 
                 openai_key = (os.environ.get("OPENAI_API_KEY") or local_env.get("OPENAI_API_KEY") or "").strip()
                 if not openai_key:
-                    openai_key = input("Enter OPENAI_API_KEY for Modal secret (required): ").strip()
+                    openai_key = input(
+                        "Enter your OpenAI API key, found at https://platform.openai.com/api-keys\n> "
+                    ).strip()
                     if not openai_key:
                         print("OPENAI_API_KEY is required to create the Modal secret.")
                         return 1
@@ -434,197 +924,42 @@ def cmd_deploy(args: argparse.Namespace) -> int:
             print(f"  export TASK_APP_NAME={app_name}")
             print(f"  export TASK_APP_SECRET_NAME={app_name}-secret")
         print(f"Persisted to {dotenv_path}")
-        print("Next: uvx synth-ai rl_demo configure")
+        print("\nNext step:\n$ uvx synth-ai run")
         return 0
     except Exception as e:
         print(f"Deploy error: {e}")
         return 2
 
 
-def cmd_configure(args: argparse.Namespace) -> int:
+    print("`rl_demo configure` prepares environment and secrets; `synth-ai run` now handles launches.")
     env = demo_core.load_env()
-    cwd_env_path = os.path.join(os.getcwd(), ".env")
-    local_env = demo_core.load_dotenv_file(cwd_env_path)
-
-    synth_key = env.synth_api_key.strip()
+    synth_key = (env.synth_api_key or "").strip()
     if not synth_key:
-        synth_key = input("Enter SYNTH_API_KEY (required): ").strip()
-        if not synth_key:
+        entered = input("Enter SYNTH_API_KEY (required): ").strip()
+        if not entered:
             print("SYNTH_API_KEY is required.")
             return 1
-        demo_core.persist_api_key(synth_key)
-    demo_core.persist_dotenv_values({"SYNTH_API_KEY": synth_key})
-
-    env_key = env.env_api_key.strip()
-    if not env_key:
-        print("ENVIRONMENT_API_KEY missing; run `uvx synth-ai rl_demo deploy` to mint and store one.")
+        os.environ["SYNTH_API_KEY"] = entered
+        demo_core.persist_api_key(entered)
+        demo_core.persist_dotenv_values({"SYNTH_API_KEY": entered})
+    env = demo_core.load_env()
+    synth_key = (env.synth_api_key or "").strip()
+    if not env.dev_backend_url:
+        print("Backend URL missing. Set DEV_BACKEND_URL or BACKEND_OVERRIDE.")
         return 1
-
-    task_url = env.task_app_base_url
-    if not task_url or not _is_modal_public_url(task_url):
-        # If we have an app name, offer to resolve from Modal first
-        resolved = ""
-        if env.task_app_name:
-            try:
-                choice = input(f"Resolve URL from Modal for app '{env.task_app_name}'? [Y/n]: ").strip().lower() or "y"
-                if choice.startswith("y"):
-                    code, out = _popen_capture([
-                        "uv", "run", "python", "-m", "modal", "app", "url", env.task_app_name
-                    ])
-                    if code == 0 and out:
-                        for tok in out.split():
-                            if _is_modal_public_url(tok):
-                                resolved = tok.strip().rstrip("/")
-                                break
-            except Exception:
-                resolved = ""
-        if not resolved:
-            print("Task app URL not configured or not a valid Modal public URL.")
-            print("Examples: https://<app-name>-fastapi-app.modal.run")
-            entered = input("Enter Task App base URL (must contain '.modal.run'), or press Enter to abort: ").strip()
-            if not entered or not _is_modal_public_url(entered):
-                print("Valid Task App URL is required. Run: uvx synth-ai rl_demo deploy")
-                return 1
-            task_url = entered.rstrip("/")
-        else:
-            task_url = resolved
-        demo_core.persist_task_url(task_url, name=(env.task_app_name or None))
-
-    app_name = env.task_app_name.strip()
-    if not app_name:
-        fallback = input("Enter Modal app name for the task app (required): ").strip()
-        if not fallback:
-            print("Task app name is required to configure Modal secrets.")
-            return 1
-        app_name = fallback
-        demo_core.persist_task_url(task_url, name=app_name)
-
-    secret_name = env.task_app_secret_name.strip() or f"{app_name}-secret"
-    demo_core.persist_task_url(task_url, name=app_name)
-    demo_core.persist_dotenv_values({
-        "TASK_APP_BASE_URL": task_url,
-        "TASK_APP_NAME": app_name,
-        "TASK_APP_SECRET_NAME": secret_name,
-    })
-
-    # Ensure Modal secret has the environment API key (and optional extras).
-    openai_key = (os.environ.get("OPENAI_API_KEY") or local_env.get("OPENAI_API_KEY") or "").strip()
-    synth_for_secret = synth_key
-
-    secret_values: dict[str, str] = {"ENVIRONMENT_API_KEY": env_key}
-    if openai_key:
-        secret_values["OPENAI_API_KEY"] = openai_key
-    if synth_for_secret:
-        secret_values["SYNTH_API_KEY"] = synth_for_secret
-
     try:
-        _ensure_modal_secret(secret_name, values=secret_values, label="configure", replace=True)
-    except RuntimeError as err:
-        print(f"[configure] Failed to provision Modal secret: {err}")
-        return 2
-
-    # Verify task app can read the secret by hitting rollout health with X-API-Key.
-    rollout_url = task_url.rstrip("/") + "/health/rollout"
-    print("[configure] Verifying rollout health:")
-    # Prefer rollout-specific health first (auth-aware), then plain /health
-    health_base = task_url.rstrip("/")
-    health_urls = [f"{health_base}/health/rollout", f"{health_base}/health"]
-    rc = 0
-    body = ""
-    for h in health_urls:
-        print("[configure] GET", h)
-        rc, body = _http("GET", h, headers={"X-API-Key": env_key})
-        if rc == 200:
-            rollout_url = h
-            break
-    print("[configure] status:", rc)
+        env = _ensure_task_app_ready(env, synth_key, label="configure")
+    except RuntimeError as exc:
+        print(exc)
+        return 1
+    os.environ["ENVIRONMENT_API_KEY"] = env.env_api_key
     try:
-        import json as _json
-        preview = _json.dumps(body)[:800] if isinstance(body, dict) else str(body)[:800]
+        review = input("Review or create an RL config now? [Y/n]: ").strip().lower() or "y"
     except Exception:
-        preview = str(body)[:800]
-    print("[configure] body:", preview)
-    if rc != 200:
-        print(f"Warning: rollout health check failed ({rc}). Response: {body}")
-    else:
-        print("Task app rollout health check OK.")
-
-    env.synth_api_key = synth_key
-    env.env_api_key = env_key
-    env.task_app_name = app_name
-    env.task_app_secret_name = secret_name
-
-    # Prefer the seeded CWD config if present; otherwise fall back to packaged default
-    seeded_cfg = os.path.abspath(os.path.join(os.getcwd(), "demo_config.toml"))
-    if os.path.isfile(seeded_cfg):
-        base_path = seeded_cfg
-    else:
-        defaults = [
-            os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "demo_task_apps", "math", "config.toml")),
-        ]
-        mono = "/Users/joshpurtell/Documents/GitHub/monorepo/tests/applications/math/rl/math_online.toml"
-        if os.path.isfile(mono):
-            defaults.append(mono)
-        print("Select a baseline TOML:")
-        for i, p in enumerate(defaults, 1):
-            print(f"  [{i}] {p}")
-        choice = input(f"Enter choice [1-{len(defaults)}] (default 1): ").strip() or "1"
-        try:
-            idx = max(1, min(int(choice), len(defaults))) - 1
-        except Exception:
-            idx = 0
-        base_path = defaults[idx]
-    with open(base_path, "r") as fh:
-        text = fh.read()
-    import re
-    # Extract current defaults from the selected TOML
-    def _extract(pattern: str, default: str) -> str:
-        m = re.search(pattern, text, flags=re.M)
-        if not m:
-            return default
-        val = (m.group(1) or "").strip()
-        return val if val else default
-    current_gpu_type = _extract(r"^gpu_type\s*=\s*\"([^\"]+)\"$", "A100")
-    # topology form gpu_type = "TYPE:COUNT" also supported for deriving defaults
-    topo_gpu = _extract(r"^gpu_type\s*=\s*\"([^\":]+):(\d+)\"$", current_gpu_type)
-    if ":" in topo_gpu:
-        current_gpu_type = topo_gpu.split(":", 1)[0]
-    current_gpu_count = _extract(r"^gpu_count\s*=\s*(\d+)$", "4")
-    if ":" in topo_gpu:
-        current_gpu_count = topo_gpu.split(":", 1)[1]
-    current_model = _extract(r"^name\s*=\s*\"([^\"]+)\"$", "Qwen/Qwen3-0.6B")
-    current_tp = _extract(r"^tensor_parallel_size\s*=\s*(\d+)$", "2")
-
-    # Prompts with defaults shown; Enter keeps current
-    def _prompt(label: str, default_val: str) -> str:
-        entered = input(f"{label} [{default_val}]: ").strip()
-        return entered or default_val
-
-    gpu_type = _prompt("GPU type", current_gpu_type)
-    gpu_count = _prompt("GPU count", current_gpu_count)
-    model = _prompt("Model", current_model)
-    tp = _prompt("Tensor parallel", current_tp)
-
-    text = re.sub(r"(?m)^gpu_type\s*=\s*\".*?\"$", f"gpu_type = \"{gpu_type}\"", text)
-    text = re.sub(r"(?m)^gpu_count\s*=\s*\d+$", f"gpu_count = {int(gpu_count)}", text)
-    text = re.sub(r"(?m)^name\s*=\s*\".*?\"$", f"name = \"{model}\"", text)
-    text = re.sub(r"(?m)^tensor_parallel_size\s*=\s*\d+$", f"tensor_parallel_size = {int(tp)}", text)
-    text = re.sub(r"(?m)^gpu_type\s*=\s*\".*?:\d+\"$", f"gpu_type = \"{gpu_type}:{int(gpu_count)}\"", text)
-    out_path = os.path.abspath(os.path.join(os.getcwd(), "demo_config.toml"))
-    _write_text(out_path, text)
-    print(f"Prepared config at: {out_path}")
-    here_cfg = os.path.abspath(out_path)
-    print("Config path:", here_cfg)
-    print("Environment (masked):")
-    print(json.dumps({
-        "DEV_BACKEND_URL": env.dev_backend_url,
-        "SYNTH_API_KEY": (synth_key[:6] + "…") if synth_key else "",
-        "ENVIRONMENT_API_KEY": (env_key[:6] + "…") if env_key else "",
-        "TASK_APP_BASE_URL": task_url,
-        "TASK_APP_NAME": app_name,
-        "TASK_APP_SECRET_NAME": secret_name,
-    }, indent=2))
-    print("Next: uvx synth-ai rl_demo run")
+        review = "y"
+    if review.startswith("y"):
+        _select_or_create_config(None, env)
+    print("Environment ready. Use `uvx synth-ai run` to launch an RL job.")
     return 0
 
 
@@ -685,7 +1020,7 @@ def cmd_init(args: argparse.Namespace) -> int:
         shutil.copy2(src_modal, dst_task_py)
 
         # Create deploy script in synth_demo/
-        deploy_text = """#!/usr/bin/env bash
+        deploy_text = r"""#!/usr/bin/env bash
 set -euo pipefail
 
 HERE=$(cd "$(dirname "$0")" && pwd)
@@ -742,11 +1077,7 @@ fi
         if os.path.exists(dst_cfg):
             print(f"  - {dst_cfg} (seeded)")
         print("")
-        print("Next steps:")
-        print("  1) cd synth_demo && put your ENVIRONMENT_API_KEY in ./.env")
-        print("  2) Deploy to Modal:")
-        print("     uvx bash ./deploy_task_app.sh")
-        print("  3) From project root, run: uvx synth-ai rl_demo configure; uvx synth-ai rl_demo run")
+        print("\nNext step:\n$ uvx synth-ai setup")
         return 0
     except Exception as e:
         print(f"Init error: {e}")
@@ -754,13 +1085,18 @@ fi
 
 
 def _http(method: str, url: str, headers: Dict[str, str] | None = None, body: Dict[str, Any] | None = None) -> tuple[int, Dict[str, Any] | str]:
-    import urllib.request, urllib.error, json as _json
+    import urllib.request, urllib.error, json as _json, ssl
     data = None
     if body is not None:
         data = _json.dumps(body).encode("utf-8")
     req = urllib.request.Request(url, method=method, headers=headers or {}, data=data)
     try:
-        with urllib.request.urlopen(req, timeout=60) as resp:
+        # Default: disable SSL verification for local/dev convenience.
+        # Set SYNTH_SSL_VERIFY=1 to enable verification.
+        ctx = ssl._create_unverified_context()  # nosec: disabled by default for dev
+        if os.getenv("SYNTH_SSL_VERIFY", "0") == "1":
+            ctx = None
+        with urllib.request.urlopen(req, timeout=60, context=ctx) as resp:
             code = getattr(resp, "status", 200)
             txt = resp.read().decode("utf-8", errors="ignore")
             try:
@@ -788,8 +1124,11 @@ def _write_text(path: str, content: str) -> None:
 
 def cmd_run(args: argparse.Namespace) -> int:
     env = demo_core.load_env()
-    # Prompt for missing SYNTH_API_KEY
-    if not env.synth_api_key:
+    cwd_env_path = os.path.join(os.getcwd(), ".env")
+    local_env = demo_core.load_dotenv_file(cwd_env_path)
+
+    synth_key = (env.synth_api_key or "").strip()
+    if not synth_key:
         entered = input("Enter SYNTH_API_KEY (required): ").strip()
         if not entered:
             print("SYNTH_API_KEY is required.")
@@ -797,19 +1136,32 @@ def cmd_run(args: argparse.Namespace) -> int:
         os.environ["SYNTH_API_KEY"] = entered
         demo_core.persist_api_key(entered)
         demo_core.persist_dotenv_values({"SYNTH_API_KEY": entered})
-    # Re-resolve env after potential persist
     env = demo_core.load_env()
-    if not env.task_app_base_url:
-        print("Task app URL missing. Run: uvx synth-ai rl_demo deploy")
+    synth_key = (env.synth_api_key or "").strip()
+    if not synth_key:
+        print("SYNTH_API_KEY missing after persist.")
         return 1
+
     if not env.dev_backend_url:
-        print("Backend URL missing. Set DEV_BACKEND_URL in a .env or rely on default prod.")
+        print("Backend URL missing. Set DEV_BACKEND_URL or BACKEND_OVERRIDE.")
         return 1
-    if not env.env_api_key:
-        print("ENVIRONMENT_API_KEY missing. Run: uvx synth-ai rl_demo configure")
+
+    try:
+        env = _ensure_task_app_ready(env, synth_key, label="run")
+    except RuntimeError as exc:
+        print(exc)
         return 1
+
     os.environ["ENVIRONMENT_API_KEY"] = env.env_api_key
 
+    import tomllib
+
+    try:
+        cfg_path = _select_or_create_config(getattr(args, "config", None), env)
+    except FileNotFoundError as exc:
+        print(exc)
+        return 1
+
     # Detect monorepo launcher and delegate if available (aligns with run_clustered.sh which works)
     launcher = "/Users/joshpurtell/Documents/GitHub/monorepo/tests/applications/math/rl/start_math_clustered.py"
     if os.path.isfile(launcher):
@@ -819,6 +1171,7 @@ def cmd_run(args: argparse.Namespace) -> int:
         run_env["SYNTH_API_KEY"] = env.synth_api_key
         run_env["TASK_APP_BASE_URL"] = env.task_app_base_url
         run_env["ENVIRONMENT_API_KEY"] = env.env_api_key
+        run_env["RL_CONFIG_PATH"] = cfg_path
         # Optional: TRAINER_START_URL passthrough if already set in environment
         run_env["TRAINER_START_URL"] = run_env.get("TRAINER_START_URL", "")
         # Forward convenience knobs
@@ -849,46 +1202,6 @@ def cmd_run(args: argparse.Namespace) -> int:
         return code
 
     # Fallback: legacy jobs API flow
-    import tomllib
-    # Determine config path: --config overrides; otherwise prompt from detected candidates
-    cfg_path = None
-    if getattr(args, "config", None):
-        cfg_path = os.path.abspath(args.config)
-        if not os.path.isfile(cfg_path):
-            print(f"Config not found: {cfg_path}")
-            return 1
-    else:
-        candidates: list[str] = []
-        # Prepared in CWD and home
-        cwd_prepared = os.path.abspath(os.path.join(os.getcwd(), "demo_config.toml"))
-        home_prepared = os.path.expanduser("~/.synth-ai/demo_config.toml")
-        if os.path.isfile(cwd_prepared):
-            candidates.append(cwd_prepared)
-        if os.path.isfile(home_prepared):
-            candidates.append(home_prepared)
-        # Monorepo math_online.toml if present
-        mono = "/Users/joshpurtell/Documents/GitHub/monorepo/tests/applications/math/rl/math_online.toml"
-        if os.path.isfile(mono):
-            candidates.append(mono)
-        # Packaged default
-        packaged = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "demo_task_apps", "math", "config.toml"))
-        candidates.append(packaged)
-        # Deduplicate while preserving order
-        seen = set()
-        uniq: list[str] = []
-        for p in candidates:
-            if p not in seen:
-                seen.add(p)
-                uniq.append(p)
-        print("Choose a TOML config:")
-        for i, p in enumerate(uniq, 1):
-            print(f"  [{i}] {p}")
-        sel = input(f"Enter choice [1-{len(uniq)}] (default 1): ").strip() or "1"
-        try:
-            idx = max(1, min(int(sel), len(uniq))) - 1
-        except Exception:
-            idx = 0
-        cfg_path = uniq[idx]
     with open(cfg_path, "rb") as fh:
         inline_cfg = tomllib.load(fh)
     with open(cfg_path, "r") as fh2:
@@ -899,6 +1212,15 @@ def cmd_run(args: argparse.Namespace) -> int:
         inline_cfg.setdefault("training", {})["group_size"] = int(args.group_size)
     model_name = args.model or (inline_cfg.get("model", {}) or {}).get("name", "Qwen/Qwen3-0.6B")
     api = env.dev_backend_url.rstrip("/") + ("" if env.dev_backend_url.endswith("/api") else "/api")
+    # Print backend and key preview before request for clearer diagnostics
+    try:
+        sk = (env.synth_api_key or "").strip()
+        sk_len = len(sk)
+        sk_tail = sk[-5:] if sk_len >= 5 else sk
+        print(f"[run] Backend API: {api}")
+        print(f"[run] Using SYNTH_API_KEY len={sk_len} last5={sk_tail}")
+    except Exception:
+        pass
     data_fragment: Dict[str, Any] = {
         "model": model_name,
         "endpoint_base_url": env.task_app_base_url,
@@ -936,6 +1258,7 @@ def cmd_run(args: argparse.Namespace) -> int:
     }, body=body)
     if code not in (200, 201) or not isinstance(js, dict):
         print("Job create failed:", code)
+        print(f"Backend: {api}")
         try:
             if isinstance(js, dict):
                 print(json.dumps(js, indent=2))
@@ -962,7 +1285,14 @@ def cmd_run(args: argparse.Namespace) -> int:
         print("Request body was:\n" + json.dumps(body, indent=2))
         return 2
     print("JOB_ID:", job_id)
-    _http("POST", api + f"/rl/jobs/{job_id}/start", headers={"Authorization": f"Bearer {env.synth_api_key}"})
+    # Original behavior: start job and stream status/events until terminal
+    _http(
+        "POST",
+        api + f"/rl/jobs/{job_id}/start",
+        headers={"Authorization": f"Bearer {env.synth_api_key}"},
+    )
+    # Inform the user immediately that the job has started and where to track it
+    print("Your job is running. Visit usesynth.ai to view its progress")
     since = 0
     terminal = {"succeeded", "failed", "cancelled", "error", "completed"}
     last_status = ""
@@ -976,7 +1306,10 @@ def cmd_run(args: argparse.Namespace) -> int:
         if status and status.lower() in terminal:
             print("FINAL:", status)
             break
-        ec, ej = _http("GET", api + f"/orchestration/jobs/{job_id}/events?since_seq={since}&limit=200")
+        ec, ej = _http(
+            "GET",
+            api + f"/orchestration/jobs/{job_id}/events?since_seq={since}&limit=200",
+        )
         if ec == 200 and isinstance(ej, dict):
             events = ej.get("events") or ej.get("data") or []
             for e in events:
@@ -986,9 +1319,17 @@ def cmd_run(args: argparse.Namespace) -> int:
                 since = seq
                 typ = str(e.get("type") or e.get("event_type") or "").lower()
                 msg = e.get("message") or e.get("msg") or ""
-                if typ in ("rl.eval.started", "rl.eval.summary", "rl.train.step", "rl.metrics", "rl.performance.metrics"):
+                if typ in (
+                    "rl.eval.started",
+                    "rl.eval.summary",
+                    "rl.train.step",
+                    "rl.metrics",
+                    "rl.performance.metrics",
+                ):
                     print(f"[{seq}] {typ}: {msg}")
-        mc, mj = _http("GET", api + f"/learning/jobs/{job_id}/metrics?after_step=-1&limit=50")
+        mc, mj = _http(
+            "GET", api + f"/learning/jobs/{job_id}/metrics?after_step=-1&limit=50"
+        )
         if mc == 200 and isinstance(mj, dict):
             pts = mj.get("points") or []
             for p in pts:
@@ -1012,7 +1353,7 @@ def main(argv: list[str] | None = None) -> int:
             parser = sub.add_parser(name)
             configure(parser)
 
-    _add_parser(["rl_demo.check", "demo.check"], configure=lambda parser: parser.set_defaults(func=cmd_check))
+    _add_parser(["rl_demo.setup", "demo.setup"], configure=lambda parser: parser.set_defaults(func=cmd_setup))
 
     def _init_opts(parser):
         parser.add_argument("--force", action="store_true", help="Overwrite existing files in CWD")
@@ -1025,13 +1366,13 @@ def main(argv: list[str] | None = None) -> int:
     def _deploy_opts(parser):
         parser.add_argument("--local", action="store_true", help="Run local FastAPI instead of Modal deploy")
         parser.add_argument("--app", type=str, default=None, help="Path to Modal app.py for uv run modal deploy")
-        parser.add_argument("--name", type=str, default="synth-math-demo", help="Modal app name")
+        parser.add_argument("--name", type=str, default=None, help="Modal app name")
         parser.add_argument("--script", type=str, default=None, help="Path to deploy_task_app.sh (optional legacy)")
         parser.set_defaults(func=cmd_deploy)
 
     _add_parser(["rl_demo.deploy", "demo.deploy"], configure=_deploy_opts)
 
-    _add_parser(["rl_demo.configure", "demo.configure"], configure=lambda parser: parser.set_defaults(func=cmd_configure))
+    _add_parser(["rl_demo.configure", "demo.configure"], configure=lambda parser: parser.set_defaults(func=cmd_run))
 
     def _run_opts(parser):
         parser.add_argument("--config", type=str, default=None, help="Path to TOML config (skip prompt)")
@@ -1042,7 +1383,7 @@ def main(argv: list[str] | None = None) -> int:
         parser.add_argument("--dry-run", action="store_true", help="Print request body and exit")
         parser.set_defaults(func=cmd_run)
 
-    _add_parser(["rl_demo.run", "demo.run"], configure=_run_opts)
+    _add_parser(["run", "rl_demo.run", "demo.run"], configure=_run_opts)
 
     args = p.parse_args(argv)
     if not hasattr(args, "func"):