@link-assistant/hive-mind 1.50.5 → 1.50.7

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @link-assistant/hive-mind
 
+## 1.50.7
+
+### Patch Changes
+
+- 84b9853: fix: make all long sleeps interruptible so CTRL+C responds immediately (#1574)
+  - Replace raw `setTimeout` sleeps with an interruptible sleep utility that listens for SIGINT
+  - Ensure CTRL+C during CI polling, auto-merge waits, and auto-continue delays terminates the process immediately
+  - Add `interruptible-sleep.lib.mjs` with full test coverage
+
+## 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.7",
   "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/interruptible-sleep.lib.mjs

@@ -0,0 +1,42 @@
+/**
+ * Interruptible sleep utility for long-running wait loops.
+ *
+ * Replaces raw `await new Promise(r => setTimeout(r, ms))` with a sleep
+ * that resolves immediately on SIGINT, so the process exit handler chain
+ * is not blocked by a lingering timer.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1574
+ */
+
+/**
+ * Sleep for `ms` milliseconds, but resolve early if SIGINT is received.
+ *
+ * When SIGINT fires during the sleep, the timer is cleared and the promise
+ * resolves with `{ interrupted: true }`. The existing SIGINT handler (from
+ * exit-handler.lib.mjs) continues to run normally — this function does NOT
+ * consume or re-emit the signal, it only ensures its own timer doesn't
+ * block the event loop.
+ *
+ * @param {number} ms - Duration in milliseconds
+ * @returns {Promise<{interrupted: boolean}>}
+ */
+export function interruptibleSleep(ms) {
+  return new Promise(resolve => {
+    let timer;
+
+    const onInterrupt = () => {
+      clearTimeout(timer);
+      process.removeListener('SIGINT', onInterrupt);
+      resolve({ interrupted: true });
+    };
+
+    timer = setTimeout(() => {
+      process.removeListener('SIGINT', onInterrupt);
+      resolve({ interrupted: false });
+    }, ms);
+
+    process.on('SIGINT', onInterrupt);
+  });
+}
+
+export default { interruptibleSleep };

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

@@ -49,6 +49,9 @@ const { extractLinkedIssueNumber } = githubLinking;
 // Import configuration
 import { autoContinue, limitReset } from './config.lib.mjs';
 
+// Issue #1574: Interruptible sleep so CTRL+C is never blocked by a lingering timer
+const { interruptibleSleep } = await import('./interruptible-sleep.lib.mjs');
+
 const { calculateWaitTime } = validation;
 
 /**
@@ -116,7 +119,7 @@ export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, sho
     }, countdownInterval);
 
     // Wait until reset time
-    await new Promise(resolve => setTimeout(resolve, waitMs));
+    await interruptibleSleep(waitMs);
     clearInterval(countdownTimer);
 
     const actionType = isRestart ? 'Restarting' : 'Resuming';

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

@@ -54,6 +54,9 @@ import { limitReset } from './config.lib.mjs';
 const autoMergeHelpers = await import('./solve.auto-merge-helpers.lib.mjs');
 const { checkForExistingComment, checkForNonBotComments, getMergeBlockers } = autoMergeHelpers;
 
+// Issue #1574: Interruptible sleep so CTRL+C is never blocked by a lingering timer
+const { interruptibleSleep } = await import('./interruptible-sleep.lib.mjs');
+
 /**
  * Main function: Watch and restart until PR becomes mergeable
  * This implements --auto-restart-until-mergeable functionality
@@ -104,7 +107,7 @@ export const watchUntilMergeable = async params => {
   // Issue #1567: Wait for initial cooldown before first check.
   // This gives CI/CD time to start and solution logs time to be posted.
   await log(formatAligned('⏳', 'Initial cooldown:', `Waiting ${INITIAL_COOLDOWN_SECONDS}s before first check...`));
-  await new Promise(resolve => setTimeout(resolve, INITIAL_COOLDOWN_SECONDS * 1000));
+  await interruptibleSleep(INITIAL_COOLDOWN_SECONDS * 1000);
   await log(formatAligned('✅', 'Cooldown complete:', 'Starting monitoring loop'));
   await log('');
 
@@ -200,7 +203,7 @@ export const watchUntilMergeable = async params => {
         if (!noCiConfigured) {
           const DOUBLE_CHECK_DELAY_MS = 10000; // 10 seconds
           await log(formatAligned('🔍', 'Multi-mechanism CI consensus check:', `Waiting ${DOUBLE_CHECK_DELAY_MS / 1000}s then verifying...`, 2));
-          await new Promise(resolve => setTimeout(resolve, DOUBLE_CHECK_DELAY_MS));
+          await interruptibleSleep(DOUBLE_CHECK_DELAY_MS);
 
           // Run multi-mechanism consensus: Check Runs API + Workflow Runs API + Repo-wide actions
           const consensus = await checkCIConsensus({
@@ -223,7 +226,7 @@ export const watchUntilMergeable = async params => {
             const actualWaitSeconds = currentBackoffSeconds;
             await log(formatAligned('⏱️', 'Next check in:', `${actualWaitSeconds} seconds...`, 2));
             await log('');
-            await new Promise(resolve => setTimeout(resolve, actualWaitSeconds * 1000));
+            await interruptibleSleep(actualWaitSeconds * 1000);
             continue;
           }
           await log(formatAligned('✅', 'All CI mechanisms agree:', `CheckRuns=${consensus.mechanisms.checkRunsAPI.status}, WorkflowRuns=complete(${consensus.mechanisms.workflowRunsAPI.total}), RepoActions=${consensus.mechanisms.repoActions.skipped ? 'skipped' : 'clear'}`, 2));
@@ -236,7 +239,7 @@ export const watchUntilMergeable = async params => {
             const actualWaitSeconds = currentBackoffSeconds;
             await log(formatAligned('⏱️', 'Next check in:', `${actualWaitSeconds} seconds...`, 2));
             await log('');
-            await new Promise(resolve => setTimeout(resolve, actualWaitSeconds * 1000));
+            await interruptibleSleep(actualWaitSeconds * 1000);
             continue;
           }
         }
@@ -606,7 +609,7 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
             }
 
             // Wait until the limit resets
-            await new Promise(resolve => setTimeout(resolve, waitMs));
+            await interruptibleSleep(waitMs);
 
             await log(formatAligned('✅', 'Usage limit wait complete', 'Resuming session...'));
             await log('');
@@ -841,7 +844,7 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
     const actualWaitSeconds = currentBackoffSeconds;
     await log(formatAligned('⏱️', 'Next check in:', `${actualWaitSeconds} seconds...`, 2));
     await log('');
-    await new Promise(resolve => setTimeout(resolve, actualWaitSeconds * 1000));
+    await interruptibleSleep(actualWaitSeconds * 1000);
   }
 };
 

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

@@ -37,6 +37,9 @@ const { detectAndCountFeedback } = feedbackLib;
 const restartShared = await import('./solve.restart-shared.lib.mjs');
 const { checkPRMerged, checkForUncommittedChanges, getUncommittedChangesDetails, executeToolIteration, buildUncommittedChangesFeedback, isApiError } = restartShared;
 
+// Issue #1574: Interruptible sleep so CTRL+C is never blocked by a lingering timer
+const { interruptibleSleep } = await import('./interruptible-sleep.lib.mjs');
+
 /**
  * Monitor for feedback in a loop and trigger restart when detected
  */
@@ -347,7 +350,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 });
@@ -446,7 +449,7 @@ export const watchForFeedback = async params => {
       const actualWaitMs = actualWaitSeconds * 1000;
       await log(formatAligned('⏱️', 'Next check in:', `${actualWaitSeconds} seconds...`, 2));
       await log(''); // Blank line for readability
-      await new Promise(resolve => setTimeout(resolve, actualWaitMs));
+      await interruptibleSleep(actualWaitMs);
     } else if (isTemporaryWatch && !firstIterationInTemporaryMode) {
       // In auto-restart mode, check immediately without waiting
       await log(formatAligned('', 'Checking immediately for uncommitted changes...', '', 2));