badgr-cli 1.0.14 → 1.0.15

package/package.json

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

package/src/commands/run.js

@@ -309,15 +309,24 @@ export async function runCommand(config, args, chalk) {
         const d2 = err2.errorData;
         if (d2?.code === 'PROVISIONING_FAILED' || d2?.code === 'PROVIDER_ADAPTER_ERROR') {
           console.error(chalk.red(`\n  ✗ Badgr found ${chosen.gpu} capacity but could not start the machine. Please try again.\n`));
+          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.red(`\n  ✗ Job failed to start on ${chosen.gpu}: ${err2.message}\n`));
         }
-        console.error(chalk.dim(`  Run BADGR_DEBUG=1 badgr run … for a full trace.\n`));
+        if (!(process.env.BADGR_DEBUG === '1' || process.env.BADGR_DEBUG === 'true')) {
+          console.error(chalk.dim(`  Run BADGR_DEBUG=1 badgr run … for a full trace.\n`));
+        }
         process.exit(1);
       }
     } else if (d?.code === 'PROVISIONING_FAILED' || d?.code === 'PROVIDER_ADAPTER_ERROR') {
       console.error(chalk.red(`\n  ✗ Badgr found ${gpu} capacity but could not start the machine. Please try again.\n`));
-      console.error(chalk.dim(`  Run BADGR_DEBUG=1 badgr run … for a full trace.\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 {
       console.error(chalk.red(`\n  ✗ Could not start job: ${err.message}\n`));

package/src/commands/up.js

@@ -1,37 +1,31 @@
 import { parseSpec, validateSpec, specLines } from '../spec.js';
-import { getRoutePlan } from '../router.js';
 import { requireApiKey } from '../config.js';
 import { generateDeploymentId, generateReceiptId, addDeployment, addReceipt } from '../store.js';
-import { createDeployment } from '../api.js';
+import { createDeployment, callApi } from '../api.js';
 
-const OVERHEAD_PCT = 0.25;
+function printLivePlan(suggestions, gpu, chalk) {
+  const { matches = [], alternatives = [] } = suggestions;
 
-function printRoutePlan(plan, chalk) {
-  const { lane1, lane2, cheapestRate, costWithOverhead, canonical } = plan;
-
-  console.log(chalk.bold('  Lane 1 — Own GPU Hosts'));
+  console.log(chalk.bold('  Live availability'));
   console.log(`  ${'─'.repeat(40)}`);
-  console.log(chalk.dim(`  ${lane1.description}`));
+  if (matches.length === 0) {
+    console.log(chalk.yellow(`  No ${gpu} capacity found right now`));
+  } else {
+    const cheapest = matches[0];
+    console.log(`  ${chalk.cyan(gpu)} available — from ${chalk.green('$' + cheapest.price.toFixed(2) + '/hr')}`);
+    console.log(chalk.dim(`  ${matches.length} offer(s) found`));
+  }
   console.log();
 
-  console.log(chalk.bold('  Lane 2 — Overflow Providers  (cheapest-first)'));
-  console.log(`  ${'─'.repeat(40)}`);
-  if (lane2.length === 0) {
-    console.log(chalk.yellow(`  No pricing data for ${canonical}`));
-  } else {
-    lane2.forEach((p, i) => {
-      const arrow = i === 0 ? chalk.green(' ← primary') : '';
-      console.log(
-        `  ${String(i + 1)}. ${p.provider.padEnd(12)} ${canonical.padEnd(10)}` +
-        `  $${p.ratePerHour.toFixed(2)}/hr` +
-        `  reliability: ${Math.round(p.reliability * 100)}%${arrow}`
-      );
+  if (alternatives.length > 0) {
+    console.log(chalk.bold('  Alternatives if unavailable'));
+    console.log(`  ${'─'.repeat(40)}`);
+    alternatives.slice(0, 3).forEach((a, i) => {
+      const diff = a.diff_desc ? chalk.dim(` — ${a.diff_desc}`) : '';
+      console.log(`  ${i + 1}. ${chalk.cyan(a.gpu)} in ${a.region}  $${a.price.toFixed(2)}/hr${diff}`);
     });
     console.log();
-    console.log(`  Estimated range: $${cheapestRate.toFixed(2)}–$${lane2[lane2.length - 1].ratePerHour.toFixed(2)}/hr`);
-    console.log(chalk.dim(`  Estimated Badgr price: ~$${costWithOverhead.toFixed(2)}/hr`));
   }
-  console.log();
   console.log(chalk.dim('  Remove --dry-run to provision.'));
   console.log();
 }
@@ -45,15 +39,27 @@ export async function upCommand(config, args, chalk) {
     return;
   }
 
-  // ── Dry-run: show route plan and exit ─────────────────────────────────────
+  // ── Dry-run: show live route plan from backend ───────────────────────────
   if (spec.dryRun) {
     console.log(chalk.bold('\n🔍 Dry Run — Route Plan\n'));
     console.log(chalk.bold('  Spec'));
     console.log(`  ${'─'.repeat(40)}`);
     specLines(spec).forEach(l => console.log(`  ${l}`));
     console.log();
-    const plan = getRoutePlan(spec.gpu, spec.count);
-    printRoutePlan(plan, chalk);
+
+    requireApiKey(config);
+    try {
+      const params = new URLSearchParams({ gpu: spec.gpu, max_price: String(spec.maxPrice ?? 10) });
+      if (spec.region) params.set('region', spec.region);
+      const suggestions = await callApi(`/capacity/suggestions?${params}`, {
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+      });
+      printLivePlan(suggestions, spec.gpu, chalk);
+    } catch (err) {
+      console.log(chalk.yellow(`  Could not fetch live availability: ${err.message}`));
+      console.log(chalk.dim('  Tip: check `badgr capacity` for live data.\n'));
+    }
     return;
   }
 

package/src/fallback.js

@@ -1,73 +1,43 @@
 import readline from 'readline';
 
-// Static GPU metadata for local ranking. Routing still happens server-side.
-const GPU_META = {
-  RTX_3080: { vramGb: 10,  family: 'consumer',   tags: ['inference', 'dev'],             desc: 'Dev, light inference' },
-  RTX_4080: { vramGb: 16,  family: 'consumer',   tags: ['inference', 'dev'],             desc: 'Inference and dev workloads' },
-  RTX_4090: { vramGb: 24,  family: 'consumer',   tags: ['inference', 'training', 'dev'], desc: 'Inference, training, dev' },
-  L40S:     { vramGb: 48,  family: 'datacenter', tags: ['inference', 'training'],         desc: 'Inference, vLLM, batch jobs' },
-  A6000:    { vramGb: 48,  family: 'datacenter', tags: ['training', 'inference'],         desc: 'Training, large models, inference' },
-  A100:     { vramGb: 40,  family: 'datacenter', tags: ['training', 'inference'],         desc: 'Large-scale training and inference' },
-  H100:     { vramGb: 80,  family: 'datacenter', tags: ['training', 'large-model'],       desc: 'Large model training, best throughput' },
+// 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 = {
+  RTX_3080: { desc: 'Dev, light inference' },
+  RTX_4080: { desc: 'Inference and dev workloads' },
+  RTX_4090: { desc: 'Inference, training, dev' },
+  L40S:     { desc: 'Inference, vLLM, batch jobs' },
+  A6000:    { desc: 'Training, large models, inference' },
+  A100:     { desc: 'Large-scale training and inference' },
+  H100:     { desc: 'Large model training, best throughput' },
 };
 
-function altScore(alt, reqMeta) {
-  const meta = GPU_META[alt.gpu] ?? { vramGb: 0, family: 'unknown', tags: [] };
-  let s = 0;
-
-  // 1. GPU class/family similarity
-  if (meta.family === reqMeta.family) s += 200;
-
-  // 2. VRAM — prefer same or more, penalize less
-  const vramDiff = meta.vramGb - reqMeta.vramGb;
-  if (vramDiff >= 0) {
-    s += 80 - Math.min(vramDiff, 40) * 0.5;
-  } else {
-    s += 80 + vramDiff * 4;
-  }
-
-  // 3. Workload tag overlap
-  s += reqMeta.tags.filter(t => meta.tags.includes(t)).length * 20;
-
-  // 4. Availability confidence — not in alternatives payload, treated equal
-
-  // 5. Price — lower wins
-  s -= alt.price * 10;
-
-  return s;
-}
-
 /**
- * Rank a list of { gpu, region, price } alternatives.
- * mode 'closest'  → family / VRAM / tag / price (default)
- * mode 'cheapest' → price ascending only
+ * Sort alternatives for display.
+ *
+ * - mode 'closest'  → use backend `rank` field (1 = best match); fall back to price.
+ * - mode 'cheapest' → sort by price ascending only.
+ *
+ * The scoring algorithm has been removed from the CLI; the backend now
+ * computes and attaches `rank` and `diff_desc` to every alternative.
  */
 export function rankAlternatives(requestedGpu, alternatives, mode = 'closest') {
   if (!alternatives || alternatives.length === 0) return [];
   if (mode === 'cheapest') return [...alternatives].sort((a, b) => a.price - b.price);
-
-  const reqMeta = GPU_META[requestedGpu] ?? { vramGb: 0, family: 'unknown', tags: [] };
-  return [...alternatives].sort((a, b) => altScore(b, reqMeta) - altScore(a, reqMeta));
+  // 'closest': honour backend rank when present
+  if (alternatives.some(a => a.rank != null)) {
+    return [...alternatives].sort((a, b) => (a.rank ?? 999) - (b.rank ?? 999));
+  }
+  // Older backend without rank — fall back to price
+  return [...alternatives].sort((a, b) => a.price - b.price);
 }
 
 /**
- * One-line human-readable diff between requested and chosen GPU.
- * e.g. "less VRAM (24GB vs 40GB), different GPU class than A100"
+ * One-line diff for display. Uses `diff_desc` from backend when present,
+ * otherwise omits the diff rather than duplicating the scoring logic.
  */
-export function diffDescription(requestedGpu, altGpu) {
-  const req = GPU_META[requestedGpu];
-  const alt = GPU_META[altGpu];
-  if (!req || !alt) return '';
-
-  const parts = [];
-  const vramDiff = alt.vramGb - req.vramGb;
-  if (vramDiff < -4)  parts.push(`less VRAM (${alt.vramGb}GB vs ${req.vramGb}GB)`);
-  else if (vramDiff > 4) parts.push(`more VRAM (${alt.vramGb}GB vs ${req.vramGb}GB)`);
-
-  if (alt.family !== req.family) parts.push('different GPU class');
-
-  if (parts.length === 0) return `similar specs to ${requestedGpu}`;
-  return parts.join(', ') + ` than ${requestedGpu}`;
+export function diffDescription(requestedGpu, altGpu, alt = {}) {
+  return alt.diff_desc || '';
 }
 
 function ask(prompt) {
@@ -82,15 +52,16 @@ function ask(prompt) {
 export async function promptFallback(requestedGpu, ranked, chalk) {
   if (ranked.length === 0) return null;
 
-  const top     = ranked[0];
-  const others  = ranked.slice(1, 4); // cap at 3 extras for readability
-  const topMeta = GPU_META[top.gpu];
+  const top    = ranked[0];
+  const others = ranked.slice(1, 4);
+  const topDisp = GPU_DISPLAY[top.gpu];
 
   console.log(chalk.yellow(`\n  ${requestedGpu} isn't available right now.\n`));
   console.log(chalk.bold('  Closest match:'));
   console.log(`    ${chalk.cyan(top.gpu)} in ${top.region}`);
   console.log(`    ${chalk.green('$' + top.price.toFixed(2) + '/hr')} estimated price`);
-  if (topMeta?.desc) console.log(`    ${topMeta.desc}`);
+  if (top.diff_desc) console.log(`    ${chalk.dim(top.diff_desc)}`);
+  else if (topDisp?.desc) console.log(`    ${topDisp.desc}`);
   console.log(chalk.dim('    (availability estimated from market data — not pre-verified)'));
   console.log();
 
@@ -103,8 +74,8 @@ export async function promptFallback(requestedGpu, ranked, chalk) {
   if (others.length > 0) {
     console.log('  or type:');
     for (const [i, alt] of others.entries()) {
-      const meta = GPU_META[alt.gpu];
-      const hint = meta ? meta.desc.split(',')[0].toLowerCase() : '';
+      const disp = GPU_DISPLAY[alt.gpu];
+      const hint = disp ? disp.desc.split(',')[0].toLowerCase() : '';
       console.log(`    ${chalk.bold(String(i + 1))} = ${alt.gpu}${hint ? ', ' + hint : ''}`);
     }
   }

package/src/router.js

@@ -1,9 +1,10 @@
 /**
- * GPU catalog and routing preview.
+ * GPU catalog — static specs only (name, VRAM, tags, indicative rate).
  *
- * Provider pricing mirrors the order in overflow_providers.py:
- * Vast.ai → RunPod → TensorDock → SaladCloud.
- * Actual routing happens server-side; this is the dry-run preview.
+ * 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).
  */
 
 export const GPU_CATALOG = [
@@ -11,46 +12,11 @@ export const GPU_CATALOG = [
   { 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: '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'] },
 ];
 
-// Provider-level pricing per canonical GPU type (ordered cheapest-first per provider).
-// Mirrors overflow_providers.py search ordering: Vast → RunPod → TensorDock → Salad.
-export const PROVIDER_CATALOG = {
-  RTX_3080: [
-    { provider: 'vastai',      ratePerHour: 0.28, reliability: 0.93 },
-    { provider: 'runpod',      ratePerHour: 0.35, reliability: 0.96 },
-    { provider: 'tensordock',  ratePerHour: 0.40, reliability: 0.90 },
-  ],
-  RTX_4090: [
-    { provider: 'vastai',      ratePerHour: 0.65, reliability: 0.94 },
-    { provider: 'runpod',      ratePerHour: 0.72, reliability: 0.97 },
-    { provider: 'tensordock',  ratePerHour: 0.81, reliability: 0.91 },
-    { provider: 'salad',       ratePerHour: 0.89, reliability: 0.89 },
-  ],
-  L40S: [
-    { provider: 'vastai',      ratePerHour: 1.10, reliability: 0.94 },
-    { provider: 'runpod',      ratePerHour: 1.25, reliability: 0.97 },
-    { provider: 'salad',       ratePerHour: 1.40, reliability: 0.88 },
-  ],
-  A6000: [
-    { provider: 'vastai',      ratePerHour: 1.05, reliability: 0.93 },
-    { provider: 'runpod',      ratePerHour: 1.20, reliability: 0.97 },
-    { provider: 'salad',       ratePerHour: 1.35, reliability: 0.88 },
-  ],
-  A100: [
-    { provider: 'runpod',      ratePerHour: 1.20, reliability: 0.98 },
-    { provider: 'vastai',      ratePerHour: 1.35, reliability: 0.95 },
-    { provider: 'tensordock',  ratePerHour: 1.50, reliability: 0.92 },
-  ],
-  H100: [
-    { provider: 'runpod',      ratePerHour: 2.80, reliability: 0.99 },
-    { provider: 'vastai',      ratePerHour: 3.10, reliability: 0.96 },
-  ],
-};
-
 export function findById(id) {
   return GPU_CATALOG.find(g => g.id === id) ?? null;
 }
@@ -72,33 +38,6 @@ export function listAll() {
   return [...GPU_CATALOG].sort((a, b) => a.ratePerHour - b.ratePerHour);
 }
 
-/**
- * Build the routing preview shown in --dry-run output.
- * Mirrors the lane 1→2→3 logic in overflow_dispatch.py.
- */
-export function getRoutePlan(canonical, count = 1) {
-  const providers = PROVIDER_CATALOG[canonical] ?? [];
-  const sorted = [...providers].sort((a, b) => a.ratePerHour - b.ratePerHour);
-
-  const cheapest = sorted[0];
-  const overhead = 0.25; // ~25% overhead: startup risk + failure buffer + badgr margin
-  const costWithOverhead = cheapest ? cheapest.ratePerHour * (1 + overhead) * count : null;
-
-  return {
-    canonical,
-    gpu: findByCanonical(canonical),
-    lane1: { label: 'Own GPU hosts', description: 'checked at runtime against live worker pool' },
-    lane2: sorted.map((p, i) => ({
-      rank: i + 1,
-      provider: p.provider,
-      ratePerHour: p.ratePerHour * count,
-      reliability: p.reliability,
-    })),
-    cheapestRate: cheapest ? cheapest.ratePerHour * count : null,
-    costWithOverhead,
-  };
-}
-
 export function estimateCost(ratePerHour, durationMinutes) {
   return (ratePerHour / 60) * durationMinutes;
 }

package/tests/commands.test.js

@@ -96,10 +96,10 @@ describe('classifyFailure', () => {
 
 describe('rankAlternatives', () => {
   const pool = [
-    { gpu: 'RTX_4090', region: 'US', price: 0.72 },
-    { gpu: 'L40S',     region: 'US', price: 1.25 },
-    { gpu: 'H100',     region: 'EU', price: 2.80 },
-    { gpu: 'A6000',    region: 'US', price: 1.20 },
+    { gpu: 'RTX_4090', region: 'US', price: 0.72, rank: 3 },
+    { gpu: 'L40S',     region: 'US', price: 1.25, rank: 2 },
+    { gpu: 'H100',     region: 'EU', price: 2.80, rank: 1 },
+    { gpu: 'A6000',    region: 'US', price: 1.20 },   // no rank field
   ];
 
   it('cheapest mode sorts by price ascending', () => {
@@ -108,13 +108,25 @@ describe('rankAlternatives', () => {
     expect(ranked[ranked.length - 1].price).toBe(2.80);
   });
 
-  it('closest mode prefers same GPU family over cheaper consumer GPU', () => {
-    const ranked = rankAlternatives('A100', pool, 'closest');
-    const topGpu = ranked[0].gpu;
-    // H100, A6000, and L40S are all datacenter — any of them should beat RTX_4090
-    expect(['H100', 'A6000', 'L40S']).toContain(topGpu);
-    const rtxPos = ranked.findIndex(a => a.gpu === 'RTX_4090');
-    expect(rtxPos).toBeGreaterThan(0);
+  it('closest mode honours backend rank field when present', () => {
+    const poolWithRanks = [
+      { gpu: 'RTX_4090', region: 'US', price: 0.72, rank: 3 },
+      { gpu: 'L40S',     region: 'US', price: 1.25, rank: 2 },
+      { gpu: 'H100',     region: 'EU', price: 2.80, rank: 1 },
+    ];
+    const ranked = rankAlternatives('A100', poolWithRanks, 'closest');
+    expect(ranked[0].gpu).toBe('H100');   // rank 1 → top
+    expect(ranked[1].gpu).toBe('L40S');   // rank 2
+    expect(ranked[2].gpu).toBe('RTX_4090'); // rank 3
+  });
+
+  it('closest mode falls back to price sort when no rank field', () => {
+    const noRankPool = [
+      { gpu: 'RTX_4090', region: 'US', price: 0.72 },
+      { gpu: 'L40S',     region: 'US', price: 1.25 },
+    ];
+    const ranked = rankAlternatives('A100', noRankPool, 'closest');
+    expect(ranked[0].price).toBe(0.72);
   });
 
   it('returns empty array for empty pool', () => {
@@ -127,27 +139,17 @@ describe('rankAlternatives', () => {
 });
 
 describe('diffDescription', () => {
-  it('reports more VRAM when alt has significantly more', () => {
-    const desc = diffDescription('RTX_4090', 'L40S'); // 24GB vs 48GB
-    expect(desc).toContain('more VRAM');
-  });
-
-  it('reports less VRAM when alt has significantly less', () => {
-    const desc = diffDescription('A100', 'RTX_4090'); // 40GB vs 24GB
-    expect(desc).toContain('less VRAM');
-  });
-
-  it('reports different GPU class when family differs', () => {
-    const desc = diffDescription('A100', 'RTX_4090');
-    expect(desc).toContain('different GPU class');
+  it('uses diff_desc from alt object when backend provides it', () => {
+    const alt = { diff_desc: 'less VRAM (24GB vs 40GB) than A100' };
+    expect(diffDescription('A100', 'RTX_4090', alt)).toBe(alt.diff_desc);
   });
 
-  it('returns similar specs for same-class same VRAM GPUs', () => {
-    const desc = diffDescription('L40S', 'A6000'); // both 48GB, both datacenter
-    expect(desc).toContain('similar specs');
+  it('returns empty string when diff_desc is absent', () => {
+    expect(diffDescription('A100', 'RTX_4090', {})).toBe('');
+    expect(diffDescription('A100', 'RTX_4090')).toBe('');
   });
 
-  it('returns empty string for unknown GPUs', () => {
+  it('returns empty string for unknown GPUs with no alt object', () => {
     expect(diffDescription('UNKNOWN', 'ALSO_UNKNOWN')).toBe('');
   });
 });

package/tests/router.test.js

@@ -1,10 +1,14 @@
 import { describe, it, expect } from 'vitest';
 import {
   findById, findByCanonical, findCheapest, listAll,
-  getRoutePlan, estimateCost,
-  GPU_CATALOG, PROVIDER_CATALOG,
+  estimateCost,
+  GPU_CATALOG,
 } from '../src/router.js';
 
+// getRoutePlan and PROVIDER_CATALOG have been removed from the CLI.
+// Provider routing is now server-side only. Tests below cover the
+// remaining local GPU catalog helpers.
+
 describe('findById', () => {
   it('finds GPU by id', () => {
     expect(findById('rtx-4090').name).toContain('4090');
@@ -67,43 +71,6 @@ describe('listAll', () => {
   });
 });
 
-describe('getRoutePlan', () => {
-  it('returns lane1 and lane2 for RTX_4090', () => {
-    const plan = getRoutePlan('RTX_4090');
-    expect(plan.lane1).toBeTruthy();
-    expect(plan.lane2.length).toBeGreaterThan(0);
-  });
-
-  it('lane2 is sorted cheapest-first', () => {
-    const plan = getRoutePlan('RTX_4090');
-    for (let i = 1; i < plan.lane2.length; i++) {
-      expect(plan.lane2[i].ratePerHour).toBeGreaterThanOrEqual(plan.lane2[i - 1].ratePerHour);
-    }
-  });
-
-  it('scales ratePerHour by count', () => {
-    const plan1 = getRoutePlan('RTX_4090', 1);
-    const plan2 = getRoutePlan('RTX_4090', 2);
-    expect(plan2.lane2[0].ratePerHour).toBeCloseTo(plan1.lane2[0].ratePerHour * 2, 5);
-  });
-
-  it('cheapestRate matches first provider rate', () => {
-    const plan = getRoutePlan('H100');
-    expect(plan.cheapestRate).toBe(plan.lane2[0].ratePerHour);
-  });
-
-  it('costWithOverhead > cheapestRate', () => {
-    const plan = getRoutePlan('RTX_4090');
-    expect(plan.costWithOverhead).toBeGreaterThan(plan.cheapestRate);
-  });
-
-  it('includes gpu info for known canonical', () => {
-    const plan = getRoutePlan('H100');
-    expect(plan.gpu).not.toBeNull();
-    expect(plan.gpu.id).toBe('h100');
-  });
-});
-
 describe('estimateCost', () => {
   it('calculates cost for 60 minutes = 1 hour', () => {
     expect(estimateCost(1.10, 60)).toBeCloseTo(1.10, 5);
@@ -124,34 +91,8 @@ describe('L40S', () => {
     expect(findByCanonical('L40S').vramGb).toBe(48);
   });
 
-  it('has provider pricing in PROVIDER_CATALOG', () => {
-    expect(Array.isArray(PROVIDER_CATALOG['L40S'])).toBe(true);
-    expect(PROVIDER_CATALOG['L40S'].length).toBeGreaterThan(0);
-  });
-
-  it('route plan is cheapest-first for L40S', () => {
-    const plan = getRoutePlan('L40S');
-    expect(plan.lane2.length).toBeGreaterThan(0);
-    for (let i = 1; i < plan.lane2.length; i++) {
-      expect(plan.lane2[i].ratePerHour).toBeGreaterThanOrEqual(plan.lane2[i - 1].ratePerHour);
-    }
-  });
-});
-
-describe('PROVIDER_CATALOG', () => {
-  it('exists for all GPU_CATALOG canonical types', () => {
-    const catalogCanonicals = [...new Set(GPU_CATALOG.map(g => g.canonical))];
-    catalogCanonicals.forEach(c => {
-      // Some may not have provider pricing — just check the ones that do are valid arrays
-      if (PROVIDER_CATALOG[c]) {
-        expect(Array.isArray(PROVIDER_CATALOG[c])).toBe(true);
-        PROVIDER_CATALOG[c].forEach(p => {
-          expect(p.provider).toBeTruthy();
-          expect(p.ratePerHour).toBeGreaterThan(0);
-          expect(p.reliability).toBeGreaterThan(0);
-          expect(p.reliability).toBeLessThanOrEqual(1);
-        });
-      }
-    });
+  it('has no PROVIDER_CATALOG (provider routing is server-side)', async () => {
+    const mod = await import('../src/router.js');
+    expect(mod.PROVIDER_CATALOG).toBeUndefined();
   });
 });