badgr-cli 1.0.38 → 1.0.39

package/README.md

@@ -275,7 +275,7 @@ Additional GPU types may be routable depending on current capacity — check wit
 
 Pricing is confirmed before provisioning. Use `--dry-run` to see pricing before committing.
 
-Full GPU support details: see [GPU_SUPPORT.md](../../GPU_SUPPORT.md) in the repo root.
+Full GPU support details: see [NOTES.md](../../NOTES.md#gpu-support) in the repo root.
 
 ---
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "badgr-cli",
-  "version": "1.0.38",
-  "description": "Badgr, run or serve GPU workloads from one command",
+  "version": "1.0.39",
+  "description": "DEPRECATED: Use badgr-agent CLI instead. Badgr, run or serve GPU workloads from one command",
   "type": "module",
   "bin": {
     "badgr": "src/badgr.js"
@@ -12,23 +12,21 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@inquirer/prompts": "^8.5.2",
-    "chalk": "^5.3.0"
+    "badgr-agent": "1.0.0"
   },
   "devDependencies": {
     "vitest": "^4.1.8"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.10.0"
   },
   "keywords": [
     "gpu",
     "cli",
     "ai",
     "compute",
-    "modal",
     "gateway",
     "openai"
   ],
-  "license": "MIT"
+  "license": "Apache-2.0"
 }

package/src/badgr.js

@@ -18,6 +18,8 @@ import { trainCommand }      from './commands/train.js';
 import { transcribeCommand } from './commands/transcribe.js';
 import { embedCommand }      from './commands/embed.js';
 import { templateCommand }   from './commands/template.js';
