badgr-cli 1.1.3 → 1.1.5

package/src/commands/diagnose.js

@@ -1,11 +1,14 @@
 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>"
@@ -24,8 +27,14 @@ Input (auto-detected):
   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)
+  --approve              Launch a real Badgr Run after diagnosis (opens
+                          browser sign-in automatically if not logged in).
+                          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)
@@ -35,11 +44,63 @@ Flags:
   --json                 Machine-readable JSON output
   --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 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
+          creates) -- a saved, runnable configuration you or anyone with the
+          link can open and click Run on. NEEDS INFO and INVALID never get
+          one (nothing runnable to save, or a check just proved it broken)
+          -- both print the correction instead. The page shows the exact
+          canonical "badgr ..." command --approve would run, not merely the
+          source command extraction found. Still no GPU starts until that
+          click. --approve reuses this same case rather than creating a
+          second one.
+
 Safety: nothing runs from AI-extracted data without --approve.
         No GPU launches without explicit approval and a credit check.
+        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 {
@@ -66,32 +127,27 @@ function detectInput(raw, flags) {
 
   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 };
+  // Case-id / GitHub-URL-shape classification is shared with the web page
+  // (`classifyPastedInput`, packages/shared/src/index.ts) so the CLI and
+  // /run-issue never disagree about what a given paste is. 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 classified = classifyPastedInput(raw);
+  if (classified.kind === 'existing_case') {
+    return { kind: 'existing_case', label: `Existing case: ${classified.body.case_id}`, caseId: classified.body.case_id };
   }
-
-  if (/^https?:\/\/(www\.)?github\.com\/[^/]+\/[^/]+\/issues\/\d/.test(raw)) {
-    return {
-      kind:  'github_issue',
-      label: `GitHub issue: ${raw}`,
-      body:  { github_url: raw },
-    };
+  if (classified.kind === 'github_issue') {
+    return { kind: 'github_issue', label: `GitHub issue: ${raw}`, body: classified.body };
   }
-
-  if (/^https?:\/\/(www\.)?github\.com\//.test(raw)) {
-    return {
-      kind:  'repo_url',
-      label: `GitHub repository: ${raw}`,
-      body:  { repo_url: raw },
-    };
+  if (classified.kind === 'repo_url') {
+    return { kind: 'repo_url', label: `GitHub repository: ${raw}`, body: classified.body };
   }
 
+  // Local filesystem paths -- only the CLI has a filesystem to check
+  // against, so this stays CLI-only, sitting between the shared URL checks
+  // above and the shared Docker-image/text fallback below (matches
+  // classifyPastedInput's own precedence for everything except this).
   if (fs.existsSync(raw)) {
     const content = fs.readFileSync(raw, 'utf8');
     if (raw.endsWith('.json') || raw.endsWith('.JSON')) {
@@ -112,27 +168,34 @@ function detectInput(raw, flags) {
     };
   }
 
-  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 },
-    };
+  if (classified.kind === 'docker_image') {
+    return { kind: 'docker_image', label: `Docker image: ${raw}`, body: classified.body };
   }
 
-  return {
-    kind:  'text',
-    label: 'Text / conversation',
-    body:  { text: raw.slice(0, 50_000) },
-  };
+  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}]`)}`);
@@ -176,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`);
@@ -199,16 +269,227 @@ 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)`)}`);
+  }
+}
+
+// Local-machine file paths (e.g. a pasted .gguf path) can only be checked
+// client-side -- the backend never sees this machine's filesystem, so it
+// must not (and does not) claim to validate them. Only paths that look like
+// a real filesystem reference (absolute, `./`, `../`, or `~/`) are checked;
+// bare words, URLs, and Docker image references are left alone.
+//
+// Path checks must respect context (locked Free Command Check spec, problem
+// #3): a repo path is checked against the repo tree, a container path
+// against Dockerfile/image evidence -- both server-side, inside
+// `mechanical_checks` -- and only a genuinely local path belongs to this
+// machine. Once a repository or Docker image is in evidence for this
+// workload, an absolute path *inside the resolved command* (e.g. "python3
+// /src/main.py") is a repo/container path, not a claim about this laptop,
+// so it must never be re-checked against the local filesystem here -- doing
+// so is exactly the "/src/main.py NOT FOUND on this machine" false failure
+// the spec calls out. `model_artifact` is different: it is always this
+// machine's own claim about a locally-downloaded checkpoint, never repo or
+// container evidence, so it stays checked regardless.
+function _localPathCandidates(e) {
+  const candidates = new Set();
+  const hasRepoOrContainerContext = Boolean(
+    e.repositories?.length || e.docker_images?.length || e.dockerfile
+  );
+  const maybeAdd = (value) => {
+    if (typeof value !== 'string') return;
+    const s = value.trim().replace(/^['"]|['"]$/g, '');
+    if (!s || /^https?:\/\//i.test(s)) return;
+    if (s.startsWith('/') || s.startsWith('./') || s.startsWith('../') || s.startsWith('~/')) {
+      candidates.add(s);
+    }
+  };
+  maybeAdd(e.model_artifact);
+  if (!hasRepoOrContainerContext) {
+    for (const tok of (e.commands?.[0] || '').split(/\s+/)) maybeAdd(tok);
+  }
+  return [...candidates];
+}
+
+// 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. 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)
+// and read here via `e.smoke_status` -- this and /run-issue's `smokeStatus()`
+// (frontend/app/run-issue/page.tsx) both just render that one backend
+// verdict rather than each re-deriving pass/fail from mechanical_checks, so
+// the CLI and the web page can never disagree on what a given result means.
+// A `smoke_status` fallback derivation is kept only for a backend response
+// that predates this field (defensive, not the normal path).
+//
+// 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';
+  // 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',
+  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, chalk, caseData, config) {
+  const e = result.extraction || {};
+  const status = _statusWord(result);
+
+  console.log(`  ${chalk.bold(`STATUS: ${status}`)}`);
+  console.log();
+
+  if (status === 'NEEDS INFO') {
+    // Static incompatibilities and missing-information both mean "no
+    // command yet" -- whichever fired is the reason to surface here.
+    const reasons = result.static_incompatibilities?.length
+      ? result.static_incompatibilities
+      : (e.missing_information || []);
+    console.log(`  ${chalk.bold('Missing:')}`);
+    for (const r of reasons) console.log(`  - ${r}`);
+    console.log();
+    return;
+  }
+
+  // The prepared case's canonical `badgr ...` command (the exact line
+  // --approve would run) is preferred over the raw source command --
+  // /confirm can only compute it once a case exists (READY/SMOKE CHECKED),
+  // and only when there's enough evidence to convert (see
+  // _canonical_badgr_command's docstring, backend/run_issue_routes.py, for
+  // what it can't yet convert, e.g. training/ComfyUI). Falls back to the
+  // raw extracted command otherwise -- still true and still runnable input,
+  // just not guaranteed to already be `badgr`-shaped.
+  const badgrJob = caseData?.findings?.canonical_command || e.commands?.[0] || '(no command produced)';
+  console.log(`  ${chalk.bold('Badgr job:')}`);
+  console.log(`  ${badgrJob}`);
+  console.log();
+
+  if (caseData?.case_id) {
+    console.log(`  ${chalk.bold('Run:')}`);
+    console.log(`  ${chalk.cyan(_runPageUrl(caseData.case_id, config))}`);
+    console.log();
+  }
+
+  if (status === 'SMOKE CHECKED' || status === 'INVALID') {
+    console.log(`  ${chalk.bold('Checks:')}`);
+    const iconFor = (s) => (s === 'pass' ? '✓' : s === 'fail' ? '✗' : '-');
+    for (const check of (e.mechanical_checks || [])) {
+      console.log(`  ${iconFor(check.status)} ${_CHECK_LABELS[check.name] || check.name}`);
+    }
+    const localPaths = _localPathCandidates(e);
+    if (!localPaths.length) {
+      console.log('  - local file check skipped');
+    } else {
+      const allExist = localPaths.every((p) => fs.existsSync(p));
+      console.log(`  ${allExist ? '✓' : '✗'} local file check${allExist ? '' : ' (not found)'}`);
+    }
+    console.log();
+    if (status === 'INVALID') {
+      console.log('  A check above actually failed -- this command is not runnable as-is.');
+    } else {
+      console.log('  Not GPU-verified.');
+    }
+    console.log();
+  }
+}
+
+// --smoke's mechanical checks: prints the backend's evidence-backed
+// pass/fail/skip results (`extraction.mechanical_checks`, computed for
+// free from data already gathered by /run-issue/extract -- no extra
+// network call), plus this machine's own local-file existence check.
+// Deliberately never prints "Verified" -- see AGENTS.md §12; a genuinely
+// passing smoke check still only earns "Smoke Checked".
+function _printSmokeChecks(result, chalk) {
+  const e = result.extraction || {};
+  const mech = e.mechanical_checks || [];
+  const localPaths = _localPathCandidates(e);
+
+  console.log();
+  // 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('-')
+  );
+  for (const check of mech) {
+    console.log(`    ${icon(check.status)} ${chalk.dim(`[${check.name}]`)} ${check.detail}`);
+  }
+  for (const p of localPaths) {
+    const exists = fs.existsSync(p);
+    console.log(`    ${exists ? chalk.green('✓') : chalk.red('✗')} ${chalk.dim('[local_file]')} ${p} ${exists ? 'exists on this machine' : 'NOT FOUND on this machine'}`);
+  }
+  if (!mech.length && !localPaths.length) {
+    console.log(`    ${chalk.dim('No mechanical checks applicable to this input.')}`);
   }
+
+  const proofLevel = e.smoke_check?.proof_level;
+  if (proofLevel === 'smoke_checked') {
+    console.log(`    ${chalk.green('✓')} ${chalk.dim('[command_scope]')} Command is the repository/image/service's own documented default.`);
+  }
+  console.log();
 }
 
