@link-assistant/hive-mind 1.40.0 → 1.40.2

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @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
+
+- 9df62ed: fix: increase activity timeout to 1hr, fix idle tracking, improve graceful kill (#1510)
+
 ## 1.40.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.40.0",
+  "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;
@@ -853,21 +854,27 @@ export const executeClaudeCommand = async params => {
       let lastEventTime = null;
       let activityTimeoutId = null;
       let isActivityTimeout = false;
+      // Issue #1510: Separate SIGTERM (graceful) and SIGKILL (force) phases to allow
+      // capturing final output from the process during graceful shutdown
       const forceExitOnTimeout = async () => {
         if (forceExitTriggered) return;
         forceExitTriggered = true;
-        await log(`⚠️ Stream timeout — forcing exit (Issue #1280)`, { verbose: true });
+        await log(`⚠️ Stream timeout — sending SIGTERM for graceful shutdown (Issue #1280, #1510)`, { verbose: true });
         try {
           if (execCommand.kill) {
             execCommand.kill('SIGTERM');
-            // Issue #1346: Follow up with SIGKILL after 2s if still alive
+            // Issue #1346/#1510: Follow up with SIGKILL after 5s if still alive
+            // Increased from 2s to 5s to give more time for final output capture
             const t = setTimeout(() => {
               try {
-                if (!execCommand.result?.code) execCommand.kill('SIGKILL');
+                if (!execCommand.result?.code) {
+                  log(`⚠️ Process did not exit after SIGTERM, sending SIGKILL`, { verbose: true });
+                  execCommand.kill('SIGKILL');
+                }
               } catch {
                 /* exited */
               }
-            }, 2000);
+            }, 5000);
             t.unref();
           }
         } catch (e) {
@@ -892,8 +899,8 @@ export const executeClaudeCommand = async params => {
           activityTimeoutId = setTimeout(async () => {
             if (!forceExitTriggered && !resultEventReceived) {
               isActivityTimeout = true;
-              const idleSeconds = lastEventTime ? Math.round((Date.now() - lastEventTime) / 1000) : 'unknown';
-              await log(`\n⚠️ No stream output for ${timeouts.streamActivityMs / 1000}s after previous activity (idle: ${idleSeconds}s) — force-killing (Issue #1472)`, { level: 'warning' });
+              const idleSeconds = lastEventTime ? `${Math.round((Date.now() - lastEventTime) / 1000)}s` : 'unknown';
+              await log(`\n⚠️ No stream output for ${timeouts.streamActivityMs / 1000}s after previous activity (idle: ${idleSeconds}) — force-killing (Issue #1472)`, { level: 'warning' });
               await forceExitOnTimeout();
             }
           }, timeouts.streamActivityMs);
@@ -901,7 +908,8 @@ export const executeClaudeCommand = async params => {
         }
       };
       for await (const chunk of execCommand.stream()) {
-        if (forceExitTriggered) break;
+        // Issue #1510: Continue processing stream after SIGTERM to capture final output
+        // The stream will naturally end when the process exits (SIGTERM) or is force-killed (SIGKILL after 5s)
         if (!firstChunkReceived) {
           // Issue #1472/#1475: Clear startup timeout on first output
           firstChunkReceived = true;
@@ -922,12 +930,14 @@ export const executeClaudeCommand = async params => {
             if (!line.trim()) continue;
             try {
               const data = sanitizeObjectStrings(JSON.parse(line));
+              // Issue #1510: Track last event time for all modes (not just interactive)
+              // so activity timeout can report accurate idle duration
+              lastEventTime = Date.now();
               if (interactiveHandler) {
                 if (!interactiveHandler._firstEventLogged) {
                   interactiveHandler._firstEventLogged = true;
                   await log(`🔌 Interactive mode: First event received (type: ${data.type || 'unknown'}) — stream is active`, { verbose: true });
                 }
-                lastEventTime = Date.now();
                 try {
                   await interactiveHandler.processEvent(data);
                 } catch (interactiveError) {
@@ -1193,6 +1203,19 @@ export const executeClaudeCommand = async params => {
           const retryMode = isStartupTimeout ? ' (fresh start)' : ' (session preserved)';
           await log(`\n⚠️ ${errorLabel} detected. Retry ${retryCount + 1}/${maxRetries} in ${delayLabel}${retryMode}${notRetryableHint}...`, { level: 'warning' });
           await log(`   Error: ${isStartupTimeout ? `No output from Claude CLI within ${timeouts.streamStartupMs / 1000}s` : isActivityTimeout ? `No output for ${timeouts.streamActivityMs / 1000}s after previous activity` : lastMessage.substring(0, 200)}`, { verbose: true });
+          // Issue #1510: Post PR comment when force-killing and auto-resuming so reviewers can follow the session lifecycle
+          if ((isActivityTimeout || isStartupTimeout) && owner && repo && prNumber && $) {
+            try {
+              const timeoutType = isActivityTimeout ? 'activity' : 'startup';
+              const sessionInfo = sessionId ? `\nSession ID: \`${sessionId}\`` : '';
+              const resumeInfo = isStartupTimeout ? 'Session will be restarted (fresh start).' : `Session will be resumed with \`--resume\` (context preserved).`;
+              const commentBody = `## :warning: Session Force-Killed (${timeoutType} timeout)\n\nThe working session was force-killed due to ${timeoutType} timeout (no stream output for ${isActivityTimeout ? timeouts.streamActivityMs / 1000 : timeouts.streamStartupMs / 1000}s).\n\n**Auto-resuming**: Retry ${retryCount + 1}/${maxRetries} in ${delayLabel}. ${resumeInfo}${sessionInfo}\n\n*This is an automated notification — the session will continue automatically.*`;
+              await $`gh pr comment ${prNumber} --repo ${owner}/${repo} --body ${commentBody}`;
+              await log(`   Posted force-kill notification to PR #${prNumber}`, { verbose: true });
+            } catch (commentError) {
+              await log(`   Warning: Could not post force-kill comment to PR: ${commentError.message}`, { verbose: true });
+            }
+          }
           // Activity timeout preserves session (work was started), startup timeout does not (no session created)
           if (!isStartupTimeout && sessionId && !argv.resume) argv.resume = sessionId;
           await waitWithCountdown(delay, log);
@@ -1285,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) {
@@ -1298,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/config.lib.mjs

@@ -63,8 +63,11 @@ export const timeouts = {
   // after at least one event was received, the process is considered hung mid-session.
   // This catches the case where Claude CLI starts producing output but then stops (e.g., the
   // original Issue #1472 where CLI was stuck for 4.5h with all output arriving only at CTRL+C).
-  // Default: 300000ms (5 minutes). Set to 0 to disable. Configurable via environment variable.
-  streamActivityMs: parseIntWithDefault('HIVE_MIND_STREAM_ACTIVITY_MS', 300000),
+  // Issue #1510: Increased from 300000ms (5 min) to 3600000ms (1 hour) because Claude Code can
+  // legitimately wait for long-running operations (docker builds, CI polls, large compilations).
+  // The 5-minute timeout was force-killing sessions during `sleep 300 && gh run view ...` commands.
+  // Default: 3600000ms (1 hour). Set to 0 to disable. Configurable via environment variable.
+  streamActivityMs: parseIntWithDefault('HIVE_MIND_STREAM_ACTIVITY_MS', 3600000),
 };
 
 // Auto-continue configurations

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) {