badgr-cli 1.0.29 → 1.0.30

package/package.json

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

package/src/commands/run.js

@@ -1,7 +1,7 @@
-import readline from 'readline';
 import { requireApiKey } from '../config.js';
 import { callApi, terminateDeployment } from '../api.js';
 import { addReceipt, updateReceipt, generateReceiptId } from '../store.js';
+import { normalizeTier, callWithFallback, HIGH_RATE_THRESHOLD } from '../fallback.js';
 
 /**
  * badgr run python train.py                    # gpu=auto, attached
@@ -21,8 +21,10 @@ export function parseRunArgs(args) {
     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] === '--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; }
     positional.push(args[i++]);
@@ -30,6 +32,25 @@ export function parseRunArgs(args) {
   return { flags, positional };
 }
 
+// Mirror of backend workload_profile.py — kept in sync for pre-flight display.
+const _PROFILES = {
+  smoke_test:       { label: 'smoke test',            vram: '4 GB',    gpus: ['RTX 3080', 'RTX 3090', 'RTX 4090'] },
+  lora_finetune:    { label: 'fine-tuning (LoRA)',     vram: '40+ GB',  gpus: ['A6000', 'L40S', 'A100'] },
+  image_gen:        { label: 'image generation',       vram: '16+ GB',  gpus: ['RTX 4090', 'A6000', 'L40S'] },
+  inference_small:  { label: 'inference (7B–8B model)', vram: '24+ GB', gpus: ['RTX 4090', 'A6000', 'L40S'] },
+  general:          { label: 'GPU job',                vram: '16+ GB',  gpus: ['RTX 4090', 'RTX 3090', 'A6000', 'L40S'] },
+};
+
+function inferProfileFromCommand(cmdStr) {
+  const s = cmdStr.toLowerCase();
+  if (/print\s*\(|['"]hello/.test(s) && s.length < 100) return 'smoke_test';
+  if (/lora|qlora|finetune|fine[_-]tun|peft/.test(s))    return 'lora_finetune';
+  if (/diffusion|stable.?diff|sdxl|sd.?xl|comfyui|a1111|invoke|kohya/.test(s)) return 'image_gen';
+  if (/vllm|tgi|text.generation.inference/.test(s))       return 'inference_small';
+  if (/\btrain\.py\b/.test(s))                            return 'lora_finetune';
+  return 'general';
+}
+
 function fmtRuntime(ms) {
   const s = Math.round(ms / 1000);
   if (s < 60) return `${s}s`;
@@ -82,7 +103,7 @@ function renderStatusBar(chalk, { elapsedMs, ratePerHour, gpuUtil, cpuUtil, maxR
 }
 
 // Wait for status to leave 'starting'/'queued'/'provisioning'.
-// This covers image pull time — runtime limit does NOT start until this returns.
+// The 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;
@@ -285,11 +306,6 @@ async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost
   }
 }
 
-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()); }));
-}
-
 export async function runCommand(config, args, chalk) {
   const { flags, positional } = parseRunArgs(args);
 
@@ -312,10 +328,7 @@ export async function runCommand(config, args, chalk) {
   const maxRuntimeMs = flags.maxRuntime ? flags.maxRuntime * 60 * 1000 : null;
   const maxCost      = flags.maxCost ?? null;
 
-  // Tier 1 = managed routing (default). Tier 2 = marketplace routing, opt-in via --tier 2.
-  const effectiveTier = (flags.tier === '2' || flags.tier === 'tier2' || flags.tier === 'tier-2')
-    ? '2'
-    : (flags.tier || '1');
+  const effectiveTier = normalizeTier(flags.tier);
 
   // ── Auto GPU selection (no --gpu specified) ────────────────────────────────
   let gpu = flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : 'auto';
@@ -324,7 +337,16 @@ export async function runCommand(config, args, chalk) {
     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)')}`)
+    // Show workload estimate so the user knows what Badgr inferred.
+    if (command) {
+      const profKey = inferProfileFromCommand(cmdStr);
+      const prof = _PROFILES[profKey];
+      console.log();
+      console.log(`  ${chalk.bold('Estimated workload:')}      ${prof.label}`);
+      console.log(`  ${chalk.bold('Estimated minimum VRAM:')}  ${prof.vram}`);
+      if (maxCost)          console.log(`  ${chalk.bold('Max cost:')}                $${maxCost.toFixed(2)}`);
+      if (flags.maxRuntime) console.log(`  ${chalk.bold('Max runtime:')}             ${flags.maxRuntime}min`);
+    }
     console.log();
   } else {
     // Specific GPU requested — show header
@@ -343,12 +365,12 @@ export async function runCommand(config, args, chalk) {
     }
   }
 
-  console.log(chalk.dim('  Finding reliable capacity...'));
+  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}`));
   }
 
-  function buildBody(gpuOverride) {
+  function buildBody(gpuOverride, tierOverride) {
     const effectiveRegion = flags.region ? flags.region.toUpperCase() : undefined;
     return {
       command,
@@ -358,94 +380,28 @@ export async function runCommand(config, args, chalk) {
       ...(effectiveRegion ? { region: effectiveRegion } : {}),
       max_price_per_hour: flags.maxPrice,
       name: flags.name,
-      tier: effectiveTier,
+      tier: tierOverride || effectiveTier,
     };
   }
 
   let dep;
   try {
-    dep = await callApi('/run', {
-      method: 'POST',
-      apiKey: config.apiKey,
-      baseUrl: config.baseUrl,
-      body: buildBody(),
-    });
+    dep = await callWithFallback(
+      '/run',
+      { apiKey: config.apiKey, baseUrl: config.baseUrl },
+      (tierOverride) => buildBody(undefined, tierOverride),
+      effectiveTier,
+      chalk,
+      { thing: 'job', cmd: 'badgr run' },
+    );
   } catch (err) {
-    const d = err.errorData;
-    if (d?.code === 'NO_CAPACITY_MATCH') {
-      if (effectiveTier === '2') {
-        console.error(chalk.red('\n  ✗ No GPU capacity available right now on any provider.\n'));
-        console.error(chalk.dim('  Try `badgr capacity` to see what\'s available, or try again shortly.'));
-        process.exit(1);
-      }
-
-      // Tier 1 out of capacity — offer tier 2 marketplace routing.
-      if (process.stdin.isTTY) {
-        const answer = await askConfirm(
-          `\n  No tier 1 capacity available. Try tier 2 marketplace routing? [${chalk.bold('Enter')}/${chalk.bold('q')}]: `
-        );
-        if (answer.toLowerCase() === 'q') {
-          console.log(chalk.dim('\n  Cancelled.\n'));
-          process.exit(0);
-        }
-      } else {
-        console.log(chalk.dim('\n  No tier 1 capacity — trying tier 2 marketplace routing...\n'));
-      }
-
-      console.log(chalk.dim('  Searching tier 2 capacity...'));
-      try {
-        dep = await callApi('/run', {
-          method: 'POST',
-          apiKey: config.apiKey,
-          baseUrl: config.baseUrl,
-          body: { ...buildBody(), tier: '2' },
-        });
-      } catch (err2) {
-        const d2 = err2.errorData;
-        if (d2?.code === 'NO_CAPACITY_MATCH') {
-          console.error(chalk.red('\n  ✗ No GPU capacity available right now on any provider.\n'));
-          console.error(chalk.dim('  Try `badgr capacity` to see what\'s available, or try again shortly.'));
-        } else if (d2?.code === 'PROVISIONING_FAILED' || d2?.code === 'PROVIDER_ADAPTER_ERROR') {
-          console.error(chalk.red(`\n  ✗ Budget provider found capacity but could not start the machine. Please try again.\n`));
-          // (error detail kept below)
-          if (process.env.BADGR_DEBUG === '1' || process.env.BADGR_DEBUG === 'true') {
-            if (d2?.debug_error) console.error(chalk.dim(`  Provider detail: ${d2.debug_error}`));
-          } else {
-            console.error(chalk.dim(`  Run BADGR_DEBUG=1 badgr run … for a full trace.\n`));
-          }
-        } else {
-          console.error(chalk.red(`\n  ✗ Could not start job on tier 2: ${err2.message}\n`));
-          console.error(chalk.dim(`  Run BADGR_DEBUG=1 badgr run … for a full trace.`));
-        }
-        process.exit(1);
-      }
-    } else if (d?.code === 'PROVISIONING_FAILED' || d?.code === 'PROVIDER_ADAPTER_ERROR') {
-      if (d?.low_cost_provider_failed) {
-        console.error(chalk.red(`\n  ✗ Tier 2 unavailable. Tier 1 also unavailable. Try again shortly.\n`));
-      } else {
-        console.error(chalk.red(`\n  ✗ Badgr found ${gpu} capacity but could not start the machine. Please try again.\n`));
-      }
-      if (process.env.BADGR_DEBUG === '1' || process.env.BADGR_DEBUG === 'true') {
-        if (d?.debug_error) console.error(chalk.dim(`  Provider detail: ${d.debug_error}`));
-      } else {
-        console.error(chalk.dim(`  Run BADGR_DEBUG=1 badgr run … for a full trace.\n`));
-      }
-      process.exit(1);
-    } else if (err.isPaymentRequired) {
+    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.`));
-      console.error(chalk.dim(`  Check config: badgr config\n`));
-      process.exit(1);
     }
-  }
-
-  if (dep.provider_fallback_note === 'tier2_failed_using_tier1') {
-    console.log(chalk.yellow('  ℹ Tier 2 unavailable. Running on Tier 1 instead.\n'));
+    throw err;
   }
 
   const rcptId = dep.receipt_id || generateReceiptId();
@@ -455,20 +411,27 @@ export async function runCommand(config, args, chalk) {
     deploymentId:  dep.deployment_id,
     gpu:           dep.gpu_type,
     providerRoute: dep.provider ?? null,
+    tier:          dep.tier ?? null,
     maxCost:       maxCost ?? null,
     maxRuntime:    flags.maxRuntime ?? null,
     status:        dep.status,
     createdAt:     new Date().toISOString(),
   });
 
-  console.log();
+  const rate = dep.cost_per_hour || 0;
+
+  console.log(chalk.dim('  Capacity found.\n'));
   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`);
+  if (rate > 0) console.log(`  ${chalk.bold('Rate:')}     $${rate.toFixed(2)}/hr`);
+  if (maxCost)  console.log(`  ${chalk.bold('Max cost:')} $${maxCost.toFixed(2)}`);
   console.log(`  ${chalk.bold('Receipt:')}  ${chalk.dim(rcptId)}`);
 
+  if (rate > HIGH_RATE_THRESHOLD && !maxCost) {
+    console.log(chalk.yellow(`\n  Selected capacity rate: $${rate.toFixed(2)}/hr`));
+    console.log(chalk.dim('  Tip: use --max-cost to enforce a hard ceiling.'));
+  }
+
   if (detach) {
     console.log(`\n  ${chalk.bold('Logs:')}     ${dep.logs_url || `badgr logs ${dep.deployment_id}`}`);
     console.log(chalk.dim(`\n  Detached. Track progress: badgr logs ${dep.deployment_id}\n`));
@@ -476,7 +439,7 @@ export async function runCommand(config, args, chalk) {
   }
 
   // Wait through startup phases (queued → provisioning → starting → running).
-  // The max-runtime clock does NOT start until this returns — image pull time is free.
+  // The max-runtime clock does NOT start until this returns.
   const STARTUP_STATES = new Set(['queued', 'provisioning', 'starting']);
   if (STARTUP_STATES.has(dep.status)) {
     console.log();

package/src/commands/serve.js

@@ -1,12 +1,6 @@
-import readline from 'readline';
 import { requireApiKey } from '../config.js';
-import { callApi } from '../api.js';
 import { addDeployment, addReceipt, updateReceipt, generateReceiptId } from '../store.js';
-
-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()); }));
-}
+import { normalizeTier, callWithFallback, HIGH_RATE_THRESHOLD } from '../fallback.js';
 
 /**
  * badgr serve meta-llama/Llama-3.1-8B-Instruct
@@ -25,13 +19,33 @@ export function parseServeArgs(args) {
     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] === '--no-wait')    { flags.noWait = true; i++; continue; }
+    if (args[i] === '--no-wait')               { flags.noWait = true; i++; continue; }
+    if (args[i] === '--max-cost')              { flags.maxCost = parseFloat(args[++i]); i++; continue; }
+    if (args[i] === '--strict-capacity')    { flags.noMarketplaceFallback = true; i++; continue; }
+    if (args[i] === '--no-expanded-search') { flags.noMarketplaceFallback = true; i++; continue; }
     positional.push(args[i++]);
   }
   const model = positional[0] || null;
   return { model, flags };
 }
 
+// Mirror of backend workload_profile.py infer_profile_from_model — for pre-flight display.
+function _inferServeProfile(modelName) {
+  const s = modelName.toLowerCase();
+  const moe = s.match(/(\d+)x(\d+)b/);
+  let paramsB;
+  if (moe) {
+    paramsB = parseInt(moe[1]) * parseInt(moe[2]);
+  } else {
+    const m = s.match(/(\d+)b/);
+    paramsB = m ? parseInt(m[1]) : null;
+  }
+  if (paramsB === null) return { label: 'inference (7B–8B model)', vram: '24+ GB', gpus: ['RTX 4090', 'A6000', 'L40S'] };
+  if (paramsB <= 9)    return { label: 'inference (7B–8B model)', vram: '24+ GB', gpus: ['RTX 4090', 'A6000', 'L40S'] };
+  if (paramsB <= 35)   return { label: 'inference (30B–34B model)', vram: '40+ GB', gpus: ['A6000', 'L40S', 'A100'] };
+  return                      { label: 'inference (70B+ model)',    vram: '80+ GB', gpus: ['H100', 'A100'] };
+}
+
 function _serveStageLabel(elapsedSec) {
   if (elapsedSec < 45)  return 'Starting vLLM…';
   if (elapsedSec < 150) return 'Downloading model…';
@@ -74,118 +88,68 @@ export async function serveCommand(config, args, chalk) {
   const gpu = flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : 'AUTO';
   const gpuLabel = gpu === 'AUTO' ? 'auto' : gpu;
 
-  // Tier 1 = managed routing (default). Tier 2 = marketplace routing, opt-in via --tier 2.
-  const effectiveTier = (flags.tier === '2' || flags.tier === 'tier2' || flags.tier === 'tier-2')
-    ? '2'
-    : (flags.tier || '1');
+  const effectiveTier = normalizeTier(flags.tier);
 
-  console.log(chalk.bold('\nServing model\n'));
+  console.log(chalk.bold('\n⚡ Serving model\n'));
   console.log(`  ${chalk.bold('Model:')}  ${model}`);
   console.log(`  ${chalk.bold('GPU:')}    ${gpuLabel}`);
-  if (effectiveTier === '2') console.log(`  ${chalk.dim('(tier 2 — marketplace routing)')}`);
+
+  // Show inferred workload so the user knows what Badgr detected.
+  if (gpu === 'AUTO') {
+    const prof = _inferServeProfile(model);
+    console.log();
+    console.log(`  ${chalk.bold('Estimated workload:')}      ${prof.label}`);
+    console.log(`  ${chalk.bold('Estimated minimum VRAM:')}  ${prof.vram}`);
+    if (flags.maxCost) console.log(`  ${chalk.bold('Max cost:')}           $${flags.maxCost.toFixed(2)}`);
+  }
   console.log();
-  process.stdout.write(chalk.dim('  Finding reliable capacity...\n'));
+  process.stdout.write(chalk.dim('  Finding suitable capacity...\n'));
 
   const effectiveRegion = flags.region ? flags.region.toUpperCase() : undefined;
 
-  function buildBody(gpuOverride, regionOverride) {
+  function buildBody(gpuOverride, tierOverride) {
     return {
       model,
       gpu: gpuOverride || gpu,
       gpu_count: flags.count || 1,
-      ...(regionOverride || effectiveRegion ? { region: regionOverride || effectiveRegion } : {}),
+      ...(effectiveRegion ? { region: effectiveRegion } : {}),
       max_price_per_hour: flags.maxPrice,
       name: flags.name,
-      tier: effectiveTier,
+      tier: tierOverride || effectiveTier,
     };
   }
 
   let dep;
   try {
-    dep = await callApi('/serve', {
-      method: 'POST',
-      apiKey: config.apiKey,
-      baseUrl: config.baseUrl,
-      body: buildBody(),
-    });
+    dep = await callWithFallback(
+      '/serve',
+      { apiKey: config.apiKey, baseUrl: config.baseUrl },
+      (tierOverride) => buildBody(undefined, tierOverride),
+      effectiveTier,
+      chalk,
+      { thing: 'endpoint', cmd: 'badgr serve' },
+    );
   } catch (err) {
-    const d = err.errorData;
-    if (d?.code === 'NO_CAPACITY_MATCH') {
-      if (effectiveTier === '2') {
-        console.error(chalk.red('\n  ✗ No GPU capacity available right now on any provider.\n'));
-        console.error(chalk.dim('  Run `badgr capacity` to see alternatives, or try again shortly.'));
-        process.exit(1);
-      }
-
-      // Tier 1 out of capacity — offer tier 2 marketplace routing.
-      if (process.stdin.isTTY) {
-        const answer = await askConfirm(
-          `\n  No tier 1 capacity available. Try tier 2 marketplace routing? [${chalk.bold('Enter')}/${chalk.bold('q')}]: `
-        );
-        if (answer.toLowerCase() === 'q') {
-          console.log(chalk.dim('\n  Cancelled.\n'));
-          process.exit(0);
-        }
-      } else {
-        console.log(chalk.dim('\n  No tier 1 capacity — trying tier 2 marketplace routing...\n'));
-      }
-
-      console.log(chalk.dim('  Searching tier 2 capacity...'));
-      try {
-        dep = await callApi('/serve', {
-          method: 'POST',
-          apiKey: config.apiKey,
-          baseUrl: config.baseUrl,
-          body: { ...buildBody(), tier: '2' },
-        });
-      } catch (err2) {
-        const d2 = err2.errorData;
-        if (d2?.code === 'NO_CAPACITY_MATCH') {
-          console.error(chalk.red('\n  ✗ No GPU capacity available right now on any provider.\n'));
-          console.error(chalk.dim('  Run `badgr capacity` to see alternatives, or try again shortly.'));
-        } else if (d2?.code === 'PROVISIONING_FAILED' || d2?.code === 'PROVIDER_ADAPTER_ERROR') {
-          console.error(chalk.red(`\n  ✗ Budget provider found capacity but could not start the endpoint. Please try again.\n`));
-          console.error(chalk.dim(`  Run BADGR_DEBUG=1 badgr serve … for a full trace.\n`));
-        } else {
-          console.error(chalk.red(`\n  ✗ Could not start endpoint on tier 2: ${err2.message}\n`));
-          console.error(chalk.dim(`  Run BADGR_DEBUG=1 badgr serve … for a full trace.\n`));
-        }
-        process.exit(1);
-      }
-    } else if (d?.code === 'PROVISIONING_FAILED' || d?.code === 'PROVIDER_ADAPTER_ERROR') {
-      if (d?.low_cost_provider_failed) {
-        console.error(chalk.red(`\n  ✗ Tier 2 unavailable. Tier 1 also unavailable. Try again shortly.\n`));
-      } else {
-        console.error(chalk.red(`\n  ✗ Badgr found capacity but could not start the endpoint. Please try again.\n`));
-      }
-      console.error(chalk.dim(`  Run BADGR_DEBUG=1 badgr serve … for a full trace.\n`));
-      process.exit(1);
-    } else {
-      const failRcptId = generateReceiptId();
-      addReceipt({
-        receiptId:   failRcptId,
-        action:      'badgr serve',
-        model,
-        gpu: gpuLabel,
-        status:      'failed',
-        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`));
+    const failRcptId = generateReceiptId();
+    addReceipt({
+      receiptId:   failRcptId,
+      action:      'badgr serve',
+      model,
+      gpu: gpuLabel,
+      status:      'failed',
+      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;
     }
-  }
-
-  if (dep.provider_fallback_note === 'tier2_failed_using_tier1') {
-    console.log(chalk.yellow('  ℹ Tier 2 unavailable. Running on Tier 1 instead.\n'));
+    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`));
+    return;
   }
 
   addDeployment({
@@ -200,6 +164,8 @@ export async function serveCommand(config, args, chalk) {
     receiptId:   dep.receipt_id,
     createdAt:   new Date().toISOString(),
     costPerHour: dep.cost_per_hour || 0,
+    providerRoute: dep.provider ?? null,
+    tier:          dep.tier ?? null,
   });
 
   const rcptId = dep.receipt_id || generateReceiptId();
@@ -208,6 +174,8 @@ export async function serveCommand(config, args, chalk) {
     action:       'badgr serve',
     deploymentId: dep.deployment_id,
     gpu:          dep.gpu_type,
+    providerRoute: dep.provider ?? null,
+    tier:          dep.tier ?? null,
     status:       dep.status,
     createdAt:    new Date().toISOString(),
   });
@@ -234,15 +202,24 @@ export async function serveCommand(config, args, chalk) {
     console.log();
   }
 
-  console.log(`  ${chalk.bold('Base URL:')}   ${chalk.cyan(endpointUrl)}`);
-  console.log(`  ${chalk.bold('Model:')}      ${dep.model || model}`);
-  console.log(`  ${chalk.bold('GPU:')}        ${dep.gpu_type} × ${dep.gpu_count}`);
-  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('Logs:')}       ${chalk.dim(`badgr logs ${dep.deployment_id}`)}`);
-  console.log(`  ${chalk.bold('Stop billing:')} ${chalk.dim(`badgr down ${dep.deployment_id}`)}`);
+  const serveRate = dep.cost_per_hour || 0;
+
+  console.log(`  ${chalk.bold('Base URL:')}     ${chalk.cyan(endpointUrl)}`);
+  console.log(`  ${chalk.bold('Model:')}        ${dep.model || model}`);
+  console.log(`  ${chalk.bold('GPU:')}          ${dep.gpu_type} × ${dep.gpu_count}`);
+  if (serveRate > 0) console.log(`  ${chalk.bold('Rate:')}         $${serveRate.toFixed(2)}/hr`);
+  if (flags.maxCost) console.log(`  ${chalk.bold('Max cost:')}     $${flags.maxCost.toFixed(2)}`);
+  console.log(`  ${chalk.bold('Receipt:')}      ${chalk.dim(rcptId)}`);
+  console.log(`  ${chalk.bold('Logs:')}         ${chalk.dim(`badgr logs ${dep.deployment_id}`)}`);
+  console.log(`  ${chalk.bold('Stop billing:')} ${chalk.cyan(`badgr down ${dep.deployment_id}`)}`);
   console.log();
 
+  if (serveRate > HIGH_RATE_THRESHOLD && !flags.maxCost) {
+    console.log(chalk.yellow(`  Selected capacity rate: $${serveRate.toFixed(2)}/hr`));
+    console.log(chalk.dim('  Tip: use --max-cost to enforce a hard ceiling.\n'));
+  }
+  console.log(chalk.dim('  Billing continues until you run: ') + chalk.cyan(`badgr down ${dep.deployment_id}`));
+
   if (endpointReady) {
     const keySnip = config.apiKey?.slice(0, 8) || 'sk-...';
     console.log(`  ${chalk.bold('Use with OpenAI SDK:')}`);

package/src/fallback.js

@@ -1,5 +1,80 @@
 import readline from 'readline';
 
+// ── Shared routing helpers ────────────────────────────────────────────────────
+
+/** Rates above this threshold trigger a visible warning when no --max-cost is set. */
+export const HIGH_RATE_THRESHOLD = 3.00;
+
+/** Normalise --tier flag variants to '1' or '2'. */
+export function normalizeTier(tier) {
+  return (tier === '2' || tier === 'tier2' || tier === 'tier-2') ? '2' : (tier || '1');
+}
+
+/**
+ * Call an API endpoint with automatic tier-2 expansion on NO_CAPACITY_MATCH.
+ * Returns the deployment object on success; throws or calls process.exit on failure.
+ *
+ * @param {string}   endpoint   - '/run' or '/serve'
+ * @param {object}   callOpts   - { apiKey, baseUrl }
+ * @param {function} buildBody  - (tierOverride?) => body object
+ * @param {string}   effectiveTier
+ * @param {object}   chalk
+ * @param {object}   labels     - { thing: 'job'|'endpoint', cmd: 'badgr run'|'badgr serve' }
+ */
+export async function callWithFallback(endpoint, callOpts, buildBody, effectiveTier, chalk, labels) {
+  const { callApi } = await import('./api.js');
+  const thing = labels?.thing ?? 'job';
+  const cmd   = labels?.cmd   ?? 'badgr run';
+
+  async function attempt(body) {
+    return callApi(endpoint, { method: 'POST', ...callOpts, body });
+  }
+
+  function handleErr(err, isFallback) {
+    const d = err.errorData;
+    if (d?.code === 'NO_CAPACITY_MATCH') {
+      console.error(chalk.red('\n  ✗ No suitable GPU capacity available right now.\n'));
+      console.error(chalk.dim('  Try `badgr capacity` to see what\'s available, or try again shortly.'));
+    } else if (d?.code === 'PROVISIONING_FAILED' || d?.code === 'PROVIDER_ADAPTER_ERROR') {
+      if (d?.low_cost_provider_failed) {
+        console.error(chalk.red(`\n  ✗ No suitable capacity available right now. Try again shortly.\n`));
+      } else {
+        console.error(chalk.red(`\n  ✗ Capacity found but ${thing} failed to start. Please try again.\n`));
+        if (process.env.BADGR_DEBUG === '1' || process.env.BADGR_DEBUG === 'true') {
+          if (d?.debug_error) console.error(chalk.dim(`  Detail: ${d.debug_error}`));
+        } else {
+          console.error(chalk.dim(`  Run BADGR_DEBUG=1 ${cmd} … for a full trace.\n`));
+        }
+      }
+    } else {
+      console.error(chalk.red(`\n  ✗ Could not start ${thing}: ${err.message}\n`));
+      console.error(chalk.dim(`  Run BADGR_DEBUG=1 ${cmd} … for a full trace.`));
+      if (!isFallback) console.error(chalk.dim(`  Check config: badgr config\n`));
+    }
+    process.exit(1);
+  }
+
+  try {
+    return await attempt(buildBody());
+  } catch (err) {
+    const d = err.errorData;
+
+    if (d?.code === 'NO_CAPACITY_MATCH' && effectiveTier !== '2') {
+      console.log(chalk.dim('\n  Primary capacity unavailable — expanding search...\n'));
+      try {
+        return await attempt(buildBody('2'));
+      } catch (err2) {
+        handleErr(err2, true);
+      }
+    }
+
+    if (err.isPaymentRequired) throw err; // let caller handle payment errors
+    handleErr(err, false);
+  }
+}
+
+// ── GPU fallback prompt ───────────────────────────────────────────────────────
+
 // GPU descriptions for display only — no scoring logic lives here.
 // Ranking is computed server-side and returned as `rank` on each alternative.
 const GPU_DISPLAY = {