badgr-cli 1.0.42 → 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.42",
+  "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/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

@@ -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

@@ -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,6 +216,17 @@ 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';
@@ -402,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 } : {}),
     };
   }
 
@@ -520,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) {

package/src/commands/train.js

@@ -21,6 +21,17 @@ const TRAINING_IMAGES = {
   generic: 'nvidia/cuda:12.1.0-cudnn8-devel-ubuntu22.04',
 };
 
+// Container command per framework — must match what's actually installed in
+// TRAINING_IMAGES[framework]. A framework with no entry here has no known
+// working command and is blocked in trainCommand() rather than guessed at,
+// since a wrong guess still provisions (and bills) the GPU before failing.
+const TRAINING_COMMANDS = {
+  axolotl: 'echo "$TRAIN_CONFIG_B64" | base64 -d > /tmp/config.yaml && axolotl train /tmp/config.yaml',
+  // huggingface/trl-source ships the `trl` CLI (trl sft|dpo|kto --config <yaml>).
+  // We default to `sft` — the common case for a plain base_model+dataset config.
+  trl:     'echo "$TRAIN_CONFIG_B64" | base64 -d > /tmp/config.yaml && trl sft --config /tmp/config.yaml',
+};
+
 // Preferred GPUs for training: VRAM-heavy workloads.
 const TRAINING_GPUS = ['A100', 'H100', 'L40S', 'A6000'];
 
@@ -104,11 +115,18 @@ export function parseTrainLoraArgs(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;
 }
 
+// Mirror of backend LORA_PRESETS (jobs_routes.py) — display only, server is authoritative.
+export const LORA_PRESET_INFO = {
+  small:  { gpu_type: 'RTX_4090', rank: 16, epochs: 3, description: 'Fast, low-cost — good default for most datasets' },
+  medium: { gpu_type: 'A100',     rank: 32, epochs: 5, description: 'Larger rank/more epochs — bigger datasets or higher quality' },
+};
+
 export async function trainLoraCommand(config, args, chalk) {
   const { callApi } = await import('../api.js');
   const { addReceipt, generateReceiptId } = await import('../store.js');
@@ -124,12 +142,31 @@ export async function trainLoraCommand(config, args, chalk) {
     return;
   }
 
-  if (!flags.maxCost) {
+  if (!flags.maxCost && !flags.dryRun) {
     console.error(chalk.red('\n  ✗ --max-cost is required to cap GPU spend.\n'));
     process.exitCode = 1;
     return;
   }
 
+  if (flags.dryRun) {
+    const preset = flags.preset || 'small';
+    const presetInfo = LORA_PRESET_INFO[preset];
+    console.log(chalk.bold('\n⚡ Dry run — no GPU will be provisioned\n'));
+    console.log(`  ${chalk.bold('Base model:')}   ${flags.baseModel}`);
+    console.log(`  ${chalk.bold('Dataset:')}      ${flags.fileId || flags.dataset || chalk.dim('(none given)')}`);
+    console.log(`  ${chalk.bold('Preset:')}       ${preset}${presetInfo ? '' : chalk.yellow(' (unknown — server will reject this)')}`);
+    if (presetInfo) {
+      console.log(`  ${chalk.bold('GPU:')}          ${flags.gpuType || presetInfo.gpu_type}`);
+      console.log(`  ${chalk.bold('LoRA rank:')}    ${presetInfo.rank}`);
+      console.log(`  ${chalk.bold('Epochs:')}       ${presetInfo.epochs}`);
+      console.log(`  ${chalk.dim(presetInfo.description)}`);
+    }
+    if (flags.maxCost)    console.log(`  ${chalk.bold('Max cost:')}     $${flags.maxCost}`);
+    console.log(`  ${chalk.bold('Max runtime:')}  ${flags.maxRuntime ?? 240}min`);
+    console.log(chalk.dim('\n  Remove --dry-run to submit (local file datasets are uploaded first).\n'));
+    return;
+  }
+
   requireApiKey(config);
 
   // Build dataset input field
@@ -147,11 +184,23 @@ export async function trainLoraCommand(config, args, chalk) {
       return;
     }
     console.log(chalk.dim(`\n  Uploading dataset ${flags.dataset}…`));
-    const FormData = (await import('formdata-node')).FormData;
-    const { fileFromPath } = await import('formdata-node/file-from-path');
+    const { readFileSync: readDs } = await import('fs');
+    const fileData = readDs(flags.dataset);
     const form = new FormData();
-    form.set('file', await fileFromPath(flags.dataset));
-    const uploadResp = await callApi(config, 'POST', '/v1/uploads', null, form);
+    form.append('file', new Blob([fileData]), flags.dataset.split('/').pop() || 'dataset.jsonl');
+    const baseUrl = config.baseUrl.replace(/\/v1\/?$/, '');
+    const uploadRes = await fetch(`${baseUrl}/v1/uploads`, {
+      method: 'POST',
+      body: form,
+      headers: { Authorization: `Bearer ${config.apiKey}` },
+    });
+    if (!uploadRes.ok) {
+      const text = await uploadRes.text().catch(() => '');
+      console.error(chalk.red(`\n  ✗ Dataset upload failed: ${uploadRes.status}${text ? ` — ${text}` : ''}\n`));
+      process.exitCode = 1;
+      return;
+    }
+    const uploadResp = await uploadRes.json();
     input.dataset_file_id = uploadResp.upload_id;
     console.log(chalk.dim(`  Uploaded: ${uploadResp.upload_id}`));
   }
@@ -169,10 +218,15 @@ export async function trainLoraCommand(config, args, chalk) {
 
   let job;
   try {
-    job = await callApi(config, 'POST', '/v1/jobs', {
-      type: 'train.lora',
-      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: 'train.lora',
+        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`));
@@ -191,7 +245,12 @@ export async function trainLoraCommand(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 || {};
@@ -287,12 +346,27 @@ export async function trainCommand(config, args, chalk) {
   console.log(`  ${chalk.bold('Max runtime:')} ${runtimeLabel}`);
   if (maxCost) console.log(`  ${chalk.bold('Max cost:')}    $${maxCost.toFixed(2)}`);
   console.log();
+
+  // Block before provisioning: TRAINING_IMAGES[framework] and the container
+  // command must be a matched pair, or the job burns GPU time and then fails
+  // (e.g. an axolotl `train` binary that doesn't exist in the unsloth image).
+  const trainCmd = TRAINING_COMMANDS[framework];
+  if (!trainCmd) {
+    console.error(chalk.red(`  ✗ No runnable command for framework '${framework}' — refusing to provision a GPU that will fail.\n`));
+    console.error(chalk.dim(`    '${image}' does not have a known working entrypoint for this config yet.`));
+    console.error(chalk.dim(`    Options:`));
+    console.error(chalk.dim(`      --framework axolotl   force Axolotl (it has native Unsloth-optimization support via config keys)`));
+    console.error(chalk.dim(`      badgr train lora ...  use the productized LoRA path instead\n`));
+    process.exitCode = 1;
+    return;
+  }
+
   process.stdout.write(chalk.dim('  Finding suitable capacity...\n'));
 
   function buildBody(tierOverride) {
     return {
       image,
-      command: ['sh', '-c', 'echo "$TRAIN_CONFIG_B64" | base64 -d > /tmp/config.yaml && axolotl train /tmp/config.yaml'],
+      command: ['sh', '-c', trainCmd],
       gpu,
       gpu_count:          1,
       ...(flags.region ? { region: flags.region.toUpperCase() } : {}),