badgr-cli 1.1.0 → 1.1.2

package/tests/slurm.test.js

@@ -1,77 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseSlurmScript, envForArrayTask, SlurmParseError } from '../src/slurm.js';
-
-const BASIC = `#!/bin/bash
-#SBATCH --job-name=train
-#SBATCH --cpus-per-task=32
-#SBATCH --mem=128G
-#SBATCH --gres=gpu:a100:2
-#SBATCH --time=02:30:00
-#SBATCH --export=FOO=bar,BAZ=qux
-
-python train.py --epochs 10
-`;
-
-const ARRAY = `#!/bin/bash
-#SBATCH --job-name=screen
-#SBATCH --array=1-100:5
-#SBATCH --gpus=1
-#SBATCH --partition=gpu-fast
-#SBATCH --mail-user=someone@example.com
-
-python screen.py --scenario $SLURM_ARRAY_TASK_ID
-`;
-
-describe('parseSlurmScript', () => {
-  it('parses cpus, mem, gres, time, export', () => {
-    const job = parseSlurmScript(BASIC, { filename: 'train.slurm' });
-    expect(job.name).toBe('train');
-    expect(job.cpus).toBe(32);
-    expect(job.memGb).toBeCloseTo(128);
-    expect(job.gpuCount).toBe(2);
-    expect(job.gpuType).toBe('a100');
-    expect(job.timeMinutes).toBe(150);
-    expect(job.env).toEqual({ FOO: 'bar', BAZ: 'qux' });
-    expect(job.command).toContain('python train.py --epochs 10');
-    expect(job.arrayIndices).toEqual([]);
-  });
-
-  it('parses --array ranges with a step and ignores unknown directives', () => {
-    const job = parseSlurmScript(ARRAY, { filename: 'screen.slurm' });
-    expect(job.arrayIndices).toEqual([1, 6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 56, 61, 66, 71, 76, 81, 86, 91, 96]);
-    expect(job.gpuCount).toBe(1);
-    expect(job.ignoredDirectives).toContain('--partition=gpu-fast');
-    expect(job.ignoredDirectives).toContain('--mail-user=someone@example.com');
-  });
-
-  it('parses mem-per-cpu combined with cpus-per-task', () => {
-    const job = parseSlurmScript(`#SBATCH --cpus-per-task=4\n#SBATCH --mem-per-cpu=2G\necho hi\n`);
-    expect(job.memGb).toBeCloseTo(8);
-  });
-
-  it('parses simple comma/range --array lists', () => {
-    const job = parseSlurmScript(`#SBATCH --array=1,3,5-7\necho hi\n`);
-    expect(job.arrayIndices).toEqual([1, 3, 5, 6, 7]);
-  });
-
-  it('throws when there is no runnable command', () => {
-    expect(() => parseSlurmScript(`#!/bin/bash\n#SBATCH --job-name=empty\n`)).toThrow(SlurmParseError);
-  });
-
-  it('supports export lines in the script body in addition to --export', () => {
-    const job = parseSlurmScript(`#SBATCH --job-name=x\nexport MODE="fast"\npython run.py\n`);
-    expect(job.env.MODE).toBe('fast');
-  });
-});
-
-describe('envForArrayTask', () => {
-  it('injects SLURM_ARRAY_TASK_ID/JOB_ID on top of the base env', () => {
-    const env = envForArrayTask({ FOO: 'bar' }, 7, 'rcpt-123');
-    expect(env).toEqual({ FOO: 'bar', SLURM_ARRAY_TASK_ID: '7', SLURM_ARRAY_JOB_ID: 'rcpt-123' });
-  });
-
-  it('leaves env untouched for non-array jobs', () => {
-    const env = envForArrayTask({ FOO: 'bar' }, null, null);
-    expect(env).toEqual({ FOO: 'bar' });
-  });
-});

package/tests/spec.test.js

