badgr-cli 1.0.48 → 1.1.0

package/src/commands/run.js

@@ -3,13 +3,21 @@ import path from 'path';
 import os from 'os';
 import { createWriteStream } from 'fs';
 import { requireApiKey } from '../config.js';
-import { callApi, terminateDeployment, uploadBlob } from '../api.js';
-import { addReceipt, updateReceipt, generateReceiptId } from '../store.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 { 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 } from '../progress.js';
 import { detectWorkload, workloadTypeLabel } from '../detect.js';
+import { ensureBadgrReady } from '../onboarding.js';
+import { VM_CLASSES, parseGbSize } from '../spec.js';
+
+function vmClassLine(sizeKey) {
+  const vmClass = VM_CLASSES[sizeKey];
+  if (!vmClass) return sizeKey;
+  return `${sizeKey} (${vmClass.vcpu} vCPU, ${vmClass.ramGb} GB RAM)`;
+}
 
 /**
  * Flow 1 — local project (primary):
@@ -25,7 +33,12 @@ import { detectWorkload, workloadTypeLabel } from '../detect.js';
  * Legacy / direct command:
  *   badgr run python train.py --gpu A100
  *   badgr run --image my/image:latest --gpu L40S --detach
+ *
+ * CPU launches (see commands/launch.js) reuse this same flow via
+ * runCommand(config, args, chalk, { isLaunch: true }) — a source plus a
+ * `--cmd`/`-- <command>` command, provisioned on a CPU VM instead of a GPU.
  */
+
 export function parseRunArgs(args) {
   const flags = {};
   const positional = [];
@@ -46,6 +59,7 @@ export function parseRunArgs(args) {
     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; }
+    if (flagArgs[i] === '--no-detach')       { flags.noDetach = true; i++; continue; }
     if (flagArgs[i] === '--fallback')           { flags.fallback = flagArgs[++i]; i++; continue; }
     if (flagArgs[i] === '--no-fallback')        { flags.noFallback = true; i++; continue; }
     if (flagArgs[i] === '--strict-capacity')    { flags.noFallback = true; i++; continue; }
@@ -53,6 +67,10 @@ export function parseRunArgs(args) {
     if (flagArgs[i] === '--max-runtime')     { flags.maxRuntime = parseFloat(flagArgs[++i]); i++; continue; }
     if (flagArgs[i] === '--max-cost')        { flags.maxCost = parseFloat(flagArgs[++i]); i++; continue; }
     if (flagArgs[i] === '--min-vram')        { flags.minVram = parseFloat(flagArgs[++i]); i++; continue; }
+    if (flagArgs[i] === '--gpu-memory')      { flags.gpuMemoryRaw = flagArgs[++i]; flags.minVram = parseGbSize(flags.gpuMemoryRaw); i++; continue; }
+    if (flagArgs[i] === '--cpu')             { flags.cpuRaw = flagArgs[++i]; flags.cpu = parseInt(flags.cpuRaw, 10); i++; continue; }
+    if (flagArgs[i] === '--memory')          { flags.memoryRaw = flagArgs[++i]; flags.memory = parseGbSize(flags.memoryRaw); i++; continue; }
+    if (flagArgs[i] === '--no-gpu')          { flags.noGpu = true; i++; continue; }
     if (flagArgs[i] === '--dry-run')         { flags.dryRun = true; i++; continue; }
     if (flagArgs[i] === '--save')            { flags.save = flagArgs[++i]; i++; continue; }
     if (flagArgs[i] === '--workspace')       { flags.workspace = flagArgs[++i]; i++; continue; }
@@ -61,12 +79,20 @@ export function parseRunArgs(args) {
     if (flagArgs[i] === '--checkpoint')      { flags.checkpoint = flagArgs[++i]; i++; continue; }
     if (flagArgs[i] === '--retry-safe')      { flags.retrySafe = true; i++; continue; }
     if (flagArgs[i] === '--resume-cmd')      { flags.resumeCmd = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--agent-name')      { flags.agentName = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--size')             { flags.size = flagArgs[++i]; i++; continue; }
     if (flagArgs[i] === '--env') {
       const kv = flagArgs[++i]; i++;
       if (!flags.env) flags.env = [];
       flags.env.push(kv);
       continue;
     }
+    if (flagArgs[i] === '--artifacts') {
+      const p = flagArgs[++i]; i++;
+      if (!flags.artifacts) flags.artifacts = [];
+      flags.artifacts.push(p);
+      continue;
+    }
     positional.push(flagArgs[i++]);
   }
   return { flags, positional, commandArgv };
@@ -81,6 +107,33 @@ function parseEnvFlag(envList) {
   return obj;
 }
 
+// Heuristic for --env keys that look like secrets — used to warn (not
+// block) since there is no dashboard --profile injection path yet and
+// --env is currently the only way to get a provider key into a launch VM.
+const _SECRET_ENV_KEY_RE = /(API_KEY|SECRET|TOKEN|PASSWORD|PASSWD|PRIVATE_KEY|CREDENTIAL)/i;
+
+function warnAboutSecretEnvFlags(envList, chalk) {
+  const secretKeys = (envList || [])
+    .map(kv => kv.slice(0, kv.indexOf('=')))
+    .filter(key => key && _SECRET_ENV_KEY_RE.test(key));
+  if (secretKeys.length === 0) return;
+  console.log(chalk.yellow(`\n  ⚠ --env ${secretKeys.join(', ')} looks like a secret passed on the command line.`));
+  console.log(chalk.dim('    It may be saved in your shell history and is visible to anyone who can run `ps`/`history` on this machine.'));
+  console.log(chalk.dim('    Dashboard-managed secret profiles (--profile <name>) are planned but not built yet — see docs/badgr-cloud-phase1-2-checklist.md.'));
+}
+
+// Never print a credential value to the terminal — dry-run banner, live
+// banner, and anywhere else --env gets echoed back. Applies to both
+// user-typed --env and any credential badgr connect injected automatically.
+function redactEnvForDisplay(envList) {
+  return (envList || []).map(kv => {
+    const idx = kv.indexOf('=');
+    if (idx <= 0) return kv;
+    const key = kv.slice(0, idx);
+    return _SECRET_ENV_KEY_RE.test(key) ? `${key}=<redacted>` : kv;
+  }).join(', ');
+}
+
 // Mirror of backend workload_profile.py — kept in sync for pre-flight display.
 const _PROFILES = {
   smoke_test:       { label: 'smoke test',            vram: '4 GB',    gpus: ['RTX 3080', 'RTX 3090', 'RTX 4090'] },
@@ -346,6 +399,10 @@ async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost
           failureType: classifyFailure(status, exitCode),
           failureClass: dep.failure_class ?? null,
           nextAction: dep.next_action ?? null,
+          // Reflects whatever the backend's own teardown attempt (the job
+          // runner's /complete webhook, which fires on any exit code) has
+          // already confirmed — not a guess made by this CLI.
+          teardownOk: dep.teardown_ok === 'ok',
         };
       }
     }
