@link-assistant/hive-mind 1.50.4 → 1.50.6

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @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
+
+- 61b2a32: fix: prevent solution draft log and ready to merge comments from appearing between limit reached and auto resume (#1571)
+  - `autoContinueWhenLimitResets()` now awaits child process exit instead of returning immediately after spawn
+  - Added defense-in-depth guard in solve.mjs to skip post-processing when limit was reached with auto-continue enabled
+  - This ensures the correct comment ordering: Limit Reached → Auto Resume → Solution Draft Log → Ready to merge
+
 ## 1.50.4
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.50.4",
+  "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.auto-continue.lib.mjs

@@ -182,8 +182,16 @@ export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, sho
       env: process.env,
     });
 
-    child.on('close', code => {
-      process.exit(code);
+    // Issue #1571: Await child process exit to prevent parent from continuing
+    // to post "Solution Draft Log" and "Ready to merge" comments before the
+    // resumed session starts. Without this await, the parent process would
+    // return from this function and continue executing verifyResults() and
+    // startAutoRestartUntilMergeable(), causing confusing comment ordering.
+    await new Promise(resolve => {
+      child.on('close', code => {
+        process.exit(code);
+        resolve(); // Won't be reached due to process.exit, but included for completeness
+      });
     });
   } catch (error) {
     reportError(error, {

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

@@ -62,10 +62,7 @@ export const watchUntilMergeable = async params => {
   const { issueUrl, owner, repo, issueNumber, prNumber, prBranch, branchName, tempDir, argv } = params;
 
   const rawWatchInterval = argv.watchInterval || 60; // seconds
-  // Issue #1503: Enforce minimum CI check interval to conserve GitHub API rate limits.
-  // Issue #1567: Reduced from 5 minutes (300s) to 2 minutes (120s) to decrease wait times
-  // between working session finish and "Ready to merge" / next action detection.
-  // This also applies uniformly whether CI/CD is configured or not.
+  // Issue #1567: Minimum 120s interval to conserve API rate limits while keeping responsiveness
   const MIN_CI_CHECK_INTERVAL_SECONDS = 120;
   const watchInterval = Math.max(rawWatchInterval, MIN_CI_CHECK_INTERVAL_SECONDS);
   const isAutoMerge = argv.autoMerge || false;
@@ -76,39 +73,19 @@ export const watchUntilMergeable = async params => {
   let latestSessionId = null;
   let latestAnthropicCost = null;
 
-  // Issue #1323: Track actual restart count separately from check cycle iteration
-  // `iteration` counts check cycles (how many times we check for blockers)
-  // `restartCount` counts actual AI tool executions (when we actually restart the AI)
+  // Issue #1323: Track actual AI restarts separately from check cycle iterations
   let restartCount = 0;
 
-  // Issue #1371: Track whether a "Ready to merge" comment was posted in THIS session.
-  // This replaces the all-time history check (checkForExistingComment) which incorrectly
-  // suppressed new notifications when a previous solve run had already posted one.
-  // In-memory deduplication correctly handles the case where multiple check cycles in
-  // the same run detect mergeability simultaneously, without blocking fresh runs.
+  // Issue #1371: In-memory dedup for "Ready to merge" comment (per-session, not all-time)
   let readyToMergeCommentPosted = false;
 
   let currentBackoffSeconds = watchInterval;
 
-  // Issue #1503: Track consecutive "no workflow runs" checks per-SHA separately from iteration count.
-  // The `checkCount` parameter in getMergeBlockers is a safety valve that triggers after
-  // MAX_NO_RUNS_CHECKS (5) consecutive checks with zero workflow runs, concluding CI was
-  // genuinely not triggered (paths-ignore, fork PRs, etc.). Previously, `iteration` (total
-  // loop count) was passed as `checkCount`, which meant after 5 iterations (regardless of
-  // CI state), any new push would immediately trigger the safety valve because checkCount
-  // was already >= 5. This caused false positive "Ready to merge" when a new commit was
-  // pushed and CI hadn't registered yet.
-  //
-  // Fix: Track the HEAD SHA and reset the counter when it changes (new push detected).
+  // Issue #1503: Track consecutive "no workflow runs" checks per-SHA (reset on new push)
   let consecutiveNoRunsChecks = 0;
   let lastKnownHeadSha = null;
 
-  // Issue #1567: Initial cooldown before first check.
-  // Wait at least MIN_CI_CHECK_INTERVAL_SECONDS after working session finishes before
-  // starting to check. This ensures:
-  // 1. Solution Draft Log is fully posted before any "Ready to merge" can appear
-  // 2. CI/CD checks have time to register with GitHub (avoids false "no CI" detection)
-  // 3. Consistent behavior whether CI/CD is configured or not
+  // Issue #1567: Initial cooldown to let CI register and solution logs post
   const INITIAL_COOLDOWN_SECONDS = MIN_CI_CHECK_INTERVAL_SECONDS;
 
   await log('');
@@ -161,9 +138,7 @@ export const watchUntilMergeable = async params => {
     await log(formatAligned('🔍', `Check #${iteration}:`, currentTime.toLocaleTimeString()));
 
     try {
-      // Issue #1503: Get the current HEAD SHA to detect new pushes and reset the
-      // consecutive no-runs counter. This prevents false positives where the counter
-      // from a previous commit's checks carries over to a new commit.
+      // Issue #1503: Get current HEAD SHA to detect new pushes and reset no-runs counter
       let currentHeadSha = null;
       try {
         const shaResult = await $`gh pr view ${prNumber} --repo ${owner}/${repo} --json headRefOid --jq .headRefOid`;
@@ -184,17 +159,13 @@ export const watchUntilMergeable = async params => {
         readyToMergeCommentPosted = false;
       }
 
-      // Issue #1503: Increment counter; getMergeBlockers will use it as a safety valve.
-      // If getMergeBlockers sees no workflow runs on this check, the counter stays incremented.
-      // If it sees workflow runs or checks, the counter is irrelevant (different code paths).
+      // Issue #1503: Increment counter; getMergeBlockers uses it as a safety valve
       consecutiveNoRunsChecks++;
 
       // Get merge blockers
       const { blockers, noCiConfigured, noCiTriggered, workflowRunConclusions, ciStatus } = await getMergeBlockers(owner, repo, prNumber, argv.verbose, consecutiveNoRunsChecks, prBranch);
 
-      // Issue #1503: Reset consecutive counter when CI checks or workflow runs were found.
-      // This ensures the safety valve only fires after truly consecutive "no runs" checks,
-      // not after interleaved pending/success/failure states that happened to reach the count.
+      // Issue #1503: Reset counter when CI checks exist (safety valve only for consecutive "no runs")
       if (ciStatus && ciStatus.status !== 'no_checks') {
         // CI checks exist (pending, success, failure, etc.) — the "no runs" counter is irrelevant
         consecutiveNoRunsChecks = 0;

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;
 
@@ -1077,13 +1078,10 @@ try {
     }
   }
 
-  // Handle failure cases, but skip exit if limit reached with auto-resume enabled
-  // This allows the code to continue to showSessionSummary() where autoContinueWhenLimitResets() is called
+  // Skip failure exit if limit reached with auto-resume (continues to showSessionSummary/autoContinueWhenLimitResets)
   const shouldSkipFailureExitForAutoLimitContinue = limitReached && argv.autoResumeOnLimitReset;
-
   if (!success && !shouldSkipFailureExitForAutoLimitContinue) {
     // Show claude resume command only for --tool claude (or default) on failure
-    // Uses the (cd ... && claude --resume ...) pattern for a fully copyable, executable command
     const toolForFailure = argv.tool || 'claude';
     if (sessionId && toolForFailure === 'claude') {
       const claudeResumeCmd = buildClaudeResumeCommand({ tempDir, sessionId, model: argv.model });
@@ -1094,9 +1092,7 @@ try {
       await log('');
     }
 
-    // If --attach-logs is enabled, attach failure logs before exiting
-    // Note: sessionId is not required - logs should be uploaded even if agent failed before establishing a session
-    // Issues #1212, #1462: Fall back to uploading logs to the issue if PR is not available
+    // Attach failure logs before exiting (Issues #1212, #1462: fall back to issue if no PR)
     const hasPR = global.createdPR && global.createdPR.number;
     const hasIssue = global.issueNumber;
     const logTargetType = hasPR ? 'pr' : hasIssue ? 'issue' : null;
@@ -1148,8 +1144,7 @@ try {
     await safeExit(1, `${argv.tool.toUpperCase()} execution failed`);
   }
 
-  // Clean up .playwright-mcp/ folder before checking for uncommitted changes
-  // This prevents browser automation artifacts from triggering auto-restart (Issue #1124)
+  // Clean up .playwright-mcp/ to prevent browser artifacts from triggering auto-restart (Issue #1124)
   if (argv.playwrightMcpAutoCleanup !== false) {
     const playwrightMcpDir = path.join(tempDir, '.playwright-mcp');
     try {
@@ -1179,6 +1174,12 @@ try {
   // Show summary of session and log file
   await showSessionSummary(sessionId, limitReached, argv, issueUrl, tempDir, shouldAttachLogs);
 
+  // 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');
+  }
+
   // Issue #1263: Handle solution summary attachment
   // --attach-solution-summary: Always attach if result summary is available
   // --auto-attach-solution-summary: Only attach if AI didn't create any comments during session
@@ -1215,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
@@ -1262,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 });