+import { workloadCommand }   from './commands/workload.js';
+import { workspaceCommand }  from './commands/workspace.js';
 
 const HELP = `
 ${chalk.bold('badgr')} — run or serve GPU workloads from one command
@@ -33,6 +35,10 @@ ${chalk.bold('COMMANDS')}
   ${chalk.cyan('badgr test')}               Run an end-to-end test (provision → run → teardown)
   ${chalk.cyan('badgr capacity')}            Check what GPU capacity is available right now
   ${chalk.cyan('badgr billing')}             Show balance and add funds
+  ${chalk.cyan('badgr workload list')}       List saved workloads
+  ${chalk.cyan('badgr workload run <name>')} Rerun a saved workload
+  ${chalk.cyan('badgr workspace list')}      List workspace trackers (job history + cost per named context)
+  ${chalk.cyan('badgr workspace create')}    Create a workspace tracker (link jobs to a named storage path)
 
 ${chalk.bold('SHORTCUTS')}  ${chalk.dim('(wrappers around run / serve for common workloads)')}
   ${chalk.cyan('badgr comfyui run <workflow.json>')}   Launch ComfyUI, return endpoint URL
@@ -147,6 +153,8 @@ async function main() {
     case 'transcribe': return transcribeCommand(config, rest, chalk);
     case 'embed':     return embedCommand(config, rest, chalk);
     case 'template':  return templateCommand(config, rest, chalk);
+    case 'workload':   return workloadCommand(config, rest, chalk);
+    case 'workspace':  return workspaceCommand(config, rest, chalk);
     // legacy aliases kept for compatibility
     case 'up':        return upCommand(config, rest, chalk);
     case 'config': {

package/src/catalog.js

@@ -9,7 +9,7 @@ export const TEMPLATES = [
     title:       'ComfyUI',
     description: 'Stable Diffusion image generation with ComfyUI node editor',
     type:        'endpoint',
-    image:       'yanwk/comfyui-boot:latest',
+    image:       process.env.COMFYUI_IMAGE || 'yanwk/comfyui-boot:cu126-megapak',
     gpu:         'RTX_4090',
     gpu_count:   1,
     port:        8188,
@@ -222,6 +222,198 @@ export const TEMPLATES = [
       'HF_TOKEN required for Llama, Gemma, and other gated models.',
     ],
   },
+  {
+    name:        'auto1111',
+    title:       'AUTOMATIC1111',
+    description: 'Stable Diffusion web UI — the largest SD ecosystem with ControlNet, LoRA, img2img, inpainting, and upscaling',
+    type:        'endpoint',
+    image:       'aidockorg/stable-diffusion-webui-cuda:latest',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    port:        7860,
+    health_path: '/',
+    min_vram_gb: 6,
+    env: {
+      WEBUI_FLAGS: '--xformers',
+    },
+    notes: [
+      'Web UI at the returned endpoint URL (port 7860).',
+      'Place model checkpoints under /opt/dl-ui/repositories/stable-diffusion-webui/models/Stable-diffusion/.',
+      'Override WEBUI_FLAGS to pass extra launch args (e.g. --medvram for lower VRAM).',
+    ],
+  },
+  {
+    name:        'forge',
+    title:       'Stable Diffusion WebUI Forge',
+    description: 'Optimised fork of A1111 with GPU memory improvements — runs models that OOM on standard A1111',
+    type:        'endpoint',
+    image:       'aidockorg/stable-diffusion-webui-forge-cuda:latest',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    port:        7860,
+    health_path: '/',
+    min_vram_gb: 4,
+    env: {
+      WEBUI_FLAGS: '--xformers',
+    },
+    notes: [
+      'Web UI at the returned endpoint URL (port 7860).',
+      'Forge uses less VRAM than A1111 for the same model — good for 8–12 GB cards.',
+      'Compatible with most A1111 extensions.',
+    ],
+  },
+  {
+    name:        'nerfstudio',
+    title:       'Nerfstudio',
+    description: 'NeRF and 3D Gaussian Splatting training and reconstruction from image captures',
+    type:        'job',
+    image:       'ghcr.io/nerfstudio-project/nerfstudio:latest',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    min_vram_gb: 16,
+    env: {
+      METHOD: 'nerfacto',
+    },
+    notes: [
+      'Mount your images to /workspace/data and your output dir to /workspace/outputs.',
+      'Override METHOD to switch between nerfacto, splatfacto, instant-ngp, etc.',
+      'Training a typical scene takes 15–45 min depending on method and image count.',
+    ],
+  },
+  {
+    name:        'openfold',
+    title:       'OpenFold',
+    description: 'Trainable, memory-efficient GPU-friendly PyTorch reproduction of AlphaFold 2 for protein structure prediction',
+    type:        'job',
+    image:       'nvidia/cuda:12.1.0-cudnn8-devel-ubuntu22.04',
+    gpu:         'A100',
+    gpu_count:   1,
+    min_vram_gb: 40,
+    env: {
+      OPENFOLD_REPO: 'https://github.com/aqlaboratory/openfold',
+    },
+    notes: [
+      'No pre-built public image exists — this uses a CUDA base; clone and install OpenFold at boot.',
+      'See https://github.com/aqlaboratory/openfold for full install steps.',
+      'Full inference on a single sequence: ~5–20 min on an A100.',
+    ],
+  },
+  {
+    name:        'blender-render',
+    title:       'Blender GPU Render',
+    description: 'Headless Blender GPU rendering via CUDA — render .blend files to image sequences or video',
+    type:        'job',
+    image:       'blenderkit/headless-blender:blender-4.4',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    min_vram_gb: 8,
+    env: {
+      BLEND_FILE: '/workspace/scene.blend',
+      FRAME_START: '1',
+      FRAME_END:   '250',
+    },
+    notes: [
+      'Mount your .blend file to /workspace/scene.blend.',
+      'Set FRAME_START and FRAME_END to the frame range to render.',
+      'Output frames are written to /workspace/output/ by default.',
+    ],
+  },
+  {
+    name:        'openmm',
+    title:       'OpenMM',
+    description: 'GPU-accelerated molecular dynamics simulation using the OpenMM toolkit',
+    type:        'job',
+    image:       'saladtechnologies/openmm:latest',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    min_vram_gb: 8,
+    env: {
+      SIMULATION_SCRIPT: '/workspace/simulate.py',
+    },
+    notes: [
+      'Mount your Python simulation script to /workspace/simulate.py.',
+      'OpenMM auto-selects CUDA platform when a GPU is present.',
+      'Typical MD simulation runs: minutes to hours depending on system size and steps.',
+    ],
+  },
+  {
+    name:        'gromacs',
+    title:       'GROMACS',
+    description: 'High-performance molecular dynamics package with GPU-accelerated bonded and non-bonded calculations',
+    type:        'job',
+    image:       'scientiflow/gromacs-gpu:2024.3',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    min_vram_gb: 8,
+    env: {
+      GMX_GPU_DD_COMMS:    'true',
+      GMX_GPU_PME_PP_COMMS: 'true',
+    },
+    notes: [
+      'Mount your .tpr input file and output directory to /workspace.',
+      'GROMACS auto-detects CUDA GPU — no extra flags needed.',
+      'For multi-GPU: increase gpu_count and pass -ntmpi / -ntomp flags via command override.',
+    ],
+  },
+  {
+    name:        'lammps',
+    title:       'LAMMPS',
+    description: 'Large-scale Atomic/Molecular Massively Parallel Simulator with GPU acceleration via Kokkos/CUDA',
+    type:        'job',
+    image:       'nvcr.io/hpc/lammps:release-29Sep2021',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    min_vram_gb: 8,
+    env: {
+      LAMMPS_INPUT: '/workspace/in.lammps',
+    },
+    notes: [
+      'Mount your LAMMPS input script to /workspace/in.lammps.',
+      'GPU acceleration uses the Kokkos or GPU package — enable via -pk gpu 1 in your input.',
+      'Simulation runtime scales with system size; use --max-runtime to cap spend.',
+    ],
+  },
+  {
+    name:        'diffusers',
+    title:       'Hugging Face Diffusers',
+    description: 'State-of-the-art diffusion model library for image, video, and audio generation',
+    type:        'job',
+    image:       'diffusers/diffusers-pytorch-cuda:latest',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    min_vram_gb: 16,
+    env: {
+      HF_TOKEN:   '<for-gated-models>',
+      MODEL_ID:   'stabilityai/stable-diffusion-xl-base-1.0',
+      SCRIPT:     '/workspace/run.py',
+    },
+    notes: [
+      'Mount your generation or training script to /workspace/run.py.',
+      'HF_TOKEN required for gated models.',
+      'Supports SDXL, FLUX, Stable Diffusion 3, ControlNet, IP-Adapter, and more.',
+    ],
+  },
+  {
+    name:        'torchtune',
+    title:       'torchtune',
+    description: 'PyTorch-native post-training library for LLM fine-tuning via config-driven YAML recipes',
+    type:        'job',
+    image:       'pytorch/pytorch:2.6.0-cuda12.4-cudnn9-devel',
+    gpu:         'A100',
+    gpu_count:   1,
+    min_vram_gb: 40,
+    env: {
+      HF_TOKEN: '<for-gated-models>',
+      RECIPE:   'lora_finetune_single_device',
+      CONFIG:   '/workspace/config.yaml',
+    },
+    notes: [
+      'Install torchtune at boot: pip install torchtune.',
+      'Mount your YAML recipe config to /workspace/config.yaml.',
+      'HF_TOKEN required for Llama and other gated base models.',
+      'Supports LoRA, QLoRA, DPO, full fine-tune, and quantisation-aware training.',
+    ],
+  },
 ];
 
 export const TEMPLATE_MAP = Object.fromEntries(TEMPLATES.map(t => [t.name, t]));

package/src/commands/comfyui.js

@@ -12,7 +12,7 @@ import { addDeployment, addReceipt, updateReceipt, generateReceiptId } from '../
 import { normalizeTier, callWithFallback, HIGH_RATE_THRESHOLD } from '../fallback.js';
 import { formatCliError } from '../errors.js';
 
-const COMFYUI_IMAGE   = 'yanwk/comfyui-boot:latest';
+const COMFYUI_IMAGE   = process.env.COMFYUI_IMAGE || 'yanwk/comfyui-boot:cu126-megapak';
 const HEALTH_PATH     = '/system_stats';
 const WAIT_TIMEOUT_MS = 10 * 60 * 1000; // 10 min — model downloads on first boot
 const MAX_WORKFLOW_B  = 1 * 1024 * 1024; // 1 MB workflow limit

package/src/commands/receipts.js

@@ -5,7 +5,8 @@ function fmtMs(ms) {
   return ms >= 1000 ? `${(ms / 1000).toFixed(1)}s` : `${ms}ms`;
 }
 
-function fmtRuntime(s) {
+export function fmtRuntime(s) {
+  if (s == null) return '—';
   if (s < 60) return `${s}s`;
   return `${Math.floor(s / 60)}m ${s % 60}s`;
 }

package/src/commands/run.js

@@ -14,32 +14,42 @@ import { TEMPLATE_MAP, buildTemplateFlags, parseTemplateOverrides } from '../cat
 export function parseRunArgs(args) {
   const flags = {};
   const positional = [];
+
+  // Split at -- so badgr flags and the user command don't collide.
+  // Everything before -- is parsed for flags; everything after becomes commandArgv.
+  const sepIdx = args.indexOf('--');
+  const flagArgs = sepIdx === -1 ? args : args.slice(0, sepIdx);
+  const commandArgv = sepIdx === -1 ? null : args.slice(sepIdx + 1);
+
   let i = 0;
-  while (i < args.length) {
-    if (args[i] === '--gpu')            { flags.gpu = args[++i]; i++; continue; }
-    if (args[i] === '--image')          { flags.image = args[++i]; i++; continue; }
-    if (args[i] === '--count')          { flags.count = parseInt(args[++i], 10); i++; continue; }
-    if (args[i] === '--region')         { flags.region = args[++i]; i++; continue; }
-    if (args[i] === '--tier')           { flags.tier = args[++i]; i++; continue; }
-    if (args[i] === '--max-price')      { flags.maxPrice = parseFloat(args[++i]); i++; continue; }
-    if (args[i] === '--name')           { flags.name = args[++i]; i++; continue; }
-    if (args[i] === '--detach')          { flags.detach = true; i++; continue; }
-    if (args[i] === '--fallback')           { flags.fallback = args[++i]; i++; continue; }
-    if (args[i] === '--no-fallback')        { flags.noFallback = true; i++; continue; }
-    if (args[i] === '--strict-capacity')    { flags.noFallback = true; i++; continue; }
-    if (args[i] === '--no-expanded-search') { flags.noFallback = true; i++; continue; }
-    if (args[i] === '--max-runtime')     { flags.maxRuntime = parseFloat(args[++i]); i++; continue; }
-    if (args[i] === '--max-cost')        { flags.maxCost = parseFloat(args[++i]); i++; continue; }
-    if (args[i] === '--min-vram')        { flags.minVram = parseFloat(args[++i]); i++; continue; }
-    if (args[i] === '--env') {
-      const kv = args[++i]; i++;
+  while (i < flagArgs.length) {
+    if (flagArgs[i] === '--gpu')            { flags.gpu = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--image')          { flags.image = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--count')          { flags.count = parseInt(flagArgs[++i], 10); i++; continue; }
+    if (flagArgs[i] === '--region')         { flags.region = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--tier')           { flags.tier = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--max-price')      { flags.maxPrice = parseFloat(flagArgs[++i]); i++; continue; }
+    if (flagArgs[i] === '--name')           { flags.name = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--detach')          { flags.detach = true; i++; continue; }
+    if (flagArgs[i] === '--fallback')           { flags.fallback = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--no-fallback')        { flags.noFallback = true; i++; continue; }
+    if (flagArgs[i] === '--strict-capacity')    { flags.noFallback = true; i++; continue; }
+    if (flagArgs[i] === '--no-expanded-search') { flags.noFallback = true; i++; continue; }
+    if (flagArgs[i] === '--max-runtime')     { flags.maxRuntime = parseFloat(flagArgs[++i]); i++; continue; }
+    if (flagArgs[i] === '--max-cost')        { flags.maxCost = parseFloat(flagArgs[++i]); i++; continue; }
+    if (flagArgs[i] === '--min-vram')        { flags.minVram = parseFloat(flagArgs[++i]); i++; continue; }
+    if (flagArgs[i] === '--dry-run')         { flags.dryRun = true; i++; continue; }
+    if (flagArgs[i] === '--save')            { flags.save = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--workspace')       { flags.workspace = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--env') {
+      const kv = flagArgs[++i]; i++;
       if (!flags.env) flags.env = [];
       flags.env.push(kv);
       continue;
     }
-    positional.push(args[i++]);
+    positional.push(flagArgs[i++]);
   }
-  return { flags, positional };
+  return { flags, positional, commandArgv };
 }
 
 function parseEnvFlag(envList) {
@@ -332,6 +342,7 @@ const _KNOWN_RUN_FLAGS = new Set([
   '--gpu', '--image', '--count', '--region', '--tier', '--max-price', '--name',
   '--detach', '--fallback', '--no-fallback', '--strict-capacity',
   '--no-expanded-search', '--max-runtime', '--max-cost', '--min-vram', '--env',
+  '--dry-run',
 ]);
 
 export async function runCommand(config, args, chalk) {
@@ -357,7 +368,7 @@ export async function runCommand(config, args, chalk) {
     return runCommand(config, expandedArgs, chalk);
   }
 
-  const { flags, positional } = parseRunArgs(args);
+  const { flags, positional, commandArgv } = parseRunArgs(args);
 
   // Detect flags that ended up in the command because of broken shell line continuation
   // (e.g. `\ ` with trailing space instead of `\<newline>`).
@@ -376,12 +387,17 @@ export async function runCommand(config, args, chalk) {
     return;
   }
 
-  if (positional.length === 0 && !flags.image) {
-    console.error(chalk.red('Usage: badgr run <command...>'));
+  if (positional.length === 0 && commandArgv === null && !flags.image) {
+    console.error(chalk.red('Usage: badgr run --gpu <GPU> --image <image> --max-cost <n> -- <command...>'));
     console.error(chalk.red('       badgr run --image my/image:latest'));
     return;
   }
-
+  if (commandArgv !== null && commandArgv.length === 0 && !flags.image) {
+    console.error(chalk.red('  ✗ No command after --. Provide a command or --image.'));
+    console.error(chalk.dim('  Example: badgr run --gpu RTX_4090 --max-cost 1 -- node script.js'));
+    process.exitCode = 1;
+    return;
+  }
   requireApiKey(config);
 
   // ── Validate flags early ───────────────────────────────────────────────────
@@ -405,7 +421,18 @@ export async function runCommand(config, args, chalk) {
     process.exitCode = 1;
     return;
   }
-  const command      = positional.length > 0 ? positional : undefined;
+
+  if (!flags.maxCost && !flags.dryRun) {
+    console.error(chalk.red('\n  ✗ --max-cost is required for run workloads.\n'));
+    console.error(chalk.dim('  Example: badgr run --gpu RTX_4090 --image node:20 --max-cost 5 -- node script.js\n'));
+    process.exitCode = 1;
+    return;
+  }
+
+  // commandArgv is set when -- separator was used; fall back to positional for legacy syntax.
+  const command = commandArgv !== null
+    ? (commandArgv.length > 0 ? commandArgv : undefined)
+    : (positional.length > 0 ? positional : undefined);
   const cmdStr = command ? command.join(' ') : '';
   const isSmoke = cmdStr.length < 80 && /print\s*\(|['"]hello/i.test(cmdStr);
   const inferredImage = isSmoke ? 'python:3.11-alpine' : 'python:3.11-slim';
@@ -424,6 +451,19 @@ export async function runCommand(config, args, chalk) {
 
   const gpu = flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : undefined;
 
+  if (flags.dryRun) {
+    console.log(chalk.bold('\n⚡ Dry run — no GPU will be provisioned\n'));
+    if (command)          console.log(`  ${chalk.bold('Command:')}      ${command.join(' ')}`);
+    if (image)            console.log(`  ${chalk.bold('Image:')}        ${image}`);
+    console.log(`  ${chalk.bold('GPU:')}          ${gpu || chalk.dim('auto')}`);
+    console.log(`  ${chalk.bold('Max runtime:')}  ${effectiveMaxRuntime}min`);
+    if (maxCost)          console.log(`  ${chalk.bold('Max cost:')}     $${maxCost}`);
+    if (flags.maxPrice)   console.log(`  ${chalk.bold('Max price:')}    $${flags.maxPrice}/hr`);
+    if (flags.env?.length) console.log(`  ${chalk.bold('Env:')}         ${flags.env.join(', ')}`);
+    console.log(chalk.dim('\n  Remove --dry-run to provision.\n'));
+    return;
+  }
+
   console.log(chalk.bold('\n⚡ Running GPU job\n'));
   if (command) console.log(`  ${chalk.bold('Command:')}  ${command.join(' ')}`);
   if (image)   console.log(`  ${chalk.bold('Image:')}    ${image}`);
@@ -441,6 +481,23 @@ export async function runCommand(config, args, chalk) {
   console.log();
 
 
+  // Resolve --workspace name → ws_… ID before submitting
+  let resolvedWorkspaceId = flags.workspace ?? null;
+  if (resolvedWorkspaceId && !resolvedWorkspaceId.startsWith('ws_')) {
+    try {
+      const wsData = await callApi(`/workspaces?limit=100`, { apiKey: config.apiKey, baseUrl: config.baseUrl });
+      const match = (wsData?.workspaces ?? []).find(w => w.name === resolvedWorkspaceId);
+      if (!match) {
+        console.error(chalk.red(`Workspace not found: ${resolvedWorkspaceId}`));
+        process.exitCode = 1; return;
+      }
+      resolvedWorkspaceId = match.workspace_id;
+    } catch (err) {
+      console.error(chalk.red(`Could not resolve workspace: ${err.message}`));
+      process.exitCode = 1; return;
+    }
+  }
+
   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}`));
