badgr-cli 1.0.43 → 1.0.45

package/src/commands/run.js

@@ -8,6 +8,8 @@ import { addReceipt, updateReceipt, generateReceiptId } from '../store.js';
 import { normalizeTier, callWithFallback, HIGH_RATE_THRESHOLD } from '../fallback.js';
 import { formatCliError } from '../errors.js';
 import { TEMPLATE_MAP, buildTemplateFlags, parseTemplateOverrides } from '../catalog.js';
+import { stage as _stage, stageDone as _stageDone, writeBlock as _writeBlock, clearBlock as _clearBlock, renderLiveBlock as _renderLiveBlock, printFailureClass as _printFailureClass } from '../progress.js';
+import { detectWorkload, workloadTypeLabel } from '../detect.js';
 
 /**
  * Flow 1 — local project (primary):
@@ -55,6 +57,10 @@ export function parseRunArgs(args) {
     if (flagArgs[i] === '--save')            { flags.save = flagArgs[++i]; i++; continue; }
     if (flagArgs[i] === '--workspace')       { flags.workspace = flagArgs[++i]; i++; continue; }
     if (flagArgs[i] === '--cmd')             { flags.cmd = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--output')          { flags.output = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--checkpoint')      { flags.checkpoint = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--retry-safe')      { flags.retrySafe = true; i++; continue; }
+    if (flagArgs[i] === '--resume-cmd')      { flags.resumeCmd = flagArgs[++i]; i++; continue; }
     if (flagArgs[i] === '--env') {
       const kv = flagArgs[++i]; i++;
       if (!flags.env) flags.env = [];
@@ -105,6 +111,20 @@ const HEARTBEAT_WARN_POLLS  = 3;
 const HEARTBEAT_KILL_POLLS  = 15;
 const STARTUP_STATES = new Set(['queued', 'provisioning', 'starting']);
 
+// Shared closing block for every terminal path (success, failure, cap, heartbeat loss) —
+// always states exit code (when known), whether teardown/billing succeeded, and how to
+// pull the receipt, so the user is never left guessing what happened.
+function _printFinalInfo(chalk, { exitCode = undefined, teardownOk, jobId, rcptId, logsAvailable = true }) {
+  if (exitCode !== null && exitCode !== undefined) {
+    console.log(`  ${chalk.bold('Exit code:')} ${exitCode !== 0 ? chalk.red(exitCode) : chalk.green(exitCode)}`);
+  }
+  console.log(`  ${chalk.bold('Teardown:')}  ${teardownOk ? chalk.green('succeeded') : chalk.red(`failed — run: badgr down ${jobId}`)}`);
+  console.log(`  ${chalk.bold('Billing:')}   ${teardownOk ? 'stopped' : 'unconfirmed — check receipt'}`);
+  if (logsAvailable) console.log(`  ${chalk.bold('Logs:')}      badgr logs ${jobId}`);
+  console.log(`  ${chalk.bold('Job ID:')}    ${jobId}`);
+  console.log(`  ${chalk.bold('Receipt:')}   badgr receipts ${rcptId}`);
+}
+
 export function classifyFailure(finalStatus, exitCode) {
   if (finalStatus === 'failed' && (exitCode === null || exitCode === undefined)) return 'infrastructure';
   if (exitCode !== null && exitCode !== undefined && exitCode !== 0) return 'customer_code';
@@ -128,24 +148,6 @@ function parseProviderLine(line) {
   };
 }
 
-function renderStatusBar(chalk, { elapsedMs, ratePerHour, gpuUtil, cpuUtil, maxRuntimeMs, maxCost }) {
-  const spent = ratePerHour * (elapsedMs / 3_600_000);
-  const parts = [`⏱ ${fmtRuntime(elapsedMs)}`];
-  if (ratePerHour > 0) parts.push(`$${spent.toFixed(4)} spent`);
-  if (gpuUtil !== null) parts.push(`GPU ${gpuUtil.toFixed(0)}%`);
-  if (cpuUtil !== null) parts.push(`CPU ${cpuUtil.toFixed(0)}%`);
-  if (maxRuntimeMs) {
-    const left = Math.max(0, maxRuntimeMs - elapsedMs);
-    parts.push(`${fmtRuntime(left)} left`);
-  }
-  if (maxCost && ratePerHour > 0) {
-    const budgetLeft = Math.max(0, maxCost - spent);
-    parts.push(`$${budgetLeft.toFixed(4)} budget left`);
-  }
-  parts.push('Ctrl+C to stop');
-  return chalk.dim('  ' + parts.join('  •  '));
-}
-
 // Wait for status to leave 'starting'/'queued'/'provisioning'.
 // Returns the dep once it leaves startup states (or the last known state on timeout).
 async function waitForRunning(config, depId, chalk) {
@@ -200,7 +202,7 @@ async function waitForRunning(config, depId, chalk) {
   });
 }
 
-async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost = null, ratePerHour = 0, onTeardown, isShuttingDown }) {
+async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost = null, ratePerHour = 0, onTeardown, isShuttingDown, stageLine }) {
   const TERMINAL = new Set(['stopped', 'failed', 'completed', 'succeeded']);
   const POLL_MS  = 4000;
   let seenContent     = new Set();
@@ -209,7 +211,8 @@ async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost
   let gpuUtil         = null;
   let cpuUtil         = null;
   let sshShown        = false;
-  let statusBarActive = false;
+  let statusWord      = 'running';
+  let blockLines      = 0;
   const startMs       = Date.now();
 
   // tearing: guards against double-teardown for cap/heartbeat paths within this function.
@@ -218,17 +221,17 @@ async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost
   let tickerInterval = null;
   const startTicker = () => {
     if (tickerInterval) return;
-    statusBarActive = true;
     tickerInterval = setInterval(() => {
-      const bar = renderStatusBar(chalk, {
-        elapsedMs: Date.now() - startMs, ratePerHour, gpuUtil, cpuUtil, maxRuntimeMs, maxCost,
-      });
-      process.stdout.write(`\r${bar}   `);
+      const elapsedSec = Math.round((Date.now() - startMs) / 1000);
+      const spend = ratePerHour * (elapsedSec / 3600);
+      blockLines = _writeBlock(blockLines, _renderLiveBlock(chalk, {
+        stageLine, elapsedSec, statusWord, spend, id: depId,
+      }));
     }, 1000);
   };
   const stopTicker = () => {
     if (tickerInterval) { clearInterval(tickerInterval); tickerInterval = null; }
-    if (statusBarActive) { process.stdout.write('\r\x1b[2K'); statusBarActive = false; }
+    if (blockLines > 0) { _clearBlock(blockLines); blockLines = 0; }
   };
 
   try {
@@ -271,6 +274,7 @@ async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost
         consecutiveErrs++;
         if (lastStatus === 'running') {
           const lostSec = Math.round((consecutiveErrs * POLL_MS) / 1000);
+          if (consecutiveErrs >= HEARTBEAT_WARN_POLLS) statusWord = 'stuck';
           if (consecutiveErrs === HEARTBEAT_WARN_POLLS) {
             stopTicker();
             console.log(chalk.yellow(`\n  ⚠ No heartbeat for ${lostSec}s — cloud machine may be unresponsive`));
@@ -293,6 +297,7 @@ async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost
         }
         lastStatus = status;
       }
+      if (status === 'running') statusWord = seenContent.size === 0 ? 'no logs yet' : 'running';
 
       try {
         const logData = await callApi(`/deployments/${depId}/logs`, {
@@ -339,6 +344,8 @@ async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost
           exitCode,
           runtimeMs: Date.now() - startMs,
           failureType: classifyFailure(status, exitCode),
+          failureClass: dep.failure_class ?? null,
+          nextAction: dep.next_action ?? null,
         };
       }
     }
@@ -357,6 +364,7 @@ const _KNOWN_RUN_FLAGS = new Set([
   '--detach', '--fallback', '--no-fallback', '--strict-capacity',
   '--no-expanded-search', '--max-runtime', '--max-cost', '--min-vram', '--env',
   '--dry-run', '--cmd', '--save', '--workspace',
+  '--output', '--checkpoint', '--retry-safe', '--resume-cmd',
 ]);
 
 // Directories and files always excluded from project zip uploads.
@@ -497,10 +505,43 @@ export async function runCommand(config, args, chalk) {
   const isGitHubUrl  = firstArg && _isGitHubUrl(firstArg);
   const isCodeSource = isLocalPath || isGitHubUrl;
 
+  // Local paths can be inspected on disk, so a missing --cmd doesn't have to be
+  // an error — try to infer it (and output/checkpoint conventions) the same way
+  // `badgr detect .` would, before ever provisioning anything.
+  let detectionReport = null;
+  if (isLocalPath && !flags.cmd) {
+    detectionReport = detectWorkload(firstArg);
+    if (detectionReport.command && detectionReport.confidence !== 'low') {
+      flags.cmd = detectionReport.command;
+      console.log(chalk.dim(`\n  Detected command (${detectionReport.confidence} confidence): ${detectionReport.command}`));
+      console.log(chalk.dim(`  Workload: ${workloadTypeLabel(detectionReport.workloadType)}  •  badgr detect . for the full report  •  --cmd to override`));
+    }
+    if (!flags.output && detectionReport.outputs?.length) flags.output = detectionReport.outputs[0];
+    if (!flags.checkpoint && detectionReport.checkpoints?.length) flags.checkpoint = detectionReport.checkpoints[0];
+  }
+
+  // Detection couldn't confidently name a command — ask for just that one
+  // missing essential (interactively, if we have a terminal to ask on).
+  if (isLocalPath && !flags.cmd && process.stdin.isTTY && process.stdout.isTTY) {
+    console.log(chalk.dim(`\n  Badgr couldn't confidently detect a command to run in ${path.resolve(firstArg)}.`));
+    try {
+      const { input } = await import('@inquirer/prompts');
+      const answer = await input({
+        message: 'Which command should run?',
+        default: detectionReport?.command || undefined,
+        validate: v => v.trim() ? true : 'A command is required',
+      });
+      flags.cmd = answer.trim();
+    } catch {
+      // Ctrl+C or a non-interactive stdin that lied about isTTY — fall through to the hard error below.
+    }
+  }
+
   if (isCodeSource && !flags.cmd) {
     console.error(chalk.red(`\n  ✗ --cmd is required when running from a ${isLocalPath ? 'local path' : 'GitHub URL'}.\n`));
     if (isLocalPath) {
       console.error(chalk.dim('  Example: badgr run . --cmd "python train.py" --max-cost 5\n'));
+      console.error(chalk.dim('  Or check what Badgr detects first: badgr detect .\n'));
     } else {
       console.error(chalk.dim('  Example: badgr run https://github.com/user/repo --cmd "python train.py" --max-cost 5\n'));
     }
@@ -550,6 +591,20 @@ export async function runCommand(config, args, chalk) {
     return;
   }
 
+  if (!flags.maxCost && !flags.dryRun && isLocalPath && process.stdin.isTTY && process.stdout.isTTY) {
+    try {
+      const { input } = await import('@inquirer/prompts');
+      const answer = await input({
+        message: 'What max cost ($) should cap this run?',
+        default: '5',
+        validate: v => (Number.isFinite(parseFloat(v)) && parseFloat(v) > 0) ? true : 'Enter a number greater than 0',
+      });
+      flags.maxCost = parseFloat(answer);
+    } catch {
+      // fall through to the hard error below
+    }
+  }
+
   if (!flags.maxCost && !flags.dryRun) {
     console.error(chalk.red('\n  ✗ --max-cost is required for run workloads.\n'));
     console.error(chalk.dim('  Example: badgr run --gpu RTX_4090 --image node:20 --max-cost 5 -- node script.js\n'));
@@ -578,7 +633,16 @@ export async function runCommand(config, args, chalk) {
   const maxRuntimeMs = effectiveMaxRuntime * 60 * 1000;
 
   const maxCost      = flags.maxCost ?? null;
-  const envObj       = parseEnvFlag(flags.env);
+  // BADGR_OUTPUT_DIR / BADGR_CHECKPOINT_DIR / BADGR_RETRY_SAFE are a
+  // convention for custom.run containers to write recoverable state outside
+  // the pod — Badgr doesn't enforce what the container does with them, it
+  // just wires the directories through and surfaces --resume-cmd on failure.
+  // Explicit --env always wins if the user passes the same key directly.
+  const conventionEnv = {};
+  if (flags.output)     conventionEnv.BADGR_OUTPUT_DIR = flags.output;
+  if (flags.checkpoint) conventionEnv.BADGR_CHECKPOINT_DIR = flags.checkpoint;
+  if (flags.retrySafe)  conventionEnv.BADGR_RETRY_SAFE = '1';
+  const envObj       = { ...conventionEnv, ...parseEnvFlag(flags.env) };
   const effectiveTier = normalizeTier(flags.tier);
 
   const gpu = flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : undefined;
@@ -595,6 +659,10 @@ export async function runCommand(config, args, chalk) {
     if (maxCost)          console.log(`  ${chalk.bold('Max cost:')}     $${maxCost}`);
     if (flags.maxPrice)   console.log(`  ${chalk.bold('Max price:')}    $${flags.maxPrice}/hr`);
     if (flags.env?.length) console.log(`  ${chalk.bold('Env:')}         ${flags.env.join(', ')}`);
+    if (flags.output)     console.log(`  ${chalk.bold('Output:')}       ${flags.output}`);
+    if (flags.checkpoint) console.log(`  ${chalk.bold('Checkpoint:')}   ${flags.checkpoint}`);
+    if (flags.retrySafe)  console.log(`  ${chalk.bold('Retry-safe:')}   enabled`);
+    if (flags.resumeCmd)  console.log(`  ${chalk.bold('Resume cmd:')}   ${flags.resumeCmd}`);
     console.log(chalk.dim('\n  Remove --dry-run to provision.\n'));
     return;
   }
@@ -605,17 +673,20 @@ export async function runCommand(config, args, chalk) {
   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 (gpu)          console.log(`  ${chalk.bold('GPU:')}      ${gpu}`);
-  else              console.log(`  ${chalk.bold('GPU:')}      ${chalk.dim('auto')}`);
+  if (flags.gpu)    console.log(`  ${chalk.bold('GPU:')}      ${gpu}`);
   if (flags.minVram)  console.log(`  ${chalk.bold('Min VRAM:')}   ${flags.minVram} GB`);
   const runtimeLabel = isDefaultRuntime
-    ? `${effectiveMaxRuntime}min ${chalk.dim('(default — use --max-runtime N to override)')}`
-    : `${effectiveMaxRuntime}min`;
+    ? `${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')}`);
   console.log(`  ${chalk.bold('Max runtime:')} ${runtimeLabel}`);
-  if (maxCost)        console.log(`  ${chalk.bold('Max cost:')}    $${maxCost.toFixed(2)}`);
+  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.output)     console.log(`  ${chalk.bold('Output:')}     ${flags.output}`);
+  if (flags.checkpoint) console.log(`  ${chalk.bold('Checkpoint:')} ${flags.checkpoint}`);
+  if (flags.retrySafe)  console.log(`  ${chalk.bold('Retry-safe:')} enabled`);
   console.log();
 
 
@@ -636,6 +707,10 @@ export async function runCommand(config, args, chalk) {
     }
   }
 
+  // Total stages: local-path runs get a "Preparing upload" stage the others don't.
+  const STAGE_TOTAL = isLocalPath ? 5 : 4;
+  let stageN = 1;
+
   // ── Upload local project zip (Flow 1) ─────────────────────────────────────
   let codeUri = null;
   if (isLocalPath) {
@@ -646,9 +721,10 @@ export async function runCommand(config, args, chalk) {
       process.exitCode = 1;
       return;
     }
+    console.log(chalk.dim(_stageDone(stageN, STAGE_TOTAL, 'Preparing upload...')));
+    stageN++;
   }
 
-  console.log(chalk.dim('  Finding suitable capacity...'));
   if (process.env.BADGR_DEBUG === '1' || process.env.BADGR_DEBUG === 'true') {
     console.log(chalk.dim(`  API: ${config.baseUrl}`));
   }
@@ -717,12 +793,10 @@ export async function runCommand(config, args, chalk) {
 
   const rate = dep.cost_per_hour || 0;
 
-  console.log(chalk.dim('  Capacity found.\n'));
-  console.log(chalk.bold(`  Job ID:    ${chalk.cyan(dep.deployment_id)}`));
-  console.log(`  ${chalk.bold('GPU:')}      ${dep.gpu_type} × ${dep.gpu_count}`);
-  if (rate > 0) console.log(`  ${chalk.bold('Rate:')}     $${rate.toFixed(2)}/hr`);
-  if (maxCost)  console.log(`  ${chalk.bold('Max cost:')} $${maxCost.toFixed(2)}`);
-  console.log(`  ${chalk.bold('Receipt:')}  ${chalk.dim(rcptId)}`);
+  console.log(chalk.dim(_stageDone(stageN, STAGE_TOTAL, 'Finding a working route...')));
+  stageN++;
+  console.log(chalk.dim(_stageDone(stageN, STAGE_TOTAL, 'Starting runtime...')));
+  stageN++;
 
   if (rate > HIGH_RATE_THRESHOLD && !maxCost) {
     console.log(chalk.yellow(`\n  Selected capacity rate: $${rate.toFixed(2)}/hr`));
@@ -745,30 +819,35 @@ export async function runCommand(config, args, chalk) {
     if (teardownCalled) return;
     teardownCalled = true;
 
-    const labels = {
-      'max-runtime':    chalk.yellow('\n  ⏱ Max runtime reached — stopping job...'),
-      'max-cost':       chalk.yellow('\n  💰 Spend cap reached — stopping job...'),
-      'heartbeat-lost': chalk.red('\n  ✗ No response from machine — stopping job...'),
-      'interrupted':    chalk.yellow('\n  Stopping job...'),
+    const stageLabels = {
+      'max-runtime':    'Stopped — runtime cap reached',
+      'max-cost':       'Stopped — spend cap reached',
+      'heartbeat-lost': 'Failed — lost connection to machine',
+      'interrupted':    'Stopped',
     };
-    console.log(labels[reason] ?? chalk.yellow('\n  Stopping job...'));
 
+    let teardownOk = true;
     try {
       await terminateDeployment(config, dep.deployment_id);
     } catch {
       // terminateDeployment retries 3×; best-effort if all fail
+      teardownOk = false;
     }
 
     const runtimeMs = Date.now() - attachStart;
     const finalCost = ratePerHour * (runtimeMs / 3_600_000);
     updateReceipt(rcptId, {
       status: reason,
-      teardownStatus: 'terminated',
+      teardownStatus: teardownOk ? 'terminated' : 'failed',
       runtimeSeconds: Math.round(runtimeMs / 1000),
       finalCost,
     });
-    console.log(chalk.dim(`  Runtime: ${fmtRuntime(runtimeMs)}  •  Est. cost: $${finalCost.toFixed(4)}`));
-    console.log(chalk.dim('  Job stopped. Billing ended.\n'));
+    console.log();
+    console.log(chalk.dim(_stage(STAGE_TOTAL, STAGE_TOTAL, stageLabels[reason] ?? 'Stopped')));
+    console.log(chalk.dim(`  Runtime: ${fmtRuntime(runtimeMs)}  •  Estimated cost: ~$${finalCost.toFixed(2)}`));
+    _printFinalInfo(chalk, { exitCode: null, teardownOk, jobId: dep.deployment_id, rcptId });
+    if (flags.resumeCmd) console.log(`  ${chalk.bold('Resume:')}    ${flags.resumeCmd}`);
+    console.log();
   }
 
   // ── SIGINT handler — installed immediately after we have a deployment ID ───
@@ -798,20 +877,23 @@ export async function runCommand(config, args, chalk) {
   if (dep.status === 'failed') {
     process.removeListener('SIGINT', handleShutdown);
     console.error(formatCliError('JOB_INFRASTRUCTURE_FAILURE', { receiptId: rcptId }, chalk));
+    _printFailureClass(chalk, dep);
     process.exitCode = 1;
     return;
   }
 
-  console.log(chalk.dim('\n  ── Running command (Ctrl+C to stop) ────────────────────────────\n'));
+  const runStageLine = _stage(stageN, STAGE_TOTAL, 'Running command...');
+  console.log(chalk.dim(`\n  [${stageN}/${STAGE_TOTAL}] Running command (Ctrl+C to stop)`));
 
   attachStart = Date.now();
-  const { status: finalStatus, exitCode, runtimeMs, failureType } = await attachToJob(config, dep.deployment_id, {
+  const { status: finalStatus, exitCode, runtimeMs, failureType, failureClass, nextAction } = await attachToJob(config, dep.deployment_id, {
     chalk,
     maxRuntimeMs,
     maxCost,
     ratePerHour,
     onTeardown: teardown,
     isShuttingDown: () => shuttingDown,
+    stageLine: runStageLine,
   });
 
   // Remove SIGINT handler — job is done (or SIGINT was handled)
@@ -820,7 +902,11 @@ export async function runCommand(config, args, chalk) {
   // 'interrupted' = SIGINT handler is managing teardown + exit — don't duplicate
   if (finalStatus === 'interrupted') return;
 
-  console.log();
+  // 'capped' = max-runtime or max-cost path; teardown() already printed the full summary
+  if (finalStatus === 'capped') {
+    process.exitCode = 1;
+    return;
+  }
 
   const finalCost = ratePerHour * (runtimeMs / 3_600_000);
   updateReceipt(rcptId, {
@@ -832,20 +918,7 @@ export async function runCommand(config, args, chalk) {
     teardownStatus: (finalStatus === 'completed' || finalStatus === 'succeeded') ? 'terminated' : 'failed',
   });
 
-  console.log(`  ${chalk.bold('Runtime:')}  ${fmtRuntime(runtimeMs)}`);
-  if (ratePerHour > 0) {
-    console.log(`  ${chalk.bold('Cost:')}     $${finalCost.toFixed(4)}  (${chalk.dim(`$${ratePerHour.toFixed(2)}/hr`)})`);
-  }
-  if (exitCode !== null && exitCode !== undefined) {
-    console.log(`  ${chalk.bold('Exit code:')} ${exitCode !== 0 ? chalk.red(exitCode) : chalk.green(exitCode)}`);
-  }
-  console.log(`  ${chalk.bold('Receipt:')}  ${chalk.dim(rcptId)}`);
-
-  // 'capped' = max-runtime or max-cost path; teardown message already printed
-  if (finalStatus === 'capped') {
-    process.exitCode = 1;
-    return;
-  }
+  console.log();
 
   if (finalStatus === 'failed' || (exitCode !== null && exitCode !== 0)) {
     if (failureType === 'infrastructure') {
@@ -853,16 +926,25 @@ export async function runCommand(config, args, chalk) {
     } else {
       console.error(formatCliError('JOB_FAILED', { exitCode, deploymentId: dep.deployment_id }, chalk));
     }
+    _printFailureClass(chalk, { failure_class: failureClass, next_action: nextAction });
+    console.log(chalk.dim(_stage(STAGE_TOTAL, STAGE_TOTAL, 'Failed')));
+    console.log(chalk.dim(`  Runtime: ${fmtRuntime(runtimeMs)}  •  Estimated cost: ~$${finalCost.toFixed(2)}`));
+    // The container already reached a terminal state on the provider side by the
+    // time we observe it here, so billing is already stopped — no extra teardown call needed.
+    _printFinalInfo(chalk, { exitCode, teardownOk: true, jobId: dep.deployment_id, rcptId });
+    if (flags.resumeCmd) console.log(`  ${chalk.bold('Resume:')}    ${flags.resumeCmd}`);
     process.exitCode = exitCode ?? 1;
     return;
   }
 
   if ((finalStatus === 'completed' || finalStatus === 'succeeded') && (exitCode === 0 || exitCode === null)) {
+    let teardownOk = true;
     try {
       await terminateDeployment(config, dep.deployment_id);
-    } catch { /* already stopped */ }
-    console.log(chalk.green(`\n  ✓ Complete`));
-    console.log(chalk.dim(`  Billing ended`));
+    } 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)}`));
+    _printFinalInfo(chalk, { exitCode, teardownOk, jobId: dep.deployment_id, rcptId });
 
     if (flags.save && config.apiKey) {
       try {