freesolo-flash-dev 0.2.33__tar.gz → 0.2.35__tar.gz

freesolo_flash_dev-0.2.35/.github/workflows/notify-tests-repo.yml

@@ -0,0 +1,35 @@
+name: Notify tests repo
+
+# Flash's cross-repo integration seams (flash<->backend auth, allocator, CLI flow)
+# live in the freesolo-co/tests repo, which carries flash as a pinned submodule.
+# On every push to dev/main, dispatch to that repo so its CI bumps the flash
+# submodule pin and runs the affected suites against the new sha. Mirrors the
+# freesolo-side notify-tests-repo.yml; the tests repo listens for `flash-merged`.
+
+on:
+  push:
+    branches: [dev, main]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  notify:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Dispatch to freesolo-co/tests
+        env:
+          PAT: ${{ secrets.FREESOLO_GITHUB_PAT }}
+          SHA: ${{ github.sha }}
+          REF: ${{ github.ref_name }}
+        run: |
+          if [ -z "$PAT" ]; then
+            echo "No FREESOLO_GITHUB_PAT (likely a fork) — skipping dispatch."
+            exit 0
+          fi
+          curl -fsS -X POST \
+            -H "Authorization: Bearer ${PAT}" \
+            -H "Accept: application/vnd.github+json" \
+            https://api.github.com/repos/freesolo-co/tests/dispatches \
+            -d "{\"event_type\":\"flash-merged\",\"client_payload\":{\"sha\":\"${SHA}\",\"ref\":\"${REF}\"}}"

{freesolo_flash_dev-0.2.33 → freesolo_flash_dev-0.2.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freesolo-flash-dev
-Version: 0.2.33
+Version: 0.2.35
 Summary: Flash — managed LoRA post-training (SFT/GRPO) for Freesolo environments, driven by the `flash` CLI
 Project-URL: Homepage, https://github.com/freesolo-co/flash
 Project-URL: Repository, https://github.com/freesolo-co/flash

{freesolo_flash_dev-0.2.33 → freesolo_flash_dev-0.2.35}/flash/catalog.py

@@ -38,6 +38,7 @@ class ServingCapacity:
     serve_model_id: str = ""
     max_num_seqs: int = 0
     max_num_batched_tokens: int = 0
+    tensor_parallel_size: int = 0
     gpu_memory_utilization: float = 0.0
 
 
@@ -104,6 +105,7 @@ class ModelInfo:
                 "serve_model_id",
                 "max_num_seqs",
                 "max_num_batched_tokens",
+                "tensor_parallel_size",
                 "gpu_memory_utilization",
             ):
                 if serving.get(key) in ("", 0, 0.0, None):
@@ -113,6 +115,15 @@ class ModelInfo:
 
 DEFAULT_MODEL = "Qwen/Qwen3.5-4B"
 
