badgr-cli 1.1.2 → 1.1.3

package/README.md

@@ -103,13 +103,13 @@ Everything before `--` is a `badgr launch` flag; everything after `--` is passed
 | `--region US\|EU\|AU` | — | Region preference |
 | `--size small\|medium\|browser` | per-workload default | VM class override |
 
-### `badgr task` — a labeled launch
+### `badgr job` — a tracked coding-agent job
 
 ```bash
-badgr task "Run the Chromium tests and tell me what failed" --max-cost 1 -- npm run test:chromium
+badgr job cline "Run the Chromium tests and tell me what failed" --check "npm run test:chromium" --max-cost 1
 ```
 
-A thin wrapper over `badgr launch . -- <command>` — the description is printed for the human and otherwise discarded; the receipt and `badgr status` still key off the deployment ID like any other launch.
+Submits via `POST /v1/jobs` (`type: "agent"`) — the same Jobs API used by every other job type. Requires `--check <command>` (verifies success); tracked at `/jobs` with a `job_id`, status, logs, output, cost, and time.
 
 ---
 
@@ -185,7 +185,7 @@ test
 | `badgr doctor` | Diagnose a GPU workload failure — read-only, no login needed |
 | `badgr run <command>` | Run a one-off GPU job (any container command) |
 | `badgr launch cline\|claude\|codex\|playwright "<task>"` | Run a coding/testing agent on a CPU VM — image + command auto-selected |
-| `badgr task "<desc>" -- <command>` | Label + launch — thin wrapper over `badgr launch . -- <command>` |
+| `badgr job <agent> "<instruction>" --check "<cmd>"` | Tracked coding-agent job via `POST /v1/jobs` (type: agent) |
 | `badgr serve <model>` | Start a persistent OpenAI-compatible endpoint |
 | `badgr status` | Show what's running and what's billing |
 | `badgr logs <id>` | Fetch log output from a deployment |

package/package.json

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

package/src/badgr.js

@@ -9,7 +9,7 @@ import { logsCommand }       from './commands/logs.js';
 import { receiptsCommand }   from './commands/receipts.js';
 import { runCommand }        from './commands/run.js';
 import { launchCommand }     from './commands/launch.js';
-import { taskCommand }       from './commands/task.js';
+import { jobCommand }        from './commands/job.js';
 import { artifactsCommand }  from './commands/artifacts.js';
 import { serveCommand }      from './commands/serve.js';
 import { modelsCommand }     from './commands/models.js';
@@ -31,6 +31,7 @@ import { rerunCommand }      from './commands/rerun.js';
 import { heartbeatCommand }  from './commands/heartbeat.js';
 import { pullCommand }       from './commands/pull.js';
 import { doctorCommand }     from './commands/doctor.js';
