badgr-cli 1.0.42 → 1.0.44

package/README.md

@@ -66,10 +66,26 @@ 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 tested vLLM model routes (`qwen-7b`, `llama-8b`, `qwen-coder-7b`) that can be used in place of a full model ID.
+
+### 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, with the CLI honest (but brief) about what that means:
+
+| Level | What it means |
+|-------|---------------|
+| **Tested route** (`badgr serve qwen-7b`) | One of the aliases above — tested and officially supported. No extra caveats printed. |
+| **Best-effort Hugging Face model** (`badgr serve <org>/<model>`) | Any other Hugging Face model ID. Badgr will try a compatible route — not a guarantee every model works. |
+| **Custom container** (`badgr serve --image ...`) | You own the server behavior; Badgr manages runtime, logs, spend caps, teardown, and the receipt. |
+
+Gated Hugging Face models (e.g. Llama, Gemma) may need `--env HF_TOKEN=$HF_TOKEN`. Badgr doesn't warn about this up front — it only prints the hint if the deployment actually fails to start, so tested and working launches stay short.
+
 ---
 
 ## `badgr serve` options
@@ -91,6 +107,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 +172,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 +214,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.42",
+  "version": "1.0.44",
   "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

@@ -471,6 +471,21 @@ export const BLESSED_VLLM_MODELS = {
   },
 };
 
