badgr-cli 1.0.41 → 1.0.43

package/README.md

@@ -66,10 +66,14 @@ badgr down <deployment-id>
 **Shortcuts** — wrappers around `run` / `serve` for common workloads:
 
 | `badgr comfyui run <workflow.json>` | Launch ComfyUI, queue workflow, return endpoint URL |
+| `badgr comfyui batch --workflow ...` | Productized batch image generation — no ComfyUI setup, blessed workflow only |
 | `badgr train <config.yaml>` | LoRA / fine-tuning job, stream logs |
+| `badgr train lora --base-model ...` | Productized LoRA training — preset + dataset, no config file needed |
 | `badgr transcribe <audio>` | Whisper transcription, print transcript |
 | `badgr embed <model> <input>` | Text embeddings, output JSONL |
 
+`badgr serve --list-aliases` lists the blessed vLLM model shortcuts (`qwen-7b`, `llama-8b`, `qwen-coder-7b`) that can be used in place of a full model ID.
+
 ---
 
 ## `badgr serve` options
@@ -91,6 +95,9 @@ badgr serve meta-llama/Llama-3.1-8B-Instruct --gpu L40S --region EU
 | `--max-cost <$>` | — | Auto-stop when total spend reaches this amount |
 | `--health-path <path>` | auto | Readiness path to poll (auto-detected for ComfyUI → `/system_stats`) |
 | `--no-wait` | — | Skip endpoint health check and return immediately |
+| `--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.
 
 ---
 
@@ -153,13 +160,39 @@ Requires either `--max-cost` or `--persistent` to prevent runaway billing.
 
 ---
 
+## `badgr comfyui batch` options
+
+Productized batch image generation — runs a list of prompts through a **blessed** ComfyUI workflow and returns image URLs. No ComfyUI setup, no workflow file, no manual teardown.
+
+```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
+```
+
+Blessed workflows: `sdxl-basic` (SDXL text-to-image, default sampler settings). Max 20 prompts per batch.
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--workflow <name>` | — | Blessed workflow ID (required) — currently `sdxl-basic` |
+| `--prompts <file>` | — | Text file, one prompt per line |
+| `--prompt <text>` | — | Inline prompt (repeatable) — combine with `--prompts` if needed |
+| `--max-cost <$>` | — | Auto-stop when total spend reaches this amount (required unless `--dry-run`) |
+| `--max-runtime <min>` | 60 | Auto-stop after N minutes |
+| `--gpu-type <type>` | workflow default | GPU type override |
+| `--tier 1\|2` | 1 | Provider tier |
+| `--dry-run` | — | Preview the batch (workflow, GPU, prompt count, cost) without provisioning |
+
+Polls until complete and prints image URLs, or detaches with `badgr status` guidance if it outlives `--max-runtime`.
+
+---
+
 ## `badgr train` options
 
 ```bash
 badgr train config.yaml --gpu A100 --max-runtime 240 --env HF_TOKEN=$HF_TOKEN
 ```
 
-Auto-detects framework (axolotl, unsloth, trl) from config content. Default max-runtime is 120 min.
+Detects framework (axolotl, unsloth, trl) from config content, but **only Axolotl configs run today** — the container command for `unsloth`/`trl`/unrecognized configs isn't wired up yet, so `badgr train` blocks before provisioning rather than billing a GPU that's guaranteed to fail. Use `--framework axolotl` to force it, or use `badgr train lora` for a config-free productized path. Default max-runtime is 120 min.
 
 | Flag | Default | Description |
 |------|---------|-------------|
@@ -169,12 +202,46 @@ Auto-detects framework (axolotl, unsloth, trl) from config content. Default max-
 | `--max-price <$/hr>` | — | Hard spend cap per GPU-hour |
 | `--tier 1\|2` | 1 | Provider tier |
 | `--region US\|EU\|AU` | — | Region preference |
-| `--framework <name>` | auto-detect | Force framework: `axolotl`, `unsloth`, `trl` |
+| `--framework <name>` | auto-detect | Force framework: `axolotl`, `unsloth`, `trl` (only `axolotl` currently runs) |
 | `--env KEY=VALUE` | — | Environment variable (repeatable) |
 | `--detach` | — | Launch and return immediately, don't stream logs |
 
 ---
 