@@ -1,201 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseSpec, validateSpec, specLines, parseFlags, normalizeGpuType, VM_CLASSES, LAUNCH_VM_SIZES, vmClassForWorkload, parseGbSize } from '../src/spec.js';
-
-describe('vmClassForWorkload — deterministic workload → VM class table', () => {
-  it('maps playwright to browser', () => expect(vmClassForWorkload('playwright')).toBe('browser'));
-  it('maps cline/claude/codex to small', () => {
-    expect(vmClassForWorkload('cline')).toBe('small');
-    expect(vmClassForWorkload('claude')).toBe('small');
-    expect(vmClassForWorkload('codex')).toBe('small');
-  });
-  it('defaults an unknown/explicit-form workload (null) to small', () => {
-    expect(vmClassForWorkload(null)).toBe('small');
-  });
-  it('every LAUNCH_VM_SIZES entry has a VM_CLASSES definition', () => {
-    for (const size of LAUNCH_VM_SIZES) expect(VM_CLASSES[size]).toBeTruthy();
-  });
-});
-
-describe('normalizeGpuType', () => {
-  it('maps RTX-4090 to RTX_4090', () => expect(normalizeGpuType('RTX-4090')).toBe('RTX_4090'));
-  it('maps rtx4090 to RTX_4090', ()  => expect(normalizeGpuType('rtx4090')).toBe('RTX_4090'));
-  it('maps 4090 to RTX_4090', ()     => expect(normalizeGpuType('4090')).toBe('RTX_4090'));
-  it('maps h100 to H100', ()         => expect(normalizeGpuType('h100')).toBe('H100'));
-  it('maps a100 to A100', ()         => expect(normalizeGpuType('a100')).toBe('A100'));
-  it('defaults null to RTX_4090', () => expect(normalizeGpuType(null)).toBe('RTX_4090'));
-  it('uppercases unknown types', ()  => expect(normalizeGpuType('l40s')).toBe('L40S'));
-});
-
-describe('parseFlags', () => {
-  it('parses --key value pairs', () => {
-    const f = parseFlags(['--model', 'llama-3', '--gpu', 'RTX_4090']);
-    expect(f.model).toBe('llama-3');
-    expect(f.gpu).toBe('RTX_4090');
-  });
-
-  it('parses boolean flags', () => {
-    const f = parseFlags(['--dry-run']);
-    expect(f['dry-run']).toBe(true);
-  });
-
-  it('handles mixed flags and values', () => {
-    const f = parseFlags(['--model', 'gpt2', '--dry-run', '--count', '2']);
-    expect(f.model).toBe('gpt2');
-    expect(f['dry-run']).toBe(true);
-    expect(f.count).toBe('2');
-  });
-});
-
-describe('parseSpec', () => {
-  it('defaults to endpoint type with default model', () => {
-    const spec = parseSpec([]);
-    expect(spec.type).toBe('endpoint');
-    expect(spec.model).toBeTruthy();
-    expect(spec.count).toBe(1);
-    expect(spec.region).toBe('US');
-  });
-
-  it('infers job type from --image', () => {
-    const spec = parseSpec(['--image', 'vllm/vllm-openai:latest']);
-    expect(spec.type).toBe('job');
-    expect(spec.image).toBe('vllm/vllm-openai:latest');
-  });
-
-  it('respects explicit --type', () => {
-    const spec = parseSpec(['--type', 'job', '--image', 'myimg:latest']);
-    expect(spec.type).toBe('job');
-  });
-
-  it('parses all flags', () => {
-    const spec = parseSpec([
-      '--model', 'llama-3',
-      '--gpu', 'H100',
-      '--count', '2',
-      '--region', 'EU',
-      '--max-price', '3.00',
-      '--name', 'my-deploy',
-    ]);
-    expect(spec.model).toBe('llama-3');
-    expect(spec.gpu).toBe('H100');
-    expect(spec.count).toBe(2);
-    expect(spec.region).toBe('EU');
-    expect(spec.maxPrice).toBe(3.00);
-    expect(spec.name).toBe('my-deploy');
-  });
-
-  it('sets dryRun when --dry-run present', () => {
-    const spec = parseSpec(['--dry-run']);
-    expect(spec.dryRun).toBe(true);
-  });
-
-  it('normalizes GPU type', () => {
-    const spec = parseSpec(['--gpu', 'rtx-4090']);
-    expect(spec.gpu).toBe('RTX_4090');
-  });
-
-  it('--endpoint shorthand sets type to endpoint', () => {
-    const spec = parseSpec(['--endpoint', '--model', 'X']);
-    expect(spec.type).toBe('endpoint');
-  });
-
-  it('--job shorthand sets type to job', () => {
-    const spec = parseSpec(['--job', '--image', 'myimg:latest']);
-    expect(spec.type).toBe('job');
-  });
-
-  it('--type takes precedence over shorthands', () => {
-    const spec = parseSpec(['--type', 'job', '--endpoint']);
-    expect(spec.type).toBe('job');
-  });
-
-  it('parses L40S gpu', () => {
-    const spec = parseSpec(['--endpoint', '--model', 'X', '--gpu', 'L40S']);
-    expect(spec.gpu).toBe('L40S');
-  });
-});
-
-describe('validateSpec', () => {
-  it('returns no errors for valid endpoint spec', () => {
-    const spec = parseSpec(['--model', 'llama-3', '--gpu', 'RTX_4090']);
-    expect(validateSpec(spec)).toEqual([]);
-  });
-
-  it('returns error for invalid type', () => {
-    const spec = { ...parseSpec([]), type: 'invalid' };
-    const errors = validateSpec(spec);
-    expect(errors.some(e => e.includes('type'))).toBe(true);
-  });
-
-  it('returns error for count out of range', () => {
-    const spec = { ...parseSpec([]), count: 0 };
-    expect(validateSpec(spec).some(e => e.includes('count'))).toBe(true);
-  });
-
-  it('returns error for invalid region', () => {
-    const spec = { ...parseSpec([]), region: 'MARS' };
-    expect(validateSpec(spec).some(e => e.includes('region'))).toBe(true);
-  });
-});
-
-describe('specLines', () => {
-  it('includes type and gpu', () => {
-    const spec = parseSpec(['--model', 'llama-3', '--gpu', 'RTX_4090']);
-    const lines = specLines(spec);
-    expect(lines.some(l => l.includes('endpoint'))).toBe(true);
-    expect(lines.some(l => l.includes('RTX_4090'))).toBe(true);
-  });
-
-  it('includes model when present', () => {
-    const spec = parseSpec(['--model', 'llama-3']);
-    expect(specLines(spec).some(l => l.includes('llama-3'))).toBe(true);
-  });
-
-  it('omits null fields', () => {
-    const spec = { ...parseSpec([]), maxPrice: null, name: null };
-    const lines = specLines(spec);
-    expect(lines.every(l => l !== null)).toBe(true);
-  });
-});
-
-
-describe('CPU compute sizing', () => {
-  it('selects CPU compute and heuristic size for agent tasks', async () => {
-    const { parseSpec } = await import('../src/spec.js');
-    const spec = parseSpec(['--type', 'job', '--compute', 'cpu', '--agent', 'claude', '--task', 'run e2e tests']);
-    expect(spec.compute).toBe('cpu');
-    expect(spec.gpu).toBe('CPU');
-    expect(spec.cpuSize).toBe('large');
-  });
-});
-
-describe('parseGbSize', () => {
-  it('parses a plain GB suffix', () => {
-    expect(parseGbSize('64GB')).toBe(64);
-    expect(parseGbSize('64G')).toBe(64);
-  });
-
-  it('parses MB/TB/KB and converts to GB', () => {
-    expect(parseGbSize('65536MB')).toBeCloseTo(64);
-    expect(parseGbSize('1TB')).toBe(1024);
-    expect(parseGbSize('1048576KB')).toBeCloseTo(1);
-  });
-
-  it('is case-insensitive', () => {
-    expect(parseGbSize('24gb')).toBe(24);
-  });
-
-  it('defaults a bare number to GB unless bareUnit overrides it', () => {
-    expect(parseGbSize('24')).toBe(24);
-    expect(parseGbSize('2048', { bareUnit: 'M' })).toBe(2);
-  });
-
-  it('accepts a number input directly', () => {
-    expect(parseGbSize(32)).toBe(32);
-  });
-
-  it('returns null for unparseable input', () => {
-    expect(parseGbSize('not-a-size')).toBeNull();
-    expect(parseGbSize(null)).toBeNull();
-    expect(parseGbSize(undefined)).toBeNull();
-  });
-});

