badgr-cli 1.0.48 → 1.1.0

package/tests/run-lifecycle.test.js

@@ -15,16 +15,39 @@
  *   - Receipt explains state   → status, exitCode, failureType, runtimeSeconds, finalCost
  */
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { writeFileSync } from 'fs';
 import { runCommand, parseRunArgs } from '../src/commands/run.js';
+import { launchCommand } from '../src/commands/launch.js';
 
 // ── Module mocks ──────────────────────────────────────────────────────────────
 
 vi.mock('../src/api.js', () => ({
   callApi:             vi.fn(),
-  terminateDeployment: vi.fn().mockResolvedValue({}),
+  terminateDeployment: vi.fn().mockResolvedValue({ teardown_ok: 'ok' }),
+  uploadBlob: vi.fn().mockResolvedValue({ code_uri: 'blob://project.zip' }),
+  quoteRun:   vi.fn(),
+}));
+
+vi.mock('archiver', () => ({
+  default: () => {
+    let output;
+    return {
+      on: vi.fn(),
+      pipe: vi.fn(o => { output = o; }),
+      glob: vi.fn(),
+      finalize: vi.fn(() => { if (output?.path) writeFileSync(output.path, 'zip'); output?.emit?.('close'); }),
+    };
+  },
 }));
 
 vi.mock('../src/store.js', () => ({
+  selectedComputeFromDeployment: (dep) => ({
+    gpu: dep.gpu_type ?? null,
+    gpuCount: dep.gpu_count ?? null,
+    vcpus: dep.selected_vcpus ?? null,
+    ramGb: dep.selected_ram_gb ?? null,
+    vramGb: dep.selected_vram_gb ?? null,
+  }),
   addDeployment:        vi.fn(),
   addReceipt:           vi.fn(),
   updateReceipt:        vi.fn(),
@@ -75,7 +98,7 @@ function setupSuccessfulRun(depOverrides = {}, exitCode = 0) {
     .mockResolvedValueOnce(makeDep(depOverrides))                         // POST /run
     .mockResolvedValueOnce({ status: 'completed', exit_code: exitCode }) // GET /deployments/…
     .mockResolvedValueOnce({ logs: ['step 1', 'step 2'] });              // GET /deployments/…/logs
-  api.terminateDeployment.mockResolvedValue({});
+  api.terminateDeployment.mockResolvedValue({ teardown_ok: 'ok' });
 }
 
 // ── Setup / teardown ─────────────────────────────────────────────────────────
@@ -104,7 +127,8 @@ beforeEach(() => {
   store.listDeployments.mockReturnValue([]);
   store.listReceipts.mockReturnValue([]);
   store.findDeployment.mockReturnValue(null);
-  api.terminateDeployment.mockResolvedValue({});
+  api.terminateDeployment.mockResolvedValue({ teardown_ok: 'ok' });
+  api.uploadBlob.mockResolvedValue({ code_uri: 'blob://project.zip' });
 });
 
 afterEach(() => {
@@ -158,6 +182,37 @@ describe('GPU / provider matrix', () => {
   });
 });
 
+describe('CPU launch — price quoted before provisioning', () => {
+  it('shows the quoted Badgr rate before the deployment is created, and does not repeat it after', async () => {
+    api.quoteRun.mockResolvedValueOnce({ vm_class: 'small', vcpus: 2, memory_gb: 4, region: 'US', rate_per_hour: 0.13 });
+    api.callApi
+      .mockResolvedValueOnce(makeDep({ gpu_type: 'CPU', cost_per_hour: 0.13 })) // POST /run
+      .mockResolvedValueOnce({});
+
+    await launchCommand(config, ['cline', '--max-cost', '1', 'Fix the checkout bug'], chalk);
+
+    expect(api.quoteRun).toHaveBeenCalledWith(config, expect.objectContaining({ compute: 'cpu', agent: 'cline' }));
+    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(logged).toContain('Badgr rate: $0.13/hour');
+    // The quoted rate is shown once, pre-provisioning — not repeated as the
+    // post-creation fallback line too.
+    expect(logged.match(/Badgr rate:/g)?.length).toBe(1);
+  });
+
+  it('still launches, falling back to the post-creation rate, when the quote call fails', async () => {
+    api.quoteRun.mockRejectedValueOnce(new Error('network error'));
+    api.callApi
+      .mockResolvedValueOnce(makeDep({ gpu_type: 'CPU', cost_per_hour: 0.13 })) // POST /run
+      .mockResolvedValueOnce({});
+
+    await launchCommand(config, ['cline', '--max-cost', '1', 'Fix the checkout bug'], chalk);
+
+    expect(process.exitCode).toBeFalsy();
+    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(logged).toContain('Badgr rate: $0.13/hour');
+  });
+});
+
 // ─────────────────────────────────────────────────────────────────────────────
 // 2. Job exits non-zero
 // ─────────────────────────────────────────────────────────────────────────────
@@ -179,6 +234,51 @@ describe('non-zero exit code', () => {
     expect(process.exitCode).toBe(1);
   });
 
+  it('reports "Teardown: succeeded" on a customer-code failure when the backend already confirmed teardown', async () => {
+    // The job-runner's own /complete webhook (complete_job_atomic) already
+    // attempts + confirms teardown on any exit code, before the CLI ever
+    // observes the failure via polling — teardown_ok in the poll response
+    // reflects that already-confirmed result.
+    api.callApi
+      .mockResolvedValueOnce(makeDep())
+      .mockResolvedValueOnce({ status: 'failed', exit_code: 1, teardown_ok: 'ok' })
+      .mockResolvedValueOnce({ logs: ['Traceback (most recent call last)'] });
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(logged).toContain('succeeded');
+  });
+
+  it('reports "Teardown: failed" on a customer-code failure when the backend never confirmed deletion', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeDep())
+      .mockResolvedValueOnce({ status: 'failed', exit_code: 1, teardown_ok: 'failed' })
+      .mockResolvedValueOnce({ logs: ['Traceback (most recent call last)'] });
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(logged).not.toContain('Teardown:  succeeded');
+    expect(logged).toContain('failed');
+  });
+
+  it('writes an initial receipt for a job that ultimately fails', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeDep())
+      .mockResolvedValueOnce({ status: 'failed', exit_code: 1 })
+      .mockResolvedValueOnce({ logs: ['Traceback (most recent call last)'] });
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    // A receipt must exist from the start of the job, not only once it fails —
+    // updateReceipt above mutates the same receipt addReceipt created here.
+    expect(store.addReceipt).toHaveBeenCalled();
+  });
+
   it('distinguishes customer_code from infrastructure when exit code is null', async () => {
     api.callApi
       .mockResolvedValueOnce(makeDep())
@@ -255,7 +355,7 @@ describe('max-runtime cap', () => {
       .mockResolvedValueOnce(makeDep({ cost_per_hour: 2.50 }))  // POST /run
       .mockResolvedValueOnce({ status: 'running', exit_code: null }) // poll 1
       .mockResolvedValueOnce({ logs: [] });                          // logs 1
-    api.terminateDeployment.mockResolvedValue({});
+    api.terminateDeployment.mockResolvedValue({ teardown_ok: 'ok' });
 
     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)
@@ -282,7 +382,7 @@ describe('max-cost cap', () => {
       .mockResolvedValueOnce(makeDep({ cost_per_hour: 3600 })) // POST /run
       .mockResolvedValueOnce({ status: 'running' })            // poll 1 (never reached — cap fires first)
       .mockResolvedValueOnce({ logs: [] });
-    api.terminateDeployment.mockResolvedValue({});
+    api.terminateDeployment.mockResolvedValue({ teardown_ok: 'ok' });
 
     const p = runCommand(config, ['python', 'train.py', '--max-cost', '0.001'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
@@ -312,7 +412,7 @@ describe('heartbeat lost', () => {
       .mockResolvedValueOnce({ status: 'running' })          // first dep poll → sets lastStatus = 'running'
       .mockResolvedValueOnce({ logs: [] })                   // first logs poll
       .mockRejectedValue(new Error('ETIMEDOUT'));             // all subsequent dep/logs polls fail
-    api.terminateDeployment.mockResolvedValue({});
+    api.terminateDeployment.mockResolvedValue({ teardown_ok: 'ok' });
 
     const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
     // Advance past 1 successful poll (4000ms) + 15 failed polls (60000ms) = 64000ms
@@ -496,6 +596,20 @@ describe('billing lifecycle', () => {
     expect(typeof updateCall[1].runtimeSeconds).toBe('number');
     expect(typeof updateCall[1].finalCost).toBe('number');
   });
+
+  it('reports "Teardown: failed" — never "succeeded" — when the backend accepted the DELETE but did not confirm deletion', async () => {
+    // A 200 response with teardown_ok: 'failed' must never be reported as a
+    // successful teardown — the caller only knows deletion was *requested*.
+    setupSuccessfulRun();
+    api.terminateDeployment.mockResolvedValue({ teardown_ok: 'failed' });
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(logged).not.toContain('Teardown:  succeeded');
+    expect(logged).toContain('failed');
+  });
 });
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -653,3 +767,288 @@ describe('--output / --checkpoint / --retry-safe / --resume-cmd', () => {
     expect(logs.some(l => l.includes('Resume:'))).toBe(false);
   });
 });
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 13b. --cpu / --memory / --gpu-memory — CPU/RAM/VRAM resource matching
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('--cpu / --memory / --gpu-memory', () => {
+  it('wires --cpu and --memory into the /run request body as cpu/memory_gb', async () => {
+    setupSuccessfulRun();
+    const p = runCommand(config, [
+      '--cpu', '16', '--memory', '64GB', '--max-cost', '5', '--', 'python', 'train.py',
+    ], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    const postRunBody = api.callApi.mock.calls[0][1].body;
+    expect(postRunBody.cpu).toBe(16);
+    expect(postRunBody.memory_gb).toBe(64);
+  });
+
+  it('--gpu-memory sets min_vram the same way --min-vram does', async () => {
+    setupSuccessfulRun();
+    const p = runCommand(config, [
+      '--gpu-memory', '24GB', '--max-cost', '5', '--', 'python', 'train.py',
+    ], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    const postRunBody = api.callApi.mock.calls[0][1].body;
+    expect(postRunBody.min_vram).toBe(24);
+  });
+
+  it('omits cpu/memory_gb/min_vram from the body when none were requested', async () => {
+    setupSuccessfulRun();
+    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    const postRunBody = api.callApi.mock.calls[0][1].body;
+    expect(postRunBody.cpu).toBeUndefined();
+    expect(postRunBody.memory_gb).toBeUndefined();
+    expect(postRunBody.min_vram).toBeUndefined();
+  });
+
+  it('--dry-run shows CPU/Memory/Min VRAM without calling 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', '--cpu', '16', '--memory', '64GB', '--gpu-memory', '24GB',
+      '--image', 'node:20', '--max-cost', '1', '--', 'node', '-e', "console.log('dry')",
+    ], dryChalk);
+    console.log = origLog;
+    expect(api.callApi).not.toHaveBeenCalled();
+    expect(output.some(l => /CPU:.*16 cores/.test(l))).toBe(true);
+    expect(output.some(l => /Memory:.*64 GB/.test(l))).toBe(true);
+    expect(output.some(l => /Min VRAM:.*24 GB/.test(l))).toBe(true);
+  });
+
+  it('rejects an unparseable --memory value before touching the API', async () => {
+    await runCommand(config, ['python', 'train.py', '--memory', 'not-a-size', '--max-cost', '5'], chalk);
+    expect(api.callApi).not.toHaveBeenCalled();
+    expect(process.exitCode).toBe(1);
+  });
+
+  it('rejects an unparseable --gpu-memory value before touching the API', async () => {
+    await runCommand(config, ['python', 'train.py', '--gpu-memory', 'huge', '--max-cost', '5'], chalk);
+    expect(api.callApi).not.toHaveBeenCalled();
+    expect(process.exitCode).toBe(1);
+  });
+
+  it('rejects a non-integer --cpu before touching the API', async () => {
+    await runCommand(config, ['python', 'train.py', '--cpu', 'sixteen', '--max-cost', '5'], chalk);
+    expect(api.callApi).not.toHaveBeenCalled();
+    expect(process.exitCode).toBe(1);
+  });
+
+  it('rejects --no-gpu combined with --gpu', async () => {
+    await runCommand(config, ['python', 'sim.py', '--no-gpu', '--gpu', 'A100', '--max-cost', '5'], chalk);
+    expect(api.callApi).not.toHaveBeenCalled();
+    expect(process.exitCode).toBe(1);
+  });
+
+  it('--no-gpu sends no_gpu:true and no gpu-specific fields beyond the default', async () => {
+    setupSuccessfulRun();
+    const p = runCommand(config, [
+      '--no-gpu', '--cpu', '16', '--memory', '64GB', '--max-cost', '5', '--', 'python', 'sim.py',
+    ], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    const postRunBody = api.callApi.mock.calls[0][1].body;
+    expect(postRunBody.no_gpu).toBe(true);
+    expect(postRunBody.cpu).toBe(16);
+    expect(postRunBody.memory_gb).toBe(64);
+  });
+
+  it('shows what was actually provisioned when a resource floor was requested', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeDep({ gpu_type: 'A100', gpu_count: 1, selected_vcpus: 16, selected_ram_gb: 64, selected_vram_gb: 40 }))
+      .mockResolvedValueOnce({ status: 'completed', exit_code: 0 })
+      .mockResolvedValueOnce({ logs: [] });
+    const logs = [];
+    const origLog = console.log;
+    console.log = (...args) => { logs.push(args.join(' ')); origLog(...args); };
+    const p = runCommand(config, [
+      '--gpu-memory', '24GB', '--cpu', '16', '--memory', '64GB', '--max-cost', '5', '--', 'python', 'train.py',
+    ], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+    console.log = origLog;
+
+    expect(logs.some(l => l.includes('Provisioned:') && l.includes('A100') && l.includes('40GB VRAM') && l.includes('16 vCPU') && l.includes('64GB RAM'))).toBe(true);
+  });
+
+  it('does not print a Provisioned line when no resource floor was requested', async () => {
+    setupSuccessfulRun();
+    const logs = [];
+    const origLog = console.log;
+    console.log = (...args) => { logs.push(args.join(' ')); origLog(...args); };
+    const p = runCommand(config, ['python', 'train.py', '--gpu', 'A100', '--max-cost', '5'], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+    console.log = origLog;
+
+    expect(logs.some(l => l.includes('Provisioned:'))).toBe(false);
+  });
+
+  it('records workload shape and requested/selected compute on the receipt', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeDep({ gpu_type: 'A100', gpu_count: 1, selected_vcpus: 16, selected_ram_gb: 64, selected_vram_gb: 40 }))
+      .mockResolvedValueOnce({ status: 'completed', exit_code: 0 })
+      .mockResolvedValueOnce({ logs: [] });
+    const p = runCommand(config, [
+      '--gpu-memory', '24GB', '--cpu', '16', '--memory', '64GB', '--max-cost', '5', '--image', 'node:20', '--', 'node', 'train.js',
+    ], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    expect(store.addReceipt).toHaveBeenCalledWith(expect.objectContaining({
+      workloadShape: 'container',
+      computeRequested: expect.objectContaining({ minVram: 24, cpu: 16, memoryGb: 64, noGpu: false }),
+      computeSelected: expect.objectContaining({ gpu: 'A100', vcpus: 16, ramGb: 64, vramGb: 40 }),
+    }));
+  });
+
+  it('tags a local-path run as workloadShape "project"', async () => {
+    setupSuccessfulRun();
+    const p = runCommand(config, ['.', '--cmd', 'python train.py', '--max-cost', '5'], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    expect(store.addReceipt).toHaveBeenCalledWith(expect.objectContaining({ workloadShape: 'project' }));
+  });
+});
+
+describe('badgr launch (CPU VM)', () => {
+  it('maps `badgr launch . -- <command>` to a detached CPU project run', async () => {
+    setupSuccessfulRun({ gpu_type: 'CPU', cost_per_hour: 0.10 });
+    const p = launchCommand(config, ['.', '--max-cost', '5', '--', 'claude', '-p', 'Fix the failing tests'], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    const [, opts] = api.callApi.mock.calls.find(([path]) => path === '/run');
+    const body = typeof opts.body === 'string' ? JSON.parse(opts.body) : opts.body;
+    expect(body.compute).toBe('cpu');
+    expect(body.gpu).toBe('CPU');
+    expect(body.cmd).toBe('claude -p Fix the failing tests');
+    expect(body.code_uri).toBeTruthy();
+    expect(body.agent).toBeUndefined();
+    expect(body.task).toBeUndefined();
+  });
+
+  it('defaults to detached (returns without waiting on the job)', async () => {
+    setupSuccessfulRun({ gpu_type: 'CPU', cost_per_hour: 0.10 });
+    const logs = [];
+    const origLog = console.log;
+    console.log = (...args) => { logs.push(args.join(' ')); origLog(...args); };
+    await launchCommand(config, ['.', '--max-cost', '5', '--', 'python', 'narrgo.py'], chalk);
+    console.log = origLog;
+
+    expect(logs.some(l => l.includes('Detached'))).toBe(true);
+  });
+
+  it('accepts the quoted --cmd form as equivalent to -- passthrough', async () => {
+    setupSuccessfulRun({ gpu_type: 'CPU', cost_per_hour: 0.10 });
+    const p = launchCommand(config, ['.', '--max-cost', '5', '--cmd', 'codex exec "Write tests"'], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    const [, opts] = api.callApi.mock.calls.find(([path]) => path === '/run');
+    const body = typeof opts.body === 'string' ? JSON.parse(opts.body) : opts.body;
+    expect(body.cmd).toBe('codex exec "Write tests"');
+  });
+
+  it('sends declared --artifacts paths as output_paths in the /run request body', async () => {
+    setupSuccessfulRun({ gpu_type: 'CPU', cost_per_hour: 0.10 });
+    const p = launchCommand(config, [
+      '.', '--max-cost', '5',
+      '--artifacts', 'playwright-report', '--artifacts', 'test-results',
+      '--', 'npx', 'playwright', 'test',
+    ], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    const [, opts] = api.callApi.mock.calls.find(([path]) => path === '/run');
+    const body = typeof opts.body === 'string' ? JSON.parse(opts.body) : opts.body;
+    expect(body.output_paths).toEqual(['playwright-report', 'test-results']);
+  });
+
+  it('does not send output_paths when --artifacts is not passed', async () => {
+    setupSuccessfulRun({ gpu_type: 'CPU', cost_per_hour: 0.10 });
+    const p = launchCommand(config, ['.', '--max-cost', '5', '--', 'npm', 'test'], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    const [, opts] = api.callApi.mock.calls.find(([path]) => path === '/run');
+    const body = typeof opts.body === 'string' ? JSON.parse(opts.body) : opts.body;
+    expect(body.output_paths).toBeUndefined();
+  });
+
+  it('--no-detach streams the job to completion instead of returning immediately', async () => {
+    setupSuccessfulRun({ gpu_type: 'CPU', cost_per_hour: 0.10 });
+    const logs = [];
+    const origLog = console.log;
+    console.log = (...args) => { logs.push(args.join(' ')); origLog(...args); };
+    const p = launchCommand(config, ['.', '--max-cost', '5', '--no-detach', '--', 'npm', 'test'], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+    console.log = origLog;
+
+    expect(logs.some(l => l.includes('Detached'))).toBe(false);
+    expect(logs.some(l => l.includes('Complete'))).toBe(true);
+  });
+
+  it('rejects --gpu end to end without ever calling the API', async () => {
+    await launchCommand(config, ['.', '--gpu', 'A100', '--max-cost', '5', '--', 'npm', 'test'], chalk);
+    expect(process.exitCode).toBe(1);
+    expect(api.callApi).not.toHaveBeenCalled();
+    process.exitCode = undefined;
+  });
+
+  it('prints a secret-shaped --env warning before submitting the run', async () => {
+    setupSuccessfulRun({ gpu_type: 'CPU', cost_per_hour: 0.10 });
+    const logs = [];
+    const origLog = console.log;
+    console.log = (...args) => { logs.push(args.join(' ')); origLog(...args); };
+    const p = launchCommand(config, [
+      '.', '--max-cost', '5', '--env', 'ANTHROPIC_API_KEY=sk-ant-fake',
+      '--', 'claude', '-p', 'fix',
+    ], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+    console.log = origLog;
+
+    const joinedLogs = logs.join('\n');
+    expect(joinedLogs).toContain('ANTHROPIC_API_KEY');
+    expect(joinedLogs).toContain('shell history');
+    const [, opts] = api.callApi.mock.calls.find(([path]) => path === '/run');
+    const body = typeof opts.body === 'string' ? JSON.parse(opts.body) : opts.body;
+    expect(body.env.ANTHROPIC_API_KEY).toBe('sk-ant-fake');
+  });
+
+  it('a failed CPU launch command still updates the receipt with a usable status', async () => {
+    api.callApi
+      .mockResolvedValueOnce({
+        deployment_id: 'dep-launch-001', status: 'running', gpu_type: 'CPU',
+        cost_per_hour: 0.10, receipt_id: 'rcpt-launch-001', tier: '1',
+      })
+      .mockResolvedValueOnce({ status: 'completed', exit_code: 1 })
+      .mockResolvedValueOnce({ logs: ['error: test failed'] });
+
+    const p = launchCommand(config, ['.', '--max-cost', '5', '--no-detach', '--', 'npm', 'test'], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    expect(store.updateReceipt).toHaveBeenCalledWith('rcpt-launch-001', expect.objectContaining({
+      status: 'completed',
+      exitCode: 1,
+      failureType: 'customer_code',
+    }));
+    expect(process.exitCode).toBe(1);
+    process.exitCode = undefined;
+  });
+});

package/tests/sbatch.test.js

@@ -0,0 +1,190 @@
+/**
+ * badgr sbatch — /run body translation from #SBATCH directives, dry-run
+ * behavior, and job-array fan-out (one deployment per task index).
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, writeFileSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+vi.mock('../src/store.js', () => ({
+  selectedComputeFromDeployment: (dep) => ({
+    gpu: dep.gpu_type ?? null,
+    gpuCount: dep.gpu_count ?? null,
+    vcpus: dep.selected_vcpus ?? null,
+    ramGb: dep.selected_ram_gb ?? null,
+    vramGb: dep.selected_vram_gb ?? null,
+  }),
+  addReceipt: vi.fn(),
+  updateReceipt: vi.fn(),
+  generateReceiptId: vi.fn(() => 'rcpt-sbatch-001'),
+  loadStore: vi.fn(() => ({ receipts: [], deployments: [] })),
+}));
+
+vi.mock('../src/api.js', () => ({
+  callApi: vi.fn(),
+}));
+
+vi.mock('../src/fallback.js', async (importOriginal) => {
+  const actual = await importOriginal();
+  return { ...actual, callWithFallback: vi.fn() };
+});
+
+vi.mock('../src/batch.js', () => ({
+  monitorBatchJob: vi.fn(() => Promise.resolve({ status: 'succeeded', exitCode: 0, runtimeMs: 5000, reason: 'complete' })),
+  fmtRuntime: (ms) => `${Math.round(ms / 1000)}s`,
+}));
+
+import { sbatchCommand, buildRunBody } from '../src/commands/sbatch.js';
+import * as store from '../src/store.js';
+import * as api from '../src/api.js';
+import * as fallback from '../src/fallback.js';
+
+const chalk = {
+  bold: s => s, dim: s => s, red: s => s, yellow: s => s, green: s => s, cyan: s => s,
+};
+
+const config = { apiKey: 'sk-test', baseUrl: 'https://api.test/v1' };
+
+let dir;
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), 'badgr-sbatch-cmd-test-'));
+  process.exitCode = undefined;
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+  vi.spyOn(console, 'error').mockImplementation(() => {});
+  vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+  vi.clearAllMocks();
+});
+
+afterEach(() => {
+  rmSync(dir, { recursive: true, force: true });
+  vi.restoreAllMocks();
+});
+
+describe('buildRunBody', () => {
+  it('translates a GPU job into the /run body shape', () => {
+    const job = {
+      name: 'train', command: 'python train.py', cpus: 32, memGb: 128,
+      gpuCount: 2, gpuType: 'a100', env: { FOO: 'bar' },
+    };
+    const body = buildRunBody(job, {
+      image: 'python:3.11-slim', tier: '1', region: null,
+      maxCostUsd: 5, maxRuntimeMinutes: 60,
+    });
+    expect(body.command).toEqual(['bash', '-lc', 'python train.py']);
+    expect(body.gpu).toBe('A100');
+    expect(body.gpu_count).toBe(2);
+    expect(body.cpu).toBe(32);
+    expect(body.memory_gb).toBe(128);
+    expect(body.env).toEqual({ FOO: 'bar' });
+    expect(body.max_cost_usd).toBe(5);
+    expect(body.max_runtime_seconds).toBe(3600);
+    expect(body.name).toBe('train');
+  });
+
+  it('requests no GPU when the script has no gres/gpus directive', () => {
+    const job = { name: 'cpu-job', command: 'echo hi', cpus: null, memGb: null, gpuCount: 0, gpuType: null, env: {} };
+    const body = buildRunBody(job, { image: 'python:3.11-slim', tier: '1', region: null, maxCostUsd: 1, maxRuntimeMinutes: 10 });
+    expect(body.gpu).toBe('NONE');
+    // Backend's RunBody requires gpu_count >= 1; CPU-only routing goes through
+    // the separate no_gpu flag instead of gpu_count: 0 (which the real
+    // Pydantic-validated backend rejects with a 422 before provisioning).
+    expect(body.gpu_count).toBe(1);
+    expect(body.no_gpu).toBe(true);
+  });
+
+  it('suffixes the name and injects SLURM_ARRAY_TASK_ID for array tasks', () => {
+    const job = { name: 'screen', command: 'python screen.py', cpus: null, memGb: null, gpuCount: 1, gpuType: null, env: {} };
+    const body = buildRunBody(job, { image: 'python:3.11-slim', tier: '1', region: null, maxCostUsd: 1, maxRuntimeMinutes: 10, taskId: 7, arrayJobId: 'rcpt-x' });
+    expect(body.name).toBe('screen-7');
+    expect(body.env.SLURM_ARRAY_TASK_ID).toBe('7');
+    expect(body.env.SLURM_ARRAY_JOB_ID).toBe('rcpt-x');
+  });
+});
+
+describe('sbatchCommand', () => {
+  function writeScript(name, contents) {
+    const p = join(dir, name);
+    writeFileSync(p, contents);
+    return p;
+  }
+
+  it('dry-run parses and prints the plan without calling the network', async () => {
+    const scriptPath = writeScript('job.slurm', `#!/bin/bash\n#SBATCH --job-name=t\n#SBATCH --gres=gpu:1\npython run.py\n`);
+    await sbatchCommand(config, [scriptPath, '--dry-run'], chalk);
+    expect(fallback.callWithFallback).not.toHaveBeenCalled();
+    expect(process.exitCode).toBeUndefined();
+  });
+
+  it('submits a single job and reports success', async () => {
+    const scriptPath = writeScript('job.slurm', `#!/bin/bash\n#SBATCH --job-name=t\n#SBATCH --gres=gpu:1\npython run.py\n`);
+
+    fallback.callWithFallback.mockResolvedValue({
+      deployment_id: 'dep-1', receipt_id: 'rcpt-1', gpu_type: 'RTX_4090',
+      gpu_count: 1, cost_per_hour: 0.5, provider: 'runpod', tier: '1', status: 'running',
+    });
+    api.callApi.mockResolvedValue({
+      status: 'succeeded', failure_reason: null, teardown_ok: 'ok',
+      runtime_seconds: 5, accrued_cost_usd: 0.01, provider: 'runpod',
+    });
+
+    await sbatchCommand(config, [scriptPath], chalk);
+
+    expect(fallback.callWithFallback).toHaveBeenCalledTimes(1);
+    expect(store.addReceipt).toHaveBeenCalledTimes(1);
+    expect(store.addReceipt).toHaveBeenCalledWith(expect.objectContaining({
+      workloadShape: 'slurm',
+      computeSelected: expect.objectContaining({ gpu: 'RTX_4090', gpuCount: 1 }),
+    }));
+    expect(process.exitCode).toBeUndefined();
+  });
+
+  it('fans out array jobs into one deployment per task', async () => {
+    const scriptPath = writeScript('array.slurm', `#!/bin/bash\n#SBATCH --job-name=screen\n#SBATCH --array=1-3\n#SBATCH --gpus=1\npython screen.py\n`);
+
+    let callCount = 0;
+    fallback.callWithFallback.mockImplementation(() => {
+      callCount += 1;
+      return Promise.resolve({
+        deployment_id: `dep-${callCount}`, receipt_id: `rcpt-${callCount}`, gpu_type: 'RTX_4090',
+        gpu_count: 1, cost_per_hour: 0.5, provider: 'runpod', tier: '1', status: 'running',
+      });
+    });
+    api.callApi.mockResolvedValue({
+      status: 'succeeded', failure_reason: null, teardown_ok: 'ok',
+      runtime_seconds: 5, accrued_cost_usd: 0.01, provider: 'runpod',
+    });
+
+    await sbatchCommand(config, [scriptPath], chalk);
+
+    expect(fallback.callWithFallback).toHaveBeenCalledTimes(3);
+    expect(store.addReceipt).toHaveBeenCalledTimes(3);
+    expect(store.addReceipt).toHaveBeenCalledWith(expect.objectContaining({ workloadShape: 'slurm-array' }));
+    expect(process.exitCode).toBeUndefined();
+  });
+
+  it('reports failure exit code when a task does not succeed', async () => {
+    const scriptPath = writeScript('job.slurm', `#!/bin/bash\n#SBATCH --gres=gpu:1\npython run.py\n`);
+    const { monitorBatchJob } = await import('../src/batch.js');
+    monitorBatchJob.mockResolvedValueOnce({ status: 'failed', exitCode: 1, runtimeMs: 1000, reason: 'infrastructure' });
+
+    fallback.callWithFallback.mockResolvedValue({
+      deployment_id: 'dep-1', receipt_id: 'rcpt-1', gpu_type: 'RTX_4090',
+      gpu_count: 1, cost_per_hour: 0.5, provider: 'runpod', tier: '1', status: 'running',
+    });
+    api.callApi.mockResolvedValue({
+      status: 'failed', failure_reason: 'infrastructure', teardown_ok: 'ok',
+      runtime_seconds: 1, accrued_cost_usd: 0.01, provider: 'runpod',
+    });
+
+    await sbatchCommand(config, [scriptPath], chalk);
+    expect(process.exitCode).toBe(1);
+  });
+
+  it('errors before touching the network when the script has no command', async () => {
+    const scriptPath = writeScript('empty.slurm', `#!/bin/bash\n#SBATCH --job-name=empty\n`);
+    await sbatchCommand(config, [scriptPath], chalk);
+    expect(process.exitCode).toBe(1);
+    expect(fallback.callWithFallback).not.toHaveBeenCalled();
+  });
+});