@link-assistant/hive-mind 1.40.1 → 1.40.2

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @link-assistant/hive-mind
 
+## 1.40.2
+
+### Patch Changes
+
+- 3dbbe9c: fix: improve context, token and cost estimation accuracy for multi-model sessions (#1508)
+  - Merge resultModelUsage from Claude Code result JSON into JSONL-based calculations to include sub-agent model tokens (e.g., Haiku) that are missing from JSONL
+  - Split token and context usage per model in budget stats PR comments
+  - Show per-model cost breakdown in budget stats
+  - Fix sub-sessions being duplicated under each model heading in multi-model mode
+  - Add verbose diagnostics indicating when token data is sourced from result JSON vs JSONL
+
 ## 1.40.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.40.1",
+  "version": "1.40.2",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/claude.budget-stats.lib.mjs

@@ -200,6 +200,49 @@ export const displayBudgetStats = async (usage, tokenUsage, log) => {
   await log(`        Total output tokens: ${formatNumber(usage.outputTokens)}`);
 };
 
+/**
+ * Merge resultModelUsage from Claude Code result JSON into JSONL-based modelUsage map.
+ * Issue #1508: The JSONL file may miss sub-agent model entries (e.g., Haiku used internally),
+ * while resultModelUsage from the success result event has the authoritative per-model breakdown.
+ * @param {Object} modelUsage - Map of model ID to accumulated usage from JSONL parsing
+ * @param {Object} resultModelUsage - Per-model usage from Claude Code result JSON event
+ */
+export const mergeResultModelUsage = (modelUsage, resultModelUsage) => {
+  if (!resultModelUsage || typeof resultModelUsage !== 'object') return;
+  for (const [modelId, resultUsage] of Object.entries(resultModelUsage)) {
+    if (modelId.startsWith('<') && modelId.endsWith('>')) continue;
+    if (!modelUsage[modelId]) {
+      modelUsage[modelId] = {
+        inputTokens: resultUsage.inputTokens || 0,
+        cacheCreationTokens: resultUsage.cacheCreationInputTokens || 0,
+        cacheCreation5mTokens: 0,
+        cacheCreation1hTokens: 0,
+        cacheReadTokens: resultUsage.cacheReadInputTokens || 0,
+        outputTokens: resultUsage.outputTokens || 0,
+        webSearchRequests: resultUsage.webSearchRequests || 0,
+        _sourceResultJson: true,
+      };
+      if (resultUsage.costUSD != null) {
+        modelUsage[modelId]._resultCostUSD = resultUsage.costUSD;
+      }
+    } else {
+      const jsonlUsage = modelUsage[modelId];
+      const jsonlTotal = jsonlUsage.inputTokens + jsonlUsage.cacheCreationTokens + jsonlUsage.cacheReadTokens + jsonlUsage.outputTokens;
+      const resultTotal = (resultUsage.inputTokens || 0) + (resultUsage.cacheCreationInputTokens || 0) + (resultUsage.cacheReadInputTokens || 0) + (resultUsage.outputTokens || 0);
+      if (resultTotal > jsonlTotal) {
+        jsonlUsage.inputTokens = resultUsage.inputTokens || 0;
+        jsonlUsage.cacheCreationTokens = resultUsage.cacheCreationInputTokens || 0;
+        jsonlUsage.cacheReadTokens = resultUsage.cacheReadInputTokens || 0;
+        jsonlUsage.outputTokens = resultUsage.outputTokens || 0;
+        jsonlUsage._sourceResultJson = true;
+      }
+      if (resultUsage.costUSD != null) {
+        jsonlUsage._resultCostUSD = resultUsage.costUSD;
+      }
+    }
+  }
+};
+
 /**
  * Format a token count with K/M suffix for compact display
  * @param {number} tokens - Token count
@@ -212,9 +255,43 @@ const formatTokensCompact = tokens => {
 };
 
 /**
- * Build budget stats string for GitHub PR comments (Issue #1491, #1501)
+ * Format sub-sessions list for budget stats display
+ * @param {Array} subSessions - Array of sub-session usage objects
+ * @param {number|null} contextLimit - Context window limit for the model
+ * @param {number|null} outputLimit - Output token limit for the model
+ * @returns {string} Formatted sub-sessions string
+ */
+const formatSubSessionsList = (subSessions, contextLimit, outputLimit) => {
+  let result = '\n\nSub sessions (between compact events):';
+  for (let i = 0; i < subSessions.length; i++) {
+    const sub = subSessions[i];
+    const subPeakContext = sub.peakContextUsage || 0;
+    const subTotalInput = sub.inputTokens + sub.cacheCreationTokens + sub.cacheReadTokens;
+    let line = `\n${i + 1}. `;
+    if (contextLimit && subPeakContext > 0) {
+      const pct = ((subPeakContext / contextLimit) * 100).toFixed(0);
+      line += `${formatTokensCompact(subPeakContext)} / ${formatTokensCompact(contextLimit)} input tokens (${pct}%)`;
+    } else {
+      line += `${formatTokensCompact(subTotalInput)} input tokens`;
+    }
+    if (outputLimit) {
+      const outPct = ((sub.outputTokens / outputLimit) * 100).toFixed(0);
+      line += `; ${formatTokensCompact(sub.outputTokens)} / ${formatTokensCompact(outputLimit)} output tokens (${outPct}%)`;
+    } else {
+      line += `; ${formatTokensCompact(sub.outputTokens)} output tokens`;
+    }
+    result += line;
+  }
+  return result;
+};
+
+/**
+ * Build budget stats string for GitHub PR comments (Issue #1491, #1501, #1508)
  * Format requested by user: sub-sessions between compactification events,
  * per-model breakdown, cumulative totals with cached tokens shown separately.
+ * Issue #1508: When multiple models are used, token and context usage is now split by model.
+ * Sub-sessions are shown as a global section (not duplicated per model) since JSONL
+ * sub-session tracking is global across all models.
  * @param {Object} tokenUsage - Token usage data from calculateSessionTokens
  * @param {Object|null} streamTokenUsage - Token usage from stream JSON events (used for comparison, not displayed)
  * @returns {string} Formatted markdown string for PR comment
@@ -229,6 +306,20 @@ export const buildBudgetStatsString = tokenUsage => {
     const modelIds = Object.keys(tokenUsage.modelUsage);
     const isMultiModel = modelIds.length > 1;
 
+    // Issue #1508: For multi-model sessions, show sub-sessions once (globally), not per-model
+    // Sub-sessions track compactification boundaries which are session-wide, not model-specific
+    const subSessions = tokenUsage.subSessions || [];
+    const hasMultipleSubSessions = subSessions.length > 1;
+
+    if (isMultiModel && hasMultipleSubSessions) {
+      // Issue #1508: For multi-model sessions, show global sub-sessions once (not per-model),
+      // since sub-sessions track compactification boundaries which are session-wide.
+      // Per-model context/output limits are shown below under each model heading.
+      const primaryModelId = modelIds[0];
+      const primaryUsage = tokenUsage.modelUsage[primaryModelId];
+      stats += formatSubSessionsList(subSessions, primaryUsage.modelInfo?.limit?.context, primaryUsage.modelInfo?.limit?.output);
+    }
+
     for (const modelId of modelIds) {
       const usage = tokenUsage.modelUsage[modelId];
       const modelName = usage.modelName || modelId;
@@ -237,34 +328,29 @@ export const buildBudgetStatsString = tokenUsage => {
 
       if (isMultiModel) stats += `\n\n**${modelName}:**`;
 
-      // Sub-session display (Issue #1501: show per sub-session stats)
-      const subSessions = tokenUsage.subSessions || [];
-      const hasMultipleSubSessions = subSessions.length > 1;
-
-      if (hasMultipleSubSessions) {
-        // Multiple sub-sessions: show numbered list
-        stats += '\n\nSub sessions (between compact events):';
-        for (let i = 0; i < subSessions.length; i++) {
-          const sub = subSessions[i];
-          const subPeakContext = sub.peakContextUsage || 0;
-          const subTotalInput = sub.inputTokens + sub.cacheCreationTokens + sub.cacheReadTokens;
-          let line = `\n${i + 1}. `;
-          if (contextLimit && subPeakContext > 0) {
-            const pct = ((subPeakContext / contextLimit) * 100).toFixed(0);
-            line += `${formatTokensCompact(subPeakContext)} / ${formatTokensCompact(contextLimit)} input tokens (${pct}%)`;
-          } else {
-            line += `${formatTokensCompact(subTotalInput)} input tokens`;
-          }
-          if (outputLimit) {
-            const outPct = ((sub.outputTokens / outputLimit) * 100).toFixed(0);
-            line += `; ${formatTokensCompact(sub.outputTokens)} / ${formatTokensCompact(outputLimit)} output tokens (${outPct}%)`;
+      if (!isMultiModel && hasMultipleSubSessions) {
+        // Single-model + multiple sub-sessions: show sub-sessions under that model
+        stats += formatSubSessionsList(subSessions, contextLimit, outputLimit);
+      } else if (!isMultiModel && !hasMultipleSubSessions) {
+        // Single-model + single sub-session: simplified format with context/output limits
+        const peakContext = usage.peakContextUsage || 0;
+        if (contextLimit) {
+          if (peakContext > 0) {
+            const pct = ((peakContext / contextLimit) * 100).toFixed(0);
+            stats += `\n- Max context window: ${formatTokensCompact(peakContext)} / ${formatTokensCompact(contextLimit)} input tokens (${pct}%)`;
           } else {
-            line += `; ${formatTokensCompact(sub.outputTokens)} output tokens`;
+            const totalInput = usage.inputTokens + usage.cacheCreationTokens + usage.cacheReadTokens;
+            const pct = ((totalInput / contextLimit) * 100).toFixed(0);
+            stats += `\n- Context window: ${formatTokensCompact(totalInput)} / ${formatTokensCompact(contextLimit)} tokens (${pct}%)`;
           }
-          stats += line;
+        }
+        if (outputLimit) {
+          const outPct = ((usage.outputTokens / outputLimit) * 100).toFixed(0);
+          stats += `\n- Max output tokens: ${formatTokensCompact(usage.outputTokens)} / ${formatTokensCompact(outputLimit)} output tokens (${outPct}%)`;
         }
       } else {
-        // Single sub-session (or no sub-sessions): simplified format
+        // Multi-model (single or multiple sub-sessions): show per-model context/output limits
+        // Issue #1508: Context window and max output tokens should be split by model
         const peakContext = usage.peakContextUsage || 0;
         if (contextLimit) {
           if (peakContext > 0) {
@@ -282,12 +368,17 @@ export const buildBudgetStatsString = tokenUsage => {
         }
       }
 
-      // Cumulative totals: input tokens + cached shown separately
+      // Cumulative totals per model: input tokens + cached shown separately
       const totalInputNonCached = usage.inputTokens + usage.cacheCreationTokens;
       const cachedTokens = usage.cacheReadTokens;
       stats += `\n\nTotal input tokens: ${formatTokensCompact(totalInputNonCached)}`;
       if (cachedTokens > 0) stats += ` + ${formatTokensCompact(cachedTokens)} cached`;
       stats += `\nTotal output tokens: ${formatTokensCompact(usage.outputTokens)} output`;
+
+      // Issue #1508: Show per-model cost when available
+      if (usage.costUSD !== null && usage.costUSD !== undefined) {
+        stats += `\nCost: $${usage.costUSD.toFixed(6)}`;
+      }
     }
   }
 

package/src/claude.lib.mjs

@@ -12,7 +12,7 @@ import { timeouts, retryLimits, claudeCode, getClaudeEnv, getThinkingLevelToToke
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
 import { createInteractiveHandler } from './interactive-mode.lib.mjs';
 import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
-import { displayBudgetStats, createEmptySubSessionUsage, accumulateModelUsage, displayModelUsage, displayCostComparison } from './claude.budget-stats.lib.mjs';
+import { displayBudgetStats, createEmptySubSessionUsage, accumulateModelUsage, displayModelUsage, displayCostComparison, mergeResultModelUsage } from './claude.budget-stats.lib.mjs';
 import { buildClaudeResumeCommand } from './claude.command-builder.lib.mjs';
 import { handleClaudeRuntimeSwitch } from './claude.runtime-switch.lib.mjs'; // see issue #1141
 import { CLAUDE_MODELS as availableModels } from './models/index.mjs'; // Issue #1221
@@ -480,7 +480,7 @@ export const calculateModelCost = (usage, modelInfo, includeBreakdown = false) =
   }
   return totalCost;
 };
-export const calculateSessionTokens = async (sessionId, tempDir) => {
+export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsage = null) => {
   const os = (await use('os')).default;
   const homeDir = os.homedir();
   // Construct the path to the session JSONL file
@@ -576,6 +576,7 @@ export const calculateSessionTokens = async (sessionId, tempDir) => {
     if (currentSubSession.messageCount > 0) {
       subSessions.push(currentSubSession);
     }
+    mergeResultModelUsage(modelUsage, resultModelUsage);
     // If no usage data was found, return null
     if (Object.keys(modelUsage).length === 0) {
       return null;
@@ -605,7 +606,7 @@ export const calculateSessionTokens = async (sessionId, tempDir) => {
         usage.modelName = modelInfo.name || modelId;
         usage.modelInfo = modelInfo; // Store complete model info
       } else {
-        usage.costUSD = null;
+        usage.costUSD = usage._resultCostUSD ?? null;
         usage.costBreakdown = null;
         usage.modelName = modelId;
         usage.modelInfo = null;
@@ -1307,7 +1308,7 @@ export const executeClaudeCommand = async params => {
       // Calculate and display total token usage from session JSONL file
       if (sessionId && tempDir) {
         try {
-          const tokenUsage = await calculateSessionTokens(sessionId, tempDir);
+          const tokenUsage = await calculateSessionTokens(sessionId, tempDir, resultModelUsage);
           if (tokenUsage) {
             // Issue #1501: Log deduplication stats in verbose mode
             if (tokenUsage.duplicateEntriesSkipped > 0) {
@@ -1320,9 +1321,14 @@ export const executeClaudeCommand = async params => {
             // Display per-model breakdown
             if (tokenUsage.modelUsage) {
               const modelIds = Object.keys(tokenUsage.modelUsage);
+              const modelsFromResult = modelIds.filter(id => tokenUsage.modelUsage[id]._sourceResultJson);
+              if (modelsFromResult.length > 0) {
+                await log(`📊 Token data supplemented from result JSON for: ${modelsFromResult.join(', ')}`, { verbose: true });
+              }
               for (const modelId of modelIds) {
                 const usage = tokenUsage.modelUsage[modelId];
-                await log(`\n   📊 ${usage.modelName || modelId}:`);
+                const sourceNote = usage._sourceResultJson ? ' (from result JSON)' : '';
+                await log(`\n   📊 ${usage.modelName || modelId}:${sourceNote}`);
                 await displayModelUsage(usage, log);
                 // Display budget stats if flag is enabled
                 if (argv.tokensBudgetStats && usage.modelInfo?.limit) {

package/src/github.lib.mjs

@@ -399,7 +399,7 @@ export async function attachLogToGitHub(options) {
     if (totalCostUSD === null && sessionId && tempDir && !errorMessage) {
       try {
         const { calculateSessionTokens } = await import('./claude.lib.mjs');
-        const tokenUsage = await calculateSessionTokens(sessionId, tempDir);
+        const tokenUsage = await calculateSessionTokens(sessionId, tempDir, resultModelUsage);
         if (tokenUsage) {
           if (tokenUsage.totalCostUSD !== null && tokenUsage.totalCostUSD !== undefined) {
             totalCostUSD = tokenUsage.totalCostUSD;

package/src/solve.auto-merge.lib.mjs

@@ -1120,6 +1120,20 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
             latestAnthropicCost = toolResult.anthropicTotalCostUSD;
           }
 
+          // Issue #1508: Compute budget stats for auto-restart-until-mergeable log comment
+          let autoMergeBudgetStatsData = null;
+          if (argv.tokensBudgetStats && latestSessionId && tempDir) {
+            try {
+              const { calculateSessionTokens } = await import('./claude.lib.mjs');
+              const tokenUsage = await calculateSessionTokens(latestSessionId, tempDir, toolResult.resultModelUsage);
+              if (tokenUsage) {
+                autoMergeBudgetStatsData = { tokenUsage, streamTokenUsage: toolResult.streamTokenUsage || null };
+              }
+            } catch (budgetError) {
+              if (argv.verbose) await log(`  ⚠️  Could not calculate budget stats: ${budgetError.message}`, { verbose: true });
+            }
+          }
+
           // Attach log if enabled
           const shouldAttachLogs = argv.attachLogs || argv['attach-logs'];
           if (prNumber && shouldAttachLogs) {
@@ -1149,6 +1163,9 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
                   // Issue #1225: Pass model and tool info for PR comments
                   requestedModel: argv.model,
                   tool: argv.tool || 'claude',
+                  // Issue #1508: Include budget stats (context/token/cost) for auto-restart log
+                  resultModelUsage: toolResult.resultModelUsage || null,
+                  budgetStatsData: autoMergeBudgetStatsData,
                 });
                 await log(formatAligned('', '✅ Session log uploaded to PR', '', 2));
               }

package/src/solve.results.lib.mjs

@@ -502,7 +502,7 @@ export const verifyResults = async (owner, repo, branchName, issueNumber, prNumb
   if (argv.tokensBudgetStats && sessionId && tempDir) {
     try {
       const { calculateSessionTokens } = await import('./claude.lib.mjs');
-      const tokenUsage = await calculateSessionTokens(sessionId, tempDir);
+      const tokenUsage = await calculateSessionTokens(sessionId, tempDir, resultModelUsage);
       if (tokenUsage) {
         budgetStatsData = { tokenUsage, streamTokenUsage };
       }

package/src/solve.watch.lib.mjs

@@ -300,6 +300,8 @@ export const watchForFeedback = async params => {
                   // Issue #1225: Pass model and tool info for PR comments
                   requestedModel: argv.model,
                   tool: argv.tool || 'claude',
+                  // Issue #1508: Pass model usage for failure log (cost info per model)
+                  resultModelUsage: toolResult.resultModelUsage || null,
                 });
 
                 if (logUploadSuccess) {
@@ -338,6 +340,20 @@ export const watchForFeedback = async params => {
             }
           }
 
+          // Issue #1508: Compute budget stats for auto-restart log comment
+          let autoRestartBudgetStatsData = null;
+          if (argv.tokensBudgetStats && latestSessionId && tempDir) {
+            try {
+              const { calculateSessionTokens } = await import('./claude.lib.mjs');
+              const tokenUsage = await calculateSessionTokens(latestSessionId, tempDir, toolResult.resultModelUsage);
+              if (tokenUsage) {
+                autoRestartBudgetStatsData = { tokenUsage, streamTokenUsage: toolResult.streamTokenUsage || null };
+              }
+            } catch (budgetError) {
+              if (argv.verbose) await log(`  ⚠️  Could not calculate budget stats: ${budgetError.message}`, { verbose: true });
+            }
+          }
+
           // Issue #1107: Attach log after each auto-restart session with its own cost estimation
           // This ensures each restart has its own log comment instead of one combined log at the end
           const shouldAttachLogs = argv.attachLogs || argv['attach-logs'];
@@ -369,6 +385,9 @@ export const watchForFeedback = async params => {
                   // Issue #1225: Pass model and tool info for PR comments
                   requestedModel: argv.model,
                   tool: argv.tool || 'claude',
+                  // Issue #1508: Include budget stats (context/token/cost) for auto-restart log
+                  resultModelUsage: toolResult.resultModelUsage || null,
+                  budgetStatsData: autoRestartBudgetStatsData,
                 });
 
                 if (logUploadSuccess) {