badgr-cli 1.0.25 → 1.0.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "badgr-cli",
-  "version": "1.0.25",
+  "version": "1.0.27",
   "description": "Badgr, run or serve GPU workloads from one command",
   "type": "module",
   "bin": {

package/src/commands/models.js

@@ -1,19 +1,38 @@
-import { listModels } from '../api.js';
+import { listModels, callApi } from '../api.js';
 import { listAll } from '../router.js';
 
 export async function modelsCommand(config, chalk) {
-  const gpus = listAll();
-
   console.log(chalk.bold('\n📦 GPU Options (cheapest first)\n'));
+
+  let gpus = null;
+  if (config.apiKey) {
+    try {
+      const data = await callApi('/gpus', { apiKey: config.apiKey, baseUrl: config.baseUrl });
+      if (data?.gpus?.length) {
+        gpus = data.gpus.map(g => ({
+          id:          g.id,
+          name:        g.name,
+          vramGb:      g.vram_gb,
+          ratePerHour: g.rate_per_hour,
+        })).sort((a, b) => a.ratePerHour - b.ratePerHour);
+      }
+    } catch {
+      // fallback to local catalog on error
+    }
+  }
+
+  if (!gpus) gpus = listAll();
+
   console.log(
-    `  ${'ID'.padEnd(14)}  ${'Name'.padEnd(24)}  ${'VRAM'.padEnd(8)}  Rate/hr`
+    `  ${'ID'.padEnd(14)}  ${'Name'.padEnd(24)}  ${'VRAM'.padEnd(8)}  Rate/hr (indicative)`
   );
-  console.log(`  ${'─'.repeat(58)}`);
+  console.log(`  ${'─'.repeat(68)}`);
   gpus.forEach(g => {
     console.log(
-      `  ${chalk.cyan(g.id.padEnd(14))}  ${g.name.padEnd(24)}  ${`${g.vramGb}GB`.padEnd(8)}  $${g.ratePerHour.toFixed(2)}`
+      `  ${chalk.cyan(g.id.padEnd(14))}  ${g.name.padEnd(24)}  ${`${g.vramGb}GB`.padEnd(8)}  ~$${g.ratePerHour.toFixed(2)}`
     );
   });
+  console.log(chalk.dim('  Actual billing is set at job start — use `badgr run` to see live rates.'));
 
   console.log(chalk.bold('\n🤖 LLM Models\n'));
   if (!config.apiKey) {

package/src/commands/run.js

@@ -81,18 +81,36 @@ function renderStatusBar(chalk, { elapsedMs, ratePerHour, gpuUtil, cpuUtil, maxR
   return chalk.dim('  ' + parts.join('  •  '));
 }
 
-// Wait for status to leave 'starting' (smoke check running on backend).
+// Wait for status to leave 'starting'/'queued'/'provisioning'.
+// This covers image pull time — runtime limit does NOT start until this returns.
 // Returns the final dep object with status 'running' or 'failed'.
 async function waitForRunning(config, depId, chalk) {
-  const POLL_MS = 3000;
-  const TIMEOUT_MS = 120_000; // 2 min max for smoke check
-  const startMs = Date.now();
-  let dots = 0;
+  const POLL_MS     = 3000;
+  const TIMEOUT_MS  = 5 * 60 * 1000; // 5 min startup grace (image pull + container init)
+  const startMs     = Date.now();
+  const PHASES = [
+    { afterMs:     0, label: '  Starting container'    },
+    { afterMs: 15000, label: '  Pulling image'         },
+    { afterMs: 60000, label: '  Starting container'    },
+    { afterMs: 180000, label: '  Running command'      },
+  ];
+
+  let lastPhaseIdx = -1;
+  const STARTUP_STATES = new Set(['queued', 'provisioning', 'starting']);
 
-  process.stdout.write(chalk.dim('  Waiting for container to start'));
   const ticker = setInterval(() => {
+    const elapsed = Date.now() - startMs;
+    // Find the latest phase whose afterMs has been passed
+    let phaseIdx = 0;
+    for (let i = 0; i < PHASES.length; i++) {
+      if (elapsed >= PHASES[i].afterMs) phaseIdx = i;
+    }
+    if (phaseIdx !== lastPhaseIdx) {
+      process.stdout.write('\r\x1b[2K');
+      process.stdout.write(chalk.dim(PHASES[phaseIdx].label));
+      lastPhaseIdx = phaseIdx;
+    }
     process.stdout.write('.');
-    dots++;
   }, 1000);
 
   try {
@@ -102,23 +120,22 @@ async function waitForRunning(config, depId, chalk) {
         apiKey: config.apiKey,
         baseUrl: config.baseUrl,
       });
-      if (dep.status !== 'starting') {
-        clearInterval(ticker);
+      if (!STARTUP_STATES.has(dep.status)) {
         process.stdout.write('\n');
         return dep;
       }
     }
   } finally {
     clearInterval(ticker);
-    if (dots > 0) process.stdout.write('\n');
+    process.stdout.write('\n');
   }
 
-  // Timed out waiting — return whatever we have
+  // Timed out — return last known state
   return await callApi(`/deployments/${depId}`, { apiKey: config.apiKey, baseUrl: config.baseUrl });
 }
 
 async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost = null, ratePerHour = 0, onTeardown }) {
-  const TERMINAL = new Set(['stopped', 'failed', 'completed']);
+  const TERMINAL = new Set(['stopped', 'failed', 'completed', 'succeeded']);
   const POLL_MS  = 4000;
   let seenContent     = new Set();  // track by content, not index, to avoid reprinting stale lines
   let lastStatus      = '';
@@ -268,63 +285,6 @@ async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost
   }
 }
 
