@link-assistant/hive-mind 1.11.4 → 1.11.6

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @link-assistant/hive-mind
 
+## 1.11.6
+
+### Patch Changes
+
+- 5eef9e4: Skip Claude API limits for --tool agent tasks in queue
+  - Agent tools (Grok Code, OpenCode Zen) use different backends with their own rate limits
+  - Add tool parameter to canStartCommand() and checkApiLimits() functions
+  - Skip Claude-specific limits (5-hour session, weekly) when tool is 'agent'
+  - Consumer loop now passes next queue item's tool to limit checks
+  - Add 7 new tests for tool-specific limit handling
+  - Add case study documentation
+
+  Fixes #1159
+
+## 1.11.5
+
+### Patch Changes
+
+- 7d3387c: Fix duplicate Solution Draft Log comments on GitHub PRs
+
+  When a Claude session ends with uncommitted changes and --attach-logs is enabled, the solution draft log was being uploaded twice - once by verifyResults() during normal completion, and again after temporary watch mode completes. This fix tracks whether logs were already uploaded and skips the duplicate upload.
+
 ## 1.11.4
 
 ### Patch Changes

package/package.json

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

package/src/config.lib.mjs

@@ -194,7 +194,7 @@ export const cacheTtl = {
   api: parseIntWithDefault('HIVE_MIND_API_CACHE_TTL_MS', 3 * 60 * 1000), // 3 minutes
   // Claude Usage API cache TTL - must be at least 20 minutes to avoid rate limiting
   // The API returns null values when called too frequently
-  usageApi: parseIntWithDefault('HIVE_MIND_USAGE_API_CACHE_TTL_MS', 20 * 60 * 1000), // 20 minutes
+  usageApi: parseIntWithDefault('HIVE_MIND_USAGE_API_CACHE_TTL_MS', 10 * 60 * 1000), // 10 minutes
   // System metrics cache TTL (RAM, CPU, disk)
   system: parseIntWithDefault('HIVE_MIND_SYSTEM_CACHE_TTL_MS', 2 * 60 * 1000), // 2 minutes
 };

package/src/solve.mjs

