badgr-cli 1.1.4 → 1.1.6

package/src/commands/diagnose.js

@@ -2,15 +2,16 @@ import fs from 'fs';
 import { classifyPastedInput } from 'badgr-shared';
 import { callApi } from '../api.js';
 import { ensureLoggedIn } from '../onboarding.js';
+import { webBaseUrl } from '../config.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.
+Paste anything. This IS the Badgr Smoke Test: free, no GPU, no login.
+Badgr detects the input, resolves a command, and automatically runs every
+applicable free structural check on it. No GPU launches without explicit
+--approve, which starts a real Badgr Run.
 
 Usage:
   badgr diagnose "<input>"
-  badgr diagnose "<input>" --smoke
   badgr diagnose "<input>" --approve
   badgr diagnose "<input>" --json
   badgr diagnose <case_id_or_url> --approve   Resume an existing case (e.g.
@@ -26,24 +27,14 @@ Input (auto-detected):
   Existing case          repro_xxxxxxxx  or  https://aibadgr.com/repro/repro_xxxxxxxx
 
 Flags:
-  --smoke                Free. Runs real, cheap mechanical validation of the
-                          produced command on top of the normal diagnosis --
-                          command syntax, CLI-entrypoint corroboration,
-                          referenced-file presence, Docker ENTRYPOINT/CMD
-                          consistency, required env vars -- plus a client-side
-                          check of any local file path you pasted (e.g. a
-                          .gguf path), which only this machine can see. Never
-                          starts a GPU, never requires login, never prints
-                          "Verified" -- only "Smoke Checked" (AGENTS.md proof
-                          levels). Can be combined with --approve: the smoke
-                          checks print first, then the normal approve flow
-                          runs (they are independent, non-blocking steps).
-                          Unrelated to "badgr run --smoke", which launches a
-                          real, billable cheapest-GPU job.
-  --approve              Approve the capped smoke test after diagnosis (opens
+  --approve              Launch a real Badgr Run after diagnosis (opens
                           browser sign-in automatically if not logged in).
-                          This is a real, billable GPU-provisioned run --
-                          distinct from the free --smoke flag above.
+                          This is a real, billable GPU-provisioned execution
+                          -- distinct from the free diagnosis above.
+  --smoke                Deprecated, no-op. The free mechanical checks this
+                          used to gate are now always run automatically as
+                          part of plain "badgr diagnose" -- kept only so
+                          existing scripts that pass it don't break.
   --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)
@@ -54,11 +45,18 @@ Flags:
   --help, -h             Show this help
 
 Status: every run prints one of NEEDS INFO / READY / SMOKE CHECKED / INVALID / VERIFIED.
-        NEEDS INFO   -- cannot yet produce a complete command
-        READY        -- complete evidence-backed command, no smoke run
-        SMOKE CHECKED -- --smoke ran; all applicable checks PASS or SKIPPED
-        INVALID      -- --smoke ran and an applicable check actually FAILED
-        VERIFIED     -- only after a real successful run (never from --smoke)
+        NEEDS INFO    -- cannot yet produce a complete command
+        READY         -- complete evidence-backed command, no applicable checks to run
+        SMOKE CHECKED -- applicable checks ran; all PASS or SKIPPED
+        INVALID       -- an applicable check actually FAILED
+        VERIFIED      -- only after a real Badgr Run succeeds (never from diagnosis alone)
+
+Checks run automatically whenever applicable: command syntax,
+CLI-entrypoint corroboration, referenced-file presence, Docker
+ENTRYPOINT/CMD consistency, required env vars -- plus a client-side check
+of any local file path you pasted (e.g. a .gguf path), which only this
+machine can see. Never starts a GPU, never requires login, never prints
+"Verified" -- only "Smoke Checked" (AGENTS.md proof levels).
 
 Run page: READY and SMOKE CHECKED results also create a free, anonymous
           "Run" link (the same prepared case /run-issue's own confirm form
@@ -73,10 +71,36 @@ Run page: READY and SMOKE CHECKED results also create a free, anonymous
 
 Safety: nothing runs from AI-extracted data without --approve.
         No GPU launches without explicit approval and a credit check.
-        --smoke never provisions a GPU and never requires login.
+        Diagnosis (with or without its automatic checks) never provisions
+        a GPU and never requires login.
 
 Full interactive flow: https://aibadgr.com/run-issue`;
 
+// Best-effort, purely local (no network, no AI) runtime/model preview for
+// an already-classified "command" input -- shown immediately, before the
+// `/run-issue/extract` request (which still runs unchanged right after, so
+// the full server-side checks -- static incompatibility, missing info,
+// etc. -- are untouched). An obvious `vllm serve facebook/opt-125m` used to
+// sit behind "Analysing... Xs" with zero feedback about what Badgr even
+// detected until the AI-backed extract call finished; the deterministic
+// parser already knows the runtime and model instantly, so there's no
+// reason to make the user wait through that just to see it. Returns null
+// (nothing printed) for any command shape this doesn't recognize --
+// never a guess, and never a substitute for the real extract result below.
+const _PREVIEW_PATTERNS = [
+  { runtime: 'vLLM', re: /\bvllm\s+serve\s+(\S+)/i },
+  { runtime: 'Ollama', re: /\bollama\s+run\s+(\S+)/i },
+];
+
+function _previewLaunchCommand(raw) {
+  if (!raw || raw.includes('\n')) return null;
+  for (const { runtime, re } of _PREVIEW_PATTERNS) {
+    const m = re.exec(raw);
+    if (m) return { runtime, model: m[1] };
+  }
+  return null;
+}
+
 function detectInput(raw, flags) {
   if (flags.docker) {
     return {
@@ -148,11 +172,30 @@ function detectInput(raw, flags) {
     return { kind: 'docker_image', label: `Docker image: ${raw}`, body: classified.body };
   }
 
+  if (classified.kind === 'command') {
+    return { kind: 'command', label: 'Explicit command', body: classified.body };
+  }
+
   return { kind: 'text', label: 'Text / conversation', body: classified.body };
 }
 
+// backend/run_issue_routes.py's /extract now returns the canonical
+// "service" (persistent, badgr serve) vs "finite_job" (bounded, badgr
+// run/train/comfyui) classification directly on the extraction as
+// `workload_shape` (_workload_shape, the same predicate
+// _canonical_badgr_command itself uses to pick a subcommand) -- read that
+// instead of re-deriving an approximation here, so the CLI's wording can
+// never drift from what the backend actually decided. The local fallback
+// only matters for a response predating this field (e.g. a cached fixture).
+function _isServiceShape(e) {
+  if (e.workload_shape) return e.workload_shape === 'service';
+  const wt = e.workload_type;
+  return Boolean(e.models?.length) && wt !== 'training' && wt !== 'comfyui';
+}
+
 function _printResult(result, chalk) {
   const { extraction: e, static_incompatibilities, multi_gpu_detected, large_download, github_issue, detected_github_url } = result;
+  const isService = _isServiceShape(e);
 
   if (github_issue) {
     console.log(`  ${chalk.bold('Issue:')}   ${github_issue.title}  ${chalk.dim(`[${github_issue.state}]`)}`);
@@ -196,12 +239,19 @@ function _printResult(result, chalk) {
     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`);
+    console.log(`  ${chalk.bold('Diagnosis:')} ${isService
+      ? 'Persistent service detected — ready to serve'
+      : '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.')}`);
+    console.log(`  ${chalk.yellow('!')} Multi-GPU requested: ${multi_gpu_detected.gpu_count} GPUs ${chalk.dim(`(${multi_gpu_detected.evidence})`)}`);
+    // Never claim an automatic single-GPU downgrade here -- this topology
+    // is preserved if Badgr's runner supports it, or the paid CTA is
+    // blocked with an explicit unsupported-topology message once a plan
+    // exists (see /confirm's requires_reduced_test); a reduced test is
+    // only ever a distinct, explicit secondary choice, never silent.
+    console.log(`    ${chalk.dim('Badgr will preserve this topology if supported, or report it as unsupported before any GPU runs.')}`);
   }
   if (large_download) {
     console.log(`  ${chalk.yellow('!')} Large model download: ~${large_download.estimated_gb} GB`);
@@ -219,8 +269,23 @@ function _printResult(result, chalk) {
     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 if (isService) {
+    // A persistent service has no lifetime cost cap by default -- the free
+    // verification step below is still capped (it's just a readiness
+    // check), but the resulting `badgr serve` endpoint keeps running and
+    // billing until stopped, or an explicit --max-cost/--max-runtime is
+    // supplied. See backend/run_issue_routes.py's _canonical_badgr_command.
+    console.log(`  ${chalk.bold('Recommended action:')} Open the Run link below to verify readiness and start the service`);
+    console.log(`    ${chalk.dim('The service keeps running after verification -- stop it with `badgr down`, or launch it with --max-cost/--persistent.')}`);
   } else {
-    console.log(`  ${chalk.bold('Recommended action:')} Run ${chalk.cyan('badgr diagnose "<input>" --approve')} to launch a capped test`);
+    // The prepared case URL (printed below by _printCopySummary as "Run:")
+    // is the primary handoff -- it's the same Page 2 the web flow uses, with
+    // the real free-check evidence, the dynamic recommended cap, and login/
+    // approval built in. `--approve` remains available for backward
+    // compatibility (a same-terminal, no-browser capped test) but is no
+    // longer the recommended path.
+    console.log(`  ${chalk.bold('Recommended action:')} Open the Run link below to review and approve a capped test`);
+    console.log(`    ${chalk.dim(`(or run ${chalk.cyan('badgr diagnose "<input>" --approve')} to launch one directly from this terminal)`)}`);
   }
 }
 
@@ -265,8 +330,11 @@ function _localPathCandidates(e) {
 // Locked status ladder (product-level labels, not the backend's internal
 // proof_level enum): NEEDS INFO / READY / SMOKE CHECKED / INVALID / VERIFIED.
 // Pure presentation over data /run-issue/extract already returns -- no new
-// endpoint, no new GPU behaviour. --smoke can reach SMOKE CHECKED or INVALID
-// (never VERIFIED, see AGENTS.md §12 and _printCopySummary below).
+// endpoint, no new GPU behaviour. Diagnosis alone can reach SMOKE CHECKED
+// or INVALID (never VERIFIED, see AGENTS.md §12 and _printCopySummary
+// below) -- `badgr diagnose` IS the Badgr Smoke Test, so applicable free
+// checks always run and always count toward the printed status; there is
+// no separate opt-in step for them.
 //
 // The evidence-only judgment (needs_info/invalid/smoke_checked) is computed
 // once, server-side, in `_compute_smoke_status` (backend/run_issue_routes.py)
@@ -277,39 +345,50 @@ function _localPathCandidates(e) {
 // A `smoke_status` fallback derivation is kept only for a backend response
 // that predates this field (defensive, not the normal path).
 //
-// READY means "no smoke run" -- a command that's merely complete is never
-// itself proof of validity, so mechanical/local-file results only ever
-// change the printed word when --smoke actually ran them (locked spec
-// problem #6: a real FAIL must demote SMOKE CHECKED to INVALID; SKIPPED
-// checks never do). This part stays CLI-side: it depends on the --smoke
-// flag and this machine's own filesystem, neither of which the backend can
-// see.
-function _statusWord(result, smokeRequested) {
+// READY means "no applicable checks to run" -- a command that's merely
+// complete is never itself proof of validity, so mechanical/local-file
+// results only ever change the printed word when a check actually ran
+// (locked spec problem #6: a real FAIL must demote SMOKE CHECKED to
+// INVALID; SKIPPED checks never do). The local-file half of this stays
+// CLI-side since it depends on this machine's own filesystem, which the
+// backend can never see.
+function _statusWord(result) {
   const e = result.extraction || {};
   if (result.static_incompatibilities?.length || e.missing_information?.length) return 'NEEDS INFO';
-  if (!smokeRequested) return 'READY';
-  const backendStatus = e.smoke_status
-    || ((e.mechanical_checks || []).some((check) => check.status === 'fail') ? 'invalid' : 'smoke_checked');
+  // Mirrors backend/run_issue_routes.py's _compute_smoke_status exactly: a
+  // mechanical FAIL is invalid; otherwise only real command-scope evidence
+  // (smoke_check.proof_level === "smoke_checked" -- the repository/image/
+  // service's own documented default, not just a syntax-only pass) earns
+  // SMOKE CHECKED. Everything else is READY, even if mechanical checks ran
+  // and all passed -- a syntax-only pass proves the command is well formed,
+  // not that its runtime is available.
+  const backendStatus = e.smoke_status || (
+    (e.mechanical_checks || []).some((check) => check.status === 'fail')
+      ? 'invalid'
+      : (e.smoke_check || {}).proof_level === 'smoke_checked' ? 'smoke_checked' : 'ready'
+  );
   const localFail = _localPathCandidates(e).some((p) => !fs.existsSync(p));
   if (backendStatus === 'invalid' || localFail) return 'INVALID';
   return backendStatus === 'ready' ? 'READY' : 'SMOKE CHECKED';
 }
 
 const _CHECK_LABELS = {
-  command_syntax:    'command syntax',
-  cli_entrypoint:    'CLI entrypoint',
-  referenced_files:  'referenced repo files',
-  docker_entrypoint: 'Docker metadata',
-  required_env_vars: 'required env vars',
+  command_syntax:     'command syntax',
+  supported_flags:    'known CLI flags',
+  cli_entrypoint:     'CLI entrypoint',
+  referenced_files:   'referenced repo files',
+  image_availability: 'image exists / accessible',
+  docker_entrypoint:  'Docker metadata',
+  required_env_vars:  'required env vars',
 };
 
 // Compact, copy-pasteable result -- the literal STATUS word plus just enough
 // to forward to someone else. Additive to the detailed report above it;
 // does not replace it. Never prints "Verified" -- SMOKE CHECKED is the
 // ceiling for this free path.
-function _printCopySummary(result, flags, chalk, caseData) {
+function _printCopySummary(result, chalk, caseData, config) {
   const e = result.extraction || {};
-  const status = _statusWord(result, flags.smoke);
+  const status = _statusWord(result);
 
   console.log(`  ${chalk.bold(`STATUS: ${status}`)}`);
   console.log();
@@ -341,7 +420,7 @@ function _printCopySummary(result, flags, chalk, caseData) {
 
   if (caseData?.case_id) {
     console.log(`  ${chalk.bold('Run:')}`);
-    console.log(`  ${chalk.cyan(_runPageUrl(caseData.case_id))}`);
+    console.log(`  ${chalk.cyan(_runPageUrl(caseData.case_id, config))}`);
     console.log();
   }
 
@@ -380,7 +459,13 @@ function _printSmokeChecks(result, chalk) {
   const localPaths = _localPathCandidates(e);
 
   console.log();
-  console.log(`  ${chalk.bold('Smoke Checked (free, no GPU, no login):')}`);
+  // Neutral header -- this section always runs and prints regardless of the
+  // final verdict (_statusWord can land on READY, NEEDS INFO, or INVALID
+  // just as easily as SMOKE CHECKED; see its own comment for why a
+  // syntax-only pass isn't proof of scope). A fixed "Smoke Checked" header
+  // here previously disagreed with a `STATUS: READY` line printed right
+  // after it -- this section is the free checks themselves, not the verdict.
+  console.log(`  ${chalk.bold('Free checks (no GPU, no login):')}`);
 
   const icon = (status) => (
     status === 'pass' ? chalk.green('✓') : status === 'fail' ? chalk.red('✗') : chalk.dim('-')
@@ -416,11 +501,46 @@ function _confirmBodyFromExtraction(e) {
                                   ? e.gpu_requirements.join(', ')
                                   : e.gpu_requirements || null,
     source_summary:             e.summary || null,
+    // Same free-check evidence /extract already computed for this session --
+    // /confirm only persists it (see ConfirmBody's docstring), it never
+    // re-derives it. Without these, a case created via `badgr diagnose`
+    // (as opposed to the web page's own /confirm call, which already sends
+    // them) persisted no evidence at all, so its Run Link's Page 2 showed
+    // no "Free Smoke Test" section on a cold load -- not because the
+    // section is missing, but because there was nothing in it to render.
+    mechanical_checks:           e.mechanical_checks || null,
+    smoke_check:                 e.smoke_check || null,
+    resolution_evidence:         e.resolved_workload || null,
   };
 }
 
-function _runPageUrl(caseId) {
-  return `https://aibadgr.com/run-issue?case_id=${caseId}`;
+function _runPageUrl(caseId, config) {
+  return `${webBaseUrl(config)}/run-issue?case_id=${caseId}`;
+}
+
+// /run-issue/extract can legitimately take up to 120s (AI extraction) and
+// /run-issue/confirm up to 20s -- both used to print one static line
+// ("Analysing..." / nothing at all) and then go silent until the request
+// resolved, which is indistinguishable from a hung terminal on a slow
+// backend. This redraws a single in-place elapsed-time line every second
+// so a slow response still reads as "working", not "stuck". Only runs when
+// stdout is a TTY -- a piped/non-interactive run (e.g. --json in a script)
+// must not get raw carriage-return control codes mixed into its output.
+async function _withElapsed(chalk, label, promise) {
+  if (!process.stdout.isTTY) return promise;
+  const startMs = Date.now();
+  const tick = () => {
+    const elapsedSec = Math.floor((Date.now() - startMs) / 1000);
+    process.stdout.write(`\r\x1b[2K${chalk.dim(`  ${label} ${elapsedSec}s`)}`);
+  };
+  tick();
+  const timer = setInterval(tick, 1000);
+  try {
+    return await promise;
+  } finally {
+    clearInterval(timer);
+    process.stdout.write('\r\x1b[2K');
+  }
 }
 
 // Creates the free, anonymous "prepared run" case that backs a shareable
@@ -450,7 +570,7 @@ async function _createRunPage(config, e, chalk) {
 }
 
 async function _doApprove(config, caseData, chalk) {
-  const { case_id: caseId, status, test_plan: plan, missing_information: missing } = caseData;
+  const { case_id: caseId, status, test_plan: plan, workload_plan: workloadPlan, missing_information: missing } = caseData;
 
   if (status === 'incompatible') {
     console.log(chalk.yellow('\n  Static incompatibility — no GPU test needed.'));
@@ -474,13 +594,19 @@ async function _doApprove(config, caseData, chalk) {
     return;
   }
 
-  if (plan) {
+  // Display the canonical WorkloadPlan (backend/reliability_engine.py) --
+  // the same object creation -> routing -> Jobs -> watchdog all consume --
+  // rather than a second, independently-derived estimate. Falls back to the
+  // raw test_plan only for fields the canonical plan doesn't carry
+  // (requires_reduced_test / requires_funding_approval are smoke-check-only
+  // concerns, never part of WorkloadPlan).
+  if (workloadPlan || 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`);
+    if (workloadPlan?.gpu_type)            console.log(`  ${chalk.bold('GPU:')}          ${workloadPlan.gpu_type}`);
+    if (workloadPlan?.estimated_cost_usd != null) console.log(`  ${chalk.bold('Maximum cost:')} $${Number(workloadPlan.estimated_cost_usd).toFixed(2)}`);
+    if (workloadPlan?.deadline_secs)       console.log(`  ${chalk.bold('Max runtime:')}  ${Math.round(workloadPlan.deadline_secs / 60)} min`);
+    if (plan?.requires_reduced_test)       console.log(`  ${chalk.red('!')} Requested topology not supported -- run blocked, see below`);
+    if (plan?.requires_funding_approval)   console.log(`  ${chalk.yellow('!')} Large download — funding required`);
   }
 
   await _approveAndRun(config, caseId, plan, chalk);
@@ -494,8 +620,33 @@ async function _doApprove(config, caseData, chalk) {
 // 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`));
+    console.error(chalk.dim(`  Resume this case: ${webBaseUrl(config)}/run-issue?case_id=${caseId}\n`));
+
+  // A requested topology Badgr's current runner can't satisfy (e.g.
+  // --tensor-parallel-size 2 on a single-GPU-only runner) must never be
+  // silently downgraded to a reduced single-GPU test -- that used to
+  // happen here automatically (reduced_test_confirmed defaulted to
+  // Boolean(plan.requires_reduced_test), so plain --approve auto-consented
+  // on the caller's behalf). A reduced test is only ever a distinct,
+  // explicit secondary choice -- the web /run-issue page already offers
+  // that as its own "Run reduced 1-GPU acceptance test instead" action;
+  // the CLI has no equivalent explicit opt-in yet, so it blocks here
+  // rather than inventing implicit consent.
+  if (plan?.requires_reduced_test) {
+    const detected = plan.multi_gpu_detected;
+    console.error(chalk.red('\n  ✗ Cannot run this workload as requested\n'));
+    if (detected?.gpu_count) {
+      console.error(`  This command requires ${detected.gpu_count} GPUs. Badgr's current verification runner supports only 1 GPU.\n`);
+    }
+    console.error(chalk.dim(`  A reduced 1-GPU test is available as an explicit separate choice on the case page, not via --approve:`));
+    console.error(chalk.dim(`  ${webBaseUrl(config)}/run-issue?case_id=${caseId}\n`));
+    process.exitCode = 1;
+    return;
+  }
 
+  // Same just-in-time login flow badgr run/serve/comfyui/job trigger — no
+  // separate `badgr login` step, and once the browser login completes this
+  // function keeps running right here with the now-populated config.
   let authConfig = config;
   if (!authConfig.apiKey) {
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
@@ -530,13 +681,20 @@ async function _approveAndRun(config, caseId, plan, chalk) {
       body: {
         confirmed:               true,
         funding_approved:        Boolean(plan?.requires_funding_approval),
-        reduced_test_confirmed:  Boolean(plan?.requires_reduced_test),
+        // Always false: the guard above already returned before this point
+        // for any plan with requires_reduced_test set -- never re-derive
+        // implicit consent from the plan here.
+        reduced_test_confirmed:  false,
       },
       timeoutMs: 15_000,
     });
   } catch (err) {
-    if (err.httpStatus === 402 || err.message?.includes('402')) {
-      console.error(chalk.yellow('\n  ✗ Insufficient credits. Run: badgr billing\n'));
+    // Same isPaymentRequired convention every other paid command follows
+    // (run.js, serve.js, train.js, ...) -- api.js already builds the full
+    // balance/required/top-up message onto err.message for a 402.
+    if (err.isPaymentRequired) {
+      console.error(chalk.yellow(err.message));
+      printResumeHint();
     } else {
       console.error(chalk.red(`\n  ✗ Approve failed: ${err.message}\n`));
     }
@@ -544,24 +702,29 @@ async function _approveAndRun(config, caseId, plan, chalk) {
     return;
   }
 
-  console.log(chalk.dim('\n  Launching capped smoke test...'));
+  console.log(chalk.dim('\n  Launching Badgr Run...'));
   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`));
+    if (err.isPaymentRequired) {
+      console.error(chalk.yellow(err.message));
+      printResumeHint();
+    } else {
+      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.green('  Run started.'));
   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(`  ${chalk.bold('Evidence:')} ${webBaseUrl(config)}/repro/${caseId}`);
   console.log();
 }
 
@@ -618,8 +781,8 @@ async function _diagnoseExistingCase(config, caseId, flags, chalk) {
       ? caseData.lead_summary.test_checklist
       : ['Verified'];
     for (const line of resultLines) console.log(`  - ${line}`);
-    if (caseData.actual_cost_aud != null) {
-      console.log(`  Verified on Badgr for AUD $${Number(caseData.actual_cost_aud).toFixed(2)}. GPU torn down after the test.`);
+    if (caseData.actual_cost_usd != null) {
+      console.log(`  Verified on Badgr for $${Number(caseData.actual_cost_usd).toFixed(2)} USD. GPU torn down after the test.`);
     }
   }
 
@@ -628,8 +791,9 @@ async function _diagnoseExistingCase(config, caseId, flags, chalk) {
     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)}`)}`);
+  } else if (caseData.workload_plan || caseData.test_plan) {
+    const capUsd = caseData.workload_plan?.recommended_cap_usd ?? caseData.test_plan?.max_cost_usd ?? 0;
+    console.log(`  ${chalk.dim(`Verification available — max $${Number(capUsd).toFixed(2)}`)}`);
   }
   console.log();
 
@@ -648,7 +812,15 @@ export async function diagnoseCommand(config, args, chalk) {
   }
 
   const flags = {};
-  let positional = null;
+  // Every non-flag token is joined into one input string, not just the
+  // first -- `badgr diagnose vllm serve facebook/opt-125m` (unquoted) must
+  // diagnose the same thing as `badgr diagnose "vllm serve
+  // facebook/opt-125m"` (quoted). Previously only args[0] after flags
+  // ("vllm") became `positional` and every token after it was silently
+  // dropped, so an unquoted multi-word command was diagnosed as if the
+  // user had only pasted its first word -- bizarrely resolving to a
+  // Docker-image lookup for an image literally named "vllm".
+  const positionalParts = [];
   let i = 0;
   while (i < args.length) {
     const a = args[i];
@@ -659,9 +831,10 @@ export async function diagnoseCommand(config, args, chalk) {
     if (a === '--approve')  { flags.approve = true;  i++; continue; }
     if (a === '--smoke')    { flags.smoke   = true;  i++; continue; }
     if (a === '--json')     { flags.json    = true;  i++; continue; }
-    if (!a.startsWith('-') && positional === null) positional = a;
+    if (!a.startsWith('-')) positionalParts.push(a);
     i++;
   }
+  const positional = positionalParts.length ? positionalParts.join(' ') : null;
 
   if (!positional && !flags.docker && !flags.repo && !flags.comfyui) {
     console.log(DIAGNOSE_HELP);
@@ -694,25 +867,34 @@ export async function diagnoseCommand(config, args, chalk) {
   if (!flags.json) {
     console.log();
     console.log(`  ${chalk.bold('Detected:')} ${detected.label}`);
-    console.log(chalk.dim('  Analysing...'));
+    if (detected.kind === 'command') {
+      const preview = _previewLaunchCommand(positional);
+      if (preview) {
+        console.log(`  ${chalk.bold('Runtime:')} ${preview.runtime}`);
+        console.log(`  ${chalk.bold('Model:')}   ${preview.model}`);
+      }
+    }
   }
 
   let result;
   try {
-    result = await callApi('/run-issue/extract', {
+    const extractPromise = callApi('/run-issue/extract', {
       method:    'POST',
       apiKey:    config.apiKey || '',
       baseUrl:   config.baseUrl,
       body:      detected.body,
       timeoutMs: 120_000,
     });
+    result = flags.json
+      ? await extractPromise
+      : await _withElapsed(chalk, 'Running free checks...', extractPromise);
   } catch (err) {
     console.error(chalk.red(`\n  ✗ ${err.message}\n`));
     process.exitCode = 1;
     return;
   }
 
-  const status = _statusWord(result, flags.smoke);
+  const status = _statusWord(result);
 
   // A command that's actually runnable also gets a free prepared Run
   // page -- the same case /run-issue's own confirm step would create --
@@ -725,14 +907,20 @@ export async function diagnoseCommand(config, args, chalk) {
   let caseData = null;
   let caseError = null;
   if (status === 'READY' || status === 'SMOKE CHECKED') {
-    const created = await _createRunPage(config, result.extraction || {}, chalk);
+    const createPromise = _createRunPage(config, result.extraction || {}, chalk);
+    const created = flags.json
+      ? await createPromise
+      : await _withElapsed(chalk, 'Preparing Run link...', createPromise);
     if (created.error) caseError = created.error;
     else caseData = created.caseData;
   }
 
   if (flags.json) {
     const output = { detected: detected.kind, ...result, status };
-    if (flags.smoke) {
+    // Applicable free checks always run as part of plain diagnosis now
+    // (see _statusWord's comment) -- always included here too, not gated
+    // behind the deprecated --smoke flag.
+    {
       const e = result.extraction || {};
       output.smoke = {
         mechanical_checks: e.mechanical_checks || [],
@@ -742,7 +930,7 @@ export async function diagnoseCommand(config, args, chalk) {
     if (caseData?.case_id) {
       output.run = {
         case_id: caseData.case_id,
-        url: _runPageUrl(caseData.case_id),
+        url: _runPageUrl(caseData.case_id, config),
         canonical_command: caseData.findings?.canonical_command || null,
       };
     }
@@ -772,15 +960,16 @@ export async function diagnoseCommand(config, args, chalk) {
   console.log();
   _printResult(result, chalk);
 
-  if (flags.smoke) {
-    _printSmokeChecks(result, chalk);
-  }
+  // Applicable free checks always run as part of plain diagnosis now
+  // (see _statusWord's comment) -- always printed, not gated behind the
+  // deprecated --smoke flag.
+  _printSmokeChecks(result, chalk);
 
   console.log();
-  _printCopySummary(result, flags, chalk, caseData);
+  _printCopySummary(result, chalk, caseData, config);
 
   console.log(chalk.dim('  Free diagnosis. No GPU was provisioned.'));
-  console.log(chalk.dim('  Full interactive flow: https://aibadgr.com/run-issue'));
+  console.log(chalk.dim(`  Full interactive flow: ${webBaseUrl(config)}/run-issue`));
   console.log();
 
   if (flags.approve) {