badgr-cli 1.0.38 → 1.0.40

package/README.md

@@ -46,6 +46,14 @@ badgr down <deployment-id>
 | `badgr capacity` | Check available GPU capacity right now |
 | `badgr billing` | Show balance and add funds |
 | `badgr test` | Run an end-to-end test (provision → run → teardown) |
+| `badgr workload list` | List saved workloads with run stats |
+| `badgr workload run <name>` | Rerun a saved workload by name or ID |
+| `badgr workload info <name>` | Show stats, route history, and recent jobs for a workload |
+| `badgr workload delete <name>` | Delete a saved workload |
+| `badgr workspace list` | List workspace trackers (job history + cost per context) |
+| `badgr workspace create <name>` | Create a workspace tracker, optionally linked to a storage path |
+| `badgr workspace info <name>` | Show jobs, cost, and files for a workspace |
+| `badgr workspace delete <name>` | Archive a workspace tracker |
 
 `badgr serve` — for anything that needs a persistent endpoint: LLM serving, embeddings, image generation APIs, transcription APIs.
 
@@ -101,6 +109,8 @@ badgr run python train.py --gpu A100 --env HF_TOKEN=$HF_TOKEN --max-runtime 60
 | `--max-runtime <min>` | — | Auto-stop after N minutes (recommended) |
 | `--max-cost <$>` | — | Auto-stop when total spend reaches this amount |
 | `--detach` | — | Launch and return immediately, don't stream logs |
+| `--save <name>` | — | Save this job as a named workload after it completes |
+| `--workspace <name\|id>` | — | Link this job to a workspace tracker (name or `ws_…` ID) |
 
 ---
 
@@ -199,6 +209,59 @@ Accepts a public URL, S3/GCS URI, or a local text file under 10 MB. Outputs JSON
 
 ---
 
+## Workloads
+
+A workload is a saved job configuration. Once saved, you can rerun it by name instead of retyping all the flags. Badgr tracks success rate, average cost, average runtime, and the last known-good route so reruns are faster and cheaper over time.
+
+**Save a workload** by adding `--save <name>` to any `badgr run` call:
+
+```bash
+badgr run python train.py --gpu A100 --env HF_TOKEN=$HF_TOKEN --max-runtime 120 --save my-training-job
+```
+
+**Rerun a saved workload:**
+
+```bash
+badgr workload run my-training-job
+badgr workload run my-training-job --max-cost 5          # override spend cap
+badgr workload run my-training-job --set HF_TOKEN=newval # override an env var
+```
+
+**Inspect and manage workloads:**
+
+```bash
+badgr workload list                  # list all saved workloads with stats
+badgr workload info my-training-job  # stats, route history, recent jobs
+badgr workload delete my-training-job
+```
+
+| `badgr workload run` flag | Description |
+|---|---|
+| `--max-cost <$>` | Override the saved spend cap for this run |
+| `--max-runtime <min>` | Override the saved runtime limit for this run |
+| `--set KEY=VALUE` | Override a saved config value for this run (repeatable) |
+
+---
+
+## Workspaces
+
+A workspace tracker groups jobs by a named context — useful for tracking cost and job history across a project or storage path.
+
+```bash
+badgr workspace create my-project --storage s3://my-bucket/runs --desc "nightly evals"
+badgr run python eval.py --workspace my-project --max-cost 5
+badgr workspace info my-project     # jobs, total cost, files
+badgr workspace list
+badgr workspace delete my-project
+```
+
+| `badgr workspace create` flag | Description |
+|---|---|
+| `--storage <path>` | S3/GCS path to associate with this workspace |
+| `--desc <text>` | Optional description |
+
+---
+
 ## Routing
 
 Badgr Auto selects the best eligible route based on GPU type, VRAM, availability, region, workload requirements, and reliability. Advanced users can optionally choose an execution tier or hardware constraint.
@@ -275,7 +338,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.40",
+  "description": "Badgr — run or serve GPU workloads from one command",
   "type": "module",
   "bin": {
     "badgr": "src/badgr.js"
@@ -12,23 +12,27 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@inquirer/prompts": "^8.5.2",
-    "chalk": "^5.3.0"
+    "chalk": "^5.3.0",
+    "@inquirer/prompts": "^8.5.2"
   },
   "devDependencies": {
     "vitest": "^4.1.8"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.10.0"
   },
   "keywords": [
     "gpu",
     "cli",
     "ai",
     "compute",
-    "modal",
     "gateway",
-    "openai"
+    "openai",
+    "workload",
+    "workspace",
+    "llm",
+    "inference",
+    "fine-tuning"
   ],
-  "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'));