package/tests/status.test.js

@@ -1,73 +0,0 @@
-/**
- * badgr status — must show every non-terminal deployment, not just
- * "running"/"provisioning". A live run found deployments stuck in
- * "starting" that used to be silently dropped, reporting "Nothing
- * running" while real billable resources kept running.
- */
-import { describe, it, expect, vi } from 'vitest';
-
-vi.mock('../src/api.js', () => ({
-  listDeployments: vi.fn(),
-}));
-
-vi.mock('../src/store.js', () => ({
-  listDeployments: vi.fn(() => []),
-}));
-
-import { statusCommand } from '../src/commands/status.js';
-import { listDeployments as apiDeployments } from '../src/api.js';
-
-const chalk = new Proxy({}, { get: () => (s) => s });
-
-function makeDep(overrides) {
-  return {
-    deployment_id: 'dep-001',
-    name: 'dep-001',
-    workload_type: 'job',
-    gpu_type: 'A100',
-    gpu_count: 1,
-    cost_per_hour: 0.5,
-    ...overrides,
-  };
-}
-
-async function runStatus(deployments) {
-  apiDeployments.mockResolvedValueOnce({ deployments });
-  const logs = [];
-  const spy = vi.spyOn(console, 'log').mockImplementation((...args) => logs.push(args.join(' ')));
-  await statusCommand({ apiKey: 'test-key' }, [], chalk);
-  spy.mockRestore();
-  return logs.join('\n');
-}
-
-describe('statusCommand', () => {
-  for (const status of ['running', 'provisioning', 'starting', 'queued']) {
-    it(`shows a deployment in "${status}" status as active, not hidden`, async () => {
-      const out = await runStatus([makeDep({ status })]);
-      expect(out).not.toContain('Nothing running');
-      expect(out).toContain('dep-001');
-    });
-  }
-
-  for (const status of ['completed', 'succeeded', 'success', 'failed', 'stopped']) {
-    it(`excludes a deployment in terminal status "${status}"`, async () => {
-      const out = await runStatus([makeDep({ status })]);
-      expect(out).toContain('Nothing running');
-      expect(out).not.toContain('dep-001');
-    });
-  }
-
-  it('reports "Nothing running" when there are no deployments at all', async () => {
-    const out = await runStatus([]);
-    expect(out).toContain('Nothing running');
-  });
-
-  it('shows the running badge for status "running" and a starting-style badge otherwise', async () => {
-    const out = await runStatus([
-      makeDep({ deployment_id: 'dep-run', status: 'running' }),
-      makeDep({ deployment_id: 'dep-start', status: 'starting' }),
-    ]);
-    expect(out).toContain('running');
-    expect(out).toContain('starting');
-  });
-});

