badgr-cli 1.1.3 → 1.1.4

package/README.md

@@ -13,7 +13,7 @@ Badgr supports many GPU workloads through two commands: `serve` for persistent e
 npm install -g badgr-cli
 ```
 
-**Jump to:** [Quick start](#quick-start) · [Coding agents (`badgr launch`)](#coding--testing-agents-badgr-launch) · [Image generation](#also-try-image-generation) · [`badgr doctor`](#something-not-working-badgr-doctor) · [Commands](#commands) · [`serve` options](#badgr-serve-options) · [`run` options](#badgr-run-options) · [Receipts](#receipts) · [OpenAI compatibility](#openai-compatibility) · [GPU options](#gpu-options) · [Advanced](#advanced) · [Requirements](#requirements)
+**Jump to:** [Quick start](#quick-start) · [Coding agents (`badgr launch`)](#coding--testing-agents-badgr-launch) · [Image generation](#also-try-image-generation) · [`badgr doctor`](#something-not-working-badgr-doctor) · [`badgr diagnose`](#diagnose-a-gpu-issue-badgr-diagnose) · [Commands](#commands) · [`serve` options](#badgr-serve-options) · [`run` options](#badgr-run-options) · [Receipts](#receipts) · [OpenAI compatibility](#openai-compatibility) · [GPU options](#gpu-options) · [Advanced](#advanced) · [Requirements](#requirements)
 
 ---
 
@@ -159,21 +159,80 @@ Run `badgr doctor --help` for the full flag list. Details in
 
 ---
 
+## Badgr Smoke Test: `badgr diagnose`
+
+Paste a GitHub issue, a Docker image, a repo URL, a log file, a ComfyUI
+workflow, or a raw conversation — Badgr auto-detects the input, redacts
+secrets, and runs free static checks as part of a Badgr Smoke Test.
+Nothing runs on a GPU without explicit `--approve`.
+
+```bash
+# Free Badgr Smoke Test — no login required
+badgr diagnose "https://github.com/org/repo/issues/123"
+badgr diagnose ajayrajtp/vllm_gemma412b:latest
+badgr diagnose ./vllm-error.log
+badgr diagnose "https://github.com/org/repo"
+badgr diagnose workflow.json
+
+# Free mechanical validation of the produced command — still no GPU, no login
+badgr diagnose "https://github.com/org/repo/issues/123" --smoke
+
+# Approve a capped smoke test after diagnosis (login required)
+badgr diagnose "https://github.com/org/repo/issues/123" --approve
+
+# Resume an existing case, e.g. one shared via a case link
+badgr diagnose repro_xxxxxxxx --approve
+badgr diagnose "https://aibadgr.com/repro/repro_xxxxxxxx" --approve
+
+# Machine-readable output
+badgr diagnose "https://github.com/org/repo/issues/123" --json
+```
+
+| Flag | Description |
+|------|-------------|
+| `--smoke` | Free. Runs real, cheap mechanical validation of the produced command (syntax, CLI-entrypoint corroboration, referenced-file presence, Docker `ENTRYPOINT`/`CMD` consistency, required env vars, plus a client-side check of any local file path you pasted). Never starts a GPU, never requires login. Combine with `--approve` — the smoke checks print first, then the normal approve flow runs. Not the same as `badgr run --smoke`, which launches a real, billable GPU job |
+| `--approve` | Approve the capped smoke test after diagnosis (opens browser sign-in automatically if not logged in) |
+| `--docker <image>` | Force Docker-image intake (override auto-detect) |
+| `--repo <url>` | Force repository intake (override auto-detect) |
+| `--comfyui <path>` | Force ComfyUI workflow intake (override auto-detect) |
+| `--github <url>` | Include a GitHub issue URL found inside pasted text as additional context (opt-in, never fetched automatically) |
+| `--json` | Machine-readable JSON output |
+
+Every run prints one status: `NEEDS INFO` (fields still missing) →
+`READY` (complete evidence-backed command, no smoke run) → `SMOKE CHECKED`
+(`--smoke` ran, every applicable check passed or was skipped) / `INVALID`
+(`--smoke` ran and a check actually failed) → `VERIFIED` (reserved for an
+actual successful GPU-provisioned run — never assigned from static
+resolution or `--smoke`). `READY`/`SMOKE CHECKED` results also print the
+canonical `badgr run`/`badgr serve` command `--approve` would run, plus a
+shareable case link — pass that case ID or URL back into `badgr diagnose
+<case_id_or_url> --approve` to resume the same case without re-diagnosing.
+
+`badgr run-issue` is an alias for `badgr diagnose`, matching the
+[aibadgr.com/run-issue](https://aibadgr.com/run-issue) Badgr Smoke Test
+web flow.
+
+---
+
 ## Commands
 
 ```text
 login
 connect
 doctor
+diagnose
 run
 launch
-task
+job
 serve
 status
 logs
 pull
 artifacts
 down
+restart
+rerun
+heartbeat
 receipts
 test
 ```
@@ -183,6 +242,7 @@ test
 | `badgr login` | Save API key to `~/.badgr/config.json` |
 | `badgr connect <provider>` | Store a provider credential (`anthropic`, `openai`) for `badgr launch` |
 | `badgr doctor` | Diagnose a GPU workload failure — read-only, no login needed |
+| `badgr diagnose "<input>"` | Run a Badgr Smoke Test on a GitHub issue, Docker image, repo, log, or workflow — free, no GPU until `--approve` |
 | `badgr run <command>` | Run a one-off GPU job (any container command) |
 | `badgr launch cline\|claude\|codex\|playwright "<task>"` | Run a coding/testing agent on a CPU VM — image + command auto-selected |
 | `badgr job <agent> "<instruction>" --check "<cmd>"` | Tracked coding-agent job via `POST /v1/jobs` (type: agent) |
@@ -192,10 +252,13 @@ test
 | `badgr pull <id>` | Pull a code-editing agent's patch as a local git diff/branch |
 | `badgr artifacts <id>` | Download non-patch outputs (test reports, screenshots, traces) |
 | `badgr down <id>` | Terminate a deployment — stops billing immediately |
+| `badgr restart <id>` | Relaunch an endpoint with the same config, on a new deployment ID, keeping its API key |
+| `badgr rerun <id>` | Replay a past job or endpoint with its exact original spec, on a new deployment ID |
+| `badgr heartbeat <id>` | Reset an endpoint's idle-timeout clock (see `--idle-timeout` under [`badgr serve` options](#badgr-serve-options)) |
 | `badgr receipts [n]` | Cost, route, and retry receipts (default 10) |
 | `badgr test` | Run an end-to-end test (provision → run → teardown) |
 
-More commands below, under [Advanced](#advanced): `comfyui`, `train`, `transcribe`, `embed`, `workload`, `workspace`, `batch`, `sbatch`, `capacity`, `billing`.
+More commands below, under [Advanced](#advanced): `comfyui`, `train`, `transcribe`, `embed`, `workload`, `workspace`, `batch`, `sbatch`, `capacity`, `billing`, `models`, `template`.
 
 `badgr serve` — for anything that needs a persistent endpoint: LLM serving, embeddings, image generation APIs, transcription APIs.
 
@@ -228,16 +291,38 @@ Each command section below lists only its own extra flags.
 badgr serve meta-llama/Llama-3.1-8B-Instruct --gpu L40S --region EU
 ```
 
