badgr-cli 1.0.23 → 1.0.26

package/package.json

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

package/src/badgr.js

@@ -17,27 +17,27 @@ const HELP = `
 ${chalk.bold('badgr')} — run or serve GPU workloads from one command
 
 ${chalk.bold('COMMANDS')}
-  ${chalk.cyan('badgr login')}                  Authenticate with your API key
-  ${chalk.cyan('badgr run <command>')}          Run a one-off GPU job
-  ${chalk.cyan('badgr serve <model>')}          Serve a model with an OpenAI-compatible endpoint
-  ${chalk.cyan('badgr status')}                 Show what's running and what's billing
-  ${chalk.cyan('badgr logs <id>')}              Stream logs for a running job or endpoint
-  ${chalk.cyan('badgr down <id>')}              Stop a deployment and end billing
-  ${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 login')}               Authenticate with your API key
+  ${chalk.cyan('badgr run <command>')}       Run a one-off GPU job
+  ${chalk.cyan('badgr serve <model>')}       Serve a model with an OpenAI-compatible endpoint
+  ${chalk.cyan('badgr status')}              Show what's running and what's billing
+  ${chalk.cyan('badgr logs <id>')}           Stream logs for a running job or endpoint
+  ${chalk.cyan('badgr down <id>')}           Stop a deployment and end billing
+  ${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.bold('EXAMPLES')}
   ${chalk.dim('# Verify the stack works end-to-end:')}
   badgr test
 
-  ${chalk.dim('# Simplest — Badgr picks the GPU (RunPod, reliable):')}
+  ${chalk.dim('# Tier 1 — managed provider routing (default):')}
   badgr run python train.py
   badgr serve meta-llama/Llama-3.1-8B-Instruct
 
-  ${chalk.dim('# Opt into cheaper budget providers (Vast.ai etc.):')}
-  badgr run python train.py --cheap
-  badgr serve meta-llama/Llama-3.1-8B-Instruct --cheap
+  ${chalk.dim('# Tier 2 — marketplace routing, lower-cost options:')}
+  badgr run python train.py --tier 2
+  badgr serve meta-llama/Llama-3.1-8B-Instruct --tier 2
 
   ${chalk.dim('# Pin a specific GPU:')}
   badgr run python train.py --gpu A100
@@ -53,12 +53,12 @@ ${chalk.bold('EXAMPLES')}
   badgr receipts dep-abc123
 
 ${chalk.bold('badgr run OPTIONS')}
-  --gpu <type>           GPU type (default: auto — Badgr picks best available on RunPod)
-  --cheap                Search budget providers too (Vast.ai etc.) for lower prices
+  --gpu <type>           GPU type (default: auto — Badgr picks best available)
+  --tier 1               Managed provider routing (default)
+  --tier 2               Marketplace provider routing, lower-cost options
   --image <image>        Docker image (default: python:3.11-slim)
   --count <n>            Number of GPUs (default: 1)
   --region US|EU|AU      Region preference
-  --tier 1|2             Provider tier: 1 = reliable (default), 2 = budget
   --max-price <$/hr>     Hard spend cap per GPU-hour
   --max-runtime <min>    Auto-stop after N minutes (recommended)
   --max-cost <$>         Auto-stop when spend reaches this amount
@@ -66,10 +66,10 @@ ${chalk.bold('badgr run OPTIONS')}
 
 ${chalk.bold('badgr serve OPTIONS')}
   --gpu <type>           GPU type (default: auto — inferred from model size)
-  --cheap                Search budget providers too (Vast.ai etc.) for lower prices
+  --tier 1               Managed provider routing (default)
+  --tier 2               Marketplace provider routing, lower-cost options
   --count <n>            Number of GPUs (default: 1)
   --region US|EU|AU      Region preference
-  --tier 1|2             Provider tier: 1 = reliable (default), 2 = budget
   --max-price <$/hr>     Hard spend cap per GPU-hour
   --no-wait              Skip endpoint health check
 
@@ -103,7 +103,7 @@ async function main() {
     case 'receipts': return receiptsCommand(config, rest, chalk);
     case 'models':   return modelsCommand(config, chalk);
     case 'capacity': return capacityCommand(config, rest, chalk);
-    case 'test':     return testCommand(config, chalk);
+    case 'test':     return testCommand(config, rest, chalk);
     // legacy aliases kept for compatibility
     case 'up':       return upCommand(config, rest, chalk);
     case 'config': {

package/src/commands/run.js

@@ -18,7 +18,6 @@ export function parseRunArgs(args) {
     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] === '--cheap')          { flags.cheap = true; 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; }
@@ -82,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 machine'     },
+    { 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 {
@@ -103,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      = '';
@@ -343,66 +359,33 @@ 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 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';
+  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;
   const maxCost      = flags.maxCost ?? null;
 
-  // Resolve effective tier: --cheap and --tier 2 opt into budget providers;
-  // everything else defaults to tier 1 (RunPod only) for reliability.
-  const effectiveTier = (flags.cheap || flags.tier === '2' || flags.tier === 'tier2' || flags.tier === 'tier-2')
+  // 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');
 
   // ── 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) {
+  if (gpu === 'auto') {
     console.log(chalk.bold(`\n⚡ Running ${workloadLabel}\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('(budget mode — searching all providers)')}`);
-    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 budget provider, 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;
+    if (effectiveTier === '2') console.log(`  ${chalk.dim('(tier 2 — marketplace routing)')}`)
     console.log();
   } else {
     // Specific GPU requested — show header
@@ -421,15 +404,13 @@ export async function runCommand(config, args, chalk) {
     }
   }
 
-  console.log(chalk.dim('  Finding best available GPU capacity...'));
+  console.log(chalk.dim('  Starting machine...'));
   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,
@@ -459,20 +440,20 @@ export async function runCommand(config, args, chalk) {
         process.exit(1);
       }
 
-      // Tier 1 (RunPod) is out of capacity — offer budget providers.
+      // Tier 1 out of capacity — offer tier 2 marketplace routing.
       if (process.stdin.isTTY) {
         const answer = await askConfirm(
-          `\n  RunPod has no suitable capacity. Try budget marketplace GPUs? (Vast.ai, Salad) [${chalk.bold('Enter')}/${chalk.bold('q')}]: `
+          `\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  RunPod capacity unavailable — falling back to budget providers...\n'));
+        console.log(chalk.dim('\n  No tier 1 capacity — trying tier 2 marketplace routing...\n'));
       }
 
