@link-assistant/hive-mind 1.0.3 → 1.0.5

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # @link-assistant/hive-mind
 
+## 1.0.5
+
+### Patch Changes
+
+- a68a9f2: fix(queue): simplify queue logic based on PR feedback
+  - **Use 5-minute load average for CPU**: Uses `loadAvg5` instead of instantaneous CPU usage,
+    providing a more stable metric not affected by transient spikes during claude startup.
+    Cache TTL is 2 minutes.
+  - **Keep RAM threshold with caching**: RAM_THRESHOLD (50%) is still checked but uses cached
+    values only (no uncached rechecks) to simplify the logic.
+  - **Increase MIN_START_INTERVAL_MS to 2 minutes**: Allows enough time for solve command to
+    start actual claude process, ensuring running processes are counted when API limits are checked.
+  - **Increase CONSUMER_POLL_INTERVAL_MS to 1 minute**: Reduces unnecessary system checks.
+    One-minute polling is sufficient for queue management.
+  - **Running processes not a blocking limit**: Commands can run in parallel as long as actual
+    limits (CPU, API, etc.) are not exceeded. Claude process info is only supplementary.
+
+  Fixes #1078
+
+## 1.0.4
+
+### Patch Changes
+
+- 4e5e1ab: Use gh-upload-log for log file uploads (issue #587)
+  - Replace custom gist creation with gh-upload-log command
+  - Implement smart linking: 1 chunk = direct raw link, >1 chunks = repo link
+  - Update case study documentation with gh-upload-log v0.5.0 fixes
+  - Remove custom log compression in favor of gh-upload-log auto mode
+
 ## 1.0.3
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",
@@ -13,7 +13,8 @@
     "hive-telegram-bot": "./src/telegram-bot.mjs"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "node tests/solve-queue.test.mjs",
+    "test:queue": "node tests/solve-queue.test.mjs",
     "lint": "eslint 'src/**/*.{js,mjs,cjs}'",
     "lint:fix": "eslint 'src/**/*.{js,mjs,cjs}' --fix",
     "format": "prettier --write \"**/*.{js,mjs,json,md}\"",

package/src/github.lib.mjs

@@ -16,6 +16,8 @@ import { reportError } from './sentry.lib.mjs';
 import { githubLimits, timeouts } from './config.lib.mjs';
 // Import batch operations from separate module
 import { batchCheckPullRequestsForIssues as batchCheckPRs, batchCheckArchivedRepositories as batchCheckArchived } from './github.batch.lib.mjs';
+// Import log upload function from separate module
+import { uploadLogWithGhUploadLog } from './log-upload.lib.mjs';
 
 /**
  * Build cost estimation string for log comments
@@ -55,6 +57,7 @@ const buildCostInfoString = (totalCostUSD, anthropicTotalCostUSD, pricingInfo) =
   }
   return costInfo;
 };
+
 // Helper function to mask GitHub tokens (alias for backward compatibility)
 export const maskGitHubToken = maskToken;
 // Helper function to get GitHub tokens from local config files
@@ -649,7 +652,7 @@ ${logContent}
     let commentResult;
     if (logComment.length > githubLimits.commentMaxSize) {
       await log(`  ⚠️  Log comment too long (${logComment.length} chars), GitHub limit is ${githubLimits.commentMaxSize} chars`);
-      await log('  📎 Uploading log as GitHub Gist instead...');
+      await log('  📎 Uploading log using gh-upload-log...');
       try {
         // Check if repository is public or private
         let isPublicRepo = true;
@@ -670,49 +673,36 @@ ${logContent}
             repo,
           });
           // Default to public if we can't determine visibility
-          await log('  ⚠️  Could not determine repository visibility, defaulting to public gist', { verbose: true });
+          await log('  ⚠️  Could not determine repository visibility, defaulting to public', { verbose: true });
         }
-        // Create gist with appropriate visibility
-        // Note: Gists don't need escaping because they are uploaded as plain text files
+        // Create temp log file with sanitized content (no compression, just gh-upload-log)
         const tempLogFile = `/tmp/solution-draft-log-${targetType}-${Date.now()}.txt`;
-        // Use the original sanitized content (before escaping) for gist since it's a text file
+        // Use the original sanitized content for upload since it's a plain text file
         await fs.writeFile(tempLogFile, await sanitizeLogContent(rawLogContent));
-        const gistCommand = isPublicRepo ? `gh gist create "${tempLogFile}" --public --desc "Solution draft log for https://github.com/${owner}/${repo}/${targetType === 'pr' ? 'pull' : 'issues'}/${targetNumber}" --filename "solution-draft-log.txt"` : `gh gist create "${tempLogFile}" --desc "Solution draft log for https://github.com/${owner}/${repo}/${targetType === 'pr' ? 'pull' : 'issues'}/${targetNumber}" --filename "solution-draft-log.txt"`;
-        if (verbose) {
-          await log(`  🔐 Creating ${isPublicRepo ? 'public' : 'private'} gist...`, { verbose: true });
-        }
-        const gistResult = await $(gistCommand);
+
+        // Use gh-upload-log to upload the log file
+        const uploadDescription = `Solution draft log for https://github.com/${owner}/${repo}/${targetType === 'pr' ? 'pull' : 'issues'}/${targetNumber}`;
+        const uploadResult = await uploadLogWithGhUploadLog({
+          logFile: tempLogFile,
+          isPublic: isPublicRepo,
+          description: uploadDescription,
+          verbose,
+        });
         await fs.unlink(tempLogFile).catch(() => {});
-        if (gistResult.code === 0) {
-          const gistPageUrl = gistResult.stdout.toString().trim();
-          // Extract gist ID from URL
-          const gistId = gistPageUrl.split('/').pop();
-          // Construct raw file URL
-          // Format: https://gist.githubusercontent.com/{owner}/{gist_id}/raw/{commit_sha}/{filename}
-          // We use gh api to get the gist details for owner and commit SHA
-          let gistUrl = gistPageUrl; // fallback to page URL if we can't get raw URL
-
-          const gistDetailsResult = await $`gh api gists/${gistId} --jq '{owner: .owner.login, files: .files, history: .history}'`;
-          if (gistDetailsResult.code === 0) {
-            const gistDetails = JSON.parse(gistDetailsResult.stdout.toString());
-            const commitSha = gistDetails.history && gistDetails.history[0] ? gistDetails.history[0].version : null;
-            // Get the actual filename from the gist API response (--filename flag only works with stdin)
-            const fileNames = gistDetails.files ? Object.keys(gistDetails.files) : [];
-            const fileName = fileNames.length > 0 ? fileNames[0] : 'solution-draft-log.txt';
-
-            if (commitSha) {
-              gistUrl = `https://gist.githubusercontent.com/${gistDetails.owner}/${gistId}/raw/${commitSha}/${fileName}`;
-            } else {
-              // Fallback: use simpler format without commit SHA (GitHub will redirect to latest)
-              gistUrl = `https://gist.githubusercontent.com/${gistDetails.owner}/${gistId}/raw/${fileName}`;
-            }
-          }
-          // Create comment with gist link
-          let gistComment;
+
+        if (uploadResult.success) {
+          // Use rawUrl for direct file access (single chunk) or url for repository (multiple chunks)
+          // Requirements: 1 chunk = direct raw link, >1 chunks = repo link
+          const logUrl = uploadResult.chunks === 1 ? uploadResult.rawUrl : uploadResult.url;
+          const uploadTypeLabel = uploadResult.type === 'gist' ? 'Gist' : 'Repository';
+          const chunkInfo = uploadResult.chunks > 1 ? ` (${uploadResult.chunks} chunks)` : '';
+
+          // Create comment with log link
+          let logUploadComment;
           // For usage limit cases, always use the dedicated format regardless of errorMessage
           if (isUsageLimit) {
-            // Usage limit error gist format
-            gistComment = `## ⏳ Usage Limit Reached
+            // Usage limit error format
+            logUploadComment = `## ⏳ Usage Limit Reached
 
 The automated solution draft was interrupted because the ${toolName} usage limit was reached.
 
@@ -721,86 +711,86 @@ The automated solution draft was interrupted because the ${toolName} usage limit
 - **Limit Type**: Usage limit exceeded`;
 
             if (limitResetTime) {
-              gistComment += `\n- **Reset Time**: ${limitResetTime}`;
+              logUploadComment += `\n- **Reset Time**: ${limitResetTime}`;
             }
 
             if (sessionId) {
-              gistComment += `\n- **Session ID**: ${sessionId}`;
+              logUploadComment += `\n- **Session ID**: ${sessionId}`;
             }
 
-            gistComment += '\n\n### 🔄 How to Continue\n';
+            logUploadComment += '\n\n### 🔄 How to Continue\n';
 
             if (limitResetTime) {
-              gistComment += `Once the limit resets at **${limitResetTime}**, `;
+              logUploadComment += `Once the limit resets at **${limitResetTime}**, `;
             } else {
-              gistComment += 'Once the limit resets, ';
+              logUploadComment += 'Once the limit resets, ';
             }
 
             if (resumeCommand) {
-              gistComment += `you can resume this session by running:
+              logUploadComment += `you can resume this session by running:
 \`\`\`bash
 ${resumeCommand}
 \`\`\``;
             } else if (sessionId) {
-              gistComment += `you can resume this session using session ID: \`${sessionId}\``;
+              logUploadComment += `you can resume this session using session ID: \`${sessionId}\``;
             } else {
-              gistComment += 'you can retry the operation.';
+              logUploadComment += 'you can retry the operation.';
             }
 
-            gistComment += `
+            logUploadComment += `
 
-📎 **Execution log uploaded as GitHub Gist** (${Math.round(logStats.size / 1024)}KB)
-🔗 [View complete execution log](${gistUrl})
+📎 **Execution log uploaded as ${uploadTypeLabel}${chunkInfo}** (${Math.round(logStats.size / 1024)}KB)
+🔗 [View complete execution log](${logUrl})
 
 ---
 *This session was interrupted due to usage limits. You can resume once the limit resets.*`;
           } else if (errorMessage) {
-            // Failure log gist format (non-usage-limit errors)
-            gistComment = `## 🚨 Solution Draft Failed
+            // Failure log format (non-usage-limit errors)
+            logUploadComment = `## 🚨 Solution Draft Failed
 The automated solution draft encountered an error:
 \`\`\`
 ${errorMessage}
 \`\`\`
-📎 **Failure log uploaded as GitHub Gist** (${Math.round(logStats.size / 1024)}KB)
-🔗 [View complete failure log](${gistUrl})
+📎 **Failure log uploaded as ${uploadTypeLabel}${chunkInfo}** (${Math.round(logStats.size / 1024)}KB)
+🔗 [View complete failure log](${logUrl})
 ---
 *Now working session is ended, feel free to review and add any feedback on the solution draft.*`;
           } else {
-            // Success log gist format - use helper function for cost info
+            // Success log format - use helper function for cost info
             const costInfo = buildCostInfoString(totalCostUSD, anthropicTotalCostUSD, pricingInfo);
-            gistComment = `## ${customTitle}
+            logUploadComment = `## ${customTitle}
 This log file contains the complete execution trace of the AI ${targetType === 'pr' ? 'solution draft' : 'analysis'} process.${costInfo}
-📎 **Log file uploaded as GitHub Gist** (${Math.round(logStats.size / 1024)}KB)
-🔗 [View complete solution draft log](${gistUrl})
+📎 **Log file uploaded as ${uploadTypeLabel}${chunkInfo}** (${Math.round(logStats.size / 1024)}KB)
+🔗 [View complete solution draft log](${logUrl})
 ---
 *Now working session is ended, feel free to review and add any feedback on the solution draft.*`;
           }
-          const tempGistCommentFile = `/tmp/log-gist-comment-${targetType}-${Date.now()}.md`;
-          await fs.writeFile(tempGistCommentFile, gistComment);
-          commentResult = await $`gh ${ghCommand} comment ${targetNumber} --repo ${owner}/${repo} --body-file "${tempGistCommentFile}"`;
-          await fs.unlink(tempGistCommentFile).catch(() => {});
+          const tempCommentFile = `/tmp/log-upload-comment-${targetType}-${Date.now()}.md`;
+          await fs.writeFile(tempCommentFile, logUploadComment);
+          commentResult = await $`gh ${ghCommand} comment ${targetNumber} --repo ${owner}/${repo} --body-file "${tempCommentFile}"`;
+          await fs.unlink(tempCommentFile).catch(() => {});
           if (commentResult.code === 0) {
-            await log(`  ✅ Solution draft log uploaded to ${targetName} as ${isPublicRepo ? 'public' : 'private'} Gist`);
-            await log(`  🔗 Gist URL: ${gistUrl}`);
+            await log(`  ✅ Solution draft log uploaded to ${targetName} as ${isPublicRepo ? 'public' : 'private'} ${uploadTypeLabel}${chunkInfo}`);
+            await log(`  🔗 Log URL: ${logUrl}`);
             await log(`  📊 Log size: ${Math.round(logStats.size / 1024)}KB`);
             return true;
           } else {
-            await log(`  ❌ Failed to upload comment with gist link: ${commentResult.stderr ? commentResult.stderr.toString().trim() : 'unknown error'}`);
+            await log(`  ❌ Failed to post comment with log link: ${commentResult.stderr ? commentResult.stderr.toString().trim() : 'unknown error'}`);
             return false;
           }
         } else {
-          await log(`  ❌ Failed to create gist: ${gistResult.stderr ? gistResult.stderr.toString().trim() : 'unknown error'}`);
+          await log('  ❌ gh-upload-log failed');
 
           // Fallback to truncated comment
           await log('  🔄 Falling back to truncated comment...');
           return await attachTruncatedLog(options);
         }
-      } catch (gistError) {
-        reportError(gistError, {
-          context: 'create_gist',
+      } catch (uploadError) {
+        reportError(uploadError, {
+          context: 'upload_log_gh_upload_log',
           level: 'error',
         });
-        await log(`  ❌ Error creating gist: ${gistError.message}`);
+        await log(`  ❌ Error uploading log: ${uploadError.message}`);
         // Try regular comment as last resort
         return await attachRegularComment(options, logComment);
       }
@@ -1471,6 +1461,8 @@ export async function detectRepositoryVisibility(owner, repo) {
 }
 // Re-export batch archived check from separate module
 export const batchCheckArchivedRepositories = batchCheckArchived;
+// Re-export log upload function from separate module
+export { uploadLogWithGhUploadLog } from './log-upload.lib.mjs';
 // Export all functions as default object too
 export default {
   maskGitHubToken,
@@ -1482,6 +1474,7 @@ export default {
   checkGitHubPermissions,
   checkRepositoryWritePermission,
   attachLogToGitHub,
+  uploadLogWithGhUploadLog,
   fetchAllIssuesWithPagination,
   fetchProjectIssues,
   isRateLimitError,

package/src/log-upload.lib.mjs

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+
+// Log upload module for hive-mind
+// Uses gh-upload-log for uploading log files to GitHub
+
+// Use use-m to dynamically import modules for cross-runtime compatibility
+if (typeof globalThis.use === 'undefined') {
+  globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
+}
+const use = globalThis.use;
+
+// Use command-stream for consistent $ behavior across runtimes
+const { $ } = await use('command-stream');
+
+// Import shared library functions
+const lib = await import('./lib.mjs');
+const { log } = lib;
+
+// Import Sentry integration
+const sentryLib = await import('./sentry.lib.mjs');
+const { reportError } = sentryLib;
+
+/**
+ * Upload a log file using gh-upload-log command
+ * @param {Object} options - Upload options
+ * @param {string} options.logFile - Path to the log file to upload
+ * @param {boolean} options.isPublic - Whether to make the upload public
+ * @param {string} options.description - Description for the upload
+ * @param {boolean} [options.verbose=false] - Enable verbose logging
+ * @returns {Promise<{success: boolean, url: string|null, rawUrl: string|null, type: 'gist'|'repository'|null, chunks: number}>}
+ */
+export const uploadLogWithGhUploadLog = async ({ logFile, isPublic, description, verbose = false }) => {
+  const result = { success: false, url: null, rawUrl: null, type: null, chunks: 1 };
+
+  try {
+    // Build command with appropriate flags
+    const publicFlag = isPublic ? '--public' : '--private';
+    const descFlag = description ? `--description "${description}"` : '';
+    const verboseFlag = verbose ? '--verbose' : '';
+
+    const command = `gh-upload-log "${logFile}" ${publicFlag} ${descFlag} ${verboseFlag}`.trim().replace(/\s+/g, ' ');
+
+    if (verbose) {
+      await log(`  📤 Running: ${command}`, { verbose: true });
+    }
+
+    const uploadResult = await $`gh-upload-log "${logFile}" ${publicFlag} ${verbose ? '--verbose' : ''}`;
+    const output = (uploadResult.stdout?.toString() || '') + (uploadResult.stderr?.toString() || '');
+
+    if (uploadResult.code !== 0) {
+      await log(`  ❌ gh-upload-log failed: ${output}`);
+      return result;
+    }
+
+    // Parse output to extract URL and type
+    // Look for the URL line: 🔗 https://...
+    const urlMatch = output.match(/🔗\s+(https:\/\/[^\s\n]+)/);
+    if (urlMatch) {
+      result.url = urlMatch[1].trim();
+    }
+
+    // Determine type from output
+    if (output.includes('Type: 📝 Gist') || result.url?.includes('gist.github.com')) {
+      result.type = 'gist';
+    } else if (output.includes('Type: 📦 Repository') || (result.url?.includes('github.com') && !result.url?.includes('gist'))) {
+      result.type = 'repository';
+    }
+
+    // Extract chunk count if mentioned
+    const chunkMatch = output.match(/split into (\d+) chunks/i);
+    if (chunkMatch) {
+      result.chunks = parseInt(chunkMatch[1], 10);
+    }
+
+    // Construct raw URL based on type and chunks
+    if (result.url) {
+      result.success = true;
+
+      if (result.type === 'gist') {
+        // For gist: get raw URL from gist API
+        const gistId = result.url.split('/').pop();
+        try {
+          const gistDetailsResult = await $`gh api gists/${gistId} --jq '{owner: .owner.login, files: .files, history: .history}'`;
+          if (gistDetailsResult.code === 0) {
+            const gistDetails = JSON.parse(gistDetailsResult.stdout.toString());
+            const gistOwner = gistDetails.owner;
+            const commitSha = gistDetails.history?.[0]?.version;
+            const fileNames = gistDetails.files ? Object.keys(gistDetails.files) : [];
+            const fileName = fileNames.length > 0 ? fileNames[0] : 'log.txt';
+
+            if (commitSha) {
+              result.rawUrl = `https://gist.githubusercontent.com/${gistOwner}/${gistId}/raw/${commitSha}/${fileName}`;
+            } else {
+              result.rawUrl = `https://gist.githubusercontent.com/${gistOwner}/${gistId}/raw/${fileName}`;
+            }
+          }
+        } catch (apiError) {
+          if (verbose) {
+            await log(`  ⚠️  Could not get gist raw URL: ${apiError.message}`, { verbose: true });
+          }
+          // Use page URL as fallback
+          result.rawUrl = result.url;
+        }
+      } else if (result.type === 'repository') {
+        if (result.chunks === 1) {
+          // For single chunk repository: construct raw URL to the file
+          // Repository URL format: https://github.com/owner/repo
+          // We need to find the actual file name in the repo
+          try {
+            const repoUrl = result.url;
+            const repoPath = repoUrl.replace('https://github.com/', '');
+            const contentsResult = await $`gh api repos/${repoPath}/contents --jq '.[].name'`;
+            if (contentsResult.code === 0) {
+              const files = contentsResult.stdout
+                .toString()
+                .trim()
+                .split('\n')
+                .filter(f => f && !f.startsWith('.'));
+              if (files.length > 0) {
+                const fileName = files[0];
+                result.rawUrl = `${repoUrl}/raw/main/${fileName}`;
+              }
+            }
+          } catch (apiError) {
+            if (verbose) {
+              await log(`  ⚠️  Could not get repo file raw URL: ${apiError.message}`, { verbose: true });
+            }
+            // For single chunk, try common pattern
+            result.rawUrl = result.url;
+          }
+        } else {
+          // For multiple chunks: link to repository itself (not raw)
+          result.rawUrl = result.url;
+        }
+      }
+    }
+
+    if (verbose) {
+      await log(`  ✅ Upload successful: ${result.url}`, { verbose: true });
+      await log(`  📊 Type: ${result.type}, Chunks: ${result.chunks}`, { verbose: true });
+      if (result.rawUrl !== result.url) {
+        await log(`  🔗 Raw URL: ${result.rawUrl}`, { verbose: true });
+      }
+    }
+
+    return result;
+  } catch (error) {
+    reportError(error, {
+      context: 'upload_log_with_gh_upload_log',
+      logFile,
+      operation: 'gh_upload_log_command',
+    });
+    await log(`  ❌ Error running gh-upload-log: ${error.message}`);
+    return result;
+  }
+};
+
+// Export all functions as default object too
+export default {
+  uploadLogWithGhUploadLog,
+};

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

@@ -26,11 +26,16 @@ import { getCachedClaudeLimits, getCachedGitHubLimits, getCachedMemoryInfo, getC
 /**
  * Configuration constants for queue throttling
  * All thresholds use ratios (0.0 - 1.0) representing usage percentage
+ *
+ * IMPORTANT: Running claude processes is NOT a blocking limit by itself.
+ * Commands can run in parallel as long as actual limits (CPU, API, etc.) are not exceeded.
+ * See: https://github.com/link-assistant/hive-mind/issues/1078
  */
 export const QUEUE_CONFIG = {
   // Resource thresholds (usage ratios: 0.0 - 1.0)
   RAM_THRESHOLD: 0.5, // Stop if RAM usage > 50%
-  CPU_THRESHOLD: 0.5, // Stop if CPU usage > 50%
+  // CPU threshold uses 5-minute load average, not instantaneous CPU usage
+  CPU_THRESHOLD: 0.5, // Stop if 5-minute load average > 50% of CPU count
   DISK_THRESHOLD: 0.95, // One-at-a-time if disk usage > 95%
 
   // API limit thresholds (usage ratios: 0.0 - 1.0)
@@ -39,8 +44,11 @@ export const QUEUE_CONFIG = {
   GITHUB_API_THRESHOLD: 0.8, // Stop if GitHub > 80% with parallel claude
 
   // Timing
-  MIN_START_INTERVAL_MS: 60000, // 1 minute between starts
-  CONSUMER_POLL_INTERVAL_MS: 5000, // 5 seconds between queue checks
+  // MIN_START_INTERVAL_MS: Time to allow solve command to start actual claude process
+  // This ensures that when API limits are checked, the running process is counted
+  MIN_START_INTERVAL_MS: 120000, // 2 minutes between starts (was 1 minute)
+  CONSUMER_POLL_INTERVAL_MS: 60000, // 1 minute between queue checks (was 5 seconds)
+  MESSAGE_UPDATE_INTERVAL_MS: 60000, // 1 minute between status message updates
 
   // Process detection
   CLAUDE_PROCESS_NAMES: ['claude'], // Process names to detect
@@ -163,6 +171,9 @@ class SolveQueueItem {
     this.sessionName = null;
     // Message tracking - forget after STARTED
     this.messageInfo = null; // { chatId, messageId }
+    // Track when we last updated the Telegram message
+    // See: https://github.com/link-assistant/hive-mind/issues/1078
+    this.lastMessageUpdateTime = null;
   }
 
   /**
@@ -409,8 +420,10 @@ export class SolveQueue {
     // "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)`);
+      // Add claude_running info at the END (not beginning) of reasons
+      // Since it's supplementary info, not the primary blocking reason
+      // See: https://github.com/link-assistant/hive-mind/issues/1078
+      reasons.push(formatWaitingReason('claude_running', claudeProcs.count, 0) + ` (${claudeProcs.count} processes)`);
     }
 
     const canStart = reasons.length === 0;
@@ -430,6 +443,11 @@ export class SolveQueue {
 
   /**
    * Check system resources (RAM, CPU, disk) using cached values
+   *
+   * Uses 5-minute load average for CPU instead of instantaneous usage.
+   * This provides a more stable metric that isn't affected by brief spikes
+   * during claude process startup.
+   *
    * @returns {Promise<{ok: boolean, reasons: string[], oneAtATime: boolean}>}
    */
   async checkSystemResources() {
@@ -446,12 +464,25 @@ export class SolveQueue {
       }
     }
 
-    // Check CPU (using cached value)
+    // Check CPU using 5-minute load average (more stable than 1-minute)
+    // Cache TTL is 2 minutes, which is appropriate for this metric
     const cpuResult = await getCachedCpuInfo(this.verbose);
     if (cpuResult.success) {
-      const usedRatio = cpuResult.cpuLoad.usagePercentage / 100;
-      if (usedRatio > QUEUE_CONFIG.CPU_THRESHOLD) {
-        reasons.push(formatWaitingReason('cpu', cpuResult.cpuLoad.usagePercentage, QUEUE_CONFIG.CPU_THRESHOLD));
+      // Use loadAvg5 (5-minute average) instead of usagePercentage (1-minute based)
+      // This provides a more stable metric that isn't affected by transient spikes
+      const loadAvg5 = cpuResult.cpuLoad.loadAvg5;
+      const cpuCount = cpuResult.cpuLoad.cpuCount;
+      // Calculate usage ratio: loadAvg5 / cpuCount
+      // Load average of 1.0 per CPU = 100% utilization
+      const usageRatio = loadAvg5 / cpuCount;
+      const usagePercent = Math.min(100, Math.round(usageRatio * 100));
+
+      if (this.verbose) {
+        this.log(`CPU 5m load avg: ${loadAvg5.toFixed(2)}, cpus: ${cpuCount}, usage: ${usagePercent}%`);
+      }
+
+      if (usageRatio > QUEUE_CONFIG.CPU_THRESHOLD) {
+        reasons.push(formatWaitingReason('cpu', usagePercent, QUEUE_CONFIG.CPU_THRESHOLD));
         this.recordThrottle('cpu_high');
       }
     }
@@ -564,18 +595,33 @@ export class SolveQueue {
    * Update item message in Telegram
    * @param {SolveQueueItem} item
    * @param {string} text
+   * @param {boolean} trackUpdateTime - Whether to track this as a periodic update (default: true)
    */
-  async updateItemMessage(item, text) {
+  async updateItemMessage(item, text, trackUpdateTime = true) {
     if (!item.messageInfo || !item.ctx) return;
 
     try {
       const { chatId, messageId } = item.messageInfo;
       await item.ctx.telegram.editMessageText(chatId, messageId, undefined, text, { parse_mode: 'Markdown' });
+      if (trackUpdateTime) {
+        item.lastMessageUpdateTime = Date.now();
+      }
     } catch (error) {
       this.log(`Failed to update message: ${error.message}`);
     }
   }
 
+  /**
+   * Check if an item's message should be updated periodically
+   * @param {SolveQueueItem} item
+   * @returns {boolean}
+   */
+  shouldUpdateMessage(item) {
+    if (!item.messageInfo || !item.ctx) return false;
+    if (!item.lastMessageUpdateTime) return true; // Never updated
+    return Date.now() - item.lastMessageUpdateTime >= QUEUE_CONFIG.MESSAGE_UPDATE_INTERVAL_MS;
+  }
+
   /**
    * Consumer loop - processes items from the queue
    */
@@ -592,14 +638,20 @@ export class SolveQueue {
 
       if (!check.canStart) {
         // Update all queued items to waiting status with reason
+        // Also periodically refresh messages to show current status
+        // See: https://github.com/link-assistant/hive-mind/issues/1078
         for (const item of this.queue) {
           if (item.status === QueueItemStatus.QUEUED || item.status === QueueItemStatus.WAITING) {
             const previousStatus = item.status;
             const previousReason = item.waitingReason;
             item.setWaiting(check.reason);
 
-            // Update message if status or reason changed
-            if (previousStatus !== item.status || previousReason !== item.waitingReason) {
+            // Update message if:
+            // 1. Status or reason changed
+            // 2. OR it's time for a periodic update (every MESSAGE_UPDATE_INTERVAL_MS)
+            const shouldUpdate = previousStatus !== item.status || previousReason !== item.waitingReason || this.shouldUpdateMessage(item);
+
+            if (shouldUpdate) {
               const position = this.queue.indexOf(item) + 1;
               await this.updateItemMessage(item, `⏳ Waiting (position #${position})\n\n${item.infoBlock}\n\n*Reason:*\n${check.reason}`);
             }
@@ -622,13 +674,10 @@ export class SolveQueue {
       const item = this.queue.shift();
       if (!item) continue;
 
-      // Check if this item uses claude tool and claude is running
-      if (item.tool === 'claude' && check.claudeProcesses > 0) {
-        this.queue.unshift(item);
-        this.log(`Claude tool item queued but claude running, waiting...`);
-        await this.sleep(QUEUE_CONFIG.CONSUMER_POLL_INTERVAL_MS);
-        continue;
-      }
+      // NOTE: Running claude processes is NOT a blocking limit by itself
+      // Commands can run in parallel as long as actual limits (CPU, API, etc.) are not exceeded
+      // The MIN_START_INTERVAL_MS ensures enough time for processes to be counted
+      // See: https://github.com/link-assistant/hive-mind/issues/1078
 
       // Update status to Starting
       item.setStarting();