badgr-cli 1.0.44 → 1.0.45

package/src/catalog.js

@@ -112,6 +112,32 @@ export const TEMPLATES = [
       'OpenAI client: OpenAI(base_url="<endpoint>/v1", api_key="<key>")',
     ],
   },
+  {
+    name:        'openwebui',
+    title:       'Open WebUI',
+    description: 'Self-hosted ChatGPT-style web UI for any OpenAI-compatible endpoint',
+    type:        'endpoint',
+    image:       process.env.OPENWEBUI_IMAGE || 'ghcr.io/open-webui/open-webui:main',
+    gpu:         'RTX_3080',
+    gpu_count:   1,
+    port:        8080,
+    health_path: '/health',
+    min_vram_gb: 8,
+    env: {
+      OPENAI_API_BASE_URL: '<set-automatically-by-badgr-serve-openwebui>',
+      OPENAI_API_KEY:      '<your-badgr-api-key>',
+      WEBUI_AUTH:          'False',
+    },
+    notes: [
+      'Preferred: `badgr serve openwebui --model qwen-7b` auto-launches (or reuses) a vLLM',
+      'endpoint and connects Open WebUI to it — no manual env wiring needed.',
+      'Open WebUI is a separate served app from the model — it needs a model endpoint',
+      'behind it (usually vLLM), it is not itself powered by vLLM.',
+      'Or set OPENAI_API_BASE_URL / OPENAI_API_KEY manually via --env to point at any',
+      'OpenAI-compatible server, including one you already have running.',
+      'Chat history and settings persist only for the life of this deployment.',
+    ],
+  },
   {
     name:        'llama-cpp',
     title:       'llama.cpp Server',
@@ -493,6 +519,11 @@ export const BLESSED_COMFY_WORKFLOWS = {
     gpu_type:    'RTX_4090',
     output_type: 'images',
   },
+  'flux-basic': {
+    description: 'FLUX.1-schnell text-to-image',
+    gpu_type:    'RTX_4090',
+    output_type: 'images',
+  },
 };
 
 /**

package/src/commands/comfyui.js

@@ -9,9 +9,10 @@ import { readFileSync, existsSync } from 'fs';
 import { requireApiKey } from '../config.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 { normalizeTier, callWithFallback } from '../fallback.js';
 import { formatCliError } from '../errors.js';
 import { BLESSED_COMFY_WORKFLOWS } from '../catalog.js';
+import { pollJobUntilTerminal, renderJobClosingBlock, stage as _stage, stageDone as _stageDone, writeBlock as _writeBlock, clearBlock as _clearBlock, renderLiveBlock as _renderLiveBlock, printFailureClass as _printFailureClass } from '../progress.js';
 
 const COMFYUI_IMAGE   = process.env.COMFYUI_IMAGE || 'yanwk/comfyui-boot:cu126-megapak';
 const HEALTH_PATH     = '/system_stats';
@@ -54,16 +55,14 @@ function parseEnvFlag(envList) {
   return obj;
 }
 
-function stageLabel(elapsedSec) {
-  if (elapsedSec < 30)  return 'Starting ComfyUI…';
-  if (elapsedSec < 120) return 'Downloading models…';
-  if (elapsedSec < 300) return 'Loading custom nodes…';
-  return `Waiting for ${HEALTH_PATH}…`;
-}
-
-async function waitForComfyUI(endpointUrl, depId, config, chalk) {
+// Live block while ComfyUI comes up — same generic "Checking health" stage
+// line and status block as every other launch path (see serve.js's
+// waitForEndpoint), so ComfyUI doesn't read as a different UX than vLLM.
+async function waitForComfyUI(endpointUrl, depId, config, chalk, costCtx = {}) {
+  const { costPerHour = 0, stageLine = '' } = costCtx;
   const startMs  = Date.now();
   const deadline = startMs + WAIT_TIMEOUT_MS;
+  let blockLines = 0;
 
   while (Date.now() < deadline) {
     try {
@@ -71,22 +70,32 @@ async function waitForComfyUI(endpointUrl, depId, config, chalk) {
         apiKey: config.apiKey, baseUrl: config.baseUrl, timeoutMs: 10_000,
       });
       if (['failed', 'terminated', 'error', 'stopped'].includes(dep.status)) {
-        process.stdout.write('\n');
-        return { ready: false, timedOut: false, depFailed: true, failReason: dep.error || dep.status };
+        if (blockLines > 0) { _clearBlock(blockLines); blockLines = 0; }
+        return {
+          ready: false, timedOut: false, depFailed: true,
+          failReason: dep.error || dep.status,
+          failureClass: dep.failure_class ?? null,
+          nextAction: dep.next_action ?? null,
+        };
       }
     } catch {}
 
     try {
       const res = await fetch(`${endpointUrl}${HEALTH_PATH}`, { signal: AbortSignal.timeout(8000) });
-      if (res.ok) { process.stdout.write('\n'); return { ready: true, timedOut: false, depFailed: false }; }
+      if (res.ok) {
+        if (blockLines > 0) { _clearBlock(blockLines); blockLines = 0; }
+        return { ready: true, timedOut: false, depFailed: false };
+      }
     } catch {}
 
-    const elapsed = Math.round((Date.now() - startMs) / 1000);
-    process.stdout.write(`\r  ${chalk.dim(stageLabel(elapsed) + ` (${elapsed}s)`)}   `);
+    const elapsedSec = Math.round((Date.now() - startMs) / 1000);
+    const spend = costPerHour * (elapsedSec / 3600);
+    blockLines = _writeBlock(blockLines, _renderLiveBlock(chalk, {
+      stageLine, elapsedSec, statusWord: 'starting', spend, id: depId,
+    }));
     await new Promise(r => setTimeout(r, 8000));
   }
 
-  process.stdout.write('\n');
   return { ready: false, timedOut: true, depFailed: false };
 }
 
@@ -142,7 +151,7 @@ export async function comfyBatchCommand(config, args, chalk) {
   if (!flags.workflow) {
     console.error(chalk.red('\n  Usage: badgr comfyui batch --workflow sdxl-basic --prompts prompts.txt --max-cost 10\n'));
     console.error(chalk.dim('  Runs a batch of prompts through a blessed ComfyUI workflow and returns image URLs.\n'));
-    console.error(chalk.dim('  Blessed workflows: sdxl-basic\n'));
+    console.error(chalk.dim(`  Blessed workflows: ${Object.keys(BLESSED_COMFY_WORKFLOWS).join(', ')}\n`));
     process.exitCode = 1;
     return;
   }
@@ -232,36 +241,30 @@ export async function comfyBatchCommand(config, args, chalk) {
   console.log(`  ${chalk.bold('Receipt:')} ${chalk.dim(rcptId)}`);
   console.log(chalk.dim('\n  Polling for completion…\n'));
 
-  const startMs = Date.now();
   const maxMs = maxRuntime * 60 * 1000;
-  while (Date.now() - startMs < maxMs) {
-    await new Promise(r => setTimeout(r, 15_000));
-    let detail;
-    try {
-      detail = await callApi(`/jobs/${job.job_id}`, {
-        apiKey: config.apiKey,
-        baseUrl: config.baseUrl,
-      });
-    } catch { continue; }
-    process.stdout.write(`\r  Status: ${detail.status}  elapsed: ${Math.floor((Date.now() - startMs) / 1000)}s  `);
-    if (detail.status === 'completed') {
-      const out = detail.output || {};
-      console.log(chalk.green('\n\n  ✓ Batch complete\n'));
-      if (out.image_urls && out.image_urls.length > 0) {
-        console.log(`  ${chalk.bold('Images (${out.image_urls.length}):')}`);
-        out.image_urls.forEach((url, i) => console.log(`    ${i + 1}. ${url}`));
-      }
-      console.log(`\n  ${chalk.bold('Receipt:')} ${chalk.dim(rcptId)}\n`);
-      return;
-    }
-    if (detail.status === 'failed') {
-      console.error(chalk.red(`\n\n  ✗ Batch failed: ${detail.error_code || ''} — ${detail.error_message || ''}\n`));
-      process.exitCode = 1;
-      return;
+  const { outcome, detail } = await pollJobUntilTerminal(callApi, config, job.job_id, { chalk, maxMs });
+
+  if (outcome === 'polling_failed') {
+    console.error(chalk.red(`\n\n  ✗ Lost contact with Badgr — could not confirm job status.\n`));
+    console.error(chalk.dim(`    badgr status\n    badgr logs ${job.job_id}\n`));
+    process.exitCode = 1;
+    return;
+  }
+  if (outcome === 'timed_out') {
+    console.error(chalk.yellow('\n\n  Batch still running — detached. Check status:\n'));
+    console.error(chalk.dim(`    badgr status\n`));
+    return;
+  }
+
+  if (outcome === 'completed') {
+    const out = detail.output || {};
+    if (out.image_urls && out.image_urls.length > 0) {
+      console.log(`\n  ${chalk.bold(`Images (${out.image_urls.length}):`)}`);
+      out.image_urls.forEach((url, i) => console.log(`    ${i + 1}. ${url}`));
     }
   }
-  console.error(chalk.yellow('\n\n  Batch still running — detached. Check status:\n'));
-  console.error(chalk.dim(`    badgr status\n`));
+  console.log(renderJobClosingBlock(chalk, detail, rcptId));
+  if (outcome === 'failed') process.exitCode = 1;
 }
 
 export async function comfyuiCommand(config, args, chalk) {
@@ -322,7 +325,10 @@ export async function comfyuiCommand(config, args, chalk) {
   const effectiveTier = normalizeTier(flags.tier);
   const envObj        = { ...parseEnvFlag(flags.env), COMFYUI_WORKFLOW_B64: workflowB64 };
 
-  console.log(chalk.bold('\n🎨 ComfyUI\n'));
+  const STAGE_TOTAL = 4;
+  let stageN = 1;
+
+  console.log(chalk.bold('\n⚡ Running ComfyUI\n'));
   console.log(`  ${chalk.bold('Workflow:')} ${workflow} (${nodeCount} nodes)`);
   console.log(`  ${chalk.bold('Image:')}    ${COMFYUI_IMAGE}`);
   console.log(`  ${chalk.bold('GPU:')}      ${gpu === 'AUTO' ? chalk.dim('auto (16+ GB VRAM)') : gpu}`);
@@ -332,7 +338,6 @@ export async function comfyuiCommand(config, args, chalk) {
     console.log(chalk.yellow('  ⚠  Persistent — billing until: badgr down <id>'));
   }
   console.log();
-  process.stdout.write(chalk.dim('  Finding suitable capacity...\n'));
 
   // Duplicate check
   if (config.apiKey) {
@@ -412,6 +417,11 @@ export async function comfyuiCommand(config, args, chalk) {
     createdAt:     new Date().toISOString(),
   });
 
+  console.log(chalk.dim(_stageDone(stageN, STAGE_TOTAL, 'Finding a working route...')));
+  stageN++;
+  console.log(chalk.dim(_stageDone(stageN, STAGE_TOTAL, 'Starting runtime...')));
+  stageN++;
+
   const endpointUrl = dep.endpoint_url || dep.openai_base_url;
   if (!endpointUrl) {
     console.error(chalk.red(`\n  ✗ No endpoint URL returned. Run: badgr status ${dep.deployment_id}\n`));
@@ -420,25 +430,36 @@ export async function comfyuiCommand(config, args, chalk) {
     return;
   }
 
+  const healthStageN = stageN;
+  const readyStageN  = stageN + 1;
+
   let endpointReady = false;
   if (flags.noWait) {
-    console.log(chalk.yellow('\n  Skipped health check (--no-wait)\n'));
+    console.log(chalk.dim(_stage(healthStageN, STAGE_TOTAL, 'Checking health...')) + chalk.yellow('  (skipped — --no-wait)'));
   } else {
-    const result = await waitForComfyUI(endpointUrl, dep.deployment_id, config, chalk);
-    process.stdout.write('\n');
+    const stageLine = _stage(healthStageN, STAGE_TOTAL, 'Checking health...');
+    const result = await waitForComfyUI(endpointUrl, dep.deployment_id, config, chalk, {
+      costPerHour: dep.cost_per_hour || 0, stageLine,
+    });
 
     if (result.depFailed) {
       console.error(formatCliError('HEALTH_CHECK_DEPLOY_FAILED', {
         deploymentId: dep.deployment_id,
         failReason:   result.failReason,
       }, chalk));
+      _printFailureClass(chalk, { failure_class: result.failureClass, next_action: result.nextAction });
       updateReceipt(rcptId, { status: 'failed', failReason: result.failReason });
       process.exitCode = 1;
       return;
     }
 
     endpointReady = result.ready;
-    if (!endpointReady) updateReceipt(rcptId, { status: 'health_check_timeout' });
+    if (endpointReady) {
+      console.log(chalk.dim(_stage(healthStageN, STAGE_TOTAL, 'Checking health...')));
+      console.log(chalk.green(_stage(readyStageN, STAGE_TOTAL, 'Ready')));
+    } else {
+      updateReceipt(rcptId, { status: 'health_check_timeout' });
+    }
   }
 
   if (flags.checkNodes && endpointReady) {
@@ -460,18 +481,11 @@ export async function comfyuiCommand(config, args, chalk) {
     console.log();
   }
 
-  const rate = dep.cost_per_hour || 0;
   console.log(`  ${chalk.bold('URL:')}          ${chalk.cyan(endpointUrl)}`);
-  console.log(`  ${chalk.bold('GPU:')}          ${dep.gpu_type} × ${dep.gpu_count}`);
-  if (rate > 0)       console.log(`  ${chalk.bold('Rate:')}         $${rate.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 (rate > HIGH_RATE_THRESHOLD && !flags.maxCost) {
-    console.log(chalk.yellow(`  Rate: $${rate.toFixed(2)}/hr — use --max-cost to cap total spend.\n`));
-  }
   console.log(chalk.dim('  Billing continues until you run: ') + chalk.cyan(`badgr down ${dep.deployment_id}`));
 }

package/src/commands/detect.js

@@ -0,0 +1,58 @@
+import path from 'path';
+import { detectWorkload, workloadTypeLabel } from '../detect.js';
+
+function fmtList(items, empty = 'none found') {
+  return items && items.length ? items.join(', ') : empty;
+}
+
+export function suggestedCommandLine(report, { save } = {}) {
+  const parts = ['badgr run .'];
+  if (report.command) parts.push(`--cmd "${report.command}"`);
+  if (report.outputs?.length) parts.push(`--output ${report.outputs[0]}`);
+  if (report.checkpoints?.length) parts.push(`--checkpoint ${report.checkpoints[0]}`);
+  parts.push('--max-cost 5');
+  if (save) parts.push(`--save ${save}`);
+  return parts.join(' ');
+}
+
+export function renderDetectReport(report, chalk) {
+  const lines = [];
+  lines.push('');
+  lines.push(chalk.bold(`Workload:    ${workloadTypeLabel(report.workloadType)}`));
+  const confColor = report.confidence === 'high' ? chalk.green : report.confidence === 'medium' ? chalk.yellow : chalk.red;
+  lines.push(`Confidence:  ${confColor(report.confidence)}`);
+  lines.push('');
+  lines.push(`Detected command:        ${report.command ? chalk.cyan(report.command) : chalk.dim('(none — pass --cmd)')}`);
+  if (report.dockerfile) lines.push(`Detected image:          Dockerfile (${report.dockerfile})`);
+  if (report.requirements.length) lines.push(`Detected requirements:   ${fmtList(report.requirements)}`);
+  lines.push(`Detected inputs:         ${fmtList(report.inputs)}`);
+  lines.push(`Detected outputs:        ${fmtList(report.outputs)}`);
+  if (report.checkpoints.length) lines.push(`Detected checkpoints:    ${fmtList(report.checkpoints)}`);
+  lines.push(`Detected models/assets:  ${fmtList(report.models)}`);
+  if (report.ports.length) lines.push(`Detected ports:          ${report.ports.join(', ')}`);
+  lines.push(`Estimated VRAM:          ${report.vram}`);
+  lines.push(`Estimated runtime:       ${report.runtimeEstimateMinutes != null ? `${report.runtimeEstimateMinutes} min` : 'until stopped (endpoint)'}`);
+  if (report.signals.length) {
+    lines.push('');
+    lines.push(chalk.dim(`Why: ${report.signals.join('; ')}`));
+  }
+  lines.push('');
+  lines.push(`Suggested Badgr command:`);
+  lines.push(`  ${chalk.cyan(suggestedCommandLine(report))}`);
+  lines.push('');
+  return lines.join('\n');
+}
+
+export async function detectCommand(config, args, chalk) {
+  const target = args.find(a => !a.startsWith('--')) || '.';
+  const report = detectWorkload(target);
+
+  if (report.error) {
+    console.error(chalk.red(`\n  ✗ ${report.error}: ${path.resolve(target)}\n`));
+    process.exitCode = 1;
+    return report;
+  }
+
+  console.log(renderDetectReport(report, chalk));
+  return report;
+}

package/src/commands/receipts.js

@@ -1,5 +1,5 @@
-import { listReceipts as localReceipts } from '../store.js';
-import { listReceipts as apiReceipts, getReceipt as apiGetReceipt } from '../api.js';
+import { listReceipts as localReceipts, findReceipt } from '../store.js';
+import { listReceipts as apiReceipts, getReceipt as apiGetReceipt, getJobStatus } from '../api.js';
 
 function fmtMs(ms) {
   return ms >= 1000 ? `${(ms / 1000).toFixed(1)}s` : `${ms}ms`;
@@ -54,6 +54,43 @@ export async function receiptsCommand(config, args, chalk) {
       console.log(chalk.dim('  Run `badgr login` to look up receipts from the API.\n'));
       return;
     }
+
+    // Job-family receipts (badgr comfyui batch / train lora / run / serve)
+    // mint a *local* receipt id that points at a job_id — the backend's
+    // /v1/receipts endpoint has never heard of it (that's the separate LLM
+    // inference receipt ledger), so look it up via the job's own status
+    // instead of 404ing against the wrong system.
+    const local = findReceipt(firstArg);
+    if (local?.job_id) {
+      try {
+        const job = await getJobStatus(config, local.job_id);
+        if (job.status === 'queued' || job.status === 'provisioning' || job.status === 'running' || job.status === 'tearing_down') {
+          console.log(chalk.yellow('  Receipt is still finalizing. Try again shortly.\n'));
+          console.log(`    ${chalk.bold('Job ID:')} ${local.job_id}  (status: ${job.status})\n`);
+          return;
+        }
+        printReceipt({
+          receiptId: firstArg,
+          action: local.type,
+          status: job.status,
+          created_at: new Date(local.started_at || Date.now()).toISOString(),
+          runtimeSeconds: job.elapsed_seconds,
+          finalCost: job.charged_usd ?? undefined,
+          failure_reason: job.failure_class,
+        }, chalk);
+        console.log(`    ${chalk.bold('Teardown:')} ${job.teardown_status === 'ok' ? 'succeeded' : job.teardown_status === 'failed' ? 'failed' : 'n/a'}`);
+        console.log(`    ${chalk.bold('Billing:')}  ${job.billing_status === 'stopped' ? 'stopped' : 'running'}\n`);
+      } catch (err) {
+        // The job finished (we have a local record of a terminal receipt),
+        // but the backend can't confirm it right now — don't silently show
+        // nothing, since billing may or may not actually be settled.
+        console.log(chalk.yellow('  Billing stopped, but receipt finalization failed.\n'));
+        console.log(`    ${chalk.bold('Job ID:')} ${local.job_id}`);
+        console.log(chalk.dim('    Contact support with this ID.\n'));
+      }
+      return;
+    }
+
     try {
       const r = await apiGetReceipt(config, firstArg);
       printReceipt(r, chalk);

package/src/commands/run.js

@@ -8,7 +8,8 @@ import { addReceipt, updateReceipt, generateReceiptId } from '../store.js';
 import { normalizeTier, callWithFallback, HIGH_RATE_THRESHOLD } from '../fallback.js';
 import { formatCliError } from '../errors.js';
 import { TEMPLATE_MAP, buildTemplateFlags, parseTemplateOverrides } from '../catalog.js';
-import { stage as _stage, stageDone as _stageDone, writeBlock as _writeBlock, clearBlock as _clearBlock, renderLiveBlock as _renderLiveBlock } from '../progress.js';
+import { stage as _stage, stageDone as _stageDone, writeBlock as _writeBlock, clearBlock as _clearBlock, renderLiveBlock as _renderLiveBlock, printFailureClass as _printFailureClass } from '../progress.js';
+import { detectWorkload, workloadTypeLabel } from '../detect.js';
 
 /**
  * Flow 1 — local project (primary):
@@ -56,6 +57,10 @@ export function parseRunArgs(args) {
     if (flagArgs[i] === '--save')            { flags.save = flagArgs[++i]; i++; continue; }
     if (flagArgs[i] === '--workspace')       { flags.workspace = flagArgs[++i]; i++; continue; }
     if (flagArgs[i] === '--cmd')             { flags.cmd = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--output')          { flags.output = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--checkpoint')      { flags.checkpoint = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--retry-safe')      { flags.retrySafe = true; i++; continue; }
+    if (flagArgs[i] === '--resume-cmd')      { flags.resumeCmd = flagArgs[++i]; i++; continue; }
     if (flagArgs[i] === '--env') {
       const kv = flagArgs[++i]; i++;
       if (!flags.env) flags.env = [];
@@ -339,6 +344,8 @@ async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost
           exitCode,
           runtimeMs: Date.now() - startMs,
           failureType: classifyFailure(status, exitCode),
+          failureClass: dep.failure_class ?? null,
+          nextAction: dep.next_action ?? null,
         };
       }
     }
@@ -357,6 +364,7 @@ const _KNOWN_RUN_FLAGS = new Set([
   '--detach', '--fallback', '--no-fallback', '--strict-capacity',
   '--no-expanded-search', '--max-runtime', '--max-cost', '--min-vram', '--env',
   '--dry-run', '--cmd', '--save', '--workspace',
+  '--output', '--checkpoint', '--retry-safe', '--resume-cmd',
 ]);
 
 // Directories and files always excluded from project zip uploads.
@@ -497,10 +505,43 @@ export async function runCommand(config, args, chalk) {
   const isGitHubUrl  = firstArg && _isGitHubUrl(firstArg);
   const isCodeSource = isLocalPath || isGitHubUrl;
 
+  // Local paths can be inspected on disk, so a missing --cmd doesn't have to be
+  // an error — try to infer it (and output/checkpoint conventions) the same way
+  // `badgr detect .` would, before ever provisioning anything.
+  let detectionReport = null;
+  if (isLocalPath && !flags.cmd) {
+    detectionReport = detectWorkload(firstArg);
+    if (detectionReport.command && detectionReport.confidence !== 'low') {
+      flags.cmd = detectionReport.command;
+      console.log(chalk.dim(`\n  Detected command (${detectionReport.confidence} confidence): ${detectionReport.command}`));
+      console.log(chalk.dim(`  Workload: ${workloadTypeLabel(detectionReport.workloadType)}  •  badgr detect . for the full report  •  --cmd to override`));
+    }
+    if (!flags.output && detectionReport.outputs?.length) flags.output = detectionReport.outputs[0];
+    if (!flags.checkpoint && detectionReport.checkpoints?.length) flags.checkpoint = detectionReport.checkpoints[0];
+  }
+
+  // Detection couldn't confidently name a command — ask for just that one
+  // missing essential (interactively, if we have a terminal to ask on).
+  if (isLocalPath && !flags.cmd && process.stdin.isTTY && process.stdout.isTTY) {
+    console.log(chalk.dim(`\n  Badgr couldn't confidently detect a command to run in ${path.resolve(firstArg)}.`));
+    try {
+      const { input } = await import('@inquirer/prompts');
+      const answer = await input({
+        message: 'Which command should run?',
+        default: detectionReport?.command || undefined,
+        validate: v => v.trim() ? true : 'A command is required',
+      });
+      flags.cmd = answer.trim();
+    } catch {
+      // Ctrl+C or a non-interactive stdin that lied about isTTY — fall through to the hard error below.
+    }
+  }
+
   if (isCodeSource && !flags.cmd) {
     console.error(chalk.red(`\n  ✗ --cmd is required when running from a ${isLocalPath ? 'local path' : 'GitHub URL'}.\n`));
     if (isLocalPath) {
       console.error(chalk.dim('  Example: badgr run . --cmd "python train.py" --max-cost 5\n'));
+      console.error(chalk.dim('  Or check what Badgr detects first: badgr detect .\n'));
     } else {
       console.error(chalk.dim('  Example: badgr run https://github.com/user/repo --cmd "python train.py" --max-cost 5\n'));
     }
@@ -550,6 +591,20 @@ export async function runCommand(config, args, chalk) {
     return;
   }
 
+  if (!flags.maxCost && !flags.dryRun && isLocalPath && process.stdin.isTTY && process.stdout.isTTY) {
+    try {
+      const { input } = await import('@inquirer/prompts');
+      const answer = await input({
+        message: 'What max cost ($) should cap this run?',
+        default: '5',
+        validate: v => (Number.isFinite(parseFloat(v)) && parseFloat(v) > 0) ? true : 'Enter a number greater than 0',
+      });
+      flags.maxCost = parseFloat(answer);
+    } catch {
+      // fall through to the hard error below
+    }
+  }
+
   if (!flags.maxCost && !flags.dryRun) {
     console.error(chalk.red('\n  ✗ --max-cost is required for run workloads.\n'));
     console.error(chalk.dim('  Example: badgr run --gpu RTX_4090 --image node:20 --max-cost 5 -- node script.js\n'));
@@ -578,7 +633,16 @@ export async function runCommand(config, args, chalk) {
   const maxRuntimeMs = effectiveMaxRuntime * 60 * 1000;
 
   const maxCost      = flags.maxCost ?? null;
-  const envObj       = parseEnvFlag(flags.env);
+  // BADGR_OUTPUT_DIR / BADGR_CHECKPOINT_DIR / BADGR_RETRY_SAFE are a
+  // convention for custom.run containers to write recoverable state outside
+  // the pod — Badgr doesn't enforce what the container does with them, it
+  // just wires the directories through and surfaces --resume-cmd on failure.
+  // Explicit --env always wins if the user passes the same key directly.
+  const conventionEnv = {};
+  if (flags.output)     conventionEnv.BADGR_OUTPUT_DIR = flags.output;
+  if (flags.checkpoint) conventionEnv.BADGR_CHECKPOINT_DIR = flags.checkpoint;
+  if (flags.retrySafe)  conventionEnv.BADGR_RETRY_SAFE = '1';
+  const envObj       = { ...conventionEnv, ...parseEnvFlag(flags.env) };
   const effectiveTier = normalizeTier(flags.tier);
 
   const gpu = flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : undefined;
@@ -595,6 +659,10 @@ export async function runCommand(config, args, chalk) {
     if (maxCost)          console.log(`  ${chalk.bold('Max cost:')}     $${maxCost}`);
     if (flags.maxPrice)   console.log(`  ${chalk.bold('Max price:')}    $${flags.maxPrice}/hr`);
     if (flags.env?.length) console.log(`  ${chalk.bold('Env:')}         ${flags.env.join(', ')}`);
+    if (flags.output)     console.log(`  ${chalk.bold('Output:')}       ${flags.output}`);
+    if (flags.checkpoint) console.log(`  ${chalk.bold('Checkpoint:')}   ${flags.checkpoint}`);
+    if (flags.retrySafe)  console.log(`  ${chalk.bold('Retry-safe:')}   enabled`);
+    if (flags.resumeCmd)  console.log(`  ${chalk.bold('Resume cmd:')}   ${flags.resumeCmd}`);
     console.log(chalk.dim('\n  Remove --dry-run to provision.\n'));
     return;
   }
@@ -616,6 +684,9 @@ export async function runCommand(config, args, chalk) {
   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(', ')}`);
+  if (flags.output)     console.log(`  ${chalk.bold('Output:')}     ${flags.output}`);
+  if (flags.checkpoint) console.log(`  ${chalk.bold('Checkpoint:')} ${flags.checkpoint}`);
+  if (flags.retrySafe)  console.log(`  ${chalk.bold('Retry-safe:')} enabled`);
   console.log();
 
 
@@ -775,6 +846,7 @@ export async function runCommand(config, args, chalk) {
     console.log(chalk.dim(_stage(STAGE_TOTAL, STAGE_TOTAL, stageLabels[reason] ?? 'Stopped')));
     console.log(chalk.dim(`  Runtime: ${fmtRuntime(runtimeMs)}  •  Estimated cost: ~$${finalCost.toFixed(2)}`));
     _printFinalInfo(chalk, { exitCode: null, teardownOk, jobId: dep.deployment_id, rcptId });
+    if (flags.resumeCmd) console.log(`  ${chalk.bold('Resume:')}    ${flags.resumeCmd}`);
     console.log();
   }
 
@@ -805,6 +877,7 @@ export async function runCommand(config, args, chalk) {
   if (dep.status === 'failed') {
     process.removeListener('SIGINT', handleShutdown);
     console.error(formatCliError('JOB_INFRASTRUCTURE_FAILURE', { receiptId: rcptId }, chalk));
+    _printFailureClass(chalk, dep);
     process.exitCode = 1;
     return;
   }
@@ -813,7 +886,7 @@ export async function runCommand(config, args, chalk) {
   console.log(chalk.dim(`\n  [${stageN}/${STAGE_TOTAL}] Running command (Ctrl+C to stop)`));
 
   attachStart = Date.now();
-  const { status: finalStatus, exitCode, runtimeMs, failureType } = await attachToJob(config, dep.deployment_id, {
+  const { status: finalStatus, exitCode, runtimeMs, failureType, failureClass, nextAction } = await attachToJob(config, dep.deployment_id, {
     chalk,
     maxRuntimeMs,
     maxCost,
@@ -853,11 +926,13 @@ export async function runCommand(config, args, chalk) {
     } else {
       console.error(formatCliError('JOB_FAILED', { exitCode, deploymentId: dep.deployment_id }, chalk));
     }
+    _printFailureClass(chalk, { failure_class: failureClass, next_action: nextAction });
     console.log(chalk.dim(_stage(STAGE_TOTAL, STAGE_TOTAL, 'Failed')));
     console.log(chalk.dim(`  Runtime: ${fmtRuntime(runtimeMs)}  •  Estimated cost: ~$${finalCost.toFixed(2)}`));
     // The container already reached a terminal state on the provider side by the
     // time we observe it here, so billing is already stopped — no extra teardown call needed.
     _printFinalInfo(chalk, { exitCode, teardownOk: true, jobId: dep.deployment_id, rcptId });
+    if (flags.resumeCmd) console.log(`  ${chalk.bold('Resume:')}    ${flags.resumeCmd}`);
     process.exitCode = exitCode ?? 1;
     return;
   }