@@ -1159,7 +1159,9 @@ try {
   // Pass shouldRestart to prevent early exit when auto-restart is needed
   // Include agent tool pricing data when available (publicPricingEstimate, pricingInfo)
   // Issue #1088: Pass errorDuringExecution for "Finished with errors" state
-  await verifyResults(owner, repo, branchName, issueNumber, prNumber, prUrl, referenceTime, argv, shouldAttachLogs, shouldRestart, sessionId, tempDir, anthropicTotalCostUSD, publicPricingEstimate, pricingInfo, errorDuringExecution);
+  // Issue #1154: Track if logs were already uploaded to prevent duplicates
+  const verifyResult = await verifyResults(owner, repo, branchName, issueNumber, prNumber, prUrl, referenceTime, argv, shouldAttachLogs, shouldRestart, sessionId, tempDir, anthropicTotalCostUSD, publicPricingEstimate, pricingInfo, errorDuringExecution);
+  const logsAlreadyUploaded = verifyResult?.logUploadSuccess || false;
 
   // Start watch mode if enabled OR if we need to handle uncommitted changes
   if (argv.verbose) {
@@ -1246,7 +1248,8 @@ try {
     }
 
     // Attach updated logs to PR after auto-restart completes
-    if (shouldAttachLogs && prNumber) {
+    // Issue #1154: Skip if logs were already uploaded by verifyResults() to prevent duplicates
+    if (shouldAttachLogs && prNumber && !logsAlreadyUploaded) {
       await log('📎 Uploading working session logs to Pull Request...');
       try {
         const logUploadSuccess = await attachLogToGitHub({
@@ -1273,6 +1276,9 @@ try {
       } catch (uploadError) {
         await log(`⚠️  Error uploading logs: ${uploadError.message}`, { level: 'warning' });
       }
+    } else if (logsAlreadyUploaded) {
+      await log('ℹ️  Logs already uploaded by verifyResults, skipping duplicate upload', { verbose: true });
+      logsAttached = true;
     }
   }
 

package/src/solve.results.lib.mjs

@@ -564,7 +564,8 @@ export const verifyResults = async (owner, repo, branchName, issueNumber, prNumb
         if (!argv.watch && !shouldRestart) {
           await safeExit(0, 'Process completed successfully');
         }
-        return; // Return normally for watch mode or auto-restart
+        // Issue #1154: Return logUploadSuccess to prevent duplicate log uploads
+        return { logUploadSuccess }; // Return for watch mode or auto-restart
       } else {
         await log(`  ℹ️  Found pull request #${pr.number} but it appears to be from a different session`);
       }
@@ -627,7 +628,8 @@ export const verifyResults = async (owner, repo, branchName, issueNumber, prNumb
       if (!argv.watch && !shouldRestart) {
         await safeExit(0, 'Process completed successfully');
       }
-      return; // Return normally for watch mode or auto-restart
+      // Issue #1154: Return logUploadSuccess to prevent duplicate log uploads
+      return { logUploadSuccess: true }; // Return for watch mode or auto-restart
     } else if (allComments.length > 0) {
       await log(`  ℹ️  Issue has ${allComments.length} existing comment(s)`);
     } else {
@@ -645,7 +647,8 @@ export const verifyResults = async (owner, repo, branchName, issueNumber, prNumb
     if (!argv.watch) {
       await safeExit(0, 'Process completed successfully');
     }
-    return; // Return normally for watch mode
+    // Issue #1154: Return logUploadSuccess to prevent duplicate log uploads
+    return { logUploadSuccess: false }; // Return for watch mode
   } catch (searchError) {
     reportError(searchError, {
       context: 'verify_pr_creation',
@@ -661,7 +664,8 @@ export const verifyResults = async (owner, repo, branchName, issueNumber, prNumb
     if (!argv.watch) {
       await safeExit(0, 'Process completed successfully');
     }
-    return; // Return normally for watch mode
+    // Issue #1154: Return logUploadSuccess to prevent duplicate log uploads
+    return { logUploadSuccess: false }; // Return for watch mode
   }
 };
 

package/src/telegram-bot.mjs

@@ -1102,7 +1102,7 @@ bot.command(/^solve$/i, async ctx => {
     return;
   }
 
-  const check = await solveQueue.canStartCommand();
+  const check = await solveQueue.canStartCommand({ tool: solveTool }); // Skip Claude limits for agent (#1159)
   const queueStats = solveQueue.getStats();
   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 });

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

@@ -41,9 +41,9 @@ export const QUEUE_CONFIG = {
 
   // API limit thresholds (usage ratios: 0.0 - 1.0)
   // All thresholds use >= comparison (inclusive)
-  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, // Enqueue if GitHub >= 80% with parallel claude
+  CLAUDE_5_HOUR_SESSION_THRESHOLD: 0.75, // One-at-a-time if 5-hour limit >= 75%
+  CLAUDE_WEEKLY_THRESHOLD: 0.97, // One-at-a-time if weekly limit >= 97%
+  GITHUB_API_THRESHOLD: 0.75, // Enqueue if GitHub >= 75% with parallel claude
 
   // Timing
   // MIN_START_INTERVAL_MS: Time to allow solve command to start actual claude process
@@ -242,6 +242,13 @@ class SolveQueueItem {
 
 /**
  * Solve Queue - Producer/Consumer queue for /solve commands
+ *
+ * Uses separate queues for each tool type to ensure:
+ * - Claude tasks never block agent tasks (and vice versa)
+ * - Each tool queue maintains FIFO order
+ * - Each tool has independent rate limiting
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1159
  */
 export class SolveQueue {
   constructor(options = {}) {
@@ -249,14 +256,23 @@ export class SolveQueue {
     this.executeCallback = options.executeCallback || null;
     this.messageUpdateCallback = options.messageUpdateCallback || null;
 
-    // Queue state
-    this.queue = [];
+    // Separate queues per tool type - claude tasks never block agent tasks
+    // See: https://github.com/link-assistant/hive-mind/issues/1159
+    this.queues = {
+      claude: [],
+      agent: [],
+    };
     this.processing = new Map();
     this.completed = [];
     this.failed = [];
     this.isRunning = true;
 
-    // Timing
+    // Timing - separate per tool to ensure independent processing
+    this.lastStartTimeByTool = {
+      claude: null,
+      agent: null,
+    };
+    // Legacy: keep for compatibility with existing code that uses lastStartTime
     this.lastStartTime = null;
 
     // Consumer task reference
@@ -272,7 +288,43 @@ export class SolveQueue {
       throttleReasons: {},
     };
 
-    this.log('SolveQueue initialized');
+    this.log('SolveQueue initialized with separate tool queues');
+  }
+
+  /**
+   * Get the queue array for a specific tool, creating it if needed
+   * @param {string} tool - Tool type ('claude', 'agent', etc.)
+   * @returns {Array} The queue array for this tool
+   */
+  getToolQueue(tool) {
+    if (!this.queues[tool]) {
+      this.queues[tool] = [];
+    }
+    return this.queues[tool];
+  }
+
+  /**
+   * Get combined queue length across all tools (for backwards compatibility)
+   * @returns {number} Total queue length
+   */
+  get queue() {
+    let total = [];
+    for (const toolQueue of Object.values(this.queues)) {
+      total = total.concat(toolQueue);
+    }
+    return total;
+  }
+
+  /**
+   * Get total pending count across all tool queues
+   * @returns {number} Total pending items
+   */
+  getTotalQueueLength() {
+    let total = 0;
+    for (const toolQueue of Object.values(this.queues)) {
+      total += toolQueue.length;
+    }
+    return total;
   }
 
   /**
@@ -286,16 +338,19 @@ export class SolveQueue {
   }
 
   /**
-   * Add a solve command to the queue
+   * Add a solve command to the appropriate tool queue
+   * Items are added to the queue for their specific tool type.
    * @param {Object} options - Queue item options
    * @returns {SolveQueueItem} The queued item
+   * @see https://github.com/link-assistant/hive-mind/issues/1159
    */
   enqueue(options) {
     const item = new SolveQueueItem(options);
-    this.queue.push(item);
+    const toolQueue = this.getToolQueue(item.tool);
+    toolQueue.push(item);
     this.stats.totalEnqueued++;
 
-    this.log(`Enqueued: ${item.toString()}, queue length: ${this.queue.length}`);
+    this.log(`Enqueued: ${item.toString()} to ${item.tool} queue, queue length: ${toolQueue.length}`);
 
     // Start consumer if not already running
     this.ensureConsumerRunning();
@@ -304,17 +359,19 @@ export class SolveQueue {
   }
 
   /**
-   * Find an item by URL in the queue or processing items
+   * Find an item by URL in any queue or processing items
    * Used to prevent duplicate URLs from being added to the queue
    * @param {string} url - The URL to search for
    * @returns {SolveQueueItem|null} The found item or null
    * @see https://github.com/link-assistant/hive-mind/issues/1080
    */
   findByUrl(url) {
-    // Check queued items
-    const queuedItem = this.queue.find(item => item.url === url);
-    if (queuedItem) {
-      return queuedItem;
+    // Check all tool queues
+    for (const toolQueue of Object.values(this.queues)) {
+      const queuedItem = toolQueue.find(item => item.url === url);
+      if (queuedItem) {
+        return queuedItem;
+      }
     }
 
     // Check processing items
@@ -329,17 +386,22 @@ export class SolveQueue {
 
   /**
    * Cancel a queued item by ID
+   * Searches all tool queues to find the item.
    * @param {string} id - Item ID
    * @returns {boolean} True if cancelled
+   * @see https://github.com/link-assistant/hive-mind/issues/1159
    */
   cancel(id) {
-    const queueIndex = this.queue.findIndex(item => item.id === id);
-    if (queueIndex !== -1) {
-      const item = this.queue.splice(queueIndex, 1)[0];
-      item.setCancelled();
-      this.stats.totalCancelled++;
-      this.log(`Cancelled queued item: ${item.toString()}`);
-      return true;
+    // Search all tool queues
+    for (const [tool, toolQueue] of Object.entries(this.queues)) {
+      const queueIndex = toolQueue.findIndex(item => item.id === id);
+      if (queueIndex !== -1) {
+        const item = toolQueue.splice(queueIndex, 1)[0];
+        item.setCancelled();
+        this.stats.totalCancelled++;
+        this.log(`Cancelled queued item: ${item.toString()} from ${tool} queue`);
+        return true;
+      }
     }
 
     if (this.processing.has(id)) {
@@ -355,39 +417,130 @@ export class SolveQueue {
    * @returns {Object}
    */
   getStats() {
+    // Calculate per-tool queue stats
+    const queuedByTool = {};
+    let totalQueued = 0;
+    for (const [tool, toolQueue] of Object.entries(this.queues)) {
+      queuedByTool[tool] = toolQueue.length;
+      totalQueued += toolQueue.length;
+    }
+
     return {
-      queued: this.queue.length,
+      queued: totalQueued,
+      queuedByTool,
       processing: this.processing.size,
       completed: this.completed.length,
       failed: this.failed.length,
       ...this.stats,
       cacheStats: getLimitCache().getStats(),
       lastStartTime: this.lastStartTime,
+      lastStartTimeByTool: this.lastStartTimeByTool,
       isRunning: this.isRunning,
     };
   }
 
+  /**
+   * Count processing items by tool type
+   * Used for tool-specific limit checking - e.g., Claude limits only count Claude processing items
+   * @param {string} tool - Tool type to count ('claude', 'agent', etc.)
+   * @returns {number} Count of processing items with the specified tool
+   * @see https://github.com/link-assistant/hive-mind/issues/1159
+   */
+  getProcessingCountByTool(tool) {
+    let count = 0;
+    for (const item of this.processing.values()) {
+      if (item.tool === tool) {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  /**
+   * Find startable items from each tool queue
+   * Returns the first item from each tool queue that can start.
+   * With separate queues, each tool is checked independently so they don't block each other.
+   * @returns {Promise<Array<{item: SolveQueueItem, tool: string, index: number, check: Object}>>}
+   * @see https://github.com/link-assistant/hive-mind/issues/1159
+   */
+  async findStartableItems() {
+    const startableItems = [];
+
+    for (const [tool, toolQueue] of Object.entries(this.queues)) {
+      if (toolQueue.length === 0) continue;
+
+      // Check if first item in this tool's queue can start
+      const item = toolQueue[0];
+      const check = await this.canStartCommand({ tool });
+
+      if (check.canStart) {
+        // Also check one-at-a-time mode for this specific tool
+        // For tool-specific one-at-a-time, only count that tool's processing items
+        const toolProcessingCount = this.getProcessingCountByTool(tool);
+        if (check.oneAtATime && toolProcessingCount > 0) {
+          // This tool is in one-at-a-time mode and has items processing
+          // Skip but don't block other tools
+          continue;
+        }
+        startableItems.push({ item, tool, index: 0, check });
+      }
+    }
+
+    return startableItems;
+  }
+
+  /**
+   * Find first queue item that can start based on its tool's limits (legacy compatibility)
+   * With separate queues, returns the first startable item from any tool queue.
+   * @returns {Promise<{item: SolveQueueItem|null, index: number, check: Object}>}
+   * @see https://github.com/link-assistant/hive-mind/issues/1159
+   */
+  async findStartableItem() {
+    const startableItems = await this.findStartableItems();
+    if (startableItems.length > 0) {
+      // Return the first startable item (arbitrary order among tools)
+      const first = startableItems[0];
+      return { item: first.item, index: first.index, check: first.check };
+    }
+    return { item: null, index: -1, check: null };
+  }
+
   /**
    * Get queue items summary for display
+   * Combines items from all tool queues into a single pending list.
    * @returns {Object}
+   * @see https://github.com/link-assistant/hive-mind/issues/1159
    */
   getQueueSummary() {
+    // Collect pending items from all tool queues
+    const pending = [];
+    for (const [tool, toolQueue] of Object.entries(this.queues)) {
+      for (const item of toolQueue) {
+        pending.push({
+          id: item.id,
+          url: item.url,
+          requester: item.requester,
+          waitTime: item.getWaitTime(),
+          createdAt: item.createdAt,
+          status: item.status,
+          waitingReason: item.waitingReason,
+          tool,
+        });
+      }
+    }
+
+    // Sort by createdAt to show oldest first (global order)
+    pending.sort((a, b) => a.createdAt - b.createdAt);
+
     return {
-      pending: this.queue.map(item => ({
-        id: item.id,
-        url: item.url,
-        requester: item.requester,
-        waitTime: item.getWaitTime(),
-        createdAt: item.createdAt,
-        status: item.status,
-        waitingReason: item.waitingReason,
-      })),
+      pending,
       processing: Array.from(this.processing.values()).map(item => ({
         id: item.id,
         url: item.url,
         requester: item.requester,
         startedAt: item.startedAt,
         status: item.status,
+        tool: item.tool,
       })),
     };
   }
@@ -400,15 +553,26 @@ export class SolveQueue {
    * 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
    *
+   * Logic per issue #1159:
+   * - Different tools have different limits. Claude limits only apply to 'claude' tool.
+   * - Processing count for Claude limits only includes Claude items, not agent items.
+   * - This allows agent tasks to run in parallel when Claude limits are reached.
+   *
+   * @param {Object} options - Options for the check
+   * @param {string} options.tool - The tool being used ('claude', 'agent', etc.)
    * @returns {Promise<{canStart: boolean, reason?: string, reasons?: string[], oneAtATime?: boolean}>}
    */
-  async canStartCommand() {
+  async canStartCommand(options = {}) {
+    const tool = options.tool || 'claude';
     const reasons = [];
     let oneAtATime = false;
 
-    // Check minimum interval since last start
-    if (this.lastStartTime) {
-      const timeSinceLastStart = Date.now() - this.lastStartTime;
+    // Check minimum interval since last start FOR THIS TOOL
+    // Each tool queue has independent timing to prevent cross-blocking
+    // See: https://github.com/link-assistant/hive-mind/issues/1159
+    const lastStartTime = this.lastStartTimeByTool[tool] || null;
+    if (lastStartTime) {
+      const timeSinceLastStart = Date.now() - lastStartTime;
       if (timeSinceLastStart < QUEUE_CONFIG.MIN_START_INTERVAL_MS) {
         const waitSeconds = Math.ceil((QUEUE_CONFIG.MIN_START_INTERVAL_MS - timeSinceLastStart) / 1000);
         reasons.push(formatWaitingReason('min_interval', 0, 0) + ` (${waitSeconds}s remaining)`);
@@ -420,18 +584,23 @@ export class SolveQueue {
     const claudeProcs = await getRunningClaudeProcesses(this.verbose);
     const hasRunningClaude = claudeProcs.count > 0;
 
-    // Calculate total processing count: queue-internal + external claude processes
-    // This is used for CLAUDE_5_HOUR_SESSION_THRESHOLD and CLAUDE_WEEKLY_THRESHOLD
-    // to allow exactly one command at a time when threshold is reached
-    // See: https://github.com/link-assistant/hive-mind/issues/1133
+    // Calculate total processing count for system resources (all tools)
+    // System resources (RAM, CPU, disk) apply to all tools
     const totalProcessing = this.processing.size + claudeProcs.count;
 
+    // Calculate Claude-specific processing count for Claude API limits
+    // Only counts Claude items in queue + external claude processes
+    // Agent items don't count against Claude's one-at-a-time limit
+    // See: https://github.com/link-assistant/hive-mind/issues/1159
+    const claudeProcessingCount = this.getProcessingCountByTool('claude');
+
     // Track claude_running as a metric (but don't add to reasons yet)
     if (hasRunningClaude) {
       this.recordThrottle('claude_running');
     }
 
     // Check system resources (RAM, CPU block unconditionally; disk uses one-at-a-time mode)
+    // System resources apply to ALL tools, not just Claude
     // See: https://github.com/link-assistant/hive-mind/issues/1155
     const resourceCheck = await this.checkSystemResources(totalProcessing);
     if (!resourceCheck.ok) {
@@ -441,8 +610,11 @@ export class SolveQueue {
       oneAtATime = true;
     }
 
-    // Check API limits (pass hasRunningClaude and totalProcessing for uniform checking)
-    const limitCheck = await this.checkApiLimits(hasRunningClaude, totalProcessing);
+    // Check API limits (pass hasRunningClaude, claudeProcessingCount, and tool)
+    // Claude limits use claudeProcessingCount (only Claude items), not totalProcessing
+    // This allows agent tasks to proceed when Claude limits are reached
+    // See: https://github.com/link-assistant/hive-mind/issues/1159
+    const limitCheck = await this.checkApiLimits(hasRunningClaude, claudeProcessingCount, tool);
     if (!limitCheck.ok) {
       reasons.push(...limitCheck.reasons);
     }
@@ -472,6 +644,7 @@ export class SolveQueue {
       oneAtATime,
       claudeProcesses: claudeProcs.count,
       totalProcessing,
+      claudeProcessingCount,
     };
   }
 
@@ -559,54 +732,77 @@ export class SolveQueue {
    *
    * Logic per issue #1133:
    * - CLAUDE_5_HOUR_SESSION_THRESHOLD and CLAUDE_WEEKLY_THRESHOLD use one-at-a-time mode:
-   *   when above threshold, allow exactly one command, block if totalProcessing > 0
+   *   when above threshold, allow exactly one command, block if claudeProcessing > 0
    * - GitHub threshold blocks unconditionally when exceeded (ultimate restriction)
-   * - totalProcessing = queue-internal count + external claude processes (pgrep)
    *
-   * @param {boolean} hasRunningClaude - Whether claude processes are running
-   * @param {number} totalProcessing - Total processing count (queue + external claude processes)
+   * Logic per issue #1159:
+   * - When tool is 'agent', skip Claude-specific limits entirely since agent uses different
+   *   rate limits (Grok Code or similar). Only system resources and GitHub limits apply.
+   * - For Claude limits, only count Claude-specific processing items, not agent items.
+   *   This allows agent tasks to run in parallel even when Claude limits are reached.
+   *
+   * @param {boolean} hasRunningClaude - Whether claude processes are running (from pgrep)
+   * @param {number} claudeProcessingCount - Count of 'claude' tool items being processed in queue
+   * @param {string} tool - The tool being used ('claude', 'agent', etc.)
    * @returns {Promise<{ok: boolean, reasons: string[], oneAtATime: boolean}>}
    */
-  async checkApiLimits(hasRunningClaude = false, totalProcessing = 0) {
+  async checkApiLimits(hasRunningClaude = false, claudeProcessingCount = 0, tool = 'claude') {
     const reasons = [];
     let oneAtATime = false;
 
+    // Apply Claude-specific limits only when tool is 'claude'
+    // Other tools (like 'agent') use different rate limiting backends and are not
+    // affected by Claude API limits (5-hour session, weekly limits)
+    // See: https://github.com/link-assistant/hive-mind/issues/1159
+    const applyClaudeLimits = tool === 'claude';
+
+    // Calculate total Claude processing: queue-internal claude items + external claude processes
+    // This is used for Claude limits one-at-a-time mode - only counts Claude-related processing
+    // Agent items in the queue don't count against Claude's one-at-a-time limit
+    // See: https://github.com/link-assistant/hive-mind/issues/1159
+    const totalClaudeProcessing = claudeProcessingCount + (hasRunningClaude ? 1 : 0);
+
     // Check Claude limits (using cached value)
-    const claudeResult = await getCachedClaudeLimits(this.verbose);
-    if (claudeResult.success) {
-      const sessionPercent = claudeResult.usage.currentSession.percentage;
-      const weeklyPercent = claudeResult.usage.allModels.percentage;
-
-      // Session limit (5-hour)
-      // When above threshold: allow exactly one command, block if any processing is happening
-      // Uses totalProcessing (queue + external claude) for uniform checking
-      // See: https://github.com/link-assistant/hive-mind/issues/1133
-      if (sessionPercent !== null) {
-        const sessionRatio = sessionPercent / 100;
-        if (sessionRatio >= QUEUE_CONFIG.CLAUDE_5_HOUR_SESSION_THRESHOLD) {
-          oneAtATime = true;
-          this.recordThrottle(sessionRatio >= 1.0 ? 'claude_5_hour_session_100' : 'claude_5_hour_session_high');
-          // Use totalProcessing (queue + external claude) for uniform checking
-          if (totalProcessing > 0) {
-            reasons.push(formatWaitingReason('claude_5_hour_session', sessionPercent, QUEUE_CONFIG.CLAUDE_5_HOUR_SESSION_THRESHOLD) + ' (waiting for current command)');
+    // Only applied when tool is 'claude'
+    if (applyClaudeLimits) {
+      const claudeResult = await getCachedClaudeLimits(this.verbose);
+      if (claudeResult.success) {
+        const sessionPercent = claudeResult.usage.currentSession.percentage;
+        const weeklyPercent = claudeResult.usage.allModels.percentage;
+
+        // Session limit (5-hour)
+        // When above threshold: allow exactly one Claude command, block if any Claude processing
+        // Only counts Claude-specific processing, not agent items
+        // See: https://github.com/link-assistant/hive-mind/issues/1133, #1159
+        if (sessionPercent !== null) {
+          const sessionRatio = sessionPercent / 100;
+          if (sessionRatio >= QUEUE_CONFIG.CLAUDE_5_HOUR_SESSION_THRESHOLD) {
+            oneAtATime = true;
+            this.recordThrottle(sessionRatio >= 1.0 ? 'claude_5_hour_session_100' : 'claude_5_hour_session_high');
+            // Use totalClaudeProcessing for Claude-specific one-at-a-time checking
+            if (totalClaudeProcessing > 0) {
+              reasons.push(formatWaitingReason('claude_5_hour_session', sessionPercent, QUEUE_CONFIG.CLAUDE_5_HOUR_SESSION_THRESHOLD) + ' (waiting for current command)');
+            }
           }
         }
-      }
 
-      // Weekly limit
-      // When above threshold: allow exactly one command, block if one is in progress
-      if (weeklyPercent !== null) {
-        const weeklyRatio = weeklyPercent / 100;
-        if (weeklyRatio >= QUEUE_CONFIG.CLAUDE_WEEKLY_THRESHOLD) {
-          oneAtATime = true;
-          this.recordThrottle(weeklyRatio >= 1.0 ? 'claude_weekly_100' : 'claude_weekly_high');
-          // Use totalProcessing (queue + external claude) for uniform checking
-          // See: https://github.com/link-assistant/hive-mind/issues/1133
-          if (totalProcessing > 0) {
-            reasons.push(formatWaitingReason('claude_weekly', weeklyPercent, QUEUE_CONFIG.CLAUDE_WEEKLY_THRESHOLD) + ' (waiting for current command)');
+        // Weekly limit
+        // When above threshold: allow exactly one Claude command, block if one is in progress
+        if (weeklyPercent !== null) {
+          const weeklyRatio = weeklyPercent / 100;
+          if (weeklyRatio >= QUEUE_CONFIG.CLAUDE_WEEKLY_THRESHOLD) {
+            oneAtATime = true;
+            this.recordThrottle(weeklyRatio >= 1.0 ? 'claude_weekly_100' : 'claude_weekly_high');
+            // Use totalClaudeProcessing for Claude-specific one-at-a-time checking
+            // See: https://github.com/link-assistant/hive-mind/issues/1133, #1159
+            if (totalClaudeProcessing > 0) {
+              reasons.push(formatWaitingReason('claude_weekly', weeklyPercent, QUEUE_CONFIG.CLAUDE_WEEKLY_THRESHOLD) + ' (waiting for current command)');
+            }
           }
         }
       }
+    } else if (this.verbose) {
+      this.log(`Claude limits not applied for --tool ${tool}`);
     }
 
     // Check GitHub limits (only relevant if claude processes running)
@@ -678,88 +874,101 @@ export class SolveQueue {
   }
 
   /**
-   * Consumer loop - processes items from the queue
+   * Consumer loop - processes items from all tool queues
+   *
+   * With separate queues per tool:
+   * - Each tool queue is checked independently
+   * - Claude limits only affect Claude queue
+   * - Agent queue can proceed even when Claude is blocked (and vice versa)
+   * - Multiple items can start in the same cycle (one per tool)
+   *
+   * @see https://github.com/link-assistant/hive-mind/issues/1159
    */
   async runConsumer() {
-    this.log('Consumer started');
+    this.log('Consumer started with separate tool queues');
 
     while (this.isRunning) {
-      if (this.queue.length === 0) {
+      // Check if all queues are empty
+      if (this.getTotalQueueLength() === 0) {
         await this.sleep(QUEUE_CONFIG.CONSUMER_POLL_INTERVAL_MS);
         continue;
       }
 
-      const check = await this.canStartCommand();
-
-      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:
-            // 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}`);
-            }
-          }
-        }
+      // Find startable items from each tool queue
+      // Each tool is checked independently so they don't block each other
+      // See: https://github.com/link-assistant/hive-mind/issues/1159
+      const startableItems = await this.findStartableItems();
 
-        this.log(`Throttled: ${check.reason}`);
+      if (startableItems.length === 0) {
+        // No items can start - update all queued items with their tool-specific waiting reasons
+        await this.updateAllWaitingItems();
+        this.log(`Throttled: no items can start from any tool queue`);
         await this.sleep(QUEUE_CONFIG.CONSUMER_POLL_INTERVAL_MS);
         continue;
       }
 
-      // Check one-at-a-time mode
-      // When oneAtATime is true (e.g., weekly limit >= 99%), block if any processing is happening
-      // totalProcessing = queue-internal (this.processing.size) + external claude processes (pgrep)
-      // This ensures uniform checking across all threshold conditions
-      // See: https://github.com/link-assistant/hive-mind/issues/1133
-      if (check.oneAtATime && check.totalProcessing > 0) {
-        const processInfo = check.claudeProcesses > 0 ? ` (${check.claudeProcesses} claude process${check.claudeProcesses > 1 ? 'es' : ''} running)` : '';
-        this.log(`One-at-a-time mode: waiting for current command to finish${processInfo}`);
-        await this.sleep(QUEUE_CONFIG.CONSUMER_POLL_INTERVAL_MS);
-        continue;
-      }
+      // Start items from each tool that can proceed
+      // This allows parallel starts from different tool queues
+      for (const startable of startableItems) {
+        const { tool } = startable;
+        const toolQueue = this.getToolQueue(tool);
 
-      // Get next item from queue
-      const item = this.queue.shift();
-      if (!item) continue;
+        // Remove the first item from this tool's queue
+        const item = toolQueue.shift();
+        if (!item) 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();
+        this.processing.set(item.id, item);
 
-      // Update status to Starting
-      item.setStarting();
-      this.processing.set(item.id, item);
-      this.lastStartTime = Date.now();
-      this.stats.totalStarted++;
+        // Update tool-specific last start time
+        this.lastStartTimeByTool[tool] = Date.now();
+        this.lastStartTime = Date.now(); // Legacy compatibility
+        this.stats.totalStarted++;
 
-      // Update message to show Starting status
-      await this.updateItemMessage(item, `🚀 Starting solve command...\n\n${item.infoBlock}`);
+        // Update message to show Starting status
+        await this.updateItemMessage(item, `🚀 Starting solve command...\n\n${item.infoBlock}`);
 
-      this.log(`Starting: ${item.toString()}`);
+        this.log(`Starting: ${item.toString()} from ${tool} queue`);
 
-      // Execute in background
-      this.executeItem(item).catch(error => {
-        console.error(`[solve-queue] Execution error for ${item.id}:`, error);
-      });
+        // Execute in background
+        this.executeItem(item).catch(error => {
+          console.error(`[solve-queue] Execution error for ${item.id}:`, error);
+        });
+      }
     }
 
     this.log('Consumer stopped');
     this.consumerTask = null;
   }
 
+  /**
+   * Update all waiting items with their tool-specific waiting reasons
+   * @see https://github.com/link-assistant/hive-mind/issues/1078
+   */
+  async updateAllWaitingItems() {
+    for (const [tool, toolQueue] of Object.entries(this.queues)) {
+      for (let i = 0; i < toolQueue.length; i++) {
+        const item = toolQueue[i];
+        if (item.status === QueueItemStatus.QUEUED || item.status === QueueItemStatus.WAITING) {
+          // Get the specific reason for this item's tool
+          const itemCheck = await this.canStartCommand({ tool: item.tool });
+          const previousStatus = item.status;
+          const previousReason = item.waitingReason;
+          item.setWaiting(itemCheck.reason || 'Waiting in queue');
+
+          // Update message if status/reason changed or it's time for periodic update
+          const shouldUpdate = previousStatus !== item.status || previousReason !== item.waitingReason || this.shouldUpdateMessage(item);
+
+          if (shouldUpdate) {
+            const position = i + 1; // Position within this tool's queue
+            await this.updateItemMessage(item, `⏳ Waiting (${tool} queue #${position})\n\n${item.infoBlock}\n\n*Reason:*\n${item.waitingReason}`);
+          }
+        }
+      }
+    }
+  }
+
   /**
    * Execute a queue item
    * @param {SolveQueueItem} item
@@ -870,26 +1079,47 @@ export class SolveQueue {
 
   /**
    * Format queue status for display
+   * Shows per-tool queue counts.
    * @returns {string}
+   * @see https://github.com/link-assistant/hive-mind/issues/1159
    */
   formatStatus() {
     const stats = this.getStats();
     if (stats.queued > 0 || stats.processing > 0) {
-      return `Solve Queue: ${stats.queued} pending, ${stats.processing} processing\n`;
+      // 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`;
     }
     return 'Solve Queue: empty\n';
   }
 
   /**
    * Format detailed queue status for Telegram message
+   * Shows per-tool queue breakdown.
    * @returns {string}
+   * @see https://github.com/link-assistant/hive-mind/issues/1159
    */
   formatDetailedStatus() {
     const stats = this.getStats();
     const summary = this.getQueueSummary();
 
     let message = '📋 *Solve Queue Status*\n\n';
-    message += `Pending: ${stats.queued}\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';
+
     message += `Processing: ${stats.processing}\n`;
     message += `Completed: ${stats.completed}\n`;
     message += `Failed: ${stats.failed}\n\n`;
@@ -897,7 +1127,7 @@ export class SolveQueue {
     if (summary.processing.length > 0) {
       message += '*Currently Processing:*\n';
       for (const item of summary.processing) {
-        message += `• ${item.url}\n`;
+        message += `• ${item.url} [${item.tool}]\n`;
       }
       message += '\n';
     }
@@ -906,7 +1136,7 @@ export class SolveQueue {
       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.status}, ${waitSeconds}s)\n`;
+        message += `• ${item.url} [${item.tool}] (${item.status}, ${waitSeconds}s)\n`;
         if (item.waitingReason) {
           message += `  └ ${item.waitingReason}\n`;
         }