badgr-cli 1.0.26 → 1.0.28

package/package.json

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

package/src/api.js

@@ -59,6 +59,24 @@ export async function callApi(path, { method = 'GET', apiKey, baseUrl, body } =
       detail = rawBody || res.statusText || '';
     }
     const isCapacityError = errorData?.code === 'NO_CAPACITY_MATCH';
+    if (res.status === 402) {
+      // Payment required — format a clear, actionable error
+      const d = errorData?.detail ?? errorData ?? {};
+      const detailObj = typeof d === 'object' ? d : {};
+      const balanceUsd = typeof detailObj.balance_usd === 'number' ? detailObj.balance_usd : null;
+      const requiredUsd = typeof detailObj.required_usd === 'number' ? detailObj.required_usd : null;
+      const topupUrl = detailObj.topup_url || 'https://aibadgr.com/dashboard#billing';
+
+      let msg = '\nPayment required.\n';
+      if (balanceUsd !== null) msg += `Your balance is $${balanceUsd.toFixed(2)}.`;
+      if (requiredUsd !== null) msg += ` This job needs a $${requiredUsd.toFixed(2)} reserve.`;
+      msg += '\n\nAdd balance:\n  ' + topupUrl + '\n';
+      const err = new Error(msg);
+      err.errorData = errorData;
+      err.httpStatus = 402;
+      err.isPaymentRequired = true;
+      throw err;
+    }
     const hint =
       res.status === 401 ? '\n  Hint: Invalid or missing API key — run: badgr login' :
       res.status === 403 ? '\n  Hint: Access denied — check your API key permissions' :

package/src/badgr.js

@@ -12,6 +12,7 @@ import { serveCommand }    from './commands/serve.js';
 import { modelsCommand }   from './commands/models.js';
 import { capacityCommand } from './commands/capacity.js';
 import { testCommand }     from './commands/test-run.js';
+import { billingCommand }  from './commands/billing.js';
 
 const HELP = `
 ${chalk.bold('badgr')} — run or serve GPU workloads from one command
@@ -26,6 +27,7 @@ ${chalk.bold('COMMANDS')}
   ${chalk.cyan('badgr receipts')}            Show cost history
   ${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.bold('EXAMPLES')}
   ${chalk.dim('# Verify the stack works end-to-end:')}
@@ -104,6 +106,7 @@ async function main() {
     case 'models':   return modelsCommand(config, chalk);
     case 'capacity': return capacityCommand(config, rest, chalk);
     case 'test':     return testCommand(config, rest, chalk);
+    case 'billing':  return billingCommand(config, rest, chalk);
     // legacy aliases kept for compatibility
     case 'up':       return upCommand(config, rest, chalk);
     case 'config': {

package/src/commands/billing.js

@@ -0,0 +1,93 @@
+import { execSync } from 'child_process';
+import { requireApiKey } from '../config.js';
+import { callApi } from '../api.js';
+
+const BILLING_HELP = `
+badgr billing — manage your AI Badgr balance
+
+COMMANDS
+  badgr billing status         Show current balance
+  badgr billing add <amount>   Open checkout to add balance (minimum $10)
+
+EXAMPLES
+  badgr billing status
+  badgr billing add 10
+  badgr billing add 20
+  badgr billing add 50
+`;
+
+function openBrowser(url) {
+  const platform = process.platform;
+  try {
+    if (platform === 'darwin') execSync(`open "${url}"`);
+    else if (platform === 'win32') execSync(`start "" "${url}"`);
+    else execSync(`xdg-open "${url}"`);
+  } catch {
+    // Silently ignore — we print the URL anyway
+  }
+}
+
+async function billingStatus(config, chalk) {
+  requireApiKey(config);
+  try {
+    const apiUrl = config.baseUrl.replace('/v1', '').replace('/api/v1', '');
+    const data = await callApi('/api/me', {
+      apiKey: config.apiKey,
+      baseUrl: apiUrl,
+    });
+    const credits = data.credits ?? 0;
+    const balanceUsd = (credits / 10000).toFixed(2);
+    console.log();
+    console.log(chalk.bold('  Balance'));
+    console.log(`  ${chalk.bold(chalk.blue(`$${balanceUsd}`))}`);
+    console.log();
+    if (credits === 0) {
+      console.log(chalk.yellow('  Balance is $0.00. Add balance before making API calls or running GPU jobs.'));
+      console.log(chalk.dim('  Add balance: badgr billing add 10'));
+      console.log(chalk.dim('  Or visit:    https://aibadgr.com/billing/top-up'));
+    }
+    console.log();
+  } catch (err) {
+    if (err.isPaymentRequired) {
+      console.error(err.message);
+      process.exit(1);
+    }
+    console.error(chalk.red('  Could not fetch balance: ' + err.message));
+    process.exit(1);
+  }
+}
+
+async function billingAdd(config, amount, chalk) {
+  requireApiKey(config);
+  const amountInt = parseInt(amount, 10);
+  if (!amountInt || amountInt < 10) {
+    console.error(chalk.red('  Minimum top-up is $10. Example: badgr billing add 10'));
+    process.exit(1);
+  }
+
+  const url = `https://aibadgr.com/dashboard#billing`;
+  console.log();
+  console.log(chalk.bold(`  Opening dashboard billing to add $${amountInt}...`));
+  console.log();
+  console.log(`  ${chalk.dim(url)}`);
+  console.log();
+  openBrowser(url);
+  console.log(chalk.dim('  Complete payment in your browser, then rerun your command.'));
+  console.log();
+}
+
+export async function billingCommand(config, args, chalk) {
+  const [sub, ...rest] = args;
+
+  if (!sub || sub === '--help' || sub === '-h') {
+    console.log(BILLING_HELP);
+    return;
+  }
+
+  if (sub === 'status') return billingStatus(config, chalk);
+  if (sub === 'add') return billingAdd(config, rest[0], chalk);
+
+  console.error(chalk.red(`  Unknown billing command: ${sub}`));
+  console.log(chalk.dim('  Run: badgr billing --help'));
+  process.exit(1);
+}

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

