badgr-cli 1.0.44 → 1.0.46

package/tests/detect.test.js

@@ -0,0 +1,191 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { detectWorkload, workloadTypeLabel } from '../src/detect.js';
+
+let tmpRoot;
+
+function makeProject(files) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'badgr-detect-'));
+  for (const [rel, content] of Object.entries(files)) {
+    const abs = path.join(dir, rel);
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, content);
+  }
+  return dir;
+}
+
+beforeEach(() => { tmpRoot = []; });
+afterEach(() => {
+  for (const dir of tmpRoot) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+function project(files) {
+  const dir = makeProject(files);
+  tmpRoot.push(dir);
+  return dir;
+}
+
+describe('detectWorkload — missing / empty directory', () => {
+  it('reports an error without throwing for a missing directory', () => {
+    const report = detectWorkload('/nonexistent/badgr-detect-fixture');
+    expect(report.error).toBeTruthy();
+    expect(report.confidence).toBe('low');
+  });
+
+  it('is low confidence with no command for an empty directory', () => {
+    const dir = project({});
+    const report = detectWorkload(dir);
+    expect(report.command).toBeNull();
+    expect(report.confidence).toBe('low');
+  });
+});
+
+describe('detectWorkload — plain Python CUDA script', () => {
+  it('finds the entry point and requirements, classifies as custom', () => {
+    const dir = project({
+      'train.py': `
+import torch
+model = torch.nn.Linear(10, 10).cuda()
+for step in range(100):
+    optimizer.step()
+`,
+      'requirements.txt': 'torch\nnumpy\n',
+      'output/.gitkeep': '',
+    });
+    const report = detectWorkload(dir);
+    expect(report.command).toBe('python train.py');
+    expect(report.requirements).toContain('requirements.txt');
+    expect(report.outputs).toContain('output/');
+    expect(report.workloadType).toBe('training');
+    expect(['medium', 'high']).toContain(report.confidence);
+  });
+});
+
+describe('detectWorkload — vLLM endpoint', () => {
+  it('classifies as endpoint and detects the port', () => {
+    const dir = project({
+      'server.py': `
+from vllm import LLM
+import uvicorn
+app = None
+
+if __name__ == "__main__":
+    uvicorn.run(app, port=8000)
+`,
+      'requirements.txt': 'vllm\nfastapi\nuvicorn\n',
+    });
+    const report = detectWorkload(dir);
+    expect(report.command).toBe('python server.py');
+    expect(report.workloadType).toBe('endpoint');
+    expect(report.ports).toContain(8000);
+    expect(report.healthPath).toBe('/health');
+  });
+});
+
+describe('detectWorkload — LoRA training repo', () => {
+  it('classifies as training and estimates high VRAM for a large model', () => {
+    const dir = project({
+      'train.py': `
+from peft import LoraConfig
+base_model = "meta-llama/Llama-3.1-70B-Instruct"
+trainer = Trainer(model=model)
+trainer.train()
+`,
+      'config.yaml': 'base_model: meta-llama/Llama-3.1-70B-Instruct\nlora_r: 16\n',
+      'requirements.txt': 'peft\ntransformers\naccelerate\n',
+      'checkpoints/.gitkeep': '',
+    });
+    const report = detectWorkload(dir);
+    expect(report.workloadType).toBe('training');
+    expect(report.checkpoints).toContain('checkpoints/');
+    expect(report.models.some(m => m.includes('Llama-3.1-70B'))).toBe(true);
+    expect(report.vram).toBe('80+ GB');
+  });
+});
+
+describe('detectWorkload — ComfyUI-style project', () => {
+  it('classifies as image_gen from a workflow json without special-casing ComfyUI by name', () => {
+    const dir = project({
+      'workflow_api.json': JSON.stringify({ '1': { class_type: 'CheckpointLoaderSimple' } }),
+      'requirements.txt': 'torch\npillow\n',
+    });
+    const report = detectWorkload(dir);
+    expect(report.workloadType).toBe('image_gen');
+    expect(workloadTypeLabel(report.workloadType)).toMatch(/image generation/);
+  });
+});
+
+describe('detectWorkload — custom Docker image', () => {
+  it('detects the Dockerfile and exposed port instead of guessing a base image', () => {
+    const dir = project({
+      Dockerfile: `
+FROM python:3.11-slim
+COPY . /app
+EXPOSE 7860
+CMD ["python", "app.py"]
+`,
+      'app.py': `
+import gradio as gr
+demo = gr.Interface()
+demo.launch(server_port=7860)
+`,
+    });
+    const report = detectWorkload(dir);
+    expect(report.dockerfile).toBe('Dockerfile');
+    expect(report.image).toBeNull();
+    expect(report.ports).toContain(7860);
+    expect(report.workloadType).toBe('endpoint');
+  });
+});
+
+describe('detectWorkload — RunPod-style serverless handler job', () => {
+  it('classifies a handler-based job as an endpoint without naming any provider', () => {
+    const dir = project({
+      'rp_handler.py': `
+import runpod
+
+def handler(event):
+    return {"output": "ok"}
+
+runpod.serverless.start({"handler": handler})
+`,
+      'requirements.txt': 'runpod\n',
+    });
+    const report = detectWorkload(dir);
+    expect(report.command).toBe('python rp_handler.py');
+    expect(report.workloadType).toBe('endpoint');
+    // No provider name should leak into any user-visible field.
+    const serialized = JSON.stringify(report).toLowerCase();
+    expect(serialized).not.toContain('runpod.com');
+  });
+});
+
+describe('detectWorkload — batch image generation over an input directory', () => {
+  it('classifies as batch when the script iterates an input directory', () => {
+    const dir = project({
+      'generate.py': `
+import os
+for fname in os.listdir("input"):
+    process(fname)
+`,
+      'input/.gitkeep': '',
+      'output/.gitkeep': '',
+    });
+    const report = detectWorkload(dir);
+    expect(report.workloadType).toBe('batch');
+    expect(report.inputs).toContain('input/');
+    expect(report.outputs).toContain('output/');
+  });
+});
+
+describe('workloadTypeLabel', () => {
+  it('never returns a provider-specific label', () => {
+    for (const t of ['endpoint', 'training', 'image_gen', 'batch', 'custom', 'unknown']) {
+      expect(workloadTypeLabel(t)).not.toMatch(/runpod|vast|hyperstack/i);
+    }
+  });
+});

package/tests/heartbeat.test.js

@@ -0,0 +1,70 @@
+/**
+ * badgr heartbeat — resets an endpoint's idle-timeout clock
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { heartbeatCommand } from '../src/commands/heartbeat.js';
+
+vi.mock('../src/api.js', () => ({
+  heartbeatDeployment: vi.fn(),
+}));
+
+vi.mock('../src/store.js', () => ({
+  findDeployment: vi.fn(() => null),
+}));
+
+vi.mock('../src/config.js', () => ({
+  requireApiKey: vi.fn(),
+}));
+
+import * as api   from '../src/api.js';
+import * as store from '../src/store.js';
+
+const config = { apiKey: 'sk-test', baseUrl: 'https://api.test/v1' };
+
+const chalk = {
+  bold:   s => s,
+  dim:    s => s,
+  red:    s => s,
+  yellow: s => s,
+  green:  s => s,
+  cyan:   s => s,
+};
+
+beforeEach(() => {
+  process.exitCode = undefined;
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+  vi.spyOn(console, 'error').mockImplementation(() => {});
+  vi.resetAllMocks();
+  store.findDeployment.mockReturnValue(null);
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  process.exitCode = undefined;
+});
+
+it('requires a deployment id', async () => {
+  await heartbeatCommand(config, [], chalk);
+  expect(api.heartbeatDeployment).not.toHaveBeenCalled();
+});
+
+it('calls heartbeatDeployment and prints confirmation', async () => {
+  api.heartbeatDeployment.mockResolvedValue({ deployment_id: 'dep-abc123', last_activity_at: 1700000000 });
+
+  const lines = [];
+  console.log.mockImplementation((...args) => lines.push(args.join(' ')));
+
+  await heartbeatCommand(config, ['dep-abc123'], chalk);
+
+  expect(api.heartbeatDeployment).toHaveBeenCalledWith(config, 'dep-abc123');
+  expect(lines.some(l => l.includes('Heartbeat recorded for dep-abc123'))).toBe(true);
+  expect(process.exitCode).toBeFalsy();
+});
+
+it('reports an error and sets exitCode on failure', async () => {
+  api.heartbeatDeployment.mockRejectedValue(new Error('deployment not found'));
+
+  await heartbeatCommand(config, ['dep-missing'], chalk);
+
+  expect(process.exitCode).toBe(1);
+});

package/tests/job-progress-poll.test.js

@@ -0,0 +1,136 @@
+import { describe, it, expect, vi } from 'vitest';
+import { pollJobUntilTerminal, renderJobClosingBlock } from '../src/progress.js';
+
+const chalk = new Proxy({}, { get: () => (s) => s });
+const config = { apiKey: 'k', baseUrl: 'https://api.test' };
+
+function silenceStdout() {
+  return vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+}
+
+describe('pollJobUntilTerminal', () => {
+  it('returns immediately once the job reaches a terminal status', async () => {
+    const writeSpy = silenceStdout();
+    const detail = { job_id: 'job_1', status: 'completed', stage_label: 'Complete', health: 'completed' };
+    const callApi = vi.fn().mockResolvedValue(detail);
+
+    const result = await pollJobUntilTerminal(callApi, config, 'job_1', { chalk, maxMs: 60_000, pollMs: 1 });
+
+    expect(result.outcome).toBe('completed');
+    expect(result.detail).toBe(detail);
+    writeSpy.mockRestore();
+  });
+
+  it('surfaces progress fields (stage/current/total) while polling', async () => {
+    const writeSpy = silenceStdout();
+    const callApi = vi.fn()
+      .mockResolvedValueOnce({ job_id: 'job_2', status: 'running', stage_label: 'Generating images', progress_current: 3, progress_total: 10, progress_unit: 'images', health: 'progressing' })
+      .mockResolvedValueOnce({ job_id: 'job_2', status: 'completed', stage_label: 'Complete', health: 'completed' });
+
+    const result = await pollJobUntilTerminal(callApi, config, 'job_2', { chalk, maxMs: 60_000, pollMs: 1 });
+
+    expect(result.outcome).toBe('completed');
+    const output = writeSpy.mock.calls.map(c => c[0]).join('');
+    expect(output).toContain('3/10 images');
+    writeSpy.mockRestore();
+  });
+
+  it('does not swallow repeated poll failures silently — gives up and reports polling_failed', async () => {
+    const writeSpy = silenceStdout();
+    const callApi = vi.fn().mockRejectedValue(new Error('network down'));
+
+    const result = await pollJobUntilTerminal(callApi, config, 'job_3', { chalk, maxMs: 60_000, pollMs: 1 });
+
+    expect(result.outcome).toBe('polling_failed');
+    // Must have warned the user at least once instead of looping silently.
+    const output = writeSpy.mock.calls.map(c => c[0]).join('');
+    expect(output).toMatch(/Lost contact/i);
+    writeSpy.mockRestore();
+  });
+
+  it('announces a retry-on-a-different-route once, with teardown/billing status', async () => {
+    const writeSpy = silenceStdout();
+    const callApi = vi.fn()
+      .mockResolvedValueOnce({
+        job_id: 'job_retry', status: 'running', stage: 'retrying_different_route',
+        stage_label: 'Retrying on a different route', health: 'progressing',
+        progress_message: 'Retrying on a different route... attempt 2/2',
+        teardown_status: 'ok',
+      })
+      .mockResolvedValueOnce({
+        job_id: 'job_retry', status: 'completed', stage_label: 'Complete', health: 'completed',
+      });
+
+    const result = await pollJobUntilTerminal(callApi, config, 'job_retry', { chalk, maxMs: 60_000, pollMs: 1 });
+
+    expect(result.outcome).toBe('completed');
+    const output = writeSpy.mock.calls.map(c => c[0]).join('');
+    expect(output).toContain('Retrying on a different route... attempt 2/2');
+    expect(output).toContain('Previous attempt teardown: succeeded');
+    expect(output).toContain('Billing: stopped');
+    writeSpy.mockRestore();
+  });
+
+  it('recovers from transient poll failures once the API responds again', async () => {
+    const writeSpy = silenceStdout();
+    const callApi = vi.fn()
+      .mockRejectedValueOnce(new Error('timeout'))
+      .mockRejectedValueOnce(new Error('timeout'))
+      .mockResolvedValueOnce({ job_id: 'job_4', status: 'completed', stage_label: 'Complete', health: 'completed' });
+
+    const result = await pollJobUntilTerminal(callApi, config, 'job_4', { chalk, maxMs: 60_000, pollMs: 1 });
+
+    expect(result.outcome).toBe('completed');
+    writeSpy.mockRestore();
+  });
+});
+
+describe('renderJobClosingBlock', () => {
+  it('shows teardown/billing/logs/receipt for a completed job', () => {
+    const block = renderJobClosingBlock(chalk, {
+      job_id: 'job_5', status: 'completed', elapsed_seconds: 252,
+      charged_usd: 0.08, teardown_status: 'ok', billing_status: 'stopped',
+    }, 'rcpt-abc');
+
+    expect(block).toContain('Complete');
+    expect(block).toContain('Teardown: succeeded');
+    expect(block).toContain('Billing: stopped');
+    expect(block).toContain('badgr logs job_5');
+    expect(block).toContain('badgr receipts rcpt-abc');
+  });
+
+  it('shows failure class, stage, and next action for a failed job', () => {
+    const block = renderJobClosingBlock(chalk, {
+      job_id: 'job_6', status: 'failed', elapsed_seconds: 1112,
+      error: { code: 'comfy_health_failed', message: 'ComfyUI did not start within 10 minutes.' },
+      failure_class: 'health_check_failed', stage: 'comfy_waiting_for_health',
+      teardown_status: 'ok', billing_status: 'stopped',
+      next_action: 'Run `badgr logs <job_id>` or retry with a longer max-runtime.',
+    });
+
+    expect(block).toContain('Failed');
+    expect(block).toContain('Class: health_check_failed');
+    expect(block).toContain('Stage: comfy_waiting_for_health');
+    expect(block).toContain('Next:');
+  });
+
+  it('labels a runtime/spend cap failure as "Stopped — limit reached", not a crash', () => {
+    const block = renderJobClosingBlock(chalk, {
+      job_id: 'job_7', status: 'failed', elapsed_seconds: 545,
+      error: { code: 'max_runtime_reached', message: 'Job reached max runtime and was stopped. Billing ended.' },
+      failure_class: 'runtime_cap_reached',
+      teardown_status: 'ok', billing_status: 'stopped',
+    });
+
+    expect(block).toContain('Stopped — limit reached');
+  });
+
+  it('shows cancelled block distinctly from failed', () => {
+    const block = renderJobClosingBlock(chalk, {
+      job_id: 'job_8', status: 'canceled', elapsed_seconds: 164,
+      teardown_status: 'ok', billing_status: 'stopped',
+    });
+
+    expect(block).toContain('Cancelled by user');
+  });
+});

package/tests/productized-runners.test.js

@@ -131,6 +131,13 @@ describe('BLESSED_COMFY_WORKFLOWS catalog', () => {
     expect(wf.gpu_type).toBe('RTX_4090');
     expect(wf.output_type).toBe('images');
   });
+
+  it('has flux-basic with gpu_type and output_type', () => {
+    const wf = BLESSED_COMFY_WORKFLOWS['flux-basic'];
+    expect(wf).toBeDefined();
+    expect(wf.gpu_type).toBe('RTX_4090');
+    expect(wf.output_type).toBe('images');
+  });
 });
 
 // ── parseServeArgs alias recognition ─────────────────────────────────────────

package/tests/restart.test.js

@@ -0,0 +1,88 @@
+/**
+ * badgr restart — relaunches an endpoint with the same config and API key
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { restartCommand } from '../src/commands/restart.js';
+
+vi.mock('../src/api.js', () => ({
+  restartDeployment: vi.fn(),
+}));
+
+vi.mock('../src/store.js', () => ({
+  findDeployment:    vi.fn(() => null),
+  removeDeployment:  vi.fn(),
+  addDeployment:     vi.fn(),
+  addReceipt:        vi.fn(),
+  generateReceiptId: vi.fn(() => 'rcpt-restart-001'),
+}));
+
+vi.mock('../src/config.js', () => ({
+  requireApiKey: vi.fn(),
+}));
+
+import * as api   from '../src/api.js';
+import * as store from '../src/store.js';
+
+const config = { apiKey: 'sk-test', baseUrl: 'https://api.test/v1' };
+
+const chalk = {
+  bold:   s => s,
+  dim:    s => s,
+  red:    s => s,
+  yellow: s => s,
+  green:  s => s,
+  cyan:   s => s,
+};
+
+beforeEach(() => {
+  process.exitCode = undefined;
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+  vi.spyOn(console, 'error').mockImplementation(() => {});
+  vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+  vi.resetAllMocks();
+  store.findDeployment.mockReturnValue(null);
+  store.generateReceiptId.mockReturnValue('rcpt-restart-001');
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  process.exitCode = undefined;
+});
+
+it('requires a deployment id', async () => {
+  await restartCommand(config, [], chalk);
+  expect(api.restartDeployment).not.toHaveBeenCalled();
+});
+
+it('calls restartDeployment and prints the new deployment id and URL', async () => {
+  api.restartDeployment.mockResolvedValue({
+    deployment_id: 'dep-new-002',
+    workload_type: 'endpoint',
+    model: 'Qwen/Qwen2.5-7B-Instruct',
+    gpu_type: 'L40S',
+    gpu_count: 1,
+    status: 'provisioning',
+    endpoint_url: 'https://dep-new-002.aibadgr.com/v1',
+    cost_per_hour: 1.2,
+  });
+
+  const lines = [];
+  console.log.mockImplementation((...args) => lines.push(args.join(' ')));
+
+  await restartCommand(config, ['dep-old-001'], chalk);
+
+  expect(api.restartDeployment).toHaveBeenCalledWith(config, 'dep-old-001');
+  expect(store.removeDeployment).toHaveBeenCalledWith('dep-old-001');
+  expect(store.addDeployment).toHaveBeenCalledWith(expect.objectContaining({ id: 'dep-new-002' }));
+  expect(lines.some(l => l.includes('dep-new-002'))).toBe(true);
+  expect(lines.some(l => l.includes('https://dep-new-002.aibadgr.com/v1'))).toBe(true);
+  expect(process.exitCode).toBeFalsy();
+});
+
+it('reports an error and sets exitCode on failure', async () => {
+  api.restartDeployment.mockRejectedValue(new Error('deployment not found'));
+
+  await restartCommand(config, ['dep-missing'], chalk);
+
+  expect(process.exitCode).toBe(1);
+});

package/tests/run-lifecycle.test.js

@@ -15,7 +15,7 @@
  *   - Receipt explains state   → status, exitCode, failureType, runtimeSeconds, finalCost
  */
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { runCommand } from '../src/commands/run.js';
+import { runCommand, parseRunArgs } from '../src/commands/run.js';
 
 // ── Module mocks ──────────────────────────────────────────────────────────────
 
@@ -222,6 +222,26 @@ describe('container fails to start', () => {
 
     expect(process.exitCode).toBe(1);
   });
+
+  it('prints the backend failure_class/next_action using the same vocabulary as the job API', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeDep({ status: 'provisioning' }))
+      .mockResolvedValueOnce({
+        status: 'failed',
+        failure_class: 'container_start_failed',
+        next_action: 'Check the image and command, then retry.',
+      });
+    const logs = [];
+    const origError = console.error;
+    console.error = (...args) => { logs.push(args.join(' ')); origError(...args); };
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
+    await vi.advanceTimersByTimeAsync(4000);
+    await p;
+    console.error = origError;
+
+    expect(logs.some(l => l.includes('Class: container_start_failed'))).toBe(true);
+    expect(logs.some(l => l.includes('Next: Check the image and command, then retry.'))).toBe(true);
+  });
 });
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -543,3 +563,93 @@ describe('--dry-run', () => {
     expect(api.callApi).not.toHaveBeenCalled();
   });
 });
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 13. Progress-loss handling — --output / --checkpoint / --retry-safe / --resume-cmd
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('--output / --checkpoint / --retry-safe / --resume-cmd', () => {
+  it('parseRunArgs parses all four flags', () => {
+    const { flags } = parseRunArgs([
+      '--output', './outputs', '--checkpoint', './checkpoints', '--retry-safe',
+      '--resume-cmd', 'python train.py --resume ./checkpoints/latest',
+      '--max-cost', '5', '--', 'python', 'train.py',
+    ]);
+    expect(flags.output).toBe('./outputs');
+    expect(flags.checkpoint).toBe('./checkpoints');
+    expect(flags.retrySafe).toBe(true);
+    expect(flags.resumeCmd).toBe('python train.py --resume ./checkpoints/latest');
+  });
+
+  it('wires --output/--checkpoint/--retry-safe into the job env as BADGR_* vars', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeDep())
+      .mockResolvedValueOnce({ status: 'completed', exit_code: 0 })
+      .mockResolvedValueOnce({ logs: [] });
+    const p = runCommand(config, [
+      '--output', './outputs', '--checkpoint', './checkpoints', '--retry-safe',
+      '--max-cost', '5', '--', 'python', 'train.py',
+    ], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    const postRunBody = api.callApi.mock.calls[0][1].body;
+    expect(postRunBody.env).toEqual(expect.objectContaining({
+      BADGR_OUTPUT_DIR: './outputs',
+      BADGR_CHECKPOINT_DIR: './checkpoints',
+      BADGR_RETRY_SAFE: '1',
+    }));
+  });
+
+  it('explicit --env overrides the BADGR_* convention var for the same key', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeDep())
+      .mockResolvedValueOnce({ status: 'completed', exit_code: 0 })
+      .mockResolvedValueOnce({ logs: [] });
+    const p = runCommand(config, [
+      '--output', './outputs', '--env', 'BADGR_OUTPUT_DIR=./custom-outputs',
+      '--max-cost', '5', '--', 'python', 'train.py',
+    ], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    const postRunBody = api.callApi.mock.calls[0][1].body;
+    expect(postRunBody.env.BADGR_OUTPUT_DIR).toBe('./custom-outputs');
+  });
+
+  it('prints the --resume-cmd hint when the job fails', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeDep())
+      .mockResolvedValueOnce({ status: 'failed', exit_code: 1 })
+      .mockResolvedValueOnce({ logs: [] });
+    const logs = [];
+    const captureChalk = { bold: s => s, dim: s => s, red: s => s, yellow: s => s, green: s => s, cyan: s => s };
+    const origLog = console.log;
+    console.log = (...args) => { logs.push(args.join(' ')); origLog(...args); };
+    const p = runCommand(config, [
+      '--resume-cmd', 'python train.py --resume ./checkpoints/latest',
+      '--max-cost', '5', '--', 'python', 'train.py',
+    ], captureChalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+    console.log = origLog;
+
+    expect(logs.some(l => l.includes('python train.py --resume ./checkpoints/latest'))).toBe(true);
+  });
+
+  it('does not print a Resume line when --resume-cmd was not given', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeDep())
+      .mockResolvedValueOnce({ status: 'failed', exit_code: 1 })
+      .mockResolvedValueOnce({ logs: [] });
+    const logs = [];
+    const origLog = console.log;
+    console.log = (...args) => { logs.push(args.join(' ')); origLog(...args); };
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+    console.log = origLog;
+
+    expect(logs.some(l => l.includes('Resume:'))).toBe(false);
+  });
+});