badgr-cli 1.0.35 → 1.0.36

package/src/commands/run.js

@@ -388,7 +388,13 @@ export async function runCommand(config, args, chalk) {
   const inferredImage = isSmoke ? 'python:3.11-alpine' : 'python:3.11-slim';
   const image = flags.image || (command ? inferredImage : undefined);
   const detach       = flags.detach || false;
-  const maxRuntimeMs = flags.maxRuntime ? flags.maxRuntime * 60 * 1000 : null;
+
+  // Default max-runtime of 60 minutes — always applied unless overridden.
+  const DEFAULT_JOB_RUNTIME_MIN = 60;
+  const isDefaultRuntime = flags.maxRuntime === undefined;
+  const effectiveMaxRuntime = flags.maxRuntime ?? DEFAULT_JOB_RUNTIME_MIN;
+  const maxRuntimeMs = effectiveMaxRuntime * 60 * 1000;
+
   const maxCost      = flags.maxCost ?? null;
   const envObj       = parseEnvFlag(flags.env);
   const effectiveTier = normalizeTier(flags.tier);
@@ -400,18 +406,17 @@ export async function runCommand(config, args, chalk) {
   if (image)   console.log(`  ${chalk.bold('Image:')}    ${image}`);
   if (gpu)     console.log(`  ${chalk.bold('GPU:')}      ${gpu}`);
   else         console.log(`  ${chalk.bold('GPU:')}      ${chalk.dim('auto')}`);
-  if (flags.minVram)    console.log(`  ${chalk.bold('Min VRAM:')}   ${flags.minVram} GB`);
-  if (flags.maxRuntime) console.log(`  ${chalk.bold('Max runtime:')} ${flags.maxRuntime}min`);
-  if (maxCost)          console.log(`  ${chalk.bold('Max cost:')}    $${maxCost.toFixed(2)}`);
-  if (flags.maxPrice)   console.log(`  ${chalk.bold('Max price:')}   $${flags.maxPrice.toFixed(2)}/hr`);
-  if (detach)           console.log(`  ${chalk.dim('(detached — returns immediately)')}`);
+  if (flags.minVram)  console.log(`  ${chalk.bold('Min VRAM:')}   ${flags.minVram} GB`);
+  const runtimeLabel = isDefaultRuntime
+    ? `${effectiveMaxRuntime}min ${chalk.dim('(default — use --max-runtime N to override)')}`
+    : `${effectiveMaxRuntime}min`;
+  console.log(`  ${chalk.bold('Max runtime:')} ${runtimeLabel}`);
+  if (maxCost)        console.log(`  ${chalk.bold('Max cost:')}    $${maxCost.toFixed(2)}`);
+  if (flags.maxPrice) console.log(`  ${chalk.bold('Max price:')}   $${flags.maxPrice.toFixed(2)}/hr`);
+  if (detach)         console.log(`  ${chalk.dim('(detached — returns immediately)')}`);
   if (flags.env?.length) console.log(`  ${chalk.bold('Env:')}      ${flags.env.join(', ')}`);
   console.log();
 
-  if (!detach && !flags.maxRuntime && !maxCost) {
-    console.log(chalk.dim('  Tip: add --max-runtime 60 or --max-cost 5.00 to cap spend automatically'));
-  }
-
 
   console.log(chalk.dim('  Finding suitable capacity...'));
   if (process.env.BADGR_DEBUG === '1' || process.env.BADGR_DEBUG === 'true') {
@@ -431,6 +436,8 @@ export async function runCommand(config, args, chalk) {
       name: flags.name,
       tier: tierOverride || effectiveTier,
       ...(Object.keys(envObj).length > 0 ? { env: envObj } : {}),
+      max_runtime_seconds: effectiveMaxRuntime * 60,
+      ...(maxCost ? { max_cost_usd: maxCost } : {}),
     };
   }
 

package/src/commands/serve.js

@@ -1,5 +1,5 @@
 import { requireApiKey } from '../config.js';
-import { callApi } from '../api.js';
+import { callApi, listDeployments } from '../api.js';
 import { addDeployment, addReceipt, updateReceipt, generateReceiptId } from '../store.js';
 import { normalizeTier, callWithFallback, HIGH_RATE_THRESHOLD } from '../fallback.js';
 import { formatCliError } from '../errors.js';
@@ -33,6 +33,8 @@ export function parseServeArgs(args) {
     if (args[i] === '--no-fallback' ||
         args[i] === '--strict-capacity' ||
         args[i] === '--no-expanded-search') { flags.noMarketplaceFallback = true; i++; continue; }
+    if (args[i] === '--persistent')          { flags.persistent = true; i++; continue; }
+    if (args[i] === '--yes' || args[i] === '-y') { flags.yes = true; i++; continue; }
     if (args[i] === '--env') {
       const kv = args[++i]; i++;
       if (!flags.env) flags.env = [];
@@ -159,6 +161,7 @@ const _KNOWN_SERVE_FLAGS = new Set([
   '--gpu', '--image', '--task', '--count', '--region', '--tier', '--max-price',
   '--name', '--no-wait', '--max-cost', '--health-path', '--check-nodes',
   '--no-fallback', '--strict-capacity', '--no-expanded-search', '--env',
+  '--persistent', '--yes', '-y',
 ]);
 
 export async function serveCommand(config, args, chalk) {
@@ -211,6 +214,18 @@ export async function serveCommand(config, args, chalk) {
     return;
   }
 
+  // Endpoints bill continuously — require explicit cost control.
+  if (!flags.maxCost && !flags.persistent) {
+    const example = model || (customImage ? '--image ...' : '<model>');
+    console.error(chalk.red('\n  ✗ Endpoints bill continuously until stopped. Specify a spending limit:\n'));
+    console.error(chalk.dim(`    --max-cost 5           auto-stop when $5 is reached`));
+    console.error(chalk.dim(`    --persistent           run until you stop it manually\n`));
+    console.error(chalk.dim(`  Example:`));
+    console.error(chalk.dim(`    badgr serve ${example} --max-cost 10\n`));
+    process.exitCode = 1;
+    return;
+  }
+
   const envObj = parseEnvFlag(flags.env);
 
   const gpu = flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : (customImage ? 'L40S' : 'AUTO');
@@ -236,12 +251,49 @@ export async function serveCommand(config, args, chalk) {
       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)}`);
     }
   }
+  if (flags.maxCost) {
+    console.log(`  ${chalk.bold('Max cost:')}    $${flags.maxCost.toFixed(2)} (auto-stop)`);
+  } else {
+    console.log(chalk.yellow(`  ⚠  Persistent — billing until: badgr down <id>  or  badgr down --all`));
+  }
   console.log();
   process.stdout.write(chalk.dim('  Finding suitable capacity...\n'));
 
+  // ── Duplicate check ────────────────────────────────────────────────────────
+  if (config.apiKey) {
+    try {
+      const existing = await listDeployments(config);
+      const ACTIVE = new Set(['running', 'provisioning', 'starting', 'queued']);
+      const duplicate = (existing.deployments ?? []).find(d =>
+        ACTIVE.has(d.status) &&
+        d.workload_type === 'endpoint' &&
+        (
+          (model && d.model === model) ||
+          (customImage && d.image === customImage)
+        )
+      );
+      if (duplicate) {
+        console.log(chalk.yellow(`\n  ⚠ This workload is already running:\n`));
+        console.log(`    ${chalk.cyan(duplicate.deployment_id)}  ${duplicate.gpu_type || ''}  $${(duplicate.cost_per_hour || 0).toFixed(2)}/hr`);
+        if (duplicate.endpoint_url) console.log(`    URL: ${chalk.cyan(duplicate.endpoint_url)}`);
+        console.log();
+        console.log(chalk.dim(`    Reuse:       Use the URL above`));
+        console.log(chalk.dim(`    Stop first:  badgr down ${duplicate.deployment_id}`));
+        console.log(chalk.dim(`    Launch new:  add --yes to this command`));
+        console.log();
+        if (!flags.yes) {
+          process.exitCode = 1;
+          return;
+        }
+        console.log(chalk.dim('  Launching another anyway (--yes).\n'));
+      }
+    } catch {
+      // non-fatal — skip duplicate check if API is unreachable
+    }
+  }
+
   const effectiveRegion = flags.region ? flags.region.toUpperCase() : undefined;
 
   function buildBody(gpuOverride, tierOverride) {
@@ -256,6 +308,7 @@ export async function serveCommand(config, args, chalk) {
       name: flags.name,
       tier: tierOverride || effectiveTier,
       ...(Object.keys(envObj).length > 0 ? { env: envObj } : {}),
+      ...(flags.maxCost ? { max_cost_usd: flags.maxCost } : {}),
     };
   }
 

package/src/commands/train.js

@@ -0,0 +1,255 @@
+/**
+ * badgr train config.yaml [--gpu A100] [--max-cost N] [--max-runtime N]
+ *
+ * Runs a LoRA/QLoRA/fine-tuning job on GPU.
+ * Detects the training framework from config.yaml and selects the right image.
+ * Enforces a max-runtime (default 120 min) and streams logs until completion.
+ */
+import { readFileSync, existsSync } from 'fs';
+import { requireApiKey } from '../config.js';
+import { addReceipt, updateReceipt, generateReceiptId } from '../store.js';
+import { normalizeTier, callWithFallback } from '../fallback.js';
+import { monitorBatchJob, fmtRuntime } from '../batch.js';
+
+const MAX_CONFIG_B = 512 * 1024; // 512 KB config limit
+
+// Training images keyed by framework name.
+const TRAINING_IMAGES = {
+  axolotl: 'winglian/axolotl:main-latest',
+  unsloth: 'unslothai/unsloth:latest',
+  trl:     'huggingface/trl-source:latest',
+  generic: 'nvidia/cuda:12.1.0-cudnn8-devel-ubuntu22.04',
+};
+
+// Preferred GPUs for training: VRAM-heavy workloads.
+const TRAINING_GPUS = ['A100', 'H100', 'L40S', 'A6000'];
+
+const DEFAULT_MAX_RUNTIME_MIN = 120;
+
+export function parseTrainArgs(args) {
+  const flags = {};
+  const positional = [];
+  let i = 0;
+  while (i < args.length) {
+    const a = args[i];
+    if (a === '--gpu')          { flags.gpu = args[++i]; i++; continue; }
+    if (a === '--max-cost')     { flags.maxCost = parseFloat(args[++i]); i++; continue; }
+    if (a === '--max-price')    { flags.maxPrice = parseFloat(args[++i]); i++; continue; }
+    if (a === '--max-runtime')  { flags.maxRuntime = parseFloat(args[++i]); i++; continue; }
+    if (a === '--tier')         { flags.tier = args[++i]; i++; continue; }
+    if (a === '--region')       { flags.region = args[++i]; i++; continue; }
+    if (a === '--framework')    { flags.framework = args[++i]; i++; continue; }
+    if (a === '--detach')       { flags.detach = true; i++; continue; }
+    if (a === '--env') {
+      const kv = args[++i]; i++;
+      if (!flags.env) flags.env = [];
+      flags.env.push(kv);
+      continue;
+    }
+    positional.push(args[i++]);
+  }
+  return { configFile: positional[0] || null, flags };
+}
+
+function parseEnvFlag(envList) {
+  const obj = {};
+  for (const kv of (envList || [])) {
+    const idx = kv.indexOf('=');
+    if (idx > 0) obj[kv.slice(0, idx)] = kv.slice(idx + 1);
+  }
+  return obj;
+}
+
+/**
+ * Detect training framework from config content.
+ * Returns 'axolotl' | 'unsloth' | 'trl' | 'generic'.
+ */
+export function detectFramework(configContent) {
+  const s = configContent.toLowerCase();
+  if (/axolotl|base_model.*:\s*\S+/.test(s) && !/unsloth/.test(s)) return 'axolotl';
+  if (/unsloth/.test(s)) return 'unsloth';
+  if (/\btrl\b|sfttrainer|dpotrainer|ppotrainer/.test(s)) return 'trl';
+  return 'generic';
+}
+
+/**
+ * Warn if config references local dataset paths that won't be accessible remotely.
+ */
+export function findLocalDatasetPaths(configContent) {
+  const paths = [];
+  // Match: path: ./foo or path: /absolute/path (not s3://, gs://, hf://, https://)
+  // Handles both bare `path:` and YAML list-item `- path:` prefixes.
+  const re = /^\s*(?:-\s+)?path:\s*(?!s3:|gs:|hf:|https?:|huggingface\/)(['"]?)([./][^\s'"#]+)\1/gm;
+  let m;
+  while ((m = re.exec(configContent)) !== null) {
+    paths.push(m[2]);
+  }
+  return paths;
+}
+
+export async function trainCommand(config, args, chalk) {
+  const { configFile, flags } = parseTrainArgs(args);
+
+  if (!configFile) {
+    console.error(chalk.red('\n  Usage: badgr train config.yaml\n'));
+    console.error(chalk.dim('  Runs LoRA / fine-tuning on GPU and streams logs.\n'));
+    process.exitCode = 1;
+    return;
+  }
+
+  requireApiKey(config);
+
+  if (!existsSync(configFile)) {
+    console.error(chalk.red(`\n  ✗ Config file not found: ${configFile}\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  let configRaw;
+  try {
+    configRaw = readFileSync(configFile, 'utf8');
+  } catch (err) {
+    console.error(chalk.red(`\n  ✗ Could not read ${configFile}: ${err.message}\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  if (Buffer.byteLength(configRaw) > MAX_CONFIG_B) {
+    console.error(chalk.red(`\n  ✗ Config exceeds 512 KB (${(Buffer.byteLength(configRaw) / 1024).toFixed(0)} KB).\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  const framework  = flags.framework || detectFramework(configRaw);
+  const image      = TRAINING_IMAGES[framework] || TRAINING_IMAGES.generic;
+  const configB64  = Buffer.from(configRaw).toString('base64');
+  const gpu        = flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : 'AUTO';
+  const effectiveTier = normalizeTier(flags.tier);
+
+  const isDefaultRuntime = flags.maxRuntime === undefined;
+  const maxRuntimeMin    = flags.maxRuntime ?? DEFAULT_MAX_RUNTIME_MIN;
+  const maxRuntimeMs     = maxRuntimeMin * 60 * 1000;
+  const maxCost          = flags.maxCost ?? null;
+
+  const envObj = {
+    ...parseEnvFlag(flags.env),
+    TRAIN_CONFIG_B64: configB64,
+    TRAIN_FRAMEWORK:  framework,
+  };
+
+  // Warn about local dataset paths that won't be accessible from the cloud.
+  const localPaths = findLocalDatasetPaths(configRaw);
+  if (localPaths.length > 0) {
+    console.log(chalk.yellow('\n  ⚠ Config references local paths — these won\'t be accessible from the cloud:\n'));
+    for (const p of localPaths) {
+      console.log(chalk.yellow(`    ${p}`));
+    }
+    console.log(chalk.dim('\n  Upload your dataset to Hugging Face or S3 and update the path in your config.\n'));
+  }
+
+  console.log(chalk.bold('\n🏋️  Training\n'));
+  console.log(`  ${chalk.bold('Config:')}      ${configFile}`);
+  console.log(`  ${chalk.bold('Framework:')}   ${framework}`);
+  console.log(`  ${chalk.bold('Image:')}       ${image}`);
+  console.log(`  ${chalk.bold('GPU:')}         ${gpu === 'AUTO' ? chalk.dim('auto (40+ GB VRAM preferred)') : gpu}`);
+  const runtimeLabel = isDefaultRuntime
+    ? `${maxRuntimeMin}min ${chalk.dim('(default — use --max-runtime N to override)')}`
+    : `${maxRuntimeMin}min`;
+  console.log(`  ${chalk.bold('Max runtime:')} ${runtimeLabel}`);
+  if (maxCost) console.log(`  ${chalk.bold('Max cost:')}    $${maxCost.toFixed(2)}`);
+  console.log();
+  process.stdout.write(chalk.dim('  Finding suitable capacity...\n'));
+
+  function buildBody(tierOverride) {
+    return {
+      image,
+      command: ['sh', '-c', 'echo "$TRAIN_CONFIG_B64" | base64 -d > /tmp/config.yaml && axolotl train /tmp/config.yaml'],
+      gpu,
+      gpu_count:          1,
+      ...(flags.region ? { region: flags.region.toUpperCase() } : {}),
+      max_price_per_hour: flags.maxPrice,
+      tier:               tierOverride || effectiveTier,
+      env:                envObj,
+      max_runtime_seconds: maxRuntimeMin * 60,
+      ...(maxCost ? { max_cost_usd: maxCost } : {}),
+    };
+  }
+
+  let dep;
+  try {
+    dep = await callWithFallback(
+      '/run',
+      { apiKey: config.apiKey, baseUrl: config.baseUrl },
+      (tierOverride) => buildBody(tierOverride),
+      effectiveTier,
+      chalk,
+      { thing: 'training job', cmd: 'badgr train' },
+    );
+  } catch (err) {
+    if (err.isPaymentRequired) {
+      console.error(chalk.yellow(err.message));
+      console.error(chalk.dim(`After payment, rerun:\n  badgr train ${args.join(' ')}\n`));
+      process.exitCode = 1;
+      return;
+    }
+    console.error(err.message);
+    process.exitCode = 1;
+    return;
+  }
+
+  const rcptId = dep.receipt_id || generateReceiptId();
+  addReceipt({
+    receiptId:     rcptId,
+    action:        'badgr train',
+    deploymentId:  dep.deployment_id,
+    gpu:           dep.gpu_type,
+    providerRoute: dep.provider ?? null,
+    tier:          dep.tier ?? null,
+    maxCost,
+    maxRuntime:    maxRuntimeMin,
+    status:        dep.status,
+    createdAt:     new Date().toISOString(),
+  });
+
+  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 (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 (flags.detach) {
+    console.log(`\n  ${chalk.bold('Logs:')}  ${chalk.dim(`badgr logs ${dep.deployment_id}`)}`);
+    console.log(chalk.dim(`\n  Detached. Monitor: badgr logs ${dep.deployment_id}\n`));
+    return;
+  }
+
+  const result = await monitorBatchJob(config, dep.deployment_id, rcptId, {
+    chalk,
+    maxRuntimeMs,
+    maxCost,
+    ratePerHour: rate,
+  });
+
+  console.log();
+  const finalCost = rate * (result.runtimeMs / 3_600_000);
+  console.log(`  ${chalk.bold('Runtime:')}  ${fmtRuntime(result.runtimeMs)}`);
+  if (rate > 0) console.log(`  ${chalk.bold('Cost:')}     $${finalCost.toFixed(4)}`);
+  if (result.exitCode !== null && result.exitCode !== undefined) {
+    console.log(`  ${chalk.bold('Exit code:')} ${result.exitCode !== 0 ? chalk.red(result.exitCode) : chalk.green(result.exitCode)}`);
+  }
+  console.log(`  ${chalk.bold('Receipt:')}  ${chalk.dim(rcptId)}`);
+
+  if (result.reason === 'complete' &&
+      (result.status === 'completed' || result.status === 'succeeded') &&
+      (result.exitCode === 0 || result.exitCode === null)) {
+    console.log(chalk.green('\n  ✓ Training complete\n'));
+  } else if (result.reason === 'interrupted') {
+    process.exitCode = 0;
+  } else if (result.status === 'failed' || (result.exitCode !== null && result.exitCode !== 0)) {
+    console.error(chalk.red('\n  ✗ Training failed\n'));
+    console.error(chalk.dim(`  Logs: badgr logs ${dep.deployment_id}\n`));
+    process.exitCode = result.exitCode ?? 1;
+  }
+}

package/src/commands/transcribe.js

@@ -0,0 +1,221 @@
+/**
+ * badgr transcribe <audio-url-or-file> [--model large-v3] [--max-cost N]
+ *
+ * Runs Whisper transcription on GPU.
+ * Accepts a public URL, S3/GCS URI, or a local file under 50 MB (base64-encoded inline).
+ * Transcript appears in streaming logs and is written to stdout by the container.
+ */
+import { readFileSync, existsSync, statSync } from 'fs';
+import { requireApiKey } from '../config.js';
+import { addReceipt, generateReceiptId } from '../store.js';
+import { normalizeTier, callWithFallback } from '../fallback.js';
+import { monitorBatchJob, fmtRuntime } from '../batch.js';
+
+const WHISPER_IMAGE        = 'fedirz/faster-whisper-server:latest-cuda';
+const DEFAULT_WHISPER_MODEL = 'large-v3';
+const DEFAULT_MAX_RUNTIME_MIN = 30;
+const MAX_INLINE_B = 50 * 1024 * 1024; // 50 MB inline limit
+
+export function parseTranscribeArgs(args) {
+  const flags = {};
+  const positional = [];
+  let i = 0;
+  while (i < args.length) {
+    const a = args[i];
+    if (a === '--model')       { flags.model = args[++i]; i++; continue; }
+    if (a === '--gpu')         { flags.gpu = args[++i]; i++; continue; }
+    if (a === '--max-cost')    { flags.maxCost = parseFloat(args[++i]); i++; continue; }
+    if (a === '--max-price')   { flags.maxPrice = parseFloat(args[++i]); i++; continue; }
+    if (a === '--max-runtime') { flags.maxRuntime = parseFloat(args[++i]); i++; continue; }
+    if (a === '--tier')        { flags.tier = args[++i]; i++; continue; }
+    if (a === '--region')      { flags.region = args[++i]; i++; continue; }
+    if (a === '--language')    { flags.language = args[++i]; i++; continue; }
+    if (a === '--output')      { flags.output = args[++i]; i++; continue; }
+    if (a === '--detach')      { flags.detach = true; i++; continue; }
+    if (a === '--env') {
+      const kv = args[++i]; i++;
+      if (!flags.env) flags.env = [];
+      flags.env.push(kv);
+      continue;
+    }
+    positional.push(args[i++]);
+  }
+  return { input: positional[0] || null, flags };
+}
+
+function parseEnvFlag(envList) {
+  const obj = {};
+  for (const kv of (envList || [])) {
+    const idx = kv.indexOf('=');
+    if (idx > 0) obj[kv.slice(0, idx)] = kv.slice(idx + 1);
+  }
+  return obj;
+}
+
+function isUrl(s) {
+  return /^(https?|s3|gs|hf):\/\//i.test(s);
+}
+
+/**
+ * Resolve input to { audioUrl, audioB64, inputLabel }.
+ * Returns null and sets an error message if the input is invalid.
+ */
+export function resolveAudioInput(input) {
+  if (isUrl(input)) {
+    return { audioUrl: input, audioB64: null, inputLabel: input };
+  }
+  if (!existsSync(input)) {
+    return { error: `File not found: ${input}` };
+  }
+  const size = statSync(input).size;
+  if (size > MAX_INLINE_B) {
+    return {
+      error: `File too large for inline transfer (${(size / 1024 / 1024).toFixed(1)} MB > 50 MB limit).\n` +
+             '  Upload to S3 or a public URL and pass the URL instead.',
+    };
+  }
+  const audioB64 = readFileSync(input).toString('base64');
+  return { audioUrl: null, audioB64, inputLabel: input };
+}
+
+export async function transcribeCommand(config, args, chalk) {
+  const { input, flags } = parseTranscribeArgs(args);
+
+  if (!input) {
+    console.error(chalk.red('\n  Usage: badgr transcribe <audio-url-or-file>\n'));
+    console.error(chalk.dim('  Examples:'));
+    console.error(chalk.dim('    badgr transcribe s3://my-bucket/meeting.mp3'));
+    console.error(chalk.dim('    badgr transcribe https://example.com/lecture.mp4'));
+    console.error(chalk.dim('    badgr transcribe recording.mp3 --max-cost 2\n'));
+    process.exitCode = 1;
+    return;
+  }
+
+  requireApiKey(config);
+
+  const resolved = resolveAudioInput(input);
+  if (resolved.error) {
+    console.error(chalk.red(`\n  ✗ ${resolved.error}\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  const whisperModel  = flags.model || DEFAULT_WHISPER_MODEL;
+  const gpu           = flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : 'AUTO';
+  const effectiveTier = normalizeTier(flags.tier);
+  const maxRuntimeMin = flags.maxRuntime ?? DEFAULT_MAX_RUNTIME_MIN;
+  const maxRuntimeMs  = maxRuntimeMin * 60 * 1000;
+  const maxCost       = flags.maxCost ?? null;
+
+  const envObj = {
+    ...parseEnvFlag(flags.env),
+    WHISPER_MODEL: whisperModel,
+    ...(resolved.audioUrl  ? { AUDIO_URL: resolved.audioUrl }   : {}),
+    ...(resolved.audioB64  ? { AUDIO_B64: resolved.audioB64 }   : {}),
+    ...(flags.language     ? { WHISPER_LANGUAGE: flags.language } : {}),
+    ...(flags.output       ? { WHISPER_OUTPUT_FORMAT: flags.output } : {}),
+  };
+
+  console.log(chalk.bold('\n🎙 Transcription\n'));
+  console.log(`  ${chalk.bold('Input:')}       ${resolved.inputLabel}`);
+  console.log(`  ${chalk.bold('Model:')}       ${whisperModel}`);
+  console.log(`  ${chalk.bold('Image:')}       ${WHISPER_IMAGE}`);
+  console.log(`  ${chalk.bold('GPU:')}         ${gpu === 'AUTO' ? chalk.dim('auto (8+ GB VRAM)') : gpu}`);
+  console.log(`  ${chalk.bold('Max runtime:')} ${maxRuntimeMin}min`);
+  if (maxCost) console.log(`  ${chalk.bold('Max cost:')}    $${maxCost.toFixed(2)}`);
+  if (flags.language) console.log(`  ${chalk.bold('Language:')}    ${flags.language}`);
+  console.log();
+  process.stdout.write(chalk.dim('  Finding suitable capacity...\n'));
+
+  function buildBody(tierOverride) {
+    return {
+      image: WHISPER_IMAGE,
+      command: ['sh', '-c', [
+        resolved.audioB64
+          ? 'echo "$AUDIO_B64" | base64 -d > /tmp/audio_input && export AUDIO_PATH=/tmp/audio_input'
+          : 'export AUDIO_PATH="$AUDIO_URL"',
+        'whisper "$AUDIO_PATH" --model "$WHISPER_MODEL"' +
+          (flags.language ? ' --language "$WHISPER_LANGUAGE"' : '') +
+          (flags.output   ? ' --output_format "$WHISPER_OUTPUT_FORMAT"' : ''),
+      ].join(' && ')],
+      gpu,
+      gpu_count:           1,
+      ...(flags.region ? { region: flags.region.toUpperCase() } : {}),
+      max_price_per_hour:  flags.maxPrice,
+      tier:                tierOverride || effectiveTier,
+      env:                 envObj,
+      max_runtime_seconds: maxRuntimeMin * 60,
+      ...(maxCost ? { max_cost_usd: maxCost } : {}),
+    };
+  }
+
+  let dep;
+  try {
+    dep = await callWithFallback(
+      '/run',
+      { apiKey: config.apiKey, baseUrl: config.baseUrl },
+      (tierOverride) => buildBody(tierOverride),
+      effectiveTier,
+      chalk,
+      { thing: 'transcription job', cmd: 'badgr transcribe' },
+    );
+  } catch (err) {
+    if (err.isPaymentRequired) { console.error(chalk.yellow(err.message)); process.exitCode = 1; return; }
+    console.error(err.message);
+    process.exitCode = 1;
+    return;
+  }
+
+  const rcptId = dep.receipt_id || generateReceiptId();
+  addReceipt({
+    receiptId:     rcptId,
+    action:        'badgr transcribe',
+    deploymentId:  dep.deployment_id,
+    gpu:           dep.gpu_type,
+    providerRoute: dep.provider ?? null,
+    tier:          dep.tier ?? null,
+    maxCost,
+    maxRuntime:    maxRuntimeMin,
+    status:        dep.status,
+    createdAt:     new Date().toISOString(),
+  });
+
+  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 (rate > 0) console.log(`  ${chalk.bold('Rate:')}     $${rate.toFixed(2)}/hr`);
+  console.log(`  ${chalk.bold('Receipt:')}  ${chalk.dim(rcptId)}`);
+
+  if (flags.detach) {
+    console.log(`\n  ${chalk.bold('Logs:')}  ${chalk.dim(`badgr logs ${dep.deployment_id}`)}`);
+    console.log(chalk.dim(`\n  Detached. View transcript: badgr logs ${dep.deployment_id}\n`));
+    return;
+  }
+
+  const result = await monitorBatchJob(config, dep.deployment_id, rcptId, {
+    chalk,
+    maxRuntimeMs,
+    maxCost,
+    ratePerHour: rate,
+  });
+
+  console.log();
+  const finalCost = rate * (result.runtimeMs / 3_600_000);
+  console.log(`  ${chalk.bold('Runtime:')}  ${fmtRuntime(result.runtimeMs)}`);
+  if (rate > 0) console.log(`  ${chalk.bold('Cost:')}     $${finalCost.toFixed(4)}`);
+  console.log(`  ${chalk.bold('Receipt:')}  ${chalk.dim(rcptId)}`);
+
+  if (result.reason === 'complete' &&
+      (result.status === 'completed' || result.status === 'succeeded') &&
+      (result.exitCode === 0 || result.exitCode === null)) {
+    console.log(chalk.green('\n  ✓ Transcription complete\n'));
+    console.log(chalk.dim('  Transcript appears above in the log output.'));
+    console.log(chalk.dim(`  Full logs: badgr logs ${dep.deployment_id}\n`));
+  } else if (result.reason !== 'interrupted' &&
+             (result.status === 'failed' || (result.exitCode !== null && result.exitCode !== 0))) {
+    console.error(chalk.red('\n  ✗ Transcription failed\n'));
+    console.error(chalk.dim(`  Logs: badgr logs ${dep.deployment_id}\n`));
+    process.exitCode = result.exitCode ?? 1;
+  }
+}

package/tests/launch-readiness.test.js

@@ -324,3 +324,54 @@ describe('compat_failure error message', () => {
     expect(thrown.message).toMatch(/GPU type|image/i);
   });
 });
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 4. Stale-capacity retry — PROVISIONING_FAILED triggers one immediate retry
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('stale-capacity retry on PROVISIONING_FAILED', () => {
+  function makeProvisioningFailedErr() {
+    const err = new Error('PROVISIONING_FAILED');
+    err.errorData = { code: 'PROVISIONING_FAILED', failure_category: 'infrastructure' };
+    return err;
+  }
+
+  it('retries the API call once before escalating on PROVISIONING_FAILED (tier=2 → no tier-2 expansion)', async () => {
+    // tier=2 means no tier-2 fallback expansion, so only the stale-capacity retry fires.
+    api.callApi.mockRejectedValue(makeProvisioningFailedErr());
+
+    try {
+      await callWithFallback(
+        '/run',
+        { apiKey: 'sk-test', baseUrl: 'https://api.test/v1' },
+        () => ({}),
+        '2',
+        chalk,
+        { thing: 'job', cmd: 'badgr run' },
+      );
+    } catch (_) {}
+
+    // First attempt + one stale-capacity retry = 2 calls minimum
+    expect(api.callApi.mock.calls.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it('does NOT double-retry on non-PROVISIONING_FAILED errors', async () => {
+    const err = new Error('NO_CAPACITY_MATCH');
+    err.errorData = { code: 'NO_CAPACITY_MATCH' };
+    api.callApi.mockRejectedValue(err);
+
+    try {
+      await callWithFallback(
+        '/run',
+        { apiKey: 'sk-test', baseUrl: 'https://api.test/v1' },
+        () => ({}),
+        '2',
+        chalk,
+        { thing: 'job', cmd: 'badgr run' },
+      );
+    } catch (_) {}
+
+    // tier=2 → no tier-2 expansion; no stale-capacity retry for NO_CAPACITY_MATCH
+    expect(api.callApi.mock.calls.length).toBe(1);
+  });
+});