+Endpoints bill continuously, so `serve` requires either `--max-cost` or `--persistent` (or `--dry-run` to just preview) — it refuses to start otherwise.
+
 | Flag | Default | Description |
 |------|---------|-------------|
 | `--image <img>` | — | Serve a custom container instead of a HuggingFace model |
 | `--task <task>` | — | vLLM task override, e.g. `embed` for embedding models |
-| `--health-path <path>` | auto | Readiness path to poll (auto-detected for ComfyUI → `/system_stats`) |
+| `--runtime llama.cpp\|ollama` | vLLM | Serve via a different runtime instead of vLLM |
+| `--hf-repo <repo>` | — | HuggingFace repo for a GGUF file (with `--runtime llama.cpp`), e.g. `org/model-repo` |
+| `--hf-file <file>` | — | GGUF filename within that repo, e.g. `model.gguf` (required with `--runtime llama.cpp`) |
+| `--idle-timeout <min>` | — | Auto-stop after N minutes with no `badgr heartbeat` call — see [`badgr heartbeat`](#badgr-heartbeat) |
+| `--persistent` | off | Run until manually stopped — satisfies the cost-control requirement in place of `--max-cost` |
+| `--check-nodes <n1,n2>` | — | For ComfyUI-shaped images: verify custom nodes are installed after startup |
+| `--health-path <path>` | auto | Readiness path to poll (auto-detected: ComfyUI → `/system_stats`, llama.cpp → `/health`) |
 | `--no-wait` | off | Skip endpoint health check and return immediately |
+| `--yes` / `-y` | off | Skip duplicate-deployment warning |
+| `--dry-run` | — | Preview the plan (GPU, price) without provisioning |
 | `--list-aliases` | — | List blessed vLLM model aliases (`qwen-7b`, `llama-8b`, `qwen-coder-7b`) and exit — no provisioning, no API key required |
 
 Blessed aliases expand to a full model ID + preset GPU, e.g. `badgr serve qwen-7b` → `Qwen/Qwen2.5-7B-Instruct` on an RTX 4090. Run `badgr serve --list-aliases` to see the current list.
 
+```bash
+# Serve a Hugging Face GGUF file via llama.cpp instead of vLLM
+badgr serve --runtime llama.cpp --hf-repo org/model-repo --hf-file model.gguf --max-cost 10
+
+# Serve Open WebUI, a chat UI, pointed at a model endpoint
+badgr serve openwebui --model qwen-7b --max-cost 10
+badgr serve openwebui --connect <existing-endpoint-url>   # connect to an endpoint you already have
+
+# Auto-stop only when idle — requires periodic badgr heartbeat calls to stay up
+badgr serve qwen-7b --idle-timeout 30 --max-cost 10
+```
+
 ### Model support levels
 
 `badgr serve qwen-7b` is the happy path — a tested route with no extra setup. `badgr serve` also accepts any other model ID or a custom container:
@@ -269,10 +354,21 @@ badgr run . --image mycompany/custom:latest --cmd "python train.py" --max-cost 5
 
 Badgr zips and uploads the folder (Flow 1) or clones the repo (Flow 2), picks a generic runner, installs deps, runs the command, stores outputs for 48 hours, and tears down the GPU. `--max-cost` is required.
 
+```bash
+# No GPU needed — run on a plain CPU VM instead
+badgr run . --cmd "npm test" --no-gpu --max-cost 1
+
+# Describe basic compute needs instead of a GPU model — Badgr finds a compatible machine
+badgr run . --cpu 16 --memory 64GB --gpu-memory 24GB --max-cost 5
+```
+
 | Flag | Default | Description |
 |------|---------|-------------|
 | `--cmd <command>` | — | Command to run inside the uploaded project or cloned repo (required for folder/GitHub flows) |
-| `--min-vram <GB>` | — | Minimum VRAM in GB — optional constraint for Auto routing |
+| `--min-vram <GB>` | — | Minimum VRAM in GB — optional constraint for Auto routing (alias: `--gpu-memory`) |
+| `--cpu <cores>` | — | Minimum CPU cores (for a CPU-only run) |
+| `--memory <size>` | — | Minimum RAM, e.g. `64GB` |
+| `--no-gpu` | off | Run on a CPU-only VM — no GPU is provisioned (conflicts with `--gpu`/`--min-vram`) |
 | `--image <img>` | — | Custom Docker image — bypasses the runner |
 | `--max-runtime <min>` | — | Auto-stop after N minutes |
 | `--save <name>` | — | Save this job as a named workload after it completes |
@@ -320,13 +416,14 @@ Productized batch image generation — runs a list of prompts through a **blesse
 ```bash
 badgr comfyui batch --workflow sdxl-basic --prompts prompts.txt --max-cost 10
 badgr comfyui batch --workflow sdxl-basic --prompt "a cat on a beach" --prompt "a dog in the park" --max-cost 5
+badgr comfyui batch --workflow flux-basic --prompt "a neon city at night" --max-cost 5
 ```
 
-Blessed workflows: `sdxl-basic` (SDXL text-to-image, default sampler settings). Max 20 prompts per batch.
+Blessed workflows: `sdxl-basic` (SDXL text-to-image, default sampler settings), `flux-basic` (FLUX.1-schnell text-to-image). Max 20 prompts per batch.
 
 | Flag | Default | Description |
 |------|---------|-------------|
-| `--workflow <name>` | — | Blessed workflow ID (required) — currently `sdxl-basic` |
+| `--workflow <name>` | — | Blessed workflow ID (required) — `sdxl-basic` or `flux-basic` |
 | `--prompts <file>` | — | Text file, one prompt per line |
 | `--prompt <text>` | — | Inline prompt (repeatable) — combine with `--prompts` if needed |
 | `--max-runtime <min>` | 60 | Auto-stop after N minutes |
@@ -350,6 +447,37 @@ Each receipt includes runtime, estimated/settled cost, status, retries, teardown
 
 ---
 
+## Managing a deployment
+
+```bash
+badgr status                          # what's running and billing
+badgr logs dep-abc123                 # fetch current log output
+badgr logs dep-abc123 --follow        # stream logs until the deployment reaches a terminal state
+badgr pull dep-abc123                 # pull a coding agent's patch as a local git diff
+badgr pull dep-abc123 --branch        # ...as a new local branch instead of a diff
+badgr pull dep-abc123 --diff-only     # print the diff, don't touch the working tree
+badgr artifacts dep-abc123            # download non-patch outputs (test reports, screenshots, traces)
+badgr down dep-abc123                 # terminate one deployment, stop billing
+badgr down --all                      # terminate everything running, with a confirmation prompt
+badgr down --all --yes                # ...skip the confirmation prompt
+badgr restart dep-abc123              # relaunch an endpoint with the same config — new ID, same API key
+badgr rerun dep-abc123                # replay a past job/endpoint with its exact original spec — new ID
+badgr heartbeat dep-abc123            # reset an endpoint's idle-timeout clock (see --idle-timeout on badgr serve)
+```
+
+| Command | Flag | Description |
+|---------|------|-------------|
+| `badgr logs <id>` | `--follow` / `-f` | Stream/poll logs until the deployment reaches a terminal state instead of a one-shot fetch |
+| `badgr pull <id>` | `--branch` | Create a new local git branch from the patch instead of leaving it as an unstaged diff |
+| `badgr pull <id>` | `--diff-only` | Print the raw diff, don't touch the local working tree at all |
+| `badgr pull <id>` | `--yes` / `-y` | Skip the confirmation prompt before applying |
+| `badgr down <id\|--all>` | `--all` | Terminate every running deployment instead of one by ID |
+| `badgr down <id\|--all>` | `--yes` / `-y` | Skip the confirmation prompt |
+
+`badgr restart` is endpoint-only (it tears down the current pod and relaunches with the same GPU/model/price/runtime caps and endpoint API key, so existing clients keep working against a new URL). `badgr rerun` works for both one-off jobs and endpoints, replaying the exact original image/command/env/GPU/caps, and never tears down the source deployment.
+
+---
+
 ## OpenAI compatibility
 
 `badgr serve` provisions a vLLM endpoint that is fully OpenAI-compatible:
@@ -417,22 +545,26 @@ Less common commands — training, transcription, embeddings, and the workload/w
 badgr train config.yaml --gpu A100 --max-runtime 240 --env HF_TOKEN=$HF_TOKEN
 ```
 
-Detects framework (axolotl, unsloth, trl) from the config file, but **only Axolotl configs run today** — `unsloth`/`trl`/unrecognized configs are blocked before provisioning rather than billing a GPU that's guaranteed to fail. Default max-runtime is 120 min.
+Detects framework (axolotl, unsloth, trl) from the config file. **Axolotl and TRL configs run today** — `unsloth`/unrecognized configs are blocked before provisioning rather than billing a GPU that's guaranteed to fail. Default max-runtime is 120 min.
 
 ```bash
 badgr train lora --base-model mistralai/Mistral-7B-v0.1 --dataset ./train.jsonl --preset small --max-cost 20
+
+# Resume from a prior job's checkpoint instead of starting over
+badgr train lora --base-model mistralai/Mistral-7B-v0.1 --dataset ./train.jsonl --resume https://.../checkpoint --max-cost 20
 ```
 
 Productized LoRA training — pass a base model and dataset, no Axolotl config file needed. Badgr generates the config from a preset and returns a downloadable adapter.
 
 | Flag | Default | Description |
 |------|---------|-------------|
-| `--framework <name>` | auto-detect | Force framework: `axolotl`, `unsloth`, `trl` (only `axolotl` currently runs) |
+| `--framework <name>` | auto-detect | Force framework: `axolotl`, `unsloth`, `trl` (`axolotl`/`trl` currently run; `unsloth` is blocked pre-provisioning) |
 | `--base-model <id>` | — | HuggingFace model ID (required for `train lora`) — validated to exist before provisioning |
 | `--dataset <path\|url>` | — | Local file, direct URL, or `s3://` URI |
 | `--file-id <id>` | — | Badgr upload ID instead of `--dataset` |
 | `--preset small\|medium` | `small` | `small` = RTX 4090, rank 16, 3 epochs. `medium` = A100, rank 32, 5 epochs |
 | `--gpu-type <type>` | preset default | GPU type override for `train lora` |
+| `--resume <checkpoint-url>` | — | Continue training from a prior job's checkpoint instead of starting fresh |
 | `--dry-run` | — | Preview the job without provisioning |
 
 On completion, `train lora` prints an `adapter_url` — download with `GET /v1/jobs/{job_id}/adapter`, or via `badgr workload info` if saved.
@@ -502,8 +634,11 @@ badgr batch status dep-abc123
 badgr batch artifacts dep-abc123
 badgr batch receipt dep-abc123
 badgr batch compare dep-abc123 dep-def456
+badgr batch compare dep-abc123 dep-def456 --key accuracy --higher-is-better
 ```
 
+`batch compare` reads each run's `success_metric` by default; `--key <metric>` compares a different field from the receipt instead, and `--higher-is-better` (default) / `--higher-is-better false` controls which run is reported as the winner.
+
 For CV/video/scientific batch, simulation, and physical-AI eval workloads — runs a container from a `workload.yml` spec and captures output artifacts automatically.
 
 **Fan-out** — run the same program once per file in a directory, one deployment per input, in parallel:
@@ -539,14 +674,44 @@ Translates `--cpus-per-task`/`--mem`/`--gres`/`--time`/`--export` from a real `.
 | `--max-concurrency <n>` | 5 | Cap in-flight array tasks |
 | `--dry-run` | — | Preview the translated job without provisioning |
 
-### Other commands
+### `badgr models` — GPU catalog and pricing
+
+```bash
+badgr models
+```
+
+Lists available GPU types cheapest-first, with VRAM and hourly rate — pulled live from your account when logged in, falling back to the local catalog otherwise. No flags.
 
-- `badgr capacity [--gpu <type>]` — check available GPU capacity right now
-- `badgr billing status` / `badgr billing add <amount>` — check balance / add funds
+### `badgr template` — pre-built workload templates
+
+```bash
+badgr template list
+badgr template info axolotl
+badgr serve template vllm --model meta-llama/Llama-3.1-8B-Instruct --max-cost 10
+badgr run template axolotl --config ./config.yaml --max-cost 10
+```
+
+Provider-neutral templates for common frameworks (`vllm`, `invokeai`, `comfyui`, `axolotl`, `unsloth`, …). `template list`/`template info <name>` just browse the catalog; launching always goes through `badgr serve template <name>` or `badgr run template <name>`, which apply the template's default flags before handing off to the normal `serve`/`run` path.
+
+### `badgr capacity` — check live availability
+
+```bash
+badgr capacity                              # cheapest runnable GPU across all types
+badgr capacity --gpu A100                   # a specific GPU type
+badgr capacity --gpu A100 --region EU       # region-filtered
+badgr capacity --gpu A100 --max-price 2.50  # price-capped
+```
+
+### `badgr billing`
+
+```bash
+badgr billing status         # current balance
+badgr billing add 20         # add funds — $5 minimum top-up
+```
 
 ---
 
 ## Requirements
 
-- Node.js 18+
+- Node.js 20.10+
 - A Badgr account — sign up at [aibadgr.com](https://aibadgr.com)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "badgr-cli",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "Badgr — run or serve GPU workloads from one command",
   "type": "module",
   "bin": {
@@ -14,6 +14,7 @@
   "dependencies": {
     "@inquirer/prompts": "^8.5.2",
     "archiver": "^7.0.1",
+    "badgr-shared": "0.1.1",
     "chalk": "^5.3.0",
     "js-yaml": "^4.1.0",
     "tar": "^7.4.3"

package/src/badgr.js

@@ -47,7 +47,7 @@ ${chalk.bold('COMMANDS')}
   ${chalk.cyan('badgr job <agent> "<instruction>" --check "<command>"')}  Bounded coding-agent job, tracked at /jobs (POST /v1/jobs, type: agent)
   ${chalk.cyan('badgr serve <model>')}       Serve a model with an OpenAI-compatible endpoint
   ${chalk.cyan('badgr serve openwebui')}     Serve Open WebUI — chat UI, connects to a model endpoint
-  ${chalk.cyan('badgr diagnose "<input>"')}   Diagnose any GPU issue for free — GitHub issue, Docker image, log, repo, or text
+  ${chalk.cyan('badgr diagnose "<input>"')}   Run a free Badgr Smoke Test on any GPU issue — GitHub issue, Docker image, log, repo, or text
   ${chalk.cyan('badgr doctor')}              Local GPU / model-fit diagnosis (read-only, no login needed)
   ${chalk.cyan('badgr status')}              Show what's running and what's billing
   ${chalk.cyan('badgr logs <id>')}           Stream logs for a running job or endpoint
@@ -113,7 +113,7 @@ ${chalk.bold('EXAMPLES')}
   ${chalk.dim('# badgr job — bounded coding-agent job with a pass/fail check, tracked at /jobs:')}
   badgr job cline "Run the Chromium tests and tell me what failed" --check "npm run test:chromium" --max-cost 1
 
-  ${chalk.dim('# Diagnose any GPU issue for free (no login needed):')}
+  ${chalk.dim('# Run a free Badgr Smoke Test on any GPU issue (no login needed):')}
   badgr diagnose "https://github.com/org/repo/issues/123"
   badgr diagnose ./error.log
   badgr diagnose --docker ajayrajtp/vllm_gemma412b:latest

package/src/commands/diagnose.js

@@ -1,4 +1,5 @@
 import fs from 'fs';
+import { classifyPastedInput } from 'badgr-shared';
 import { callApi } from '../api.js';
 import { ensureLoggedIn } from '../onboarding.js';
 
@@ -9,6 +10,7 @@ smoke-test plan. No GPU launches without explicit --approve.
 
 Usage:
   badgr diagnose "<input>"
+  badgr diagnose "<input>" --smoke
   badgr diagnose "<input>" --approve
   badgr diagnose "<input>" --json
   badgr diagnose <case_id_or_url> --approve   Resume an existing case (e.g.
@@ -24,8 +26,24 @@ Input (auto-detected):
   Existing case          repro_xxxxxxxx  or  https://aibadgr.com/repro/repro_xxxxxxxx
 
 Flags:
+  --smoke                Free. Runs real, cheap mechanical validation of the
+                          produced command on top of the normal diagnosis --
+                          command syntax, CLI-entrypoint corroboration,
+                          referenced-file presence, Docker ENTRYPOINT/CMD
+                          consistency, required env vars -- plus a client-side
+                          check of any local file path you pasted (e.g. a
+                          .gguf path), which only this machine can see. Never
+                          starts a GPU, never requires login, never prints
+                          "Verified" -- only "Smoke Checked" (AGENTS.md proof
+                          levels). Can be combined with --approve: the smoke
+                          checks print first, then the normal approve flow
+                          runs (they are independent, non-blocking steps).
+                          Unrelated to "badgr run --smoke", which launches a
+                          real, billable cheapest-GPU job.
   --approve              Approve the capped smoke test after diagnosis (opens
-                          browser sign-in automatically if not logged in)
+                          browser sign-in automatically if not logged in).
+                          This is a real, billable GPU-provisioned run --
+                          distinct from the free --smoke flag above.
   --docker <image>       Force Docker-image intake (override auto-detect)
   --repo   <url>         Force repository intake (override auto-detect)
   --comfyui <path>       Force ComfyUI workflow intake (override auto-detect)
@@ -35,8 +53,27 @@ Flags:
   --json                 Machine-readable JSON output
   --help, -h             Show this help
 
+Status: every run prints one of NEEDS INFO / READY / SMOKE CHECKED / INVALID / VERIFIED.
+        NEEDS INFO   -- cannot yet produce a complete command
+        READY        -- complete evidence-backed command, no smoke run
+        SMOKE CHECKED -- --smoke ran; all applicable checks PASS or SKIPPED
+        INVALID      -- --smoke ran and an applicable check actually FAILED
+        VERIFIED     -- only after a real successful run (never from --smoke)
+
+Run page: READY and SMOKE CHECKED results also create a free, anonymous
+          "Run" link (the same prepared case /run-issue's own confirm form
+          creates) -- a saved, runnable configuration you or anyone with the
+          link can open and click Run on. NEEDS INFO and INVALID never get
+          one (nothing runnable to save, or a check just proved it broken)
+          -- both print the correction instead. The page shows the exact
+          canonical "badgr ..." command --approve would run, not merely the
+          source command extraction found. Still no GPU starts until that
+          click. --approve reuses this same case rather than creating a
+          second one.
+
 Safety: nothing runs from AI-extracted data without --approve.
         No GPU launches without explicit approval and a credit check.
+        --smoke never provisions a GPU and never requires login.
 
 Full interactive flow: https://aibadgr.com/run-issue`;
 
@@ -66,32 +103,27 @@ function detectInput(raw, flags) {
 
   if (!raw) return null;
 
-  // A case_id (bare, or embedded in a /repro/<id> or /run-issue?case_id=<id>
-  // link — the two shapes an admin-prepared or self-created case gets
-  // shared as) resumes that existing case instead of diagnosing new input.
-  const bareCaseMatch = /^repro_[a-zA-Z0-9]+$/.exec(raw.trim());
-  const urlCaseMatch = /\/repro\/(repro_[a-zA-Z0-9]+)/.exec(raw) || /[?&]case_id=(repro_[a-zA-Z0-9]+)/.exec(raw);
-  const caseId = bareCaseMatch?.[0] || urlCaseMatch?.[1];
-  if (caseId) {
-    return { kind: 'existing_case', label: `Existing case: ${caseId}`, caseId };
+  // Case-id / GitHub-URL-shape classification is shared with the web page
+  // (`classifyPastedInput`, packages/shared/src/index.ts) so the CLI and
+  // /run-issue never disagree about what a given paste is. A case_id (bare,
+  // or embedded in a /repro/<id> or /run-issue?case_id=<id> link — the two
+  // shapes an admin-prepared or self-created case gets shared as) resumes
+  // that existing case instead of diagnosing new input.
+  const classified = classifyPastedInput(raw);
+  if (classified.kind === 'existing_case') {
+    return { kind: 'existing_case', label: `Existing case: ${classified.body.case_id}`, caseId: classified.body.case_id };
   }
-
-  if (/^https?:\/\/(www\.)?github\.com\/[^/]+\/[^/]+\/issues\/\d/.test(raw)) {
-    return {
-      kind:  'github_issue',
-      label: `GitHub issue: ${raw}`,
-      body:  { github_url: raw },
-    };
+  if (classified.kind === 'github_issue') {
+    return { kind: 'github_issue', label: `GitHub issue: ${raw}`, body: classified.body };
   }
-
-  if (/^https?:\/\/(www\.)?github\.com\//.test(raw)) {
-    return {
-      kind:  'repo_url',
-      label: `GitHub repository: ${raw}`,
-      body:  { repo_url: raw },
-    };
+  if (classified.kind === 'repo_url') {
+    return { kind: 'repo_url', label: `GitHub repository: ${raw}`, body: classified.body };
   }
 
+  // Local filesystem paths -- only the CLI has a filesystem to check
+  // against, so this stays CLI-only, sitting between the shared URL checks
+  // above and the shared Docker-image/text fallback below (matches
+  // classifyPastedInput's own precedence for everything except this).
   if (fs.existsSync(raw)) {
     const content = fs.readFileSync(raw, 'utf8');
     if (raw.endsWith('.json') || raw.endsWith('.JSON')) {
@@ -112,23 +144,11 @@ function detectInput(raw, flags) {
     };
   }
 
-  if (
-    !raw.startsWith('http') &&
-    /^[a-z0-9][a-z0-9._\-]*(?:\/[a-z0-9._\-]+)*(?::[a-zA-Z0-9._\-]+)?$/.test(raw) &&
-    raw.length < 200
-  ) {
-    return {
-      kind:  'docker_image',
-      label: `Docker image: ${raw}`,
-      body:  { docker_image: raw },
-    };
+  if (classified.kind === 'docker_image') {
+    return { kind: 'docker_image', label: `Docker image: ${raw}`, body: classified.body };
   }
 
-  return {
-    kind:  'text',
-    label: 'Text / conversation',
-    body:  { text: raw.slice(0, 50_000) },
-  };
+  return { kind: 'text', label: 'Text / conversation', body: classified.body };
 }
 
 function _printResult(result, chalk) {
@@ -204,11 +224,187 @@ function _printResult(result, chalk) {
   }
 }
 
-async function _doApprove(config, result, chalk) {
-  // Diagnosis and case creation stay anonymous and free — login is only
-  // required once we know a real GPU test needs approving (below).
-  const e = result.extraction;
-  const confirmBody = {
+// Local-machine file paths (e.g. a pasted .gguf path) can only be checked
+// client-side -- the backend never sees this machine's filesystem, so it
+// must not (and does not) claim to validate them. Only paths that look like
+// a real filesystem reference (absolute, `./`, `../`, or `~/`) are checked;
+// bare words, URLs, and Docker image references are left alone.
+//
+// Path checks must respect context (locked Free Command Check spec, problem
+// #3): a repo path is checked against the repo tree, a container path
+// against Dockerfile/image evidence -- both server-side, inside
+// `mechanical_checks` -- and only a genuinely local path belongs to this
+// machine. Once a repository or Docker image is in evidence for this
+// workload, an absolute path *inside the resolved command* (e.g. "python3
+// /src/main.py") is a repo/container path, not a claim about this laptop,
+// so it must never be re-checked against the local filesystem here -- doing
+// so is exactly the "/src/main.py NOT FOUND on this machine" false failure
+// the spec calls out. `model_artifact` is different: it is always this
+// machine's own claim about a locally-downloaded checkpoint, never repo or
+// container evidence, so it stays checked regardless.
+function _localPathCandidates(e) {
+  const candidates = new Set();
+  const hasRepoOrContainerContext = Boolean(
+    e.repositories?.length || e.docker_images?.length || e.dockerfile
+  );
+  const maybeAdd = (value) => {
+    if (typeof value !== 'string') return;
+    const s = value.trim().replace(/^['"]|['"]$/g, '');
+    if (!s || /^https?:\/\//i.test(s)) return;
+    if (s.startsWith('/') || s.startsWith('./') || s.startsWith('../') || s.startsWith('~/')) {
+      candidates.add(s);
+    }
+  };
+  maybeAdd(e.model_artifact);
+  if (!hasRepoOrContainerContext) {
+    for (const tok of (e.commands?.[0] || '').split(/\s+/)) maybeAdd(tok);
+  }
+  return [...candidates];
+}
+
+// Locked status ladder (product-level labels, not the backend's internal
+// proof_level enum): NEEDS INFO / READY / SMOKE CHECKED / INVALID / VERIFIED.
+// Pure presentation over data /run-issue/extract already returns -- no new
+// endpoint, no new GPU behaviour. --smoke can reach SMOKE CHECKED or INVALID
+// (never VERIFIED, see AGENTS.md §12 and _printCopySummary below).
+//
+// The evidence-only judgment (needs_info/invalid/smoke_checked) is computed
+// once, server-side, in `_compute_smoke_status` (backend/run_issue_routes.py)
+// and read here via `e.smoke_status` -- this and /run-issue's `smokeStatus()`
+// (frontend/app/run-issue/page.tsx) both just render that one backend
+// verdict rather than each re-deriving pass/fail from mechanical_checks, so
+// the CLI and the web page can never disagree on what a given result means.
+// A `smoke_status` fallback derivation is kept only for a backend response
+// that predates this field (defensive, not the normal path).
+//
+// READY means "no smoke run" -- a command that's merely complete is never
+// itself proof of validity, so mechanical/local-file results only ever
+// change the printed word when --smoke actually ran them (locked spec
+// problem #6: a real FAIL must demote SMOKE CHECKED to INVALID; SKIPPED
+// checks never do). This part stays CLI-side: it depends on the --smoke
+// flag and this machine's own filesystem, neither of which the backend can
+// see.
+function _statusWord(result, smokeRequested) {
+  const e = result.extraction || {};
+  if (result.static_incompatibilities?.length || e.missing_information?.length) return 'NEEDS INFO';
+  if (!smokeRequested) return 'READY';
+  const backendStatus = e.smoke_status
+    || ((e.mechanical_checks || []).some((check) => check.status === 'fail') ? 'invalid' : 'smoke_checked');
+  const localFail = _localPathCandidates(e).some((p) => !fs.existsSync(p));
+  if (backendStatus === 'invalid' || localFail) return 'INVALID';
+  return backendStatus === 'ready' ? 'READY' : 'SMOKE CHECKED';
+}
+
+const _CHECK_LABELS = {
+  command_syntax:    'command syntax',
+  cli_entrypoint:    'CLI entrypoint',
+  referenced_files:  'referenced repo files',
+  docker_entrypoint: 'Docker metadata',
+  required_env_vars: 'required env vars',
+};
+
+// Compact, copy-pasteable result -- the literal STATUS word plus just enough
+// to forward to someone else. Additive to the detailed report above it;
+// does not replace it. Never prints "Verified" -- SMOKE CHECKED is the
+// ceiling for this free path.
+function _printCopySummary(result, flags, chalk, caseData) {
+  const e = result.extraction || {};
+  const status = _statusWord(result, flags.smoke);
+
+  console.log(`  ${chalk.bold(`STATUS: ${status}`)}`);
+  console.log();
+
+  if (status === 'NEEDS INFO') {
+    // Static incompatibilities and missing-information both mean "no
+    // command yet" -- whichever fired is the reason to surface here.
+    const reasons = result.static_incompatibilities?.length
+      ? result.static_incompatibilities
+      : (e.missing_information || []);
+    console.log(`  ${chalk.bold('Missing:')}`);
+    for (const r of reasons) console.log(`  - ${r}`);
+    console.log();
+    return;
+  }
+
+  // The prepared case's canonical `badgr ...` command (the exact line
+  // --approve would run) is preferred over the raw source command --
+  // /confirm can only compute it once a case exists (READY/SMOKE CHECKED),
+  // and only when there's enough evidence to convert (see
+  // _canonical_badgr_command's docstring, backend/run_issue_routes.py, for
+  // what it can't yet convert, e.g. training/ComfyUI). Falls back to the
+  // raw extracted command otherwise -- still true and still runnable input,
+  // just not guaranteed to already be `badgr`-shaped.
+  const badgrJob = caseData?.findings?.canonical_command || e.commands?.[0] || '(no command produced)';
+  console.log(`  ${chalk.bold('Badgr job:')}`);
+  console.log(`  ${badgrJob}`);
+  console.log();
+
+  if (caseData?.case_id) {
+    console.log(`  ${chalk.bold('Run:')}`);
+    console.log(`  ${chalk.cyan(_runPageUrl(caseData.case_id))}`);
+    console.log();
+  }
+
+  if (status === 'SMOKE CHECKED' || status === 'INVALID') {
+    console.log(`  ${chalk.bold('Checks:')}`);
+    const iconFor = (s) => (s === 'pass' ? '✓' : s === 'fail' ? '✗' : '-');
+    for (const check of (e.mechanical_checks || [])) {
+      console.log(`  ${iconFor(check.status)} ${_CHECK_LABELS[check.name] || check.name}`);
+    }
+    const localPaths = _localPathCandidates(e);
+    if (!localPaths.length) {
+      console.log('  - local file check skipped');
+    } else {
+      const allExist = localPaths.every((p) => fs.existsSync(p));
+      console.log(`  ${allExist ? '✓' : '✗'} local file check${allExist ? '' : ' (not found)'}`);
+    }
+    console.log();
+    if (status === 'INVALID') {
+      console.log('  A check above actually failed -- this command is not runnable as-is.');
+    } else {
+      console.log('  Not GPU-verified.');
+    }
+    console.log();
+  }
+}
+
+// --smoke's mechanical checks: prints the backend's evidence-backed
+// pass/fail/skip results (`extraction.mechanical_checks`, computed for
+// free from data already gathered by /run-issue/extract -- no extra
+// network call), plus this machine's own local-file existence check.
+// Deliberately never prints "Verified" -- see AGENTS.md §12; a genuinely
+// passing smoke check still only earns "Smoke Checked".
+function _printSmokeChecks(result, chalk) {
+  const e = result.extraction || {};
+  const mech = e.mechanical_checks || [];
+  const localPaths = _localPathCandidates(e);
+
+  console.log();
+  console.log(`  ${chalk.bold('Smoke Checked (free, no GPU, no login):')}`);
+
+  const icon = (status) => (
+    status === 'pass' ? chalk.green('✓') : status === 'fail' ? chalk.red('✗') : chalk.dim('-')
+  );
+  for (const check of mech) {
+    console.log(`    ${icon(check.status)} ${chalk.dim(`[${check.name}]`)} ${check.detail}`);
+  }
+  for (const p of localPaths) {
+    const exists = fs.existsSync(p);
+    console.log(`    ${exists ? chalk.green('✓') : chalk.red('✗')} ${chalk.dim('[local_file]')} ${p} ${exists ? 'exists on this machine' : 'NOT FOUND on this machine'}`);
+  }
+  if (!mech.length && !localPaths.length) {
+    console.log(`    ${chalk.dim('No mechanical checks applicable to this input.')}`);
+  }
+
+  const proofLevel = e.smoke_check?.proof_level;
+  if (proofLevel === 'smoke_checked') {
+    console.log(`    ${chalk.green('✓')} ${chalk.dim('[command_scope]')} Command is the repository/image/service's own documented default.`);
+  }
+  console.log();
+}
+
+function _confirmBodyFromExtraction(e) {
+  return {
     workload_type:              e.workload_type || 'generic',
     docker_image:               e.docker_images?.[0] || null,
     model_id:                   e.models?.[0] || null,
@@ -221,23 +417,39 @@ async function _doApprove(config, result, chalk) {
                                   : e.gpu_requirements || null,
     source_summary:             e.summary || null,
   };
+}
 
-  let caseData;
+function _runPageUrl(caseId) {
+  return `https://aibadgr.com/run-issue?case_id=${caseId}`;
+}
+
+// Creates the free, anonymous "prepared run" case that backs a shareable
+// Run Link -- the exact same /run-issue/confirm call and case object
+// /run-issue's own confirm step creates, so the CLI and the web page never
+// diverge on what a given diagnosis resolves to. No GPU, no login, no
+// payment -- confirm only ever inspects and plans (see its own docstring).
+// Called once per diagnosis (main flow), then reused by --approve below
+// instead of confirming a second time.
+//
+// Returns `{ caseData }` on success, `{ error }` on a network/API failure --
+// never throws, since a plain diagnosis must still succeed even if the
+// free run-page creation itself fails.
+async function _createRunPage(config, e, chalk) {
   try {
-    console.log(chalk.dim('  Creating case...'));
-    caseData = await callApi('/run-issue/confirm', {
+    const caseData = await callApi('/run-issue/confirm', {
       method:    'POST',
       apiKey:    config.apiKey || '',
       baseUrl:   config.baseUrl,
-      body:      confirmBody,
+      body:      _confirmBodyFromExtraction(e),
       timeoutMs: 20_000,
     });
+    return caseData?.case_id ? { caseData } : { caseData: null };
   } catch (err) {
-    console.error(chalk.red(`\n  ✗ Could not create case: ${err.message}\n`));
-    process.exitCode = 1;
-    return;
+    return { error: err };
   }
+}
 
+async function _doApprove(config, caseData, chalk) {
   const { case_id: caseId, status, test_plan: plan, missing_information: missing } = caseData;
 
   if (status === 'incompatible') {
@@ -386,6 +598,31 @@ async function _diagnoseExistingCase(config, caseId, flags, chalk) {
     for (const m of caseData.missing_information) console.log(`    ? ${m}`);
   }
 
+  // "Verified" is only ever earned here -- a case whose real GPU run
+  // actually completed (`lead_summary.status`, computed server-side by
+  // `_build_lead_summary` from `ReproCase.status`/`final_command`). Never
+  // reachable from --smoke, which never provisions anything.
+  console.log();
+  const existingStatus = caseData.lead_summary?.status === 'verified'
+    || caseData.status === 'verified' || caseData.status === 'completed'
+    ? 'VERIFIED'
+    : (caseData.missing_information || []).length ? 'NEEDS INFO' : 'READY';
+  console.log(`  ${chalk.bold(`STATUS: ${existingStatus}`)}`);
+  if (existingStatus === 'VERIFIED') {
+    console.log();
+    console.log(`  ${chalk.bold('Command:')}`);
+    console.log(`  ${caseData.final_command || caseData.known_command}`);
+    console.log();
+    console.log(`  ${chalk.bold('Result:')}`);
+    const resultLines = caseData.lead_summary?.test_checklist?.length
+      ? caseData.lead_summary.test_checklist
+      : ['Verified'];
+    for (const line of resultLines) console.log(`  - ${line}`);
+    if (caseData.actual_cost_aud != null) {
+      console.log(`  Verified on Badgr for AUD $${Number(caseData.actual_cost_aud).toFixed(2)}. GPU torn down after the test.`);
+    }
+  }
+
   console.log();
   if (caseData.free_verification_consumed) {
     console.log(`  ${chalk.dim('This case\'s free run has already been used — further verification is normal billing.')}`);
@@ -420,6 +657,7 @@ export async function diagnoseCommand(config, args, chalk) {
     if (a === '--comfyui')  { flags.comfyui = args[++i]; i++; continue; }
     if (a === '--github')   { flags.github  = args[++i]; i++; continue; }
     if (a === '--approve')  { flags.approve = true;  i++; continue; }
+    if (a === '--smoke')    { flags.smoke   = true;  i++; continue; }
     if (a === '--json')     { flags.json    = true;  i++; continue; }
     if (!a.startsWith('-') && positional === null) positional = a;
     i++;
@@ -474,20 +712,87 @@ export async function diagnoseCommand(config, args, chalk) {
     return;
   }
 
+  const status = _statusWord(result, flags.smoke);
+
+  // A command that's actually runnable also gets a free prepared Run
+  // page -- the same case /run-issue's own confirm step would create --
+  // so diagnosis ends at a page someone can click Run on, not just a
+  // printed command. Only READY and SMOKE CHECKED qualify: NEEDS INFO has
+  // nothing runnable to save yet, and INVALID is a command a real check
+  // just proved broken -- turning that into a clickable "Run" page would
+  // contradict the label. Both print their own guidance instead (Missing:
+  // / the failed check) and stop there.
+  let caseData = null;
+  let caseError = null;
+  if (status === 'READY' || status === 'SMOKE CHECKED') {
+    const created = await _createRunPage(config, result.extraction || {}, chalk);
+    if (created.error) caseError = created.error;
+    else caseData = created.caseData;
+  }
+
   if (flags.json) {
-    console.log(JSON.stringify({ detected: detected.kind, ...result }, null, 2));
+    const output = { detected: detected.kind, ...result, status };
+    if (flags.smoke) {
+      const e = result.extraction || {};
+      output.smoke = {
+        mechanical_checks: e.mechanical_checks || [],
+        local_file_checks: _localPathCandidates(e).map(p => ({ path: p, exists: fs.existsSync(p) })),
+      };
+    }
+    if (caseData?.case_id) {
+      output.run = {
+        case_id: caseData.case_id,
+        url: _runPageUrl(caseData.case_id),
+        canonical_command: caseData.findings?.canonical_command || null,
+      };
+    }
+    console.log(JSON.stringify(output, null, 2));
+
+    // --json must not silently skip --approve -- the JSON branch used to
+    // return here unconditionally, so a scripted `--approve --json` call
+    // never claimed/approved/launched anything (bug: approval was silently
+    // dropped in the one output mode automation actually uses). Approval
+    // output itself stays human-readable (chalk console lines), matching
+    // _diagnoseExistingCase's existing --json + --approve behaviour below.
+    if (flags.approve) {
+      if (caseError) {
+        console.error(chalk.red(`\n  ✗ Could not create case: ${caseError.message}\n`));
+        process.exitCode = 1;
+        return;
+      }
+      if (!caseData) {
+        console.error(chalk.yellow('\n  Cannot approve — missing information above.\n'));
+        return;
+      }
+      await _doApprove(config, caseData, chalk);
+    }
     return;
   }
 
   console.log();
   _printResult(result, chalk);
 
+  if (flags.smoke) {
+    _printSmokeChecks(result, chalk);
+  }
+
   console.log();
+  _printCopySummary(result, flags, chalk, caseData);
+
   console.log(chalk.dim('  Free diagnosis. No GPU was provisioned.'));
   console.log(chalk.dim('  Full interactive flow: https://aibadgr.com/run-issue'));
   console.log();
 
   if (flags.approve) {
-    await _doApprove(config, result, chalk);
+    if (caseError) {
+      console.error(chalk.red(`\n  ✗ Could not create case: ${caseError.message}\n`));
+      process.exitCode = 1;
+      return;
+    }
+    if (!caseData) {
+      console.log(chalk.yellow('\n  Cannot approve — missing information above.\n'));
+      return;
+    }
+    await _doApprove(config, caseData, chalk);
   }
 }

package/src/commands/serve.js

@@ -357,9 +357,10 @@ export async function serveCommand(config, args, chalk) {
   const { model, flags } = parseServeArgs(args);
   const customImage = flags.image || null;
   const isLlamaCpp = flags.runtime === 'llama.cpp';
+  const isOllama = flags.runtime === 'ollama';
 
   // Expand blessed alias (qwen-7b, llama-8b, qwen-coder-7b) to full model ID + GPU.
-  const vllmAlias = model && !customImage && !isLlamaCpp ? BLESSED_VLLM_MODELS[model] : null;
+  const vllmAlias = model && !customImage && !isLlamaCpp && !isOllama ? BLESSED_VLLM_MODELS[model] : null;
   const effectiveModel = vllmAlias ? vllmAlias.model_id : model;
 
   // Detect flags that ended up as positional args due to broken shell line continuation
@@ -564,6 +565,7 @@ export async function serveCommand(config, args, chalk) {
     return {
       ...(effectiveModel ? { model: effectiveModel } : {}),
       ...(isLlamaCpp ? { image: LLAMA_CPP_IMAGE } : customImage ? { image: customImage } : {}),
+      ...(isOllama ? { runtime: 'ollama' } : {}),
       ...(flags.task ? { task: flags.task } : {}),
       gpu: gpuOverride || gpu,
       gpu_count: flags.count || 1,
@@ -649,7 +651,9 @@ export async function serveCommand(config, args, chalk) {
   }
 
   // ── Determine health check path ───────────────────────────────────────────
-  const resolvedHealthPath = _resolveHealthPath({ healthPath: flags.healthPath, isLlamaCpp, customImage, task: flags.task });
+  const resolvedHealthPath = isOllama
+    ? (flags.healthPath || '/api/tags')
+    : _resolveHealthPath({ healthPath: flags.healthPath, isLlamaCpp, customImage, task: flags.task });
 
   // Gated-model guidance is only shown when it's actually needed — on failure —
   // not up front, so common launches stay short and uncluttered.
@@ -770,7 +774,13 @@ export async function serveCommand(config, args, chalk) {
   console.log();
   console.log(chalk.dim('  Billing continues until you run: ') + chalk.cyan(`badgr down ${dep.deployment_id}`));
 
-  if (endpointReady && !customImage) {
+  if (endpointReady && isOllama) {
+    console.log(`  ${chalk.bold('Test with curl:')}`);
+    console.log(chalk.dim(`    curl ${endpointUrl}/api/generate \\`));
+    console.log(chalk.dim(`      -H "Content-Type: application/json" \\`));
+    console.log(chalk.dim(`      -d '{"model":"${dep.model || effectiveModel}","prompt":"Hello","stream":false}'`));
+    console.log();
+  } else if (endpointReady && !customImage) {
     // dep.endpoint_api_key is a per-endpoint key generated for this deployment
     // (vLLM model serves only) — shown exactly once, here. Falls back to the
     // account-wide key (truncated) for serves that don't get one yet

package/src/errors.js

@@ -17,7 +17,12 @@ export const CATALOG = {
   // ── Capacity ──────────────────────────────────────────────────────────────
 
   NO_CAPACITY: {
+    // Prefer the backend's specific detail (e.g. "CPU launch is not
+    // configured on this backend (missing HETZNER_API_TOKEN)") over the
+    // generic template — a real config/provider reason is far more
+    // actionable than "not available right now" when that's not why.
     message: (ctx) =>
+      ctx.server_message ||
       `No ${ctx.gpu || 'GPU'} available${ctx.region ? ` in ${ctx.region}` : ''} right now.`,
     billing:  'never_started',
     retried:  false,

package/src/fallback.js

@@ -93,7 +93,10 @@ export async function callWithFallback(endpoint, callOpts, buildBody, effectiveT
     if (key) {
       const ctx = {
         gpu:              d.filters?.gpu ?? d.gpu,
-        region:           d.filters?.region,
+        // Server uses the literal string "any" as a filters.region placeholder
+        // when no region was requested — don't surface that as if the user
+        // had actually asked for a region named "any" (e.g. "in any right now").
+        region:           d.filters?.region && d.filters.region !== 'any' ? d.filters.region : undefined,
         failure_category: d.failure_category,
         low_cost_failed:  d.low_cost_provider_failed,
         server_message:   d.message,