+## `badgr train lora` options
+
+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.
+
+```bash
+badgr train lora --base-model mistralai/Mistral-7B-v0.1 --dataset ./train.jsonl --preset small --max-cost 20
+badgr train lora --base-model meta-llama/Llama-3.1-8B-Instruct --dataset https://example.com/data.jsonl --preset medium --max-cost 40
+```
+
+Dataset sources: local file (uploaded first), direct URL (`https://`, `s3://`), or `--file-id` from a prior `badgr` upload.
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--base-model <id>` | — | HuggingFace model ID (required) — 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` | Training profile — see below |
+| `--max-cost <$>` | — | Auto-stop when total spend reaches this amount (required unless `--dry-run`) |
+| `--max-runtime <min>` | 240 | Auto-stop after N minutes |
+| `--gpu-type <type>` | preset default | GPU type override |
+| `--tier 1\|2` | 1 | Provider tier |
+| `--dry-run` | — | Preview the job (preset, GPU, rank, epochs, cost) without provisioning |
+
+**Presets:**
+
+| Preset | GPU | LoRA rank | Epochs | Best for |
+|--------|-----|-----------|--------|----------|
+| `small` (default) | RTX 4090 | 16 | 3 | Fast, low-cost — good default for most datasets |
+| `medium` | A100 | 32 | 5 | Larger rank/more epochs — bigger datasets or higher quality |
+
+On completion, prints an `adapter_url` — download with `GET /v1/jobs/{job_id}/adapter`, or via `badgr workload info` if saved.
+
+---
+
 ## `badgr transcribe` options
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "badgr-cli",
-  "version": "1.0.41",
+  "version": "1.0.43",
   "description": "Badgr — run or serve GPU workloads from one command",
   "type": "module",
   "bin": {
@@ -13,6 +13,7 @@
   },
   "dependencies": {
     "@inquirer/prompts": "^8.5.2",
+    "archiver": "^7.0.1",
     "chalk": "^5.3.0"
   },
   "devDependencies": {

package/src/badgr.js

@@ -42,12 +42,15 @@ ${chalk.bold('COMMANDS')}
 
 ${chalk.bold('SHORTCUTS')}  ${chalk.dim('(wrappers around run / serve for common workloads)')}
   ${chalk.cyan('badgr comfyui run <workflow.json>')}   Launch ComfyUI, return endpoint URL
+  ${chalk.cyan('badgr comfyui batch --workflow ...')}  Blessed-workflow batch image gen (no ComfyUI setup needed)
   ${chalk.cyan('badgr train <config.yaml>')}           LoRA / fine-tuning job, stream logs
+  ${chalk.cyan('badgr train lora --base-model ...')}   Productized LoRA training (preset + dataset, no config file)
   ${chalk.cyan('badgr transcribe <audio>')}            Whisper transcription, print transcript
   ${chalk.cyan('badgr embed <model> <input>')}         Text embeddings, output JSONL
   ${chalk.cyan('badgr serve template <name>')}         Launch an endpoint template (vllm, invokeai, comfyui, …)
   ${chalk.cyan('badgr run   template <name>')}         Launch a job template (axolotl, unsloth)
   ${chalk.cyan('badgr template list')}                 Browse all pre-built templates
+  ${chalk.cyan('badgr serve --list-aliases')}          List blessed vLLM model shortcuts (qwen-7b, llama-8b, …)
 
 ${chalk.bold('EXAMPLES')}
   ${chalk.dim('# Verify the stack works end-to-end:')}

package/src/catalog.js

@@ -442,6 +442,44 @@ export const TEMPLATES = [
 
 export const TEMPLATE_MAP = Object.fromEntries(TEMPLATES.map(t => [t.name, t]));
 
+// ---------------------------------------------------------------------------
+// Productized runner catalogs
+// ---------------------------------------------------------------------------
+
+/** Blessed vLLM model aliases. `badgr serve qwen-7b` expands to the full model ID. */
+export const BLESSED_VLLM_MODELS = {
+  'qwen-7b': {
+    model_id:    'Qwen/Qwen2.5-7B-Instruct',
+    gpu_type:    'RTX_4090',
+    image:       'vllm/vllm-openai:latest',
+    health_path: '/v1/models',
+    description: 'Qwen 2.5 7B Instruct — fast, multilingual',
+  },
+  'llama-8b': {
+    model_id:    'meta-llama/Llama-3.1-8B-Instruct',
+    gpu_type:    'RTX_4090',
+    image:       'vllm/vllm-openai:latest',
+    health_path: '/v1/models',
+    description: 'Llama 3.1 8B Instruct — Meta flagship 8B',
+  },
+  'qwen-coder-7b': {
+    model_id:    'Qwen/Qwen2.5-Coder-7B-Instruct',
+    gpu_type:    'RTX_4090',
+    image:       'vllm/vllm-openai:latest',
+    health_path: '/v1/models',
+    description: 'Qwen 2.5 Coder 7B — code generation specialist',
+  },
+};
+
+/** Blessed ComfyUI workflows accepted by `POST /v1/jobs` comfy.batch. */
+export const BLESSED_COMFY_WORKFLOWS = {
+  'sdxl-basic': {
+    description: 'SDXL text-to-image with default sampler settings',
+    gpu_type:    'RTX_4090',
+    output_type: 'images',
+  },
+};
+
 /**
  * Build the args array passed to serveCommand / runCommand.
  * Template defaults are applied first; CLI overrides win.

package/src/commands/comfyui.js

@@ -11,6 +11,7 @@ import { callApi, listDeployments } from '../api.js';
 import { addDeployment, addReceipt, updateReceipt, generateReceiptId } from '../store.js';
 import { normalizeTier, callWithFallback, HIGH_RATE_THRESHOLD } from '../fallback.js';
 import { formatCliError } from '../errors.js';
+import { BLESSED_COMFY_WORKFLOWS } from '../catalog.js';
 
 const COMFYUI_IMAGE   = process.env.COMFYUI_IMAGE || 'yanwk/comfyui-boot:cu126-megapak';
 const HEALTH_PATH     = '/system_stats';
@@ -110,11 +111,169 @@ async function validateComfyNodes(endpointUrl, nodeList, chalk) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// badgr comfyui batch — productized batch via POST /v1/jobs comfy.batch
+// ---------------------------------------------------------------------------
+
+export function parseComfyBatchArgs(args) {
+  const flags = {};
+  let i = 0;
+  while (i < args.length) {
+    const a = args[i];
+    if (a === '--workflow')    { flags.workflow = args[++i]; i++; continue; }
+    if (a === '--prompts')     { flags.prompts = args[++i]; i++; continue; }
+    if (a === '--prompt')      { if (!flags.inlinePrompts) flags.inlinePrompts = []; flags.inlinePrompts.push(args[++i]); i++; continue; }
+    if (a === '--max-cost')    { flags.maxCost = parseFloat(args[++i]); i++; continue; }
+    if (a === '--max-runtime') { flags.maxRuntime = parseFloat(args[++i]); i++; continue; }
+    if (a === '--tier')        { flags.tier = args[++i]; i++; continue; }
+    if (a === '--gpu-type')    { flags.gpuType = args[++i]; i++; continue; }
+    if (a === '--dry-run')     { flags.dryRun = true; i++; continue; }
+    i++;
+  }
+  return flags;
+}
+
+export async function comfyBatchCommand(config, args, chalk) {
+  const { readFileSync, existsSync } = await import('fs');
+  const { callApi } = await import('../api.js');
+  const { addReceipt, generateReceiptId } = await import('../store.js');
+  const flags = parseComfyBatchArgs(args);
+
+  if (!flags.workflow) {
+    console.error(chalk.red('\n  Usage: badgr comfyui batch --workflow sdxl-basic --prompts prompts.txt --max-cost 10\n'));
+    console.error(chalk.dim('  Runs a batch of prompts through a blessed ComfyUI workflow and returns image URLs.\n'));
+    console.error(chalk.dim('  Blessed workflows: sdxl-basic\n'));
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!flags.maxCost && !flags.dryRun) {
+    console.error(chalk.red('\n  ✗ --max-cost is required.\n'));
+    process.exitCode = 1;
+    return;
+  }
+
+  // Collect prompts from file or --prompt flags
+  let prompts = flags.inlinePrompts || [];
+  if (flags.prompts) {
+    if (!existsSync(flags.prompts)) {
+      console.error(chalk.red(`\n  ✗ Prompts file not found: ${flags.prompts}\n`));
+      process.exitCode = 1;
+      return;
+    }
+    const lines = readFileSync(flags.prompts, 'utf8')
+      .split('\n')
+      .map(l => l.trim())
+      .filter(Boolean);
+    prompts = prompts.concat(lines);
+  }
+
+  if (flags.dryRun) {
+    const workflowSpec = BLESSED_COMFY_WORKFLOWS[flags.workflow];
+    console.log(chalk.bold('\n⚡ Dry run — no GPU will be provisioned\n'));
+    console.log(`  ${chalk.bold('Workflow:')}     ${flags.workflow}${workflowSpec ? '' : chalk.yellow(' (unknown — server will reject this)')}`);
+    if (workflowSpec) {
+      console.log(`  ${chalk.bold('GPU:')}          ${flags.gpuType || workflowSpec.gpu_type}`);
+      console.log(`  ${chalk.dim(workflowSpec.description)}`);
+    }
+    console.log(`  ${chalk.bold('Prompts:')}      ${prompts.length}${prompts.length > 20 ? chalk.yellow(' (exceeds the 20-prompt limit — server will reject this)') : ''}`);
+    if (flags.maxCost)    console.log(`  ${chalk.bold('Max cost:')}     $${flags.maxCost}`);
+    console.log(`  ${chalk.bold('Max runtime:')}  ${flags.maxRuntime ?? 60}min`);
+    console.log(chalk.dim('\n  Remove --dry-run to submit.\n'));
+    return;
+  }
+
+  requireApiKey(config);
+
+  if (prompts.length === 0) {
+    console.error(chalk.red('\n  ✗ No prompts provided. Use --prompts file.txt or --prompt "text"\n'));
+    process.exitCode = 1;
+    return;
+  }
+
+  if (prompts.length > 20) {
+    console.error(chalk.red(`\n  ✗ Max 20 prompts per batch (got ${prompts.length})\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  const input = { workflow_id: flags.workflow, prompts };
+  if (flags.gpuType) input.gpu_type = flags.gpuType;
+
+  const rcptId = generateReceiptId();
+  const maxRuntime = flags.maxRuntime ?? 60;
+
+  console.log(chalk.bold('\n⚡ Starting ComfyUI batch\n'));
+  console.log(`  ${chalk.bold('Workflow:')}   ${flags.workflow}`);
+  console.log(`  ${chalk.bold('Prompts:')}    ${prompts.length}`);
+  console.log(`  ${chalk.bold('Max cost:')}   $${flags.maxCost}`);
+  console.log(`  ${chalk.bold('Max runtime:')} ${maxRuntime} min\n`);
+
+  let job;
+  try {
+    job = await callApi('/jobs', {
+      method: 'POST',
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl,
+      body: {
+        type: 'comfy.batch',
+        input,
+        policy: { max_cost: flags.maxCost, max_runtime_minutes: maxRuntime, tier: flags.tier },
+      },
+    });
+  } catch (err) {
+    console.error(chalk.red(`\n  ✗ Failed to submit job: ${err.message}\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  addReceipt({ id: rcptId, type: 'comfy.batch', job_id: job.job_id, started_at: Date.now() });
+  console.log(`  ${chalk.bold('Job ID:')}  ${job.job_id}`);
+  console.log(`  ${chalk.bold('Receipt:')} ${chalk.dim(rcptId)}`);
+  console.log(chalk.dim('\n  Polling for completion…\n'));
+
+  const startMs = Date.now();
+  const maxMs = maxRuntime * 60 * 1000;
+  while (Date.now() - startMs < maxMs) {
+    await new Promise(r => setTimeout(r, 15_000));
+    let detail;
+    try {
+      detail = await callApi(`/jobs/${job.job_id}`, {
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+      });
+    } catch { continue; }
+    process.stdout.write(`\r  Status: ${detail.status}  elapsed: ${Math.floor((Date.now() - startMs) / 1000)}s  `);
+    if (detail.status === 'completed') {
+      const out = detail.output || {};
+      console.log(chalk.green('\n\n  ✓ Batch complete\n'));
+      if (out.image_urls && out.image_urls.length > 0) {
+        console.log(`  ${chalk.bold('Images (${out.image_urls.length}):')}`);
+        out.image_urls.forEach((url, i) => console.log(`    ${i + 1}. ${url}`));
+      }
+      console.log(`\n  ${chalk.bold('Receipt:')} ${chalk.dim(rcptId)}\n`);
+      return;
+    }
+    if (detail.status === 'failed') {
+      console.error(chalk.red(`\n\n  ✗ Batch failed: ${detail.error_code || ''} — ${detail.error_message || ''}\n`));
+      process.exitCode = 1;
+      return;
+    }
+  }
+  console.error(chalk.yellow('\n\n  Batch still running — detached. Check status:\n'));
+  console.error(chalk.dim(`    badgr status\n`));
+}
+
 export async function comfyuiCommand(config, args, chalk) {
+  // Route subcommands
+  const sub = args[0];
+  if (sub === 'batch') return comfyBatchCommand(config, args.slice(1), chalk);
+
   const { workflow, flags } = parseComfyuiArgs(args);
 
   if (!workflow) {
     console.error(chalk.red('\n  Usage: badgr comfyui run workflow.json\n'));
+    console.error(chalk.dim('  Batch mode: badgr comfyui batch --workflow sdxl-basic --prompts prompts.txt --max-cost 10\n'));
     console.error(chalk.dim('  Launches ComfyUI, queues your workflow, and returns the URL.\n'));
     process.exitCode = 1;
     return;

package/src/commands/run.js

@@ -383,11 +383,10 @@ function _isGitHubUrl(arg) {
 
 /**
  * Zip a local directory into a temp file, returning the temp file path.
- * Uses Node's built-in APIs — no external zip library required.
+ * Uses the `archiver` package so the CLI never depends on a system `zip`
+ * binary being present (Windows, minimal containers, etc).
  */
 async function _zipDirectory(dirPath, chalk) {
-  // Use archiver if available, otherwise fall back to a manual approach via
-  // a child process calling `zip` (available on Linux/macOS) or PowerShell on Windows.
   const absDir = path.resolve(dirPath);
   if (!fs.existsSync(absDir)) {
     throw new Error(`Directory not found: ${absDir}`);
@@ -395,37 +394,19 @@ async function _zipDirectory(dirPath, chalk) {
 
   const tmpFile = path.join(os.tmpdir(), `badgr-upload-${Date.now()}.zip`);
 
-  // Attempt to use archiver (optional peer dep) first; fall back to system zip.
-  try {
-    const { default: archiver } = await import('archiver');
-    await new Promise((resolve, reject) => {
-      const output = createWriteStream(tmpFile);
-      const archive = archiver('zip', { zlib: { level: 6 } });
-      output.on('close', resolve);
-      archive.on('error', reject);
-      archive.pipe(output);
-      archive.glob('**/*', {
-        cwd: absDir,
-        dot: false,
-        ignore: [..._ZIP_EXCLUDES].map(e => `**/${e}/**`).concat([..._ZIP_EXCLUDES].map(e => e)),
-      });
-      archive.finalize();
-    });
-    return tmpFile;
-  } catch {
-    // archiver not installed — fall back to system zip command
-  }
-
-  const { spawn } = await import('child_process');
+  const { default: archiver } = await import('archiver');
   await new Promise((resolve, reject) => {
-    // Build exclude args — zip uses -x patterns
-    const excludeArgs = [];
-    for (const ex of _ZIP_EXCLUDES) {
-      excludeArgs.push('-x', `*/${ex}/*`, '-x', `${ex}/*`, '-x', `${ex}`);
-    }
-    const child = spawn('zip', ['-r', '-q', tmpFile, '.', ...excludeArgs], { cwd: absDir });
-    child.on('close', code => code === 0 ? resolve() : reject(new Error(`zip exited ${code}`)));
-    child.on('error', reject);
+    const output = createWriteStream(tmpFile);
+    const archive = archiver('zip', { zlib: { level: 6 } });
+    output.on('close', resolve);
+    archive.on('error', reject);
+    archive.pipe(output);
+    archive.glob('**/*', {
+      cwd: absDir,
+      dot: false,
+      ignore: [..._ZIP_EXCLUDES].map(e => `**/${e}/**`).concat([..._ZIP_EXCLUDES].map(e => e)),
+    });
+    archive.finalize();
   });
 
   return tmpFile;

package/src/commands/serve.js

@@ -3,7 +3,7 @@ import { callApi, listDeployments } from '../api.js';
 import { addDeployment, addReceipt, updateReceipt, generateReceiptId } from '../store.js';
 import { normalizeTier, callWithFallback, HIGH_RATE_THRESHOLD } from '../fallback.js';
 import { formatCliError } from '../errors.js';
-import { TEMPLATE_MAP, buildTemplateFlags, parseTemplateOverrides } from '../catalog.js';
+import { TEMPLATE_MAP, buildTemplateFlags, parseTemplateOverrides, BLESSED_VLLM_MODELS } from '../catalog.js';
 
 const LLAMA_CPP_IMAGE = 'michaelmanleyx/llama-cpp:server-cuda';
 
@@ -42,6 +42,7 @@ export function parseServeArgs(args) {
     if (args[i] === '--runtime')  { flags.runtime = args[++i]; i++; continue; }
     if (args[i] === '--hf-repo') { flags.hfRepo = args[++i]; i++; continue; }
     if (args[i] === '--hf-file') { flags.hfFile = args[++i]; i++; continue; }
+    if (args[i] === '--list-aliases') { flags.listAliases = true; i++; continue; }
     if (args[i] === '--env') {
       const kv = args[++i]; i++;
       if (!flags.env) flags.env = [];
@@ -97,20 +98,17 @@ function _inferGgufProfile(ggufPath) {
   return                                      { label: 'GGUF inference (36B+, llama.cpp)',      vram: '48+ GB', gpus: ['A6000', 'L40S', 'A100'] };
 }
 
-function _serveStageLabel(elapsedSec, healthPath = '/models') {
-  if (healthPath === '/models') {
-    if (elapsedSec < 45)  return 'Starting vLLM…';
-    if (elapsedSec < 150) return 'Downloading model…';
-    return 'Waiting for /v1/models…';
+// Label derived from the backend's real readiness signal (readiness_reason),
+// not a fixed timer — the timer only breaks ties when we have no signal yet.
+function _serveStageLabel(elapsedSec, healthPath, readinessReason) {
+  switch (readinessReason) {
+    case 'port_unreachable': return 'Waiting for container to start…';
+    case 'http_404':         return 'Model loading — waiting for the API to come up…';
+    case 'http_error':       return `Waiting for ${healthPath || 'endpoint'} (non-200 response)…`;
+    default: break;
   }
-  if (healthPath === '/health') {
-    if (elapsedSec < 60)  return 'Starting server…';
-    if (elapsedSec < 180) return 'Downloading model…';
-    return 'Waiting for /health…';
-  }
-  if (elapsedSec < 30)  return 'Starting container…';
-  if (elapsedSec < 120) return 'Container starting…';
-  return `Waiting for ${healthPath}…`;
+  if (elapsedSec < 30) return 'Starting container…';
+  return `Waiting for ${healthPath || 'endpoint'}…`;
 }
 
 function _detectHealthPath(image) {
@@ -121,16 +119,21 @@ function _detectHealthPath(image) {
 }
 
 /**
- * Poll the model endpoint until /models returns 200, or timeout.
- * Also checks deployment status on each iteration — fails fast if the dep is dead.
+ * Wait for the deployment's app-level endpoint to become ready by polling Badgr's
+ * own deployment status (GET /deployments/{id}) — never the RunPod proxy/pod
+ * directly. The backend does the real health_path probing (see
+ * DeploymentService.check_endpoint_readiness); a pod reporting RUNNING only
+ * means infrastructure is up, not that the app inside is serving.
  * Returns { ready: boolean, timedOut: boolean, depFailed: boolean, failReason?: string }
  */
-async function waitForEndpoint(endpointUrl, deploymentId, config, timeoutMs = 5 * 60 * 1000, chalk, healthPath = '/models') {
+// vLLM cold start (model download + load) often exceeds 5 min on first boot.
+const VLLM_SERVE_WAIT_MS = 15 * 60 * 1000;
+
+async function waitForEndpoint(deploymentId, config, timeoutMs = VLLM_SERVE_WAIT_MS, chalk, healthPath = '/models') {
   const startMs  = Date.now();
   const deadline = startMs + timeoutMs;
 
   while (Date.now() < deadline) {
-    // Check deployment status first — fail fast on OOM/crash before waiting more
     try {
       const dep = await callApi(`/deployments/${deploymentId}`, {
         apiKey: config.apiKey,
@@ -139,23 +142,19 @@ async function waitForEndpoint(endpointUrl, deploymentId, config, timeoutMs = 5
       });
       if (['failed', 'terminated', 'error', 'stopped'].includes(dep.status)) {
         process.stdout.write('\n');
-        return { ready: false, timedOut: false, depFailed: true, failReason: dep.error || dep.status };
+        return { ready: false, timedOut: false, depFailed: true, failReason: dep.fix_hint || dep.error || dep.status };
       }
+      if (dep.endpoint_ready) {
+        process.stdout.write('\n');
+        return { ready: true, timedOut: false, depFailed: false };
+      }
+      const elapsed = Math.round((Date.now() - startMs) / 1000);
+      process.stdout.write(
+        `\r  ${chalk.dim(_serveStageLabel(elapsed, dep.health_path || healthPath, dep.readiness_reason) + ` (${elapsed}s)`)}   `
+      );
     } catch {
-      // status check failed — continue to endpoint check
-    }
-
-    try {
-      const res = await fetch(`${endpointUrl}${healthPath}`, { signal: AbortSignal.timeout(8000) });
-      if (res.ok) { process.stdout.write('\n'); return { ready: true, timedOut: false, depFailed: false }; }
-    } catch {
-      // still starting
+      // status check failed (transient network/API issue) — retry next tick
     }
-
-    const elapsed = Math.round((Date.now() - startMs) / 1000);
-    process.stdout.write(
-      `\r  ${chalk.dim(_serveStageLabel(elapsed, healthPath) + ` (${elapsed}s)`)}   `
-    );
     await new Promise(r => setTimeout(r, 8000));
   }
 
@@ -217,10 +216,25 @@ export async function serveCommand(config, args, chalk) {
     return serveCommand(config, expandedArgs, chalk);
   }
 
+  if (args.includes('--list-aliases')) {
+    console.log(chalk.bold('\n⚡ Blessed vLLM aliases\n'));
+    console.log(chalk.dim('  Use any of these in place of a full model ID: badgr serve <alias>\n'));
+    for (const [alias, spec] of Object.entries(BLESSED_VLLM_MODELS)) {
+      console.log(`  ${chalk.cyan(alias.padEnd(16))}  ${spec.model_id}`);
+      console.log(`  ${''.padEnd(16)}  ${chalk.dim(spec.description)}`);
+    }
+    console.log();
+    return;
+  }
+
   const { model, flags } = parseServeArgs(args);
   const customImage = flags.image || null;
   const isLlamaCpp = flags.runtime === 'llama.cpp';
 
+  // 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 effectiveModel = vllmAlias ? vllmAlias.model_id : model;
+
   // Detect flags that ended up as positional args due to broken shell line continuation
   // (e.g. `\ ` with a trailing space instead of `\<newline>`).
   // After parseServeArgs, only the model name should be in positional. Any extra token
@@ -293,7 +307,9 @@ export async function serveCommand(config, args, chalk) {
 
   const envObj = parseEnvFlag(flags.env);
 
-  const gpu = flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : (customImage ? 'L40S' : 'AUTO');
+  const gpu = flags.gpu
+    ? flags.gpu.toUpperCase().replace('-', '_')
+    : (vllmAlias ? vllmAlias.gpu_type : (customImage ? 'L40S' : 'AUTO'));
   const gpuLabel = gpu === 'AUTO' ? 'auto' : gpu;
 
   const effectiveTier = normalizeTier(flags.tier);
@@ -319,13 +335,17 @@ export async function serveCommand(config, args, chalk) {
     if (flags.env?.length) console.log(`  ${chalk.bold('Env:')}    ${flags.env.join(', ')}`);
   } else {
     console.log(chalk.bold('\n⚡ Serving model\n'));
-    console.log(`  ${chalk.bold('Model:')}  ${model}`);
+    if (vllmAlias) {
+      console.log(`  ${chalk.bold('Alias:')}  ${model}  ${chalk.dim(`→ ${effectiveModel}`)}`);
+    } else {
+      console.log(`  ${chalk.bold('Model:')}  ${effectiveModel}`);
+    }
     console.log(`  ${chalk.bold('GPU:')}    ${gpuLabel}`);
     if (flags.task) console.log(`  ${chalk.bold('Task:')}   ${flags.task}`);
     if (flags.env?.length) console.log(`  ${chalk.bold('Env:')}    ${flags.env.join(', ')}`);
 
     if (gpu === 'AUTO') {
-      const prof = _inferServeProfile(model);
+      const prof = _inferServeProfile(effectiveModel);
       console.log();
       console.log(`  ${chalk.bold('Estimated workload:')}      ${prof.label}`);
       console.log(`  ${chalk.bold('Estimated minimum VRAM:')}  ${prof.vram}`);
@@ -348,7 +368,7 @@ export async function serveCommand(config, args, chalk) {
         ACTIVE.has(d.status) &&
         d.workload_type === 'endpoint' &&
         (
-          (model && d.model === model) ||
+          (effectiveModel && d.model === effectiveModel) ||
           (customImage && d.image === customImage) ||
           (isLlamaCpp && d.image === LLAMA_CPP_IMAGE &&
            d.env?.LLAMA_ARG_HF_REPO === flags.hfRepo && d.env?.LLAMA_ARG_HF_FILE === flags.hfFile)
@@ -381,7 +401,7 @@ export async function serveCommand(config, args, chalk) {
       ? { LLAMA_ARG_HF_REPO: flags.hfRepo, LLAMA_ARG_HF_FILE: flags.hfFile, ...envObj }
       : envObj;
     return {
-      ...(model ? { model } : {}),
+      ...(effectiveModel ? { model: effectiveModel } : {}),
       ...(isLlamaCpp ? { image: LLAMA_CPP_IMAGE } : customImage ? { image: customImage } : {}),
       ...(flags.task ? { task: flags.task } : {}),
       gpu: gpuOverride || gpu,
@@ -392,6 +412,7 @@ export async function serveCommand(config, args, chalk) {
       tier: tierOverride || effectiveTier,
       ...(Object.keys(effectiveEnv).length > 0 ? { env: effectiveEnv } : {}),
       ...(flags.maxCost ? { max_cost_usd: flags.maxCost } : {}),
+      ...(flags.healthPath ? { health_path: flags.healthPath } : {}),
     };
   }
 
@@ -424,7 +445,7 @@ export async function serveCommand(config, args, chalk) {
     id:          dep.deployment_id,
     name:        dep.name,
     type:        'endpoint',
-    model:       dep.model || model,
+    model:       dep.model || effectiveModel,
     gpu:         dep.gpu_type,
     count:       dep.gpu_count,
     status:      dep.status,
@@ -510,7 +531,7 @@ export async function serveCommand(config, args, chalk) {
       // status check failed — proceed with endpoint poll anyway
     }
 
-    const healthResult = await waitForEndpoint(endpointUrl, dep.deployment_id, config, 5 * 60 * 1000, chalk, resolvedHealthPath);
+    const healthResult = await waitForEndpoint(dep.deployment_id, config, VLLM_SERVE_WAIT_MS, chalk, resolvedHealthPath);
     process.stdout.write('\n');
 
     if (healthResult.depFailed) {
@@ -556,7 +577,7 @@ export async function serveCommand(config, args, chalk) {
     console.log(`  ${chalk.bold('HF Repo:')}      ${flags.hfRepo}`);
     console.log(`  ${chalk.bold('HF File:')}      ${flags.hfFile}`);
   }
-  else if (dep.model || model) console.log(`  ${chalk.bold('Model:')}        ${dep.model || model}`);
+  else if (dep.model || effectiveModel) console.log(`  ${chalk.bold('Model:')}        ${dep.model || effectiveModel}`);
   if (customImage)        console.log(`  ${chalk.bold('Image:')}        ${customImage}`);
   console.log(`  ${chalk.bold('GPU:')}          ${dep.gpu_type} × ${dep.gpu_count}`);
   if (serveRate > 0) console.log(`  ${chalk.bold('Rate:')}         $${serveRate.toFixed(2)}/hr`);
@@ -574,7 +595,7 @@ export async function serveCommand(config, args, chalk) {
 
   if (endpointReady && !customImage) {
     const keySnip = config.apiKey?.slice(0, 4) || 'sk-...';
-    const sdkModel = isLlamaCpp ? 'default' : (dep.model || model);
+    const sdkModel = isLlamaCpp ? 'default' : (dep.model || effectiveModel);
     console.log(`  ${chalk.bold('Use with OpenAI SDK:')}`);
     console.log(chalk.dim(`    from openai import OpenAI`));
     console.log(chalk.dim(`    client = OpenAI(base_url="${endpointUrl}", api_key="${keySnip}...")`));