@link-assistant/hive-mind 1.9.1 → 1.10.0

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @link-assistant/hive-mind
 
+## 1.10.0
+
+### Minor Changes
+
+- 9b56b26: feat(solve): configure MCP_TIMEOUT and MCP_TOOL_TIMEOUT for claude tool calls
+
+  Added MCP timeout configuration to prevent tool calls from hanging indefinitely:
+  - Added `mcpTimeout` config (default: 900000ms / 15 minutes) for MCP server startup
+  - Added `mcpToolTimeout` config (default: 900000ms / 15 minutes) for MCP tool execution
+  - Support for override via `MCP_TIMEOUT`/`HIVE_MIND_MCP_TIMEOUT` and `MCP_TOOL_TIMEOUT`/`HIVE_MIND_MCP_TOOL_TIMEOUT` environment variables
+  - Updated `getClaudeEnv()` to pass both timeout values to Claude CLI
+  - Added verbose logging for MCP timeout values
+
+  Fixes #1066
+
+## 1.9.2
+
+### Patch Changes
+
+- d39bf3e: Fix disk threshold to use one-at-a-time mode instead of blocking all commands
+  - When disk usage exceeds threshold (90%), now allows exactly one command to run
+  - Previously, disk threshold blocked ALL commands unconditionally (like RAM/CPU)
+  - Now matches behavior of Claude API thresholds (CLAUDE_5_HOUR_SESSION_THRESHOLD, CLAUDE_WEEKLY_THRESHOLD)
+  - Allows controlled task execution during high disk usage while preventing multiple tasks from exhausting resources
+
+  Fixes #1155
+
 ## 1.9.1
 
 ### Patch Changes

package/package.json

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

package/src/claude.lib.mjs

