badgr-cli 1.0.38 → 1.0.40

package/src/commands/workload.js

@@ -0,0 +1,197 @@
+import { callApi } from '../api.js';
+import { fmtRuntime } from './receipts.js';
+
+function fmtRate(n) {
+  return n != null ? `${(n * 100).toFixed(1)}%` : '—';
+}
+
+function fmtCost(n) {
+  return n != null ? `$${n.toFixed(4)}` : '—';
+}
+
+function printWorkload(w, chalk) {
+  const s = w.stats;
+  console.log(`  ${chalk.cyan(w.workload_id)}  ${chalk.bold(w.name)}  ${chalk.dim(w.job_type)}`);
+  if (w.tags) console.log(`    ${chalk.dim('tags:')} ${w.tags}`);
+  console.log(`    runs: ${s.run_count}  success: ${fmtRate(s.success_rate)}  avg cost: ${fmtCost(s.avg_cost_usd)}  avg runtime: ${fmtRuntime(s.avg_runtime_seconds)}`);
+  if (s.known_good_provider) {
+    console.log(`    last good route: ${s.known_good_provider} / ${s.known_good_gpu_type}`);
+  }
+  console.log();
+}
+
+async function apiRequest(config, path, opts = {}) {
+  return callApi(path, {
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl,
+    ...opts,
+  });
+}
+
+async function resolveWorkloadId(config, nameOrId) {
+  if (nameOrId.startsWith('wl_')) return nameOrId;
+  const data = await apiRequest(config, '/workloads?limit=100');
+  const match = (data?.workloads ?? []).find(x => x.name === nameOrId);
+  return match?.workload_id ?? null;
+}
+
+export async function workloadCommand(config, args, chalk) {
+  if (!config.apiKey) {
+    console.error(chalk.red('Not logged in. Run: badgr login'));
+    process.exit(1);
+  }
+
+  const sub = args[0];
+  const rest = args.slice(1);
+
+  if (!sub || sub === 'list') {
+    const limit = parseInt(rest[0] ?? '20', 10);
+    let data;
+    try {
+      data = await apiRequest(config, `/workloads?limit=${limit}`);
+    } catch (err) {
+      console.error(chalk.red(`Could not fetch workloads: ${err.message}`));
+      process.exit(1);
+    }
+    const workloads = data?.workloads ?? [];
+    if (workloads.length === 0) {
+      console.log(chalk.dim('\nNo saved workloads. Use `badgr run --save <name>` to create one.\n'));
+      return;
+    }
+    console.log(chalk.bold(`\nSaved Workloads  (${data.total} total)\n`));
+    workloads.forEach(w => printWorkload(w, chalk));
+    if (data.total > workloads.length) {
+      console.log(chalk.dim(`  … ${data.total - workloads.length} more. badgr workload list ${limit * 2}\n`));
+    }
+    return;
+  }
+
+  if (sub === 'info') {
+    const name = rest[0];
+    if (!name) {
+      console.error(chalk.red('Usage: badgr workload info <workload-id-or-name>'));
+      process.exit(1);
+    }
+    const id = await resolveWorkloadId(config, name);
+    if (!id) {
+      console.error(chalk.red(`Workload not found: ${name}`));
+      process.exit(1);
+    }
+    let w;
+    try {
+      w = await apiRequest(config, `/workloads/${id}`);
+    } catch {
+      console.error(chalk.red(`Workload not found: ${name}`));
+      process.exit(1);
+    }
+    console.log(chalk.bold(`\nWorkload: ${w.name}\n`));
+    console.log(`  ID:       ${chalk.cyan(w.workload_id)}`);
+    console.log(`  Type:     ${w.job_type}`);
+    console.log(`  Tags:     ${w.tags || '—'}`);
+    console.log(`  Default max cost:    $${w.default_max_cost}`);
+    console.log(`  Default max runtime: ${w.default_max_runtime_minutes}m`);
+    const s = w.stats;
+    console.log(chalk.bold('\n  Stats'));
+    console.log(`    Runs:          ${s.run_count}`);
+    console.log(`    Success rate:  ${fmtRate(s.success_rate)}`);
+    console.log(`    Avg cost:      ${fmtCost(s.avg_cost_usd)}`);
+    console.log(`    Avg runtime:   ${fmtRuntime(s.avg_runtime_seconds)}`);
+    console.log(`    Total cost:    ${fmtCost(s.total_cost_usd)}`);
+    if (s.recommended_route?.provider) {
+      console.log(`    Recommended:   ${s.recommended_route.provider} / ${s.recommended_route.gpu_type}`);
+      if (s.recommended_route.reason) console.log(`                   ${chalk.dim(s.recommended_route.reason)}`);
+    } else if (s.known_good_provider) {
+      console.log(`    Good route:    ${s.known_good_provider} / ${s.known_good_gpu_type}`);
+    }
+    if (s.bad_routes?.length) {
+      console.log(`    Bad routes:    ${s.bad_routes.map(r => `${r.provider}/${r.gpu_type}`).join(', ')}`);
+    }
+    if (s.last_failure_code) {
+      console.log(chalk.dim(`    Last failure:  ${s.last_failure_code}${s.last_failure_message ? ` — ${s.last_failure_message}` : ''}`));
+    }
+    if (w.recent_jobs?.length) {
+      console.log(chalk.bold('\n  Recent Jobs'));
+      w.recent_jobs.forEach(j => {
+        const cost = j.charged_usd != null ? ` $${j.charged_usd.toFixed(4)}` : '';
+        const rt = j.runtime_seconds != null ? ` ${fmtRuntime(j.runtime_seconds)}` : '';
+        const statusColor = j.status === 'completed' ? chalk.green : j.status === 'failed' ? chalk.red : chalk.yellow;
+        console.log(`    ${chalk.dim(j.job_id)}  ${statusColor(j.status)}${cost}${rt}`);
+      });
+    }
+    console.log();
+    return;
+  }
+
+  if (sub === 'run') {
+    const name = rest[0];
+    if (!name) {
+      console.error(chalk.red('Usage: badgr workload run <workload-id-or-name> [--max-cost N] [--max-runtime N]'));
+      process.exit(1);
+    }
+    // Parse overrides
+    const flags = {};
+    const overrides = {};
+    let i = 1;
+    while (i < rest.length) {
+      if (rest[i] === '--max-cost')     { flags.maxCost = parseFloat(rest[++i]); i++; continue; }
+      if (rest[i] === '--max-runtime')  { flags.maxRuntime = parseInt(rest[++i], 10); i++; continue; }
+      if (rest[i] === '--set') {
+        const kv = rest[++i]; i++;
+        const eq = kv.indexOf('=');
+        if (eq > 0) overrides[kv.slice(0, eq)] = kv.slice(eq + 1);
+        continue;
+      }
+      i++;
+    }
+
+    const workloadId = await resolveWorkloadId(config, name);
+    if (!workloadId) {
+      console.error(chalk.red(`Workload not found: ${name}`));
+      process.exit(1);
+    }
+
+    const body = { config_overrides: overrides };
+    if (flags.maxCost != null) body.max_cost = flags.maxCost;
+    if (flags.maxRuntime != null) body.max_runtime_minutes = flags.maxRuntime;
+
+    let result;
+    try {
+      result = await apiRequest(config, `/workloads/${workloadId}/run`, {
+        method: 'POST',
+        body,
+      });
+    } catch (err) {
+      console.error(chalk.red(`Run failed: ${err.message}`));
+      process.exit(1);
+    }
+    console.log(chalk.green(`\nJob submitted: ${result.job_id}`));
+    console.log(`  Status URL: ${result.status_url}`);
+    console.log(`  Estimated: $${result.estimated_cost_usd}\n`);
+    return;
+  }
+
+  if (sub === 'delete') {
+    const name = rest[0];
+    if (!name) {
+      console.error(chalk.red('Usage: badgr workload delete <workload-id-or-name>'));
+      process.exit(1);
+    }
+    const workloadId = await resolveWorkloadId(config, name);
+    if (!workloadId) {
+      console.error(chalk.red(`Workload not found: ${name}`));
+      process.exit(1);
+    }
+    try {
+      await apiRequest(config, `/workloads/${workloadId}`, { method: 'DELETE' });
+    } catch (err) {
+      console.error(chalk.red(`Delete failed: ${err.message}`));
+      process.exit(1);
+    }
+    console.log(chalk.green(`\nWorkload deleted: ${workloadId}\n`));
+    return;
+  }
+
+  console.error(chalk.red(`Unknown workload subcommand: ${sub}`));
+  console.log(`\nUsage:\n  badgr workload list\n  badgr workload info <name>\n  badgr workload run <name>\n  badgr workload delete <name>\n`);
+  process.exit(1);
+}