-      console.log(chalk.dim('  Searching budget providers (Vast.ai, Salad)...'));
+      console.log(chalk.dim('  Searching tier 2 capacity...'));
       try {
         dep = await callApi('/run', {
           method: 'POST',
@@ -487,13 +468,14 @@ export async function runCommand(config, args, chalk) {
           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 budget providers: ${err2.message}\n`));
+          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);
@@ -545,8 +527,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);
   }
@@ -560,7 +544,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 = {
@@ -622,7 +606,7 @@ 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)) {
+    console.log(chalk.green(`\n  ✓ Job complete\n`));
   }
 }

package/src/commands/serve.js

@@ -23,7 +23,6 @@ export function parseServeArgs(args) {
     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] === '--cheap')      { flags.cheap = true; 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; }
@@ -75,15 +74,15 @@ export async function serveCommand(config, args, chalk) {
   const gpu = flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : 'AUTO';
   const gpuLabel = gpu === 'AUTO' ? 'auto' : gpu;
 
-  // Default to tier 1 (RunPod) for reliability; --cheap or --tier 2 opts into budget providers.
-  const effectiveTier = (flags.cheap || flags.tier === '2' || flags.tier === 'tier2' || flags.tier === 'tier-2')
+  // 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');
 
   console.log(chalk.bold('\nServing model\n'));
   console.log(`  ${chalk.bold('Model:')}  ${model}`);
   console.log(`  ${chalk.bold('GPU:')}    ${gpuLabel}`);
-  if (effectiveTier === '2') console.log(`  ${chalk.dim('(budget mode — searching all providers)')}`);
+  if (effectiveTier === '2') console.log(`  ${chalk.dim('(tier 2 — marketplace routing)')}`);
   console.log();
   process.stdout.write(chalk.dim('  Finding GPU capacity...\n'));
 
@@ -118,20 +117,20 @@ export async function serveCommand(config, args, chalk) {
         process.exit(1);
       }
 
-      // Tier 1 (RunPod) out of capacity — offer budget providers.
+      // Tier 1 out of capacity — offer tier 2 marketplace routing.
       if (process.stdin.isTTY) {
         const answer = await askConfirm(
-          `\n  RunPod has no suitable capacity. Try budget marketplace GPUs? (Vast.ai, Salad) [${chalk.bold('Enter')}/${chalk.bold('q')}]: `
+          `\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  RunPod capacity unavailable — falling back to budget providers...\n'));
+        console.log(chalk.dim('\n  No tier 1 capacity — trying tier 2 marketplace routing...\n'));
       }
 
-      console.log(chalk.dim('  Searching budget providers (Vast.ai, Salad)...'));
+      console.log(chalk.dim('  Searching tier 2 capacity...'));
       try {
         dep = await callApi('/serve', {
           method: 'POST',
@@ -148,7 +147,7 @@ export async function serveCommand(config, args, chalk) {
           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  ✗ Failed to start endpoint on budget providers: ${err2.message}\n`));
+          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);

package/src/commands/test-run.js

@@ -6,9 +6,25 @@ import { addReceipt, generateReceiptId } from '../store.js';
 const TEST_MAX_PRICE  = 1.50;
 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.
+// 'tier1' → managed routing (default), 'tier2' → marketplace routing, 'secondary' → secondary dispatch.
+const PROVIDER_TO_TIER = { tier1: '1', tier2: '2', secondary: 'modal' };
+
+export function parseTestArgs(args) {
+  const flags = {};
+  let i = 0;
+  while (i < args.length) {
+    if (args[i] === '--provider' && args[i + 1]) { flags.provider = args[++i]; i++; continue; }
+    i++;
+  }
+  return flags;
+}
+
 function step(chalk, ok, msg, detail = '') {
   const icon = ok ? chalk.green('✓') : chalk.red('✗');
   const suffix = detail ? chalk.dim(` — ${detail}`) : '';
@@ -46,12 +62,40 @@ async function pollLogs(config, depId, expected, timeoutMs) {
   return false;
 }
 
-export async function testCommand(config, chalk) {
+export async function testCommand(config, args, chalk) {
   requireApiKey(config);
 
+  const flags = parseTestArgs(Array.isArray(args) ? args : []);
+  const providerKey = flags.provider ? flags.provider.toLowerCase() : 'tier1';
+
+  if (providerKey === 'secondary') {
+    // Secondary dispatch provider uses a webhook model, not direct GPU rental.
+    // Verify the backend reports it as configured.
+    console.log(chalk.bold('\n⚡ Testing secondary dispatch provider\n'));
+    let routes;
+    try {
+      routes = await callApi('/compute/routes', { apiKey: config.apiKey, baseUrl: config.baseUrl });
+    } catch {
+      routes = null;
+    }
+    const secondaryRoute = Array.isArray(routes) ? routes.find(r => r.name === 'modal') : null;
+    if (secondaryRoute?.available) {
+      step(chalk, true, 'Secondary provider configured');
+      console.log(chalk.green('\n  ✓ Secondary dispatch provider is ready\n'));
+    } else {
+      step(chalk, false, 'Secondary provider configured', 'contact support to enable secondary dispatch');
+      console.log(chalk.red('\n  ✗ Secondary dispatch provider is not configured\n'));
+      process.exit(1);
+    }
+    return;
+  }
+
+  const tier = PROVIDER_TO_TIER[providerKey] ?? '1';
+  const tierLabel = tier === '1' ? 'tier 1 (managed routing)' : 'tier 2 (marketplace routing)';
+
   console.log(chalk.bold('\n⚡ Running end-to-end test\n'));
   console.log(chalk.dim(`  Command:  ${TEST_COMMAND.join(' ')}`));
-  console.log(chalk.dim(`  Provider: RunPod (Tier 1 — reliable)`));
+  console.log(chalk.dim(`  Routing:  ${tier === '1' ? 'tier 1 — managed provider routing' : 'tier 2 — marketplace routing'}`));
   console.log(chalk.dim(`  Budget:   max $${TEST_MAX_PRICE.toFixed(2)}/hr · 2 minute cap (~$0.05 max)`));
   console.log();
 
@@ -59,12 +103,12 @@ export async function testCommand(config, chalk) {
   let depId;
 
   // ── 1. Provision ─────────────────────────────────────────────────────────
-  process.stdout.write(chalk.dim('  Provisioning GPU (RunPod)...'));
+  process.stdout.write(chalk.dim(`  Provisioning GPU (${tierLabel})...\n`));
   let dep;
   const baseBody = {
     command: TEST_COMMAND,
     image:   TEST_IMAGE,
-    gpu:     'RTX_3080',
+    gpu:     'auto',
     max_price_per_hour: TEST_MAX_PRICE,
   };
   try {
@@ -72,12 +116,12 @@ export async function testCommand(config, chalk) {
       method: 'POST',
       apiKey: config.apiKey,
       baseUrl: config.baseUrl,
-      body: { ...baseBody, tier: '1' },
+      body: { ...baseBody, tier },
     });
   } catch (err) {
-    if (err.errorData?.code === 'NO_CAPACITY_MATCH') {
+    if (err.errorData?.code === 'NO_CAPACITY_MATCH' && tier === '1') {
       process.stdout.write('\n');
-      process.stdout.write(chalk.dim('  RunPod unavailable, trying budget providers...'));
+      process.stdout.write(chalk.dim('  No tier 1 capacity — trying tier 2 marketplace routing...'));
       try {
         dep = await callApi('/run', {
           method: 'POST',
@@ -148,18 +192,22 @@ export async function testCommand(config, 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/tests/commands.test.js

@@ -1,7 +1,7 @@
 import { describe, it, expect, vi } from 'vitest';
 import { parseRunArgs, classifyFailure, inferWorkload } from '../src/commands/run.js';
 import { parseServeArgs } from '../src/commands/serve.js';
-import { testCommand } from '../src/commands/test-run.js';
+import { testCommand, parseTestArgs } from '../src/commands/test-run.js';
 import { rankAlternatives, diffDescription, promptFallback } from '../src/fallback.js';
 
 describe('parseRunArgs', () => {
@@ -73,20 +73,15 @@ describe('parseRunArgs', () => {
     expect(flags.maxCost).toBe(5.0);
   });
 
-  it('parses --cheap flag', () => {
-    const { flags } = parseRunArgs(['python', 'train.py', '--cheap']);
-    expect(flags.cheap).toBe(true);
-  });
-
-  it('--cheap defaults to falsy when not passed', () => {
-    const { flags } = parseRunArgs(['python', 'train.py']);
-    expect(flags.cheap).toBeFalsy();
-  });
-
   it('parses --tier 2 flag', () => {
     const { flags } = parseRunArgs(['python', 'train.py', '--tier', '2']);
     expect(flags.tier).toBe('2');
   });
+
+  it('--tier defaults to undefined when not passed', () => {
+    const { flags } = parseRunArgs(['python', 'train.py']);
+    expect(flags.tier).toBeUndefined();
+  });
 });
 
 describe('classifyFailure', () => {
@@ -204,14 +199,14 @@ describe('parseServeArgs', () => {
     expect(model).toBeNull();
   });
 
-  it('parses --cheap flag', () => {
-    const { flags } = parseServeArgs(['my/model', '--cheap']);
-    expect(flags.cheap).toBe(true);
+  it('parses --tier 2 flag', () => {
+    const { flags } = parseServeArgs(['my/model', '--tier', '2']);
+    expect(flags.tier).toBe('2');
   });
 
-  it('--cheap defaults to falsy when not passed', () => {
+  it('--tier defaults to undefined when not passed', () => {
     const { flags } = parseServeArgs(['my/model']);
-    expect(flags.cheap).toBeFalsy();
+    expect(flags.tier).toBeUndefined();
   });
 });
 
@@ -221,6 +216,24 @@ describe('testCommand', () => {
   });
 });
 
+describe('parseTestArgs', () => {
+  it('returns empty flags for no args', () => {
+    expect(parseTestArgs([])).toEqual({});
+  });
+
+  it('parses --provider tier1', () => {
+    expect(parseTestArgs(['--provider', 'tier1'])).toEqual({ provider: 'tier1' });
+  });
+
+  it('parses --provider tier2', () => {
+    expect(parseTestArgs(['--provider', 'tier2'])).toEqual({ provider: 'tier2' });
+  });
+
+  it('parses --provider secondary', () => {
+    expect(parseTestArgs(['--provider', 'secondary'])).toEqual({ provider: 'secondary' });
+  });
+});
+
 describe('inferWorkload', () => {
   it('returns general for empty command', () => {
     expect(inferWorkload([])).toBe('general');