@link-assistant/hive-mind 1.50.5 → 1.50.6

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @link-assistant/hive-mind
 
+## 1.50.6
+
+### Patch Changes
+
+- 854a74b: feat: track sub-agent calls and show per-call stats in budget display (#1590)
+  - Split budget usage statistics per sub-agent call when working sessions contain multiple sub-agent invocations
+  - Extract and display individual sub-agent call metrics from Claude API session data
+  - Add budget stats library for parsing and formatting per-call usage information
+
 ## 1.50.5
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.50.5",
+  "version": "1.50.6",
   "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

@@ -362,11 +362,71 @@ const formatContextOutputLine = (peakContext, contextLimit, outputTokens, output
  * @param {Object} tokenUsage - Token usage data from calculateSessionTokens or buildAgentBudgetStats
  * @returns {string} Formatted markdown string for PR comment
  */
-export const buildBudgetStatsString = tokenUsage => {
+/**
+ * Issue #1590: Build a map of model short name to sub-agent call count.
+ * Sub-agent calls use short model names (e.g., "sonnet", "haiku", "opus")
+ * while modelUsage uses full model IDs (e.g., "claude-sonnet-4-6").
+ * @param {Array|null} subAgentCalls - Array of {id, description, model} from stream tracking
+ * @returns {Object} Map of model short name to call count, e.g., {"sonnet": 12, "haiku": 3}
+ */
+const buildSubAgentCallCounts = subAgentCalls => {
+  if (!subAgentCalls || subAgentCalls.length === 0) return {};
+  const counts = {};
+  for (const call of subAgentCalls) {
+    const model = call.model || 'default';
+    counts[model] = (counts[model] || 0) + 1;
+  }
+  return counts;
+};
+
+/**
+ * Issue #1590: Match a full model ID to sub-agent call count.
+ * Maps full model IDs (e.g., "claude-sonnet-4-6") to short names used in Agent tool
+ * (e.g., "sonnet") and returns the call count.
+ * @param {string} modelId - Full model ID
+ * @param {Object} callCounts - Map from buildSubAgentCallCounts
+ * @returns {number} Number of sub-agent calls for this model, or 0 if none
+ */
+const getSubAgentCallCount = (modelId, callCounts) => {
+  if (!callCounts || Object.keys(callCounts).length === 0) return 0;
+  // Direct match first (e.g., model short name used as full ID)
+  if (callCounts[modelId]) return callCounts[modelId];
+  // Match short names to full model IDs:
+  // "claude-sonnet-4-6" contains "sonnet", "claude-haiku-4-5-20251001" contains "haiku", etc.
+  const modelIdLower = modelId.toLowerCase();
+  for (const [shortName, count] of Object.entries(callCounts)) {
+    if (modelIdLower.includes(shortName.toLowerCase())) return count;
+  }
+  return 0;
+};
+
+/**
+ * Issue #1590: Get sub-agent calls matching a specific model ID.
+ * Filters the subAgentCalls array to return only calls whose short model name
+ * matches the given full model ID.
+ * @param {string} modelId - Full model ID (e.g., "claude-sonnet-4-6")
+ * @param {Array|null} subAgentCalls - Array of {id, description, model} from stream tracking
+ * @returns {Array} Matching sub-agent calls for this model
+ */
+const getSubAgentCallsForModel = (modelId, subAgentCalls) => {
+  if (!subAgentCalls || subAgentCalls.length === 0) return [];
+  const modelIdLower = modelId.toLowerCase();
+  return subAgentCalls.filter(call => {
+    const shortName = (call.model || 'default').toLowerCase();
+    return modelIdLower === shortName || modelIdLower.includes(shortName);
+  });
+};
+
+export const buildBudgetStatsString = (tokenUsage, subAgentCalls = null) => {
   if (!tokenUsage) return '';
 
   let stats = '\n\n### 📊 **Context and tokens usage:**';
 
+  // Issue #1590: Build sub-agent call counts per model for per-call breakdown
+  // Guard: subAgentCalls must be an array (ignore legacy streamUsage objects passed as second arg)
+  const validSubAgentCalls = Array.isArray(subAgentCalls) ? subAgentCalls : null;
+  const subAgentCallCounts = buildSubAgentCallCounts(validSubAgentCalls);
+
   // Per-model breakdown
   if (tokenUsage.modelUsage) {
     const modelIds = Object.keys(tokenUsage.modelUsage);
@@ -383,7 +443,17 @@ export const buildBudgetStatsString = tokenUsage => {
       const contextLimit = usage.modelInfo?.limit?.context;
       const outputLimit = usage.modelInfo?.limit?.output;
 
-      if (isMultiModel) stats += `\n\n**${modelName}:**`;
+      // Issue #1590: Check if this model was used as a sub-agent
+      const callCount = getSubAgentCallCount(modelId, subAgentCallCounts);
+
+      if (isMultiModel) {
+        // Issue #1590: Show sub-agent call count alongside model name
+        if (callCount > 1) {
+          stats += `\n\n**${modelName}:** (${callCount} sub-agent calls)`;
+        } else {
+          stats += `\n\n**${modelName}:**`;
+        }
+      }
 
       const peakContext = usage.peakContextUsage || 0;
 
@@ -410,9 +480,16 @@ export const buildBudgetStatsString = tokenUsage => {
       }
 
       // Issue #1547: Consistent output format — use X / Y (Z%) output tokens when limit known
+      // Issue #1590: When multiple sub-agent calls exist, show total output without misleading
+      // per-call percentage (e.g., 530% is sum across 12 calls, not a single call)
       if (peakContext === 0 && outputLimit) {
-        const outPct = ((usage.outputTokens / outputLimit) * 100).toFixed(0);
-        totalLine += `, ${formatTokensCompact(usage.outputTokens)} / ${formatTokensCompact(outputLimit)} (${outPct}%) output tokens`;
+        if (callCount > 1) {
+          // Show total output without percentage (percentage is misleading for aggregated sub-agent calls)
+          totalLine += `, ${formatTokensCompact(usage.outputTokens)} output tokens`;
+        } else {
+          const outPct = ((usage.outputTokens / outputLimit) * 100).toFixed(0);
+          totalLine += `, ${formatTokensCompact(usage.outputTokens)} / ${formatTokensCompact(outputLimit)} (${outPct}%) output tokens`;
+        }
       } else {
         totalLine += `, ${formatTokensCompact(usage.outputTokens)} output tokens`;
       }
@@ -422,6 +499,61 @@ export const buildBudgetStatsString = tokenUsage => {
         totalLine += `, $${usage.costUSD.toFixed(6)} cost`;
       }
 
+      // Issue #1590: Show individual sub-agent call list when multiple calls exist
+      // Total line appears AFTER the sub-agent calls list (not before)
+      if (callCount > 1) {
+        const matchingCalls = getSubAgentCallsForModel(modelId, validSubAgentCalls);
+        // Issue #1590: Check if actual per-call usage data is available from parent_tool_use_id tracking
+        const hasActualUsage = matchingCalls.some(c => c.usage && (c.usage.inputTokens > 0 || c.usage.outputTokens > 0 || c.usage.cacheReadTokens > 0 || c.usage.cacheCreationTokens > 0));
+
+        stats += `\n\nSub-agent calls:`;
+        if (hasActualUsage) {
+          // Show actual per-call usage with limits and percentages (same format as sub-sessions)
+          for (let i = 0; i < matchingCalls.length; i++) {
+            const call = matchingCalls[i];
+            const cu = call.usage || {};
+            const callInput = (cu.inputTokens || 0) + (cu.cacheCreationTokens || 0) + (cu.cacheReadTokens || 0);
+            const callOutput = cu.outputTokens || 0;
+            const parts = [];
+            if (contextLimit) {
+              const pct = ((callInput / contextLimit) * 100).toFixed(0);
+              parts.push(`${formatTokensCompact(callInput)} / ${formatTokensCompact(contextLimit)} (${pct}%) input tokens`);
+            } else {
+              parts.push(`${formatTokensCompact(callInput)} input tokens`);
+            }
+            if (outputLimit) {
+              const outPct = ((callOutput / outputLimit) * 100).toFixed(0);
+              parts.push(`${formatTokensCompact(callOutput)} / ${formatTokensCompact(outputLimit)} (${outPct}%) output tokens`);
+            } else {
+              parts.push(`${formatTokensCompact(callOutput)} output tokens`);
+            }
+            stats += `\n${i + 1}. ${parts.join(', ')}`;
+          }
+        } else {
+          // Fallback: show estimates with limits and percentages when actual per-call data is not available
+          const avgInput = Math.round((totalInputNonCached + cachedTokens) / callCount);
+          const avgOutput = Math.round(usage.outputTokens / callCount);
+          for (let i = 0; i < matchingCalls.length; i++) {
+            const parts = [];
+            if (contextLimit) {
+              const pct = ((avgInput / contextLimit) * 100).toFixed(0);
+              parts.push(`~${formatTokensCompact(avgInput)} / ${formatTokensCompact(contextLimit)} (${pct}%) input tokens`);
+            } else {
+              parts.push(`~${formatTokensCompact(avgInput)} input tokens`);
+            }
+            if (outputLimit) {
+              const outPct = ((avgOutput / outputLimit) * 100).toFixed(0);
+              parts.push(`~${formatTokensCompact(avgOutput)} / ${formatTokensCompact(outputLimit)} (${outPct}%) output tokens`);
+            } else {
+              parts.push(`~${formatTokensCompact(avgOutput)} output tokens`);
+            }
+            stats += `\n${i + 1}. ${parts.join(', ')}`;
+          }
+          // Note about estimates only when using fallback
+          stats += `\n\n_Per-call values are estimates (total ÷ ${callCount}). Exact per-call breakdown requires [upstream support](https://github.com/anthropics/claude-code/issues/46520)._`;
+        }
+      }
+
       stats += `\n\nTotal: ${totalLine}`;
     }
   }
@@ -468,3 +600,36 @@ export const buildAgentBudgetStats = (tokenUsage, pricingInfo) => {
     totalTokens: tokenUsage.inputTokens + (tokenUsage.cacheWriteTokens || 0) + tokenUsage.outputTokens,
   };
 };
+
+/**
+ * Issue #1590: Creates a fresh sub-agent call entry for tracking per-call token usage
+ * @param {Object} item - The tool_use content item from the assistant message
+ * @returns {Object} Sub-agent call entry with id, description, model, and empty usage
+ */
+export const createSubAgentCallEntry = item => {
+  const agentInput = item.input || {};
+  return {
+    id: item.id || null,
+    description: agentInput.description || null,
+    model: agentInput.model || null,
+    usage: {
+      inputTokens: 0,
+      cacheCreationTokens: 0,
+      cacheReadTokens: 0,
+      outputTokens: 0,
+      totalTokens: null, // from task_notification
+    },
+  };
+};
+
+/**
+ * Issue #1590: Accumulates token usage from a stream event into a sub-agent call entry
+ * @param {Object} callEntry - The sub-agent call entry to accumulate into
+ * @param {Object} u - The usage object from the stream event
+ */
+export const accumulateSubAgentUsage = (callEntry, u) => {
+  if (u.input_tokens) callEntry.usage.inputTokens += u.input_tokens;
+  if (u.cache_creation_input_tokens) callEntry.usage.cacheCreationTokens += u.cache_creation_input_tokens;
+  if (u.cache_read_input_tokens) callEntry.usage.cacheReadTokens += u.cache_read_input_tokens;
+  if (u.output_tokens) callEntry.usage.outputTokens += u.output_tokens;
+};

package/src/claude.lib.mjs

@@ -13,7 +13,7 @@ import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs
 import { createInteractiveHandler } from './interactive-mode.lib.mjs';
 import { initProgressMonitoring } from './solve.progress-monitoring.lib.mjs';
 import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
-import { displayBudgetStats, createEmptySubSessionUsage, accumulateModelUsage, displayModelUsage, displayCostComparison, mergeResultModelUsage } from './claude.budget-stats.lib.mjs';
+import { displayBudgetStats, createEmptySubSessionUsage, accumulateModelUsage, displayModelUsage, displayCostComparison, mergeResultModelUsage, createSubAgentCallEntry, accumulateSubAgentUsage } 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
@@ -653,44 +653,9 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
     throw new Error(`Failed to read session file: ${readError.message}`);
   }
 };
-/**
- * Determines whether a stderr message line should be treated as an error.
- *
- * Excludes:
- * - Emoji-prefixed warnings (Issue #477): lines starting with ⚠️ or ⚠
- * - JSON-structured log messages with non-error level (Issue #1337):
- *   e.g. {"level":"warn","message":"...failed..."} — the word "failed" is in
- *   the message text but the level is "warn", so it is NOT an error.
- *   Only JSON lines with level "error" or "fatal" are treated as real errors.
- *
- * @param {string} message - A single trimmed stderr line
- * @returns {boolean} true if the line should count as an error
- */
-export const isStderrError = message => {
-  const trimmed = message.trim();
-  if (!trimmed) return false;
-  // Detection 1: Emoji-prefixed warnings (Issue #477)
-  let isWarning = trimmed.startsWith('⚠️') || trimmed.startsWith('⚠');
-  // Detection 2: JSON-structured log messages (Issue #1337)
-  if (!isWarning && trimmed.startsWith('{')) {
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (parsed && typeof parsed.level === 'string') {
-        const level = parsed.level.toLowerCase();
-        // Only "error" and "fatal" levels are real errors.
-        if (level !== 'error' && level !== 'fatal') {
-          isWarning = true;
-        }
-      }
-    } catch {
-      // Not valid JSON — fall through to keyword matching
-    }
-  }
-  if (!isWarning && (trimmed.includes('Error:') || trimmed.includes('error') || trimmed.includes('failed') || trimmed.includes('not found'))) {
-    return true;
-  }
-  return false;
-};
+// Extracted to claude.stderr.lib.mjs (Issue #477, #1337)
+import { isStderrError } from './claude.stderr.lib.mjs';
+export { isStderrError };
 export const executeClaudeCommand = async params => {
   const {
     tempDir,
@@ -777,6 +742,10 @@ export const executeClaudeCommand = async params => {
     let errorDuringExecution = false;
     let resultSummary = null;
     let resultModelUsage = null;
+    // Issue #1590: Track sub-agent calls (Agent tool invocations) for per-call stats
+    const subAgentCalls = [];
+    // Issue #1590: Map tool_use_id -> subAgentCalls index for accumulating per-call usage from parent_tool_use_id events
+    const subAgentCallsByToolUseId = new Map();
     // Issue #1491: Track token usage from stream JSON events for independent calculation
     const streamTokenUsage = {
       inputTokens: 0,
@@ -1026,6 +995,18 @@ export const executeClaudeCommand = async params => {
                 if (u.cache_read_input_tokens) streamTokenUsage.cacheReadTokens += u.cache_read_input_tokens;
                 if (u.output_tokens) streamTokenUsage.outputTokens += u.output_tokens;
                 streamTokenUsage.eventCount++;
+                // Issue #1590: Accumulate per-sub-agent usage from parent_tool_use_id
+                if (data.parent_tool_use_id && subAgentCallsByToolUseId.has(data.parent_tool_use_id)) {
+                  accumulateSubAgentUsage(subAgentCallsByToolUseId.get(data.parent_tool_use_id), u);
+                }
+              }
+              // Issue #1590: Capture total_tokens from task_notification (completed sub-agent)
+              if (data.type === 'system' && data.subtype === 'task_notification' && data.status === 'completed' && data.tool_use_id) {
+                const callEntry = subAgentCallsByToolUseId.get(data.tool_use_id);
+                if (callEntry && data.usage && data.usage.total_tokens) {
+                  callEntry.usage.totalTokens = data.usage.total_tokens;
+                  await log(`🤖 Sub-agent "${callEntry.description || 'unknown'}" completed: ${data.usage.total_tokens} total tokens`, { verbose: true });
+                }
               }
               if (data.type === 'assistant' && data.message && data.message.content) {
                 const content = Array.isArray(data.message.content) ? data.message.content : [data.message.content];
@@ -1054,6 +1035,13 @@ export const executeClaudeCommand = async params => {
                       await log('⏱️ Detected request timeout in assistant message (will retry with --resume)', { verbose: true });
                     }
                   }
+                  // Issue #1590: Track sub-agent calls (Agent tool invocations) for per-call stats
+                  if (item.type === 'tool_use' && item.name === 'Agent') {
+                    const callEntry = createSubAgentCallEntry(item);
+                    subAgentCalls.push(callEntry);
+                    if (item.id) subAgentCallsByToolUseId.set(item.id, callEntry);
+                    await log(`🤖 Sub-agent call #${subAgentCalls.length}: "${callEntry.description || 'unknown'}" (model: ${callEntry.model || 'default'})`, { verbose: true });
+                  }
                 }
               }
             } catch (parseError) {
@@ -1381,6 +1369,7 @@ export const executeClaudeCommand = async params => {
         resultSummary, // Issue #1263: Include result summary for --attach-solution-summary
         resultModelUsage, // Issue #1454
         streamTokenUsage: streamTokenUsage.eventCount > 0 ? streamTokenUsage : null, // Issue #1491
+        subAgentCalls: subAgentCalls.length > 0 ? subAgentCalls : null, // Issue #1590
       };
     } catch (error) {
       reportError(error, {

package/src/claude.stderr.lib.mjs

@@ -0,0 +1,38 @@
+/**
+ * Determines whether a stderr message line should be treated as an error.
+ *
+ * Excludes:
+ * - Emoji-prefixed warnings (Issue #477): lines starting with ⚠️ or ⚠
+ * - JSON-structured log messages with non-error level (Issue #1337):
+ *   e.g. {"level":"warn","message":"...failed..."} — the word "failed" is in
+ *   the message text but the level is "warn", so it is NOT an error.
+ *   Only JSON lines with level "error" or "fatal" are treated as real errors.
+ *
+ * @param {string} message - A single trimmed stderr line
+ * @returns {boolean} true if the line should count as an error
+ */
+export const isStderrError = message => {
+  const trimmed = message.trim();
+  if (!trimmed) return false;
+  // Detection 1: Emoji-prefixed warnings (Issue #477)
+  let isWarning = trimmed.startsWith('⚠️') || trimmed.startsWith('⚠');
+  // Detection 2: JSON-structured log messages (Issue #1337)
+  if (!isWarning && trimmed.startsWith('{')) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed.level === 'string') {
+        const level = parsed.level.toLowerCase();
+        // Only "error" and "fatal" levels are real errors.
+        if (level !== 'error' && level !== 'fatal') {
+          isWarning = true;
+        }
+      }
+    } catch {
+      // Not valid JSON — fall through to keyword matching
+    }
+  }
+  if (!isWarning && (trimmed.includes('Error:') || trimmed.includes('error') || trimmed.includes('failed') || trimmed.includes('not found'))) {
+    return true;
+  }
+  return false;
+};

package/src/github.lib.mjs

@@ -366,7 +366,7 @@ export async function attachLogToGitHub(options) {
     resultModelUsage = null, // Issue #1454
     budgetStatsData = null, // Issue #1491: budget stats for comment
   } = options;
-  const budgetStats = budgetStatsData ? buildBudgetStatsString(budgetStatsData.tokenUsage) : '';
+  const budgetStats = budgetStatsData ? buildBudgetStatsString(budgetStatsData.tokenUsage, budgetStatsData.subAgentCalls) : '';
   const targetName = targetType === 'pr' ? 'Pull Request' : 'Issue';
   const ghCommand = targetType === 'pr' ? 'pr' : 'issue';
   try {

package/src/solve.mjs

@@ -879,6 +879,7 @@ try {
   let resultSummary = toolResult.resultSummary || null;
   let resultModelUsage = toolResult.resultModelUsage || null;
   let streamTokenUsage = toolResult.streamTokenUsage || null;
+  let subAgentCalls = toolResult.subAgentCalls || null; // Issue #1590
   limitReached = toolResult.limitReached;
   cleanupContext.limitReached = limitReached;
 
@@ -1173,9 +1174,8 @@ try {
   // Show summary of session and log file
   await showSessionSummary(sessionId, limitReached, argv, issueUrl, tempDir, shouldAttachLogs);
 
-  // Issue #1571: Defense-in-depth guard. autoContinueWhenLimitResets() awaits child exit
-  // and calls process.exit(), so this should not be reached. Skip post-processing to
-  // prevent "Solution Draft Log" / "Ready to merge" comments before "Auto Resume".
+  // Issue #1571: Defense-in-depth guard — skip post-processing if auto-continue is handling it
+  // (prevents "Solution Draft Log" / "Ready to merge" comments before "Auto Resume")
   if (limitReached && (argv.autoResumeOnLimitReset || argv.autoRestartOnLimitReset) && global.limitResetTime) {
     await safeExit(0, 'Auto-continue child process will handle post-processing');
   }
@@ -1216,7 +1216,7 @@ try {
   }
 
   // Search for newly created pull requests and comments
-  const verifyResult = await verifyResults(owner, repo, branchName, issueNumber, prNumber, prUrl, referenceTime, argv, shouldAttachLogs, shouldRestart, sessionId, tempDir, anthropicTotalCostUSD, publicPricingEstimate, pricingInfo, errorDuringExecution, sessionType, resultModelUsage, streamTokenUsage);
+  const verifyResult = await verifyResults(owner, repo, branchName, issueNumber, prNumber, prUrl, referenceTime, argv, shouldAttachLogs, shouldRestart, sessionId, tempDir, anthropicTotalCostUSD, publicPricingEstimate, pricingInfo, errorDuringExecution, sessionType, resultModelUsage, streamTokenUsage, subAgentCalls);
   const logsAlreadyUploaded = verifyResult?.logUploadSuccess || false;
 
   // Issue #1162: Auto-restart when PR title/description still has placeholder content
@@ -1263,7 +1263,7 @@ try {
     await cleanupClaudeFile(tempDir, branchName, null, argv);
 
     // Re-verify results after restart (without auto-restart flag to prevent recursion)
-    const reVerifyResult = await verifyResults(owner, repo, branchName, issueNumber, prNumber, prUrl, referenceTime, { ...argv, autoRestartOnNonUpdatedPullRequestDescription: false }, shouldAttachLogs, false, sessionId, tempDir, anthropicTotalCostUSD, publicPricingEstimate, pricingInfo, errorDuringExecution, sessionType, resultModelUsage, streamTokenUsage);
+    const reVerifyResult = await verifyResults(owner, repo, branchName, issueNumber, prNumber, prUrl, referenceTime, { ...argv, autoRestartOnNonUpdatedPullRequestDescription: false }, shouldAttachLogs, false, sessionId, tempDir, anthropicTotalCostUSD, publicPricingEstimate, pricingInfo, errorDuringExecution, sessionType, resultModelUsage, streamTokenUsage, subAgentCalls);
 
     if (reVerifyResult?.prTitleHasPlaceholder || reVerifyResult?.prBodyHasPlaceholder) {
       await log('⚠️  PR title/description still not updated after restart');

package/src/solve.results.lib.mjs

@@ -503,7 +503,7 @@ export const showSessionSummary = async (sessionId, limitReached, argv, issueUrl
 };
 
 // Verify results by searching for new PRs and comments
-export const verifyResults = async (owner, repo, branchName, issueNumber, prNumber, prUrl, referenceTime, argv, shouldAttachLogs, shouldRestart = false, sessionId = null, tempDir = null, anthropicTotalCostUSD = null, publicPricingEstimate = null, pricingInfo = null, errorDuringExecution = false, sessionType = 'new', resultModelUsage = null, streamTokenUsage = null) => {
+export const verifyResults = async (owner, repo, branchName, issueNumber, prNumber, prUrl, referenceTime, argv, shouldAttachLogs, shouldRestart = false, sessionId = null, tempDir = null, anthropicTotalCostUSD = null, publicPricingEstimate = null, pricingInfo = null, errorDuringExecution = false, sessionType = 'new', resultModelUsage = null, streamTokenUsage = null, subAgentCalls = null) => {
   await log('\n🔍 Searching for created pull requests or comments...');
 
   // Issue #1491, #1526: Build budget stats data for GitHub comment (computed once, used in both PR and issue paths)
@@ -513,7 +513,7 @@ export const verifyResults = async (owner, repo, branchName, issueNumber, prNumb
       const { calculateSessionTokens } = await import('./claude.lib.mjs');
       const tokenUsage = await calculateSessionTokens(sessionId, tempDir, resultModelUsage);
       if (tokenUsage) {
-        budgetStatsData = { tokenUsage, streamTokenUsage };
+        budgetStatsData = { tokenUsage, streamTokenUsage, subAgentCalls };
       }
     } catch (budgetError) {
       if (argv.verbose) await log(`  ⚠️  Could not calculate budget stats: ${budgetError.message}`, { verbose: true });

package/src/solve.watch.lib.mjs

@@ -347,7 +347,7 @@ export const watchForFeedback = async params => {
               const { calculateSessionTokens } = await import('./claude.lib.mjs');
               const tokenUsage = await calculateSessionTokens(latestSessionId, tempDir, toolResult.resultModelUsage);
               if (tokenUsage) {
-                autoRestartBudgetStatsData = { tokenUsage, streamTokenUsage: toolResult.streamTokenUsage || null };
+                autoRestartBudgetStatsData = { tokenUsage, streamTokenUsage: toolResult.streamTokenUsage || null, subAgentCalls: toolResult.subAgentCalls || null };
               }
             } catch (budgetError) {
               if (argv.verbose) await log(`  ⚠️  Could not calculate budget stats: ${budgetError.message}`, { verbose: true });