@@ -361,10 +418,11 @@ 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',
-  '--detach', '--fallback', '--no-fallback', '--strict-capacity',
-  '--no-expanded-search', '--max-runtime', '--max-cost', '--min-vram', '--env',
+  '--detach', '--no-detach', '--fallback', '--no-fallback', '--strict-capacity',
+  '--no-expanded-search', '--max-runtime', '--max-cost', '--min-vram', '--gpu-memory',
+  '--cpu', '--memory', '--no-gpu', '--env',
   '--dry-run', '--cmd', '--save', '--workspace',
-  '--output', '--checkpoint', '--retry-safe', '--resume-cmd',
+  '--output', '--checkpoint', '--retry-safe', '--resume-cmd', '--artifacts',
 ]);
 
 // Directories and files always excluded from project zip uploads.
@@ -378,14 +436,14 @@ function _shouldExclude(name) {
   return _ZIP_EXCLUDES.has(name) || name.startsWith('.') && name !== '.gitignore';
 }
 
-function _isLocalPath(arg) {
+export function _isLocalPath(arg) {
   // '.' or './' or relative/absolute paths that exist on disk
   if (arg === '.') return true;
   if (arg.startsWith('./') || arg.startsWith('../') || arg.startsWith('/')) return true;
   return false;
 }
 
-function _isGitHubUrl(arg) {
+export function _isGitHubUrl(arg) {
   return /^https?:\/\/(www\.)?github\.com\//.test(arg);
 }
 
@@ -440,9 +498,20 @@ export async function _uploadCodeZip(config, dirPath, chalk) {
   return uploadResp.code_uri;
 }
 
-export async function runCommand(config, args, chalk) {
+export async function runCommand(config, args, chalk, opts = {}) {
+  const isLaunch = Boolean(opts.isLaunch);
+  const maxCostIsDefault = Boolean(opts.maxCostIsDefault);
+  // Real argv array for a code-source job's command — set only by internal
+  // callers (badgr launch's agent workloads), never parsed from a shell
+  // string. Passed to the backend as command_argv, which the worker always
+  // prefers over the legacy cmd string + shlex.split() path (see
+  // images/badgr-job-runner/entrypoint.py). flags.cmd stays the
+  // human-readable display string only.
+  const cmdArgv = Array.isArray(opts.cmdArgv) ? opts.cmdArgv : undefined;
+  const cmdName = isLaunch ? 'badgr launch' : 'badgr run';
+
   // `badgr run template <name> [flags]` — expand template defaults then re-dispatch
-  if (args[0] === 'template') {
+  if (!isLaunch && args[0] === 'template') {
     const name = args[1];
     const t = name && TEMPLATE_MAP[name];
     if (!t) {
@@ -475,7 +544,7 @@ export async function runCommand(config, args, chalk) {
     console.error(chalk.dim('  This usually means a line continuation has a trailing space.'));
     console.error(chalk.dim('  Use a single line, or end each continued line with \\ and no space after:'));
     console.error(chalk.dim(''));
-    console.error(chalk.dim('    badgr run python script.py \\'));
+    console.error(chalk.dim(`    ${cmdName} python script.py \\`));
     console.error(chalk.dim('      --gpu RTX_4090 --max-cost 10 --max-runtime 60'));
     console.error(chalk.dim(''));
     process.exitCode = 1;
@@ -489,10 +558,13 @@ export async function runCommand(config, args, chalk) {
   const isGitHubUrl  = firstArg && _isGitHubUrl(firstArg);
   const isCodeSource = isLocalPath || isGitHubUrl;
 
+  if (isLaunch) flags.detach = flags.noDetach ? false : (flags.detach ?? true);
+
   // Local paths can be inspected on disk, so a missing --cmd doesn't have to be
   // an error — try to infer it (and output/checkpoint conventions) the same way
   // `badgr detect .` would, before ever provisioning anything.
   let detectionReport = null;
+
   if (isLocalPath && !flags.cmd) {
     detectionReport = detectWorkload(firstArg);
     if (detectionReport.command && detectionReport.confidence !== 'low') {
@@ -522,19 +594,27 @@ export async function runCommand(config, args, chalk) {
   }
 
   if (isCodeSource && !flags.cmd) {
-    console.error(chalk.red(`\n  ✗ --cmd is required when running from a ${isLocalPath ? 'local path' : 'GitHub URL'}.\n`));
+    const example = isLaunch ? '-- claude -p "Fix the checkout bug"' : '--cmd "python train.py" --max-cost 5';
+    console.error(chalk.red(`\n  ✗ ${isLaunch ? 'A command (`-- <command>` or --cmd) is' : '--cmd is'} required when running from a ${isLocalPath ? 'local path' : 'GitHub URL'}.\n`));
     if (isLocalPath) {
-      console.error(chalk.dim('  Example: badgr run . --cmd "python train.py" --max-cost 5\n'));
-      console.error(chalk.dim('  Or check what Badgr detects first: badgr detect .\n'));
+      console.error(chalk.dim(`  Example: ${cmdName} . ${example}\n`));
+      if (!isLaunch) console.error(chalk.dim('  Or check what Badgr detects first: badgr detect .\n'));
     } else {
-      console.error(chalk.dim('  Example: badgr run https://github.com/user/repo --cmd "python train.py" --max-cost 5\n'));
+      console.error(chalk.dim(`  Example: ${cmdName} https://github.com/user/repo ${example}\n`));
     }
     process.exitCode = 1;
     return;
   }
 
+  if (isLaunch && !isCodeSource) {
+    console.error(chalk.red(`\n  ✗ ${cmdName} requires a source: a local path ('.') or a GitHub URL.\n`));
+    console.error(chalk.dim('  Example: badgr launch . --max-cost 1 -- claude -p "Fix the checkout bug"\n'));
+    process.exitCode = 1;
+    return;
+  }
+
   // Legacy direct-command mode: positional args form the command
-  const isDirectCommand = !isCodeSource && (positional.length > 0 || commandArgv !== null || flags.image);
+  const isDirectCommand = !isLaunch && !isCodeSource && (positional.length > 0 || commandArgv !== null || flags.image);
 
   if (!isCodeSource && positional.length === 0 && commandArgv === null && !flags.image) {
     console.error(chalk.red('\nUsage:'));
@@ -551,7 +631,17 @@ export async function runCommand(config, args, chalk) {
     process.exitCode = 1;
     return;
   }
-  requireApiKey(config);
+  // Just-in-time login + funding — the first meaningful action should be
+  // `badgr run`/`badgr launch`, not a separate `badgr login` step. A dry run
+  // previews the plan only and never provisions or spends anything, so it
+  // still needs a stored key (to keep its existing fail-fast behavior in
+  // non-interactive contexts like tests/CI) but doesn't trigger the
+  // interactive browser flow.
+  if (flags.dryRun) {
+    requireApiKey(config);
+  } else {
+    config = await ensureBadgrReady(config, chalk);
+  }
 
   // ── Validate flags early ───────────────────────────────────────────────────
   if (flags.count !== undefined && (!Number.isFinite(flags.count) || flags.count < 1)) {
@@ -574,6 +664,26 @@ export async function runCommand(config, args, chalk) {
     process.exitCode = 1;
     return;
   }
+  if (flags.cpuRaw !== undefined && (!Number.isFinite(flags.cpu) || flags.cpu < 1 || !Number.isInteger(flags.cpu))) {
+    console.error(chalk.red(`  ✗ --cpu must be a positive whole number of cores, got: ${flags.cpuRaw}`));
+    process.exitCode = 1;
+    return;
+  }
+  if (flags.memoryRaw !== undefined && (flags.memory == null || !Number.isFinite(flags.memory) || flags.memory <= 0)) {
+    console.error(chalk.red(`  ✗ --memory could not be parsed as a size, got: ${flags.memoryRaw} (try "64GB" or "65536MB")`));
+    process.exitCode = 1;
+    return;
+  }
+  if (flags.gpuMemoryRaw !== undefined && (flags.minVram == null || !Number.isFinite(flags.minVram) || flags.minVram <= 0)) {
+    console.error(chalk.red(`  ✗ --gpu-memory could not be parsed as a size, got: ${flags.gpuMemoryRaw} (try "24GB" or "24576MB")`));
+    process.exitCode = 1;
+    return;
+  }
+  if (flags.noGpu && (flags.gpu || flags.minVram)) {
+    console.error(chalk.red('  ✗ --no-gpu conflicts with --gpu/--gpu-memory/--min-vram — pick one'));
+    process.exitCode = 1;
+    return;
+  }
 
   if (!flags.maxCost && !flags.dryRun && isLocalPath && process.stdin.isTTY && process.stdout.isTTY) {
     try {
@@ -627,50 +737,91 @@ export async function runCommand(config, args, chalk) {
   if (flags.checkpoint) conventionEnv.BADGR_CHECKPOINT_DIR = flags.checkpoint;
   if (flags.retrySafe)  conventionEnv.BADGR_RETRY_SAFE = '1';
   const envObj       = { ...conventionEnv, ...parseEnvFlag(flags.env) };
+  if (isLaunch) warnAboutSecretEnvFlags(flags.env, chalk);
   const effectiveTier = normalizeTier(flags.tier);
 
-  const gpu = flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : undefined;
+  const gpu = isLaunch ? 'CPU' : (flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : undefined);
+
+  // Detect VM → show price → launch VM: for CPU launches, ask the backend
+  // what this would cost *before* calling /run, so the customer sees the
+  // rate before anything is provisioned or billed — not just after. This is
+  // a best-effort preview (short timeout, never fatal): if the quote call
+  // fails for any reason, the launch still proceeds and the rate falls back
+  // to being shown once the deployment is actually created (see below).
+  let quotedRate = null;
+  if (isLaunch) {
+    try {
+      const quote = await quoteRun(config, {
+        compute: 'cpu',
+        ...(flags.agentName ? { agent: flags.agentName } : {}),
+        ...(flags.size ? { size: flags.size } : {}),
+        ...(flags.region ? { region: flags.region.toUpperCase() } : {}),
+      });
+      if (quote && typeof quote.rate_per_hour === 'number') quotedRate = quote.rate_per_hour;
+    } catch {
+      // Non-fatal — the launch itself still shows the confirmed rate once
+      // the deployment is created.
+    }
+  }
 
   if (flags.dryRun) {
-    console.log(chalk.bold('\n⚡ Dry run — no GPU will be provisioned\n'));
+    console.log(chalk.bold(`\n⚡ Dry run — no ${isLaunch ? 'VM' : 'GPU'} will be provisioned\n`));
     if (isLocalPath)      console.log(`  ${chalk.bold('Source:')}       ${path.resolve(firstArg)} (local project)`);
     if (isGitHubUrl)      console.log(`  ${chalk.bold('Source:')}       ${firstArg} (GitHub)`);
+    if (flags.agentName)  console.log(`  ${chalk.bold('Workload:')}     ${flags.agentName}`);
     if (flags.cmd)        console.log(`  ${chalk.bold('Command:')}      ${flags.cmd}`);
     if (command)          console.log(`  ${chalk.bold('Command:')}      ${command.join(' ')}`);
     if (image)            console.log(`  ${chalk.bold('Image:')}        ${image}`);
-    console.log(`  ${chalk.bold('GPU:')}          ${gpu || chalk.dim('auto')}`);
+    console.log(`  ${chalk.bold(isLaunch || flags.noGpu ? 'Compute:' : 'GPU:')}      ${isLaunch || flags.noGpu ? 'CPU VM (no GPU)' : (gpu || chalk.dim('auto'))}`);
+    if (isLaunch && flags.size) console.log(`  ${chalk.bold('VM class:')}     ${vmClassLine(flags.size)}`);
+    if (isLaunch && quotedRate != null) console.log(`  ${chalk.bold('Badgr rate:')}   $${quotedRate.toFixed(2)}/hour`);
+    if (flags.minVram)    console.log(`  ${chalk.bold('Min VRAM:')}     ${flags.minVram} GB`);
+    if (flags.cpu)        console.log(`  ${chalk.bold('CPU:')}          ${flags.cpu} cores`);
+    if (flags.memory)     console.log(`  ${chalk.bold('Memory:')}       ${flags.memory} GB`);
     console.log(`  ${chalk.bold('Max runtime:')}  ${effectiveMaxRuntime}min`);
-    if (maxCost)          console.log(`  ${chalk.bold('Max cost:')}     $${maxCost}`);
+    if (maxCost)          console.log(`  ${chalk.bold('Max cost:')}     $${maxCost}${maxCostIsDefault ? chalk.dim(' (default — use --max-cost N to override)') : ''}`);
     if (flags.maxPrice)   console.log(`  ${chalk.bold('Max price:')}    $${flags.maxPrice}/hr`);
-    if (flags.env?.length) console.log(`  ${chalk.bold('Env:')}         ${flags.env.join(', ')}`);
+    if (flags.env?.length) console.log(`  ${chalk.bold('Env:')}         ${redactEnvForDisplay(flags.env)}`);
     if (flags.output)     console.log(`  ${chalk.bold('Output:')}       ${flags.output}`);
     if (flags.checkpoint) console.log(`  ${chalk.bold('Checkpoint:')}   ${flags.checkpoint}`);
     if (flags.retrySafe)  console.log(`  ${chalk.bold('Retry-safe:')}   enabled`);
     if (flags.resumeCmd)  console.log(`  ${chalk.bold('Resume cmd:')}   ${flags.resumeCmd}`);
+    if (flags.artifacts?.length) console.log(`  ${chalk.bold('Artifacts:')}    ${flags.artifacts.join(', ')}`);
     console.log(chalk.dim('\n  Remove --dry-run to provision.\n'));
     return;
   }
 
-  console.log(chalk.bold('\n⚡ Running GPU job\n'));
+  console.log(chalk.bold(`\n⚡ ${isLaunch ? 'Launching command on CPU VM' : 'Running GPU job'}\n`));
   if (isLocalPath)  console.log(`  ${chalk.bold('Source:')}   ${path.resolve(firstArg)}`);
   if (isGitHubUrl)  console.log(`  ${chalk.bold('Source:')}   ${firstArg}`);
+  if (flags.agentName) console.log(`  ${chalk.bold('Workload:')} ${flags.agentName}`);
   if (flags.cmd)    console.log(`  ${chalk.bold('Command:')}  ${flags.cmd}`);
   if (command)      console.log(`  ${chalk.bold('Command:')}  ${command.join(' ')}`);
   if (image)        console.log(`  ${chalk.bold('Image:')}    ${image}`);
-  if (flags.gpu)    console.log(`  ${chalk.bold('GPU:')}      ${gpu}`);
+  if (isLaunch)          console.log(`  ${chalk.bold('Compute:')}  CPU VM`);
+  else if (flags.noGpu)  console.log(`  ${chalk.bold('Compute:')}  CPU VM (no GPU)`);
+  else if (flags.gpu)    console.log(`  ${chalk.bold('GPU:')}      ${gpu}`);
+  if (isLaunch && flags.size) console.log(`  ${chalk.bold('VM class:')} ${vmClassLine(flags.size)}`);
+  if (isLaunch && quotedRate != null) console.log(`  ${chalk.bold('Badgr rate:')} $${quotedRate.toFixed(2)}/hour`);
   if (flags.minVram)  console.log(`  ${chalk.bold('Min VRAM:')}   ${flags.minVram} GB`);
+  if (flags.cpu)      console.log(`  ${chalk.bold('CPU:')}        ${flags.cpu} cores`);
+  if (flags.memory)   console.log(`  ${chalk.bold('Memory:')}     ${flags.memory} GB`);
   const runtimeLabel = isDefaultRuntime
     ? `${effectiveMaxRuntime} min ${chalk.dim('(default — use --max-runtime N to override)')}`
     : `${effectiveMaxRuntime} min`;
-  console.log(`  ${chalk.bold('Max cost:')}    ${maxCost ? `$${maxCost.toFixed(2)}` : chalk.dim('none')}`);
+  const maxCostLabel = maxCost
+    ? `$${maxCost.toFixed(2)}${maxCostIsDefault ? chalk.dim(' (default — use --max-cost N to override)') : ''}`
+    : chalk.dim('none');
+  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 (flags.maxPrice) console.log(`  ${chalk.bold('Max price:')}   $${flags.maxPrice.toFixed(2)}/hr`);
   if (detach)         console.log(`  ${chalk.dim('(detached — returns immediately)')}`);
-  if (flags.env?.length) console.log(`  ${chalk.bold('Env:')}      ${flags.env.join(', ')}`);
+  if (flags.env?.length) console.log(`  ${chalk.bold('Env:')}      ${redactEnvForDisplay(flags.env)}`);
   if (flags.output)     console.log(`  ${chalk.bold('Output:')}     ${flags.output}`);
   if (flags.checkpoint) console.log(`  ${chalk.bold('Checkpoint:')} ${flags.checkpoint}`);
   if (flags.retrySafe)  console.log(`  ${chalk.bold('Retry-safe:')} enabled`);
+  if (flags.artifacts?.length) console.log(`  ${chalk.bold('Artifacts:')}  ${flags.artifacts.join(', ')}`);
   console.log();
 
 
@@ -719,7 +870,11 @@ export async function runCommand(config, args, chalk) {
       ...(command ? { command } : {}),
       ...(image ? { image } : {}),
       gpu: gpuOverride || gpu || 'auto',
+      ...(isLaunch ? { compute: 'cpu' } : {}),
+      ...(flags.noGpu ? { no_gpu: true } : {}),
       ...(flags.minVram ? { min_vram: flags.minVram } : {}),
+      ...(flags.cpu ? { cpu: flags.cpu } : {}),
+      ...(flags.memory ? { memory_gb: flags.memory } : {}),
       gpu_count: flags.count || 1,
       ...(effectiveRegion ? { region: effectiveRegion } : {}),
       max_price_per_hour: flags.maxPrice,
@@ -733,6 +888,10 @@ export async function runCommand(config, args, chalk) {
       ...(codeUri ? { code_uri: codeUri } : {}),
       ...(isGitHubUrl ? { github_url: firstArg } : {}),
       ...(flags.cmd ? { cmd: flags.cmd } : {}),
+      ...(cmdArgv ? { command_argv: cmdArgv } : {}),
+      ...(flags.artifacts?.length ? { output_paths: flags.artifacts } : {}),
+      ...(flags.agentName ? { agent: flags.agentName } : {}),
+      ...(flags.size ? { size: flags.size } : {}),
     };
   }
 
@@ -744,13 +903,13 @@ export async function runCommand(config, args, chalk) {
       (tierOverride) => buildBody(undefined, tierOverride),
       effectiveTier,
       chalk,
-      { thing: 'job', cmd: 'badgr run' },
+      { thing: 'job', cmd: cmdName },
       { allowTier2Fallback: !flags.noFallback },
     );
   } catch (err) {
     if (err.isPaymentRequired) {
       console.error(chalk.yellow(err.message));
-      const rerun = ['badgr run', ...args].join(' ');
+      const rerun = [cmdName, ...args].join(' ');
       console.error(chalk.dim(`After payment, rerun:\n  ${rerun}\n`));
       process.exitCode = 1;
       return;
@@ -761,10 +920,20 @@ export async function runCommand(config, args, chalk) {
     return;
   }
 
+  // Minimum product-learning data: what shape of workload this was, what
+  // was requested vs. what was actually provisioned. No analytics system,
+  // no dashboard — just enough on each receipt that repeat-usage and
+  // resource-fit questions are answerable later from stored receipts.
+  const workloadShape = isLaunch ? `agent:${flags.agentName || 'custom'}`
+    : isLocalPath ? 'project'
+    : isGitHubUrl ? 'git-repo'
+    : image ? 'container'
+    : 'command';
+
   const rcptId = dep.receipt_id || generateReceiptId();
   addReceipt({
     receiptId:     rcptId,
-    action:        'badgr run',
+    action:        cmdName,
     deploymentId:  dep.deployment_id,
     gpu:           dep.gpu_type,
     providerRoute: dep.provider ?? null,
@@ -773,15 +942,47 @@ export async function runCommand(config, args, chalk) {
     maxRuntime:    flags.maxRuntime ?? null,
     status:        dep.status,
     createdAt:     new Date().toISOString(),
+    workloadShape,
+    computeRequested: {
+      gpu: flags.gpu ?? null,
+      gpuCount: flags.count ?? null,
+      minVram: flags.minVram ?? null,
+      cpu: flags.cpu ?? null,
+      memoryGb: flags.memory ?? null,
+      noGpu: flags.noGpu ?? false,
+    },
+    computeSelected: selectedComputeFromDeployment(dep),
   });
 
   const rate = dep.cost_per_hour || 0;
 
+  // Show what was actually provisioned, not just what was requested — only
+  // when the caller asked for a resource floor and the provider reported
+  // enough to say something concrete (best-effort; not every provider
+  // exposes vcpu/ram/vram per-offer, see deployment_service.py's
+  // chosen_instance.extra enrichment).
+  if (flags.cpu || flags.memory || flags.minVram) {
+    const parts = [];
+    if (dep.gpu_type && dep.gpu_type !== 'CPU') parts.push(`${dep.gpu_count || 1}× ${dep.gpu_type}`);
+    if (dep.selected_vram_gb != null) parts.push(`${dep.selected_vram_gb}GB VRAM`);
+    if (dep.selected_vcpus != null) parts.push(`${dep.selected_vcpus} vCPU`);
+    if (dep.selected_ram_gb != null) parts.push(`${dep.selected_ram_gb}GB RAM`);
+    if (parts.length) console.log(`  ${chalk.bold('Provisioned:')} ${parts.join(', ')}`);
+  }
+
   console.log(chalk.dim(_stageDone(stageN, STAGE_TOTAL, 'Finding a working route...')));
   stageN++;
   console.log(chalk.dim(_stageDone(stageN, STAGE_TOTAL, 'Starting runtime...')));
   stageN++;
 
+  // The rate was already shown pre-provisioning via the quote call above,
+  // in the normal case — this is only a fallback for when that quote call
+  // failed (network hiccup, older backend without the endpoint, etc.), so
+  // the customer still sees the rate somewhere rather than never at all.
+  if (isLaunch && quotedRate == null && rate > 0) {
+    console.log(chalk.dim(`\n  Badgr rate: $${rate.toFixed(2)}/hour`));
+  }
+
   if (rate > HIGH_RATE_THRESHOLD && !maxCost) {
     console.log(chalk.yellow(`\n  Selected capacity rate: $${rate.toFixed(2)}/hr`));
     console.log(chalk.dim('  Tip: use --max-cost to enforce a hard ceiling.'));
@@ -810,9 +1011,12 @@ export async function runCommand(config, args, chalk) {
       'interrupted':    'Stopped',
     };
 
-    let teardownOk = true;
+    let teardownOk = false;
     try {
-      await terminateDeployment(config, dep.deployment_id);
+      // A 200 response only means deletion was requested, not confirmed —
+      // see the identical note on the success-path teardown below.
+      const result = await terminateDeployment(config, dep.deployment_id);
+      teardownOk = result?.teardown_ok === 'ok';
     } catch {
       // terminateDeployment retries 3×; best-effort if all fail
       teardownOk = false;
@@ -870,7 +1074,7 @@ export async function runCommand(config, args, chalk) {
   console.log(chalk.dim(`\n  [${stageN}/${STAGE_TOTAL}] Running command (Ctrl+C to stop)`));
 
   attachStart = Date.now();
-  const { status: finalStatus, exitCode, runtimeMs, failureType, failureClass, nextAction } = await attachToJob(config, dep.deployment_id, {
+  const { status: finalStatus, exitCode, runtimeMs, failureType, failureClass, nextAction, teardownOk: confirmedTeardownOk } = await attachToJob(config, dep.deployment_id, {
     chalk,
     maxRuntimeMs,
     maxCost,
@@ -899,7 +1103,7 @@ export async function runCommand(config, args, chalk) {
     runtimeSeconds: Math.round(runtimeMs / 1000),
     finalCost,
     failureType,
-    teardownStatus: (finalStatus === 'completed' || finalStatus === 'succeeded') ? 'terminated' : 'failed',
+    teardownStatus: confirmedTeardownOk ? 'terminated' : 'failed',
   });
 
   console.log();
@@ -913,18 +1117,27 @@ export async function runCommand(config, args, chalk) {
     _printFailureClass(chalk, { failure_class: failureClass, next_action: nextAction });
     console.log(chalk.dim(_stage(STAGE_TOTAL, STAGE_TOTAL, 'Failed')));
     console.log(chalk.dim(`  Runtime: ${fmtRuntime(runtimeMs)}  •  Estimated cost: ~$${finalCost.toFixed(2)}`));
-    // The container already reached a terminal state on the provider side by the
-    // time we observe it here, so billing is already stopped — no extra teardown call needed.
-    _printFinalInfo(chalk, { exitCode, teardownOk: true, jobId: dep.deployment_id, rcptId });
+    // The backend's own /complete webhook already attempted teardown (on any
+    // exit code) by the time we observe this — no extra teardown call from
+    // here is needed. But whether it was *confirmed* is a real result from
+    // that attempt, not something to assume — see attachToJob's teardownOk.
+    _printFinalInfo(chalk, { exitCode, teardownOk: confirmedTeardownOk, jobId: dep.deployment_id, rcptId });
     if (flags.resumeCmd) console.log(`  ${chalk.bold('Resume:')}    ${flags.resumeCmd}`);
     process.exitCode = exitCode ?? 1;
     return;
   }
 
   if ((finalStatus === 'completed' || finalStatus === 'succeeded') && (exitCode === 0 || exitCode === null)) {
-    let teardownOk = true;
+    // A 200 response only means the backend requested deletion, not that it
+    // confirmed the underlying resource is gone — /v1/deployments/{id} never
+    // raises just because teardown failed, it returns 200 with
+    // teardown_ok: "failed" in the body. Checking only for a thrown
+    // exception here would report "Teardown: succeeded" while the resource
+    // may still exist and still be billing.
+    let teardownOk = false;
     try {
-      await terminateDeployment(config, dep.deployment_id);
+      const result = await terminateDeployment(config, dep.deployment_id);
+      teardownOk = result?.teardown_ok === 'ok';
     } catch { teardownOk = false; /* already stopped, or best-effort */ }
     console.log(chalk.green(_stage(STAGE_TOTAL, STAGE_TOTAL, 'Complete')));
     console.log(chalk.dim(`  Runtime: ${fmtRuntime(runtimeMs)}  •  Estimated cost: ~$${finalCost.toFixed(2)}`));
@@ -943,11 +1156,14 @@ export async function runCommand(config, args, chalk) {
               ...(command ? { command } : {}),
               ...(image ? { image } : {}),
               ...(flags.cmd ? { cmd: flags.cmd } : {}),
+              ...(cmdArgv ? { command_argv: cmdArgv } : {}),
               // For local-path workloads, code_uri is a snapshot — user can re-upload on next run.
               // GitHub URL is stable and stored directly.
               ...(isGitHubUrl ? { github_url: firstArg } : {}),
               gpu: gpu || 'auto',
               ...(flags.minVram ? { min_vram: flags.minVram } : {}),
+              ...(flags.cpu ? { cpu: flags.cpu } : {}),
+              ...(flags.memory ? { memory_gb: flags.memory } : {}),
               gpu_count: flags.count || 1,
               ...(flags.maxPrice ? { max_price_per_hour: flags.maxPrice } : {}),
               ...(Object.keys(envObj).length > 0 ? { env: envObj } : {}),