@link-assistant/hive-mind 1.54.1 → 1.54.3

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @link-assistant/hive-mind
 
+## 1.54.3
+
+### Patch Changes
+
+- 5030b04: Fix Codex pricing display by calculating OpenAI public estimates from models.dev token rates, passing Codex totals into shared budget stats, and avoiding duplicate raw token usage lines when a Total line is already shown.
+
+## 1.54.2
+
+### Patch Changes
+
+- 9d4e473: Cap `/limits` CPU cores display at available CPU count when load average demand exceeds capacity.
+- ea0b9f5: Use Anthropic's native Claude Code installer in Docker images so the CLI binary is installed even when Bun blocks dependency postinstall scripts.
+
 ## 1.54.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.54.1",
+  "version": "1.54.3",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",
@@ -13,7 +13,7 @@
     "hive-telegram-bot": "./src/telegram-bot.mjs"
   },
   "scripts": {
-    "test": "node tests/solve-queue.test.mjs && node tests/limits-display.test.mjs && node tests/test-usage-limit.mjs && node tests/test-issue-1616-pr-issue-link-preservation.mjs && node tests/test-telegram-message-filters.mjs && node tests/test-telegram-bot-command-aliases.mjs && node tests/test-solve-queue-command.mjs && node tests/test-queue-display-1267.mjs && node tests/test-telegram-bot-launcher.mjs",
+    "test": "node tests/solve-queue.test.mjs && node tests/limits-display.test.mjs && node tests/test-usage-limit.mjs && node tests/test-codex-support.mjs && node tests/test-build-cost-info-string.mjs && node tests/test-claude-code-install-method.mjs && node tests/test-issue-1616-pr-issue-link-preservation.mjs && node tests/test-telegram-message-filters.mjs && node tests/test-telegram-bot-command-aliases.mjs && node tests/test-solve-queue-command.mjs && node tests/test-queue-display-1267.mjs && node tests/test-telegram-bot-launcher.mjs",
     "test:queue": "node tests/solve-queue.test.mjs",
     "test:limits-display": "node tests/limits-display.test.mjs",
     "test:usage-limit": "node tests/test-usage-limit.mjs",

package/src/claude.lib.mjs

@@ -21,7 +21,9 @@ import { handleClaudeRuntimeSwitch } from './claude.runtime-switch.lib.mjs'; //
 import { CLAUDE_MODELS as availableModels } from './models/index.mjs'; // Issue #1221
 import { buildMcpConfigWithoutPlaywright } from './playwright-mcp.lib.mjs';
 import { resolveClaudeSessionToolFlags } from './useless-tools.lib.mjs';
+import { fetchModelInfo } from './model-info.lib.mjs';
 export { availableModels }; // Re-export for backward compatibility
+export { fetchModelInfo };
 const showResumeCommand = async (sessionId, tempDir, claudePath, model, log) => {
   if (!sessionId || !tempDir) return;
   const cmd = buildClaudeResumeCommand({ tempDir, sessionId, claudePath, model });
@@ -370,58 +372,6 @@ export const executeClaude = async params => {
     prNumber,
   });
 };