+SERVING_FP8_MODEL_REPOS: dict[str, str] = {
+    "openbmb/MiniCPM5-1B": "Freesolo-Co/MiniCPM5-1B-FP8",
+    "Qwen/Qwen3.5-0.8B": "Freesolo-Co/Qwen3.5-0.8B-FP8",
+    "Qwen/Qwen3.5-2B": "Freesolo-Co/Qwen3.5-2B-FP8",
+    "Qwen/Qwen3.5-4B": "Freesolo-Co/Qwen3.5-4B-FP8",
+    "Qwen/Qwen3.5-9B": "Freesolo-Co/Qwen3.5-9B-FP8",
+    "Qwen/Qwen3.6-35B-A3B": "Qwen/Qwen3.6-35B-A3B-FP8",
+}
+
 MODELS: dict[str, ModelInfo] = {
     "openbmb/MiniCPM5-1B": ModelInfo(
         id="openbmb/MiniCPM5-1B",
@@ -123,7 +134,13 @@ MODELS: dict[str, ModelInfo] = {
         algos=("sft", "grpo"),
         min_vram_gb=12,
         recommended_gpu="RTX 4090",
-        serving=ServingCapacity(gpu="L4", max_loras=16, max_lora_rank=64, max_model_len=32768),
+        serving=ServingCapacity(
+            gpu="L4",
+            serve_model_id=SERVING_FP8_MODEL_REPOS["openbmb/MiniCPM5-1B"],
+            max_loras=16,
+            max_lora_rank=128,
+            max_model_len=32768,
+        ),
         thinking="hybrid",
         notes="On-device class SLM (131k ctx); standard Llama architecture.",
     ),
@@ -136,7 +153,13 @@ MODELS: dict[str, ModelInfo] = {
         algos=("sft", "grpo"),
         min_vram_gb=12,
         recommended_gpu="RTX 4090",
-        serving=ServingCapacity(gpu="L4", max_loras=16, max_lora_rank=64, max_model_len=32768),
+        serving=ServingCapacity(
+            gpu="L4",
+            serve_model_id=SERVING_FP8_MODEL_REPOS["Qwen/Qwen3.5-0.8B"],
+            max_loras=16,
+            max_lora_rank=128,
+            max_model_len=32768,
+        ),
         thinking="hybrid",
         notes="Smallest Qwen3.5; cheap smoke/dev runs with the modern arch.",
     ),
@@ -149,7 +172,13 @@ MODELS: dict[str, ModelInfo] = {
         algos=("sft", "grpo"),
         min_vram_gb=16,
         recommended_gpu="RTX 4090",
-        serving=ServingCapacity(gpu="L4", max_loras=16, max_lora_rank=64, max_model_len=32768),
+        serving=ServingCapacity(
+            gpu="L4",
+            serve_model_id=SERVING_FP8_MODEL_REPOS["Qwen/Qwen3.5-2B"],
+            max_loras=16,
+            max_lora_rank=128,
+            max_model_len=32768,
+        ),
         thinking="hybrid",
     ),
     "Qwen/Qwen3.5-4B": ModelInfo(
@@ -162,10 +191,10 @@ MODELS: dict[str, ModelInfo] = {
         min_vram_gb=32,
         recommended_gpu="RTX 5090",
         serving=ServingCapacity(
-            gpu="L4",
-            serve_model_id="lovedheart/Qwen3.5-4B-FP8",
+            gpu="L40S",
+            serve_model_id=SERVING_FP8_MODEL_REPOS["Qwen/Qwen3.5-4B"],
             max_loras=64,
-            max_lora_rank=32,
+            max_lora_rank=64,
             max_model_len=8192,
             max_num_seqs=8,
             gpu_memory_utilization=0.98,
@@ -187,10 +216,10 @@ MODELS: dict[str, ModelInfo] = {
         quant="bf16",
         recommended_gpu="A100 PCIe",
         serving=ServingCapacity(
-            gpu="L4",
-            serve_model_id="lovedheart/Qwen3.5-9B-FP8",
+            gpu="L40S",
+            serve_model_id=SERVING_FP8_MODEL_REPOS["Qwen/Qwen3.5-9B"],
             max_loras=44,
-            max_lora_rank=32,
+            max_lora_rank=64,
             max_model_len=8192,
             max_num_seqs=8,
             gpu_memory_utilization=0.98,
@@ -225,13 +254,14 @@ MODELS: dict[str, ModelInfo] = {
         quant="bf16",
         recommended_gpu="H200",
         serving=ServingCapacity(
-            gpu="A100-80GB",
-            serve_model_id="Qwen/Qwen3.6-35B-A3B-FP8",
+            gpu="A100-80GB:2",
+            serve_model_id=SERVING_FP8_MODEL_REPOS["Qwen/Qwen3.6-35B-A3B"],
             max_loras=12,
-            max_lora_rank=32,
+            max_lora_rank=64,
             max_model_len=8192,
             max_num_seqs=8,
             max_num_batched_tokens=4096,
+            tensor_parallel_size=2,
             gpu_memory_utilization=0.98,
         ),
         thinking="hybrid",
@@ -262,8 +292,8 @@ def get_model(model_id: str) -> ModelInfo:
 def serving_lora_rank_cap(model: str | ModelInfo | None) -> int | None:
     """Return the model's serving LoRA rank cap, or None when Flash has no local cap.
 
-    Serving capacity is model-specific: small serving models currently allow rank 64, while larger
-    serving paths can cap at rank 32. Unknown/open-policy models intentionally return None instead
+    Serving capacity is model-specific: small serving models currently allow rank 128, while larger
+    serving paths currently allow rank 64. Unknown/open-policy models intentionally return None instead
     of inheriting a global fallback.
     """
     if isinstance(model, ModelInfo):

{freesolo_flash_dev-0.2.33 → freesolo_flash_dev-0.2.35}/flash/cli/__init__.py

@@ -35,6 +35,7 @@ from flash.cli.commands import (  # noqa: F401
     cmd_env_setup,
     cmd_export,
     cmd_gpus,
+    cmd_log,
     cmd_login,
     cmd_models,
     cmd_runs,
@@ -83,7 +84,8 @@ _HELP_GROUPS: list[tuple[str, list[tuple[str, str]]]] = [
         "training",
         [
             ("train", "submit a managed run from a TOML config"),
-            ("status", "show a run's status, logs, or live follow"),
+            ("status", "show a run's current status"),
+            ("log", "print or follow a run's logs"),
             ("runs", "list runs with their state and cost"),
             ("checkpoints", "list a run's deployable RL checkpoints"),
             ("cancel", "cancel a running job"),
@@ -309,21 +311,28 @@ def _build_parser() -> argparse.ArgumentParser:
     )
     train.set_defaults(func=cmd_train)
 
-    status = sub.add_parser("status", help="show a run's status, logs, or follow logs")
+    status = sub.add_parser("status", help="show a run's current status")
     status.add_argument("run_id")
     status.add_argument(
-        "--logs",
+        "-f",
+        "--follow",
         action="store_true",
-        help="print current logs before status — the orchestrator log plus the train-subprocess "
-        "stdout + traceback (console_/error_<phase>.txt) fetched from the run's HF artifact repo",
+        help="poll status until the run ends without replaying logs",
     )
-    status.add_argument(
+    status.set_defaults(func=cmd_status)
+
+    log = sub.add_parser(
+        "log",
+        help="print a run's full logs, including worker console/error artifacts",
+    )
+    log.add_argument("run_id")
+    log.add_argument(
         "-f",
         "--follow",
         action="store_true",
-        help="stream logs until the run ends, then print final status",
+        help="stream logs until the run reaches a terminal state",
     )
-    status.set_defaults(func=cmd_status)
+    log.set_defaults(func=cmd_log)
 
     runs = sub.add_parser("runs", help="list runs and their state/cost")
     runs.set_defaults(func=cmd_runs)
@@ -339,14 +348,17 @@ def _build_parser() -> argparse.ArgumentParser:
     checkpoints.set_defaults(func=cmd_checkpoints)
 
     deploy = sub.add_parser("deploy", help="deploy a run's adapter to a serving endpoint")
-    deploy.add_argument("run_id")
+    deploy.add_argument(
+        "run_id",
+        metavar="RUN_ID[/step-N]",
+        help="run id for the final adapter, or RUN_ID/step-N for a saved checkpoint",
+    )
     deploy.add_argument("--dry-run", action="store_true")
     deploy.add_argument(
-        "--step",
-        type=int,
-        default=None,
-        help="deploy a specific intermediate checkpoint (see `flash checkpoints <run_id>`) "
-        "instead of the run's final adapter; works even for a run cancelled mid-RL",
+        "--no-verify",
+        action="store_true",
+        help="skip the server-side post-deploy smoke generation (registration alone does NOT "
+        "guarantee the adapter serves; only ready deployments should be scored by evals)",
     )
     deploy.set_defaults(func=cmd_deploy)
 
@@ -359,7 +371,8 @@ def _build_parser() -> argparse.ArgumentParser:
         "--adapter-id",
         dest="adapter_id",
         required=True,
-        help="the Freesolo adapter id (the run id) to export",
+        metavar="RUN_ID[/step-N]",
+        help="run id for the final adapter, or RUN_ID/step-N for a saved checkpoint",
     )
     export.add_argument(
         "--repository",
@@ -371,13 +384,6 @@ def _build_parser() -> argparse.ArgumentParser:
         help="HuggingFace token with write access to --repository "
         "(default: HF_TOKEN from your shell or a local .env / .env.local)",
     )
-    export.add_argument(
-        "--step",
-        type=int,
-        default=None,
-        help="export a specific intermediate checkpoint (see `flash checkpoints <adapter-id>`) "
-        "instead of the run's final adapter; works even for a run cancelled mid-RL",
-    )
     export.add_argument(
         "--public",
         action="store_true",
@@ -391,6 +397,12 @@ def _build_parser() -> argparse.ArgumentParser:
     chat = sub.add_parser("chat", help="chat with a deployed adapter")
     chat.add_argument("run_id")
     chat.add_argument("-m", "--message", required=True)
+    chat.add_argument(
+        "--system",
+        default=None,
+        help="optional system prompt sent ahead of the user message "
+        "(training-prompt parity for evals)",
+    )
     chat.add_argument("--max-tokens", type=int, default=512)
     chat.add_argument("--temperature", type=float, default=0.0)
     chat.set_defaults(func=cmd_chat)

{freesolo_flash_dev-0.2.33 → freesolo_flash_dev-0.2.35}/flash/cli/commands.py

@@ -401,15 +401,18 @@ def cmd_train(args) -> int:
     else:
         print(
             f"run {run_id} submitted; following logs "
-            f"(Ctrl-C detaches, `flash status {run_id} --follow` resumes)",
+            f"(Ctrl-C detaches, `flash log {run_id} --follow` resumes)",
             file=sys.stderr,
         )
     return _follow_run(client, run_id)
 
 
-def _poll_logs(client: ApiClient, run_id: str, interval: float) -> str:
-    """Stream offset-paged logs until the run reaches a terminal state; return that state."""
+def _poll_logs(client: ApiClient, run_id: str, interval: float) -> tuple[str, bool]:
+    """Stream offset-paged logs until the run reaches a terminal state.
+
+    Returns (terminal state, whether any log bytes were printed)."""
     offset = 0
+    printed_any = False
     spinner = _LogFollowSpinner(run_id)
     try:
         while True:
@@ -417,53 +420,75 @@ def _poll_logs(client: ApiClient, run_id: str, interval: float) -> str:
             if page["logs"]:
                 spinner.clear()
                 print(page["logs"], end="", flush=True)
+                printed_any = True
             offset = page["offset"]
             if page["state"] in _CLI_DONE_STATES:
                 spinner.clear()
-                return page["state"]
+                return page["state"], printed_any
             _sleep_with_spinner(interval, spinner, page["state"])
     finally:
         spinner.clear()
 
 
+def _render_status(status: dict) -> str:
+    """One rendering of a run status: themed panel on a TTY, indented JSON on the machine path."""
+    return render.run_status(status) if render.styled() else json.dumps(status, indent=2)
+
+
 def _follow_run(client: ApiClient, run_id: str) -> int:
     """Poll logs until the run reaches a terminal state, then print the final status."""
-    state = _poll_logs(client, run_id, interval=2.0)
-    status = client.get_run(run_id)
-    if render.styled():
-        print(render.run_status(status))
-    else:
-        print(json.dumps(status, indent=2))
+    state, _ = _poll_logs(client, run_id, interval=2.0)
+    print(_render_status(client.get_run(run_id)))
     return 0 if state in _OK_STATES else 1
 
 
+def _follow_status(client: ApiClient, run_id: str, interval: float = 2.0) -> int:
+    """Poll run status until terminal, without replaying worker logs."""
+    last_rendered: str | None = None
+    while True:
+        status = client.get_run(run_id)
+        rendered = _render_status(status)
+        if rendered != last_rendered:
+            print(rendered)
+            last_rendered = rendered
+        state = str(status.get("state") or "")
+        if state in _CLI_DONE_STATES:
+            return 0 if state in _OK_STATES else 1
+        time.sleep(interval)
+
+
+def _print_worker_output(client: ApiClient, run_id: str, *, printed_any: bool = False) -> bool:
+    for name, text in (client.get_worker_output(run_id) or {}).items():
+        if not text:
+            continue
+        sep = "\n" if printed_any else ""
+        if render.styled():
+            print(f"{sep}{render.log_section(name)}")
+        else:
+            print(f"{sep}----- {name} -----")
+        print(text, end="" if text.endswith("\n") else "\n")
+        printed_any = True
+    return printed_any
+
+
+def cmd_log(args) -> int:
+    client = client_from_config()
+    if getattr(args, "follow", False):
+        state, printed_any = _poll_logs(client, args.run_id, interval=2.0)
+        _print_worker_output(client, args.run_id, printed_any=printed_any)
+        return 0 if state in _OK_STATES else 1
+    text = str(client.get_logs(args.run_id, offset=0).get("logs") or "")
+    if text:
+        print(text, end="" if text.endswith("\n") else "\n")
+    _print_worker_output(client, args.run_id, printed_any=bool(text))
+    return 0
+
+
 def cmd_status(args) -> int:
     client = client_from_config()
     if getattr(args, "follow", False):
-        return _follow_run(client, args.run_id)
-    if getattr(args, "logs", False):
-        logs = client.get_logs(args.run_id).get("logs", "")
-        printed_any = False
-        if logs:
-            print(logs, end="")
-            if not logs.endswith("\n"):
-                print()
-            printed_any = True
-        for name, text in (client.get_worker_output(args.run_id) or {}).items():
-            if not text:
-                continue
-            sep = "\n" if printed_any else ""
-            if render.styled():
-                print(f"{sep}{render.log_section(name)}")
-            else:
-                print(f"{sep}----- {name} -----")
-            print(text, end="" if text.endswith("\n") else "\n")
-            printed_any = True
-    status = client.get_run(args.run_id)
-    if render.styled():
-        print(render.run_status(status))
-    else:
-        print(json.dumps(status, indent=2))
+        return _follow_status(client, args.run_id)
+    print(_render_status(client.get_run(args.run_id)))
     return 0
 
 
@@ -516,20 +541,37 @@ def cmd_checkpoints(args) -> int:
     if render.styled():
         print(render.checkpoints_table(args.run_id, checkpoints))
         return 0
+    from flash.schema import format_checkpoint_ref
+
     for c in checkpoints:
-        print(f"step {c['step']:>6}  {c['repo_id']}:{c['subfolder']}")
+        # single-space, unpadded columns so a plain `grep "step N"` / awk split works; the ref is
+        # the canonical short form, paste-able into train.init_from_adapter.
+        print(f"step {c['step']} {format_checkpoint_ref(args.run_id, c['step'])}")
     print(
-        f"\ndeploy one with `flash deploy {args.run_id} --step <STEP>`.",
+        f"\ndeploy one with `flash deploy {args.run_id}/step-<STEP>`.",
         file=sys.stderr,
     )
     return 0
 
 
 def cmd_deploy(args) -> int:
-    dep = client_from_config().deploy(
+    from flash.schema import parse_checkpoint_ref
+
+    # `flash deploy <run_id>/step-N` is the same checkpoint ref `flash checkpoints` prints.
+    parsed = parse_checkpoint_ref(args.run_id)
+    if parsed is None:
+        print(
+            f"invalid run/checkpoint reference {args.run_id!r} "
+            "(expected <run_id> or <run_id>/step-N)",
+            file=sys.stderr,
+        )
+        return 1
+    base_run_id, _step = parsed
+    client = client_from_config()
+    dep = client.deploy(
         args.run_id,
         dry_run=args.dry_run,
-        step=getattr(args, "step", None),
+        verify=not getattr(args, "no_verify", False),
     )
     if render.styled():
         print(render.deployed(dep))
@@ -537,11 +579,35 @@ def cmd_deploy(args) -> int:
         print(json.dumps(dep, indent=2))
     # a dry run creates no deployment, so the billing / undeploy hint would be misleading.
     if dep.get("state") != "dry_run":
+        endpoint = str(dep.get("endpoint_name") or "").rstrip("/")
+        openai_base = dep.get("url") or (f"{endpoint}/v1" if endpoint else "")
         note = (
-            f"serving is billed per token only; use `flash undeploy {args.run_id}` "
+            f"serving is billed per token only; use `flash undeploy {base_run_id}` "
             "to deregister the adapter."
         )
         print(render.arrow(note) if render.styled() else f"note: {note}", file=sys.stderr)
+        if openai_base:
+            url_note = (
+                f"OpenAI-compatible base URL: {openai_base} — point clients at this /v1 base, "
+                "not the bare endpoint (which 404s on /chat/completions)."
+            )
+            print(render.arrow(url_note) if render.styled() else f"note: {url_note}", file=sys.stderr)
+    if dep.get("state") != "dry_run":
+        state = dep.get("state", "deploying")
+        status_note = (
+            f"deployment state is {state!r}; run `flash deployments` to check progress "
+            "and use `flash chat` once it is ready."
+        )
+        print(
+            render.arrow(status_note) if render.styled() else f"note: {status_note}",
+            file=sys.stderr,
+        )
+        if getattr(args, "no_verify", False):
+            skip_note = "server-side smoke verification was skipped for this deployment."
+            print(
+                render.arrow(skip_note) if render.styled() else f"note: {skip_note}",
+                file=sys.stderr,
+            )
     return 0
 
 
@@ -555,9 +621,8 @@ def cmd_export(args) -> int:
             "(export it in your shell or put it in a local .env / .env.local)"
         )
     client = client_from_config()
-    where = f" (step {args.step})" if args.step is not None else ""
     progress = (
-        f"exporting adapter {args.adapter_id}{where} to {args.repository} — "
+        f"exporting adapter {args.adapter_id} to {args.repository} — "
         "downloading then re-uploading; this can take a minute..."
     )
     print(render.note(progress) if render.styled() else progress, file=sys.stderr)
@@ -565,7 +630,6 @@ def cmd_export(args) -> int:
         args.adapter_id,
         repository=args.repository,
         hf_token=hf_token,
-        step=args.step,
         private=not args.public,
     )
     if render.styled():
@@ -602,16 +666,23 @@ def cmd_deployments(args) -> int:
     if render.styled():
         print(render.deployments_table(rows))
         return 0
-    print(f"{'RUN_ID':<32}  {'GPU':<9}  ENDPOINT")
+    print(f"{'RUN_ID':<32}  {'STATE':<10}  {'GPU':<9}  {'ENDPOINT':<32}  DETAIL")
     for r in rows:
         d = r.get("deployment") or {}
-        print(f"{r['run_id']:<32}  {d.get('gpu', '?'):<9}  {d.get('endpoint_name', '')}")
+        detail = str(d.get("error") or d.get("detail") or "")
+        print(
+            f"{r['run_id']:<32}  {d.get('state', '?'):<10}  "
+            f"{d.get('gpu', '?'):<9}  {d.get('endpoint_name', ''):<32}  {detail}"
+        )
     return 0
 
 
 def cmd_chat(args) -> int:
     client = client_from_config()
     messages = [{"role": "user", "content": args.message}]
+    system = getattr(args, "system", None)
+    if system:
+        messages.insert(0, {"role": "system", "content": system})
     if render.styled():
         print(render.chat_label())
     stream = getattr(client, "chat_stream", None)

{freesolo_flash_dev-0.2.33 → freesolo_flash_dev-0.2.35}/flash/cli/envpush.py

@@ -188,10 +188,23 @@ _ENV_PUSH_SIDECAR_SUFFIXES = frozenset(
 
 
 def _normalize_env_name(raw: str) -> str | None:
-    import re
+    """Normalize only the NAME segment; a namespace prefix is passed through verbatim.
 
-    name = re.sub(r"[^a-z0-9]+", "-", raw.lower()).strip("-")
-    return name or None
+    The server is the sole authority on namespace grammar and ownership — rewriting the
+    namespace client-side would silently target a different (possibly forbidden) slug.
+    """
+    from flash.schema import normalize_env_name_segment
+
+    text = str(raw or "").strip()
+    if "/" not in text:
+        return normalize_env_name_segment(text)
+    parts = [part.strip() for part in text.split("/")]
+    if len(parts) != 2 or not all(parts):
+        return None
+    name = normalize_env_name_segment(parts[1])
+    if name is None:
+        return None
+    return f"{parts[0]}/{name}"
 
 
 def _with_syspath_bootstrap(env_source: str) -> str:

{freesolo_flash_dev-0.2.33 → freesolo_flash_dev-0.2.35}/flash/cli/render.py

@@ -381,7 +381,7 @@ def version(value: str) -> str:
 def submitted(run_id: str) -> str:
     """The `flash train` hand-off note (printed to stderr before logs start streaming)."""
     head = ok(f"run {_paint(run_id, _ACCENT2)} submitted")
-    hint = _dim(f"following logs — Ctrl-C detaches; resume with `flash status {run_id} --follow`")
+    hint = _dim(f"following logs — Ctrl-C detaches; resume with `flash log {run_id} --follow`")
     return _safe(f"{head}\n{hint}")
 
 
@@ -439,28 +439,37 @@ def deployments_table(rows: list[dict]) -> str:
     body = []
     for r in rows:
         d = r.get("deployment") or {}
+        state = str(d.get("state") or "?")
+        color = _GREEN if state in {"ready", "deployed"} else _RED if state == "failed" else _AMBER
+        detail = str(d.get("error") or d.get("detail") or "")
+        if len(detail) > 64:
+            detail = detail[:61] + "..."
         body.append(
             [
                 (r["run_id"], _ACCENT2),
+                (state, color),
                 (d.get("gpu", "?"), _GRAY),
                 (d.get("endpoint_name", ""), _GREEN),
+                (detail, _GRAY),
             ]
         )
-    table = _table(["RUN ID", "GPU", "ENDPOINT"], body)
+    table = _table(["RUN ID", "STATE", "GPU", "ENDPOINT", "DETAIL"], body)
     return _safe(f"{header('deployments', f'{len(rows)} active')}\n{table}")
 
 
 def checkpoints_table(run_id: str, rows: list[dict]) -> str:
-    """Deployable per-step RL checkpoints: the step number + the stable repo path it lives at."""
+    """Deployable per-step RL checkpoints: step number + the canonical `<run_id>/step-N` ref."""
+    from flash.schema import format_checkpoint_ref
+
     body = [
         [
             (str(c.get("step", "")), _TEAL),
-            (f"{c.get('repo_id', '')}:{c.get('subfolder', '')}", _ACCENT2),
+            (format_checkpoint_ref(run_id, c.get("step", 0)), _ACCENT2),
         ]
         for c in sorted(rows, key=lambda c: c.get("step", 0))
     ]
     table = _table(["STEP", "CHECKPOINT"], body, aligns=["r", "l"])
-    foot = arrow(f"deploy one with: flash deploy {run_id} --step <STEP>")
+    foot = arrow(f"deploy one with: flash deploy {run_id}/step-<STEP>")
     return _safe(f"{header('checkpoints', f'{len(rows)} deployable')}\n{table}\n\n{foot}")
 
 
@@ -541,11 +550,14 @@ def cancelled(payload: dict) -> str:
 
 def deployed(dep: dict) -> str:
     """`flash deploy`: the endpoint, gpu, and serving url as an aligned card (not a JSON dump)."""
+    endpoint = str(dep.get("endpoint_name") or "")
+    # OpenAI clients need the /v1 base; older servers omit `url`, so derive it from the endpoint.
+    url = dep.get("url") or (f"{endpoint.rstrip('/')}/v1" if endpoint else None)
     pairs = [
         ("run", _paint(dep.get("run_id", ""), _ACCENT2)),
-        ("endpoint", _paint(dep["endpoint_name"], _GREEN) if dep.get("endpoint_name") else None),
+        ("endpoint", _paint(endpoint, _GREEN) if endpoint else None),
         ("gpu", dep.get("gpu")),
-        ("url", _paint(dep["url"], _ACCENT2) if dep.get("url") else None),
+        ("url", _paint(url, _ACCENT2) if url else None),
     ]
     state = dep.get("state", "deployed")
     if state == "dry_run":
@@ -571,6 +583,10 @@ def undeployed(result: dict) -> str:
     line = ok(f"torn down {rid}")
     if deleted:
         line += "\n" + _dim(f"  deregistered {', '.join(deleted)}")
+    else:
+        line += "\n" + _dim(
+            "  serving had no registered adapter to deregister (already gone or never registered)"
+        )
     return _safe(line)
 
 
@@ -659,7 +675,7 @@ def chat_label() -> str:
 
 
 def log_section(name: str) -> str:
-    """A themed divider above a passthrough worker-log section in `flash status --logs` — the same
+    """A themed divider above a passthrough worker-log section in `flash log` — the same
     idiom as chat_label sitting above a raw chat reply (the log body stays raw). The machine path
     keeps the plain ``----- name -----`` divider that scripts and tests match on."""
     rule = _paint(_glyph("─", "-") * 3, _FAINT)