@@ -881,9 +881,12 @@ export const executeClaudeCommand = async params => {
       // See issue #1146 for details on thinking budget translation
       const { thinkingBudget: resolvedThinkingBudget, thinkLevel, isNewVersion } = await resolveThinkingSettings(argv, log);
 
-      // Set CLAUDE_CODE_MAX_OUTPUT_TOKENS (see issue #1076) and optionally MAX_THINKING_TOKENS (see issue #1146)
+      // Set CLAUDE_CODE_MAX_OUTPUT_TOKENS (see issue #1076), MAX_THINKING_TOKENS (see issue #1146),
+      // and MCP timeout configurations (see issue #1066)
       const claudeEnv = getClaudeEnv({ thinkingBudget: resolvedThinkingBudget });
       if (argv.verbose) await log(`📊 CLAUDE_CODE_MAX_OUTPUT_TOKENS: ${claudeCode.maxOutputTokens}`, { verbose: true });
+      if (argv.verbose) await log(`📊 MCP_TIMEOUT: ${claudeCode.mcpTimeout}ms (server startup)`, { verbose: true });
+      if (argv.verbose) await log(`📊 MCP_TOOL_TIMEOUT: ${claudeCode.mcpToolTimeout}ms (tool execution)`, { verbose: true });
       if (resolvedThinkingBudget !== undefined) {
         await log(`📊 MAX_THINKING_TOKENS: ${resolvedThinkingBudget}`, { verbose: true });
       }

package/src/config.lib.mjs

@@ -90,6 +90,15 @@ export const claudeCode = {
   // Default: 64000 (matches Claude Sonnet/Opus/Haiku 4.5 model capabilities)
   // Set via CLAUDE_CODE_MAX_OUTPUT_TOKENS or HIVE_MIND_CLAUDE_CODE_MAX_OUTPUT_TOKENS
   maxOutputTokens: parseIntWithDefault('CLAUDE_CODE_MAX_OUTPUT_TOKENS', parseIntWithDefault('HIVE_MIND_CLAUDE_CODE_MAX_OUTPUT_TOKENS', 64000)),
+  // MCP (Model Context Protocol) timeout configurations
+  // See: https://github.com/link-assistant/hive-mind/issues/1066
+  // See: https://code.claude.com/docs/en/settings#environment-variables
+  // MCP_TIMEOUT: Timeout in milliseconds for MCP server startup
+  // MCP_TOOL_TIMEOUT: Timeout in milliseconds for MCP tool execution
+  // Default: 900000ms (15 minutes) to accommodate long-running Playwright operations
+  // Set via MCP_TIMEOUT/MCP_TOOL_TIMEOUT or HIVE_MIND_MCP_TIMEOUT/HIVE_MIND_MCP_TOOL_TIMEOUT
+  mcpTimeout: parseIntWithDefault('MCP_TIMEOUT', parseIntWithDefault('HIVE_MIND_MCP_TIMEOUT', 900000)),
+  mcpToolTimeout: parseIntWithDefault('MCP_TOOL_TIMEOUT', parseIntWithDefault('HIVE_MIND_MCP_TOOL_TIMEOUT', 900000)),
 };
 
 // Default max thinking budget for Claude Code (see issue #1146)
@@ -156,8 +165,18 @@ export const supportsThinkingBudget = (version, minVersion = '2.1.12') => {
 
 // Helper function to get Claude CLI environment with CLAUDE_CODE_MAX_OUTPUT_TOKENS set
 // Optionally sets MAX_THINKING_TOKENS when thinkingBudget is provided (see issue #1146)
+// Also sets MCP_TIMEOUT and MCP_TOOL_TIMEOUT for MCP tool execution (see issue #1066)
 export const getClaudeEnv = (options = {}) => {
-  const env = { ...process.env, CLAUDE_CODE_MAX_OUTPUT_TOKENS: String(claudeCode.maxOutputTokens) };
+  const env = {
+    ...process.env,
+    CLAUDE_CODE_MAX_OUTPUT_TOKENS: String(claudeCode.maxOutputTokens),
+    // MCP timeout configurations to prevent tool calls from hanging indefinitely
+    // See: https://github.com/link-assistant/hive-mind/issues/1066
+    // MCP_TIMEOUT: Timeout for MCP server startup
+    // MCP_TOOL_TIMEOUT: Timeout for MCP tool execution (the one that prevents stuck tools)
+    MCP_TIMEOUT: String(claudeCode.mcpTimeout),
+    MCP_TOOL_TIMEOUT: String(claudeCode.mcpToolTimeout),
+  };
   // Set MAX_THINKING_TOKENS if thinkingBudget is provided
   // This controls Claude Code's extended thinking feature (Claude Code >= 2.1.12)
   // Default is 31999, set to 0 to disable thinking, max is 63999 for 64K output models

package/src/telegram-solve-queue.lib.mjs

@@ -34,16 +34,16 @@ import { getCachedClaudeLimits, getCachedGitHubLimits, getCachedMemoryInfo, getC
 export const QUEUE_CONFIG = {
   // Resource thresholds (usage ratios: 0.0 - 1.0)
   // All thresholds use >= comparison (inclusive)
-  RAM_THRESHOLD: 0.65, // Stop if RAM usage >= 65%
+  RAM_THRESHOLD: 0.65, // Enqueue if RAM usage >= 65%
   // CPU threshold uses 5-minute load average, not instantaneous CPU usage
-  CPU_THRESHOLD: 0.75, // Stop if 5-minute load average >= 75% of CPU count
-  DISK_THRESHOLD: 0.95, // One-at-a-time if disk usage >= 95%
+  CPU_THRESHOLD: 0.65, // Enqueue if 5-minute load average >= 65% of CPU count
+  DISK_THRESHOLD: 0.9, // One-at-a-time if disk usage >= 90%
 
   // API limit thresholds (usage ratios: 0.0 - 1.0)
   // All thresholds use >= comparison (inclusive)
-  CLAUDE_5_HOUR_SESSION_THRESHOLD: 0.85, // Stop if 5-hour limit >= 85%
+  CLAUDE_5_HOUR_SESSION_THRESHOLD: 0.85, // One-at-a-time if 5-hour limit >= 85%
   CLAUDE_WEEKLY_THRESHOLD: 0.98, // One-at-a-time if weekly limit >= 98%
-  GITHUB_API_THRESHOLD: 0.8, // Stop if GitHub >= 80% with parallel claude
+  GITHUB_API_THRESHOLD: 0.8, // Enqueue if GitHub >= 80% with parallel claude
 
   // Timing
   // MIN_START_INTERVAL_MS: Time to allow solve command to start actual claude process
@@ -431,11 +431,15 @@ export class SolveQueue {
       this.recordThrottle('claude_running');
     }
 
-    // Check system resources (ultimate restrictions - block unconditionally)
-    const resourceCheck = await this.checkSystemResources();
+    // Check system resources (RAM, CPU block unconditionally; disk uses one-at-a-time mode)
+    // See: https://github.com/link-assistant/hive-mind/issues/1155
+    const resourceCheck = await this.checkSystemResources(totalProcessing);
     if (!resourceCheck.ok) {
       reasons.push(...resourceCheck.reasons);
     }
+    if (resourceCheck.oneAtATime) {
+      oneAtATime = true;
+    }
 
     // Check API limits (pass hasRunningClaude and totalProcessing for uniform checking)
     const limitCheck = await this.checkApiLimits(hasRunningClaude, totalProcessing);
@@ -478,17 +482,22 @@ export class SolveQueue {
    * This provides a more stable metric that isn't affected by brief spikes
    * during claude process startup.
    *
-   * Note: System resource thresholds are ultimate restrictions - they block unconditionally
-   * when triggered. Unlike Claude API thresholds which allow one command at a time via
-   * totalProcessing check, system resources block all new commands immediately.
-   * See: https://github.com/link-assistant/hive-mind/issues/1133
+   * Resource threshold modes:
+   * - RAM_THRESHOLD: Enqueue mode - blocks all commands unconditionally
+   * - CPU_THRESHOLD: Enqueue mode - blocks all commands unconditionally
+   * - DISK_THRESHOLD: One-at-a-time mode - allows exactly one command when nothing is processing
+   *
+   * See: https://github.com/link-assistant/hive-mind/issues/1155
    *
-   * @returns {Promise<{ok: boolean, reasons: string[]}>}
+   * @param {number} totalProcessing - Total processing count (queue + external claude processes)
+   * @returns {Promise<{ok: boolean, reasons: string[], oneAtATime: boolean}>}
    */
-  async checkSystemResources() {
+  async checkSystemResources(totalProcessing = 0) {
     const reasons = [];
+    let oneAtATime = false;
 
     // Check RAM (using cached value)
+    // Enqueue mode: blocks all commands unconditionally
     const memResult = await getCachedMemoryInfo(this.verbose);
     if (memResult.success) {
       const usedRatio = memResult.memory.usedPercentage / 100;
@@ -499,6 +508,7 @@ export class SolveQueue {
     }
 
     // Check CPU using 5-minute load average (more stable than 1-minute)
+    // Enqueue mode: blocks all commands unconditionally
     // Cache TTL is 2 minutes, which is appropriate for this metric
     const cpuResult = await getCachedCpuInfo(this.verbose);
     if (cpuResult.success) {
@@ -522,22 +532,26 @@ export class SolveQueue {
     }
 
     // Check disk space (using cached value)
-    // Note: Disk threshold is an ultimate restriction - it blocks unconditionally when triggered
-    // Unlike CLAUDE_5_HOUR_SESSION_THRESHOLD and CLAUDE_WEEKLY_THRESHOLD which use totalProcessing
-    // to allow one command at a time, disk threshold blocks all new commands immediately
-    // See: https://github.com/link-assistant/hive-mind/issues/1133
+    // One-at-a-time mode: allows exactly one command when nothing is processing
+    // Unlike RAM and CPU which block unconditionally, disk uses one-at-a-time mode
+    // because we cannot predict how much disk space a task will use
+    // See: https://github.com/link-assistant/hive-mind/issues/1155
     const diskResult = await getCachedDiskInfo(this.verbose);
     if (diskResult.success) {
       // Calculate usage from free percentage
       const usedPercent = 100 - diskResult.diskSpace.freePercentage;
       const usedRatio = usedPercent / 100;
       if (usedRatio >= QUEUE_CONFIG.DISK_THRESHOLD) {
-        reasons.push(formatWaitingReason('disk', usedPercent, QUEUE_CONFIG.DISK_THRESHOLD));
+        oneAtATime = true;
         this.recordThrottle('disk_high');
+        // Only block if something is already processing (one-at-a-time mode)
+        if (totalProcessing > 0) {
+          reasons.push(formatWaitingReason('disk', usedPercent, QUEUE_CONFIG.DISK_THRESHOLD) + ' (waiting for current command)');
+        }
       }
     }
 
-    return { ok: reasons.length === 0, reasons };
+    return { ok: reasons.length === 0, reasons, oneAtATime };
   }
 
   /**