+// Hugging Face org/model prefixes that are known to gate access behind a license
+// click-through. Used only to print a helpful HF_TOKEN hint — not exhaustive.
+const GATED_MODEL_PREFIXES = [
+  'meta-llama/',
+  'google/gemma',
+  'mistralai/Mistral-Large',
+  'mistralai/Mixtral-8x22B',
+];
+
+/** Best-effort heuristic: is this HF model ID likely to require HF_TOKEN? */
+export function isLikelyGatedModel(modelId) {
+  if (!modelId) return false;
+  return GATED_MODEL_PREFIXES.some(prefix => modelId.startsWith(prefix));
+}
+
 /** Blessed ComfyUI workflows accepted by `POST /v1/jobs` comfy.batch. */
 export const BLESSED_COMFY_WORKFLOWS = {
   'sdxl-basic': {

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';
@@ -126,6 +127,7 @@ export function parseComfyBatchArgs(args) {
     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;
@@ -145,14 +147,12 @@ export async function comfyBatchCommand(config, args, chalk) {
     return;
   }
 
-  if (!flags.maxCost) {
+  if (!flags.maxCost && !flags.dryRun) {
     console.error(chalk.red('\n  ✗ --max-cost is required.\n'));
     process.exitCode = 1;
     return;
   }
 
-  requireApiKey(config);
-
   // Collect prompts from file or --prompt flags
   let prompts = flags.inlinePrompts || [];
   if (flags.prompts) {
@@ -168,6 +168,23 @@ export async function comfyBatchCommand(config, args, chalk) {
     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;
@@ -194,10 +211,15 @@ export async function comfyBatchCommand(config, args, chalk) {
 
   let job;
   try {
-    job = await callApi(config, 'POST', '/v1/jobs', {
-      type: 'comfy.batch',
-      input,
-      policy: { max_cost: flags.maxCost, max_runtime_minutes: maxRuntime, tier: flags.tier },
+    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`));
@@ -215,7 +237,12 @@ export async function comfyBatchCommand(config, args, chalk) {
   while (Date.now() - startMs < maxMs) {
     await new Promise(r => setTimeout(r, 15_000));
     let detail;
-    try { detail = await callApi(config, 'GET', `/v1/jobs/${job.job_id}`); } catch { continue; }
+    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 || {};

package/src/commands/run.js

@@ -8,6 +8,7 @@ import { 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 { stage as _stage, stageDone as _stageDone, writeBlock as _writeBlock, clearBlock as _clearBlock, renderLiveBlock as _renderLiveBlock } from '../progress.js';
 
 /**
  * Flow 1 — local project (primary):
@@ -105,6 +106,20 @@ const HEARTBEAT_WARN_POLLS  = 3;
 const HEARTBEAT_KILL_POLLS  = 15;
 const STARTUP_STATES = new Set(['queued', 'provisioning', 'starting']);
 
+// Shared closing block for every terminal path (success, failure, cap, heartbeat loss) —
+// always states exit code (when known), whether teardown/billing succeeded, and how to
+// pull the receipt, so the user is never left guessing what happened.
+function _printFinalInfo(chalk, { exitCode = undefined, teardownOk, jobId, rcptId, logsAvailable = true }) {
+  if (exitCode !== null && exitCode !== undefined) {
+    console.log(`  ${chalk.bold('Exit code:')} ${exitCode !== 0 ? chalk.red(exitCode) : chalk.green(exitCode)}`);
+  }
+  console.log(`  ${chalk.bold('Teardown:')}  ${teardownOk ? chalk.green('succeeded') : chalk.red(`failed — run: badgr down ${jobId}`)}`);
+  console.log(`  ${chalk.bold('Billing:')}   ${teardownOk ? 'stopped' : 'unconfirmed — check receipt'}`);
+  if (logsAvailable) console.log(`  ${chalk.bold('Logs:')}      badgr logs ${jobId}`);
+  console.log(`  ${chalk.bold('Job ID:')}    ${jobId}`);
+  console.log(`  ${chalk.bold('Receipt:')}   badgr receipts ${rcptId}`);
+}
+
 export function classifyFailure(finalStatus, exitCode) {
   if (finalStatus === 'failed' && (exitCode === null || exitCode === undefined)) return 'infrastructure';
   if (exitCode !== null && exitCode !== undefined && exitCode !== 0) return 'customer_code';
@@ -128,24 +143,6 @@ function parseProviderLine(line) {
   };
 }
 
-function renderStatusBar(chalk, { elapsedMs, ratePerHour, gpuUtil, cpuUtil, maxRuntimeMs, maxCost }) {
-  const spent = ratePerHour * (elapsedMs / 3_600_000);
-  const parts = [`⏱ ${fmtRuntime(elapsedMs)}`];
-  if (ratePerHour > 0) parts.push(`$${spent.toFixed(4)} spent`);
-  if (gpuUtil !== null) parts.push(`GPU ${gpuUtil.toFixed(0)}%`);
-  if (cpuUtil !== null) parts.push(`CPU ${cpuUtil.toFixed(0)}%`);
-  if (maxRuntimeMs) {
-    const left = Math.max(0, maxRuntimeMs - elapsedMs);
-    parts.push(`${fmtRuntime(left)} left`);
-  }
-  if (maxCost && ratePerHour > 0) {
-    const budgetLeft = Math.max(0, maxCost - spent);
-    parts.push(`$${budgetLeft.toFixed(4)} budget left`);
-  }
-  parts.push('Ctrl+C to stop');
-  return chalk.dim('  ' + parts.join('  •  '));
-}
-
 // Wait for status to leave 'starting'/'queued'/'provisioning'.
 // Returns the dep once it leaves startup states (or the last known state on timeout).
 async function waitForRunning(config, depId, chalk) {
@@ -200,7 +197,7 @@ async function waitForRunning(config, depId, chalk) {
   });
 }
 
-async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost = null, ratePerHour = 0, onTeardown, isShuttingDown }) {
+async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost = null, ratePerHour = 0, onTeardown, isShuttingDown, stageLine }) {
   const TERMINAL = new Set(['stopped', 'failed', 'completed', 'succeeded']);
   const POLL_MS  = 4000;
   let seenContent     = new Set();
@@ -209,7 +206,8 @@ async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost
   let gpuUtil         = null;
   let cpuUtil         = null;
   let sshShown        = false;
-  let statusBarActive = false;
+  let statusWord      = 'running';
+  let blockLines      = 0;
   const startMs       = Date.now();
 
   // tearing: guards against double-teardown for cap/heartbeat paths within this function.
@@ -218,17 +216,17 @@ async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost
   let tickerInterval = null;
   const startTicker = () => {
     if (tickerInterval) return;
-    statusBarActive = true;
     tickerInterval = setInterval(() => {
-      const bar = renderStatusBar(chalk, {
-        elapsedMs: Date.now() - startMs, ratePerHour, gpuUtil, cpuUtil, maxRuntimeMs, maxCost,
-      });
-      process.stdout.write(`\r${bar}   `);
+      const elapsedSec = Math.round((Date.now() - startMs) / 1000);
+      const spend = ratePerHour * (elapsedSec / 3600);
+      blockLines = _writeBlock(blockLines, _renderLiveBlock(chalk, {
+        stageLine, elapsedSec, statusWord, spend, id: depId,
+      }));
     }, 1000);
   };
   const stopTicker = () => {
     if (tickerInterval) { clearInterval(tickerInterval); tickerInterval = null; }
-    if (statusBarActive) { process.stdout.write('\r\x1b[2K'); statusBarActive = false; }
+    if (blockLines > 0) { _clearBlock(blockLines); blockLines = 0; }
   };
 
   try {
@@ -271,6 +269,7 @@ async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost
         consecutiveErrs++;
         if (lastStatus === 'running') {
           const lostSec = Math.round((consecutiveErrs * POLL_MS) / 1000);
+          if (consecutiveErrs >= HEARTBEAT_WARN_POLLS) statusWord = 'stuck';
           if (consecutiveErrs === HEARTBEAT_WARN_POLLS) {
             stopTicker();
             console.log(chalk.yellow(`\n  ⚠ No heartbeat for ${lostSec}s — cloud machine may be unresponsive`));
@@ -293,6 +292,7 @@ async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost
         }
         lastStatus = status;
       }
+      if (status === 'running') statusWord = seenContent.size === 0 ? 'no logs yet' : 'running';
 
       try {
         const logData = await callApi(`/deployments/${depId}/logs`, {
@@ -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;
@@ -624,14 +605,14 @@ export async function runCommand(config, args, chalk) {
   if (flags.cmd)    console.log(`  ${chalk.bold('Command:')}  ${flags.cmd}`);
   if (command)      console.log(`  ${chalk.bold('Command:')}  ${command.join(' ')}`);
   if (image)        console.log(`  ${chalk.bold('Image:')}    ${image}`);
-  if (gpu)          console.log(`  ${chalk.bold('GPU:')}      ${gpu}`);
-  else              console.log(`  ${chalk.bold('GPU:')}      ${chalk.dim('auto')}`);
+  if (flags.gpu)    console.log(`  ${chalk.bold('GPU:')}      ${gpu}`);
   if (flags.minVram)  console.log(`  ${chalk.bold('Min VRAM:')}   ${flags.minVram} GB`);
   const runtimeLabel = isDefaultRuntime
-    ? `${effectiveMaxRuntime}min ${chalk.dim('(default — use --max-runtime N to override)')}`
-    : `${effectiveMaxRuntime}min`;
+    ? `${effectiveMaxRuntime} min ${chalk.dim('(default — use --max-runtime N to override)')}`
+    : `${effectiveMaxRuntime} min`;
+  console.log(`  ${chalk.bold('Max cost:')}    ${maxCost ? `$${maxCost.toFixed(2)}` : chalk.dim('none')}`);
   console.log(`  ${chalk.bold('Max runtime:')} ${runtimeLabel}`);
-  if (maxCost)        console.log(`  ${chalk.bold('Max cost:')}    $${maxCost.toFixed(2)}`);
+  console.log(`  ${chalk.bold('Auto-stop:')}   ${maxCost ? 'enabled' : chalk.yellow('disabled — stop manually with badgr down')}`);
   if (flags.maxPrice) console.log(`  ${chalk.bold('Max price:')}   $${flags.maxPrice.toFixed(2)}/hr`);
   if (detach)         console.log(`  ${chalk.dim('(detached — returns immediately)')}`);
   if (flags.env?.length) console.log(`  ${chalk.bold('Env:')}      ${flags.env.join(', ')}`);
@@ -655,6 +636,10 @@ export async function runCommand(config, args, chalk) {
     }
   }
 
+  // Total stages: local-path runs get a "Preparing upload" stage the others don't.
+  const STAGE_TOTAL = isLocalPath ? 5 : 4;
+  let stageN = 1;
+
   // ── Upload local project zip (Flow 1) ─────────────────────────────────────
   let codeUri = null;
   if (isLocalPath) {
@@ -665,9 +650,10 @@ export async function runCommand(config, args, chalk) {
       process.exitCode = 1;
       return;
     }
+    console.log(chalk.dim(_stageDone(stageN, STAGE_TOTAL, 'Preparing upload...')));
+    stageN++;
   }
 
-  console.log(chalk.dim('  Finding suitable capacity...'));
   if (process.env.BADGR_DEBUG === '1' || process.env.BADGR_DEBUG === 'true') {
     console.log(chalk.dim(`  API: ${config.baseUrl}`));
   }
@@ -736,12 +722,10 @@ export async function runCommand(config, args, chalk) {
 
   const rate = dep.cost_per_hour || 0;
 
-  console.log(chalk.dim('  Capacity found.\n'));
-  console.log(chalk.bold(`  Job ID:    ${chalk.cyan(dep.deployment_id)}`));
-  console.log(`  ${chalk.bold('GPU:')}      ${dep.gpu_type} × ${dep.gpu_count}`);
-  if (rate > 0) console.log(`  ${chalk.bold('Rate:')}     $${rate.toFixed(2)}/hr`);
-  if (maxCost)  console.log(`  ${chalk.bold('Max cost:')} $${maxCost.toFixed(2)}`);
-  console.log(`  ${chalk.bold('Receipt:')}  ${chalk.dim(rcptId)}`);
+  console.log(chalk.dim(_stageDone(stageN, STAGE_TOTAL, 'Finding a working route...')));
+  stageN++;
+  console.log(chalk.dim(_stageDone(stageN, STAGE_TOTAL, 'Starting runtime...')));
+  stageN++;
 
   if (rate > HIGH_RATE_THRESHOLD && !maxCost) {
     console.log(chalk.yellow(`\n  Selected capacity rate: $${rate.toFixed(2)}/hr`));
@@ -764,30 +748,34 @@ export async function runCommand(config, args, chalk) {
     if (teardownCalled) return;
     teardownCalled = true;
 
-    const labels = {
-      'max-runtime':    chalk.yellow('\n  ⏱ Max runtime reached — stopping job...'),
-      'max-cost':       chalk.yellow('\n  💰 Spend cap reached — stopping job...'),
-      'heartbeat-lost': chalk.red('\n  ✗ No response from machine — stopping job...'),
-      'interrupted':    chalk.yellow('\n  Stopping job...'),
+    const stageLabels = {
+      'max-runtime':    'Stopped — runtime cap reached',
+      'max-cost':       'Stopped — spend cap reached',
+      'heartbeat-lost': 'Failed — lost connection to machine',
+      'interrupted':    'Stopped',
     };
-    console.log(labels[reason] ?? chalk.yellow('\n  Stopping job...'));
 
+    let teardownOk = true;
     try {
       await terminateDeployment(config, dep.deployment_id);
     } catch {
       // terminateDeployment retries 3×; best-effort if all fail
+      teardownOk = false;
     }
 
     const runtimeMs = Date.now() - attachStart;
     const finalCost = ratePerHour * (runtimeMs / 3_600_000);
     updateReceipt(rcptId, {
       status: reason,
-      teardownStatus: 'terminated',
+      teardownStatus: teardownOk ? 'terminated' : 'failed',
       runtimeSeconds: Math.round(runtimeMs / 1000),
       finalCost,
     });
-    console.log(chalk.dim(`  Runtime: ${fmtRuntime(runtimeMs)}  •  Est. cost: $${finalCost.toFixed(4)}`));
-    console.log(chalk.dim('  Job stopped. Billing ended.\n'));
+    console.log();
+    console.log(chalk.dim(_stage(STAGE_TOTAL, STAGE_TOTAL, stageLabels[reason] ?? 'Stopped')));
+    console.log(chalk.dim(`  Runtime: ${fmtRuntime(runtimeMs)}  •  Estimated cost: ~$${finalCost.toFixed(2)}`));
+    _printFinalInfo(chalk, { exitCode: null, teardownOk, jobId: dep.deployment_id, rcptId });
+    console.log();
   }
 
   // ── SIGINT handler — installed immediately after we have a deployment ID ───
@@ -821,7 +809,8 @@ export async function runCommand(config, args, chalk) {
     return;
   }
 
-  console.log(chalk.dim('\n  ── Running command (Ctrl+C to stop) ────────────────────────────\n'));
+  const runStageLine = _stage(stageN, STAGE_TOTAL, 'Running command...');
+  console.log(chalk.dim(`\n  [${stageN}/${STAGE_TOTAL}] Running command (Ctrl+C to stop)`));
 
   attachStart = Date.now();
   const { status: finalStatus, exitCode, runtimeMs, failureType } = await attachToJob(config, dep.deployment_id, {
@@ -831,6 +820,7 @@ export async function runCommand(config, args, chalk) {
     ratePerHour,
     onTeardown: teardown,
     isShuttingDown: () => shuttingDown,
+    stageLine: runStageLine,
   });
 
   // Remove SIGINT handler — job is done (or SIGINT was handled)
@@ -839,7 +829,11 @@ export async function runCommand(config, args, chalk) {
   // 'interrupted' = SIGINT handler is managing teardown + exit — don't duplicate
   if (finalStatus === 'interrupted') return;
 
-  console.log();
+  // 'capped' = max-runtime or max-cost path; teardown() already printed the full summary
+  if (finalStatus === 'capped') {
+    process.exitCode = 1;
+    return;
+  }
 
   const finalCost = ratePerHour * (runtimeMs / 3_600_000);
   updateReceipt(rcptId, {
@@ -851,20 +845,7 @@ export async function runCommand(config, args, chalk) {
     teardownStatus: (finalStatus === 'completed' || finalStatus === 'succeeded') ? 'terminated' : 'failed',
   });
 
-  console.log(`  ${chalk.bold('Runtime:')}  ${fmtRuntime(runtimeMs)}`);
-  if (ratePerHour > 0) {
-    console.log(`  ${chalk.bold('Cost:')}     $${finalCost.toFixed(4)}  (${chalk.dim(`$${ratePerHour.toFixed(2)}/hr`)})`);
-  }
-  if (exitCode !== null && exitCode !== undefined) {
-    console.log(`  ${chalk.bold('Exit code:')} ${exitCode !== 0 ? chalk.red(exitCode) : chalk.green(exitCode)}`);
-  }
-  console.log(`  ${chalk.bold('Receipt:')}  ${chalk.dim(rcptId)}`);
-
-  // 'capped' = max-runtime or max-cost path; teardown message already printed
-  if (finalStatus === 'capped') {
-    process.exitCode = 1;
-    return;
-  }
+  console.log();
 
   if (finalStatus === 'failed' || (exitCode !== null && exitCode !== 0)) {
     if (failureType === 'infrastructure') {
@@ -872,16 +853,23 @@ export async function runCommand(config, args, chalk) {
     } else {
       console.error(formatCliError('JOB_FAILED', { exitCode, deploymentId: dep.deployment_id }, chalk));
     }
+    console.log(chalk.dim(_stage(STAGE_TOTAL, STAGE_TOTAL, 'Failed')));
+    console.log(chalk.dim(`  Runtime: ${fmtRuntime(runtimeMs)}  •  Estimated cost: ~$${finalCost.toFixed(2)}`));
+    // The container already reached a terminal state on the provider side by the
+    // time we observe it here, so billing is already stopped — no extra teardown call needed.
+    _printFinalInfo(chalk, { exitCode, teardownOk: true, jobId: dep.deployment_id, rcptId });
     process.exitCode = exitCode ?? 1;
     return;
   }
 
   if ((finalStatus === 'completed' || finalStatus === 'succeeded') && (exitCode === 0 || exitCode === null)) {
+    let teardownOk = true;
     try {
       await terminateDeployment(config, dep.deployment_id);
-    } catch { /* already stopped */ }
-    console.log(chalk.green(`\n  ✓ Complete`));
-    console.log(chalk.dim(`  Billing ended`));
+    } catch { teardownOk = false; /* already stopped, or best-effort */ }
+    console.log(chalk.green(_stage(STAGE_TOTAL, STAGE_TOTAL, 'Complete')));
+    console.log(chalk.dim(`  Runtime: ${fmtRuntime(runtimeMs)}  •  Estimated cost: ~$${finalCost.toFixed(2)}`));
+    _printFinalInfo(chalk, { exitCode, teardownOk, jobId: dep.deployment_id, rcptId });
 
     if (flags.save && config.apiKey) {
       try {