badgr-cli 1.1.1 → 1.1.2

package/tests/fanout.test.js

@@ -1,124 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { runFanOut } from '../src/fanout.js';
-
-describe('runFanOut', () => {
-  it('submits and monitors every task, preserving input order in results', async () => {
-    const submitTask = vi.fn(async (task) => ({ deploymentId: `dep-${task}`, receiptId: `rcpt-${task}`, ratePerHour: 1 }));
-    const monitorTask = vi.fn(async ({ deploymentId }) => ({ status: 'succeeded', succeeded: true, runtimeMs: 1000, deploymentId }));
-
-    const { results, allSucceeded, submittedCount, failedSubmitCount } = await runFanOut({
-      tasks: ['a', 'b', 'c'],
-      submitTask,
-      monitorTask,
-    });
-
-    expect(submitTask).toHaveBeenCalledTimes(3);
-    expect(monitorTask).toHaveBeenCalledTimes(3);
-    expect(results.map(r => r.task)).toEqual(['a', 'b', 'c']);
-    expect(results.every(r => r.succeeded)).toBe(true);
-    expect(allSucceeded).toBe(true);
-    expect(submittedCount).toBe(3);
-    expect(failedSubmitCount).toBe(0);
-  });
-
-  it('keeps a task that fails to submit out of monitoring, marks it as an error, and reports allSucceeded=false', async () => {
-    const submitTask = vi.fn(async (task) => {
-      if (task === 'bad') throw new Error('capacity exhausted');
-      return { deploymentId: `dep-${task}`, receiptId: `rcpt-${task}`, ratePerHour: 1 };
-    });
-    const monitorTask = vi.fn(async ({ deploymentId }) => ({ status: 'succeeded', succeeded: true, runtimeMs: 500, deploymentId }));
-    const onSubmitError = vi.fn();
-
-    const { results, allSucceeded, submittedCount, failedSubmitCount } = await runFanOut({
-      tasks: ['ok1', 'bad', 'ok2'],
-      submitTask,
-      monitorTask,
-      onSubmitError,
-    });
-
-    expect(monitorTask).toHaveBeenCalledTimes(2);
-    expect(onSubmitError).toHaveBeenCalledWith('bad', expect.any(Error));
-    expect(results[1]).toMatchObject({ task: 'bad', error: expect.any(Error) });
-    expect(results[0].succeeded).toBe(true);
-    expect(results[2].succeeded).toBe(true);
-    expect(allSucceeded).toBe(false);
-    expect(submittedCount).toBe(2);
-    expect(failedSubmitCount).toBe(1);
-  });
-
-  it('reports allSucceeded=false when a monitored task does not succeed', async () => {
-    const submitTask = vi.fn(async (task) => ({ deploymentId: `dep-${task}`, receiptId: `rcpt-${task}`, ratePerHour: 1 }));
-    const monitorTask = vi.fn(async ({ deploymentId }) =>
-      deploymentId === 'dep-b'
-        ? { status: 'failed', succeeded: false, runtimeMs: 200 }
-        : { status: 'succeeded', succeeded: true, runtimeMs: 200 });
-
-    const { allSucceeded, results } = await runFanOut({
-      tasks: ['a', 'b'],
-      submitTask,
-      monitorTask,
-    });
-
-    expect(allSucceeded).toBe(false);
-    expect(results.find(r => r.task === 'b').succeeded).toBe(false);
-  });
-
-  it('never exceeds the configured concurrency — no more than N tasks in flight at once', async () => {
-    let inFlight = 0;
-    let maxInFlight = 0;
-    const submitTask = vi.fn(async (task) => ({ deploymentId: `dep-${task}`, receiptId: `rcpt-${task}`, ratePerHour: 1 }));
-    const monitorTask = vi.fn(async ({ deploymentId }) => {
-      inFlight++;
-      maxInFlight = Math.max(maxInFlight, inFlight);
-      await new Promise(r => setTimeout(r, 5));
-      inFlight--;
-      return { status: 'succeeded', succeeded: true, runtimeMs: 5, deploymentId };
-    });
-
-    await runFanOut({ tasks: ['a', 'b', 'c', 'd', 'e', 'f'], submitTask, monitorTask, concurrency: 2 });
-
-    expect(maxInFlight).toBeLessThanOrEqual(2);
-  });
-
-  it('defaults to a bounded concurrency (5) when none is given — never unbounded', async () => {
-    let inFlight = 0;
-    let maxInFlight = 0;
-    const submitTask = vi.fn(async (task) => ({ deploymentId: `dep-${task}`, receiptId: `rcpt-${task}`, ratePerHour: 1 }));
-    const monitorTask = vi.fn(async ({ deploymentId }) => {
-      inFlight++;
-      maxInFlight = Math.max(maxInFlight, inFlight);
-      await new Promise(r => setTimeout(r, 5));
-      inFlight--;
-      return { status: 'succeeded', succeeded: true, runtimeMs: 5, deploymentId };
-    });
-
-    const tasks = Array.from({ length: 12 }, (_, i) => `t${i}`);
-    await runFanOut({ tasks, submitTask, monitorTask });
-
-    expect(maxInFlight).toBeLessThanOrEqual(5);
-  });
-
-  it('preserves original task order in results even with concurrency > 1', async () => {
-    const submitTask = vi.fn(async (task) => ({ deploymentId: `dep-${task}`, receiptId: `rcpt-${task}`, ratePerHour: 1 }));
-    const monitorTask = vi.fn(async ({ task, deploymentId }) => {
-      // Later tasks resolve faster, to prove ordering isn't just resolution order.
-      await new Promise(r => setTimeout(r, task === 'a' ? 20 : 1));
-      return { status: 'succeeded', succeeded: true, runtimeMs: 1, deploymentId };
-    });
-
-    const { results } = await runFanOut({ tasks: ['a', 'b', 'c'], submitTask, monitorTask, concurrency: 3 });
-
-    expect(results.map(r => r.task)).toEqual(['a', 'b', 'c']);
-  });
-
-  it('runs with an empty task list without submitting or monitoring anything', async () => {
-    const submitTask = vi.fn();
-    const monitorTask = vi.fn();
-    const { results, allSucceeded, submittedCount } = await runFanOut({ tasks: [], submitTask, monitorTask });
-    expect(submitTask).not.toHaveBeenCalled();
-    expect(monitorTask).not.toHaveBeenCalled();
-    expect(results).toEqual([]);
-    expect(submittedCount).toBe(0);
-    expect(allSucceeded).toBe(true); // vacuously true — no tasks, nothing failed
-  });
-});