-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 = {
+function _confirmBodyFromExtraction(e) {
+  return {
     workload_type:              e.workload_type || 'generic',
     docker_image:               e.docker_images?.[0] || null,
     model_id:                   e.models?.[0] || null,
@@ -220,25 +501,76 @@ async function _doApprove(config, result, chalk) {
                                   ? 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,
   };
+}
 
-  let caseData;
+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 {
-    console.log(chalk.dim('  Creating case...'));
-    caseData = await callApi('/run-issue/confirm', {
+    return await promise;
+  } finally {
+    clearInterval(timer);
+    process.stdout.write('\r\x1b[2K');
+  }
+}
+
+// Creates the free, anonymous "prepared run" case that backs a shareable
+// Run Link -- the exact same /run-issue/confirm call and case object
+// /run-issue's own confirm step creates, so the CLI and the web page never
+// diverge on what a given diagnosis resolves to. No GPU, no login, no
+// payment -- confirm only ever inspects and plans (see its own docstring).
+// Called once per diagnosis (main flow), then reused by --approve below
+// instead of confirming a second time.
+//
+// Returns `{ caseData }` on success, `{ error }` on a network/API failure --
+// never throws, since a plain diagnosis must still succeed even if the
+// free run-page creation itself fails.
+async function _createRunPage(config, e, chalk) {
+  try {
+    const caseData = await callApi('/run-issue/confirm', {
       method:    'POST',
       apiKey:    config.apiKey || '',
       baseUrl:   config.baseUrl,
-      body:      confirmBody,
+      body:      _confirmBodyFromExtraction(e),
       timeoutMs: 20_000,
     });
+    return caseData?.case_id ? { caseData } : { caseData: null };
   } catch (err) {
-    console.error(chalk.red(`\n  ✗ Could not create case: ${err.message}\n`));
-    process.exitCode = 1;
-    return;
+    return { error: err };
   }
+}
 
-  const { case_id: caseId, status, test_plan: plan, missing_information: missing } = caseData;
+async function _doApprove(config, caseData, chalk) {
+  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.'));
@@ -262,13 +594,19 @@ async function _doApprove(config, result, 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);
@@ -282,8 +620,33 @@ async function _doApprove(config, result, 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) {
@@ -318,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`));
     }
@@ -332,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();
 }
 
@@ -386,13 +761,39 @@ async function _diagnoseExistingCase(config, caseId, flags, chalk) {
     for (const m of caseData.missing_information) console.log(`    ? ${m}`);
   }
 
+  // "Verified" is only ever earned here -- a case whose real GPU run
+  // actually completed (`lead_summary.status`, computed server-side by
+  // `_build_lead_summary` from `ReproCase.status`/`final_command`). Never
+  // reachable from --smoke, which never provisions anything.
+  console.log();
+  const existingStatus = caseData.lead_summary?.status === 'verified'
+    || caseData.status === 'verified' || caseData.status === 'completed'
+    ? 'VERIFIED'
+    : (caseData.missing_information || []).length ? 'NEEDS INFO' : 'READY';
+  console.log(`  ${chalk.bold(`STATUS: ${existingStatus}`)}`);
+  if (existingStatus === 'VERIFIED') {
+    console.log();
+    console.log(`  ${chalk.bold('Command:')}`);
+    console.log(`  ${caseData.final_command || caseData.known_command}`);
+    console.log();
+    console.log(`  ${chalk.bold('Result:')}`);
+    const resultLines = caseData.lead_summary?.test_checklist?.length
+      ? caseData.lead_summary.test_checklist
+      : ['Verified'];
+    for (const line of resultLines) console.log(`  - ${line}`);
+    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.`);
+    }
+  }
+
   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)}`)}`);