@@ -89,7 +89,7 @@ async function waitForRunning(config, depId, chalk) {
   const TIMEOUT_MS  = 5 * 60 * 1000; // 5 min startup grace (image pull + container init)
   const startMs     = Date.now();
   const PHASES = [
-    { afterMs:     0, label: '  Starting machine'     },
+    { afterMs:     0, label: '  Starting container'    },
     { afterMs: 15000, label: '  Pulling image'         },
     { afterMs: 60000, label: '  Starting container'    },
     { afterMs: 180000, label: '  Running command'      },
@@ -285,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()); }));
@@ -359,10 +302,10 @@ export async function runCommand(config, args, chalk) {
   requireApiKey(config);
 
   const command      = positional.length > 0 ? positional : undefined;
-  // Use alpine for smoke tests (7MB vs 50MB — much faster pull), slim for general workloads
-  const inferredImage = (command && inferWorkload(command) === 'smoke_test')
-    ? 'python:3.11-alpine'
-    : 'python:3.11-slim';
+  // 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');
@@ -377,12 +320,8 @@ export async function runCommand(config, args, chalk) {
   // ── Auto GPU selection (no --gpu specified) ────────────────────────────────
   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 === 'auto') {
-    console.log(chalk.bold(`\n⚡ Running ${workloadLabel}\n`));
+    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)')}`)
@@ -404,7 +343,7 @@ export async function runCommand(config, args, chalk) {
     }
   }
 
-  console.log(chalk.dim('  Starting machine...'));
+  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}`));
   }
@@ -492,6 +431,11 @@ export async function runCommand(config, args, chalk) {
         console.error(chalk.dim(`  Run BADGR_DEBUG=1 badgr run … for a full trace.\n`));
       }
       process.exit(1);
+    } else if (err.isPaymentRequired) {
+      console.error(chalk.yellow(err.message));
+      const rerun = ['badgr run', ...args].join(' ');
+      console.error(chalk.dim(`After payment, rerun:\n  ${rerun}\n`));
+      process.exit(1);
     } else {
       console.error(chalk.red(`\n  ✗ Could not start job: ${err.message}\n`));
       console.error(chalk.dim(`  Run BADGR_DEBUG=1 badgr run … for a full trace.`));
@@ -517,6 +461,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)}`);
@@ -607,6 +552,11 @@ export async function runCommand(config, args, chalk) {
     console.log();
     process.exit(exitCode ?? 1);
   } else if ((finalStatus === 'completed' || finalStatus === 'succeeded') && (exitCode === 0 || exitCode === null)) {
-    console.log(chalk.green(`\n  ✓ Job complete\n`));
+    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;
 
@@ -171,6 +171,12 @@ export async function serveCommand(config, args, chalk) {
         failureType: 'infrastructure',
         createdAt:   new Date().toISOString(),
       });
+      if (err.isPaymentRequired) {
+        console.error(chalk.yellow(err.message));
+        const rerun = `badgr serve ${args.join(' ')}`;
+        console.error(chalk.dim(`After payment, rerun:\n  ${rerun}\n`));
+        return;
+      }
       console.error(chalk.red(`\n  ✗ Could not start endpoint: ${err.message}`));
       console.error(chalk.dim(`\n  Receipt: ${failRcptId}`));
       console.error(chalk.dim(`  Run BADGR_DEBUG=1 badgr serve … for a full trace.\n`));

package/src/commands/test-run.js

@@ -2,8 +2,8 @@ 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')"];
 // Use alpine (7MB) instead of slim (50MB) — dramatically faster image pull for smoke tests.
@@ -20,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;
@@ -46,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) {
@@ -119,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 {
@@ -136,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);
@@ -152,7 +175,8 @@ export async function testCommand(config, args, chalk) {
   process.stdout.write(chalk.dim('  Waiting for container to start...'));
   const started = await pollStatus(
     config, depId,
-    new Set(['running', 'failed', 'stopped', 'completed']),
+    // Modal serverless jobs may skip straight to succeeded when the callback fires.
+    new Set(['running', 'starting', 'succeeded', 'failed', 'stopped', 'completed']),
     TEST_MAX_RUNTIME_MS,
   );
   process.stdout.write('\n');
@@ -168,10 +192,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)');
   }

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 });
   });
 });