package/src/commands/workspace.js

@@ -0,0 +1,136 @@
+import { callApi } from '../api.js';
+import { fmtRuntime } from './receipts.js';
+
+function fmtCost(n) {
+  return n != null ? `$${n.toFixed(4)}` : '—';
+}
+
+async function apiRequest(config, path, opts = {}) {
+  return callApi(path, { apiKey: config.apiKey, baseUrl: config.baseUrl, ...opts });
+}
+
+async function resolveWorkspaceId(config, nameOrId) {
+  if (nameOrId.startsWith('ws_')) return nameOrId;
+  const data = await apiRequest(config, '/workspaces?limit=100');
+  const match = (data?.workspaces ?? []).find(x => x.name === nameOrId);
+  return match?.workspace_id ?? null;
+}
+
+export async function workspaceCommand(config, args, chalk) {
+  if (!config.apiKey) {
+    console.error(chalk.red('Not logged in. Run: badgr login'));
+    process.exit(1);
+  }
+
+  const sub = args[0];
+  const rest = args.slice(1);
+
+  // badgr workspace  /  badgr workspace list
+  if (!sub || sub === 'list') {
+    const limit = parseInt(rest[0] ?? '20', 10);
+    let data;
+    try {
+      data = await apiRequest(config, `/workspaces?limit=${limit}`);
+    } catch (err) {
+      console.error(chalk.red(`Could not fetch workspaces: ${err.message}`));
+      process.exit(1);
+    }
+    const workspaces = data?.workspaces ?? [];
+    if (workspaces.length === 0) {
+      console.log(chalk.dim('\nNo workspace trackers yet. Run: badgr workspace create <name>\n'));
+      return;
+    }
+    console.log(chalk.bold(`\nWorkspace Tracking  (${data.total} total)\n`));
+    workspaces.forEach(ws => {
+      console.log(`  ${chalk.cyan(ws.workspace_id)}  ${chalk.bold(ws.name)}`);
+      if (ws.storage_path) console.log(`    ${chalk.dim('storage:')} ${ws.storage_path}`);
+      console.log(`    jobs: ${ws.total_jobs}  total cost: ${fmtCost(ws.total_cost_usd)}`);
+      console.log();
+    });
+    return;
+  }
+
+  // badgr workspace create <name> [--storage <path>] [--desc <text>]
+  if (sub === 'create') {
+    const name = rest[0];
+    if (!name) {
+      console.error(chalk.red('Usage: badgr workspace create <name> [--storage <s3-path>] [--desc <text>]'));
+      process.exit(1);
+    }
+    const flags = {};
+    for (let i = 1; i < rest.length; i++) {
+      if (rest[i] === '--storage') { flags.storage_path = rest[++i]; continue; }
+      if (rest[i] === '--desc')    { flags.description  = rest[++i]; continue; }
+    }
+    let ws;
+    try {
+      ws = await apiRequest(config, '/workspaces', { method: 'POST', body: { name, ...flags } });
+    } catch (err) {
+      console.error(chalk.red(`Create failed: ${err.message}`));
+      process.exit(1);
+    }
+    console.log(chalk.green(`\nWorkspace tracker created: ${ws.name} (${ws.workspace_id})`));
+    if (ws.storage_path) console.log(`  Storage path: ${ws.storage_path}`);
+    console.log(`  Link jobs to this workspace: badgr run --workspace ${ws.workspace_id} <command>\n`);
+    return;
+  }
+
+  // badgr workspace info <name-or-id>
+  if (sub === 'info') {
+    const name = rest[0];
+    if (!name) {
+      console.error(chalk.red('Usage: badgr workspace info <name-or-id>'));
+      process.exit(1);
+    }
+    const id = await resolveWorkspaceId(config, name);
+    if (!id) { console.error(chalk.red(`Workspace not found: ${name}`)); process.exit(1); }
+    let ws;
+    try {
+      ws = await apiRequest(config, `/workspaces/${id}`);
+    } catch {
+      console.error(chalk.red(`Workspace not found: ${name}`)); process.exit(1);
+    }
+    console.log(chalk.bold(`\nWorkspace: ${ws.name}\n`));
+    console.log(`  ID:      ${chalk.cyan(ws.workspace_id)}`);
+    if (ws.description)  console.log(`  Desc:    ${ws.description}`);
+    if (ws.storage_path) console.log(`  Storage: ${ws.storage_path}`);
+    console.log(`  Jobs:    ${ws.total_jobs}  Total cost: ${fmtCost(ws.total_cost_usd)}`);
+    if (ws.files?.length) {
+      console.log(chalk.bold('\n  Files'));
+      ws.files.forEach(f => console.log(`    ${f.name}  ${f.size_bytes ? `(${(f.size_bytes / 1024).toFixed(1)} KB)` : ''}`));
+    }
+    if (ws.recent_jobs?.length) {
+      console.log(chalk.bold('\n  Recent Jobs'));
+      ws.recent_jobs.forEach(j => {
+        const cost = j.charged_usd != null ? ` ${fmtCost(j.charged_usd)}` : '';
+        const rt   = j.runtime_seconds != null ? ` ${fmtRuntime(j.runtime_seconds)}` : '';
+        const col  = j.status === 'completed' ? chalk.green : j.status === 'failed' ? chalk.red : chalk.yellow;
+        console.log(`    ${chalk.dim(j.job_id)}  ${col(j.status)}${cost}${rt}`);
+      });
+    }
+    console.log();
+    return;
+  }
+
+  // badgr workspace delete <name-or-id>
+  if (sub === 'delete') {
+    const name = rest[0];
+    if (!name) {
+      console.error(chalk.red('Usage: badgr workspace delete <name-or-id>'));
+      process.exit(1);
+    }
+    const id = await resolveWorkspaceId(config, name);
+    if (!id) { console.error(chalk.red(`Workspace not found: ${name}`)); process.exit(1); }
+    try {
+      await apiRequest(config, `/workspaces/${id}`, { method: 'DELETE' });
+    } catch (err) {
+      console.error(chalk.red(`Delete failed: ${err.message}`)); process.exit(1);
+    }
+    console.log(chalk.green(`\nWorkspace archived: ${id}\n`));
+    return;
+  }
+
+  console.error(chalk.red(`Unknown workspace subcommand: ${sub}`));
+  console.log('\nUsage:\n  badgr workspace list\n  badgr workspace create <name>\n  badgr workspace info <name>\n  badgr workspace delete <name>\n');
+  process.exit(1);
+}

