perf(cli): parallelize scenario log downloads with max concurrency of 50 (#176)

## Summary

- Replace the serial download loop in `rli bmj logs` with a concurrent
executor capped at 50 simultaneous downloads
- Adds a small `runWithConcurrency` helper that distributes tasks across
N workers using a shared index
- Output lines are printed atomically per-download (one full line with ✓
on success) since the old "write prefix / complete line" pattern doesn't
work in parallel

## Test plan

- [ ] Run `rli bmj logs <job-id>` on a job with many scenarios and
confirm downloads complete much faster
- [ ] Verify the output directory structure matches the previous
behaviour (`<output-dir>/<agent>/<scenario>/`)
- [ ] Verify `results.json` is written correctly for each scenario
- [ ] Confirm failed downloads still produce warning messages and the
final summary counts correctly

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Runloop Agent <[email protected]>
Co-authored-by: Claude Sonnet 4.6 <[email protected]>

Author: 3 people

src/commands/benchmark-job/logs.ts

@@ -253,6 +253,29 @@ async function downloadScenarioLogs(
   }
 }
 
+/** Run tasks in parallel with a maximum concurrency limit */
+async function runWithConcurrency<T>(
+  tasks: (() => Promise<T>)[],
+  maxConcurrency: number,
+): Promise<T[]> {
+  const results: T[] = new Array(tasks.length);
+  let nextIndex = 0;
+
+  async function worker() {
+    while (nextIndex < tasks.length) {
+      const i = nextIndex++;
+      results[i] = await tasks[i]();
+    }
+  }
+
+  const workers = Array.from(
+    { length: Math.min(maxConcurrency, tasks.length) },
+    () => worker(),
+  );
+  await Promise.all(workers);
+  return results;
+}
+
 export async function downloadBenchmarkJobLogs(
   jobId: string,
   options: LogsOptions = {},
@@ -326,18 +349,23 @@ export async function downloadBenchmarkJobLogs(
       `\nDownloading logs for ${targets.length} scenario run(s) to ${chalk.bold(outputDir)}\n`,
     );
 
-    // Download logs one at a time to avoid overwhelming the API
+    // Download logs in parallel with a max concurrency of 50
+    const MAX_CONCURRENCY = 50;
     let succeeded = 0;
-    for (const target of targets) {
-      process.stdout.write(
-        `  ${target.agentName} / ${target.scenarioName}... `,
-      );
+
+    const tasks = targets.map((target) => async () => {
       const ok = await downloadScenarioLogs(target);
       if (ok) {
-        console.log(chalk.green("done"));
-        succeeded++;
+        console.log(
+          chalk.green(`  ✓ ${target.agentName} / ${target.scenarioName}`),
+        );
+        return true;
       }
-    }
+      return false;
+    });
+
+    const results = await runWithConcurrency(tasks, MAX_CONCURRENCY);
+    succeeded = results.filter(Boolean).length;
 
     console.log(
       `\n${chalk.green(`Downloaded logs for ${succeeded}/${targets.length} scenario run(s)`)} to ${chalk.bold(outputDir)}`,