-/**
- * Fetches model information from pricing API
- * @param {string} modelId - The model ID (e.g., "claude-sonnet-4-5-20250929")
- * @returns {Promise<Object|null>} Model information or null if not found
- */
-export const fetchModelInfo = async modelId => {
-  try {
-    const https = (await use('https')).default;
-    return new Promise((resolve, reject) => {
-      https
-        .get('https://models.dev/api.json', res => {
-          let data = '';
-          res.on('data', chunk => {
-            data += chunk;
-          });
-          res.on('end', () => {
-            try {
-              const apiData = JSON.parse(data);
-              // For public pricing calculation, prefer Anthropic provider for Claude models
-              // Check Anthropic provider first
-              if (apiData.anthropic?.models?.[modelId]) {
-                const modelInfo = apiData.anthropic.models[modelId];
-                modelInfo.provider = apiData.anthropic.name || 'Anthropic';
-                resolve(modelInfo);
-                return;
-              }
-              // Search for the model across all other providers
-              for (const provider of Object.values(apiData)) {
-                if (provider.models && provider.models[modelId]) {
-                  const modelInfo = provider.models[modelId];
-                  // Add provider info
-                  modelInfo.provider = provider.name || provider.id;
-                  resolve(modelInfo);
-                  return;
-                }
-              }
-              // Model not found
-              resolve(null);
-            } catch (parseError) {
-              reject(parseError);
-            }
-          });
-        })
-        .on('error', err => {
-          reject(err);
-        });
-    });
-  } catch {
-    // If we can't fetch model info, return null and continue without it
-    return null;
-  }
-};
 /** Check if a model supports vision (image input) using models.dev API @returns {Promise<boolean>} */
 export const checkModelVisionCapability = async modelId => {
   try {

package/src/codex.lib.mjs

@@ -22,8 +22,11 @@ import { mapModelToId, resolveCodexReasoningEffort } from './codex.options.lib.m
 import { createInteractiveHandler } from './interactive-mode.lib.mjs';
 import { initProgressMonitoring } from './solve.progress-monitoring.lib.mjs';
 import { getCodexPlaywrightMcpDisableConfigArgs } from './playwright-mcp.lib.mjs';
+import { fetchModelInfo } from './model-info.lib.mjs';
+import Decimal from 'decimal.js-light';
 
 const CODEX_USAGE_FIELD_NAMES = ['input_tokens', 'cached_input_tokens', 'output_tokens', 'cache_write_tokens', 'cache_creation_input_tokens', 'reasoning_tokens', 'input_tokens_details.cached_tokens', 'input_tokens_details.cache_read_tokens', 'input_tokens_details.cache_write_tokens', 'input_tokens_details.cache_creation_tokens', 'input_tokens_details.cache_creation_input_tokens', 'output_tokens_details.reasoning_tokens'];
+const CODEX_LONG_CONTEXT_PRICE_THRESHOLD = 272000;
 const getCodexExecEnv = (verbose = false) => (verbose ? { ...process.env, RUST_LOG: 'debug' } : { ...process.env });
 const CODEX_MODEL_DIAGNOSTIC_PATHS = [
   ['model', data => data?.model],
@@ -77,6 +80,9 @@ export const createCodexTokenUsage = requestedModelId => ({
   stepCount: 0,
   requestedModelId: requestedModelId || null,
   respondedModelId: requestedModelId || null,
+  contextLimit: null,
+  outputLimit: null,
+  peakContextUsage: 0,
   tokenFieldAvailability: createCodexTokenFieldAvailability(),
 });
 
@@ -262,6 +268,10 @@ export const parseCodexExecJsonOutput = (output, state = {}, requestedModelId =
       nextState.tokenUsage.reasoningTokens += reasoningTokens;
       nextState.tokenUsage.totalTokens = nextState.tokenUsage.inputTokens + nextState.tokenUsage.cacheReadTokens + nextState.tokenUsage.outputTokens + nextState.tokenUsage.cacheWriteTokens;
       nextState.tokenUsage.stepCount += 1;
+      const turnContextUsage = inputTokens + cacheWriteTokens;
+      if (turnContextUsage > (nextState.tokenUsage.peakContextUsage || 0)) {
+        nextState.tokenUsage.peakContextUsage = turnContextUsage;
+      }
 
       const usageFieldSet = CODEX_USAGE_FIELD_NAMES.filter(fieldName => hasOwnPath(data.usage, fieldName));
       if (usageFieldSet.length > 0) nextState.observedUsageFieldSets.push(usageFieldSet);
@@ -323,12 +333,80 @@ export const buildCodexResultModelUsage = (modelId, tokenUsage, pricingInfo = nu
       outputTokens: tokenUsage.outputTokens || 0,
       modelName: pricingInfo?.modelName || modelId,
       modelInfo: pricingInfo?.modelInfo || null,
-      peakContextUsage: 0,
+      peakContextUsage: tokenUsage.peakContextUsage || 0,
       costUSD: pricingInfo?.totalCostUSD ?? null,
     },
   };
 };
 
+const toCost = (tokens, pricePerMillion) => {
+  if (!Number.isFinite(tokens) || !Number.isFinite(pricePerMillion)) return 0;
+  return new Decimal(tokens).mul(pricePerMillion).div(1_000_000).toNumber();
+};
+
+const buildCodexPricingFallback = (modelId, tokenUsage, error = null) => ({
+  modelId,
+  modelName: modelId,
+  provider: 'OpenAI',
+  tokenUsage,
+  modelInfo: null,
+  totalCostUSD: null,
+  error,
+});
+
+export const calculateCodexPricingFromModelInfo = (modelId, tokenUsage, modelInfo) => {
+  if (!modelId) return null;
+  if (!tokenUsage) return buildCodexPricingFallback(modelId, null);
+  if (!modelInfo?.cost) return buildCodexPricingFallback(modelId, tokenUsage, 'Model pricing not found in models.dev API');
+
+  const standardCost = modelInfo.cost;
+  const usesLongContextPricing = !!standardCost.context_over_200k && (tokenUsage.peakContextUsage || 0) > CODEX_LONG_CONTEXT_PRICE_THRESHOLD;
+  const cost = usesLongContextPricing ? { ...standardCost, ...standardCost.context_over_200k } : standardCost;
+
+  const pricing = {
+    inputPerMillion: cost.input || 0,
+    outputPerMillion: cost.output || 0,
+    cacheReadPerMillion: cost.cache_read || 0,
+    cacheWritePerMillion: cost.cache_write ?? cost.input ?? 0,
+    reasoningPerMillion: cost.reasoning || 0,
+  };
+
+  const breakdown = {
+    input: toCost(tokenUsage.inputTokens || 0, pricing.inputPerMillion),
+    output: toCost(tokenUsage.outputTokens || 0, pricing.outputPerMillion),
+    cacheRead: toCost(tokenUsage.cacheReadTokens || 0, pricing.cacheReadPerMillion),
+    cacheWrite: toCost(tokenUsage.cacheWriteTokens || 0, pricing.cacheWritePerMillion),
+    reasoning: toCost(tokenUsage.reasoningTokens || 0, pricing.reasoningPerMillion),
+  };
+  const totalCostUSD = Object.values(breakdown).reduce((sum, value) => new Decimal(sum).plus(value).toNumber(), 0);
+
+  tokenUsage.contextLimit = tokenUsage.contextLimit || modelInfo.limit?.context || null;
+  tokenUsage.outputLimit = tokenUsage.outputLimit || modelInfo.limit?.output || null;
+
+  return {
+    modelId,
+    modelName: modelInfo.name || modelId,
+    provider: modelInfo.provider || 'OpenAI',
+    tokenUsage,
+    modelInfo,
+    pricing,
+    breakdown,
+    totalCostUSD,
+    usesLongContextPricing,
+    longContextThreshold: usesLongContextPricing ? CODEX_LONG_CONTEXT_PRICE_THRESHOLD : null,
+  };
+};
+
+export const calculateCodexPricing = async (modelId, tokenUsage) => {
+  if (!modelId) return null;
+  try {
+    const modelInfo = await fetchModelInfo(modelId, { preferredProviderIds: ['openai'] });
+    return calculateCodexPricingFromModelInfo(modelId, tokenUsage, modelInfo);
+  } catch (error) {
+    return buildCodexPricingFallback(modelId, tokenUsage, error.message);
+  }
+};
+
 // Function to validate Codex CLI connection
 export const validateCodexConnection = async (model = 'gpt-5.4', verbose = false) => {
   // Map model alias to full ID
@@ -773,14 +851,15 @@ export const executeCodexCommand = async params => {
       }
 
       const firstActualModelId = mappedModel;
-      const pricingInfo = firstActualModelId
-        ? {
-            modelId: firstActualModelId,
-            modelName: firstActualModelId,
-            provider: 'OpenAI',
-            tokenUsage: codexJsonState.tokenUsage.stepCount > 0 ? codexJsonState.tokenUsage : null,
-          }
-        : null;
+      const pricingInfo = firstActualModelId ? await calculateCodexPricing(firstActualModelId, codexJsonState.tokenUsage.stepCount > 0 ? codexJsonState.tokenUsage : null) : null;
+      if (pricingInfo?.totalCostUSD !== null && pricingInfo?.totalCostUSD !== undefined) {
+        await log(`💰 Codex public pricing estimate: $${new Decimal(pricingInfo.totalCostUSD).toFixed(6)}`, { verbose: true });
+        if (pricingInfo.usesLongContextPricing) {
+          await log(`   Long-context pricing applied because peak prompt exceeded ${pricingInfo.longContextThreshold.toLocaleString()} input tokens`, { verbose: true });
+        }
+      } else if (pricingInfo?.error) {
+        await log(`⚠️ Codex public pricing estimate unavailable: ${pricingInfo.error}`, { level: 'warning', verbose: true });
+      }
       const resultModelUsage = pricingInfo?.tokenUsage ? buildCodexResultModelUsage(firstActualModelId, pricingInfo.tokenUsage, pricingInfo) : null;
 
       // Check for authentication errors first - these should never be retried
@@ -831,6 +910,7 @@ export const executeCodexCommand = async params => {
           limitReached,
           limitResetTime,
           pricingInfo,
+          publicPricingEstimate: pricingInfo?.totalCostUSD ?? null,
           resultModelUsage,
           subAgentCalls: codexJsonState.subAgentCalls.length > 0 ? codexJsonState.subAgentCalls : null,
           codexJsonDetails: codexJsonState,
@@ -853,6 +933,7 @@ export const executeCodexCommand = async params => {
         limitReached,
         limitResetTime,
         pricingInfo,
+        publicPricingEstimate: pricingInfo?.totalCostUSD ?? null,
         resultModelUsage,
         subAgentCalls: codexJsonState.subAgentCalls.length > 0 ? codexJsonState.subAgentCalls : null,
         codexJsonDetails: codexJsonState,
@@ -882,6 +963,7 @@ export const executeCodexCommand = async params => {
         limitReached: false,
         limitResetTime: null,
         pricingInfo: null,
+        publicPricingEstimate: null,
         resultSummary: null, // Issue #1263: No result summary available on error
       };
     } finally {

package/src/github-cost-info.lib.mjs

@@ -21,7 +21,8 @@ const buildTokenUsageString = tokenUsage => {
 };
 
 /** Build cost estimation string for log comments (Issue #1250, Issue #1557, Issue #1600: Decimal precision) */
-export const buildCostInfoString = (totalCostUSD, anthropicTotalCostUSD, pricingInfo) => {
+export const buildCostInfoString = (totalCostUSD, anthropicTotalCostUSD, pricingInfo, options = {}) => {
+  const includeTokenUsage = options.includeTokenUsage !== false;
   const hasPublic = totalCostUSD !== null && totalCostUSD !== undefined;
   const hasAnthropic = anthropicTotalCostUSD !== null && anthropicTotalCostUSD !== undefined;
   const hasPricing = pricingInfo && (pricingInfo.modelName || pricingInfo.tokenUsage || pricingInfo.isFreeModel || pricingInfo.isOpencodeFreeModel);
@@ -57,7 +58,7 @@ export const buildCostInfoString = (totalCostUSD, anthropicTotalCostUSD, pricing
       costInfo += `\n- Calculated by OpenCode Zen: $${new Decimal(pricingInfo.opencodeCost).toFixed(6)}`;
     }
   }
-  if (pricingInfo?.tokenUsage) costInfo += buildTokenUsageString(pricingInfo.tokenUsage);
+  if (includeTokenUsage && pricingInfo?.tokenUsage) costInfo += buildTokenUsageString(pricingInfo.tokenUsage);
   if (hasAnthropic) {
     costInfo += `\n- Calculated by Anthropic: $${anthropicDec.toFixed(6)}`;
     if (hasPublic) {

package/src/github.lib.mjs

@@ -501,7 +501,7 @@ ${logContent}
 *${NOW_WORKING_SESSION_IS_ENDED_MARKER}, feel free to review and add any feedback on the solution draft.*`;
     } else if (errorDuringExecution) {
       // Issue #1088: "Finished with errors" format - work may have been completed but errors occurred
-      const costInfo = buildCostInfoString(totalCostUSD, anthropicTotalCostUSD, pricingInfo);
+      const costInfo = buildCostInfoString(totalCostUSD, anthropicTotalCostUSD, pricingInfo, { includeTokenUsage: !budgetStats });
       logComment = `## ⚠️ ${SOLUTION_DRAFT_FINISHED_WITH_ERRORS_MARKER}
 This log file contains the complete execution trace of the AI ${targetType === 'pr' ? 'solution draft' : 'analysis'} process.${costInfo}${budgetStats}${modelInfoString}
 
@@ -519,7 +519,7 @@ ${logContent}
 ---
 *${NOW_WORKING_SESSION_IS_ENDED_MARKER}, feel free to review and add any feedback on the solution draft.*`;
     } else {
-      const costInfo = buildCostInfoString(totalCostUSD, anthropicTotalCostUSD, pricingInfo);
+      const costInfo = buildCostInfoString(totalCostUSD, anthropicTotalCostUSD, pricingInfo, { includeTokenUsage: !budgetStats });
       // Determine title based on session type (Issue #1152)
       // Issue #1625: Every title variant embeds SOLUTION_DRAFT_LOG_MARKER so
       // the filter in checkForAiCreatedComments matches every variant with a
@@ -684,7 +684,7 @@ ${errorMessage}
 *${NOW_WORKING_SESSION_IS_ENDED_MARKER}, feel free to review and add any feedback on the solution draft.*`;
           } else if (errorDuringExecution) {
             // Issue #1088: "Finished with errors" format - work may have been completed but errors occurred
-            const costInfo = buildCostInfoString(totalCostUSD, anthropicTotalCostUSD, pricingInfo);
+            const costInfo = buildCostInfoString(totalCostUSD, anthropicTotalCostUSD, pricingInfo, { includeTokenUsage: !budgetStats });
             logUploadComment = `## ⚠️ ${SOLUTION_DRAFT_FINISHED_WITH_ERRORS_MARKER}
 This log file contains the complete execution trace of the AI ${targetType === 'pr' ? 'solution draft' : 'analysis'} process.${costInfo}${budgetStats}${modelInfoString}
 
@@ -697,7 +697,7 @@ This log file contains the complete execution trace of the AI ${targetType === '
 *${NOW_WORKING_SESSION_IS_ENDED_MARKER}, feel free to review and add any feedback on the solution draft.*`;
           } else {
             // Success log format - use helper function for cost info
-            const costInfo = buildCostInfoString(totalCostUSD, anthropicTotalCostUSD, pricingInfo);
+            const costInfo = buildCostInfoString(totalCostUSD, anthropicTotalCostUSD, pricingInfo, { includeTokenUsage: !budgetStats });
             // Determine title based on session type
             // See: https://github.com/link-assistant/hive-mind/issues/1152
             // Issue #1625: titles embed SOLUTION_DRAFT_LOG_MARKER (single source).

package/src/limits.lib.mjs

@@ -297,6 +297,15 @@ function formatBytesRange(usedBytes, totalBytes) {
   return `${usedValue.toFixed(decimals)}/${totalValue.toFixed(decimals)} ${sizes[i]} used`;
 }
 
+function formatRoundedNumber(value, decimals = 2) {
+  return parseFloat(value.toFixed(decimals));
+}
+
+function getDisplayCpuCoresUsed(loadAvg5, cpuCount) {
+  const boundedLoad = Math.min(Math.max(loadAvg5, 0), cpuCount);
+  return formatRoundedNumber(boundedLoad);
+}
+
 /**
  * Get GitHub API rate limits by calling gh api rate_limit
  * Returns rate limit info for core, search, graphql, and other resources
@@ -428,6 +437,7 @@ export async function getCpuLoadInfo(verbose = false) {
     // Load average of 1.0 per CPU = 100% utilization
     // Using 5m average for consistency with solve queue (see issue #1137)
     const usagePercentage = Math.min(100, Math.round((loadAvg5 / cpuCount) * 100));
+    const usedCpuCores = getDisplayCpuCoresUsed(loadAvg5, cpuCount);
 
     if (verbose) {
       console.log(`[VERBOSE] /limits CPU load: ${loadAvg1.toFixed(2)} (1m), ${loadAvg5.toFixed(2)} (5m), ${loadAvg15.toFixed(2)} (15m), ${cpuCount} CPUs, ${usagePercentage}% used`);
@@ -441,6 +451,7 @@ export async function getCpuLoadInfo(verbose = false) {
         loadAvg15,
         cpuCount,
         usagePercentage,
+        usedCpuCores,
       },
     };
   } catch (error) {
@@ -1027,9 +1038,14 @@ export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = nu
     // See: https://github.com/link-assistant/hive-mind/issues/1267
     const suffix = cpuLoad.usagePercentage >= DISPLAY_THRESHOLDS.CPU ? ' ⚠️' : ' used';
     section += `${usedBar} ${cpuLoad.usagePercentage}%${suffix}\n`;
-    // Show cores used based on 5m load average (e.g., "0.04/6 CPU cores used" or "3/6 CPU cores used")
-    // Use parseFloat to strip unnecessary trailing zeros (3.00 -> 3, 0.10 -> 0.1, 0.04 -> 0.04)
-    section += `${parseFloat(cpuLoad.loadAvg5.toFixed(2))}/${cpuLoad.cpuCount} CPU cores\n`;
+    // Linux load average is demand, not bounded CPU time. Keep the cores-used
+    // display within CPU capacity and show raw load average only when saturated.
+    const usedCpuCores = cpuLoad.usedCpuCores ?? getDisplayCpuCoresUsed(cpuLoad.loadAvg5, cpuLoad.cpuCount);
+    let cpuCoresLine = `${formatRoundedNumber(usedCpuCores)}/${cpuLoad.cpuCount} CPU cores used`;
+    if (cpuLoad.loadAvg5 > cpuLoad.cpuCount) {
+      cpuCoresLine += ` (5m load avg ${formatRoundedNumber(cpuLoad.loadAvg5)})`;
+    }
+    section += `${cpuCoresLine}\n`;
     sections.push(section);
   }
 

package/src/model-info.lib.mjs

@@ -0,0 +1,66 @@
+import https from 'node:https';
+
+const buildLookupIds = modelId => (modelId?.includes('/') ? [modelId.split('/').pop(), modelId] : [modelId]);
+
+const buildProviderPriority = (modelId, preferredProviderIds = []) => {
+  const inferredProviderIds = [];
+  if (modelId?.startsWith('claude-')) inferredProviderIds.push('anthropic');
+  if (modelId?.startsWith('gpt-') || modelId?.startsWith('chatgpt-')) inferredProviderIds.push('openai');
+  return [...new Set([...preferredProviderIds, ...inferredProviderIds])];
+};
+
+const findProviderModel = (apiData, providerIds, lookupIds) => {
+  for (const providerId of providerIds) {
+    const provider = apiData[providerId];
+    if (!provider?.models) continue;
+    for (const lookupId of lookupIds) {
+      if (provider.models[lookupId]) {
+        return {
+          ...provider.models[lookupId],
+          provider: provider.name || providerId,
+        };
+      }
+    }
+  }
+  return null;
+};
+
+const fetchModelsDevApi = () =>
+  new Promise((resolve, reject) => {
+    https
+      .get('https://models.dev/api.json', res => {
+        let data = '';
+        res.on('data', chunk => {
+          data += chunk;
+        });
+        res.on('end', () => {
+          try {
+            resolve(JSON.parse(data));
+          } catch (error) {
+            reject(error);
+          }
+        });
+      })
+      .on('error', reject);
+  });
+
+/**
+ * Fetches model information from models.dev.
+ * @param {string} modelId - The model ID (e.g., "claude-sonnet-4-5-20250929")
+ * @param {Object} [options]
+ * @param {string[]} [options.preferredProviderIds] Provider IDs to check before the default search order.
+ * @returns {Promise<Object|null>} Model information or null if not found
+ */
+export const fetchModelInfo = async (modelId, options = {}) => {
+  if (!modelId) return null;
+  try {
+    const apiData = await fetchModelsDevApi();
+    const lookupIds = buildLookupIds(modelId);
+    const preferredProviderIds = Array.isArray(options.preferredProviderIds) ? options.preferredProviderIds : [];
+    const providerPriority = buildProviderPriority(modelId, preferredProviderIds);
+    return findProviderModel(apiData, providerPriority, lookupIds) || findProviderModel(apiData, Object.keys(apiData), lookupIds);
+  } catch {
+    // If we can't fetch model info, return null and continue without it.
+    return null;
+  }
+};