+import { diagnoseCommand }   from './commands/diagnose.js';
 import { connectCommand }    from './commands/connect.js';
 
 const HELP = `
@@ -43,10 +44,11 @@ ${chalk.bold('COMMANDS')}
   ${chalk.cyan('badgr run <command>')}       Run a one-off GPU job
   ${chalk.cyan('badgr launch cline|claude|codex|playwright "<task>"')}  Run a coding/testing workload on a CPU VM — image + command auto-selected
   ${chalk.cyan('badgr launch <source> -- <command>')}  Advanced escape hatch: run any other command on a CPU VM
-  ${chalk.cyan('badgr task "<desc>" -- <command>')}    Label + launch — thin wrapper over badgr launch . -- <command>
+  ${chalk.cyan('badgr job <agent> "<instruction>" --check "<command>"')}  Bounded coding-agent job, tracked at /jobs (POST /v1/jobs, type: agent)
   ${chalk.cyan('badgr serve <model>')}       Serve a model with an OpenAI-compatible endpoint
   ${chalk.cyan('badgr serve openwebui')}     Serve Open WebUI — chat UI, connects to a model endpoint
-  ${chalk.cyan('badgr doctor')}              Diagnose why a GPU workload is likely failing (read-only, no login needed)
+  ${chalk.cyan('badgr diagnose "<input>"')}   Diagnose any GPU issue for free — GitHub issue, Docker image, log, repo, or text
+  ${chalk.cyan('badgr doctor')}              Local GPU / model-fit diagnosis (read-only, no login needed)
   ${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 pull <id>')}           Safely pull cloud-agent patch artifacts
@@ -108,10 +110,18 @@ ${chalk.bold('EXAMPLES')}
   badgr launch https://github.com/user/repo --max-cost 1 -- python narrgo.py
   badgr artifacts <id>
 
-  ${chalk.dim('# badgr task is a thin label wrapper over badgr launch . -- <command>:')}
-  badgr task "Run the Chromium tests and tell me what failed" --max-cost 1 -- npm run test:chromium
+  ${chalk.dim('# badgr job — bounded coding-agent job with a pass/fail check, tracked at /jobs:')}
+  badgr job cline "Run the Chromium tests and tell me what failed" --check "npm run test:chromium" --max-cost 1
 
-  ${chalk.dim('# Diagnose why a GPU workload is likely failing (local, read-only, no login):')}
+  ${chalk.dim('# Diagnose any GPU issue for free (no login needed):')}
+  badgr diagnose "https://github.com/org/repo/issues/123"
+  badgr diagnose ./error.log
+  badgr diagnose --docker ajayrajtp/vllm_gemma412b:latest
+  badgr diagnose --repo https://github.com/org/repo
+  badgr diagnose --comfyui workflow.json
+  badgr diagnose "https://github.com/org/repo/issues/123" --approve ${chalk.dim('# approve a capped smoke test')}
+
+  ${chalk.dim('# Local model-fit and workload diagnosis (no network):')}
   badgr doctor
   badgr doctor --model Qwen/Qwen2.5-7B-Instruct --serve
   badgr doctor --logs ./vllm.log
@@ -195,6 +205,10 @@ ${chalk.bold('badgr run OPTIONS')}
   --no-gpu               Run on a CPU-only VM — no GPU is provisioned (conflicts with --gpu/--gpu-memory)
   --tier 1               Managed provider routing (default)
   --tier 2               Marketplace provider routing, lower-cost options
+  --smoke                Cheapest compatible provider for a local/dev test run — defaults: $0.25
+                         max cost, 10min max runtime (override with --max-cost/--max-runtime).
+                         Always: one attempt, mandatory teardown, no --workspace.
+                         Same as setting BADGR_DEV_CHEAPEST=1. An explicit --tier overrides this.
   --image <image>        Docker image (default: python:3.11-slim)
   --env KEY=VALUE        Set an environment variable (repeatable)
   --count <n>            Number of GPUs (default: 1)
@@ -270,7 +284,7 @@ async function main() {
     case 'detect':   return detectCommand(config, rest, chalk);
     case 'run':      return runCommand(config, rest, chalk);
     case 'launch':   return launchCommand(config, rest, chalk);
-    case 'task':     return taskCommand(config, rest, chalk);
+    case 'job':      return jobCommand(config, rest, chalk);
     case 'artifacts': return artifactsCommand(config, rest, chalk);
     case 'pull':     return pullCommand(config, rest, chalk);
     case 'serve':    return serveCommand(config, rest, chalk);
@@ -280,7 +294,9 @@ async function main() {
     case 'restart':   return restartCommand(config, rest, chalk);
     case 'rerun':     return rerunCommand(config, rest, chalk);
     case 'heartbeat': return heartbeatCommand(config, rest, chalk);
-    case 'doctor':    return doctorCommand(config, rest, chalk);
+    case 'diagnose':    return diagnoseCommand(config, rest, chalk);
+    case 'run-issue':   return diagnoseCommand(config, rest, chalk); // alias — matches the /run-issue web flow name
+    case 'doctor':      return doctorCommand(config, rest, chalk);
     case 'receipts': return receiptsCommand(config, rest, chalk);
     case 'models':   return modelsCommand(config, chalk);
     case 'capacity': return capacityCommand(config, rest, chalk);

package/src/commands/billing.js

@@ -7,7 +7,7 @@ badgr billing — manage your AI Badgr balance
 
 COMMANDS
   badgr billing status         Show current balance
-  badgr billing add <amount>   Open checkout to add balance (minimum $10)
+  badgr billing add <amount>   Open checkout to add balance (minimum $5)
 
 EXAMPLES
   badgr billing status
@@ -49,8 +49,8 @@ async function billingStatus(config, chalk) {
 async function billingAdd(config, amount, chalk) {
   requireApiKey(config);
   const amountInt = parseInt(amount, 10);
-  if (!amountInt || amountInt < 10) {
-    console.error(chalk.red('  Minimum top-up is $10. Example: badgr billing add 10'));
+  if (!amountInt || amountInt < 5) {
+    console.error(chalk.red('  Minimum top-up is $5. Example: badgr billing add 5'));
     process.exit(1);
   }
 

package/src/commands/connect.js

@@ -79,5 +79,8 @@ export async function connectCommand(args, chalk, deps = {}) {
   setCredential(provider, key);
   console.log(chalk.green(`\n  ✓ ${alreadyConnected ? 'Updated' : 'Connected'} ${provider}`));
   console.log(chalk.dim(`  Stored in ${CREDENTIALS_FILE} (owner-only file permissions)`));
-  console.log(chalk.dim(`  Used automatically by: badgr launch ${provider === 'anthropic' ? 'claude' : provider === 'openai' ? 'codex' : provider} "<task>"\n`));
+  const usageHint = provider === 'anthropic' ? 'badgr launch claude "<task>"'
+    : provider === 'openai' ? 'badgr launch codex "<task>"'
+    : `badgr launch cline/claude/codex --provider ${provider} --model <model-id> "<task>"`;
+  console.log(chalk.dim(`  Used automatically by: ${usageHint}\n`));
 }

package/src/commands/diagnose.js

@@ -0,0 +1,493 @@
+import fs from 'fs';
+import { callApi } from '../api.js';
+import { ensureLoggedIn } from '../onboarding.js';
+
+const DIAGNOSE_HELP = `
+Paste anything. Badgr detects the input, diagnoses it for free, then
+shows either missing information, a verified template, or a capped
+smoke-test plan. No GPU launches without explicit --approve.
+
+Usage:
+  badgr diagnose "<input>"
+  badgr diagnose "<input>" --approve
+  badgr diagnose "<input>" --json
+  badgr diagnose <case_id_or_url> --approve   Resume an existing case (e.g.
+                                               one shared via a case link)
+
+Input (auto-detected):
+  GitHub issue URL       https://github.com/org/repo/issues/N
+  GitHub repo URL        https://github.com/org/repo
+  Docker image           owner/image:tag  or  image:tag
+  Local log / file       ./error.log  or  vllm.log
+  ComfyUI workflow       workflow.json  (JSON file)
+  Raw conversation       paste Discord / Slack / support thread text
+  Existing case          repro_xxxxxxxx  or  https://aibadgr.com/repro/repro_xxxxxxxx
+
+Flags:
+  --approve              Approve the capped smoke test after diagnosis (opens
+                          browser sign-in automatically if not logged in)
+  --docker <image>       Force Docker-image intake (override auto-detect)
+  --repo   <url>         Force repository intake (override auto-detect)
+  --comfyui <path>       Force ComfyUI workflow intake (override auto-detect)
+  --github <url>         Include a GitHub issue URL found inside pasted text
+                          as additional context. Opt-in only, never fetched
+                          automatically (see "Additional context found" below)
+  --json                 Machine-readable JSON output
+  --help, -h             Show this help
+
+Safety: nothing runs from AI-extracted data without --approve.
+        No GPU launches without explicit approval and a credit check.
+
+Full interactive flow: https://aibadgr.com/run-issue`;
+
+function detectInput(raw, flags) {
+  if (flags.docker) {
+    return {
+      kind:  'docker_image',
+      label: `Docker image: ${flags.docker}`,
+      body:  { docker_image: flags.docker },
+    };
+  }
+  if (flags.repo) {
+    return {
+      kind:  'repo_url',
+      label: `GitHub repository: ${flags.repo}`,
+      body:  { repo_url: flags.repo },
+    };
+  }
+  if (flags.comfyui) {
+    if (!fs.existsSync(flags.comfyui)) throw new Error(`File not found: ${flags.comfyui}`);
+    return {
+      kind:  'comfyui_workflow',
+      label: `ComfyUI workflow: ${flags.comfyui}`,
+      body:  { workflow_json: fs.readFileSync(flags.comfyui, 'utf8') },
+    };
+  }
+
+  if (!raw) return null;
+
+  // A case_id (bare, or embedded in a /repro/<id> or /run-issue?case_id=<id>
+  // link — the two shapes an admin-prepared or self-created case gets
+  // shared as) resumes that existing case instead of diagnosing new input.
+  const bareCaseMatch = /^repro_[a-zA-Z0-9]+$/.exec(raw.trim());
+  const urlCaseMatch = /\/repro\/(repro_[a-zA-Z0-9]+)/.exec(raw) || /[?&]case_id=(repro_[a-zA-Z0-9]+)/.exec(raw);
+  const caseId = bareCaseMatch?.[0] || urlCaseMatch?.[1];
+  if (caseId) {
+    return { kind: 'existing_case', label: `Existing case: ${caseId}`, caseId };
+  }
+
+  if (/^https?:\/\/(www\.)?github\.com\/[^/]+\/[^/]+\/issues\/\d/.test(raw)) {
+    return {
+      kind:  'github_issue',
+      label: `GitHub issue: ${raw}`,
+      body:  { github_url: raw },
+    };
+  }
+
+  if (/^https?:\/\/(www\.)?github\.com\//.test(raw)) {
+    return {
+      kind:  'repo_url',
+      label: `GitHub repository: ${raw}`,
+      body:  { repo_url: raw },
+    };
+  }
+
+  if (fs.existsSync(raw)) {
+    const content = fs.readFileSync(raw, 'utf8');
+    if (raw.endsWith('.json') || raw.endsWith('.JSON')) {
+      let parsed;
+      try { parsed = JSON.parse(content); } catch { /* not valid JSON */ }
+      if (parsed && typeof parsed === 'object' && (parsed.nodes || parsed['1'] || parsed['0'])) {
+        return {
+          kind:  'comfyui_workflow',
+          label: `ComfyUI workflow: ${raw}`,
+          body:  { workflow_json: content },
+        };
+      }
+    }
+    return {
+      kind:  'log_file',
+      label: `Log / error file: ${raw}`,
+      body:  { text: content.slice(0, 50_000) },
+    };
+  }
+
+  if (
+    !raw.startsWith('http') &&
+    /^[a-z0-9][a-z0-9._\-]*(?:\/[a-z0-9._\-]+)*(?::[a-zA-Z0-9._\-]+)?$/.test(raw) &&
+    raw.length < 200
+  ) {
+    return {
+      kind:  'docker_image',
+      label: `Docker image: ${raw}`,
+      body:  { docker_image: raw },
+    };
+  }
+
+  return {
+    kind:  'text',
+    label: 'Text / conversation',
+    body:  { text: raw.slice(0, 50_000) },
+  };
+}
+
+function _printResult(result, chalk) {
+  const { extraction: e, static_incompatibilities, multi_gpu_detected, large_download, github_issue, detected_github_url } = result;
+
+  if (github_issue) {
+    console.log(`  ${chalk.bold('Issue:')}   ${github_issue.title}  ${chalk.dim(`[${github_issue.state}]`)}`);
+  }
+
+  // The conversation stays primary — a GitHub URL found inside pasted text
+  // is only ever offered here, never fetched automatically.
+  if (detected_github_url) {
+    console.log();
+    console.log(`  ${chalk.bold('Additional context found:')} ${detected_github_url}`);
+    console.log(`    ${chalk.dim(`Include it: badgr diagnose "<input>" --github ${detected_github_url}`)}`);
+  }
+
+  const wt = e.workload_type && e.workload_type !== 'unknown' ? e.workload_type : null;
+  const conf = e.confidence ? ` ${chalk.dim(`(${Math.round(e.confidence * 100)}% confidence)`)}` : '';
+  if (wt) console.log(`  ${chalk.bold('Workload:')} ${wt}${conf}`);
+  if (e.summary) console.log(`  ${chalk.bold('Summary:')} ${e.summary}`);
+  console.log();
+
+  if (e.docker_images?.length) {
+    console.log(`  ${chalk.bold('Image:')}   ${e.docker_images[0]}${e.docker_images.length > 1 ? chalk.dim(` +${e.docker_images.length - 1} more`) : ''}`);
+  }
+  if (e.models?.length) {
+    console.log(`  ${chalk.bold('Model:')}   ${e.models[0]}${e.models.length > 1 ? chalk.dim(` +${e.models.length - 1} more`) : ''}`);
+  }
+  if (e.commands?.length) {
+    console.log(`  ${chalk.bold('Command:')} ${e.commands[0]}`);
+  }
+  if (e.errors?.length) {
+    console.log(`  ${chalk.bold('Errors:')}`);
+    for (const err of e.errors.slice(0, 3)) console.log(`    ${chalk.red('✗')} ${err}`);
+  }
+
+  if (static_incompatibilities?.length) {
+    console.log();
+    console.log(`  ${chalk.bold('Diagnosis:')} ${chalk.yellow('Static incompatibility — no GPU needed')}`);
+    for (const inc of static_incompatibilities) console.log(`    ${chalk.yellow('!')} ${inc}`);
+  } else if (e.missing_information?.length) {
+    console.log();
+    console.log(`  ${chalk.bold('Diagnosis:')} Missing information`);
+    for (const m of e.missing_information) console.log(`    ${chalk.dim('?')} ${m}`);
+  } else if (wt) {
+    console.log();
+    console.log(`  ${chalk.bold('Diagnosis:')} Workload detected — ready for capped test`);
+  }
+
+  if (multi_gpu_detected) {
+    console.log(`  ${chalk.yellow('!')} Multi-GPU detected: ${multi_gpu_detected}`);
+    console.log(`    ${chalk.dim('Capped test will use a single GPU only.')}`);
+  }
+  if (large_download) {
+    console.log(`  ${chalk.yellow('!')} Large model download: ~${large_download.estimated_gb} GB`);
+    console.log(`    ${chalk.dim('Funding approval required before test launches.')}`);
+  }
+  if (result.secret_types_detected?.length) {
+    console.log(`  ${chalk.dim(`Secrets redacted before analysis: ${result.secret_types_detected.join(', ')}`)}`);
+  }
+  if (!result.ai_available) {
+    console.log(`  ${chalk.dim('(AI extraction unavailable — pattern matching only)')}`);
+  }
+
+  console.log();
+  if (static_incompatibilities?.length) {
+    console.log(`  ${chalk.bold('Recommended action:')} Fix the incompatibility listed above — no GPU test needed`);
+  } else if (e.missing_information?.length) {
+    console.log(`  ${chalk.bold('Recommended action:')} Provide the missing details above, then re-run`);
+  } else {
+    console.log(`  ${chalk.bold('Recommended action:')} Run ${chalk.cyan('badgr diagnose "<input>" --approve')} to launch a capped test`);
+  }
+}
+
+async function _doApprove(config, result, chalk) {
+  // Diagnosis and case creation stay anonymous and free — login is only
+  // required once we know a real GPU test needs approving (below).
+  const e = result.extraction;
+  const confirmBody = {
+    workload_type:              e.workload_type || 'generic',
+    docker_image:               e.docker_images?.[0] || null,
+    model_id:                   e.models?.[0] || null,
+    launch_command:             e.commands?.[0] || null,
+    error_log:                  null,
+    expected_result:            e.expected_result || null,
+    environment_variable_names: e.environment_variable_names || [],
+    gpu_requirements:           Array.isArray(e.gpu_requirements)
+                                  ? e.gpu_requirements.join(', ')
+                                  : e.gpu_requirements || null,
+    source_summary:             e.summary || null,
+  };
+
+  let caseData;
+  try {
+    console.log(chalk.dim('  Creating case...'));
+    caseData = await callApi('/run-issue/confirm', {
+      method:    'POST',
+      apiKey:    config.apiKey || '',
+      baseUrl:   config.baseUrl,
+      body:      confirmBody,
+      timeoutMs: 20_000,
+    });
+  } catch (err) {
+    console.error(chalk.red(`\n  ✗ Could not create case: ${err.message}\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  const { case_id: caseId, status, test_plan: plan, missing_information: missing } = caseData;
+
+  if (status === 'incompatible') {
+    console.log(chalk.yellow('\n  Static incompatibility — no GPU test needed.'));
+    console.log();
+    return;
+  }
+  if (status === 'missing_information') {
+    console.log(chalk.yellow('\n  Cannot approve — missing information:'));
+    for (const m of (missing || [])) console.log(`    ? ${m}`);
+    console.log();
+    return;
+  }
+  if (status === 'template_matched') {
+    console.log(chalk.green('\n  Matched a verified template — no new GPU test needed.'));
+    if (plan?.final_command) {
+      console.log();
+      console.log(`  ${chalk.bold('Verified command:')}`);
+      console.log(`  ${chalk.cyan(plan.final_command)}`);
+    }
+    console.log();
+    return;
+  }
+
+  if (plan) {
+    console.log();
+    if (plan.gpu_type)        console.log(`  ${chalk.bold('GPU:')}          ${plan.gpu_type}`);
+    if (plan.estimated_cost)  console.log(`  ${chalk.bold('Maximum cost:')} $${Number(plan.estimated_cost).toFixed(2)}`);
+    if (plan.max_runtime_min) console.log(`  ${chalk.bold('Max runtime:')}  ${plan.max_runtime_min} min`);
+    if (plan.requires_reduced_test)       console.log(`  ${chalk.yellow('!')} Multi-GPU detected — test uses a single GPU`);
+    if (plan.requires_funding_approval)   console.log(`  ${chalk.yellow('!')} Large download — funding required`);
+  }
+
+  await _approveAndRun(config, caseId, plan, chalk);
+}
+
+// Claim → approve → run for a case that already exists (just created via
+// /confirm above, or resumed via an existing_case input). Auth is required
+// from here on — diagnosis and case creation stay anonymous and free, but a
+// real GPU test needs a signed-in account. The CLI never grants a free-run
+// entitlement (web admin only, see grant_free_run in run_issue_routes.py);
+// it only redeems one a case already carries, same as normal billing.
+async function _approveAndRun(config, caseId, plan, chalk) {
+  const printResumeHint = () =>
+    console.error(chalk.dim(`  Resume this case: https://aibadgr.com/run-issue?case_id=${caseId}\n`));
+
+  let authConfig = config;
+  if (!authConfig.apiKey) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+      console.error(chalk.red('\n  ✗ Sign in required to approve a GPU test. Run: badgr login\n'));
+      printResumeHint();
+      process.exitCode = 1;
+      return;
+    }
+    console.log(chalk.yellow('\n  Sign in to continue. Opening browser...'));
+    try {
+      authConfig = await ensureLoggedIn(authConfig, chalk);
+    } catch (err) {
+      console.error(chalk.red(`\n  ✗ Sign-in failed: ${err.message}\n`));
+      printResumeHint();
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  try {
+    await callApi(`/run-issue/cases/${caseId}/claim`, {
+      method: 'POST', apiKey: authConfig.apiKey, baseUrl: authConfig.baseUrl, timeoutMs: 10_000,
+    });
+  } catch { /* already claimed — continue */ }
+
+  let approved;
+  try {
+    approved = await callApi(`/run-issue/cases/${caseId}/approve`, {
+      method:    'POST',
+      apiKey:    authConfig.apiKey,
+      baseUrl:   authConfig.baseUrl,
+      body: {
+        confirmed:               true,
+        funding_approved:        Boolean(plan?.requires_funding_approval),
+        reduced_test_confirmed:  Boolean(plan?.requires_reduced_test),
+      },
+      timeoutMs: 15_000,
+    });
+  } catch (err) {
+    if (err.httpStatus === 402 || err.message?.includes('402')) {
+      console.error(chalk.yellow('\n  ✗ Insufficient credits. Run: badgr billing\n'));
+    } else {
+      console.error(chalk.red(`\n  ✗ Approve failed: ${err.message}\n`));
+    }
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log(chalk.dim('\n  Launching capped smoke test...'));
+  let ran;
+  try {
+    ran = await callApi(`/run-issue/cases/${caseId}/run`, {
+      method: 'POST', apiKey: authConfig.apiKey, baseUrl: authConfig.baseUrl, timeoutMs: 30_000,
+    });
+  } catch (err) {
+    console.error(chalk.red(`\n  ✗ Launch failed: ${err.message}\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log();
+  console.log(chalk.green('  Smoke test launched.'));
+  console.log(`  ${chalk.bold('Case:')}     ${caseId}`);
+  if (ran?.job_id)      console.log(`  ${chalk.bold('Job:')}      ${ran.job_id}`);
+  if (ran?.free_run_used) console.log(`  ${chalk.bold('Billing:')}  Free run — no charge`);
+  console.log(`  ${chalk.bold('Evidence:')} https://aibadgr.com/repro/${caseId}`);
+  console.log();
+}
+
+// Resume an existing case (bare case_id or a shared /repro or /run-issue
+// link) instead of diagnosing new input. No /confirm — the case already
+// exists; this only reads its current state and, with --approve, redeems
+// whatever entitlement/billing state it already carries.
+async function _diagnoseExistingCase(config, caseId, flags, chalk) {
+  let caseData;
+  try {
+    caseData = await callApi(`/run-issue/cases/${caseId}`, {
+      apiKey: config.apiKey || '', baseUrl: config.baseUrl, timeoutMs: 15_000,
+    });
+  } catch (err) {
+    console.error(chalk.red(`\n  ✗ Could not load case ${caseId}: ${err.message}\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  if (flags.json) {
+    console.log(JSON.stringify(caseData, null, 2));
+    if (flags.approve) await _approveAndRun(config, caseId, caseData.test_plan, chalk);
+    return;
+  }
+
+  console.log();
+  console.log(`  ${chalk.bold('Case:')}      ${caseId}`);
+  console.log(`  ${chalk.bold('Status:')}    ${caseData.status}`);
+  if (caseData.workload_type) console.log(`  ${chalk.bold('Workload:')}  ${caseData.workload_type}`);
+  if (caseData.known_command) console.log(`  ${chalk.bold('Command:')}   ${caseData.known_command}`);
+  if ((caseData.missing_information || []).length) {
+    console.log();
+    console.log(`  ${chalk.bold('Missing information:')}`);
+    for (const m of caseData.missing_information) console.log(`    ? ${m}`);
+  }
+
+  console.log();
+  if (caseData.free_verification_consumed) {
+    console.log(`  ${chalk.dim('This case\'s free run has already been used — further verification is normal billing.')}`);
+  } else if (caseData.free_verification_available) {
+    console.log(`  ${chalk.green(`1 free verification job available — up to $${(caseData.free_verification_max_cost_usd ?? 5).toFixed(0)}`)}`);
+  } else if (caseData.test_plan) {
+    console.log(`  ${chalk.dim(`Verification available — max $${Number(caseData.test_plan.max_cost_usd ?? 0).toFixed(2)}`)}`);
+  }
+  console.log();
+
+  if (flags.approve) {
+    await _approveAndRun(config, caseId, caseData.test_plan, chalk);
+  } else {
+    console.log(`  ${chalk.bold('Resume:')} badgr diagnose ${caseId} --approve`);
+    console.log();
+  }
+}
+
+export async function diagnoseCommand(config, args, chalk) {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(DIAGNOSE_HELP);
+    return;
+  }
+
+  const flags = {};
+  let positional = null;
+  let i = 0;
+  while (i < args.length) {
+    const a = args[i];
+    if (a === '--docker')   { flags.docker  = args[++i]; i++; continue; }
+    if (a === '--repo')     { flags.repo    = args[++i]; i++; continue; }
+    if (a === '--comfyui')  { flags.comfyui = args[++i]; i++; continue; }
+    if (a === '--github')   { flags.github  = args[++i]; i++; continue; }
+    if (a === '--approve')  { flags.approve = true;  i++; continue; }
+    if (a === '--json')     { flags.json    = true;  i++; continue; }
+    if (!a.startsWith('-') && positional === null) positional = a;
+    i++;
+  }
+
+  if (!positional && !flags.docker && !flags.repo && !flags.comfyui) {
+    console.log(DIAGNOSE_HELP);
+    return;
+  }
+
+  let detected;
+  try {
+    detected = detectInput(positional, flags);
+  } catch (err) {
+    console.error(chalk.red(`\n  ✗ ${err.message}\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!detected) {
+    console.log(DIAGNOSE_HELP);
+    return;
+  }
+
+  if (detected.kind === 'existing_case') {
+    await _diagnoseExistingCase(config, detected.caseId, flags, chalk);
+    return;
+  }
+
+  // --github opts into fetching a GitHub issue URL found inside pasted text
+  // (see the "Additional context found" notice) — never fetched by default.
+  if (flags.github) detected.body.github_url = flags.github;
+
+  if (!flags.json) {
+    console.log();
+    console.log(`  ${chalk.bold('Detected:')} ${detected.label}`);
+    console.log(chalk.dim('  Analysing...'));
+  }
+
+  let result;
+  try {
+    result = await callApi('/run-issue/extract', {
+      method:    'POST',
+      apiKey:    config.apiKey || '',
+      baseUrl:   config.baseUrl,
+      body:      detected.body,
+      timeoutMs: 120_000,
+    });
+  } catch (err) {
+    console.error(chalk.red(`\n  ✗ ${err.message}\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  if (flags.json) {
+    console.log(JSON.stringify({ detected: detected.kind, ...result }, null, 2));
+    return;
+  }
+
+  console.log();
+  _printResult(result, chalk);
+
+  console.log();
+  console.log(chalk.dim('  Free diagnosis. No GPU was provisioned.'));
+  console.log(chalk.dim('  Full interactive flow: https://aibadgr.com/run-issue'));
+  console.log();
+
+  if (flags.approve) {
+    await _doApprove(config, result, chalk);
+  }
+}

package/src/commands/job.js

@@ -0,0 +1,246 @@
+import { callApi } from '../api.js';
+import { requireApiKey } from '../config.js';
+
+/**
+ * badgr job <agent> "<instruction>" --check "npm test"
+ *
+ * Submits a bounded coding-agent job via POST /v1/jobs (type: "agent"),
+ * which creates a Job record and runs it on a GPU/CPU VM.
+ * All three interfaces (website, CLI, POST /v1/jobs) share the same
+ * execution path on the backend (backend/jobs_routes.py).
+ *
+ * Usage:
+ *   badgr job cline "Fix the checkout bug" --check "npm test"
+ *   badgr job claude "Add pagination" --check "npm run test:e2e" --max-cost 3
+ *   badgr job codex "Refactor auth" --check "pytest tests/" --repo https://github.com/org/repo
+ */
+
+const _BOOL_FLAGS = { '--dry-run': 'dryRun', '--detach': 'detach' };
+const _VALUE_FLAGS = {
+  '--check': 'check', '--eval': 'check', '--eval-command': 'check',
+  '--repo': 'repository', '--repository': 'repository',
+  '--ref': 'ref',
+  '--agent': 'agent',
+  '--provider': 'provider',
+  '--model': 'model',
+  '--max-cost': 'maxCost',
+  '--max-runtime': 'maxRuntime',
+};
+
+// Scan the arg list, pull out known flags wherever they appear, and collect
+// the remaining tokens as positionals. This lets flags appear anywhere:
+//   badgr job cline "Fix it" --check "npm test"
+//   badgr job "Fix it" --check "npm test" --agent cline
+function parseJobArgs(rawArgs) {
+  const flags = {};
+  const positional = [];
+  let i = 0;
+  while (i < rawArgs.length) {
+    const tok = rawArgs[i];
+    if (tok in _BOOL_FLAGS) { flags[_BOOL_FLAGS[tok]] = true; i += 1; continue; }
+    if (tok in _VALUE_FLAGS) { flags[_VALUE_FLAGS[tok]] = rawArgs[i + 1]; i += 2; continue; }
+    positional.push(tok);
+    i += 1;
+  }
+  return { flags, positional };
+}
+
+// Providers the agent Job type accepts (backend jobs_routes._VALID_AGENT_PROVIDERS).
+// The BYOK/OpenAI-compatible providers `badgr launch --provider` supports
+// (openrouter, deepseek, glm, custom) are NOT among them: the Jobs API
+// resolves credentials server-side from stored provider credentials and has
+// nowhere to put a custom base URL, so those must be rejected in the CLI
+// rather than sent on to a 400 from the server.
+export const JOB_API_PROVIDERS = ['badgr', 'openai', 'anthropic'];
+
+export const JOB_AGENTS = ['cline', 'claude', 'claude-code', 'codex', 'playwright'];
+
+export async function jobCommand(config, args, chalk) {
+  // Support both:
+  //   badgr job <agent> "<instruction>" --check "..."
+  //   badgr job "<instruction>" --check "..." --agent cline   (fallback)
+  const { flags, positional } = parseJobArgs(args);
+
+  let agentName = null;
+  let instructionText = null;
+
+  const knownAgents = new Set(JOB_AGENTS);
+
+  if (positional.length >= 2 && knownAgents.has(positional[0])) {
+    agentName = positional[0];
+    instructionText = positional.slice(1).join(' ').trim();
+  } else if (positional.length >= 1) {
+    instructionText = positional.join(' ').trim();
+    agentName = flags.agent ?? 'cline';
+  }
+
+  if (!instructionText || !agentName) {
+    console.error(chalk.red('\nUsage: badgr job <agent> "<instruction>" --check "<command>"\n'));
+    console.error(chalk.dim('  Agents: cline (default), claude-code, codex, playwright'));
+    console.error(chalk.dim('  Example: badgr job cline "Fix the checkout bug" --check "npm test"'));
+    console.error(chalk.dim('  Example: badgr job claude-code "Add pagination" --check "pytest tests/" --max-cost 3\n'));
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!flags.check) {
+    console.error(chalk.red('\n  ✗ --check <command> is required — it verifies the job succeeded.\n'));
+    console.error(chalk.dim('  Example: badgr job cline "Fix the bug" --check "npm test"\n'));
+    process.exitCode = 1;
+    return;
+  }
+
+  return runJob(config, {
+    agent:       agentName,
+    instruction: instructionText,
+    check:       flags.check,
+    provider:    flags.provider,
+    model:       flags.model,
+    repository:  flags.repository,
+    ref:         flags.ref,
+    maxCost:     flags.maxCost,
+    maxRuntime:  flags.maxRuntime,
+    dryRun:      flags.dryRun,
+    detach:      flags.detach,
+  }, chalk);
+}
+
+/**
+ * Submit one agent job to POST /v1/jobs and (unless detached) poll it to a
+ * terminal state. Takes an already-resolved options object rather than argv
+ * so callers that have parsed their own flags — `badgr launch <agent>
+ * --eval-command ...` — can reuse this path directly instead of
+ * re-serializing their flags back into an argv for jobCommand to reparse.
+ */
+export async function runJob(config, opts, chalk) {
+  const { agent: agentName, instruction: instructionText, check } = opts;
+
+  // Require API key — jobs are tracked under the user account.
+  const apiKey = requireApiKey(config, chalk);
+  if (!apiKey) return;
+
+  const provider = opts.provider ?? null;
+  const model = opts.model ?? null;
+  const repository = opts.repository ?? '.';
+  const ref = opts.ref ?? null;
+  const maxCostUsd = opts.maxCost != null ? Number(opts.maxCost) : 2.0;
+  const maxRuntimeSeconds = opts.maxRuntime != null ? Number(opts.maxRuntime) : 1800;
+
+  if (provider && !JOB_API_PROVIDERS.includes(provider)) {
+    console.error(chalk.red(`\n  ✗ The Jobs API does not accept --provider ${provider}.`));
+    console.error(chalk.dim(`  Supported: ${JOB_API_PROVIDERS.join(', ')}`));
+    console.error(chalk.dim('  BYOK providers (openrouter, deepseek, glm, custom) work with'));
+    console.error(chalk.dim('  badgr launch without --eval-command.\n'));
+    process.exitCode = 1;
+    return;
+  }
+
+  // Print plan.
+  console.log('');
+  console.log(chalk.bold(`  Job: ${instructionText}`));
+  console.log(chalk.dim(`  Agent: ${agentName}${provider ? ` via ${provider}` : ''}${model ? ` / ${model}` : ''}`));
+  console.log(chalk.dim(`  Check: ${check}`));
+  console.log(chalk.dim(`  Max:   $${maxCostUsd.toFixed(2)} / ${Math.round(maxRuntimeSeconds / 60)} min`));
+  console.log('');
+
+  if (opts.dryRun) {
+    console.log(chalk.yellow('  (dry run — no job submitted)\n'));
+    return;
+  }
+
+  // Submit job.
+  let job;
+  try {
+    job = await callApi('/v1/jobs', {
+      method: 'POST',
+      apiKey,
+      baseUrl: config.baseUrl,
+      body: {
+        type: 'agent',
+        input: {
+          repository,
+          ref,
+          agent: agentName,
+          provider,
+          model,
+          instruction: instructionText,
+          check,
+        },
+        policy: {
+          max_cost: maxCostUsd,
+          max_runtime_minutes: Math.round(maxRuntimeSeconds / 60),
+        },
+      },
+    });
+  } catch (err) {
+    console.error(chalk.red(`\n  ✗ Could not submit job: ${err.message}\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  if (job?.detail || job?.error) {
+    console.error(chalk.red(`\n  ✗ ${job.detail ?? job.error}\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  const jobId = job?.job_id;
+  if (!jobId) {
+    console.error(chalk.red('\n  ✗ Unexpected response from server.\n'));
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log(chalk.green(`  ✓ Job submitted`));
+  console.log(chalk.dim(`  ID: ${jobId}`));
+
+  if (opts.detach) {
+    console.log(chalk.dim(`  Status: badgr status (or GET /v1/jobs/${jobId})\n`));
+    return;
+  }
+
+  // Poll until terminal.
+  console.log(chalk.dim('  Waiting for job to complete…\n'));
+  const pollMs = 10_000;
+  const maxWaitMs = (maxRuntimeSeconds + 60) * 1000;
+  const startMs = Date.now();
+
+  while (true) {
+    await new Promise(r => setTimeout(r, pollMs));
+    if (Date.now() - startMs > maxWaitMs) {
+      console.error(chalk.yellow(`\n  ⚠ Timed out waiting. Job ${jobId} is still running.\n`));
+      console.log(chalk.dim(`  Check: badgr status (or GET /v1/jobs/${jobId})\n`));
+      break;
+    }
+    let latest;
+    try {
+      latest = await callApi(`/v1/jobs/${jobId}`, { apiKey, baseUrl: config.baseUrl });
+    } catch {
+      continue;
+    }
+    if (!latest?.job_id) continue;
+    if (latest.status === 'running' && latest.stage) {
+      process.stdout.write(chalk.dim(`\r  ${latest.stage}…`));
+    }
+    if (latest.status === 'completed' || latest.status === 'failed' || latest.status === 'canceled') {
+      console.log('');
+      if (latest.status === 'completed') {
+        console.log(chalk.green(`\n  ✓ Job succeeded`));
+        if (latest.output?.exit_code != null) {
+          console.log(chalk.green(`  Check: ${latest.output.exit_code === 0 ? 'passed' : 'failed'}`));
+        }
+      } else if (latest.status === 'failed') {
+        console.error(chalk.red(`\n  ✗ Job failed`));
+        if (latest.error?.message) console.error(chalk.dim(`  ${latest.error.message}`));
+        process.exitCode = 1;
+      } else {
+        console.log(chalk.yellow(`\n  Job ${latest.status}`));
+      }
+      if (latest.charged_usd != null) {
+        console.log(chalk.dim(`  Cost: $${latest.charged_usd.toFixed(4)}`));
+      }
+      console.log('');
+      break;
+    }
+  }
+}

package/src/commands/launch.js

@@ -1,5 +1,6 @@
 import { runCommand, parseRunArgs } from './run.js';
-import { getCredential, setCredential, PROVIDER_ENV_KEYS } from '../credentials.js';
+import { runJob } from './job.js';
+import { getCredential, setCredential, PROVIDER_ENV_KEYS, MODEL_PROVIDERS, KNOWN_MODEL_PROVIDERS, ENV_KEYS_FOR_API_KIND } from '../credentials.js';
 import { VM_CLASSES, LAUNCH_VM_SIZES, vmClassForWorkload } from '../spec.js';
 
 // Phase 1 supports these coding/testing workloads via shorthand. Do not add
@@ -43,8 +44,8 @@ import { VM_CLASSES, LAUNCH_VM_SIZES, vmClassForWorkload } from '../spec.js';
 // images/badgr-job-runner/entrypoint.py, which subprocess.run executes
 // directly with shell=False — no shlex.split() involved for this path).
 const AGENT_WORKLOADS = {
-  cline:  { image: process.env.BADGR_AGENT_IMAGE_CLINE  || 'ghcr.io/michaelmanly/badgr-agent-cline:latest',  buildCmd: task => ['badgr-cline-run', task], provider: null },
-  claude: { image: process.env.BADGR_AGENT_IMAGE_CLAUDE || 'ghcr.io/michaelmanly/badgr-agent-claude:latest', buildCmd: task => ['claude', '-p', task],  provider: 'anthropic' },
+  cline:  { image: process.env.BADGR_AGENT_IMAGE_CLINE  || 'ghcr.io/michaelmanly/badgr-agent-cline:latest',  buildCmd: task => ['badgr-cline-run', task],  provider: null },
+  claude: { image: process.env.BADGR_AGENT_IMAGE_CLAUDE || 'ghcr.io/michaelmanly/badgr-agent-claude:latest', buildCmd: task => ['badgr-claude-run', task], provider: 'anthropic' },
   codex:  { image: process.env.BADGR_AGENT_IMAGE_CODEX   || 'ghcr.io/michaelmanly/badgr-agent-codex:latest',  buildCmd: task => ['badgr-codex-run', task], provider: 'openai' },
 };
 
@@ -100,9 +101,25 @@ const _VALUE_FLAGS = {
   '--max-runtime': 'maxRuntime', '--max-cost': 'maxCost', '--save': 'save',
   '--workspace': 'workspace', '--output': 'output', '--checkpoint': 'checkpoint',
   '--resume-cmd': 'resumeCmd', '--size': 'size',
+  // BYOK / OpenAI-compatible model selection — `badgr launch cline` only,
+  // see resolveModelProviderEnv below.
+  '--provider': 'provider', '--model': 'model', '--base-url': 'baseUrl',
+  // When present, routes to POST /v1/jobs (type: agent) instead of the
+  // plain badgr-launch GPU/CPU run path.
+  '--eval-command': 'evalCommand', '--eval': 'evalCommand',
 };
 const _REPEATABLE_FLAGS = { '--env': 'env', '--artifacts': 'artifacts' };
 
+// `badgr launch --eval-command` hands the run to the agent Job type
+// (POST /v1/jobs, type: agent), which provisions and configures the VM
+// server-side. These VM-shaping flags have no equivalent there, so they are
+// called out instead of being silently dropped.
+const JOB_API_IGNORED_FLAGS = [
+  ['--base-url', 'baseUrl'], ['--env', 'env'], ['--artifacts', 'artifacts'],
+  ['--workspace', 'workspace'], ['--output', 'output'], ['--size', 'size'],
+  ['--image', 'image'], ['--region', 'region'], ['--tier', 'tier'],
+];
+
 const _PASSTHROUGH_FLAGS = [
   ['--image', 'image'], ['--count', 'count'], ['--region', 'region'],
   ['--tier', 'tier'], ['--max-price', 'maxPrice'], ['--name', 'name'],
@@ -229,28 +246,32 @@ function resolveVmSize(flags, workloadName, chalk) {
   return true;
 }
 
-async function resolveMissingCredential(provider, chalk) {
-  const providerLabel = provider === 'anthropic' ? 'Anthropic' : 'OpenAI';
+async function resolveMissingCredential(provider, chalk, label) {
+  const displayLabel = label ?? (provider === 'anthropic' ? 'Anthropic' : 'OpenAI');
   if (!process.stdin.isTTY || !process.stdout.isTTY) {
-    console.error(chalk.red(`\n  ✗ No ${provider} credential found.\n`));
+    console.error(chalk.red(`\n  ✗ No ${displayLabel} credential found.\n`));
     console.error(chalk.dim(`  Run: badgr connect ${provider}\n`));
     return null;
   }
 
-  console.log(chalk.yellow(`\n  ${providerLabel} is not connected.`));
-  console.log(chalk.dim(`  ${providerLabel === 'Anthropic' ? 'Claude Code' : 'Codex'} uses your ${providerLabel} account for model usage.`));
-  console.log(chalk.dim('  Badgr credits still pay for the disposable VM.\n'));
+  console.log(chalk.yellow(`\n  ${displayLabel} is not connected.`));
+  if (label) {
+    console.log(chalk.dim(`  Your own ${displayLabel} API key pays for model usage — Badgr credits still pay for the disposable VM.\n`));
+  } else {
+    console.log(chalk.dim(`  ${displayLabel === 'Anthropic' ? 'Claude Code' : 'Codex'} uses your ${displayLabel} account for model usage.`));
+    console.log(chalk.dim('  Badgr credits still pay for the disposable VM.\n'));
+  }
 
   try {
     const { password } = await import('@inquirer/prompts');
     const key = await password({
-      message: `Enter your ${providerLabel} API key:`,
+      message: `Enter your ${displayLabel} API key:`,
       validate: v => v.trim() ? true : 'API key is required',
     });
     const trimmed = key.trim();
     if (!trimmed) return null;
     setCredential(provider, trimmed);
-    console.log(chalk.green(`  ✓ ${providerLabel} connected\n`));
+    console.log(chalk.green(`  ✓ ${displayLabel} connected\n`));
     return trimmed;
   } catch {
     // Ctrl+C or a non-interactive stdin that lied about isTTY.
@@ -258,6 +279,53 @@ async function resolveMissingCredential(provider, chalk) {
   }
 }
 
+/**
+ * BYOK / OpenAI-compatible or Anthropic-compatible model selection.
+ *
+ * `badgr launch <cline|codex> --provider <name> --model <id> [--base-url <url>]`
+ * uses apiKind='openai' (injects OPENAI_API_KEY/OPENAI_BASE_URL/MODEL).
+ * `badgr launch claude --provider <name> --model <id> [--base-url <url>]`
+ * uses apiKind='anthropic' (injects ANTHROPIC_API_KEY/ANTHROPIC_BASE_URL/MODEL).
+ *
+ * Validates before provisioning — unknown provider, missing --model, or
+ * missing --base-url for `custom` all hard-fail here, no VM created.
+ * Returns the extra env pairs to inject, or null on validation failure.
+ */
+async function resolveModelProviderEnv(flags, chalk, apiKind = 'openai') {
+  const provider = flags.provider;
+  if (!(provider in MODEL_PROVIDERS)) {
+    console.error(chalk.red(`\n  ✗ Unknown model provider: ${provider}`));
+    console.error(chalk.dim(`  Supported: ${KNOWN_MODEL_PROVIDERS.join(', ')}\n`));
+    return null;
+  }
+  if (!flags.model) {
+    console.error(chalk.red(`\n  ✗ --provider ${provider} requires --model <model-id> — no default model is assumed.\n`));
+    return null;
+  }
+  const baseUrl = flags.baseUrl || MODEL_PROVIDERS[provider].defaultBaseUrl;
+  if (!baseUrl) {
+    console.error(chalk.red(`\n  ✗ --provider custom requires --base-url <url>.\n`));
+    return null;
+  }
+
+  const envKeys = ENV_KEYS_FOR_API_KIND[apiKind];
+  const userEnvKeys = new Set((flags.env || []).map(kv => kv.split('=')[0]));
+  const env = [];
+
+  if (!userEnvKeys.has(envKeys.apiKey)) {
+    let credential = getCredential(provider);
+    if (!credential) {
+      credential = await resolveMissingCredential(provider, chalk, MODEL_PROVIDERS[provider].label);
+      if (!credential) return null;
+    }
+    env.push(`${envKeys.apiKey}=${credential}`);
+  }
+  if (!userEnvKeys.has(envKeys.model)) env.push(`${envKeys.model}=${flags.model}`);
+  if (!userEnvKeys.has(envKeys.baseUrl)) env.push(`${envKeys.baseUrl}=${baseUrl}`);
+
+  return env;
+}
+
 async function launchAgentWorkload(config, agentName, rawArgs, chalk) {
   const { flags, task, gpuRejected } = parseWorkloadShorthandArgs(rawArgs);
 
@@ -275,6 +343,32 @@ async function launchAgentWorkload(config, agentName, rawArgs, chalk) {
 
   warnIfTaskMayHaveSwallowedAFlag(task, chalk);
 
+  // When --eval-command is given, route to the agent Job type
+  // (POST /v1/jobs, type: agent) which tracks check results and stores a
+  // receipt — same UX path, different backend record type. Runs after the
+  // --gpu / empty-task guards above so those still apply, and calls runJob
+  // directly with the already-parsed flags rather than re-serializing them
+  // into an argv (which silently dropped everything the re-serializer
+  // forgot to list).
+  if (flags.evalCommand) {
+    const ignored = JOB_API_IGNORED_FLAGS.filter(([, key]) => flags[key] !== undefined);
+    if (ignored.length) {
+      console.error(chalk.yellow(`\n  ⚠ ${ignored.map(([f]) => f).join(', ')} ${ignored.length === 1 ? 'is' : 'are'} not supported with --eval-command and will be ignored.`));
+      console.error(chalk.dim('    The Jobs API provisions and configures the VM itself.\n'));
+    }
+    return runJob(config, {
+      agent:       agentName,
+      instruction: task,
+      check:       flags.evalCommand,
+      provider:    flags.provider,
+      model:       flags.model,
+      maxCost:     flags.maxCost,
+      maxRuntime:  flags.maxRuntime,
+      dryRun:      flags.dryRun,
+      detach:      flags.detach,
+    }, chalk);
+  }
+
   if (!resolveVmSize(flags, agentName, chalk)) {
     process.exitCode = 1;
     return;
@@ -282,7 +376,23 @@ async function launchAgentWorkload(config, agentName, rawArgs, chalk) {
 
   const spec = AGENT_WORKLOADS[agentName];
 
-  if (spec.provider) {
+  if (spec.provider && flags.provider) {
+    // BYOK override for a fixed-provider workload (claude → anthropic,
+    // codex → openai). Skip the managed credential flow and inject the
+    // BYOK model provider env vars instead. The apiKind determines which
+    // env var names the agent image reads (ANTHROPIC_* vs OPENAI_*).
+    const apiKind = spec.provider === 'anthropic' ? 'anthropic' : 'openai';
+    const modelEnv = await resolveModelProviderEnv(flags, chalk, apiKind);
+    if (!modelEnv) {
+      process.exitCode = 1;
+      return;
+    }
+    if (!flags.env) flags.env = [];
+    flags.env.push(...modelEnv);
+    flags.authRequired = { provider: flags.provider, status: 'connected' };
+  } else if (spec.provider) {
+    // Standard managed-credential flow: anthropic → ANTHROPIC_API_KEY,
+    // openai → OPENAI_API_KEY. Prompts inline on first use in a TTY.
     const envKey = PROVIDER_ENV_KEYS[spec.provider];
     const userSuppliedKey = flags.env?.some(kv => kv.startsWith(`${envKey}=`));
     let credential = userSuppliedKey ? null : getCredential(spec.provider);
@@ -309,12 +419,24 @@ async function launchAgentWorkload(config, agentName, rawArgs, chalk) {
       if (!flags.env) flags.env = [];
       flags.env.push(`${envKey}=${credential}`);
     }
+  } else if (flags.provider) {
+    // BYOK for cline (spec.provider is null) — injects OPENAI_API_KEY,
+    // OPENAI_BASE_URL, MODEL. The backend skips its managed model token
+    // when it sees an existing OPENAI_API_KEY (see jobs_routes.py).
+    const modelEnv = await resolveModelProviderEnv(flags, chalk, 'openai');
+    if (!modelEnv) {
+      process.exitCode = 1;
+      return;
+    }
+    if (!flags.env) flags.env = [];
+    flags.env.push(...modelEnv);
+    flags.authRequired = { provider: flags.provider, status: 'connected' };
   } else {
     flags.authRequired = { provider: null, status: 'none' };
   }
-  // cline has no `provider` — Badgr mints and injects its own short-lived
-  // job-scoped model token server-side (see backend jobs_routes.py); the
-  // CLI never handles or displays that token.
+  // cline with no --provider: Badgr mints a short-lived job-scoped model
+  // token server-side (see backend jobs_routes.py); the CLI never handles
+  // or displays that token. --provider switches cline to BYOK instead.
 
   const cmdArgv = spec.buildCmd(task);
   flags.cmd = displayCmd(cmdArgv);
@@ -336,6 +458,13 @@ async function launchDirectWorkload(config, workloadName, rawArgs, chalk) {
   // there's no natural-language interface to hand it to, unlike the agent
   // workloads above. Read but intentionally not passed to buildCmd().
 
+  if (flags.provider) {
+    console.error(chalk.red(`\n  ✗ --provider is not supported for \`badgr launch ${workloadName}\` — it is a test runner with no LLM component.\n`));
+    console.error(chalk.dim(`  Use \`badgr launch claude/cline/codex\` for AI agent workloads.\n`));
+    process.exitCode = 1;
+    return;
+  }
+
   if (gpuRejected) {
     console.error(chalk.red('\n  ✗ badgr launch runs on a CPU VM and does not accept --gpu.\n'));
     process.exitCode = 1;

package/src/commands/run.js

@@ -5,7 +5,7 @@ import { createWriteStream } from 'fs';
 import { requireApiKey } from '../config.js';
 import { callApi, terminateDeployment, uploadBlob, quoteRun } from '../api.js';
 import { addReceipt, updateReceipt, generateReceiptId, selectedComputeFromDeployment } from '../store.js';
-import { normalizeTier, callWithFallback, HIGH_RATE_THRESHOLD } from '../fallback.js';
+import { normalizeTier, callWithFallback, HIGH_RATE_THRESHOLD, SMOKE_MAX_COST_USD, SMOKE_MAX_RUNTIME_MINUTES } 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, printFailureClass as _printFailureClass, printCapacityPreview, formatTierLabel } from '../progress.js';
@@ -57,6 +57,7 @@ export function parseRunArgs(args) {
     if (flagArgs[i] === '--count')          { flags.count = parseInt(flagArgs[++i], 10); i++; continue; }
     if (flagArgs[i] === '--region')         { flags.region = flagArgs[++i]; i++; continue; }
     if (flagArgs[i] === '--tier')           { flags.tier = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--smoke')          { flags.smoke = true; i++; continue; }
     if (flagArgs[i] === '--max-price')      { flags.maxPrice = parseFloat(flagArgs[++i]); i++; continue; }
     if (flagArgs[i] === '--name')           { flags.name = flagArgs[++i]; i++; continue; }
     if (flagArgs[i] === '--detach')          { flags.detach = true; i++; continue; }
@@ -409,7 +410,7 @@ async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost
 
 // Known badgr run flags — used to detect broken shell line continuation.
 const _KNOWN_RUN_FLAGS = new Set([
-  '--gpu', '--image', '--count', '--region', '--tier', '--max-price', '--name',
+  '--gpu', '--image', '--count', '--region', '--tier', '--smoke', '--max-price', '--name',
   '--detach', '--no-detach', '--fallback', '--no-fallback', '--strict-capacity',
   '--no-expanded-search', '--max-runtime', '--max-cost', '--min-vram', '--gpu-memory',
   '--cpu', '--memory', '--no-gpu', '--env',
@@ -692,6 +693,28 @@ export async function runCommand(config, args, chalk, opts = {}) {
     return;
   }
 
+  // ── Smoke mode: cheapest compatible provider for local/dev test runs ──────
+  // --smoke, or BADGR_DEV_CHEAPEST=1 in the environment for a local default so
+  // it doesn't have to be typed every time. An explicit --tier always wins —
+  // the user asked for a specific tier, so smoke's routing/caps don't apply.
+  const devCheapestEnv = process.env.BADGR_DEV_CHEAPEST === '1' || process.env.BADGR_DEV_CHEAPEST === 'true';
+  const smokeMode = !flags.tier && (flags.smoke || devCheapestEnv);
+
+  if (smokeMode) {
+    if (flags.detach) {
+      console.error(chalk.red('  ✗ --smoke requires teardown to run in the foreground — remove --detach.'));
+      process.exitCode = 1;
+      return;
+    }
+    if (flags.workspace) {
+      console.error(chalk.red('  ✗ --smoke does not support --workspace (no persistent storage for smoke runs).'));
+      process.exitCode = 1;
+      return;
+    }
+    if (flags.maxCost === undefined) flags.maxCost = SMOKE_MAX_COST_USD;
+    if (flags.maxRuntime === undefined) flags.maxRuntime = SMOKE_MAX_RUNTIME_MINUTES;
+  }
+
   if (!flags.maxCost && !flags.dryRun && isLocalPath && process.stdin.isTTY && process.stdout.isTTY) {
     try {
       const { input } = await import('@inquirer/prompts');
@@ -801,6 +824,7 @@ export async function runCommand(config, args, chalk, opts = {}) {
     if (flags.resumeCmd)  console.log(`  ${chalk.bold('Resume cmd:')}   ${flags.resumeCmd}`);
     if (flags.artifacts?.length) console.log(`  ${chalk.bold('Artifacts:')}    ${flags.artifacts.join(', ')}`);
     if (!isLaunch) console.log(`  ${chalk.bold('Tier:')}         ${formatTierLabel(effectiveTier)}`);
+    if (smokeMode)  console.log(`  ${chalk.bold('Routing:')}      cheapest compatible (smoke mode)`);
 
     // Upload-size estimate is GPU-job-specific (spec: "badgr run ... upload
     // size") and does a real local zip pass — skip it for CPU launches
@@ -848,6 +872,7 @@ export async function runCommand(config, args, chalk, opts = {}) {
   console.log(`  ${chalk.bold('Max cost:')}    ${maxCostLabel}`);
   console.log(`  ${chalk.bold('Max runtime:')} ${runtimeLabel}`);
   console.log(`  ${chalk.bold('Auto-stop:')}   ${maxCost ? 'enabled' : chalk.yellow('disabled — stop manually with badgr down')}`);
+  if (smokeMode) console.log(`  ${chalk.bold('Routing:')}     cheapest compatible (smoke mode)`);
   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:')}      ${redactEnvForDisplay(flags.env)}`);
@@ -912,6 +937,7 @@ export async function runCommand(config, args, chalk, opts = {}) {
       max_price_per_hour: flags.maxPrice,
       name: flags.name,
       tier: tierOverride || effectiveTier,
+      ...(smokeMode ? { routing: 'cheapest' } : {}),
       ...(Object.keys(envObj).length > 0 ? { env: envObj } : {}),
       max_runtime_seconds: effectiveMaxRuntime * 60,
       ...(maxCost ? { max_cost_usd: maxCost } : {}),
@@ -936,7 +962,7 @@ export async function runCommand(config, args, chalk, opts = {}) {
       effectiveTier,
       chalk,
       { thing: 'job', cmd: cmdName },
-      { allowTier2Fallback: !flags.noFallback },
+      { allowTier2Fallback: !flags.noFallback, singleAttempt: smokeMode },
     );
   } catch (err) {
     if (err.isPaymentRequired) {

package/src/credentials.js

@@ -8,10 +8,43 @@ export const CREDENTIALS_FILE = join(CONFIG_DIR, 'credentials.json');
 export const PROVIDER_ENV_KEYS = {
   anthropic: 'ANTHROPIC_API_KEY',
   openai: 'OPENAI_API_KEY',
+  // OpenAI-compatible BYOK lanes for `badgr launch cline --provider <name>`
+  // (see MODEL_PROVIDERS below) — the cline agent image only ever reads
+  // OPENAI_API_KEY/OPENAI_BASE_URL/MODEL (images/badgr-agent-cline/
+  // badgr-cline-run), regardless of which upstream provider the key
+  // actually belongs to.
+  openrouter: 'OPENAI_API_KEY',
+  deepseek: 'OPENAI_API_KEY',
+  glm: 'OPENAI_API_KEY',
+  custom: 'OPENAI_API_KEY',
 };
 
 export const KNOWN_PROVIDERS = Object.keys(PROVIDER_ENV_KEYS);
 
+// `badgr launch cline --provider <name> --model <id> [--base-url <url>]` —
+// BYOK / OpenAI-compatible model selection. `custom` has no default base
+// URL: it must always be supplied explicitly, since there is nothing sane
+// to default it to. Every other entry's defaultBaseUrl is overridable with
+// an explicit --base-url too (e.g. a company-hosted DeepSeek-compatible
+// gateway).
+export const MODEL_PROVIDERS = {
+  openrouter: { label: 'OpenRouter', defaultBaseUrl: 'https://openrouter.ai/api/v1' },
+  deepseek: { label: 'DeepSeek', defaultBaseUrl: 'https://api.deepseek.com/v1' },
+  glm: { label: 'GLM (Zhipu)', defaultBaseUrl: 'https://open.bigmodel.cn/api/paas/v4' },
+  custom: { label: 'Custom (OpenAI-compatible)', defaultBaseUrl: null },
+};
+
+export const KNOWN_MODEL_PROVIDERS = Object.keys(MODEL_PROVIDERS);
+
+// Which env vars each API kind expects inside the agent container.
+// `claude` uses the Anthropic SDK (ANTHROPIC_*); `cline` and `codex` use the
+// OpenAI SDK (OPENAI_*). `model` is always 'MODEL' — every agent wrapper
+// reads that env var and maps it to its own --model flag.
+export const ENV_KEYS_FOR_API_KIND = {
+  openai:    { apiKey: 'OPENAI_API_KEY',    baseUrl: 'OPENAI_BASE_URL',    model: 'MODEL' },
+  anthropic: { apiKey: 'ANTHROPIC_API_KEY', baseUrl: 'ANTHROPIC_BASE_URL', model: 'MODEL' },
+};
+
 /**
  * Credential storage for `badgr connect <provider>`. This is a local file
  * under ~/.badgr with owner-only permissions (chmod 600) — not the

package/src/fallback.js

@@ -6,6 +6,13 @@ import { CATALOG, formatCliError } from './errors.js';
 /** Rates above this threshold trigger a visible warning when no --max-cost is set. */
 export const HIGH_RATE_THRESHOLD = 3.00;
 
+// ── badgr run --smoke defaults ────────────────────────────────────────────────
+// Hardcoded default smoke caps, not a config system — --max-cost/--max-runtime
+// still override them when passed explicitly (see run.js). The goal is to stop
+// expensive local smoke tests by default, not build another configuration system.
+export const SMOKE_MAX_COST_USD = 0.25;
+export const SMOKE_MAX_RUNTIME_MINUTES = 10;
+
 /** Normalise --tier flag variants to '1' or '2'. */
 export function normalizeTier(tier) {
   return (tier === '2' || tier === 'tier2' || tier === 'tier-2') ? '2' : (tier || '1');
@@ -37,12 +44,16 @@ export class CapacityError extends Error {
  * @param {object}   labels            - { thing: 'job'|'endpoint', cmd: 'badgr run'|'badgr serve' }
  * @param {object}   [opts]
  * @param {boolean}  [opts.allowTier2Fallback=true] - set false to disable tier-2 expansion
+ * @param {boolean}  [opts.singleAttempt=false] - set true to skip both the same-tier
+ *   provider retry and tier-2 expansion, failing immediately on the first error
+ *   (badgr run --smoke's "one attempt" guarantee)
  */
 export async function callWithFallback(endpoint, callOpts, buildBody, effectiveTier, chalk, labels, opts = {}) {
   const { callApi } = await import('./api.js');
   const thing = labels?.thing ?? 'job';
   const cmd   = labels?.cmd   ?? 'badgr run';
-  const allowTier2Fallback = opts.allowTier2Fallback !== false; // default true
+  const singleAttempt = opts.singleAttempt === true;
+  const allowTier2Fallback = !singleAttempt && opts.allowTier2Fallback !== false; // default true
 
   // 220s: comfortably above backend's BADGR_PROVISION_TIMEOUT_SECONDS (default
   // 200s, itself set above deployment_service.py's 180s routing-search
@@ -113,7 +124,7 @@ export async function callWithFallback(endpoint, callOpts, buildBody, effectiveT
   // Provider retry: PROVISIONING_FAILED means the selected provider couldn't launch the slot.
   // Retry once with prefer_different_provider so the backend routes to a different provider
   // (e.g. RunPod failed → try Vast.ai or Hyperstack) within the same max_cost budget.
-  if (d?.code === 'PROVISIONING_FAILED' || d?.code === 'PROVIDER_ADAPTER_ERROR') {
+  if (!singleAttempt && (d?.code === 'PROVISIONING_FAILED' || d?.code === 'PROVIDER_ADAPTER_ERROR')) {
     console.log(chalk.dim('\n  Provider unavailable — trying alternative provider...\n'));
     try {
       const retryBody = { ...buildBody(), prefer_different_provider: true };

package/src/commands/task.js

@@ -1,25 +0,0 @@
-import { launchCommand } from './launch.js';
-
-/**
- * badgr task "<description>" -- <command>
- *
- * The MVP version of "assign a task" — a thin label wrapper over
- * `badgr launch . -- <command>`. It does not queue, schedule, or track
- * anything beyond what `badgr launch` already does; the description is
- * printed for the human and otherwise discarded (the receipt/status page
- * still key off the deployment ID, same as any other launch).
- */
-export async function taskCommand(config, args, chalk) {
-  const description = args[0];
-  if (!description || description.startsWith('-')) {
-    console.error(chalk.red('\nUsage: badgr task "<description>" [badgr launch flags...] -- <command>\n'));
-    console.error(chalk.dim('  The description must come first, before any flags.'));
-    console.error(chalk.dim('  Example: badgr task "Run the Chromium tests and tell me what failed" --max-cost 1 -- npm run test:chromium'));
-    console.error(chalk.dim('  Example: badgr task "Fix the failing checkout test" --max-cost 1 -- claude -p "Fix the failing checkout test"\n'));
-    process.exitCode = 1;
-    return;
-  }
-
-  console.log(chalk.dim(`  Task: ${description}`));
-  return launchCommand(config, ['.', ...args.slice(1)], chalk);
-}