-/**
- * Infer a workload profile name from the command the user wants to run.
- * The backend uses this to enforce a VRAM floor when picking a GPU.
- *
- * Note: \b word boundaries are intentionally avoided for keyword checks
- * because keywords commonly appear inside filenames joined by underscores
- * (e.g. lora_train.py, run_sdxl.py) where `_` is a word character.
- */
-export function inferWorkload(command) {
-  if (!command || command.length === 0) return 'general';
-
-  const cmd = command.join(' ').toLowerCase();
-
-  // Trivial one-liner / smoke test
-  if (/print\s*\(|['"]hello/.test(cmd) && cmd.length < 80) return 'smoke_test';
-
-  // LoRA / QLoRA / PEFT fine-tuning
-  if (/lora|qlora|finetune|fine[_-]tun|peft/.test(cmd)) return 'lora_finetune';
-
-  // Diffusion / image generation
-  if (/diffusion|stable.?diff|sdxl|sd.?xl|comfyui|a1111|invoke|kohya/.test(cmd)) return 'image_gen';
-
-  // vLLM / TGI / inference server
-  if (/vllm|[^a-z]tgi[^a-z]|^tgi\b|tgi$|text.generation.inference/.test(cmd)) return 'inference_small';
-
-  // Explicit training script
-  if (/\btrain\.py\b/.test(cmd)) return 'lora_finetune';
-
-  return 'general';
-}
-
-const WORKLOAD_LABELS = {
-  smoke_test:       'smoke test',
-  general:          'GPU job',
-  lora_finetune:    'fine-tuning (40GB+ VRAM)',
-  image_gen:        'image generation',
-  inference_small:  'inference (7B–8B model)',
-  inference_medium: 'inference (30B–34B model)',
-  inference_large:  'inference (70B+ model)',
-};
-
-// Ask the backend for the best available GPU for a given workload.
-// Routes by: workload → min VRAM → provider tier → cheapest match.
-// Returns { gpu, region, price, workload, workload_desc } or null when nothing is available.
-async function findAutoGpu(config, chalk, tier = '1', workload = 'general') {
-  try {
-    const params = new URLSearchParams({ max_price: '10', tier, workload });
-    return await callApi(`/capacity/auto?${params}`, {
-      apiKey: config.apiKey,
-      baseUrl: config.baseUrl,
-    });
-  } catch (err) {
-    if (err.errorData?.code === 'NO_CAPACITY_MATCH') return null;
-    throw err;
-  }
-}
-
 function askConfirm(prompt) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise(resolve => rl.question(prompt, ans => { rl.close(); resolve(ans.trim()); }));
@@ -342,7 +302,11 @@ export async function runCommand(config, args, chalk) {
   requireApiKey(config);
 
   const command      = positional.length > 0 ? positional : undefined;
-  const image        = flags.image || (command ? 'python:3.11-slim' : undefined);
+  // Use alpine for trivial one-liners (7MB vs 50MB — much faster pull)
+  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';
+  const image = flags.image || (command ? inferredImage : undefined);
   const detach       = flags.detach || false;
   const fallbackMode = flags.noFallback ? 'none' : (flags.fallback || 'closest');
   const maxRuntimeMs = flags.maxRuntime ? flags.maxRuntime * 60 * 1000 : null;
@@ -354,54 +318,14 @@ export async function runCommand(config, args, chalk) {
     : (flags.tier || '1');
 
   // ── Auto GPU selection (no --gpu specified) ────────────────────────────────
-  let gpu = flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : null;
-  let autoRegion = null;
+  let gpu = flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : 'auto';
 
-  // Infer workload from the command so the backend can apply the correct VRAM floor.
-  const workload = command ? inferWorkload(command) : 'general';
-  const workloadLabel = WORKLOAD_LABELS[workload] || 'GPU job';
-
-  if (!gpu) {
-    console.log(chalk.bold(`\n⚡ Running ${workloadLabel}\n`));
+  if (gpu === 'auto') {
+    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}`);
     if (effectiveTier === '2') console.log(`  ${chalk.dim('(tier 2 — marketplace routing)')}`)
     console.log();
-    process.stdout.write(chalk.dim('  Finding best GPU...'));
-
-    let best;
-    try {
-      best = await findAutoGpu(config, chalk, effectiveTier, workload);
-    } catch (err) {
-      process.stdout.write('\n');
-      console.error(chalk.red(`\n  ✗ Could not find GPU capacity: ${err.message}\n`));
-      process.exit(1);
-    }
-
-    process.stdout.write('\n');
-
-    if (!best) {
-      console.error(chalk.red('\n  ✗ No GPU capacity available right now.\n'));
-      console.error(chalk.dim('  Run `badgr capacity` for details, or try again in a few minutes.'));
-      process.exit(1);
-    }
-
-    const vramNote = best.min_vram_gb ? chalk.dim(` (${best.min_vram_gb}GB VRAM)`) : '';
-    console.log(`\n  ${chalk.bold('Selected:')}   ${chalk.cyan(best.gpu)} in ${best.region} — ${chalk.green('$' + best.price.toFixed(2) + '/hr')}${vramNote}`);
-    console.log();
-
-    if (effectiveTier === '2' && process.stdin.isTTY) {
-      // Budget mode: confirm because the user is being routed to a less reliable provider.
-      const answer = await askConfirm(`  Press ${chalk.bold('Enter')} to run on tier 2 (marketplace), or ${chalk.bold('q')} to cancel: `);
-      if (answer.toLowerCase() === 'q') {
-        console.log(chalk.dim('\n  Cancelled.\n'));
-        process.exit(0);
-      }
-    }
-
-    gpu = best.gpu;
-    autoRegion = best.region;
-    console.log();
   } else {
     // Specific GPU requested — show header
     console.log(chalk.bold('\n⚡ Running GPU job\n'));
@@ -419,15 +343,13 @@ export async function runCommand(config, args, chalk) {
     }
   }
 
-  console.log(chalk.dim('  Finding best available GPU capacity...'));
+  console.log(chalk.dim('  Finding reliable capacity...'));
   if (process.env.BADGR_DEBUG === '1' || process.env.BADGR_DEBUG === 'true') {
     console.log(chalk.dim(`  API: ${config.baseUrl}`));
   }
 
-  function buildBody(gpuOverride, regionOverride) {
-    const effectiveRegion = regionOverride
-      ?? autoRegion
-      ?? (flags.region ? flags.region.toUpperCase() : undefined);
+  function buildBody(gpuOverride) {
+    const effectiveRegion = flags.region ? flags.region.toUpperCase() : undefined;
     return {
       command,
       image,
@@ -534,6 +456,7 @@ export async function runCommand(config, args, chalk) {
   console.log();
   console.log(chalk.bold(`  Job ID:    ${chalk.cyan(dep.deployment_id)}`));
   console.log(`  ${chalk.bold('GPU:')}      ${dep.gpu_type} × ${dep.gpu_count}`);
+  if (dep.workload_desc) console.log(`  ${chalk.bold('Workload:')} ${dep.workload_desc}`);
   if (dep.tier) console.log(`  ${chalk.bold('Tier:')}     ${dep.tier}`);
   if (dep.cost_per_hour > 0) console.log(`  ${chalk.bold('Rate:')}     $${dep.cost_per_hour.toFixed(2)}/hr`);
   console.log(`  ${chalk.bold('Receipt:')}  ${chalk.dim(rcptId)}`);
@@ -544,8 +467,10 @@ export async function runCommand(config, args, chalk) {
     return;
   }
 
-  // If the backend is still running the smoke check, wait for it to finish.
-  if (dep.status === 'starting') {
+  // Wait through startup phases (queued → provisioning → starting → running).
+  // The max-runtime clock does NOT start until this returns — image pull time is free.
+  const STARTUP_STATES = new Set(['queued', 'provisioning', 'starting']);
+  if (STARTUP_STATES.has(dep.status)) {
     console.log();
     dep = await waitForRunning(config, dep.deployment_id, chalk);
   }
@@ -559,7 +484,7 @@ export async function runCommand(config, args, chalk) {
   }
 
   const ratePerHour = dep.cost_per_hour || 0;
-  console.log(chalk.dim('\n  ── Live status (Ctrl+C to stop) ─────────────────────────────────\n'));
+  console.log(chalk.dim('\n  ── Running command (Ctrl+C to stop) ────────────────────────────\n'));
 
   async function teardown(reason) {
     const labels = {
@@ -621,7 +546,12 @@ export async function runCommand(config, args, chalk) {
     }
     console.log();
     process.exit(exitCode ?? 1);
-  } else if (finalStatus === 'completed' && (exitCode === 0 || exitCode === null)) {
-    console.log(chalk.green(`\n  ✓ Complete\n`));
+  } else if ((finalStatus === 'completed' || finalStatus === 'succeeded') && (exitCode === 0 || exitCode === null)) {
+    try {
+      await terminateDeployment(config, dep.deployment_id);
+    } catch { /* already stopped */ }
+    console.log(chalk.green(`\n  ✓ Complete`));
+    console.log(chalk.dim(`  Billing ended`));
+    console.log();
   }
 }

package/src/commands/serve.js

@@ -84,7 +84,7 @@ export async function serveCommand(config, args, chalk) {
   console.log(`  ${chalk.bold('GPU:')}    ${gpuLabel}`);
   if (effectiveTier === '2') console.log(`  ${chalk.dim('(tier 2 — marketplace routing)')}`);
   console.log();
-  process.stdout.write(chalk.dim('  Finding GPU capacity...\n'));
+  process.stdout.write(chalk.dim('  Finding reliable capacity...\n'));
 
   const effectiveRegion = flags.region ? flags.region.toUpperCase() : undefined;
 

package/src/commands/test-run.js

@@ -2,11 +2,13 @@ import { requireApiKey } from '../config.js';
 import { callApi, terminateDeployment } from '../api.js';
 import { addReceipt, generateReceiptId } from '../store.js';
 
-// max $1.50/hr × 2 min ≈ $0.05 total spend cap
-const TEST_MAX_PRICE  = 1.50;
+// max $0.80/hr × 2 min ≈ $0.027 total spend cap (smoke / Modal T4 tier)
+const TEST_MAX_PRICE  = 0.80;
 const TEST_MAX_RUNTIME_MS = 2 * 60 * 1000;
 const TEST_COMMAND    = ['python', '-c', "print('hello from badgr')"];
-const TEST_IMAGE      = 'python:3.11-slim';
+// Use alpine (7MB) instead of slim (50MB) — dramatically faster image pull for smoke tests.
+// Falls back gracefully: alpine has python3 and supports the test command identically.
+const TEST_IMAGE      = 'python:3.11-alpine';
 const EXPECTED_OUTPUT = 'hello from badgr';
 
 // --provider flag resolves to a backend tier value.
@@ -18,6 +20,7 @@ export function parseTestArgs(args) {
   let i = 0;
   while (i < args.length) {
     if (args[i] === '--provider' && args[i + 1]) { flags.provider = args[++i]; i++; continue; }
+    if (args[i] === '--no-tier-fallback') { flags.noTierFallback = true; i++; continue; }
     i++;
   }
   return flags;
@@ -44,20 +47,36 @@ async function pollStatus(config, depId, targetStatuses, timeoutMs) {
   return null;
 }
 
-async function pollLogs(config, depId, expected, timeoutMs) {
+async function pollOutputOrDone(config, depId, expected, timeoutMs) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
-    await new Promise(r => setTimeout(r, 4000));
+    await new Promise(r => setTimeout(r, 3000));
     try {
+      const dep = await callApi(`/deployments/${depId}`, {
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+      });
+      if (dep.status === 'succeeded' || dep.status === 'failed') {
+        const data = await callApi(`/deployments/${depId}/logs`, {
+          apiKey: config.apiKey,
+          baseUrl: config.baseUrl,
+        });
+        const lines = data?.logs ?? [];
+        return {
+          done: true,
+          ok: dep.status === 'succeeded' && lines.some(l => l.includes(expected)),
+          exitCode: dep.exit_code,
+        };
+      }
       const data = await callApi(`/deployments/${depId}/logs`, {
         apiKey: config.apiKey,
         baseUrl: config.baseUrl,
       });
       const lines = data?.logs ?? [];
-      if (lines.some(l => l.includes(expected))) return true;
+      if (lines.some(l => l.includes(expected))) return { done: true, ok: true, exitCode: 0 };
     } catch { /* retry */ }
   }
-  return false;
+  return { done: false, ok: false, exitCode: null };
 }
 
 export async function testCommand(config, args, chalk) {
@@ -106,7 +125,7 @@ export async function testCommand(config, args, chalk) {
   const baseBody = {
     command: TEST_COMMAND,
     image:   TEST_IMAGE,
-    gpu:     'RTX_3080',
+    gpu:     'auto',
     max_price_per_hour: TEST_MAX_PRICE,
   };
   try {
@@ -117,7 +136,7 @@ export async function testCommand(config, args, chalk) {
       body: { ...baseBody, tier },
     });
   } catch (err) {
-    if (err.errorData?.code === 'NO_CAPACITY_MATCH' && tier === '1') {
+    if (err.errorData?.code === 'NO_CAPACITY_MATCH' && tier === '1' && !flags.noTierFallback) {
       process.stdout.write('\n');
       process.stdout.write(chalk.dim('  No tier 1 capacity — trying tier 2 marketplace routing...'));
       try {
@@ -134,6 +153,12 @@ export async function testCommand(config, args, chalk) {
         console.error(chalk.red('  Test failed — no GPU capacity available on any provider.\n'));
         process.exit(1);
       }
+    } else if (err.errorData?.code === 'NO_CAPACITY_MATCH' && flags.noTierFallback) {
+      process.stdout.write('\n');
+      step(chalk, false, 'Provisioned', 'no tier 1 capacity');
+      console.log();
+      console.error(chalk.red('  Test failed — no tier 1 capacity (strict mode, no tier 2 fallback).\n'));
+      process.exit(1);
     } else {
       process.stdout.write('\n');
       step(chalk, false, 'Provisioned', err.message);
@@ -166,10 +191,13 @@ export async function testCommand(config, args, chalk) {
 
   // ── 3. Command output ────────────────────────────────────────────────────
   process.stdout.write(chalk.dim('  Checking command output...'));
-  const gotOutput = await pollLogs(config, depId, EXPECTED_OUTPUT, 90_000);
+  const outputResult = await pollOutputOrDone(config, depId, EXPECTED_OUTPUT, 90_000);
   process.stdout.write('\n');
+  const gotOutput = outputResult.ok;
   if (gotOutput) {
     step(chalk, true, 'Command printed output');
+  } else if (outputResult.done && outputResult.exitCode !== 0) {
+    step(chalk, false, 'Command printed output', `exit ${outputResult.exitCode}`);
   } else {
     step(chalk, false, 'Command printed output', 'not found in logs (logs may be buffered)');
   }
@@ -190,18 +218,22 @@ export async function testCommand(config, args, chalk) {
     action:       'badgr test',
     deploymentId: depId,
     gpu:          dep.gpu_type,
-    status:       'test_complete',
+    status:       gotOutput ? 'test_passed' : 'test_failed',
     createdAt:    new Date().toISOString(),
   });
   step(chalk, true, 'Receipt created', rcptId);
 
   // ── Summary ──────────────────────────────────────────────────────────────
   console.log();
-  const passed = stopped;
+  const passed = stopped && gotOutput;
   if (passed) {
     console.log(chalk.green(chalk.bold('  ✓ Test passed\n')));
   } else {
-    console.log(chalk.red(chalk.bold('  ✗ Test failed\n')));
+    if (!gotOutput) {
+      console.error(chalk.red('  Test failed — expected output not found in logs\n'));
+    } else {
+      console.error(chalk.red('  Test failed — could not stop billing\n'));
+    }
     process.exit(1);
   }
 }

package/src/router.js

@@ -1,20 +1,24 @@
 /**
- * GPU catalog — static specs only (name, VRAM, tags, indicative rate).
+ * GPU catalog — static display info only (name, VRAM, tags, indicative rate).
  *
- * Provider-level pricing and routing logic have been removed from the CLI.
- * Live routing decisions happen server-side; the CLI is a thin display layer.
- * For live availability and routing, use GET /v1/capacity/debug (operators)
- * or GET /v1/capacity/suggestions (users).
+ * ratePerHour values are indicative market averages for reference display.
+ * Actual billing is always set by the backend and returned as cost_per_hour
+ * on every deployment response. For live rates, use GET /v1/gpus.
+ *
+ * Provider routing logic lives entirely in the backend.
  */
 
 export const GPU_CATALOG = [
-  { id: 'rtx-3080',  canonical: 'RTX_3080', name: 'NVIDIA RTX 3080',  vramGb: 10, ratePerHour: 0.35, tags: ['inference', 'dev'] },
-  { id: 'rtx-4090',  canonical: 'RTX_4090', name: 'NVIDIA RTX 4090',  vramGb: 24, ratePerHour: 1.10, tags: ['inference', 'training', 'dev'] },
-  { id: 'l40s',      canonical: 'L40S',     name: 'NVIDIA L40S',      vramGb: 48, ratePerHour: 1.40, tags: ['inference', 'training'] },
-  { id: 'a6000',     canonical: 'A6000',    name: 'NVIDIA RTX A6000', vramGb: 48, ratePerHour: 1.60, tags: ['inference', 'training'] },
-  { id: 'a100-40gb', canonical: 'A100',     name: 'NVIDIA A100 40GB', vramGb: 40, ratePerHour: 1.80, tags: ['training', 'inference'] },
-  { id: 'a100-80gb', canonical: 'A100',     name: 'NVIDIA A100 80GB', vramGb: 80, ratePerHour: 2.50, tags: ['training', 'large-model'] },
-  { id: 'h100',      canonical: 'H100',     name: 'NVIDIA H100 80GB', vramGb: 80, ratePerHour: 3.50, tags: ['training', 'large-model'] },
+  { id: 'rtx-3080',  canonical: 'RTX_3080',  name: 'NVIDIA RTX 3080',   vramGb: 10, ratePerHour: 0.35, tags: ['inference', 'dev'] },
+  { id: 'rtx-3090',  canonical: 'RTX_3090',  name: 'NVIDIA RTX 3090',   vramGb: 24, ratePerHour: 0.60, tags: ['inference', 'dev'] },
+  { id: 'rtx-4090',  canonical: 'RTX_4090',  name: 'NVIDIA RTX 4090',   vramGb: 24, ratePerHour: 1.10, tags: ['inference', 'training', 'dev'] },
+  { id: 'a4000',     canonical: 'A4000',      name: 'NVIDIA RTX A4000',  vramGb: 16, ratePerHour: 0.50, tags: ['inference', 'dev'] },
+  { id: 'a5000',     canonical: 'A5000',      name: 'NVIDIA RTX A5000',  vramGb: 24, ratePerHour: 0.70, tags: ['inference', 'dev'] },
+  { id: 'l40s',      canonical: 'L40S',       name: 'NVIDIA L40S',       vramGb: 48, ratePerHour: 1.40, tags: ['inference', 'training'] },
+  { id: 'a6000',     canonical: 'A6000',      name: 'NVIDIA RTX A6000',  vramGb: 48, ratePerHour: 1.60, tags: ['inference', 'training'] },
+  { id: 'a100-40gb', canonical: 'A100',       name: 'NVIDIA A100 40GB',  vramGb: 40, ratePerHour: 1.80, tags: ['training', 'inference'] },
+  { id: 'a100-80gb', canonical: 'A100_80GB',  name: 'NVIDIA A100 80GB',  vramGb: 80, ratePerHour: 2.50, tags: ['training', 'large-model'] },
+  { id: 'h100',      canonical: 'H100',       name: 'NVIDIA H100 80GB',  vramGb: 80, ratePerHour: 3.50, tags: ['training', 'large-model'] },
 ];
 
 export function findById(id) {

package/tests/commands.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi } from 'vitest';
-import { parseRunArgs, classifyFailure, inferWorkload } from '../src/commands/run.js';
+import { parseRunArgs, classifyFailure } from '../src/commands/run.js';
 import { parseServeArgs } from '../src/commands/serve.js';
 import { testCommand, parseTestArgs } from '../src/commands/test-run.js';
 import { rankAlternatives, diffDescription, promptFallback } from '../src/fallback.js';
@@ -232,38 +232,9 @@ describe('parseTestArgs', () => {
   it('parses --provider secondary', () => {
     expect(parseTestArgs(['--provider', 'secondary'])).toEqual({ provider: 'secondary' });
   });
-});
-
-describe('inferWorkload', () => {
-  it('returns general for empty command', () => {
-    expect(inferWorkload([])).toBe('general');
-    expect(inferWorkload(null)).toBe('general');
-  });
-
-  it('returns smoke_test for short print() one-liners', () => {
-    expect(inferWorkload(['python', '-c', "print('hello')"])).toBe('smoke_test');
-    expect(inferWorkload(['python', '-c', "print('hello from badgr')"])).toBe('smoke_test');
-  });
-
-  it('returns general for a typical script', () => {
-    expect(inferWorkload(['python', 'script.py'])).toBe('general');
-    expect(inferWorkload(['python', 'run.py', '--epochs', '10'])).toBe('general');
-  });
-
-  it('returns lora_finetune for LoRA/fine-tuning keywords', () => {
-    expect(inferWorkload(['python', 'lora_train.py'])).toBe('lora_finetune');
-    expect(inferWorkload(['python', '-c', 'import peft; finetune()'])).toBe('lora_finetune');
-    expect(inferWorkload(['python', 'train.py', '--epochs', '3'])).toBe('lora_finetune');
-  });
-
-  it('returns image_gen for diffusion keywords', () => {
-    expect(inferWorkload(['python', 'stable_diff.py'])).toBe('image_gen');
-    expect(inferWorkload(['python', 'run_sdxl.py'])).toBe('image_gen');
-  });
 
-  it('returns inference_small for vllm/tgi', () => {
-    expect(inferWorkload(['python', '-m', 'vllm.entrypoints.openai.api_server'])).toBe('inference_small');
-    expect(inferWorkload(['python', 'serve_tgi.py'])).toBe('inference_small');
+  it('parses --no-tier-fallback', () => {
+    expect(parseTestArgs(['--no-tier-fallback'])).toEqual({ noTierFallback: true });
   });
 });