@link-assistant/hive-mind 0.54.0 → 0.54.2

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @link-assistant/hive-mind
 
+## 0.54.2
+
+### Patch Changes
+
+- c5f5194: Fix Telegram message getting stuck at "Starting solve command..."
+  - Add error handling to `executeAndUpdateMessage` function to catch Telegram API errors
+  - Fix critical bug where `messageInfo` was being cleared before the final message update
+  - Add proper error logging for message edit failures in both immediate and queued execution paths
+
+## 0.54.1
+
+### Patch Changes
+
+- 55576af: fix: allow parallel queue execution when no limits exceeded
+
+  Previously, "Claude process is already running" was treated as a blocking reason on its own, preventing parallel execution even when all system and API limits were within thresholds.
+
+  Changes:
+  - `claude_running` is now tracked as a metric, not a blocking reason
+  - Commands can run in parallel as long as actual limits are not exceeded
+  - When any limit >= threshold, allow exactly one claude command to pass
+
 ## 0.54.0
 
 ### Minor Changes

package/package.json

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

package/src/telegram-bot.mjs

@@ -673,20 +673,25 @@ function validateGitHubUrl(args, options = {}) {
  */
 async function executeAndUpdateMessage(ctx, startingMessage, commandName, args, infoBlock) {
   const result = await executeStartScreen(commandName, args);
+  const { chat, message_id } = startingMessage;
 
-  if (result.warning) {
-    await ctx.telegram.editMessageText(startingMessage.chat.id, startingMessage.message_id, undefined, `⚠️  ${result.warning}`, { parse_mode: 'Markdown' });
-    return;
-  }
+  // Safely edit message - catch errors to prevent stuck "Starting..." messages (issue #1062)
+  const safeEdit = async text => {
+    try {
+      await ctx.telegram.editMessageText(chat.id, message_id, undefined, text, { parse_mode: 'Markdown' });
+    } catch (e) {
+      console.error(`[telegram-bot] Failed to update message for ${commandName}: ${e.message}`);
+    }
+  };
+
+  if (result.warning) return safeEdit(`⚠️  ${result.warning}`);
 
   if (result.success) {
-    const sessionNameMatch = result.output.match(/session:\s*(\S+)/i) || result.output.match(/screen -r\s+(\S+)/);
-    const sessionName = sessionNameMatch ? sessionNameMatch[1] : 'unknown';
-    const response = `✅ ${commandName.charAt(0).toUpperCase() + commandName.slice(1)} command started successfully!\n\n📊 Session: \`${sessionName}\`\n\n${infoBlock}`;
-    await ctx.telegram.editMessageText(startingMessage.chat.id, startingMessage.message_id, undefined, response, { parse_mode: 'Markdown' });
+    const match = result.output.match(/session:\s*(\S+)/i) || result.output.match(/screen -r\s+(\S+)/);
+    const session = match ? match[1] : 'unknown';
+    await safeEdit(`✅ ${commandName.charAt(0).toUpperCase() + commandName.slice(1)} command started successfully!\n\n📊 Session: \`${session}\`\n\n${infoBlock}`);
   } else {
-    const response = `❌ Error executing ${commandName} command:\n\n\`\`\`\n${result.error || result.output}\n\`\`\``;
-    await ctx.telegram.editMessageText(startingMessage.chat.id, startingMessage.message_id, undefined, response, { parse_mode: 'Markdown' });
+    await safeEdit(`❌ Error executing ${commandName} command:\n\n\`\`\`\n${result.error || result.output}\n\`\`\``);
   }
 }
 

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

@@ -357,6 +357,12 @@ export class SolveQueue {
 
   /**
    * Check if a new command can start
+   *
+   * Logic per issue #1061:
+   * 1. "Claude process is already running" is NOT a limit by itself - it's a metric
+   * 2. Commands can run in parallel as long as actual limits are not exceeded
+   * 3. When any limit >= threshold, allow exactly one claude command to pass
+   *
    * @returns {Promise<{canStart: boolean, reason?: string, reasons?: string[], oneAtATime?: boolean}>}
    */
   async canStartCommand() {
@@ -373,10 +379,12 @@ export class SolveQueue {
       }
     }
 
-    // Check running claude processes
+    // Check running claude processes (this is a metric, not a blocking reason by itself)
     const claudeProcs = await getRunningClaudeProcesses(this.verbose);
-    if (claudeProcs.count > 0) {
-      reasons.push(formatWaitingReason('claude_running', claudeProcs.count, 0) + ` (${claudeProcs.count} processes)`);
+    const hasRunningClaude = claudeProcs.count > 0;
+
+    // Track claude_running as a metric (but don't add to reasons yet)
+    if (hasRunningClaude) {
       this.recordThrottle('claude_running');
     }
 
@@ -389,8 +397,8 @@ export class SolveQueue {
       oneAtATime = true;
     }
 
-    // Check API limits
-    const limitCheck = await this.checkApiLimits(claudeProcs.count > 0);
+    // Check API limits (pass hasRunningClaude to enable special handling)
+    const limitCheck = await this.checkApiLimits(hasRunningClaude);
     if (!limitCheck.ok) {
       reasons.push(...limitCheck.reasons);
     }
@@ -398,6 +406,13 @@ export class SolveQueue {
       oneAtATime = true;
     }
 
+    // "Claude process running" only blocks if there are OTHER reasons too
+    // This allows parallel execution when limits are not exceeded
+    if (hasRunningClaude && reasons.length > 0) {
+      // Add claude_running info only when combined with actual limit reasons
+      reasons.unshift(formatWaitingReason('claude_running', claudeProcs.count, 0) + ` (${claudeProcs.count} processes)`);
+    }
+
     const canStart = reasons.length === 0;
 
     if (!canStart && this.verbose) {
@@ -461,6 +476,12 @@ export class SolveQueue {
 
   /**
    * Check API limits (Claude, GitHub) using cached values
+   *
+   * Simplified logic per issue #1061:
+   * - When any limit >= threshold, allow exactly one claude command to pass
+   * - Only block if there's already a command in progress
+   * - Running claude is the ultimate test of whether limits are really exhausted
+   *
    * @param {boolean} hasRunningClaude - Whether claude processes are running
    * @returns {Promise<{ok: boolean, reasons: string[], oneAtATime: boolean}>}
    */
@@ -475,29 +496,26 @@ export class SolveQueue {
       const weeklyPercent = claudeResult.usage.allModels.percentage;
 
       // Session limit (5-hour)
+      // When above threshold: allow exactly one command, block if one is running
       if (sessionPercent !== null) {
         const sessionRatio = sessionPercent / 100;
-        if (sessionRatio >= 1.0) {
-          reasons.push('Claude session limit is 100% (waiting for reset)');
-          this.recordThrottle('claude_session_100');
-        } else if (sessionRatio >= QUEUE_CONFIG.CLAUDE_SESSION_THRESHOLD) {
-          reasons.push(formatWaitingReason('claude_session', sessionPercent, QUEUE_CONFIG.CLAUDE_SESSION_THRESHOLD));
-          this.recordThrottle('claude_session_high');
+        if (sessionRatio >= QUEUE_CONFIG.CLAUDE_SESSION_THRESHOLD) {
+          // Only block if Claude is already running
+          if (hasRunningClaude) {
+            reasons.push(formatWaitingReason('claude_session', sessionPercent, QUEUE_CONFIG.CLAUDE_SESSION_THRESHOLD));
+          }
+          this.recordThrottle(sessionRatio >= 1.0 ? 'claude_session_100' : 'claude_session_high');
         }
       }
 
       // Weekly limit
+      // When above threshold: allow exactly one command, block if one is in progress
       if (weeklyPercent !== null) {
         const weeklyRatio = weeklyPercent / 100;
-        if (weeklyRatio >= 1.0) {
+        if (weeklyRatio >= QUEUE_CONFIG.CLAUDE_WEEKLY_THRESHOLD) {
           oneAtATime = true;
-          this.recordThrottle('claude_weekly_100');
-          if (this.processing.size > 0) {
-            reasons.push('Claude weekly limit is 100% (waiting for current command)');
-          }
-        } else if (weeklyRatio >= QUEUE_CONFIG.CLAUDE_WEEKLY_THRESHOLD) {
-          oneAtATime = true;
-          this.recordThrottle('claude_weekly_high');
+          this.recordThrottle(weeklyRatio >= 1.0 ? 'claude_weekly_100' : 'claude_weekly_high');
+          // Only block if command is already in progress
           if (this.processing.size > 0) {
             reasons.push(formatWaitingReason('claude_weekly', weeklyPercent, QUEUE_CONFIG.CLAUDE_WEEKLY_THRESHOLD) + ' (waiting for current command)');
           }
@@ -511,12 +529,9 @@ export class SolveQueue {
       if (githubResult.success) {
         const usedPercent = githubResult.githubRateLimit.usedPercentage;
         const usedRatio = usedPercent / 100;
-        if (usedRatio >= 1.0) {
-          reasons.push('GitHub API limit is 100% (waiting for reset)');
-          this.recordThrottle('github_100');
-        } else if (usedRatio >= QUEUE_CONFIG.GITHUB_API_THRESHOLD) {
+        if (usedRatio >= QUEUE_CONFIG.GITHUB_API_THRESHOLD) {
           reasons.push(formatWaitingReason('github', usedPercent, QUEUE_CONFIG.GITHUB_API_THRESHOLD));
-          this.recordThrottle('github_high');
+          this.recordThrottle(usedRatio >= 1.0 ? 'github_100' : 'github_high');
         }
       }
     }
@@ -652,13 +667,18 @@ export class SolveQueue {
           if (sessionMatch) sessionName = sessionMatch[1];
         }
 
+        // IMPORTANT: Save messageInfo BEFORE calling setStarted, because setStarted clears it
+        // This was a bug where the final message update never happened because messageInfo was null
+        // See: https://github.com/link-assistant/hive-mind/issues/1062
+        const savedMessageInfo = item.messageInfo;
+
         // Update to Started status (terminal - forgets message tracking)
         item.setStarted(sessionName);
         this.stats.totalCompleted++;
 
-        // Final message update before forgetting
-        if (item.ctx && result) {
-          const { chatId, messageId } = item.messageInfo || {};
+        // Final message update using saved messageInfo
+        if (item.ctx && result && savedMessageInfo) {
+          const { chatId, messageId } = savedMessageInfo;
           if (chatId && messageId) {
             try {
               if (result.warning) {
@@ -670,8 +690,10 @@ export class SolveQueue {
                 const response = `❌ Error executing solve command:\n\n\`\`\`\n${result.error || result.output}\n\`\`\``;
                 await item.ctx.telegram.editMessageText(chatId, messageId, undefined, response, { parse_mode: 'Markdown' });
               }
-            } catch {
-              // Ignore message edit failures
+            } catch (error) {
+              // Log message edit failures for debugging
+              // See: https://github.com/link-assistant/hive-mind/issues/1062
+              console.error(`[solve-queue] Failed to update message for item ${item.id}: ${error.message}`);
             }
           }
         }
@@ -689,8 +711,10 @@ export class SolveQueue {
       if (chatId && messageId && item.ctx) {
         try {
           await item.ctx.telegram.editMessageText(chatId, messageId, undefined, `❌ Error: ${error.message}`, { parse_mode: 'Markdown' });
-        } catch {
-          // Ignore
+        } catch (editError) {
+          // Log the edit failure for debugging
+          // See: https://github.com/link-assistant/hive-mind/issues/1062
+          console.error(`[solve-queue] Failed to update error message for item ${item.id}: ${editError.message}`);
         }
       }
     } finally {