@@ -461,6 +518,7 @@ export async function runCommand(config, args, chalk) {
       ...(Object.keys(envObj).length > 0 ? { env: envObj } : {}),
       max_runtime_seconds: effectiveMaxRuntime * 60,
       ...(maxCost ? { max_cost_usd: maxCost } : {}),
+      ...(resolvedWorkspaceId ? { workspace_id: resolvedWorkspaceId } : {}),
     };
   }
 
@@ -651,6 +709,34 @@ export async function runCommand(config, args, chalk) {
     } catch { /* already stopped */ }
     console.log(chalk.green(`\n  ✓ Complete`));
     console.log(chalk.dim(`  Billing ended`));
+
+    if (flags.save && config.apiKey) {
+      try {
+        const saved = await callApi('/workloads', {
+          method: 'POST',
+          apiKey: config.apiKey,
+          baseUrl: config.baseUrl,
+          body: {
+            name: flags.save,
+            job_type: 'custom.run',
+            config: {
+              command: command || [],
+              image: image || 'python:3.11-slim',
+              gpu: gpu || 'auto',
+              ...(flags.minVram ? { min_vram: flags.minVram } : {}),
+              gpu_count: flags.count || 1,
+              ...(flags.maxPrice ? { max_price_per_hour: flags.maxPrice } : {}),
+              ...(Object.keys(envObj).length > 0 ? { env: envObj } : {}),
+            },
+            default_max_cost: maxCost || 10.0,
+            default_max_runtime_minutes: effectiveMaxRuntime,
+          },
+        });
+        console.log(chalk.cyan(`  Saved as workload: ${saved.name} (${saved.workload_id})`));
+      } catch (err) {
+        console.log(chalk.yellow(`  Could not save workload: ${err.message}`));
+      }
+    }
     console.log();
   }
 }