package/tests/gpu-doctor-classifiers.test.js

@@ -1,402 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { classifyLog } from '../src/gpuDoctor/logClassifier.js';
-import { estimateModelParamsB, detectQuantization, estimateModelFit } from '../src/gpuDoctor/modelFit.js';
-import { diagnoseWorkflow, parseWorkflowFile } from '../src/gpuDoctor/workflowDoctor.js';
-import { checkHealth } from '../src/gpuDoctor/healthCheck.js';
-import { redactLine } from '../src/gpuDoctor/redact.js';
-import { parseDoctorArgs } from '../src/commands/doctor.js';
-
-describe('classifyLog — vram_oom', () => {
-  it('classifies CUDA OOM + EngineDeadError + worker died as vram_oom', () => {
-    const log = [
-      'INFO engine starting',
-      'torch.cuda.OutOfMemoryError: CUDA out of memory. Tried to allocate 2.00 GiB',
-      'ERROR: EngineDeadError: engine core process died',
-      'ERROR: worker died',
-    ].join('\n');
-    const result = classifyLog(log);
-    expect(result.matched).toBe(true);
-    expect(result.category).toBe('vram_oom');
-    expect(result.fixes.some((f) => /quantiz/i.test(f))).toBe(true);
-  });
-});
-
-describe('classifyLog — cuda_pytorch_mismatch', () => {
-  it('classifies illegal memory access as cuda mismatch', () => {
-    const result = classifyLog('RuntimeError: CUDA error: an illegal memory access was encountered');
-    expect(result.category).toBe('cuda_pytorch_mismatch');
-  });
-
-  it('classifies CPU-only torch build message', () => {
-    const result = classifyLog('AssertionError: Torch not compiled with CUDA enabled');
-    expect(result.category).toBe('cuda_pytorch_mismatch');
-  });
-});
-
-describe('classifyLog — nccl_distributed', () => {
-  it('classifies NCCL timeout', () => {
-    const result = classifyLog('[E ProcessGroupNCCL.cpp:475] Watchdog caught collective operation timeout: NCCL timeout');
-    expect(result.category).toBe('nccl_distributed');
-  });
-});
-
-describe('classifyLog — missing_model', () => {
-  it('classifies a 404 from the hub as missing model', () => {
-    const result = classifyLog('huggingface_hub.utils._errors.RepositoryNotFoundError: 404 Client Error. Repository Not Found for url');
-    expect(result.category).toBe('missing_model');
-  });
-});
-
-describe('classifyLog — missing_dependency', () => {
-  it('classifies ModuleNotFoundError', () => {
-    const result = classifyLog('ModuleNotFoundError: No module named \'vllm\'');
-    expect(result.category).toBe('missing_dependency');
-  });
-});
-
-describe('classifyLog — health_check', () => {
-  it('classifies connection refused as health_check', () => {
-    const result = classifyLog('curl: (7) Failed to connect to localhost port 8000: Connection refused');
-    expect(result.category).toBe('health_check');
-  });
-});
-
-describe('classifyLog — provider_pod_issue', () => {
-  it('classifies pod preemption', () => {
-    const result = classifyLog('WARNING: pod preempted by scheduler, instance reclaimed');
-    expect(result.category).toBe('provider_pod_issue');
-  });
-});
-
-describe('classifyLog — disk_cache', () => {
-  it('classifies out-of-disk errors', () => {
-    const result = classifyLog('OSError: [Errno 28] No space left on device');
-    expect(result.category).toBe('disk_cache');
-  });
-});
-
-describe('classifyLog — unknown', () => {
-  it('falls back to unknown for unrecognized text', () => {
-    const result = classifyLog('this is a totally normal log line with no failure signature');
-    expect(result.matched).toBe(false);
-    expect(result.category).toBe('unknown');
-  });
-});
-
-describe('modelFit — estimateModelParamsB / detectQuantization', () => {
-  it('parses common size labels', () => {
-    expect(estimateModelParamsB('Qwen/Qwen2.5-7B-Instruct')).toBe(7);
-    expect(estimateModelParamsB('meta-llama/Llama-3.1-8B-Instruct')).toBe(8);
-    expect(estimateModelParamsB('Qwen/Qwen2.5-14B-Instruct')).toBe(14);
-    expect(estimateModelParamsB('Qwen/Qwen2.5-32B-Instruct')).toBe(32);
-    expect(estimateModelParamsB('meta-llama/Llama-3.1-70B-Instruct')).toBe(70);
-  });
-
-  it('returns null when no size label is present', () => {
-    expect(estimateModelParamsB('my-custom-model')).toBeNull();
-  });
-
-  it('detects quantization tags', () => {
-    expect(detectQuantization('TheBloke/Llama-2-7B-AWQ')).toBe('awq');
-    expect(detectQuantization('TheBloke/Llama-2-7B-GPTQ')).toBe('gptq');
-    expect(detectQuantization('model-fp8')).toBe('fp8');
-    expect(detectQuantization('model-4bit')).toBe('4bit');
-    expect(detectQuantization('Qwen/Qwen2.5-7B-Instruct')).toBeNull();
-  });
-});
-
-describe('estimateModelFit', () => {
-  it('estimates a small model comfortably under 24GB', () => {
-    const est = estimateModelFit('Qwen/Qwen2.5-7B-Instruct');
-    expect(est.paramsB).toBe(7);
-    expect(est.vramMaxGb).toBeLessThanOrEqual(24);
-  });
-
-  it('estimates a 70B model as needing 80GB+ class', () => {
-    const est = estimateModelFit('meta-llama/Llama-3.1-70B-Instruct');
-    expect(est.paramsB).toBe(70);
-    expect(est.vramMinGb).toBeGreaterThan(24);
-    expect(est.recommendedGpuClass).toMatch(/80GB\+|multi-GPU/);
-  });
-
-  it('returns null estimate for an unrecognized size label', () => {
-    const est = estimateModelFit('my-custom-model');
-    expect(est.paramsB).toBeNull();
-    expect(est.vramMaxGb).toBeNull();
-    expect(est.perGpuVramMaxGb).toBeNull();
-  });
-
-  it('defaults to gpuCount 1, where per-GPU figures equal the totals', () => {
-    const est = estimateModelFit('meta-llama/Llama-3.1-70B-Instruct');
-    expect(est.gpuCount).toBe(1);
-    expect(est.perGpuVramMinGb).toBe(est.vramMinGb);
-    expect(est.perGpuVramMaxGb).toBe(est.vramMaxGb);
-  });
-
-  it('shards weights across gpuCount, dividing per-GPU VRAM while the total stays the same', () => {
-    const single = estimateModelFit('meta-llama/Llama-3.1-70B-Instruct-AWQ', { gpuCount: 1 });
-    const quad = estimateModelFit('meta-llama/Llama-3.1-70B-Instruct-AWQ', { gpuCount: 4 });
-    expect(quad.vramMaxGb).toBe(single.vramMaxGb);
-    expect(quad.perGpuVramMaxGb).toBeLessThan(single.perGpuVramMaxGb);
-    expect(quad.recommendedGpuClass).not.toBe(single.recommendedGpuClass);
-  });
-
-  it('treats a fractional or zero gpuCount as 1 rather than dividing by <1 or 0', () => {
-    const est = estimateModelFit('Qwen/Qwen2.5-7B-Instruct', { gpuCount: 0 });
-    expect(est.gpuCount).toBe(1);
-    expect(est.perGpuVramMaxGb).toBe(est.vramMaxGb);
-  });
-});
-
-describe('diagnoseWorkflow — SDXL', () => {
-  it('detects SDXL checkpoint, models, and a custom node', () => {
-    const workflow = {
-      1: { class_type: 'CheckpointLoaderSimple', inputs: { ckpt_name: 'sd_xl_base_1.0.safetensors' } },
-      2: { class_type: 'KSampler', inputs: {} },
-      3: { class_type: 'ImpactWildcardEncode', inputs: {} },
-    };
-    const result = diagnoseWorkflow(workflow);
-    expect(result.likelyClass).toBe('SDXL');
-    expect(result.models).toContain('sd_xl_base_1.0.safetensors');
-    expect(result.customNodes).toContain('ImpactWildcardEncode');
-    expect(result.vramBucket).toMatch(/12/);
-  });
-});
-
-describe('diagnoseWorkflow — Flux', () => {
-  it('detects a Flux workflow from checkpoint filename', () => {
-    const workflow = {
-      1: { class_type: 'UNETLoader', inputs: { unet_name: 'flux1-dev.safetensors' } },
-      2: { class_type: 'KSampler', inputs: {} },
-    };
-    const result = diagnoseWorkflow(workflow);
-    expect(result.likelyClass).toBe('Flux');
-  });
-});
-
-describe('diagnoseWorkflow — parseWorkflowFile', () => {
-  it('parses raw JSON text', () => {
-    const raw = JSON.stringify({ 1: { class_type: 'CheckpointLoaderSimple', inputs: {} } });
-    const workflow = parseWorkflowFile(raw);
-    expect(diagnoseWorkflow(workflow).nodeCount).toBe(1);
-  });
-
-  it('throws on invalid JSON', () => {
-    expect(() => parseWorkflowFile('not json')).toThrow();
-  });
-});
-
-describe('checkHealth', () => {
-  it('classifies a healthy 200 response as ready', async () => {
-    const fetchImpl = async () => new Response(JSON.stringify({ data: [{ id: 'model-a' }] }), { status: 200 });
-    const result = await checkHealth('http://localhost:8000/v1/models', { fetchImpl });
-    expect(result.reachable).toBe(true);
-    expect(result.ready).toBe(true);
-    expect(result.modelsCount).toBe(1);
-  });
-
-  it('classifies a non-2xx response as unhealthy', async () => {
-    const fetchImpl = async () => new Response('error', { status: 503 });
-    const result = await checkHealth('http://localhost:8000/health', { fetchImpl });
-    expect(result.reachable).toBe(true);
-    expect(result.ready).toBe(false);
-    expect(result.classification).toBe('endpoint unhealthy');
-  });
-
-  it('classifies a connection refused error', async () => {
-    const err = new Error('fetch failed');
-    err.cause = { code: 'ECONNREFUSED' };
-    const fetchImpl = async () => { throw err; };
-    const result = await checkHealth('http://localhost:1/', { fetchImpl });
-    expect(result.reachable).toBe(false);
-    expect(result.classification).toBe('connection refused');
-  });
-
-  it('classifies a timeout', async () => {
-    const err = new Error('The operation was aborted');
-    err.name = 'TimeoutError';
-    const fetchImpl = async () => { throw err; };
-    const result = await checkHealth('http://localhost:1/', { fetchImpl });
-    expect(result.reachable).toBe(false);
-    expect(result.classification).toBe('timeout');
-  });
-
-  it('does not crash on a malformed URL string', async () => {
-    const result = await checkHealth('not-a-valid-url');
-    expect(result.reachable).toBe(false);
-    expect(result.status).toBeNull();
-  });
-
-  it('classifies a ComfyUI /system_stats response by its devices array', async () => {
-    const fetchImpl = async () => new Response(JSON.stringify({ system: { os: 'posix' }, devices: [{ name: 'cuda:0' }] }), { status: 200 });
-    const result = await checkHealth('http://localhost:8188/system_stats', { fetchImpl });
-    expect(result.serviceKind).toBe('comfyui');
-    expect(result.detail).toMatch(/1 device\(s\) reported/);
-  });
-
-  it('classifies a llama.cpp-style {status} response', async () => {
-    const fetchImpl = async () => new Response(JSON.stringify({ status: 'loading model' }), { status: 200 });
-    const result = await checkHealth('http://localhost:8080/health', { fetchImpl });
-    expect(result.serviceKind).toBe('llamacpp');
-    expect(result.detail).toBe('status: loading model');
-  });
-
-  it('classifies a generic {healthy: true/false} response', async () => {
-    const fetchImpl = async () => new Response(JSON.stringify({ healthy: false }), { status: 200 });
-    const result = await checkHealth('http://localhost:9000/health', { fetchImpl });
-    expect(result.serviceKind).toBe('generic');
-    expect(result.detail).toBe('healthy: false');
-  });
-
-  it('classifies a bare-text "ready" response', async () => {
-    const fetchImpl = async () => new Response('ready', { status: 200 });
-    const result = await checkHealth('http://localhost:9001/health', { fetchImpl });
-    expect(result.serviceKind).toBe('generic');
-    expect(result.detail).toBe('response: ready');
-  });
-
-  it('leaves serviceKind/detail null for an unrecognized JSON body', async () => {
-    const fetchImpl = async () => new Response(JSON.stringify({ some: 'thing' }), { status: 200 });
-    const result = await checkHealth('http://localhost:9002/health', { fetchImpl });
-    expect(result.serviceKind).toBeNull();
-    expect(result.detail).toBeNull();
-    expect(result.ready).toBe(true);
-  });
-});
-
-describe('classifyLog — malformed / empty input', () => {
-  it('does not crash on an empty log', () => {
-    const result = classifyLog('');
-    expect(result.matched).toBe(false);
-    expect(result.category).toBe('unknown');
-  });
-
-  it('does not crash on binary-ish garbage input', () => {
-    const result = classifyLog('\x00\x01\x02\xFF garbage �� not a real log');
-    expect(result.category).toBe('unknown');
-  });
-});
-
-describe('redactLine', () => {
-  it('redacts a Hugging Face token', () => {
-    const line = 'Authenticating with token hf_abcdefghijklmnopqrstuvwx1234';
-    expect(redactLine(line)).not.toMatch(/hf_abcdefghijklmnopqrstuvwx1234/);
-    expect(redactLine(line)).toMatch(/hf_\[REDACTED\]/);
-  });
-
-  it('redacts an Authorization header', () => {
-    const line = 'Authorization: Bearer sk-proj-abcdefghijklmnop1234567890';
-    expect(redactLine(line)).not.toMatch(/abcdefghijklmnop1234567890/);
-  });
-
-  it('redacts credentials embedded in a URL', () => {
-    const line = 'Fetching https://user:s3cr3t@example.com/model.bin';
-    const out = redactLine(line);
-    expect(out).not.toMatch(/s3cr3t/);
-    expect(out).toContain('[REDACTED]:[REDACTED]@');
-  });
-
-  it('redacts a home directory username', () => {
-    const line = 'Loading model from /home/alice/.cache/huggingface/model.bin';
-    expect(redactLine(line)).not.toMatch(/alice/);
-  });
-
-  it('redacts an email address', () => {
-    expect(redactLine('Contact: bob@example.com for access')).toContain('[email]');
-  });
-
-  it('leaves ordinary log lines unchanged', () => {
-    const line = 'CUDA out of memory. Tried to allocate 2.00 GiB';
-    expect(redactLine(line)).toBe(line);
-  });
-
-  it('is applied to evidence lines extracted from a log', () => {
-    const log = 'CUDA out of memory while loading with Authorization: Bearer hf_supersecrettoken1234567890';
-    const result = classifyLog(log);
-    const combined = result.evidenceLines.join(' ');
-    expect(combined).not.toMatch(/supersecrettoken1234567890/);
-  });
-});
-
-describe('diagnoseWorkflow — UI-export format', () => {
-  it('parses a UI-export workflow (nodes array with widgets_values) without crashing', () => {
-    const workflow = {
-      nodes: [
-        { type: 'CheckpointLoaderSimple', widgets_values: ['sd_xl_base_1.0.safetensors'] },
-        { type: 'KSampler', widgets_values: [20, 'euler'] },
-        { type: 'SomeCustomExtensionNode', widgets_values: [] },
-      ],
-    };
-    const result = diagnoseWorkflow(workflow);
-    expect(result.nodeCount).toBe(3);
-    expect(result.likelyClass).toBe('SDXL');
-    expect(result.models).toContain('sd_xl_base_1.0.safetensors');
-    expect(result.customNodes).toContain('SomeCustomExtensionNode');
-  });
-
-  it('handles an empty or unrecognized workflow shape without throwing', () => {
-    expect(() => diagnoseWorkflow({})).not.toThrow();
-    expect(() => diagnoseWorkflow(null)).not.toThrow();
-    expect(() => diagnoseWorkflow({ nodes: [] })).not.toThrow();
-    expect(diagnoseWorkflow(null).nodeCount).toBe(0);
-  });
-});
-
-describe('parseDoctorArgs', () => {
-  it('parses --model and --serve together', () => {
-    const flags = parseDoctorArgs(['--model', 'Qwen/Qwen2.5-7B-Instruct', '--serve']);
-    expect(flags.model).toBe('Qwen/Qwen2.5-7B-Instruct');
-    expect(flags.serve).toBe(true);
-  });
-
-  it('parses --gpu, --vram-gb, and --json', () => {
-    const flags = parseDoctorArgs(['--gpu', 'A100', '--vram-gb', '40', '--json']);
-    expect(flags.gpu).toBe('A100');
-    expect(flags.vramGb).toBe(40);
-    expect(flags.json).toBe(true);
-  });
-
-  it('serve defaults to falsy when not passed', () => {
-    const flags = parseDoctorArgs(['--model', 'Qwen/Qwen2.5-7B-Instruct']);
-    expect(flags.serve).toBeFalsy();
-  });
-});
-
-describe('badgr doctor has no badgr gpu doctor alias', () => {
-  it('commands/doctor.js exports only doctorCommand — no gpuCommand alias', async () => {
-    const mod = await import('../src/commands/doctor.js');
-    expect(typeof mod.doctorCommand).toBe('function');
-    expect(mod.gpuCommand).toBeUndefined();
-  });
-});
-
-describe('badgr doctor --help', () => {
-  const chalkStub = new Proxy(() => {}, { get: () => (s) => s, apply: (_t, _a, [s]) => s });
-
-  async function captureLogs(args) {
-    const { doctorCommand } = await import('../src/commands/doctor.js');
-    const logs = [];
-    const spy = vi.spyOn(console, 'log').mockImplementation((...a) => logs.push(a.join(' ')));
-    await doctorCommand({}, args, chalkStub);
-    spy.mockRestore();
-    return logs.join('\n');
-  }
-
-  it('--help prints usage without running any probes', async () => {
-    const output = await captureLogs(['--help']);
-    expect(output).toMatch(/Usage:/);
-    expect(output).toMatch(/--logs <path>/);
-    expect(output).not.toMatch(/Verdict:/);
-  });
-
-  it('-h is also accepted', async () => {
-    const output = await captureLogs(['-h']);
-    expect(output).toMatch(/Usage:/);
-  });
-
-  it('--help takes priority even when other flags are also passed', async () => {
-    const output = await captureLogs(['--model', 'Qwen/Qwen2.5-7B-Instruct', '--help']);
-    expect(output).toMatch(/Usage:/);
-    expect(output).not.toMatch(/Verdict:/);
-  });
-});