badgr-cli 1.1.1 → 1.1.3

package/tests/run-lifecycle.test.js

@@ -1,1054 +0,0 @@
-/**
- * badgr run — end-to-end lifecycle tests (mocked API)
- *
- * Covers the launch-readiness matrix:
- *   - Successful run on two GPU types (A100, L40S) via two providers (runpod, vastai)
- *   - Job exits non-zero  → receipt failureType = customer_code
- *   - Job exceeds max runtime  → teardown called, receipt reason = max-runtime
- *   - Job exceeds max cost     → teardown called, receipt reason = max-cost
- *   - Container fails before running (infrastructure)
- *   - Heartbeat lost mid-run   → teardown called, receipt reason = heartbeat-lost
- *   - Log streaming            → log lines appear in console output
- *   - Tier-1 unavailable       → auto-expand to tier-2, receipt records tier
- *   - No capacity at all       → CapacityError displayed, exitCode = 1
- *   - Billing stops            → terminateDeployment called on every terminal path
- *   - 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({ 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(),
-  generateReceiptId:    vi.fn(() => 'rcpt-launch-001'),
-  generateDeploymentId: vi.fn(() => 'dep-launch-001'),
-  listDeployments:      vi.fn(() => []),
-  listReceipts:         vi.fn(() => []),
-  findDeployment:       vi.fn(() => null),
-  updateDeployment:     vi.fn(),
-  removeDeployment:     vi.fn(),
-}));
-
-// Imported after mock declarations so we get the mocked versions
-import * as api   from '../src/api.js';
-import * as store from '../src/store.js';
-
-// ── Helpers ───────────────────────────────────────────────────────────────────
-
-const config = { apiKey: 'sk-test', baseUrl: 'https://api.test/v1' };
-
-// Chalk no-op (the real chalk would add ANSI codes, which makes assertions noisy)
-const chalk = {
-  bold:   s => s,
-  dim:    s => s,
-  red:    s => s,
-  yellow: s => s,
-  green:  s => s,
-  cyan:   s => s,
-};
-
-function makeDep(overrides = {}) {
-  return {
-    deployment_id: 'dep-launch-001',
-    status:        'running',
-    gpu_type:      'A100',
-    gpu_count:     1,
-    cost_per_hour: 2.50,
-    provider:      'runpod',
-    receipt_id:    'rcpt-launch-001',
-    tier:          '1',
-    ...overrides,
-  };
-}
-
-// Standard happy-path sequence: POST /run → GET /deployments → GET /logs → (no DELETE needed for success)
-function setupSuccessfulRun(depOverrides = {}, exitCode = 0) {
-  api.callApi
-    .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({ teardown_ok: 'ok' });
-}
-
-// ── Setup / teardown ─────────────────────────────────────────────────────────
-
-// Suppress MaxListenersExceededWarning — each runCommand call adds a SIGINT listener
-// and we run many tests in sequence.
-process.setMaxListeners(50);
-
-beforeEach(() => {
-  // Explicitly list what to fake — vitest 4.x also fakes queueMicrotask and
-  // nextTick by default which deadlocks await-inside-while-loop patterns.
-  vi.useFakeTimers({
-    toFake: ['setTimeout', 'setInterval', 'clearTimeout', 'clearInterval', 'Date', 'performance', 'setImmediate', 'clearImmediate'],
-  });
-  process.exitCode = undefined;
-  vi.spyOn(console, 'log').mockImplementation(() => {});
-  vi.spyOn(console, 'error').mockImplementation(() => {});
-  vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-  // resetAllMocks clears both call history AND the mockResolvedValueOnce queue
-  // (clearAllMocks only clears history in vitest 4.x, leaving stale queued values
-  // that can corrupt subsequent tests).
-  vi.resetAllMocks();
-  // Restore default mock return values cleared by resetAllMocks
-  store.generateReceiptId.mockReturnValue('rcpt-launch-001');
-  store.generateDeploymentId.mockReturnValue('dep-launch-001');
-  store.listDeployments.mockReturnValue([]);
-  store.listReceipts.mockReturnValue([]);
-  store.findDeployment.mockReturnValue(null);
-  api.terminateDeployment.mockResolvedValue({ teardown_ok: 'ok' });
-  api.uploadBlob.mockResolvedValue({ code_uri: 'blob://project.zip' });
-});
-
-afterEach(() => {
-  vi.useRealTimers();
-  vi.restoreAllMocks();
-  process.exitCode = undefined;
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// 1. GPU / provider matrix
-// ─────────────────────────────────────────────────────────────────────────────
-
-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', '--max-cost', '5'], chalk);
-    await vi.advanceTimersByTimeAsync(5000);
-    await p;
-
-    expect(api.callApi).toHaveBeenCalledWith('/run', expect.objectContaining({ method: 'POST' }));
-    expect(store.addReceipt).toHaveBeenCalledWith(expect.objectContaining({
-      gpu:           'A100',
-      providerRoute: 'runpod',
-      tier:          '1',
-    }));
-    expect(store.updateReceipt).toHaveBeenCalledWith('rcpt-launch-001', expect.objectContaining({
-      status:   'completed',
-      exitCode: 0,
-    }));
-    expect(process.exitCode).toBeFalsy();
-  });
-
-  it('L40S via Vast.ai (tier-1) completes successfully', async () => {
-    api.callApi
-      .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', '--max-cost', '5'], chalk);
-    await vi.advanceTimersByTimeAsync(5000);
-    await p;
-
-    expect(store.addReceipt).toHaveBeenCalledWith(expect.objectContaining({
-      gpu:           'L40S',
-      providerRoute: 'vastai',
-    }));
-    expect(store.updateReceipt).toHaveBeenCalledWith('rcpt-launch-001', expect.objectContaining({
-      status:   'completed',
-      exitCode: 0,
-    }));
-    expect(process.exitCode).toBeFalsy();
-  });
-});
-
-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
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('non-zero exit code', () => {
-  it('records customer_code failure and sets exitCode', 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;
-
-    expect(store.updateReceipt).toHaveBeenCalledWith('rcpt-launch-001', expect.objectContaining({
-      exitCode:    1,
-      failureType: 'customer_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())
-      .mockResolvedValueOnce({ status: 'failed', exit_code: null })
-      .mockResolvedValueOnce({ logs: [] });
-    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
-    await vi.advanceTimersByTimeAsync(5000);
-    await p;
-
-    expect(store.updateReceipt).toHaveBeenCalledWith('rcpt-launch-001', expect.objectContaining({
-      failureType: 'infrastructure',
-    }));
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// 3. Container fails to start (infrastructure failure before running)
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('container fails to start', () => {
-  it('reports infrastructure error when dep arrives already failed', async () => {
-    api.callApi
-      .mockResolvedValueOnce(makeDep({ status: 'failed' })) // POST /run returns already-failed
-      .mockResolvedValueOnce({ logs: [] });
-    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
-    await vi.advanceTimersByTimeAsync(1000);
-    await p;
-
-    // runCommand exits with process.exitCode = 1 when dep.status === 'failed' after provision
-    expect(process.exitCode).toBe(1);
-  });
-
-  it('reports infrastructure error when waitForRunning resolves to failed', async () => {
-    api.callApi
-      .mockResolvedValueOnce(makeDep({ status: 'provisioning' })) // POST /run → provisioning
-      .mockResolvedValueOnce({ status: 'failed' });               // poll → failed
-    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
-    // advance past POLL_MS (3000ms) in waitForRunning
-    await vi.advanceTimersByTimeAsync(4000);
-    await p;
-
-    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);
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// 4. Max-runtime cap
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('max-runtime cap', () => {
-  it('stops job and records max-runtime when runtime exceeded', async () => {
-    // max-runtime 0.05 min = 3 seconds; ratePerHour = 2.50
-    api.callApi
-      .mockResolvedValueOnce(makeDep({ cost_per_hour: 2.50 }))  // POST /run
-      .mockResolvedValueOnce({ status: 'running', exit_code: null }) // poll 1
-      .mockResolvedValueOnce({ logs: [] });                          // logs 1
-    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)
-    await vi.advanceTimersByTimeAsync(5000);
-    await p;
-
-    expect(api.terminateDeployment).toHaveBeenCalledWith(config, 'dep-launch-001');
-    expect(store.updateReceipt).toHaveBeenCalledWith('rcpt-launch-001', expect.objectContaining({
-      status:         'max-runtime',
-      teardownStatus: 'terminated',
-    }));
-    expect(process.exitCode).toBe(1);
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// 5. Max-cost cap
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('max-cost cap', () => {
-  it('stops job and records max-cost when budget exceeded', async () => {
-    // ratePerHour = 3600 ($1/s), maxCost = 0.001 → cap fires after 3.6ms, but poll fires at 4000ms
-    api.callApi
-      .mockResolvedValueOnce(makeDep({ cost_per_hour: 3600 })) // POST /run
-      .mockResolvedValueOnce({ status: 'running' })            // poll 1 (never reached — cap fires first)
-      .mockResolvedValueOnce({ logs: [] });
-    api.terminateDeployment.mockResolvedValue({ teardown_ok: 'ok' });
-
-    const p = runCommand(config, ['python', 'train.py', '--max-cost', '0.001'], chalk);
-    await vi.advanceTimersByTimeAsync(5000);
-    await p;
-
-    expect(api.terminateDeployment).toHaveBeenCalledWith(config, 'dep-launch-001');
-    expect(store.updateReceipt).toHaveBeenCalledWith('rcpt-launch-001', expect.objectContaining({
-      status:         'max-cost',
-      teardownStatus: 'terminated',
-    }));
-    expect(process.exitCode).toBe(1);
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// 6. Heartbeat lost
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('heartbeat lost', () => {
-  it('stops job and records heartbeat-lost after HEARTBEAT_KILL_POLLS consecutive errors', async () => {
-    // HEARTBEAT_KILL_POLLS = 15; POLL_MS = 4000ms
-    // First dep poll must succeed and return 'running' (to set lastStatus = 'running').
-    // After that, 15 consecutive failures trigger the kill.
-    // Total timer advances: (1 success + 15 failures) × 4000ms = 64000ms
-    api.callApi
-      .mockResolvedValueOnce(makeDep({ status: 'running' })) // POST /run
-      .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({ 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
-    await vi.advanceTimersByTimeAsync(66000);
-    await p;
-
-    expect(api.terminateDeployment).toHaveBeenCalledWith(config, 'dep-launch-001');
-
-    // teardown() writes first: billing stopped, status = 'heartbeat-lost'
-    expect(store.updateReceipt).toHaveBeenCalledWith('rcpt-launch-001', expect.objectContaining({
-      status:         'heartbeat-lost',
-      teardownStatus: 'terminated',
-    }));
-    // runCommand writes second: final summary with failureType
-    expect(store.updateReceipt).toHaveBeenCalledWith('rcpt-launch-001', expect.objectContaining({
-      failureType: 'infrastructure',
-    }));
-    expect(process.exitCode).toBeTruthy();
-  }, 30000 /* 30s real timeout — fake timers advance instantly but need sufficient budget */);
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// 7. Log streaming
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('log streaming', () => {
-  it('prints user-visible log lines and suppresses meta-lines', async () => {
-    const logLines = [];
-    console.log.mockImplementation((...args) => logLines.push(args.join(' ')));
-
-    api.callApi
-      .mockResolvedValueOnce(makeDep())
-      .mockResolvedValueOnce({ status: 'completed', exit_code: 0 })
-      .mockResolvedValueOnce({ logs: [
-        'Epoch 1/3: loss=0.42',                         // should appear
-        '[dep-abc] status=running',                     // meta → should be filtered
-        '[dep-abc] gpu_util=72%',                       // meta → should be filtered
-        'Epoch 2/3: loss=0.31',                         // should appear
-      ]});
-
-    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
-    await vi.advanceTimersByTimeAsync(5000);
-    await p;
-
-    const joined = logLines.join('\n');
-    expect(joined).toContain('Epoch 1/3: loss=0.42');
-    expect(joined).toContain('Epoch 2/3: loss=0.31');
-    // Meta-lines are filtered by the LOG_META_RE in run.js
-    expect(joined).not.toContain('[dep-abc] status=running');
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// 8. Routing: tier-1 unavailable → auto-expand to tier-2
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('routing fallback', () => {
-  it('expands to tier-2 when tier-1 returns NO_CAPACITY_MATCH', async () => {
-    const capacityErr = Object.assign(new Error('no capacity'), {
-      errorData: { code: 'NO_CAPACITY_MATCH' },
-      httpStatus: 503,
-    });
-    api.callApi
-      .mockRejectedValueOnce(capacityErr)                                     // tier-1 attempt
-      .mockResolvedValueOnce(makeDep({ provider: 'vastai', tier: '2' }))      // tier-2 succeeds
-      .mockResolvedValueOnce({ status: 'completed', exit_code: 0 })
-      .mockResolvedValueOnce({ logs: [] });
-
-    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
-    await vi.advanceTimersByTimeAsync(5000);
-    await p;
-
-    // Should have been called twice: once for tier-1, once for tier-2
-    const postCalls = api.callApi.mock.calls.filter(c => c[1]?.method === 'POST');
-    expect(postCalls.length).toBeGreaterThanOrEqual(2);
-
-    expect(store.addReceipt).toHaveBeenCalledWith(expect.objectContaining({
-      providerRoute: 'vastai',
-      tier:          '2',
-    }));
-    expect(process.exitCode).toBeFalsy();
-  });
-
-  it('reports CapacityError when both tiers fail', async () => {
-    const capacityErr = Object.assign(new Error('no capacity'), {
-      errorData: { code: 'NO_CAPACITY_MATCH' },
-      httpStatus: 503,
-    });
-    api.callApi.mockRejectedValue(capacityErr);
-
-    const logs = [];
-    console.error.mockImplementation(msg => logs.push(msg));
-
-    await runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
-
-    expect(process.exitCode).toBe(1);
-    const combined = logs.join('\n');
-    expect(combined).toMatch(/No suitable GPU capacity|capacity/i);
-  });
-
-  it('does not fall back to tier-2 when --no-fallback is set', async () => {
-    const capacityErr = Object.assign(new Error('no capacity'), {
-      errorData: { code: 'NO_CAPACITY_MATCH' },
-      httpStatus: 503,
-    });
-    api.callApi.mockRejectedValueOnce(capacityErr);
-
-    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');
-    expect(postCalls.length).toBe(1);
-    expect(process.exitCode).toBe(1);
-  });
-
-  it('PROVISIONING_FAILED error is surfaced clearly without showing internal debug info by default', async () => {
-    const provErr = Object.assign(new Error('provisioning failed'), {
-      errorData: { code: 'PROVISIONING_FAILED', debug_error: 'CUDA driver mismatch' },
-      httpStatus: 503,
-    });
-    api.callApi.mockRejectedValue(provErr);
-
-    const errLines = [];
-    console.error.mockImplementation(msg => errLines.push(msg));
-
-    await runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
-
-    expect(process.exitCode).toBe(1);
-    const combined = errLines.join('\n');
-    expect(combined).not.toContain('CUDA driver mismatch'); // debug info hidden by default
-    expect(combined).toMatch(/try again|failed to start/i);
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// 9. Payment required
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('payment required', () => {
-  it('shows billing message and rerun hint, exits 1', async () => {
-    const payErr = Object.assign(new Error('Payment required'), {
-      isPaymentRequired: true,
-      httpStatus: 402,
-    });
-    api.callApi.mockRejectedValueOnce(payErr);
-
-    const errLines = [];
-    console.error.mockImplementation(msg => errLines.push(msg));
-
-    await runCommand(config, ['python', 'train.py', '--gpu', 'A100', '--max-cost', '5'], chalk);
-
-    expect(process.exitCode).toBe(1);
-    const combined = errLines.join('\n');
-    expect(combined).toContain('Payment required');
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// 10. Billing stops — terminateDeployment called on every terminal path
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('billing lifecycle', () => {
-  it('terminateDeployment is called after successful completion', async () => {
-    setupSuccessfulRun();
-    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');
-  });
-
-  it('receipt records runtime and finalCost on completion', async () => {
-    setupSuccessfulRun({ cost_per_hour: 1.80 });
-    const p = runCommand(config, ['python', 'train.py', '--max-cost', '5'], chalk);
-    await vi.advanceTimersByTimeAsync(5000);
-    await p;
-
-    const updateCall = store.updateReceipt.mock.calls.find(
-      c => c[1]?.runtimeSeconds !== undefined,
-    );
-    expect(updateCall).toBeTruthy();
-    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');
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// 11. Input validation before provisioning
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('input validation', () => {
-  it('rejects --count 0 before any API call', async () => {
-    await runCommand(config, ['python', 'train.py', '--count', '0'], chalk);
-    expect(api.callApi).not.toHaveBeenCalled();
-    expect(process.exitCode).toBe(1);
-  });
-
-  it('rejects --max-cost 0 before any API call', async () => {
-    await runCommand(config, ['python', 'train.py', '--max-cost', '0'], chalk);
-    expect(api.callApi).not.toHaveBeenCalled();
-    expect(process.exitCode).toBe(1);
-  });
-
-  it('rejects unknown --region before any API call', async () => {
-    await runCommand(config, ['python', 'train.py', '--region', 'MARS'], chalk);
-    expect(api.callApi).not.toHaveBeenCalled();
-    expect(process.exitCode).toBe(1);
-  });
-
-  it('rejects empty command with no --image', async () => {
-    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();
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// 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);
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// 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;
-  });
-});