package/tests/commands.test.js

@@ -94,6 +94,54 @@ describe('parseRunArgs', () => {
     expect(flags.gpu).toBe('A100');
     expect(flags.minVram).toBe(40);
   });
+
+  it('-- separator: badgr flags before --, command argv after', () => {
+    const { flags, commandArgv, positional } = parseRunArgs([
+      '--gpu', 'RTX_4090', '--image', 'node:20', '--max-cost', '1', '--',
+      'node', '-e', "console.log('hello')",
+    ]);
+    expect(flags.gpu).toBe('RTX_4090');
+    expect(flags.image).toBe('node:20');
+    expect(flags.maxCost).toBe(1);
+    expect(commandArgv).toEqual(['node', '-e', "console.log('hello')"]);
+    expect(positional).toEqual([]);
+  });
+
+  it('-- separator: commandArgv is empty array when nothing follows --', () => {
+    const { commandArgv } = parseRunArgs(['--gpu', 'A100', '--max-cost', '2', '--']);
+    expect(commandArgv).toEqual([]);
+  });
+
+  it('commandArgv is null when -- is not used (legacy syntax)', () => {
+    const { commandArgv, positional } = parseRunArgs(['python', 'train.py', '--gpu', 'A100']);
+    expect(commandArgv).toBeNull();
+    expect(positional).toEqual(['python', 'train.py']);
+  });
+
+  it('parses --dry-run flag', () => {
+    const { flags } = parseRunArgs(['--dry-run', '--gpu', 'RTX_4090', '--image', 'node:20']);
+    expect(flags.dryRun).toBe(true);
+    expect(flags.gpu).toBe('RTX_4090');
+  });
+
+  it('--dry-run with -- separator keeps command argv intact', () => {
+    const { flags, commandArgv } = parseRunArgs([
+      '--dry-run', '--gpu', 'RTX_4090', '--image', 'node:20', '--',
+      'node', '-e', "console.log('dry')",
+    ]);
+    expect(flags.dryRun).toBe(true);
+    expect(commandArgv).toEqual(['node', '-e', "console.log('dry')"]);
+  });
+
+  it('-- separator: command tokens with --flags are not parsed as badgr flags', () => {
+    // --json is a user command flag here, not a badgr flag
+    const { flags, commandArgv } = parseRunArgs([
+      '--gpu', 'A100', '--max-cost', '2', '--',
+      'gpu-monitor', 'check', '--json',
+    ]);
+    expect(commandArgv).toEqual(['gpu-monitor', 'check', '--json']);
+    expect(flags.gpu).toBe('A100');
+  });
 });
 
 describe('classifyFailure', () => {

package/tests/run-lifecycle.test.js

@@ -120,7 +120,7 @@ afterEach(() => {
 describe('GPU / provider matrix', () => {
   it('A100 via RunPod (tier-1) completes successfully', async () => {
     setupSuccessfulRun({ gpu_type: 'A100', provider: 'runpod', tier: '1' });
-    const p = runCommand(config, ['python', 'train.py', '--gpu', 'A100'], chalk);
+    const p = runCommand(config, ['python', 'train.py', '--gpu', 'A100', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
     await p;
 
@@ -142,7 +142,7 @@ describe('GPU / provider matrix', () => {
       .mockResolvedValueOnce(makeDep({ gpu_type: 'L40S', provider: 'vastai', tier: '1', cost_per_hour: 1.80 }))
       .mockResolvedValueOnce({ status: 'completed', exit_code: 0 })
       .mockResolvedValueOnce({ logs: [] });
-    const p = runCommand(config, ['python', 'train.py', '--gpu', 'L40S'], chalk);
+    const p = runCommand(config, ['python', 'train.py', '--gpu', 'L40S', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
     await p;
 
@@ -168,7 +168,7 @@ describe('non-zero exit code', () => {
       .mockResolvedValueOnce(makeDep())
       .mockResolvedValueOnce({ status: 'failed', exit_code: 1 })
       .mockResolvedValueOnce({ logs: ['Traceback (most recent call last)'] });
-    const p = runCommand(config, ['python', 'train.py'], chalk);
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
     await p;
 
@@ -184,7 +184,7 @@ describe('non-zero exit code', () => {
       .mockResolvedValueOnce(makeDep())
       .mockResolvedValueOnce({ status: 'failed', exit_code: null })
       .mockResolvedValueOnce({ logs: [] });
-    const p = runCommand(config, ['python', 'train.py'], chalk);
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
     await p;
 
@@ -203,7 +203,7 @@ describe('container fails to start', () => {
     api.callApi
       .mockResolvedValueOnce(makeDep({ status: 'failed' })) // POST /run returns already-failed
       .mockResolvedValueOnce({ logs: [] });
-    const p = runCommand(config, ['python', 'train.py'], chalk);
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(1000);
     await p;
 
@@ -215,7 +215,7 @@ describe('container fails to start', () => {
     api.callApi
       .mockResolvedValueOnce(makeDep({ status: 'provisioning' })) // POST /run → provisioning
       .mockResolvedValueOnce({ status: 'failed' });               // poll → failed
-    const p = runCommand(config, ['python', 'train.py'], chalk);
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
     // advance past POLL_MS (3000ms) in waitForRunning
     await vi.advanceTimersByTimeAsync(4000);
     await p;
@@ -237,7 +237,7 @@ describe('max-runtime cap', () => {
       .mockResolvedValueOnce({ logs: [] });                          // logs 1
     api.terminateDeployment.mockResolvedValue({});
 
-    const p = runCommand(config, ['python', 'train.py', '--max-runtime', '0.05'], chalk);
+    const p = runCommand(config, ['python', 'train.py', '--max-runtime', '0.05', '--max-cost', '5'], chalk);
     // attachToJob POLL_MS = 4000, maxRuntime = 0.05 min = 3000ms → cap fires after 4000ms (first elapsedMs check)
     await vi.advanceTimersByTimeAsync(5000);
     await p;
@@ -294,7 +294,7 @@ describe('heartbeat lost', () => {
       .mockRejectedValue(new Error('ETIMEDOUT'));             // all subsequent dep/logs polls fail
     api.terminateDeployment.mockResolvedValue({});
 
-    const p = runCommand(config, ['python', 'train.py'], chalk);
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
     // Advance past 1 successful poll (4000ms) + 15 failed polls (60000ms) = 64000ms
     await vi.advanceTimersByTimeAsync(66000);
     await p;
@@ -333,7 +333,7 @@ describe('log streaming', () => {
         'Epoch 2/3: loss=0.31',                         // should appear
       ]});
 
-    const p = runCommand(config, ['python', 'train.py'], chalk);
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
     await p;
 
@@ -357,11 +357,11 @@ describe('routing fallback', () => {
     });
     api.callApi
       .mockRejectedValueOnce(capacityErr)                                     // tier-1 attempt
-      .mockResolvedValueOnce(makeDep({ provider: 'modal', tier: '2' }))      // tier-2 succeeds
+      .mockResolvedValueOnce(makeDep({ provider: 'vastai', tier: '2' }))      // tier-2 succeeds
       .mockResolvedValueOnce({ status: 'completed', exit_code: 0 })
       .mockResolvedValueOnce({ logs: [] });
 
-    const p = runCommand(config, ['python', 'train.py'], chalk);
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
     await p;
 
@@ -370,7 +370,7 @@ describe('routing fallback', () => {
     expect(postCalls.length).toBeGreaterThanOrEqual(2);
 
     expect(store.addReceipt).toHaveBeenCalledWith(expect.objectContaining({
-      providerRoute: 'modal',
+      providerRoute: 'vastai',
       tier:          '2',
     }));
     expect(process.exitCode).toBeFalsy();
@@ -386,7 +386,7 @@ describe('routing fallback', () => {
     const logs = [];
     console.error.mockImplementation(msg => logs.push(msg));
 
-    await runCommand(config, ['python', 'train.py'], chalk);
+    await runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
 
     expect(process.exitCode).toBe(1);
     const combined = logs.join('\n');
@@ -400,7 +400,7 @@ describe('routing fallback', () => {
     });
     api.callApi.mockRejectedValueOnce(capacityErr);
 
-    await runCommand(config, ['python', 'train.py', '--no-fallback'], chalk);
+    await runCommand(config, ['python', 'train.py', '--no-fallback', '--max-cost', '5'], chalk);
 
     // Only one POST /run call was made (no tier-2 expansion)
     const postCalls = api.callApi.mock.calls.filter(c => c[1]?.method === 'POST');
@@ -418,7 +418,7 @@ describe('routing fallback', () => {
     const errLines = [];
     console.error.mockImplementation(msg => errLines.push(msg));
 
-    await runCommand(config, ['python', 'train.py'], chalk);
+    await runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
 
     expect(process.exitCode).toBe(1);
     const combined = errLines.join('\n');
@@ -442,7 +442,7 @@ describe('payment required', () => {
     const errLines = [];
     console.error.mockImplementation(msg => errLines.push(msg));
 
-    await runCommand(config, ['python', 'train.py', '--gpu', 'A100'], chalk);
+    await runCommand(config, ['python', 'train.py', '--gpu', 'A100', '--max-cost', '5'], chalk);
 
     expect(process.exitCode).toBe(1);
     const combined = errLines.join('\n');
@@ -457,7 +457,7 @@ describe('payment required', () => {
 describe('billing lifecycle', () => {
   it('terminateDeployment is called after successful completion', async () => {
     setupSuccessfulRun();
-    const p = runCommand(config, ['python', 'train.py'], chalk);
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
     await p;
     expect(api.terminateDeployment).toHaveBeenCalledWith(config, 'dep-launch-001');
@@ -465,7 +465,7 @@ describe('billing lifecycle', () => {
 
   it('receipt records runtime and finalCost on completion', async () => {
     setupSuccessfulRun({ cost_per_hour: 1.80 });
-    const p = runCommand(config, ['python', 'train.py'], chalk);
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
     await p;
 
@@ -505,4 +505,41 @@ describe('input validation', () => {
     await runCommand(config, [], chalk);
     expect(api.callApi).not.toHaveBeenCalled();
   });
+
+  it('rejects -- with nothing after and no --image', async () => {
+    await runCommand(config, ['--gpu', 'RTX_4090', '--max-cost', '1', '--'], chalk);
+    expect(api.callApi).not.toHaveBeenCalled();
+    expect(process.exitCode).toBe(1);
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 12. --dry-run: shows config, never provisions
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('--dry-run', () => {
+  it('prints dry-run summary and never calls the API', async () => {
+    const output = [];
+    const dryChalk = { bold: (s) => s, dim: (s) => s, cyan: (s) => s, red: (s) => s, yellow: (s) => s, green: (s) => s };
+    const origLog = console.log;
+    console.log = (...args) => output.push(args.join(' '));
+    await runCommand(config, [
+      '--dry-run', '--gpu', 'RTX_4090', '--image', 'node:20', '--max-cost', '1', '--',
+      'node', '-e', "console.log('dry')",
+    ], dryChalk);
+    console.log = origLog;
+    expect(api.callApi).not.toHaveBeenCalled();
+    expect(output.some(l => /dry run/i.test(l))).toBe(true);
+    expect(output.some(l => /node -e/.test(l) || /console\.log/.test(l))).toBe(true);
+    expect(output.some(l => /RTX_4090/.test(l))).toBe(true);
+  });
+
+  it('--dry-run works without --max-cost', async () => {
+    const dryChalk = { bold: (s) => s, dim: (s) => s, cyan: (s) => s, red: (s) => s, yellow: (s) => s, green: (s) => s };
+    await runCommand(config, [
+      '--dry-run', '--gpu', 'A100', '--image', 'node:20', '--',
+      'node', 'script.js',
+    ], dryChalk);
+    expect(api.callApi).not.toHaveBeenCalled();
+  });
 });

package/tests/template.test.js

@@ -107,10 +107,12 @@ describe('TEMPLATES catalog', () => {
   const EXPECTED_NAMES = [
     'comfyui', 'axolotl', 'unsloth', 'vllm', 'llama-cpp',
     'invokeai', 'kohya-ss', 'text-gen-webui', 'sglang', 'tgi',
+    'auto1111', 'forge', 'nerfstudio', 'openfold', 'blender-render',
+    'openmm', 'gromacs', 'lammps', 'diffusers', 'torchtune',
   ];
 
-  it('contains exactly 10 templates', () => {
-    expect(TEMPLATES).toHaveLength(10);
+  it('contains exactly 20 templates', () => {
+    expect(TEMPLATES).toHaveLength(20);
   });
 
   it('contains all expected template names', () => {
@@ -178,7 +180,7 @@ describe('TEMPLATES catalog', () => {
     for (const [k, t] of Object.entries(TEMPLATE_MAP)) {
       expect(k).toBe(t.name);
     }
-    expect(Object.keys(TEMPLATE_MAP)).toHaveLength(10);
+    expect(Object.keys(TEMPLATE_MAP)).toHaveLength(20);
   });
 });
 
@@ -358,7 +360,7 @@ describe('badgr serve template <name>', () => {
     await p;
 
     const [, opts] = api.callApi.mock.calls[0];
-    expect(opts.body.image).toBe('yanwk/comfyui-boot:latest');
+    expect(opts.body.image).toBe('yanwk/comfyui-boot:cu126-megapak');
     const fetchUrl = global.fetch.mock.calls[0]?.[0] ?? '';
     expect(fetchUrl).toContain('/system_stats');
     expect(process.exitCode).toBeFalsy();

package/tests/workload-rerun.test.js

@@ -0,0 +1,56 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Verify `badgr workload run` (rerun a saved workflow) resolves name→id and
+// merges --set / --max-cost / --max-runtime into the POST body the server
+// expects, without provisioning a GPU.
+const calls = [];
+vi.mock('../src/api.js', () => ({
+  callApi: vi.fn(async (path, opts = {}) => {
+    calls.push({ path, opts });
+    if (path.startsWith('/workloads?')) {
+      return { workloads: [{ name: 'mini-train', workload_id: 'wl_abc' }], total: 1 };
+    }
+    if (path === '/workloads/wl_abc/run') {
+      return { job_id: 'job_1', status_url: 'https://aibadgr.com/v1/jobs/job_1', estimated_cost_usd: 1.23 };
+    }
+    return {};
+  }),
+}));
+
+const { workloadCommand } = await import('../src/commands/workload.js');
+const chalk = new Proxy({}, { get: () => (s) => s });
+const config = { apiKey: 'k', baseUrl: 'https://aibadgr.com/v1' };
+
+beforeEach(() => {
+  calls.length = 0;
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+});
+
+describe('badgr workload run (rerun saved workflow)', () => {
+  it('resolves name→id and merges --set / --max-cost / --max-runtime into the rerun body', async () => {
+    await workloadCommand(
+      config,
+      ['run', 'mini-train', '--set', 'gpu=H100', '--max-cost', '8', '--max-runtime', '30'],
+      chalk,
+    );
+
+    const resolve = calls.find(c => c.path.startsWith('/workloads?'));
+    expect(resolve, 'should look up workload by name').toBeTruthy();
+    expect(resolve.path.startsWith('/v1/')).toBe(false);
+
+    const run = calls.find(c => c.path === '/workloads/wl_abc/run');
+    expect(run, 'should POST to the rerun endpoint').toBeTruthy();
+    expect(run.opts.method).toBe('POST');
+    expect(run.opts.body).toEqual({
+      config_overrides: { gpu: 'H100' },
+      max_cost: 8,
+      max_runtime_minutes: 30,
+    });
+  });
+
+  it('sends only config_overrides when no caps are passed', async () => {
+    await workloadCommand(config, ['run', 'mini-train', '--set', 'steps=50'], chalk);
+    const run = calls.find(c => c.path === '/workloads/wl_abc/run');
+    expect(run.opts.body).toEqual({ config_overrides: { steps: '50' } });
+  });
+});