codexmeter 1.0.26 → 1.0.27

package/server/live-state.js

@@ -8,6 +8,7 @@ function normalizeEffortKey(effort) {
   if (k === 'medium') return 'medium';
   if (k === 'high') return 'high';
   if (k === 'xhigh') return 'xhigh';
+  if (k === 'max') return 'max';
   return k || 'unknown';
 }
 
@@ -49,33 +50,20 @@ export function createLiveAggregateState(tz) {
   };
 }
 
-export function createEmptyLivePatch() {
-  return {
-    overview: new Set(),
-    repos: { total: new Set(), d7: new Set(), d30: new Set() },
-    models: { total: new Set(), d7: new Set(), d30: new Set() },
-    families: { total: new Set(), d7: new Set(), d30: new Set() },
-    daily: new Set(),
-    heatmap: new Set(),
-  };
-}
-
-export function applySessionToLiveState(live, session, patch) {
+export function applySessionToLiveState(live, session) {
   const rootId = session.root_thread_id || session.thread_id;
 
   for (const rangeKey of ['total', 'd7', 'd30']) {
     if (!overlapsLowerBound(session, live.lowerBounds[rangeKey])) continue;
 
     applyOverviewBucket(live.overview[rangeKey], session, rootId);
-    patch.overview.add(rangeKey);
-
-    applyRepoBucket(live.repos[rangeKey], live.repoTopKeys[rangeKey], session, patch.repos[rangeKey]);
-    applyModelBucket(live.models[rangeKey], live.modelTopKeys[rangeKey], session, patch.models[rangeKey]);
-    applyFamilyBucket(live.families[rangeKey], live.familyTopKeys[rangeKey], session, patch.families[rangeKey]);
+    applyRepoBucket(live.repos[rangeKey], live.repoTopKeys[rangeKey], session);
+    applyModelBucket(live.models[rangeKey], live.modelTopKeys[rangeKey], session);
+    applyFamilyBucket(live.families[rangeKey], live.familyTopKeys[rangeKey], session);
   }
 
-  applyDailyBucket(live.daily, session, live.tz, live.toDayKey, patch.daily);
-  applyHeatmapBucket(live.heatmap, session, live.tz, live.toDayKey, patch.heatmap);
+  applyDailyBucket(live.daily, session, live.tz, live.toDayKey);
+  applyHeatmapBucket(live.heatmap, session, live.tz, live.toDayKey);
 }
 
 export function buildLiveBootstrap(live) {
@@ -100,19 +88,6 @@ export function buildLiveSnapshot(live) {
   };
 }
 
-export function buildLivePatch(live, patch) {
-  return {
-    overview: Object.fromEntries(
-      [...patch.overview].map((rangeKey) => [rangeKey, serializeOverviewBucket(live.overview[rangeKey], live.lowerBounds[rangeKey])])
-    ),
-    repos: serializePatchedTopRanges(live.repos, live.repoTopKeys, patch.repos, serializeRepoSummary),
-    models: serializePatchedTopRanges(live.models, live.modelTopKeys, patch.models, serializeModelSummary),
-    families: serializePatchedTopRanges(live.families, live.familyTopKeys, patch.families, serializeFamilySummary),
-    daily: Object.fromEntries([...patch.daily].map((dayKey) => [dayKey, serializeDailyEntry(live.daily.get(dayKey))])),
-    heatmap: Object.fromEntries([...patch.heatmap].map((dayKey) => [dayKey, serializeHeatmapEntry(live.heatmap.get(dayKey))])),
-  };
-}
-
 function createTopKeyRanges() {
   return {
     total: [],
@@ -164,7 +139,7 @@ function applyOverviewBucket(bucket, session, rootId) {
   if (session.ended_at && session.ended_at > bucket.latest) bucket.latest = session.ended_at;
 }
 
-function applyRepoBucket(repoMap, topKeys, session, dirtySet) {
+function applyRepoBucket(repoMap, topKeys, session) {
   const key = session.repo_label || 'unknown';
   if (!repoMap.has(key)) {
     repoMap.set(key, {
@@ -193,10 +168,9 @@ function applyRepoBucket(repoMap, topKeys, session, dirtySet) {
   addBreakdown(repo.by_family, session.agent_family || 'generic', session);
 
   updateTopKeys(repoMap, topKeys, key);
-  dirtySet.add(key);
 }
 
-function applyModelBucket(modelMap, topKeys, session, dirtySet) {
+function applyModelBucket(modelMap, topKeys, session) {
   const key = session.model_name || 'unknown';
   if (!modelMap.has(key)) {
     modelMap.set(key, { model_name: key, tokens: 0, cost: 0, cost_known: 0, exact_priced: 0, heuristic_priced: 0, sessions: 0, by_effort: {} });
@@ -213,7 +187,6 @@ function applyModelBucket(modelMap, topKeys, session, dirtySet) {
   addBreakdown(model.by_effort, normalizeEffortKey(session.reasoning_effort), session);
 
   updateTopKeys(modelMap, topKeys, key);
-  dirtySet.add(key);
 }
 
 function addBreakdown(target, key, session) {
@@ -228,7 +201,7 @@ function addBreakdown(target, key, session) {
   }
 }
 
-function applyFamilyBucket(familyMap, topKeys, session, dirtySet) {
+function applyFamilyBucket(familyMap, topKeys, session) {
   const key = session.agent_family || 'generic';
   if (!familyMap.has(key)) {
     familyMap.set(key, { family: key, tokens: 0, cost: 0, exact_priced: 0, heuristic_priced: 0, sessions: 0 });
@@ -242,10 +215,9 @@ function applyFamilyBucket(familyMap, topKeys, session, dirtySet) {
     if (session.cost_source === 'heuristic') family.heuristic_priced += 1;
   }
   updateTopKeys(familyMap, topKeys, key);
-  dirtySet.add(key);
 }
 
-function applyDailyBucket(dayMap, session, tz, toDayKey, dirtySet) {
+function applyDailyBucket(dayMap, session, tz, toDayKey) {
   if (!session.started_at || !session.ended_at) return;
 
   const startMs = session.started_at * 1000;
@@ -253,12 +225,11 @@ function applyDailyBucket(dayMap, session, tz, toDayKey, dirtySet) {
   const totalDur = endMs - startMs;
   if (totalDur > 0) {
     if (session.has_usage_by_day) {
-      addSessionPresence(dayMap, startMs, endMs, totalDur, tz, session, dirtySet);
-      addUsageByDay(dayMap, session, dirtySet);
+      addSessionPresence(dayMap, startMs, endMs, totalDur, tz, session);
+      addUsageByDay(dayMap, session);
     } else {
       for (const { dayKey, overlapMs } of splitIntervalByDay(startMs, endMs, tz)) {
         addToDay(dayMap, dayKey, session, overlapMs / totalDur);
-        dirtySet.add(dayKey);
       }
     }
   }
@@ -266,12 +237,11 @@ function applyDailyBucket(dayMap, session, tz, toDayKey, dirtySet) {
   if (session.active_by_day) {
     for (const [dayKey, seconds] of Object.entries(session.active_by_day)) {
       addElapsedToDay(dayMap, dayKey, session, seconds || 0);
-      dirtySet.add(dayKey);
     }
   }
 }
 
-function applyHeatmapBucket(dayMap, session, tz, toDayKey, dirtySet) {
+function applyHeatmapBucket(dayMap, session, tz, toDayKey) {
   const startMs = session.started_at ? session.started_at * 1000 : null;
   const endMs = (session.ended_at || session.started_at) ? (session.ended_at || session.started_at) * 1000 : null;
   const totalDur = endMs - startMs;
@@ -282,20 +252,17 @@ function applyHeatmapBucket(dayMap, session, tz, toDayKey, dirtySet) {
       const day = ensureHeatmapDay(dayMap, dayKey);
       day.tokens += usageDay.tokens || 0;
       if (usageDay.cost !== null) day.cost += usageDay.cost;
-      dirtySet.add(dayKey);
     }
     if (startMs !== null) {
       if (totalDur > 0) {
         for (const { dayKey, overlapMs } of splitIntervalByDay(startMs, endMs, tz)) {
           const day = ensureHeatmapDay(dayMap, dayKey);
           if ((overlapMs / totalDur) > 0.001) day.sessions += 1;
-          dirtySet.add(dayKey);
         }
       } else {
         const startDay = toDayKey(startMs);
         const day = ensureHeatmapDay(dayMap, startDay);
         day.sessions += 1;
-        dirtySet.add(startDay);
       }
     }
   } else if (startMs !== null) {
@@ -306,7 +273,6 @@ function applyHeatmapBucket(dayMap, session, tz, toDayKey, dirtySet) {
         day.tokens += (session.tokens_used || 0) * fraction;
         if (session.cost !== null) day.cost += session.cost * fraction;
         if (fraction > 0.001) day.sessions += 1;
-        dirtySet.add(dayKey);
       }
     } else {
       const dayKey = toDayKey(startMs);
@@ -314,7 +280,6 @@ function applyHeatmapBucket(dayMap, session, tz, toDayKey, dirtySet) {
       day.tokens += session.tokens_used || 0;
       if (session.cost !== null) day.cost += session.cost;
       day.sessions += 1;
-      dirtySet.add(dayKey);
     }
   }
 
@@ -322,15 +287,13 @@ function applyHeatmapBucket(dayMap, session, tz, toDayKey, dirtySet) {
     for (const [dayKey, seconds] of Object.entries(session.active_by_day)) {
       const day = ensureHeatmapDay(dayMap, dayKey);
       day.elapsed += seconds || 0;
-      dirtySet.add(dayKey);
     }
   }
 }
 
-function addSessionPresence(dayMap, startMs, endMs, totalDur, tz, session, dirtySet) {
+function addSessionPresence(dayMap, startMs, endMs, totalDur, tz, session) {
   for (const { dayKey, overlapMs } of splitIntervalByDay(startMs, endMs, tz)) {
     addPresenceToDay(dayMap, dayKey, session, overlapMs / totalDur);
-    dirtySet.add(dayKey);
   }
 }
 
@@ -347,7 +310,7 @@ function addPresenceToDay(dayMap, dayKey, session, fraction) {
   if (fraction > 0.001) day.by_repo[repoKey].sessions += 1;
 }
 
-function addUsageByDay(dayMap, session, dirtySet) {
+function addUsageByDay(dayMap, session) {
   for (const usageDay of session.usage_by_day || []) {
     const dayKey = usageDay.day;
     const day = ensureDay(dayMap, dayKey);
@@ -368,7 +331,6 @@ function addUsageByDay(dayMap, session, dirtySet) {
     if (!day.by_repo[repoKey]) day.by_repo[repoKey] = { tokens: 0, cost: 0, elapsed_seconds: 0, sessions: 0 };
     day.by_repo[repoKey].tokens += usageDay.tokens || 0;
     if (usageDay.cost !== null) day.by_repo[repoKey].cost += usageDay.cost;
-    dirtySet.add(dayKey);
   }
 }
 
@@ -474,16 +436,6 @@ function serializeTopRanges(rangeMaps, topKeyRanges, projector) {
   };
 }
 
-function serializePatchedTopRanges(rangeMaps, topKeyRanges, dirtyRanges, projector) {
-  const out = {};
-  for (const rangeKey of ['total', 'd7', 'd30']) {
-    if (dirtyRanges[rangeKey].size > 0) {
-      out[rangeKey] = serializeTopRange(rangeMaps[rangeKey], topKeyRanges[rangeKey], projector);
-    }
-  }
-  return out;
-}
-
 function serializeTopRange(map, topKeys, projector) {
   return topKeys
     .map((key) => map.get(key))

package/server/normalize.js

@@ -124,6 +124,15 @@ function isLauncherSourceKind(sourceKind) {
 
 const MODEL_ALIASES = {
   'codex-mini-latest': 'o4-mini',
+  'gpt 5.6 sol': 'gpt-5.6-sol',
+  'gpt-5.6 sol': 'gpt-5.6-sol',
+  'openai/gpt-5.6-sol': 'gpt-5.6-sol',
+  'gpt 5.6 terra': 'gpt-5.6-terra',
+  'gpt-5.6 terra': 'gpt-5.6-terra',
+  'openai/gpt-5.6-terra': 'gpt-5.6-terra',
+  'gpt 5.6 luna': 'gpt-5.6-luna',
+  'gpt-5.6 luna': 'gpt-5.6-luna',
+  'openai/gpt-5.6-luna': 'gpt-5.6-luna',
   'gpt 5.5': 'gpt-5.5',
   'gpt-5.5': 'gpt-5.5',
   'gpt 5 mini': 'gpt-5-mini',

package/server/pricing-fetch.js

@@ -1,5 +1,8 @@
 // Local pricing catalog for models used in codex-cli/codex app lifetime.
 const FALLBACK = {
+  'gpt-5.6-sol':         { input: 5.00,  output: 30.00, cached_input: 0.50, cache_write: 6.25 },
+  'gpt-5.6-terra':       { input: 2.50,  output: 15.00, cached_input: 0.25, cache_write: 3.125 },
+  'gpt-5.6-luna':        { input: 1.00,  output:  6.00, cached_input: 0.10, cache_write: 1.25 },
   'gpt-5.5':             { input: 5.00,  output: 30.00, cached_input: 0.50 },
   'gpt-5.4':             { input: 2.50,  output: 15.00, cached_input: 0.25 },
   'gpt-5-mini':          { input: 0.75,  output:  4.50, cached_input: 0.075},
@@ -29,7 +32,10 @@ const PRICING_URL = process.env.CODEXMETER_PRICING_URL || null;
 function normalizeEntry(entry) {
   if (!entry || typeof entry !== 'object' || entry.input == null || entry.output == null) return null;
   const cached = entry.cached_input ?? entry.cachedInput ?? entry.input * 0.1;
-  return { input: entry.input, output: entry.output, cached_input: cached };
+  const normalized = { input: entry.input, output: entry.output, cached_input: cached };
+  const cacheWrite = entry.cache_write ?? entry.cacheWrite ?? entry.cache_write_input;
+  if (cacheWrite != null) normalized.cache_write = cacheWrite;
+  return normalized;
 }
 
 function normalizePricing(raw) {

package/server/rollout-reader.js

@@ -65,6 +65,7 @@ export async function enrichFromRollout(rolloutPath, opts = {}) {
     const usageByDay = new Map();
     let lastInputTokens = 0;
     let lastCachedInputTokens = 0;
+    let lastCacheWriteInputTokens = 0;
     let lastOutputTokens = 0;
     let lastReasoningOutputTokens = 0;
     let lastTotalTokens = 0;
@@ -113,19 +114,21 @@ export async function enrichFromRollout(rolloutPath, opts = {}) {
         if (obj.type === 'event_msg' && obj.payload?.type === 'token_count') {
           const usage = obj.payload.info?.total_token_usage;
           if (usage) {
-            const inputTokens = usage.input_tokens || 0;
-            const cachedInputTokens = usage.cached_input_tokens || 0;
-            const outputTokens = usage.output_tokens || 0;
-            const reasoningOutputTokens = usage.reasoning_output_tokens || 0;
-            const totalTokens = usage.total_tokens || 0;
-
-            result.usage_total = {
+            const normalizedUsage = normalizeUsageTotals(usage);
+            const inputTokens = normalizedUsage.input_tokens;
+            const cachedInputTokens = normalizedUsage.cached_input_tokens;
+            const cacheWriteInputTokens = normalizedUsage.cache_write_input_tokens || 0;
+            const outputTokens = normalizedUsage.output_tokens;
+            const reasoningOutputTokens = normalizedUsage.reasoning_output_tokens;
+            const totalTokens = normalizedUsage.total_tokens;
+
+            result.usage_total = withCacheWrite({
               input_tokens: inputTokens,
               cached_input_tokens: cachedInputTokens,
               output_tokens: outputTokens,
               reasoning_output_tokens: reasoningOutputTokens,
               total_tokens: totalTokens,
-            };
+            }, cacheWriteInputTokens);
 
             const hasReset =
               hasSeenUsage &&
@@ -138,30 +141,34 @@ export async function enrichFromRollout(rolloutPath, opts = {}) {
               hasSeenUsage = false;
               lastInputTokens = 0;
               lastCachedInputTokens = 0;
+              lastCacheWriteInputTokens = 0;
               lastOutputTokens = 0;
               lastReasoningOutputTokens = 0;
               lastTotalTokens = 0;
             }
 
             const usageDelta = hasSeenUsage
-              ? {
+              ? withCacheWrite({
                   input_tokens: Math.max(inputTokens - lastInputTokens, 0),
                   cached_input_tokens: Math.max(cachedInputTokens - lastCachedInputTokens, 0),
+                  cache_write_input_tokens: Math.max(cacheWriteInputTokens - lastCacheWriteInputTokens, 0),
                   output_tokens: Math.max(outputTokens - lastOutputTokens, 0),
                   reasoning_output_tokens: Math.max(reasoningOutputTokens - lastReasoningOutputTokens, 0),
                   total_tokens: Math.max(totalTokens - lastTotalTokens, 0),
-                }
-              : {
+                }, Math.max(cacheWriteInputTokens - lastCacheWriteInputTokens, 0))
+              : withCacheWrite({
                   input_tokens: inputTokens,
                   cached_input_tokens: cachedInputTokens,
+                  cache_write_input_tokens: cacheWriteInputTokens,
                   output_tokens: outputTokens,
                   reasoning_output_tokens: reasoningOutputTokens,
                   total_tokens: totalTokens,
-                };
+                }, cacheWriteInputTokens);
 
             hasSeenUsage = true;
             lastInputTokens = inputTokens;
             lastCachedInputTokens = cachedInputTokens;
+            lastCacheWriteInputTokens = cacheWriteInputTokens;
             lastOutputTokens = outputTokens;
             lastReasoningOutputTokens = reasoningOutputTokens;
             lastTotalTokens = totalTokens;
@@ -448,36 +455,39 @@ function isTokenCountEventLine(line) {
 }
 
 function normalizeUsageTotals(usage) {
-  return {
+  return withCacheWrite({
     input_tokens: usage.input_tokens || 0,
-    cached_input_tokens: usage.cached_input_tokens || 0,
+    cached_input_tokens: usage.cached_input_tokens ?? usage.input_tokens_details?.cached_tokens ?? 0,
     output_tokens: usage.output_tokens || 0,
     reasoning_output_tokens: usage.reasoning_output_tokens || 0,
     total_tokens: usage.total_tokens || 0,
-  };
+  }, usage.cache_write_input_tokens ?? usage.cache_write_tokens ?? usage.input_tokens_details?.cache_write_tokens ?? 0);
 }
 
 function splitUsageTotals(usage) {
   const normalized = normalizeUsageTotals(usage || {});
   const cachedInputTokens = Math.min(normalized.cached_input_tokens, normalized.input_tokens);
+  const cacheWriteInputTokens = Math.min(normalized.cache_write_input_tokens || 0, Math.max(normalized.input_tokens - cachedInputTokens, 0));
   return {
-    uncached_input_tokens: Math.max(normalized.input_tokens - cachedInputTokens, 0),
+    uncached_input_tokens: Math.max(normalized.input_tokens - cachedInputTokens - cacheWriteInputTokens, 0),
     cached_input_tokens: cachedInputTokens,
+    cache_write_input_tokens: cacheWriteInputTokens,
     output_tokens: normalized.output_tokens,
     reasoning_output_tokens: normalized.reasoning_output_tokens,
   };
 }
 
 function combineUsageTotals(parts, currentTotalTokens = 0, previousTotalTokens = 0) {
-  const inputTokens = (parts.uncached_input_tokens || 0) + (parts.cached_input_tokens || 0);
+  const cacheWriteInputTokens = parts.cache_write_input_tokens || 0;
+  const inputTokens = (parts.uncached_input_tokens || 0) + (parts.cached_input_tokens || 0) + cacheWriteInputTokens;
   const outputTokens = parts.output_tokens || 0;
-  return {
+  return withCacheWrite({
     input_tokens: inputTokens,
     cached_input_tokens: parts.cached_input_tokens || 0,
     output_tokens: outputTokens,
     reasoning_output_tokens: parts.reasoning_output_tokens || 0,
     total_tokens: Math.max(inputTokens + outputTokens, Math.max(currentTotalTokens - previousTotalTokens, 0)),
-  };
+  }, cacheWriteInputTokens);
 }
 
 export function subtractUsageTotals(current, previous) {
@@ -486,6 +496,7 @@ export function subtractUsageTotals(current, previous) {
   return combineUsageTotals({
     uncached_input_tokens: Math.max(currentParts.uncached_input_tokens - previousParts.uncached_input_tokens, 0),
     cached_input_tokens: Math.max(currentParts.cached_input_tokens - previousParts.cached_input_tokens, 0),
+    cache_write_input_tokens: Math.max(currentParts.cache_write_input_tokens - previousParts.cache_write_input_tokens, 0),
     output_tokens: Math.max(currentParts.output_tokens - previousParts.output_tokens, 0),
     reasoning_output_tokens: Math.max(currentParts.reasoning_output_tokens - previousParts.reasoning_output_tokens, 0),
   }, current?.total_tokens || 0, previous?.total_tokens || 0);
@@ -495,6 +506,7 @@ export function hasUsageTotals(usage) {
   return !!usage && (
     (usage.input_tokens || 0) > 0 ||
     (usage.cached_input_tokens || 0) > 0 ||
+    (usage.cache_write_input_tokens || 0) > 0 ||
     (usage.output_tokens || 0) > 0 ||
     (usage.reasoning_output_tokens || 0) > 0 ||
     (usage.total_tokens || 0) > 0
@@ -505,6 +517,7 @@ function hasUsage(usage) {
   return !!usage && (
     usage.input_tokens > 0 ||
     usage.cached_input_tokens > 0 ||
+    (usage.cache_write_input_tokens || 0) > 0 ||
     usage.output_tokens > 0
   );
 }
@@ -521,5 +534,14 @@ function mergeUsageTotals(target, dayKey, usage) {
   }
   previous.input_tokens += usage.input_tokens || 0;
   previous.cached_input_tokens += usage.cached_input_tokens || 0;
+  if (usage.cache_write_input_tokens) {
+    previous.cache_write_input_tokens = (previous.cache_write_input_tokens || 0) + usage.cache_write_input_tokens;
+  }
   previous.output_tokens += usage.output_tokens || 0;
 }
+
+function withCacheWrite(usage, cacheWriteInputTokens) {
+  const value = Math.max(0, cacheWriteInputTokens || 0);
+  if (value > 0) usage.cache_write_input_tokens = value;
+  return usage;
+}

package/server/rollout-worker-pool.js

@@ -2,11 +2,8 @@ import os from 'os';
 import { Worker } from 'worker_threads';
 
 export function createRolloutWorkerPool(opts = {}) {
-  const size = normalizePoolSize(opts.size);
+  const size = normalizePoolSize();
   const readerOptions = opts.readerOptions || {};
-  if (size <= 1) {
-    return createInlinePool({ readerOptions });
-  }
 
   const workers = new Set();
   const idleWorkers = [];
@@ -105,10 +102,6 @@ export function createRolloutWorkerPool(opts = {}) {
     });
   }
 
-  async function mapRollouts(rolloutPaths, timezone) {
-    return Promise.all(rolloutPaths.map((rolloutPath) => runTask(rolloutPath, timezone)));
-  }
-
   async function mapRolloutsInChunks(rolloutPaths, timezone, { chunkSize = 100, onChunk } = {}) {
     const results = new Array(rolloutPaths.length);
     const completed = new Array(rolloutPaths.length).fill(false);
@@ -188,71 +181,10 @@ export function createRolloutWorkerPool(opts = {}) {
     idleWorkers.length = 0;
   }
 
-  return { mapRollouts, mapRolloutsInChunks, close, size };
-}
-
-function createInlinePool({ readerOptions = {} } = {}) {
-  return {
-    size: 1,
-    async mapRollouts(rolloutPaths, timezone) {
-      const { enrichFromRollout } = await import('./rollout-reader.js');
-      return Promise.all(
-        rolloutPaths.map(async (rolloutPath) => {
-          try {
-            const data = await enrichFromRollout(rolloutPath, { timezone, ...readerOptions });
-            return { ok: true, data, error: null };
-          } catch (error) {
-            return {
-              ok: false,
-              data: null,
-              error: error instanceof Error ? error.message : String(error),
-            };
-          }
-        })
-      );
-    },
-    async mapRolloutsInChunks(rolloutPaths, timezone, { chunkSize = 100, onChunk } = {}) {
-      const { enrichFromRollout } = await import('./rollout-reader.js');
-      const results = [];
-      const completed = [];
-      const safeChunkSize = Math.max(1, Number(chunkSize) || 1);
-
-      for (let index = 0; index < rolloutPaths.length; index += 1) {
-        try {
-          const data = await enrichFromRollout(rolloutPaths[index], { timezone, ...readerOptions });
-          const result = { ok: true, data, error: null };
-          results[index] = result;
-          completed.push({ index, result });
-        } catch (error) {
-          const result = {
-            ok: false,
-            data: null,
-            error: error instanceof Error ? error.message : String(error),
-          };
-          results[index] = result;
-          completed.push({ index, result });
-        }
-
-        if (typeof onChunk === 'function' && completed.length >= safeChunkSize) {
-          await onChunk(completed.splice(0, completed.length));
-        }
-      }
-
-      if (typeof onChunk === 'function' && completed.length) {
-        await onChunk(completed.splice(0, completed.length));
-      }
-
-      return results;
-    },
-    async close() {},
-  };
+  return { mapRolloutsInChunks, close, size };
 }
 
-function normalizePoolSize(size) {
-  if (size != null) {
-    return Math.max(1, Number(size) || 1);
-  }
-
+function normalizePoolSize() {
   const cpuCount = os.cpus()?.length || 4;
   return Math.max(2, Math.min(cpuCount - 1, 8));
 }