package/tests/store.test.js

@@ -1,187 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { rmSync, existsSync } from 'fs';
-import {
-  loadStore, saveStore,
-  addDeployment, updateDeployment, removeDeployment, findDeployment, listDeployments,
-  addReceipt, updateReceipt, listReceipts, findReceipt,
-  generateDeploymentId, generateReceiptId,
-} from '../src/store.js';
-
-const tmp  = join(tmpdir(), `gpu-store-test-${process.pid}`);
-const file = join(tmp, 'deployments.json');
-
-afterEach(() => {
-  if (existsSync(tmp)) rmSync(tmp, { recursive: true, force: true });
-});
-
-const makeDep = (overrides = {}) => ({
-  id:          generateDeploymentId(),
-  name:        'test-dep',
-  type:        'endpoint',
-  gpu:         'RTX_4090',
-  count:       1,
-  status:      'running',
-  provider:    'vastai',
-  endpointUrl: 'https://api.gpu.ai/v1',
-  createdAt:   new Date().toISOString(),
-  ...overrides,
-});
-
-describe('generateDeploymentId / generateReceiptId', () => {
-  it('deploymentId starts with dep-', () => {
-    expect(generateDeploymentId()).toMatch(/^dep-[a-f0-9]{8}$/);
-  });
-
-  it('receiptId starts with rcpt-', () => {
-    expect(generateReceiptId()).toMatch(/^rcpt-[a-f0-9]{10}$/);
-  });
-
-  it('generates unique IDs', () => {
-    const ids = new Set(Array.from({ length: 50 }, () => generateDeploymentId()));
-    expect(ids.size).toBe(50);
-  });
-});
-
-describe('loadStore / saveStore', () => {
-  it('returns empty store when file does not exist', () => {
-    const store = loadStore('/nonexistent/path/deps.json');
-    expect(store.deployments).toEqual([]);
-    expect(store.receipts).toEqual([]);
-  });
-
-  it('round-trips data', () => {
-    const data = { deployments: [makeDep()], receipts: [] };
-    saveStore(data, file);
-    expect(loadStore(file).deployments).toHaveLength(1);
-  });
-});
-
-describe('addDeployment / listDeployments / findDeployment', () => {
-  it('adds and retrieves by id', () => {
-    const dep = makeDep({ id: 'dep-aaa' });
-    addDeployment(dep, file);
-    expect(findDeployment('dep-aaa', file)).toMatchObject({ id: 'dep-aaa' });
-  });
-
-  it('retrieves by name', () => {
-    addDeployment(makeDep({ name: 'my-model' }), file);
-    expect(findDeployment('my-model', file)).toMatchObject({ name: 'my-model' });
-  });
-
-  it('returns null for missing deployment', () => {
-    expect(findDeployment('not-there', file)).toBeNull();
-  });
-
-  it('listDeployments returns all', () => {
-    addDeployment(makeDep({ id: 'dep-1', name: 'd1' }), file);
-    addDeployment(makeDep({ id: 'dep-2', name: 'd2' }), file);
-    expect(listDeployments(file)).toHaveLength(2);
-  });
-});
-
-describe('updateDeployment', () => {
-  it('updates status field', () => {
-    const dep = makeDep({ id: 'dep-upd' });
-    addDeployment(dep, file);
-    const updated = updateDeployment('dep-upd', { status: 'stopped' }, file);
-    expect(updated.status).toBe('stopped');
-    expect(findDeployment('dep-upd', file).status).toBe('stopped');
-  });
-
-  it('returns null for missing deployment', () => {
-    expect(updateDeployment('dep-missing', { status: 'stopped' }, file)).toBeNull();
-  });
-});
-
-describe('removeDeployment', () => {
-  it('removes and returns deployment', () => {
-    addDeployment(makeDep({ id: 'dep-rm' }), file);
-    const removed = removeDeployment('dep-rm', file);
-    expect(removed.id).toBe('dep-rm');
-    expect(findDeployment('dep-rm', file)).toBeNull();
-  });
-
-  it('returns null when not found', () => {
-    expect(removeDeployment('dep-missing', file)).toBeNull();
-  });
-});
-
-describe('addReceipt / listReceipts', () => {
-  it('stores and retrieves receipts newest-first', () => {
-    addReceipt({ receiptId: 'r1', action: 'gpu up' }, file);
-    addReceipt({ receiptId: 'r2', action: 'gpu down' }, file);
-    const receipts = listReceipts(10, file);
-    expect(receipts[0].receiptId).toBe('r2'); // newest first
-    expect(receipts[1].receiptId).toBe('r1');
-  });
-
-  it('respects limit', () => {
-    for (let i = 0; i < 5; i++) {
-      addReceipt({ receiptId: `r${i}`, action: 'gpu up' }, file);
-    }
-    expect(listReceipts(3, file)).toHaveLength(3);
-  });
-});
-
-describe('findReceipt', () => {
-  // comfy.batch / train.lora mint a local rcpt- id that points at a job_id —
-  // `badgr receipts <id>` needs to resolve either the receipt id itself or
-  // the job_id back to the same local record (see receipts.js).
-  it('finds a receipt by its own receiptId', () => {
-    addReceipt({ receiptId: 'rcpt-1', type: 'comfy.batch', job_id: 'job_abc' }, file);
-    const found = findReceipt('rcpt-1', file);
-    expect(found?.job_id).toBe('job_abc');
-  });
-
-  it('finds a receipt by job_id', () => {
-    addReceipt({ receiptId: 'rcpt-2', type: 'train.lora', job_id: 'job_def' }, file);
-    const found = findReceipt('job_def', file);
-    expect(found?.receiptId).toBe('rcpt-2');
-  });
-
-  it('returns null when nothing matches', () => {
-    expect(findReceipt('nope', file)).toBeNull();
-  });
-});
-
-describe('updateReceipt', () => {
-  it('merges updates into an existing receipt', () => {
-    addReceipt({ receiptId: 'r-upd', action: 'badgr run', status: 'running' }, file);
-    updateReceipt('r-upd', { status: 'completed', finalCost: 0.012, runtimeSeconds: 42 }, file);
-    const [r] = listReceipts(1, file);
-    expect(r.status).toBe('completed');
-    expect(r.finalCost).toBe(0.012);
-    expect(r.runtimeSeconds).toBe(42);
-    expect(r.action).toBe('badgr run'); // preserved
-  });
-
-  it('returns null for unknown receipt id', () => {
-    expect(updateReceipt('no-such-id', { status: 'done' }, file)).toBeNull();
-  });
-
-  it('records a serve failure receipt with failureType=infrastructure', () => {
-    addReceipt({
-      receiptId:   'r-serve-fail',
-      action:      'badgr serve',
-      model:       'meta-llama/Llama-3.1-8B-Instruct',
-      gpu:         'L40S',
-      status:      'failed',
-      failureType: 'infrastructure',
-      createdAt:   new Date().toISOString(),
-    }, file);
-    const [r] = listReceipts(1, file);
-    expect(r.failureType).toBe('infrastructure');
-    expect(r.action).toBe('badgr serve');
-    expect(r.status).toBe('failed');
-  });
-
-  it('updates a serve receipt to health_check_timeout', () => {
-    addReceipt({ receiptId: 'r-hc', action: 'badgr serve', status: 'provisioning' }, file);
-    updateReceipt('r-hc', { status: 'health_check_timeout' }, file);
-    const receipts = listReceipts(10, file);
-    const r = receipts.find(x => x.receiptId === 'r-hc');
-    expect(r.status).toBe('health_check_timeout');
-  });
-});