package/src/commands/test-run.js

@@ -2,7 +2,7 @@ import { requireApiKey } from '../config.js';
 import { callApi, terminateDeployment } from '../api.js';
 import { addReceipt, generateReceiptId } from '../store.js';
 
-// max $0.80/hr × 2 min ≈ $0.027 total spend cap (smoke / Modal T4 tier)
+// max $0.80/hr × 2 min ≈ $0.027 total spend cap
 const TEST_MAX_PRICE  = 0.80;
 const TEST_MAX_RUNTIME_MS = 2 * 60 * 1000;
 const TEST_COMMAND    = ['python', '-c', "print('hello from badgr')"];
@@ -12,8 +12,8 @@ const TEST_IMAGE      = 'python:3.11-alpine';
 const EXPECTED_OUTPUT = 'hello from badgr';
 
 // --provider flag resolves to a backend tier value.
-// 'tier1' → managed routing (default), 'tier2' → marketplace routing, 'secondary' → secondary dispatch.
-const PROVIDER_TO_TIER = { tier1: '1', tier2: '2', secondary: 'modal' };
+// 'tier1' → managed routing (default), 'tier2' → marketplace routing.
+const PROVIDER_TO_TIER = { tier1: '1', tier2: '2' };
 
 export function parseTestArgs(args) {
   const flags = {};
@@ -95,7 +95,7 @@ export async function testCommand(config, args, chalk) {
     } catch {
       routes = null;
     }
-    const secondaryRoute = Array.isArray(routes) ? routes.find(r => r.name === 'modal') : null;
+    const secondaryRoute = Array.isArray(routes) ? routes.find(r => r.tier === '2') : null;
     if (secondaryRoute?.available) {
       step(chalk, true, 'Secondary provider configured');
       console.log(chalk.green('\n  ✓ Secondary dispatch provider is ready\n'));

package/src/commands/workload.js

@@ -0,0 +1,197 @@
+import { callApi } from '../api.js';
+import { fmtRuntime } from './receipts.js';
+
+function fmtRate(n) {
+  return n != null ? `${(n * 100).toFixed(1)}%` : '—';
+}
+
+function fmtCost(n) {
+  return n != null ? `$${n.toFixed(4)}` : '—';
+}
+
+function printWorkload(w, chalk) {
+  const s = w.stats;
+  console.log(`  ${chalk.cyan(w.workload_id)}  ${chalk.bold(w.name)}  ${chalk.dim(w.job_type)}`);
+  if (w.tags) console.log(`    ${chalk.dim('tags:')} ${w.tags}`);
+  console.log(`    runs: ${s.run_count}  success: ${fmtRate(s.success_rate)}  avg cost: ${fmtCost(s.avg_cost_usd)}  avg runtime: ${fmtRuntime(s.avg_runtime_seconds)}`);
+  if (s.known_good_provider) {
+    console.log(`    last good route: ${s.known_good_provider} / ${s.known_good_gpu_type}`);
+  }
+  console.log();
+}
+
+async function apiRequest(config, path, opts = {}) {
+  return callApi(path, {
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl,
+    ...opts,
+  });
+}
+
+async function resolveWorkloadId(config, nameOrId) {
+  if (nameOrId.startsWith('wl_')) return nameOrId;
+  const data = await apiRequest(config, '/workloads?limit=100');
+  const match = (data?.workloads ?? []).find(x => x.name === nameOrId);
+  return match?.workload_id ?? null;
+}
+
+export async function workloadCommand(config, args, chalk) {
+  if (!config.apiKey) {
+    console.error(chalk.red('Not logged in. Run: badgr login'));
+    process.exit(1);
+  }
+
+  const sub = args[0];
+  const rest = args.slice(1);
+
+  if (!sub || sub === 'list') {
+    const limit = parseInt(rest[0] ?? '20', 10);
+    let data;
+    try {
+      data = await apiRequest(config, `/workloads?limit=${limit}`);
+    } catch (err) {
+      console.error(chalk.red(`Could not fetch workloads: ${err.message}`));
+      process.exit(1);
+    }
+    const workloads = data?.workloads ?? [];
+    if (workloads.length === 0) {
+      console.log(chalk.dim('\nNo saved workloads. Use `badgr run --save <name>` to create one.\n'));
+      return;
+    }
+    console.log(chalk.bold(`\nSaved Workloads  (${data.total} total)\n`));
+    workloads.forEach(w => printWorkload(w, chalk));
+    if (data.total > workloads.length) {
+      console.log(chalk.dim(`  … ${data.total - workloads.length} more. badgr workload list ${limit * 2}\n`));
+    }
+    return;
+  }
+
+  if (sub === 'info') {
+    const name = rest[0];
+    if (!name) {
+      console.error(chalk.red('Usage: badgr workload info <workload-id-or-name>'));
+      process.exit(1);
+    }
+    const id = await resolveWorkloadId(config, name);
+    if (!id) {
+      console.error(chalk.red(`Workload not found: ${name}`));
+      process.exit(1);
+    }
+    let w;
+    try {
+      w = await apiRequest(config, `/workloads/${id}`);
+    } catch {
+      console.error(chalk.red(`Workload not found: ${name}`));
+      process.exit(1);
+    }
+    console.log(chalk.bold(`\nWorkload: ${w.name}\n`));
+    console.log(`  ID:       ${chalk.cyan(w.workload_id)}`);
+    console.log(`  Type:     ${w.job_type}`);
+    console.log(`  Tags:     ${w.tags || '—'}`);
+    console.log(`  Default max cost:    $${w.default_max_cost}`);
+    console.log(`  Default max runtime: ${w.default_max_runtime_minutes}m`);
+    const s = w.stats;
+    console.log(chalk.bold('\n  Stats'));
+    console.log(`    Runs:          ${s.run_count}`);
+    console.log(`    Success rate:  ${fmtRate(s.success_rate)}`);
+    console.log(`    Avg cost:      ${fmtCost(s.avg_cost_usd)}`);
+    console.log(`    Avg runtime:   ${fmtRuntime(s.avg_runtime_seconds)}`);
+    console.log(`    Total cost:    ${fmtCost(s.total_cost_usd)}`);
+    if (s.recommended_route?.provider) {
+      console.log(`    Recommended:   ${s.recommended_route.provider} / ${s.recommended_route.gpu_type}`);
+      if (s.recommended_route.reason) console.log(`                   ${chalk.dim(s.recommended_route.reason)}`);
+    } else if (s.known_good_provider) {
+      console.log(`    Good route:    ${s.known_good_provider} / ${s.known_good_gpu_type}`);
+    }
+    if (s.bad_routes?.length) {
+      console.log(`    Bad routes:    ${s.bad_routes.map(r => `${r.provider}/${r.gpu_type}`).join(', ')}`);
+    }
+    if (s.last_failure_code) {
+      console.log(chalk.dim(`    Last failure:  ${s.last_failure_code}${s.last_failure_message ? ` — ${s.last_failure_message}` : ''}`));
+    }
+    if (w.recent_jobs?.length) {
+      console.log(chalk.bold('\n  Recent Jobs'));
+      w.recent_jobs.forEach(j => {
+        const cost = j.charged_usd != null ? ` $${j.charged_usd.toFixed(4)}` : '';
+        const rt = j.runtime_seconds != null ? ` ${fmtRuntime(j.runtime_seconds)}` : '';
+        const statusColor = j.status === 'completed' ? chalk.green : j.status === 'failed' ? chalk.red : chalk.yellow;
+        console.log(`    ${chalk.dim(j.job_id)}  ${statusColor(j.status)}${cost}${rt}`);
+      });
+    }
+    console.log();
+    return;
+  }
+
+  if (sub === 'run') {
+    const name = rest[0];
+    if (!name) {
+      console.error(chalk.red('Usage: badgr workload run <workload-id-or-name> [--max-cost N] [--max-runtime N]'));
+      process.exit(1);
+    }
+    // Parse overrides
+    const flags = {};
+    const overrides = {};
+    let i = 1;
+    while (i < rest.length) {
+      if (rest[i] === '--max-cost')     { flags.maxCost = parseFloat(rest[++i]); i++; continue; }
+      if (rest[i] === '--max-runtime')  { flags.maxRuntime = parseInt(rest[++i], 10); i++; continue; }
+      if (rest[i] === '--set') {
+        const kv = rest[++i]; i++;
+        const eq = kv.indexOf('=');
+        if (eq > 0) overrides[kv.slice(0, eq)] = kv.slice(eq + 1);
+        continue;
+      }
+      i++;
+    }
+
+    const workloadId = await resolveWorkloadId(config, name);
+    if (!workloadId) {
+      console.error(chalk.red(`Workload not found: ${name}`));
+      process.exit(1);
+    }
+
+    const body = { config_overrides: overrides };
+    if (flags.maxCost != null) body.max_cost = flags.maxCost;
+    if (flags.maxRuntime != null) body.max_runtime_minutes = flags.maxRuntime;
+
+    let result;
+    try {
+      result = await apiRequest(config, `/workloads/${workloadId}/run`, {
+        method: 'POST',
+        body,
+      });
+    } catch (err) {
+      console.error(chalk.red(`Run failed: ${err.message}`));
+      process.exit(1);
+    }
+    console.log(chalk.green(`\nJob submitted: ${result.job_id}`));
+    console.log(`  Status URL: ${result.status_url}`);
+    console.log(`  Estimated: $${result.estimated_cost_usd}\n`);
+    return;
+  }
+
+  if (sub === 'delete') {
+    const name = rest[0];
+    if (!name) {
+      console.error(chalk.red('Usage: badgr workload delete <workload-id-or-name>'));
+      process.exit(1);
+    }
+    const workloadId = await resolveWorkloadId(config, name);
+    if (!workloadId) {
+      console.error(chalk.red(`Workload not found: ${name}`));
+      process.exit(1);
+    }
+    try {
+      await apiRequest(config, `/workloads/${workloadId}`, { method: 'DELETE' });
+    } catch (err) {
+      console.error(chalk.red(`Delete failed: ${err.message}`));
+      process.exit(1);
+    }
+    console.log(chalk.green(`\nWorkload deleted: ${workloadId}\n`));
+    return;
+  }
+
+  console.error(chalk.red(`Unknown workload subcommand: ${sub}`));
+  console.log(`\nUsage:\n  badgr workload list\n  badgr workload info <name>\n  badgr workload run <name>\n  badgr workload delete <name>\n`);
+  process.exit(1);
+}

package/src/commands/workspace.js

@@ -0,0 +1,136 @@
+import { callApi } from '../api.js';
+import { fmtRuntime } from './receipts.js';
+
+function fmtCost(n) {
+  return n != null ? `$${n.toFixed(4)}` : '—';
+}
+
+async function apiRequest(config, path, opts = {}) {
+  return callApi(path, { apiKey: config.apiKey, baseUrl: config.baseUrl, ...opts });
+}
+
+async function resolveWorkspaceId(config, nameOrId) {
+  if (nameOrId.startsWith('ws_')) return nameOrId;
+  const data = await apiRequest(config, '/workspaces?limit=100');
+  const match = (data?.workspaces ?? []).find(x => x.name === nameOrId);
+  return match?.workspace_id ?? null;
+}
+
+export async function workspaceCommand(config, args, chalk) {
+  if (!config.apiKey) {
+    console.error(chalk.red('Not logged in. Run: badgr login'));
+    process.exit(1);
+  }
+
+  const sub = args[0];
+  const rest = args.slice(1);
+
+  // badgr workspace  /  badgr workspace list
+  if (!sub || sub === 'list') {
+    const limit = parseInt(rest[0] ?? '20', 10);
+    let data;
+    try {
+      data = await apiRequest(config, `/workspaces?limit=${limit}`);
+    } catch (err) {
+      console.error(chalk.red(`Could not fetch workspaces: ${err.message}`));
+      process.exit(1);
+    }
+    const workspaces = data?.workspaces ?? [];
+    if (workspaces.length === 0) {
+      console.log(chalk.dim('\nNo workspace trackers yet. Run: badgr workspace create <name>\n'));
+      return;
+    }
+    console.log(chalk.bold(`\nWorkspace Tracking  (${data.total} total)\n`));
+    workspaces.forEach(ws => {
+      console.log(`  ${chalk.cyan(ws.workspace_id)}  ${chalk.bold(ws.name)}`);
+      if (ws.storage_path) console.log(`    ${chalk.dim('storage:')} ${ws.storage_path}`);
+      console.log(`    jobs: ${ws.total_jobs}  total cost: ${fmtCost(ws.total_cost_usd)}`);
+      console.log();
+    });
+    return;
+  }
+
+  // badgr workspace create <name> [--storage <path>] [--desc <text>]
+  if (sub === 'create') {
+    const name = rest[0];
+    if (!name) {
+      console.error(chalk.red('Usage: badgr workspace create <name> [--storage <s3-path>] [--desc <text>]'));
+      process.exit(1);
+    }
+    const flags = {};
+    for (let i = 1; i < rest.length; i++) {
+      if (rest[i] === '--storage') { flags.storage_path = rest[++i]; continue; }
+      if (rest[i] === '--desc')    { flags.description  = rest[++i]; continue; }
+    }
+    let ws;
+    try {
+      ws = await apiRequest(config, '/workspaces', { method: 'POST', body: { name, ...flags } });
+    } catch (err) {
+      console.error(chalk.red(`Create failed: ${err.message}`));
+      process.exit(1);
+    }
+    console.log(chalk.green(`\nWorkspace tracker created: ${ws.name} (${ws.workspace_id})`));
+    if (ws.storage_path) console.log(`  Storage path: ${ws.storage_path}`);
+    console.log(`  Link jobs to this workspace: badgr run --workspace ${ws.workspace_id} <command>\n`);
+    return;
+  }
+
+  // badgr workspace info <name-or-id>
+  if (sub === 'info') {
+    const name = rest[0];
+    if (!name) {
+      console.error(chalk.red('Usage: badgr workspace info <name-or-id>'));
+      process.exit(1);
+    }
+    const id = await resolveWorkspaceId(config, name);
+    if (!id) { console.error(chalk.red(`Workspace not found: ${name}`)); process.exit(1); }
+    let ws;
+    try {
+      ws = await apiRequest(config, `/workspaces/${id}`);
+    } catch {
+      console.error(chalk.red(`Workspace not found: ${name}`)); process.exit(1);
+    }
+    console.log(chalk.bold(`\nWorkspace: ${ws.name}\n`));
+    console.log(`  ID:      ${chalk.cyan(ws.workspace_id)}`);
+    if (ws.description)  console.log(`  Desc:    ${ws.description}`);
+    if (ws.storage_path) console.log(`  Storage: ${ws.storage_path}`);
+    console.log(`  Jobs:    ${ws.total_jobs}  Total cost: ${fmtCost(ws.total_cost_usd)}`);
+    if (ws.files?.length) {
+      console.log(chalk.bold('\n  Files'));
+      ws.files.forEach(f => console.log(`    ${f.name}  ${f.size_bytes ? `(${(f.size_bytes / 1024).toFixed(1)} KB)` : ''}`));
+    }
+    if (ws.recent_jobs?.length) {
+      console.log(chalk.bold('\n  Recent Jobs'));
+      ws.recent_jobs.forEach(j => {
+        const cost = j.charged_usd != null ? ` ${fmtCost(j.charged_usd)}` : '';
+        const rt   = j.runtime_seconds != null ? ` ${fmtRuntime(j.runtime_seconds)}` : '';
+        const col  = j.status === 'completed' ? chalk.green : j.status === 'failed' ? chalk.red : chalk.yellow;
+        console.log(`    ${chalk.dim(j.job_id)}  ${col(j.status)}${cost}${rt}`);
+      });
+    }
+    console.log();
+    return;
+  }
+
+  // badgr workspace delete <name-or-id>
+  if (sub === 'delete') {
+    const name = rest[0];
+    if (!name) {
+      console.error(chalk.red('Usage: badgr workspace delete <name-or-id>'));
+      process.exit(1);
+    }
+    const id = await resolveWorkspaceId(config, name);
+    if (!id) { console.error(chalk.red(`Workspace not found: ${name}`)); process.exit(1); }
+    try {
+      await apiRequest(config, `/workspaces/${id}`, { method: 'DELETE' });
+    } catch (err) {
+      console.error(chalk.red(`Delete failed: ${err.message}`)); process.exit(1);
+    }
+    console.log(chalk.green(`\nWorkspace archived: ${id}\n`));
+    return;
+  }
+
+  console.error(chalk.red(`Unknown workspace subcommand: ${sub}`));
+  console.log('\nUsage:\n  badgr workspace list\n  badgr workspace create <name>\n  badgr workspace info <name>\n  badgr workspace delete <name>\n');
+  process.exit(1);
+}

package/tests/commands.test.js

@@ -94,6 +94,54 @@ describe('parseRunArgs', () => {
     expect(flags.gpu).toBe('A100');
     expect(flags.minVram).toBe(40);
   });
+
+  it('-- separator: badgr flags before --, command argv after', () => {
+    const { flags, commandArgv, positional } = parseRunArgs([
+      '--gpu', 'RTX_4090', '--image', 'node:20', '--max-cost', '1', '--',
+      'node', '-e', "console.log('hello')",
+    ]);
+    expect(flags.gpu).toBe('RTX_4090');
+    expect(flags.image).toBe('node:20');
+    expect(flags.maxCost).toBe(1);
+    expect(commandArgv).toEqual(['node', '-e', "console.log('hello')"]);
+    expect(positional).toEqual([]);
+  });
+
+  it('-- separator: commandArgv is empty array when nothing follows --', () => {
+    const { commandArgv } = parseRunArgs(['--gpu', 'A100', '--max-cost', '2', '--']);
+    expect(commandArgv).toEqual([]);
+  });
+
+  it('commandArgv is null when -- is not used (legacy syntax)', () => {
+    const { commandArgv, positional } = parseRunArgs(['python', 'train.py', '--gpu', 'A100']);
+    expect(commandArgv).toBeNull();
+    expect(positional).toEqual(['python', 'train.py']);
+  });
+
+  it('parses --dry-run flag', () => {
+    const { flags } = parseRunArgs(['--dry-run', '--gpu', 'RTX_4090', '--image', 'node:20']);
+    expect(flags.dryRun).toBe(true);
+    expect(flags.gpu).toBe('RTX_4090');
+  });
+
+  it('--dry-run with -- separator keeps command argv intact', () => {
+    const { flags, commandArgv } = parseRunArgs([
+      '--dry-run', '--gpu', 'RTX_4090', '--image', 'node:20', '--',
+      'node', '-e', "console.log('dry')",
+    ]);
+    expect(flags.dryRun).toBe(true);
+    expect(commandArgv).toEqual(['node', '-e', "console.log('dry')"]);
+  });
+
+  it('-- separator: command tokens with --flags are not parsed as badgr flags', () => {
+    // --json is a user command flag here, not a badgr flag
+    const { flags, commandArgv } = parseRunArgs([
+      '--gpu', 'A100', '--max-cost', '2', '--',
+      'gpu-monitor', 'check', '--json',
+    ]);
+    expect(commandArgv).toEqual(['gpu-monitor', 'check', '--json']);
+    expect(flags.gpu).toBe('A100');
+  });
 });
 
 describe('classifyFailure', () => {

package/tests/run-lifecycle.test.js

@@ -120,7 +120,7 @@ afterEach(() => {
 describe('GPU / provider matrix', () => {
   it('A100 via RunPod (tier-1) completes successfully', async () => {
     setupSuccessfulRun({ gpu_type: 'A100', provider: 'runpod', tier: '1' });
-    const p = runCommand(config, ['python', 'train.py', '--gpu', 'A100'], chalk);
+    const p = runCommand(config, ['python', 'train.py', '--gpu', 'A100', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
     await p;
 
@@ -142,7 +142,7 @@ describe('GPU / provider matrix', () => {
       .mockResolvedValueOnce(makeDep({ gpu_type: 'L40S', provider: 'vastai', tier: '1', cost_per_hour: 1.80 }))
       .mockResolvedValueOnce({ status: 'completed', exit_code: 0 })
       .mockResolvedValueOnce({ logs: [] });
-    const p = runCommand(config, ['python', 'train.py', '--gpu', 'L40S'], chalk);
+    const p = runCommand(config, ['python', 'train.py', '--gpu', 'L40S', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
     await p;
 
@@ -168,7 +168,7 @@ describe('non-zero exit code', () => {
       .mockResolvedValueOnce(makeDep())
       .mockResolvedValueOnce({ status: 'failed', exit_code: 1 })
       .mockResolvedValueOnce({ logs: ['Traceback (most recent call last)'] });
-    const p = runCommand(config, ['python', 'train.py'], chalk);
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
     await p;
 
@@ -184,7 +184,7 @@ describe('non-zero exit code', () => {
       .mockResolvedValueOnce(makeDep())
       .mockResolvedValueOnce({ status: 'failed', exit_code: null })
       .mockResolvedValueOnce({ logs: [] });
-    const p = runCommand(config, ['python', 'train.py'], chalk);
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
     await p;
 
@@ -203,7 +203,7 @@ describe('container fails to start', () => {
     api.callApi
       .mockResolvedValueOnce(makeDep({ status: 'failed' })) // POST /run returns already-failed
       .mockResolvedValueOnce({ logs: [] });
-    const p = runCommand(config, ['python', 'train.py'], chalk);
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(1000);
     await p;
 
@@ -215,7 +215,7 @@ describe('container fails to start', () => {
     api.callApi
       .mockResolvedValueOnce(makeDep({ status: 'provisioning' })) // POST /run → provisioning
       .mockResolvedValueOnce({ status: 'failed' });               // poll → failed
-    const p = runCommand(config, ['python', 'train.py'], chalk);
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
     // advance past POLL_MS (3000ms) in waitForRunning
     await vi.advanceTimersByTimeAsync(4000);
     await p;
@@ -237,7 +237,7 @@ describe('max-runtime cap', () => {
       .mockResolvedValueOnce({ logs: [] });                          // logs 1
     api.terminateDeployment.mockResolvedValue({});
 
-    const p = runCommand(config, ['python', 'train.py', '--max-runtime', '0.05'], chalk);
+    const p = runCommand(config, ['python', 'train.py', '--max-runtime', '0.05', '--max-cost', '5'], chalk);
     // attachToJob POLL_MS = 4000, maxRuntime = 0.05 min = 3000ms → cap fires after 4000ms (first elapsedMs check)
     await vi.advanceTimersByTimeAsync(5000);
     await p;
@@ -294,7 +294,7 @@ describe('heartbeat lost', () => {
       .mockRejectedValue(new Error('ETIMEDOUT'));             // all subsequent dep/logs polls fail
     api.terminateDeployment.mockResolvedValue({});
 
-    const p = runCommand(config, ['python', 'train.py'], chalk);
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
     // Advance past 1 successful poll (4000ms) + 15 failed polls (60000ms) = 64000ms
     await vi.advanceTimersByTimeAsync(66000);
     await p;
@@ -333,7 +333,7 @@ describe('log streaming', () => {
         'Epoch 2/3: loss=0.31',                         // should appear
       ]});
 
-    const p = runCommand(config, ['python', 'train.py'], chalk);
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
     await p;
 
@@ -357,11 +357,11 @@ describe('routing fallback', () => {
     });
     api.callApi
       .mockRejectedValueOnce(capacityErr)                                     // tier-1 attempt
-      .mockResolvedValueOnce(makeDep({ provider: 'modal', tier: '2' }))      // tier-2 succeeds
+      .mockResolvedValueOnce(makeDep({ provider: 'vastai', tier: '2' }))      // tier-2 succeeds
       .mockResolvedValueOnce({ status: 'completed', exit_code: 0 })
       .mockResolvedValueOnce({ logs: [] });
 
-    const p = runCommand(config, ['python', 'train.py'], chalk);
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
     await p;
 
@@ -370,7 +370,7 @@ describe('routing fallback', () => {
     expect(postCalls.length).toBeGreaterThanOrEqual(2);
 
     expect(store.addReceipt).toHaveBeenCalledWith(expect.objectContaining({
-      providerRoute: 'modal',
+      providerRoute: 'vastai',
       tier:          '2',
     }));
     expect(process.exitCode).toBeFalsy();
@@ -386,7 +386,7 @@ describe('routing fallback', () => {
     const logs = [];
     console.error.mockImplementation(msg => logs.push(msg));
 
-    await runCommand(config, ['python', 'train.py'], chalk);
+    await runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
 
     expect(process.exitCode).toBe(1);
     const combined = logs.join('\n');
@@ -400,7 +400,7 @@ describe('routing fallback', () => {
     });
     api.callApi.mockRejectedValueOnce(capacityErr);
 
-    await runCommand(config, ['python', 'train.py', '--no-fallback'], chalk);
+    await runCommand(config, ['python', 'train.py', '--no-fallback', '--max-cost', '5'], chalk);
 
     // Only one POST /run call was made (no tier-2 expansion)
     const postCalls = api.callApi.mock.calls.filter(c => c[1]?.method === 'POST');
@@ -418,7 +418,7 @@ describe('routing fallback', () => {
     const errLines = [];
     console.error.mockImplementation(msg => errLines.push(msg));
 
-    await runCommand(config, ['python', 'train.py'], chalk);
+    await runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
 
     expect(process.exitCode).toBe(1);
     const combined = errLines.join('\n');
@@ -442,7 +442,7 @@ describe('payment required', () => {
     const errLines = [];
     console.error.mockImplementation(msg => errLines.push(msg));
 
-    await runCommand(config, ['python', 'train.py', '--gpu', 'A100'], chalk);
+    await runCommand(config, ['python', 'train.py', '--gpu', 'A100', '--max-cost', '5'], chalk);
 
     expect(process.exitCode).toBe(1);
     const combined = errLines.join('\n');
@@ -457,7 +457,7 @@ describe('payment required', () => {
 describe('billing lifecycle', () => {
   it('terminateDeployment is called after successful completion', async () => {
     setupSuccessfulRun();
-    const p = runCommand(config, ['python', 'train.py'], chalk);
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
     await p;
     expect(api.terminateDeployment).toHaveBeenCalledWith(config, 'dep-launch-001');
@@ -465,7 +465,7 @@ describe('billing lifecycle', () => {
 
   it('receipt records runtime and finalCost on completion', async () => {
     setupSuccessfulRun({ cost_per_hour: 1.80 });
-    const p = runCommand(config, ['python', 'train.py'], chalk);
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
     await p;
 
@@ -505,4 +505,41 @@ describe('input validation', () => {
     await runCommand(config, [], chalk);
     expect(api.callApi).not.toHaveBeenCalled();
   });
+
+  it('rejects -- with nothing after and no --image', async () => {
+    await runCommand(config, ['--gpu', 'RTX_4090', '--max-cost', '1', '--'], chalk);
+    expect(api.callApi).not.toHaveBeenCalled();
+    expect(process.exitCode).toBe(1);
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 12. --dry-run: shows config, never provisions
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('--dry-run', () => {
+  it('prints dry-run summary and never calls the API', async () => {
+    const output = [];
+    const dryChalk = { bold: (s) => s, dim: (s) => s, cyan: (s) => s, red: (s) => s, yellow: (s) => s, green: (s) => s };
+    const origLog = console.log;
+    console.log = (...args) => output.push(args.join(' '));
+    await runCommand(config, [
+      '--dry-run', '--gpu', 'RTX_4090', '--image', 'node:20', '--max-cost', '1', '--',
+      'node', '-e', "console.log('dry')",
+    ], dryChalk);
+    console.log = origLog;
+    expect(api.callApi).not.toHaveBeenCalled();
+    expect(output.some(l => /dry run/i.test(l))).toBe(true);
+    expect(output.some(l => /node -e/.test(l) || /console\.log/.test(l))).toBe(true);
+    expect(output.some(l => /RTX_4090/.test(l))).toBe(true);
+  });
+
+  it('--dry-run works without --max-cost', async () => {
+    const dryChalk = { bold: (s) => s, dim: (s) => s, cyan: (s) => s, red: (s) => s, yellow: (s) => s, green: (s) => s };
+    await runCommand(config, [
+      '--dry-run', '--gpu', 'A100', '--image', 'node:20', '--',
+      'node', 'script.js',
+    ], dryChalk);
+    expect(api.callApi).not.toHaveBeenCalled();
+  });
 });

package/tests/template.test.js

@@ -107,10 +107,12 @@ describe('TEMPLATES catalog', () => {
   const EXPECTED_NAMES = [
     'comfyui', 'axolotl', 'unsloth', 'vllm', 'llama-cpp',
     'invokeai', 'kohya-ss', 'text-gen-webui', 'sglang', 'tgi',
+    'auto1111', 'forge', 'nerfstudio', 'openfold', 'blender-render',
+    'openmm', 'gromacs', 'lammps', 'diffusers', 'torchtune',
   ];
 
-  it('contains exactly 10 templates', () => {
-    expect(TEMPLATES).toHaveLength(10);
+  it('contains exactly 20 templates', () => {
+    expect(TEMPLATES).toHaveLength(20);
   });
 
   it('contains all expected template names', () => {
@@ -178,7 +180,7 @@ describe('TEMPLATES catalog', () => {
     for (const [k, t] of Object.entries(TEMPLATE_MAP)) {
       expect(k).toBe(t.name);
     }
-    expect(Object.keys(TEMPLATE_MAP)).toHaveLength(10);
+    expect(Object.keys(TEMPLATE_MAP)).toHaveLength(20);
   });
 });
 
@@ -358,7 +360,7 @@ describe('badgr serve template <name>', () => {
     await p;
 
     const [, opts] = api.callApi.mock.calls[0];
-    expect(opts.body.image).toBe('yanwk/comfyui-boot:latest');
+    expect(opts.body.image).toBe('yanwk/comfyui-boot:cu126-megapak');
     const fetchUrl = global.fetch.mock.calls[0]?.[0] ?? '';
     expect(fetchUrl).toContain('/system_stats');
     expect(process.exitCode).toBeFalsy();

package/tests/workload-rerun.test.js

@@ -0,0 +1,56 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Verify `badgr workload run` (rerun a saved workflow) resolves name→id and
+// merges --set / --max-cost / --max-runtime into the POST body the server
+// expects, without provisioning a GPU.
+const calls = [];
+vi.mock('../src/api.js', () => ({
+  callApi: vi.fn(async (path, opts = {}) => {
+    calls.push({ path, opts });
+    if (path.startsWith('/workloads?')) {
+      return { workloads: [{ name: 'mini-train', workload_id: 'wl_abc' }], total: 1 };
+    }
+    if (path === '/workloads/wl_abc/run') {
+      return { job_id: 'job_1', status_url: 'https://aibadgr.com/v1/jobs/job_1', estimated_cost_usd: 1.23 };
+    }
+    return {};
+  }),
+}));
+
+const { workloadCommand } = await import('../src/commands/workload.js');
+const chalk = new Proxy({}, { get: () => (s) => s });
+const config = { apiKey: 'k', baseUrl: 'https://aibadgr.com/v1' };
+
+beforeEach(() => {
+  calls.length = 0;
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+});
+
+describe('badgr workload run (rerun saved workflow)', () => {
+  it('resolves name→id and merges --set / --max-cost / --max-runtime into the rerun body', async () => {
+    await workloadCommand(
+      config,
+      ['run', 'mini-train', '--set', 'gpu=H100', '--max-cost', '8', '--max-runtime', '30'],
+      chalk,
+    );
+
+    const resolve = calls.find(c => c.path.startsWith('/workloads?'));
+    expect(resolve, 'should look up workload by name').toBeTruthy();
+    expect(resolve.path.startsWith('/v1/')).toBe(false);
+
+    const run = calls.find(c => c.path === '/workloads/wl_abc/run');
+    expect(run, 'should POST to the rerun endpoint').toBeTruthy();
+    expect(run.opts.method).toBe('POST');
+    expect(run.opts.body).toEqual({
+      config_overrides: { gpu: 'H100' },
+      max_cost: 8,
+      max_runtime_minutes: 30,
+    });
+  });
+
+  it('sends only config_overrides when no caps are passed', async () => {
+    await workloadCommand(config, ['run', 'mini-train', '--set', 'steps=50'], chalk);
+    const run = calls.find(c => c.path === '/workloads/wl_abc/run');
+    expect(run.opts.body).toEqual({ config_overrides: { steps: '50' } });
+  });
+});

package/tests/workload-templates.test.js

@@ -239,7 +239,7 @@ describe('comfyuiCommand', () => {
     const bodyBuilder = fallback.callWithFallback.mock.calls[0][2];
     const body = bodyBuilder();
     expect(body.env.COMFYUI_WORKFLOW_B64).toBe(Buffer.from(wfContent).toString('base64'));
-    expect(body.image).toBe('yanwk/comfyui-boot:latest');
+    expect(body.image).toBe('yanwk/comfyui-boot:cu126-megapak');
   });
 
   it('skips health check when --no-wait', async () => {

package/tests/workload-workspace-paths.test.js

@@ -0,0 +1,46 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Capture every path passed to callApi so we can assert the CLI never builds a
+// doubled `/v1/v1/...` URL. baseUrl already ends in `/v1`, so command paths must
+// be unprefixed (e.g. `/workspaces`, not `/v1/workspaces`).
+const calls = [];
+vi.mock('../src/api.js', () => ({
+  callApi: vi.fn(async (path) => {
+    calls.push(path);
+    if (path.startsWith('/workspaces')) return { workspaces: [], total: 0 };
+    if (path.startsWith('/workloads')) return { workloads: [], total: 0 };
+    return {};
+  }),
+}));
+
+const { workspaceCommand } = await import('../src/commands/workspace.js');
+const { workloadCommand } = await import('../src/commands/workload.js');
+
+// chalk stub: any style method returns its first argument unchanged.
+const chalk = new Proxy({}, { get: () => (s) => s });
+const config = { apiKey: 'test-key', baseUrl: 'https://aibadgr.com/v1' };
+
+function assertNoDoubleV1() {
+  expect(calls.length).toBeGreaterThan(0);
+  for (const path of calls) {
+    expect(path.startsWith('/v1/')).toBe(false);
+    expect(`${config.baseUrl}${path}`).not.toContain('/v1/v1/');
+  }
+}
+
+beforeEach(() => {
+  calls.length = 0;
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+});
+
+describe('CLI workload/workspace request paths', () => {
+  it('workspace list targets /workspaces (no doubled /v1)', async () => {
+    await workspaceCommand(config, ['list'], chalk);
+    assertNoDoubleV1();
+  });
+
+  it('workload list targets /workloads (no doubled /v1)', async () => {
+    await workloadCommand(config, ['list'], chalk);
+    assertNoDoubleV1();
+  });
+});