@link-assistant/hive-mind 1.21.2 → 1.21.4

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @link-assistant/hive-mind
 
+## 1.21.4
+
+### Patch Changes
+
+- ea19c72: Fix queue issues: rejection, display, and formatting
+  - Fix disk rejection not blocking queue placement when threshold exceeded
+  - Restore "used" label on progress bars when below threshold
+  - Show per-queue breakdown in /limits command
+  - Group queue items by tool and use human-readable time in /solve_queue
+
+- aa42f3a: fix: improve merge queue error handling and debugging (Issue #1269)
+  - Always log errors (not just in verbose mode) for critical merge queue failures
+  - Always notify users via Telegram when merge queue fails unexpectedly
+  - Add timeout wrapper (60s) for onStatusUpdate callback to prevent infinite blocking
+  - Add error handling for CI check failures in waitForCI loop
+  - Add comprehensive case study documentation in docs/case-studies/issue-1269/
+
+## 1.21.3
+
+### Patch Changes
+
+- 4426112: Fix error detection for `--tool agent` when JSON errors are pretty-printed (Issue #1258)
+  - Add fallback pattern matching for error events when NDJSON parsing fails
+  - Detect `"type": "error"` and `"type": "step_error"` patterns in raw output
+  - Detect critical error patterns like `AI_RetryError` and `UnhandledRejection`
+  - Extract error messages from output for better error reporting
+
 ## 1.21.2
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.21.2",
+  "version": "1.21.4",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",
@@ -13,7 +13,7 @@
     "hive-telegram-bot": "./src/telegram-bot.mjs"
   },
   "scripts": {
-    "test": "node tests/solve-queue.test.mjs && node tests/limits-display.test.mjs && node tests/test-usage-limit.mjs && node tests/test-telegram-message-filters.mjs && node tests/test-solve-queue-command.mjs",
+    "test": "node tests/solve-queue.test.mjs && node tests/limits-display.test.mjs && node tests/test-usage-limit.mjs && node tests/test-telegram-message-filters.mjs && node tests/test-solve-queue-command.mjs && node tests/test-queue-display-1267.mjs",
     "test:queue": "node tests/solve-queue.test.mjs",
     "test:limits-display": "node tests/limits-display.test.mjs",
     "test:usage-limit": "node tests/test-usage-limit.mjs",

package/src/agent.lib.mjs

@@ -703,6 +703,51 @@ export const executeAgentCommand = async params => {
         outputError.match = streamingErrorMessage;
       }
 
+      // Issue #1258: Fallback pattern match for error detection
+      // When JSON parsing fails (e.g., multi-line pretty-printed JSON in logs),
+      // we need to detect error patterns in the raw output string
+      if (!outputError.detected && !streamingErrorDetected) {
+        // Check for error type patterns in raw output (handles pretty-printed JSON)
+        const errorTypePatterns = [
+          { pattern: '"type": "error"', type: 'AgentError' },
+          { pattern: '"type":"error"', type: 'AgentError' },
+          { pattern: '"type": "step_error"', type: 'AgentStepError' },
+          { pattern: '"type":"step_error"', type: 'AgentStepError' },
+        ];
+
+        for (const { pattern, type } of errorTypePatterns) {
+          if (fullOutput.includes(pattern)) {
+            outputError.detected = true;
+            outputError.type = type;
+            // Try to extract the error message from the output
+            const messageMatch = fullOutput.match(/"message":\s*"([^"]+)"/);
+            outputError.match = messageMatch ? messageMatch[1] : `Error event detected in output (fallback pattern match for ${pattern})`;
+            await log(`⚠️  Error event detected via fallback pattern match: ${outputError.match}`, { level: 'warning' });
+            break;
+          }
+        }
+
+        // Also check for known critical error patterns that indicate failure
+        if (!outputError.detected) {
+          const criticalErrorPatterns = [
+            { pattern: 'AI_RetryError:', extract: /AI_RetryError:\s*(.+?)(?:\n|$)/ },
+            { pattern: 'UnhandledRejection', extract: /"errorType":\s*"UnhandledRejection"/ },
+            { pattern: 'Failed after 3 attempts', extract: /Failed after \d+ attempts[^"]*/ },
+          ];
+
+          for (const { pattern, extract } of criticalErrorPatterns) {
+            if (fullOutput.includes(pattern)) {
+              outputError.detected = true;
+              outputError.type = 'CriticalError';
+              const match = fullOutput.match(extract);
+              outputError.match = match ? match[0] : `Critical error pattern detected: ${pattern}`;
+              await log(`⚠️  Critical error pattern detected via fallback: ${outputError.match}`, { level: 'warning' });
+              break;
+            }
+          }
+        }
+      }
+
       if (exitCode !== 0 || outputError.detected) {
         // Build JSON error structure for consistent error reporting
         const errorInfo = {

package/src/github-merge.lib.mjs

@@ -485,15 +485,39 @@ export async function mergePullRequest(owner, repo, prNumber, options = {}, verb
  * @returns {Promise<{success: boolean, status: string, error: string|null}>}
  */
 export async function waitForCI(owner, repo, prNumber, options = {}, verbose = false) {
-  const { timeout = 30 * 60 * 1000, pollInterval = 30 * 1000, onStatusUpdate = null } = options;
+  const {
+    timeout = 30 * 60 * 1000,
+    pollInterval = 30 * 1000,
+    onStatusUpdate = null,
+    // Issue #1269: Add timeout for callback to prevent infinite blocking
+    callbackTimeout = 60 * 1000, // 1 minute max for callback
+  } = options;
 
   const startTime = Date.now();
 
   while (Date.now() - startTime < timeout) {
-    const ciStatus = await checkPRCIStatus(owner, repo, prNumber, verbose);
+    let ciStatus;
+    try {
+      ciStatus = await checkPRCIStatus(owner, repo, prNumber, verbose);
+    } catch (error) {
+      // Issue #1269: Log and continue on CI check errors instead of crashing
+      console.error(`[ERROR] /merge: Error checking CI status for PR #${prNumber}: ${error.message}`);
+      verbose && console.error(`[VERBOSE] /merge: CI check error details:`, error);
+      // Wait and retry
+      await new Promise(resolve => setTimeout(resolve, pollInterval));
+      continue;
+    }
 
     if (onStatusUpdate) {
-      await onStatusUpdate(ciStatus);
+      // Issue #1269: Wrap callback with timeout to prevent infinite blocking
+      try {
+        await Promise.race([onStatusUpdate(ciStatus), new Promise((_, reject) => setTimeout(() => reject(new Error(`Callback timeout after ${callbackTimeout}ms`)), callbackTimeout))]);
+      } catch (callbackError) {
+        // Issue #1269: Log callback errors but continue processing
+        console.error(`[ERROR] /merge: Status update callback failed for PR #${prNumber}: ${callbackError.message}`);
+        verbose && console.error(`[VERBOSE] /merge: Callback error details:`, callbackError);
+        // Continue processing even if callback fails - don't let UI issues block merging
+      }
     }
 
     if (ciStatus.status === 'success') {

package/src/limits.lib.mjs

@@ -714,11 +714,13 @@ export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = nu
   if (cpuLoad) {
     message += 'CPU\n';
     const usedBar = getProgressBar(cpuLoad.usagePercentage, DISPLAY_THRESHOLDS.CPU);
-    const warning = cpuLoad.usagePercentage >= DISPLAY_THRESHOLDS.CPU ? ' ⚠️' : '';
-    message += `${usedBar} ${cpuLoad.usagePercentage}%${warning}\n`;
+    // Show 'used' label when below threshold, warning emoji when at/above threshold
+    // See: https://github.com/link-assistant/hive-mind/issues/1267
+    const suffix = cpuLoad.usagePercentage >= DISPLAY_THRESHOLDS.CPU ? ' ⚠️' : ' used';
+    message += `${usedBar} ${cpuLoad.usagePercentage}%${suffix}\n`;
     // Show cores used based on 5m load average (e.g., "0.04/6 CPU cores used" or "3/6 CPU cores used")
     // Use parseFloat to strip unnecessary trailing zeros (3.00 -> 3, 0.10 -> 0.1, 0.04 -> 0.04)
-    message += `${parseFloat(cpuLoad.loadAvg5.toFixed(2))}/${cpuLoad.cpuCount} CPU cores used\n\n`;
+    message += `${parseFloat(cpuLoad.loadAvg5.toFixed(2))}/${cpuLoad.cpuCount} CPU cores\n\n`;
   }
 
   // Memory section (if provided)
@@ -726,8 +728,8 @@ export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = nu
   if (memory) {
     message += 'RAM\n';
     const usedBar = getProgressBar(memory.usedPercentage, DISPLAY_THRESHOLDS.RAM);
-    const warning = memory.usedPercentage >= DISPLAY_THRESHOLDS.RAM ? ' ⚠️' : '';
-    message += `${usedBar} ${memory.usedPercentage}%${warning}\n`;
+    const suffix = memory.usedPercentage >= DISPLAY_THRESHOLDS.RAM ? ' ⚠️' : ' used';
+    message += `${usedBar} ${memory.usedPercentage}%${suffix}\n`;
     message += `${formatBytesRange(memory.usedBytes, memory.totalBytes)}\n\n`;
   }
 
@@ -737,8 +739,8 @@ export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = nu
     message += 'Disk space\n';
     // Show used percentage with progress bar and threshold marker
     const usedBar = getProgressBar(diskSpace.usedPercentage, DISPLAY_THRESHOLDS.DISK);
-    const warning = diskSpace.usedPercentage >= DISPLAY_THRESHOLDS.DISK ? ' ⚠️' : '';
-    message += `${usedBar} ${diskSpace.usedPercentage}%${warning}\n`;
+    const suffix = diskSpace.usedPercentage >= DISPLAY_THRESHOLDS.DISK ? ' ⚠️' : ' used';
+    message += `${usedBar} ${diskSpace.usedPercentage}%${suffix}\n`;
     message += `${formatBytesRange(diskSpace.usedBytes, diskSpace.totalBytes)}\n\n`;
   }
 
@@ -748,9 +750,9 @@ export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = nu
     message += 'GitHub API\n';
     // Show used percentage with progress bar and threshold marker
     const usedBar = getProgressBar(githubRateLimit.usedPercentage, DISPLAY_THRESHOLDS.GITHUB_API);
-    const warning = githubRateLimit.usedPercentage >= DISPLAY_THRESHOLDS.GITHUB_API ? ' ⚠️' : '';
-    message += `${usedBar} ${githubRateLimit.usedPercentage}%${warning}\n`;
-    message += `${githubRateLimit.used}/${githubRateLimit.limit} requests used\n`;
+    const suffix = githubRateLimit.usedPercentage >= DISPLAY_THRESHOLDS.GITHUB_API ? ' ⚠️' : ' used';
+    message += `${usedBar} ${githubRateLimit.usedPercentage}%${suffix}\n`;
+    message += `${githubRateLimit.used}/${githubRateLimit.limit} requests\n`;
     if (githubRateLimit.relativeReset) {
       message += `Resets in ${githubRateLimit.relativeReset} (${githubRateLimit.resetTime})\n`;
     } else if (githubRateLimit.resetTime) {
@@ -775,8 +777,8 @@ export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = nu
     // See: https://github.com/link-assistant/hive-mind/issues/1133
     const pct = Math.floor(usage.currentSession.percentage);
     const bar = getProgressBar(pct, DISPLAY_THRESHOLDS.CLAUDE_5_HOUR_SESSION);
-    const warning = pct >= DISPLAY_THRESHOLDS.CLAUDE_5_HOUR_SESSION ? ' ⚠️' : '';
-    message += `${bar} ${pct}%${warning}\n`;
+    const suffix = pct >= DISPLAY_THRESHOLDS.CLAUDE_5_HOUR_SESSION ? ' ⚠️' : ' used';
+    message += `${bar} ${pct}%${suffix}\n`;
 
     if (usage.currentSession.resetTime) {
       const relativeTime = formatRelativeTime(usage.currentSession.resetsAt);
@@ -807,8 +809,8 @@ export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = nu
     // See: https://github.com/link-assistant/hive-mind/issues/1133
     const pct = Math.floor(usage.allModels.percentage);
     const bar = getProgressBar(pct, DISPLAY_THRESHOLDS.CLAUDE_WEEKLY);
-    const warning = pct >= DISPLAY_THRESHOLDS.CLAUDE_WEEKLY ? ' ⚠️' : '';
-    message += `${bar} ${pct}%${warning}\n`;
+    const suffix = pct >= DISPLAY_THRESHOLDS.CLAUDE_WEEKLY ? ' ⚠️' : ' used';
+    message += `${bar} ${pct}%${suffix}\n`;
 
     if (usage.allModels.resetTime) {
       const relativeTime = formatRelativeTime(usage.allModels.resetsAt);
@@ -839,8 +841,8 @@ export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = nu
     // See: https://github.com/link-assistant/hive-mind/issues/1133
     const pct = Math.floor(usage.sonnetOnly.percentage);
     const bar = getProgressBar(pct, DISPLAY_THRESHOLDS.CLAUDE_WEEKLY);
-    const warning = pct >= DISPLAY_THRESHOLDS.CLAUDE_WEEKLY ? ' ⚠️' : '';
-    message += `${bar} ${pct}%${warning}\n`;
+    const suffix = pct >= DISPLAY_THRESHOLDS.CLAUDE_WEEKLY ? ' ⚠️' : ' used';
+    message += `${bar} ${pct}%${suffix}\n`;
 
     if (usage.sonnetOnly.resetTime) {
       const relativeTime = formatRelativeTime(usage.sonnetOnly.resetsAt);

package/src/telegram-bot.mjs

@@ -42,7 +42,7 @@ const { validateModelName } = await import('./model-validation.lib.mjs');
 const { formatUsageMessage, getAllCachedLimits } = await import('./limits.lib.mjs');
 const { getVersionInfo, formatVersionMessage } = await import('./version-info.lib.mjs');
 const { escapeMarkdown, escapeMarkdownV2, cleanNonPrintableChars, makeSpecialCharsVisible } = await import('./telegram-markdown.lib.mjs');
-const { getSolveQueue, getRunningClaudeProcesses, createQueueExecuteCallback } = await import('./telegram-solve-queue.lib.mjs');
+const { getSolveQueue, createQueueExecuteCallback } = await import('./telegram-solve-queue.lib.mjs');
 // Import extracted message filter functions for testability (issue #1207)
 const { isOldMessage: _isOldMessage, isGroupChat: _isGroupChat, isChatAuthorized: _isChatAuthorized, isForwardedOrReply: _isForwardedOrReply, extractCommandFromText } = await import('./telegram-message-filters.lib.mjs');
 
@@ -784,16 +784,14 @@ bot.command('limits', async ctx => {
   // Format the message with usage limits and queue status
   let message = '📊 *Usage Limits*\n\n' + formatUsageMessage(limits.claude.usage, limits.disk.success ? limits.disk.diskSpace : null, limits.github.success ? limits.github.githubRateLimit : null, limits.cpu.success ? limits.cpu.cpuLoad : null, limits.memory.success ? limits.memory.memory : null);
   const solveQueue = getSolveQueue({ verbose: VERBOSE });
-  const queueStats = solveQueue.getStats();
-  const claudeProcs = await getRunningClaudeProcesses(VERBOSE);
-  // Calculate total processing: queue-internal + external claude processes
-  // This provides a uniform view of all processing happening
-  // See: https://github.com/link-assistant/hive-mind/issues/1133
-  const totalProcessing = queueStats.processing + claudeProcs.count;
+  // Insert per-queue status into the code block
+  // Shows each queue (claude, agent) with pending/processing counts
+  // Processing counts are actual running system processes (via pgrep)
+  // See: https://github.com/link-assistant/hive-mind/issues/1267
   const codeBlockEnd = message.lastIndexOf('```');
   if (codeBlockEnd !== -1) {
-    const queueStatus = queueStats.queued > 0 || totalProcessing > 0 ? `Pending: ${queueStats.queued}, Processing: ${totalProcessing}` : 'Empty (no pending commands)';
-    message = message.slice(0, codeBlockEnd) + `\nSolve Queue\n${queueStatus}\nClaude processes: ${claudeProcs.count}\n` + message.slice(codeBlockEnd);
+    const queueStatus = await solveQueue.formatStatus();
+    message = message.slice(0, codeBlockEnd) + `\n${queueStatus}` + message.slice(codeBlockEnd);
   }
   await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, message, { parse_mode: 'Markdown' });
 });
@@ -850,7 +848,6 @@ const { handleSolveQueueCommand } = registerSolveQueueCommand(bot, {
   isChatAuthorized,
   addBreadcrumb,
   getSolveQueue,
-  getRunningClaudeProcesses,
 });
 
 // Named handler for /solve command - extracted for reuse by text-based fallback (issue #1207)
@@ -1043,6 +1040,16 @@ async function handleSolveCommand(ctx) {
 
   const check = await solveQueue.canStartCommand({ tool: solveTool }); // Skip Claude limits for agent (#1159)
   const queueStats = solveQueue.getStats();
+
+  // Handle rejection: when a threshold strategy is 'reject', the command should fail immediately
+  // without being placed in the queue. This ensures users get clear feedback about why
+  // their command cannot be processed (e.g., disk full, server maintenance pending).
+  // See: https://github.com/link-assistant/hive-mind/issues/1267
+  if (check.rejected) {
+    await ctx.reply(`❌ Solve command rejected.\n\n${infoBlock}\n\n🚫 Reason: ${check.rejectReason}`, { parse_mode: 'Markdown', reply_to_message_id: ctx.message.message_id });
+    return;
+  }
+
   if (check.canStart && queueStats.queued === 0) {
     const startingMessage = await ctx.reply(`🚀 Starting solve command...\n\n${infoBlock}`, { parse_mode: 'Markdown', reply_to_message_id: ctx.message.message_id });
     await executeAndUpdateMessage(ctx, startingMessage, 'solve', args, infoBlock);

package/src/telegram-merge-command.lib.mjs

@@ -246,21 +246,31 @@ export function registerMergeCommand(bot, options) {
             await ctx.telegram.editMessageText(statusMessage.chat.id, statusMessage.message_id, undefined, message, {
               parse_mode: 'MarkdownV2',
             });
+            VERBOSE && console.log(`[VERBOSE] /merge: Merge queue completed successfully for ${repoKey}`);
           } catch (err) {
-            VERBOSE && console.log(`[VERBOSE] /merge: Error sending final message: ${err.message}`);
+            // Issue #1269: Always log completion failures (critical for debugging)
+            console.error(`[ERROR] /merge: Error sending final message for ${repoKey}: ${err.message}`);
           }
           activeMergeOperations.delete(repoKey);
         },
         onError: async error => {
-          VERBOSE && console.error(`[VERBOSE] /merge error for ${repoKey}:`, error);
+          // Issue #1269: Always log errors (not just in verbose mode)
+          console.error(`[ERROR] /merge: Queue error for ${repoKey}:`, error.message);
+          VERBOSE && console.error(`[VERBOSE] /merge: Full error:`, error);
           try {
             const userMessage = formatUserError(error, VERBOSE);
             const finalReport = processor.formatFinalMessage();
-            await ctx.telegram.editMessageText(statusMessage.chat.id, statusMessage.message_id, undefined, `❌ *Merge queue failed*\n\n${escapeMarkdownV2(userMessage)}\n\n${finalReport}`, {
+            // Issue #1269: Show error in the reply message with immediate feedback
+            // Keep a button so users know the error was displayed and can dismiss
+            await ctx.telegram.editMessageText(statusMessage.chat.id, statusMessage.message_id, undefined, `❌ *Merge queue failed*\n\n⚠️ *Error:* ${escapeMarkdownV2(userMessage)}\n\n${finalReport}`, {
               parse_mode: 'MarkdownV2',
+              reply_markup: {
+                inline_keyboard: [[{ text: '❌ Failed - Click to dismiss', callback_data: `merge_dismiss_${repoKey}` }]],
+              },
             });
           } catch (err) {
-            VERBOSE && console.log(`[VERBOSE] /merge: Error sending error message: ${err.message}`);
+            // Issue #1269: Always log notification failures
+            console.error(`[ERROR] /merge: Error sending error message for ${repoKey}: ${err.message}`);
           }
           activeMergeOperations.delete(repoKey);
         },
@@ -301,10 +311,36 @@ export function registerMergeCommand(bot, options) {
       });
 
       // Run the merge queue (this runs asynchronously)
-      processor.run().catch(error => {
-        VERBOSE && console.error(`[VERBOSE] /merge: Unhandled error in run(): ${error.message}`);
-        activeMergeOperations.delete(repoKey);
-      });
+      // Issue #1269: Improved error handling - always log errors and notify users
+      processor
+        .run()
+        .then(() => {
+          VERBOSE && console.log(`[VERBOSE] /merge: Merge queue completed for ${repoKey}`);
+        })
+        .catch(async error => {
+          // Always log errors (not just in verbose mode) - critical for debugging stuck queues
+          console.error(`[ERROR] /merge: Unhandled error in run() for ${repoKey}:`, error.message);
+          if (error.stack) {
+            console.error(`[ERROR] /merge: Stack trace: ${error.stack.split('\n').slice(0, 5).join('\n')}`);
+          }
+
+          // Always notify user about failure (Issue #1269)
+          // Show error in the reply message with immediate feedback
+          try {
+            const userMessage = formatUserError(error, VERBOSE);
+            await ctx.telegram.editMessageText(statusMessage.chat.id, statusMessage.message_id, undefined, `❌ *Merge queue failed unexpectedly*\n\n⚠️ *Error:* ${escapeMarkdownV2(userMessage)}\n\n_The queue processing has stopped\\. Please try again or check server logs\\._`, {
+              parse_mode: 'MarkdownV2',
+              reply_markup: {
+                inline_keyboard: [[{ text: '❌ Failed - Click to dismiss', callback_data: `merge_dismiss_${repoKey}` }]],
+              },
+            });
+          } catch (notifyError) {
+            // Log notification failure but don't throw
+            console.error(`[ERROR] /merge: Failed to notify user about error: ${notifyError.message}`);
+          }
+
+          activeMergeOperations.delete(repoKey);
+        });
     } catch (error) {
       VERBOSE && console.error('[VERBOSE] /merge error:', error);
 
@@ -334,6 +370,21 @@ export function registerMergeCommand(bot, options) {
 
     VERBOSE && console.log(`[VERBOSE] /merge: Cancelled operation for ${repoKey}`);
   });
+
+  // Handle dismiss button callback (Issue #1269: for error acknowledgement)
+  bot.action(/^merge_dismiss_(.+)$/, async ctx => {
+    const repoKey = ctx.match[1];
+    VERBOSE && console.log(`[VERBOSE] /merge dismiss callback received for ${repoKey}`);
+
+    // Remove the inline keyboard button after user acknowledges the error
+    try {
+      await ctx.editMessageReplyMarkup({ inline_keyboard: [] });
+      await ctx.answerCbQuery('Error acknowledged.');
+    } catch {
+      // Ignore errors (message might have been edited already)
+      await ctx.answerCbQuery('Error acknowledged.');
+    }
+  });
 }
 
 /**

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

@@ -360,6 +360,11 @@ export class MergeQueueProcessor {
       item.error = error.message;
       item.completedAt = new Date();
       this.stats.failed++;
+      // Issue #1269: Always log errors (not just in verbose mode) for debugging
+      console.error(`[ERROR] /merge-queue: Error processing PR #${item.pr.number}: ${error.message}`);
+      if (error.stack) {
+        console.error(`[ERROR] /merge-queue: Stack trace: ${error.stack.split('\n').slice(0, 5).join('\n')}`);
+      }
       this.log(`Error processing PR #${item.pr.number}: ${error.message}`);
     }
   }
@@ -450,6 +455,19 @@ export class MergeQueueProcessor {
       message += `${statusEmoji} ${update.current}\n\n`;
     }
 
+    // Show errors/failures inline so user gets immediate feedback (Issue #1269)
+    const failedItems = update.items.filter(item => item.status === MergeItemStatus.FAILED && item.error);
+    if (failedItems.length > 0) {
+      message += `⚠️ *Errors:*\n`;
+      for (const item of failedItems.slice(0, 3)) {
+        message += `  \\#${item.prNumber}: ${this.escapeMarkdown(item.error.substring(0, 60))}${item.error.length > 60 ? '...' : ''}\n`;
+      }
+      if (failedItems.length > 3) {
+        message += `  _...and ${failedItems.length - 3} more errors_\n`;
+      }
+      message += '\n';
+    }
+
     // PRs list with emojis
     message += `*Queue:*\n`;
     for (const item of update.items.slice(0, 10)) {

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

@@ -24,11 +24,10 @@
  * @param {Function} options.isChatAuthorized - Function to check if chat is authorized
  * @param {Function} options.addBreadcrumb - Function to add breadcrumbs for monitoring
  * @param {Function} options.getSolveQueue - Function to get the solve queue instance
- * @param {Function} options.getRunningClaudeProcesses - Function to get running claude processes
  * @returns {{ handleSolveQueueCommand: Function }} The command handler for use in text fallback
  */
 export function registerSolveQueueCommand(bot, options) {
-  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized, addBreadcrumb, getSolveQueue, getRunningClaudeProcesses } = options;
+  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized, addBreadcrumb, getSolveQueue } = options;
 
   async function handleSolveQueueCommand(ctx) {
     VERBOSE && console.log('[VERBOSE] /solve_queue command received');
@@ -72,13 +71,12 @@ export function registerSolveQueueCommand(bot, options) {
     VERBOSE && console.log('[VERBOSE] /solve_queue passed all checks, generating status...');
 
     const solveQueue = getSolveQueue({ verbose: VERBOSE });
-    const claudeProcs = await getRunningClaudeProcesses(VERBOSE);
 
     // Use the queue's built-in detailed status formatter
-    let message = solveQueue.formatDetailedStatus();
-
-    // Add running Claude processes info
-    message += `\n🖥️ Running Claude processes: ${claudeProcs.count}`;
+    // Shows per-queue breakdown with first 5 items per queue and human-readable times
+    // Processing counts are actual running system processes (via pgrep)
+    // See: https://github.com/link-assistant/hive-mind/issues/1267
+    const message = await solveQueue.formatDetailedStatus();
 
     await ctx.reply(message, {
       parse_mode: 'Markdown',

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

@@ -43,13 +43,14 @@ export const QueueItemStatus = {
 };
 
 /**
- * Count running claude processes
+ * Count running processes by name
+ * @param {string} processName - Process name to search for (e.g., 'claude', 'agent')
  * @param {boolean} verbose - Whether to log verbose output
  * @returns {Promise<{count: number, processes: string[]}>}
  */
-export async function getRunningClaudeProcesses(verbose = false) {
+export async function getRunningProcesses(processName, verbose = false) {
   try {
-    const { stdout } = await execAsync('pgrep -l -x claude 2>/dev/null || true');
+    const { stdout } = await execAsync(`pgrep -l -x ${processName} 2>/dev/null || true`);
     const lines = stdout
       .trim()
       .split('\n')
@@ -60,13 +61,13 @@ export async function getRunningClaudeProcesses(verbose = false) {
         const parts = line.trim().split(/\s+/);
         return {
           pid: parts[0],
-          name: parts.slice(1).join(' ') || 'claude',
+          name: parts.slice(1).join(' ') || processName,
         };
       })
       .filter(p => p.pid);
 
     if (verbose) {
-      console.log(`[VERBOSE] /solve_queue found ${processes.length} running claude processes`);
+      console.log(`[VERBOSE] /solve_queue found ${processes.length} running ${processName} processes`);
       if (processes.length > 0) {
         console.log(`[VERBOSE] /solve_queue processes: ${JSON.stringify(processes)}`);
       }
@@ -78,12 +79,30 @@ export async function getRunningClaudeProcesses(verbose = false) {
     };
   } catch (error) {
     if (verbose) {
-      console.error('[VERBOSE] /solve_queue error counting claude processes:', error.message);
+      console.error(`[VERBOSE] /solve_queue error counting ${processName} processes:`, error.message);
     }
     return { count: 0, processes: [] };
   }
 }
 
+/**
+ * Count running claude processes
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{count: number, processes: string[]}>}
+ */
+export async function getRunningClaudeProcesses(verbose = false) {
+  return getRunningProcesses('claude', verbose);
+}
+
+/**
+ * Count running agent processes
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{count: number, processes: string[]}>}
+ */
+export async function getRunningAgentProcesses(verbose = false) {
+  return getRunningProcesses('agent', verbose);
+}
+
 /**
  * Format a threshold as percentage for display
  * @param {number} ratio - Ratio (0.0 - 1.0)
@@ -93,6 +112,33 @@ function formatThresholdPercent(ratio) {
   return `${Math.round(ratio * 100)}%`;
 }
 
+/**
+ * Format milliseconds into human-readable duration
+ * Shows days, hours, minutes, and seconds as appropriate.
+ * Examples: "5h 43m 23s", "2m 15s", "45s", "1d 3h 12m 5s"
+ *
+ * @param {number} ms - Duration in milliseconds
+ * @returns {string} Human-readable duration
+ * @see https://github.com/link-assistant/hive-mind/issues/1267
+ */
+export function formatDuration(ms) {
+  if (ms < 0) ms = 0;
+
+  const totalSeconds = Math.floor(ms / 1000);
+  const days = Math.floor(totalSeconds / 86400);
+  const hours = Math.floor((totalSeconds % 86400) / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const seconds = totalSeconds % 60;
+
+  const parts = [];
+  if (days > 0) parts.push(`${days}d`);
+  if (hours > 0) parts.push(`${hours}h`);
+  if (minutes > 0) parts.push(`${minutes}m`);
+  if (seconds > 0 || parts.length === 0) parts.push(`${seconds}s`);
+
+  return parts.join(' ');
+}
+
 /**
  * Generate human-readable waiting reason based on threshold violation
  * @param {string} metric - The metric name (ram, cpu, disk, etc.)
@@ -1035,7 +1081,11 @@ export class SolveQueue {
           const itemCheck = await this.canStartCommand({ tool: item.tool });
           const previousStatus = item.status;
           const previousReason = item.waitingReason;
-          item.setWaiting(itemCheck.reason || 'Waiting in queue');
+          // Use rejectReason when threshold strategy is 'reject', otherwise use reason
+          // This ensures disk-full and other rejection reasons are shown properly
+          // See: https://github.com/link-assistant/hive-mind/issues/1267
+          const waitReason = itemCheck.rejectReason || itemCheck.reason || 'Waiting in queue';
+          item.setWaiting(waitReason);
 
           // Update message if status/reason changed or it's time for periodic update
           const shouldUpdate = previousStatus !== item.status || previousReason !== item.waitingReason || this.shouldUpdateMessage(item);
@@ -1158,74 +1208,113 @@ export class SolveQueue {
   }
 
   /**
-   * Format queue status for display
-   * Shows per-tool queue counts.
-   * @returns {string}
+   * Format queue status for display in /limits command
+   * Shows per-tool queue breakdown with processing counts.
+   *
+   * Processing count = actual running system processes (via pgrep), not items in queue processing state.
+   * This is because items transition quickly through the processing state, but the actual
+   * work happens in the spawned system process (claude, agent, etc.).
+   *
+   * Output format:
+   * ```
+   * Queues
+   * claude (pending: 6, processing: 0)
+   * agent (pending: 2, processing: 0)
+   * ```
+   *
+   * @returns {Promise<string>}
    * @see https://github.com/link-assistant/hive-mind/issues/1159
+   * @see https://github.com/link-assistant/hive-mind/issues/1267
    */
-  formatStatus() {
-    const stats = this.getStats();
-    if (stats.queued > 0 || stats.processing > 0) {
-      // Show per-tool breakdown if there are items
-      const toolBreakdown = Object.entries(stats.queuedByTool)
-        .filter(entry => entry[1] > 0)
-        .map(([tool, count]) => `${tool}: ${count}`)
-        .join(', ');
-      const queueInfo = toolBreakdown ? ` (${toolBreakdown})` : '';
-      return `Solve Queue: ${stats.queued} pending${queueInfo}, ${stats.processing} processing\n`;
+  async formatStatus() {
+    // Get actual process counts for each tool queue
+    // The "processing" count is the number of running system processes, not queue internal state
+    // This ensures users see accurate counts of what's actually running
+    const claudeProcs = await getRunningClaudeProcesses(this.verbose);
+    const agentProcs = await getRunningAgentProcesses(this.verbose);
+
+    const processCounts = {
+      claude: claudeProcs.count,
+      agent: agentProcs.count,
+    };
+
+    // Always show per-tool breakdown for all known queues
+    let message = 'Queues\n';
+    for (const [tool, toolQueue] of Object.entries(this.queues)) {
+      const pending = toolQueue.length;
+      const processing = processCounts[tool] || 0;
+      message += `${tool} (pending: ${pending}, processing: ${processing})\n`;
     }
-    return 'Solve Queue: empty\n';
+
+    return message;
   }
 
   /**
    * Format detailed queue status for Telegram message
-   * Shows per-tool queue breakdown.
-   * @returns {string}
+   * Groups output by tool queue, shows first 5 items per queue, and uses human-readable time.
+   *
+   * Processing count = actual running system processes (via pgrep), not items in queue processing state.
+   * This is because items transition quickly through the processing state, but the actual
+   * work happens in the spawned system process (claude, agent, etc.).
+   *
+   * Output format:
+   * ```
+   * 📋 Solve Queue Status
+   *
+   * claude (pending: 6, processing: 0)
+   * • url1 (waiting, 5h 43m 23s)
+   *   └ RAM usage is 70% (threshold: 65%)
+   * • url2 (queued, 2m 15s)
+   *
+   * agent (pending: 2, processing: 0)
+   * • url3 (waiting, 1h 2m 5s)
+   * ```
+   *
+   * @returns {Promise<string>}
    * @see https://github.com/link-assistant/hive-mind/issues/1159
+   * @see https://github.com/link-assistant/hive-mind/issues/1267
    */
-  formatDetailedStatus() {
+  async formatDetailedStatus() {
     const stats = this.getStats();
-    const summary = this.getQueueSummary();
 
-    let message = '📋 *Solve Queue Status*\n\n';
-    message += `Pending: ${stats.queued}`;
-
-    // Add per-tool breakdown
-    const toolBreakdown = Object.entries(stats.queuedByTool)
-      .filter(entry => entry[1] > 0)
-      .map(([tool, count]) => `${tool}: ${count}`)
-      .join(', ');
-    if (toolBreakdown) {
-      message += ` (${toolBreakdown})`;
-    }
-    message += '\n';
+    // Get actual process counts for each tool queue
+    // The "processing" count is the number of running system processes, not queue internal state
+    // This ensures users see accurate counts of what's actually running
+    const claudeProcs = await getRunningClaudeProcesses(this.verbose);
+    const agentProcs = await getRunningAgentProcesses(this.verbose);
 
-    message += `Processing: ${stats.processing}\n`;
-    message += `Completed: ${stats.completed}\n`;
-    message += `Failed: ${stats.failed}\n\n`;
+    const processCounts = {
+      claude: claudeProcs.count,
+      agent: agentProcs.count,
+    };
 
-    if (summary.processing.length > 0) {
-      message += '*Currently Processing:*\n';
-      for (const item of summary.processing) {
-        message += `• ${item.url} [${item.tool}]\n`;
-      }
-      message += '\n';
-    }
+    let message = '📋 *Solve Queue Status*\n\n';
 
-    if (summary.pending.length > 0) {
-      message += '*Waiting in Queue:*\n';
-      for (const item of summary.pending.slice(0, 5)) {
-        const waitSeconds = Math.floor(item.waitTime / 1000);
-        message += `• ${item.url} [${item.tool}] (${item.status}, ${waitSeconds}s)\n`;
+    // Show per-tool queue breakdown with items grouped by queue
+    for (const [tool, toolQueue] of Object.entries(this.queues)) {
+      const pending = toolQueue.length;
+      const processing = processCounts[tool] || 0;
+      message += `*${tool}* (pending: ${pending}, processing: ${processing})\n`;
+
+      // Show first 5 queued items for this tool
+      const displayItems = toolQueue.slice(0, 5);
+      for (const item of displayItems) {
+        const waitTime = formatDuration(item.getWaitTime());
+        message += `  • ${item.url} (${item.status}, ${waitTime})\n`;
         if (item.waitingReason) {
-          message += `  └ ${item.waitingReason}\n`;
+          message += `    └ ${item.waitingReason}\n`;
         }
       }
-      if (summary.pending.length > 5) {
-        message += `  ... and ${summary.pending.length - 5} more\n`;
+      if (toolQueue.length > 5) {
+        message += `    ... and ${toolQueue.length - 5} more\n`;
       }
+
+      message += '\n';
     }
 
+    // Summary stats
+    message += `Completed: ${stats.completed}, Failed: ${stats.failed}\n`;
+
     return message;
   }
 }
@@ -1275,8 +1364,11 @@ export default {
   SolveQueueItem,
   getSolveQueue,
   resetSolveQueue,
+  getRunningProcesses,
   getRunningClaudeProcesses,
+  getRunningAgentProcesses,
   createQueueExecuteCallback,
+  formatDuration,
   QUEUE_CONFIG,
   QueueItemStatus,
 };