package/tests/task.test.js

@@ -1,109 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { taskCommand } from '../src/commands/task.js';
-
-const chalk = { red: s => s, dim: s => s, green: s => s, bold: s => s, yellow: s => s, cyan: s => s };
-const config = { apiKey: 'test-key', baseUrl: 'https://example.test/v1' };
-
-describe('taskCommand', () => {
-  beforeEach(() => {
-    process.exitCode = undefined;
-    vi.spyOn(console, 'log').mockImplementation(() => {});
-    vi.spyOn(console, 'error').mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    process.exitCode = undefined;
-  });
-
-  it('requires a description', async () => {
-    await taskCommand(config, [], chalk);
-    expect(process.exitCode).toBe(1);
-  });
-
-  it('is a thin wrapper: prints the description, then delegates to `badgr launch . -- <command>`', async () => {
-    await taskCommand(config, [
-      'Run the Chromium tests and tell me what failed',
-      '--dry-run', '--max-cost', '1', '--', 'npm', 'run', 'test:chromium',
-    ], chalk);
-
-    expect(process.exitCode).toBeUndefined();
-    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(logged).toContain('Task: Run the Chromium tests and tell me what failed');
-    expect(logged).toContain('Compute:');
-    expect(logged).toContain('CPU VM');
-    expect(logged).toContain('npm run test:chromium');
-  });
-
-  it('supports an agent prompt as the command', async () => {
-    await taskCommand(config, [
-      'Fix the failing checkout test',
-      '--dry-run', '--max-cost', '1',
-      '--', 'claude', '-p', 'Fix the failing checkout test',
-    ], chalk);
-
-    expect(process.exitCode).toBeUndefined();
-    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(logged).toContain('claude -p Fix the failing checkout test');
-  });
-
-  it('bubbles up errors from the underlying launch (e.g. --gpu rejection)', async () => {
-    await taskCommand(config, [
-      'Fix the checkout bug',
-      '--gpu', 'A100', '--dry-run', '--', 'claude', '-p', 'fix',
-    ], chalk);
-    expect(process.exitCode).toBe(1);
-    const logged = console.error.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(logged).toContain('CPU VM');
-  });
-
-  it('bubbles up a missing-command error the same way badgr launch would', async () => {
-    await taskCommand(config, ['Fix the checkout bug'], chalk);
-    expect(process.exitCode).toBe(1);
-  });
-
-  it('accepts the quoted --cmd form as the command', async () => {
-    await taskCommand(config, [
-      'Run tests',
-      '--dry-run', '--max-cost', '1', '--cmd', 'npm run test:chromium',
-    ], chalk);
-    expect(process.exitCode).toBeUndefined();
-    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(logged).toContain('npm run test:chromium');
-  });
-
-  it('always launches against the current directory, never the description text', async () => {
-    await taskCommand(config, [
-      'Run the Chromium tests',
-      '--dry-run', '--max-cost', '1', '--', 'npm', 'test',
-    ], chalk);
-    expect(process.exitCode).toBeUndefined();
-    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(logged).not.toContain('Source:       Run the Chromium tests');
-  });
-
-  it('forwards --artifacts through to the underlying launch', async () => {
-    await taskCommand(config, [
-      'Run the Chromium tests and tell me what failed',
-      '--dry-run', '--max-cost', '1',
-      '--artifacts', 'playwright-report',
-      '--', 'npx', 'playwright', 'test',
-    ], chalk);
-    expect(process.exitCode).toBeUndefined();
-    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(logged).toContain('Artifacts:');
-    expect(logged).toContain('playwright-report');
-  });
-
-  it('rejects a flag placed before the description instead of silently treating it as the task text', async () => {
-    // Regression: `badgr task --max-cost 1 "fix" -- npm test` used to treat
-    // "--max-cost" itself as the description ("Task: --max-cost"), then fail
-    // downstream with a confusing "Unexpected extra arguments" error that
-    // never explained the real cause.
-    await taskCommand(config, ['--max-cost', '1', 'Fix login bug', '--', 'npm', 'test'], chalk);
-    expect(process.exitCode).toBe(1);
-    const logged = console.error.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(logged).toContain('description must come first');
-    expect(console.log).not.toHaveBeenCalledWith(expect.stringContaining('Task: --max-cost'));
-  });
-});