+  } 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();
 
@@ -411,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];
@@ -420,10 +829,12 @@ export async function diagnoseCommand(config, args, chalk) {
     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 === '--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);
@@ -456,38 +867,121 @@ 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);
+
+  // A command that's actually runnable also gets a free prepared Run
+  // page -- the same case /run-issue's own confirm step would create --
+  // so diagnosis ends at a page someone can click Run on, not just a
+  // printed command. Only READY and SMOKE CHECKED qualify: NEEDS INFO has
+  // nothing runnable to save yet, and INVALID is a command a real check
+  // just proved broken -- turning that into a clickable "Run" page would
+  // contradict the label. Both print their own guidance instead (Missing:
+  // / the failed check) and stop there.
+  let caseData = null;
+  let caseError = null;
+  if (status === 'READY' || status === 'SMOKE CHECKED') {
+    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) {
-    console.log(JSON.stringify({ detected: detected.kind, ...result }, null, 2));
+    const output = { detected: detected.kind, ...result, status };
+    // 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 || [],
+        local_file_checks: _localPathCandidates(e).map(p => ({ path: p, exists: fs.existsSync(p) })),
+      };
+    }
+    if (caseData?.case_id) {
+      output.run = {
+        case_id: caseData.case_id,
+        url: _runPageUrl(caseData.case_id, config),
+        canonical_command: caseData.findings?.canonical_command || null,
+      };
+    }
+    console.log(JSON.stringify(output, null, 2));
+
+    // --json must not silently skip --approve -- the JSON branch used to
+    // return here unconditionally, so a scripted `--approve --json` call
+    // never claimed/approved/launched anything (bug: approval was silently
+    // dropped in the one output mode automation actually uses). Approval
+    // output itself stays human-readable (chalk console lines), matching
+    // _diagnoseExistingCase's existing --json + --approve behaviour below.
+    if (flags.approve) {
+      if (caseError) {
+        console.error(chalk.red(`\n  ✗ Could not create case: ${caseError.message}\n`));
+        process.exitCode = 1;
+        return;
+      }
+      if (!caseData) {
+        console.error(chalk.yellow('\n  Cannot approve — missing information above.\n'));
+        return;
+      }
+      await _doApprove(config, caseData, chalk);
+    }
     return;
   }
 
   console.log();
   _printResult(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, 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) {
-    await _doApprove(config, result, chalk);
+    if (caseError) {
+      console.error(chalk.red(`\n  ✗ Could not create case: ${caseError.message}\n`));
+      process.exitCode = 1;
+      return;
+    }
+    if (!caseData) {
+      console.log(chalk.yellow('\n  Cannot approve — missing information above.\n'));
+      return;
+    }
+    await _doApprove(config, caseData, chalk);
   }
 }