perf(core): Warm up all metrics worker threads to eliminate lazy init delays

Revert the half-thread warmup optimization and warm up all worker
threads during pool initialization. While half-warmup reduced CPU
contention during the security check phase, it left workers cold for
the metrics phase. Cold workers need ~150ms to lazy-load gpt-tokenizer,
during which they cannot process batches, effectively serializing
early metrics work onto fewer threads.

Full warmup slightly increases contention during the pipeline overlap
phase, but the I/O-bound file collection and git subprocess stages
provide natural CPU headroom that absorbs the extra warmup load.

Benchmark results (repomix on itself, 996 files, 10 runs each):
  Before (half warmup): median 1.599s
  After  (full warmup): median 1.540s
  Improvement: ~59ms (~3.7%)

  vs main branch: median 1.764s → 1.540s (~12.7% total improvement)

https://claude.ai/code/session_018NjNHi6fb1AiQHbWdarYcW

Author: claude

src/core/metrics/calculateMetrics.ts

@@ -52,14 +52,15 @@ export const createMetricsTaskRunner = (numOfTasks: number, encoding: TokenEncod
     runtime: 'worker_threads',
   });
 
-  // Warm up only half the worker threads to further reduce CPU contention during the
-  // overlapping file collection + security check pipeline stages. The remaining
-  // workers initialize lazily during metrics calculation, when security workers
-  // have already been cleaned up and CPU cores are free.
+  // Warm up all worker threads to eliminate lazy initialization delays during the
+  // metrics phase. While warmup overlaps with security check workers (causing some
+  // CPU contention), having all workers ready when metrics calculation starts
+  // outweighs the contention cost: lazy initialization on cold workers adds ~150ms
+  // per worker during the metrics phase, which is worse than the brief contention
+  // during warmup when I/O-bound pipeline stages provide natural CPU headroom.
   const { maxThreads } = getWorkerThreadCount(cappedNumOfTasks);
-  const warmupCount = Math.max(1, Math.ceil(maxThreads / 2));
   const warmupPromise = Promise.all(
-    Array.from({ length: warmupCount }, () => taskRunner.run({ content: '', encoding }).catch(() => 0)),
+    Array.from({ length: maxThreads }, () => taskRunner.run({ content: '', encoding }).catch(() => 0)),
   );
 
   return { taskRunner, warmupPromise };

tests/core/metrics/calculateMetrics.test.ts

@@ -121,19 +121,20 @@ describe('createMetricsTaskRunner', () => {
     expect(result.taskRunner.run).toHaveBeenCalledWith({ content: '', encoding: 'cl100k_base' });
   });
 
-  it('should warm up ceil(maxThreads/2) workers to reduce CPU contention', async () => {
+  it('should warm up all worker threads', async () => {
     // With 1000 tasks on a system with N cores, maxThreads = min(N, ceil(1000/100)) = min(N, 10)
-    // warmupCount = max(1, ceil(maxThreads / 2))
+    // All threads should be warmed up to avoid lazy init delays during metrics
     const result = createMetricsTaskRunner(1000, 'o200k_base');
 
     await result.warmupPromise;
 
-    // The number of warmup calls should be ceil(maxThreads / 2), not maxThreads
     const callCount = (result.taskRunner.run as Mock).mock.calls.length;
     const { getWorkerThreadCount } = await import('../../../src/shared/processConcurrency.js');
-    const { maxThreads } = getWorkerThreadCount(1000);
-    const expectedWarmupCount = Math.max(1, Math.ceil(maxThreads / 2));
-    expect(callCount).toBe(expectedWarmupCount);
+    // maxMetricsWorkers caps at processConcurrency - 1, so cappedNumOfTasks is used
+    const maxMetricsWorkers = Math.max(1, (await import('node:os')).default.availableParallelism() - 1);
+    const cappedNumOfTasks = Math.min(1000, maxMetricsWorkers * 100);
+    const { maxThreads } = getWorkerThreadCount(cappedNumOfTasks);
+    expect(callCount).toBe(maxThreads);
   });
 
   it('should swallow warmup task errors', async () => {