@link-assistant/hive-mind 1.6.1 → 1.6.3

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # @link-assistant/hive-mind
 
+## 1.6.3
+
+### Patch Changes
+
+- Fix Anthropic cost extraction from JSON stream when session has error_during_execution
+  - Added anthropicTotalCostUSD to all failure return paths in executeClaudeCommand
+  - Changed cost capture logic to only extract from `subtype === 'success'` results
+  - This is explicit and reliable - error_during_execution results have zero cost
+  - Added case study documentation for issue #1104
+
+  Fixes #1104
+
+  Synchronize line count checks in CI/CD
+  - Add ESLint max-lines rule (1500 lines) to match CI workflow check
+  - Extract handleClaudeRuntimeSwitch to claude.runtime-switch.lib.mjs
+  - Reduce claude.lib.mjs from 1506 to 1354 lines
+  - Add case study documentation for issue #1141
+
+  Fixes #1141
+
+## 1.6.2
+
+### Patch Changes
+
+- 4ccbbd7: Fix CLAUDE_WEEKLY_THRESHOLD not enforcing one-at-a-time mode when external Claude processes are running
+  - Fixed oneAtATime mode to also consider externally running Claude processes (detected via pgrep), not just queue-internal processing
+  - Standardized all threshold comparisons to use >= (inclusive) instead of mixed > and >= operators
+  - Updated documentation comments to accurately reflect inclusive threshold behavior
+  - Added README recommendation to capture bot logs using tee for post-incident analysis
+  - Added case study documentation for issue #1133
+
 ## 1.6.1
 
 ### Patch Changes
@@ -461,7 +492,7 @@
   - `RAM_THRESHOLD: 0.5` - Stop new commands if RAM usage > 50%
   - `CPU_THRESHOLD: 0.5` - Stop new commands if CPU usage > 50%
   - `DISK_THRESHOLD: 0.95` - One-at-a-time mode if disk usage > 95%
-  - `CLAUDE_SESSION_THRESHOLD: 0.9` - Stop if Claude 5-hour limit > 90%
+  - `CLAUDE_5_HOUR_SESSION_THRESHOLD: 0.9` - Stop if Claude 5-hour limit > 90%
   - `CLAUDE_WEEKLY_THRESHOLD: 0.99` - One-at-a-time mode if weekly limit > 99%
   - `GITHUB_API_THRESHOLD: 0.8` - Stop if GitHub API > 80% with parallel claude commands
   - 1-minute minimum interval between command starts

package/README.md

@@ -409,10 +409,26 @@ Want to see the Hive Mind in action? Join our Telegram channel where you can exe
    ```
 
 3. **Start the Bot**
+
    ```bash
    hive-telegram-bot
    ```
 
+   **Recommended: Capture logs with tee**
+
+   When running the bot for extended periods, it's recommended to capture logs to a file using `tee`. This ensures you can review logs later even if the terminal buffer overflows:
+
+   ```bash
+   hive-telegram-bot 2>&1 | tee -a logs/bot-$(date +%Y%m%d).log
+   ```
+
+   Or create a logs directory and start with automatic log rotation:
+
+   ```bash
+   mkdir -p logs
+   hive-telegram-bot 2>&1 | tee -a "logs/bot-$(date +%Y%m%d-%H%M%S).log"
+   ```
+
 ### Bot Commands
 
 All commands work in **group chats only** (not in private messages with the bot):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.6.1",
+  "version": "1.6.3",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",
@@ -13,8 +13,9 @@
     "hive-telegram-bot": "./src/telegram-bot.mjs"
   },
   "scripts": {
-    "test": "node tests/solve-queue.test.mjs && node tests/test-usage-limit.mjs",
+    "test": "node tests/solve-queue.test.mjs && node tests/limits-display.test.mjs && node tests/test-usage-limit.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",
     "lint": "eslint 'src/**/*.{js,mjs,cjs}'",
     "lint:fix": "eslint 'src/**/*.{js,mjs,cjs}' --fix",

package/src/claude.lib.mjs

@@ -8,7 +8,7 @@ const { $ } = await use('command-stream');
 const fs = (await use('fs')).promises;
 const path = (await use('path')).default;
 // Import log from general lib
-import { log, cleanErrorMessage } from './lib.mjs';
+import { log } from './lib.mjs';
 import { reportError } from './sentry.lib.mjs';
 import { timeouts, retryLimits, claudeCode, getClaudeEnv } from './config.lib.mjs';
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
@@ -16,6 +16,8 @@ import { createInteractiveHandler } from './interactive-mode.lib.mjs';
 import { displayBudgetStats } from './claude.budget-stats.lib.mjs';
 // Import Claude command builder for generating resume commands
 import { buildClaudeResumeCommand } from './claude.command-builder.lib.mjs';
+// Import runtime switch module (extracted to maintain file line limits, see issue #1141)
+import { handleClaudeRuntimeSwitch } from './claude.runtime-switch.lib.mjs';
 
 // Helper to display resume command at end of session
 const showResumeCommand = async (sessionId, tempDir, claudePath, model, log) => {
@@ -214,163 +216,9 @@ export const validateClaudeConnection = async (model = 'haiku-3') => {
   // Start the validation with retry logic
   return await attemptValidation();
 };
-// Function to handle Claude runtime switching between Node.js and Bun
-export const handleClaudeRuntimeSwitch = async argv => {
-  if (argv['force-claude-bun-run']) {
-    await log('\n🔧 Switching Claude runtime to bun...');
-    try {
-      try {
-        await $`which bun`;
-        await log('   ✅ Bun runtime found');
-      } catch (bunError) {
-        reportError(bunError, {
-          context: 'claude.lib.mjs - bun availability check',
-          level: 'error',
-        });
-        await log('❌ Bun runtime not found. Please install bun first: https://bun.sh/', { level: 'error' });
-        process.exit(1);
-      }
-
-      // Find Claude executable path
-      const claudePathResult = await $`which claude`;
-      const claudePath = claudePathResult.stdout.toString().trim();
-
-      if (!claudePath) {
-        await log('❌ Claude executable not found', { level: 'error' });
-        process.exit(1);
-      }
-
-      await log(`   Claude path: ${claudePath}`);
-
-      try {
-        await fs.access(claudePath, fs.constants.W_OK);
-      } catch (accessError) {
-        reportError(accessError, {
-          context: 'claude.lib.mjs - Claude executable write permission check (bun)',
-          level: 'error',
-        });
-        await log('❌ Cannot write to Claude executable (permission denied)', { level: 'error' });
-        await log('   Try running with sudo or changing file permissions', { level: 'error' });
-        process.exit(1);
-      }
-      // Read current shebang
-      const firstLine = await $`head -1 "${claudePath}"`;
-      const currentShebang = firstLine.stdout.toString().trim();
-      await log(`   Current shebang: ${currentShebang}`);
-      if (currentShebang.includes('bun')) {
-        await log('   ✅ Claude is already configured to use bun');
-        process.exit(0);
-      }
-
-      // Create backup
-      const backupPath = `${claudePath}.nodejs-backup`;
-      await $`cp "${claudePath}" "${backupPath}"`;
-      await log(`   📦 Backup created: ${backupPath}`);
-
-      // Read file content and replace shebang
-      const content = await fs.readFile(claudePath, 'utf8');
-      const newContent = content.replace(/^#!.*node.*$/m, '#!/usr/bin/env bun');
-
-      if (content === newContent) {
-        await log('⚠️  No Node.js shebang found to replace', { level: 'warning' });
-        await log(`   Current shebang: ${currentShebang}`, { level: 'warning' });
-        process.exit(0);
-      }
-
-      await fs.writeFile(claudePath, newContent);
-      await log('   ✅ Claude shebang updated to use bun');
-      await log('   🔄 Claude will now run with bun runtime');
-    } catch (error) {
-      await log(`❌ Failed to switch Claude to bun: ${cleanErrorMessage(error)}`, { level: 'error' });
-      process.exit(1);
-    }
-
-    // Exit after switching runtime
-    process.exit(0);
-  }
-
-  if (argv['force-claude-nodejs-run']) {
-    await log('\n🔧 Restoring Claude runtime to Node.js...');
-    try {
-      try {
-        await $`which node`;
-        await log('   ✅ Node.js runtime found');
-      } catch (nodeError) {
-        reportError(nodeError, {
-          context: 'claude.lib.mjs - Node.js availability check',
-          level: 'error',
-        });
-        await log('❌ Node.js runtime not found. Please install Node.js first', { level: 'error' });
-        process.exit(1);
-      }
-
-      // Find Claude executable path
-      const claudePathResult = await $`which claude`;
-      const claudePath = claudePathResult.stdout.toString().trim();
-
-      if (!claudePath) {
-        await log('❌ Claude executable not found', { level: 'error' });
-        process.exit(1);
-      }
-
-      await log(`   Claude path: ${claudePath}`);
-
-      try {
-        await fs.access(claudePath, fs.constants.W_OK);
-      } catch (accessError) {
-        reportError(accessError, {
-          context: 'claude.lib.mjs - Claude executable write permission check (nodejs)',
-          level: 'error',
-        });
-        await log('❌ Cannot write to Claude executable (permission denied)', { level: 'error' });
-        await log('   Try running with sudo or changing file permissions', { level: 'error' });
-        process.exit(1);
-      }
-      // Read current shebang
-      const firstLine = await $`head -1 "${claudePath}"`;
-      const currentShebang = firstLine.stdout.toString().trim();
-      await log(`   Current shebang: ${currentShebang}`);
-      if (currentShebang.includes('node') && !currentShebang.includes('bun')) {
-        await log('   ✅ Claude is already configured to use Node.js');
-        process.exit(0);
-      }
-
-      const backupPath = `${claudePath}.nodejs-backup`;
-      try {
-        await fs.access(backupPath);
-        // Restore from backup
-        await $`cp "${backupPath}" "${claudePath}"`;
-        await log(`   ✅ Restored Claude from backup: ${backupPath}`);
-      } catch (backupError) {
-        reportError(backupError, {
-          context: 'claude_restore_backup',
-          level: 'info',
-        });
-        // No backup available, manually update shebang
-        await log('   📝 No backup found, manually updating shebang...');
-        const content = await fs.readFile(claudePath, 'utf8');
-        const newContent = content.replace(/^#!.*bun.*$/m, '#!/usr/bin/env node');
-
-        if (content === newContent) {
-          await log('⚠️  No bun shebang found to replace', { level: 'warning' });
-          await log(`   Current shebang: ${currentShebang}`, { level: 'warning' });
-          process.exit(0);
-        }
-
-        await fs.writeFile(claudePath, newContent);
-        await log('   ✅ Claude shebang updated to use Node.js');
-      }
-
-      await log('   🔄 Claude will now run with Node.js runtime');
-    } catch (error) {
-      await log(`❌ Failed to restore Claude to Node.js: ${cleanErrorMessage(error)}`, { level: 'error' });
-      process.exit(1);
-    }
-
-    // Exit after restoring runtime
-    process.exit(0);
-  }
-};
+// handleClaudeRuntimeSwitch is imported from ./claude.runtime-switch.lib.mjs (see issue #1141)
+// Re-export it for backwards compatibility
+export { handleClaudeRuntimeSwitch };
 /**
  * Check if Playwright MCP is available and connected to Claude
  * @returns {Promise<boolean>} True if Playwright MCP is available, false otherwise
@@ -1038,9 +886,13 @@ export const executeClaudeCommand = async params => {
               // Handle session result type from Claude CLI (emitted when session completes)
               // Subtypes: "success", "error_during_execution" (work may have been done), etc.
               if (data.type === 'result') {
-                if (data.total_cost_usd !== undefined && data.total_cost_usd !== null) {
+                // Issue #1104: Only extract cost from subtype 'success' results
+                // This is explicit and reliable - error_during_execution results have zero cost
+                if (data.subtype === 'success' && data.total_cost_usd !== undefined && data.total_cost_usd !== null) {
                   anthropicTotalCostUSD = data.total_cost_usd;
-                  await log(`💰 Anthropic official cost captured: $${anthropicTotalCostUSD.toFixed(6)}`, { verbose: true });
+                  await log(`💰 Anthropic official cost captured from success result: $${anthropicTotalCostUSD.toFixed(6)}`, { verbose: true });
+                } else if (data.total_cost_usd !== undefined && data.total_cost_usd !== null) {
+                  await log(`💰 Anthropic cost from ${data.subtype || 'unknown'} result ignored: $${data.total_cost_usd.toFixed(6)}`, { verbose: true });
                 }
                 if (data.is_error === true) {
                   lastMessage = data.result || JSON.stringify(data);
@@ -1170,6 +1022,7 @@ export const executeClaudeCommand = async params => {
             limitTimezone: null,
             messageCount,
             toolUseCount,
+            anthropicTotalCostUSD, // Issue #1104: Include cost even on failure
           };
         }
       }
@@ -1218,6 +1071,7 @@ export const executeClaudeCommand = async params => {
             messageCount,
             toolUseCount,
             is503Error: true,
+            anthropicTotalCostUSD, // Issue #1104: Include cost even on failure
           };
         }
       }
@@ -1296,6 +1150,7 @@ export const executeClaudeCommand = async params => {
           messageCount,
           toolUseCount,
           errorDuringExecution,
+          anthropicTotalCostUSD, // Issue #1104: Include cost even on failure
         };
       }
       // Issue #1088: If error_during_execution occurred but command didn't fail,
@@ -1414,6 +1269,7 @@ export const executeClaudeCommand = async params => {
         limitTimezone: null,
         messageCount,
         toolUseCount,
+        anthropicTotalCostUSD, // Issue #1104: Include cost even on failure
       };
     }
   }; // End of executeWithRetry function

package/src/claude.runtime-switch.lib.mjs

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+// Claude runtime switching module
+// Extracted from claude.lib.mjs to maintain file line limits
+// See: docs/case-studies/issue-1141
+
+// If not, fetch it (when running standalone)
+if (typeof globalThis.use === 'undefined') {
+  globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
+}
+const { $ } = await use('command-stream');
+const fs = (await use('fs')).promises;
+import { log, cleanErrorMessage } from './lib.mjs';
+import { reportError } from './sentry.lib.mjs';
+
+// Function to handle Claude runtime switching between Node.js and Bun
+export const handleClaudeRuntimeSwitch = async argv => {
+  if (argv['force-claude-bun-run']) {
+    await log('\n🔧 Switching Claude runtime to bun...');
+    try {
+      try {
+        await $`which bun`;
+        await log('   ✅ Bun runtime found');
+      } catch (bunError) {
+        reportError(bunError, {
+          context: 'claude.runtime-switch.lib.mjs - bun availability check',
+          level: 'error',
+        });
+        await log('❌ Bun runtime not found. Please install bun first: https://bun.sh/', { level: 'error' });
+        process.exit(1);
+      }
+
+      // Find Claude executable path
+      const claudePathResult = await $`which claude`;
+      const claudePath = claudePathResult.stdout.toString().trim();
+
+      if (!claudePath) {
+        await log('❌ Claude executable not found', { level: 'error' });
+        process.exit(1);
+      }
+
+      await log(`   Claude path: ${claudePath}`);
+
+      try {
+        await fs.access(claudePath, fs.constants.W_OK);
+      } catch (accessError) {
+        reportError(accessError, {
+          context: 'claude.runtime-switch.lib.mjs - Claude executable write permission check (bun)',
+          level: 'error',
+        });
+        await log('❌ Cannot write to Claude executable (permission denied)', { level: 'error' });
+        await log('   Try running with sudo or changing file permissions', { level: 'error' });
+        process.exit(1);
+      }
+      // Read current shebang
+      const firstLine = await $`head -1 "${claudePath}"`;
+      const currentShebang = firstLine.stdout.toString().trim();
+      await log(`   Current shebang: ${currentShebang}`);
+      if (currentShebang.includes('bun')) {
+        await log('   ✅ Claude is already configured to use bun');
+        process.exit(0);
+      }
+
+      // Create backup
+      const backupPath = `${claudePath}.nodejs-backup`;
+      await $`cp "${claudePath}" "${backupPath}"`;
+      await log(`   📦 Backup created: ${backupPath}`);
+
+      // Read file content and replace shebang
+      const content = await fs.readFile(claudePath, 'utf8');
+      const newContent = content.replace(/^#!.*node.*$/m, '#!/usr/bin/env bun');
+
+      if (content === newContent) {
+        await log('⚠️  No Node.js shebang found to replace', { level: 'warning' });
+        await log(`   Current shebang: ${currentShebang}`, { level: 'warning' });
+        process.exit(0);
+      }
+
+      await fs.writeFile(claudePath, newContent);
+      await log('   ✅ Claude shebang updated to use bun');
+      await log('   🔄 Claude will now run with bun runtime');
+    } catch (error) {
+      await log(`❌ Failed to switch Claude to bun: ${cleanErrorMessage(error)}`, { level: 'error' });
+      process.exit(1);
+    }
+
+    // Exit after switching runtime
+    process.exit(0);
+  }
+
+  if (argv['force-claude-nodejs-run']) {
+    await log('\n🔧 Restoring Claude runtime to Node.js...');
+    try {
+      try {
+        await $`which node`;
+        await log('   ✅ Node.js runtime found');
+      } catch (nodeError) {
+        reportError(nodeError, {
+          context: 'claude.runtime-switch.lib.mjs - Node.js availability check',
+          level: 'error',
+        });
+        await log('❌ Node.js runtime not found. Please install Node.js first', { level: 'error' });
+        process.exit(1);
+      }
+
+      // Find Claude executable path
+      const claudePathResult = await $`which claude`;
+      const claudePath = claudePathResult.stdout.toString().trim();
+
+      if (!claudePath) {
+        await log('❌ Claude executable not found', { level: 'error' });
+        process.exit(1);
+      }
+
+      await log(`   Claude path: ${claudePath}`);
+
+      try {
+        await fs.access(claudePath, fs.constants.W_OK);
+      } catch (accessError) {
+        reportError(accessError, {
+          context: 'claude.runtime-switch.lib.mjs - Claude executable write permission check (nodejs)',
+          level: 'error',
+        });
+        await log('❌ Cannot write to Claude executable (permission denied)', { level: 'error' });
+        await log('   Try running with sudo or changing file permissions', { level: 'error' });
+        process.exit(1);
+      }
+      // Read current shebang
+      const firstLine = await $`head -1 "${claudePath}"`;
+      const currentShebang = firstLine.stdout.toString().trim();
+      await log(`   Current shebang: ${currentShebang}`);
+      if (currentShebang.includes('node') && !currentShebang.includes('bun')) {
+        await log('   ✅ Claude is already configured to use Node.js');
+        process.exit(0);
+      }
+
+      const backupPath = `${claudePath}.nodejs-backup`;
+      try {
+        await fs.access(backupPath);
+        // Restore from backup
+        await $`cp "${backupPath}" "${claudePath}"`;
+        await log(`   ✅ Restored Claude from backup: ${backupPath}`);
+      } catch (backupError) {
+        reportError(backupError, {
+          context: 'claude_restore_backup',
+          level: 'info',
+        });
+        // No backup available, manually update shebang
+        await log('   📝 No backup found, manually updating shebang...');
+        const content = await fs.readFile(claudePath, 'utf8');
+        const newContent = content.replace(/^#!.*bun.*$/m, '#!/usr/bin/env node');
+
+        if (content === newContent) {
+          await log('⚠️  No bun shebang found to replace', { level: 'warning' });
+          await log(`   Current shebang: ${currentShebang}`, { level: 'warning' });
+          process.exit(0);
+        }
+
+        await fs.writeFile(claudePath, newContent);
+        await log('   ✅ Claude shebang updated to use Node.js');
+      }
+
+      await log('   🔄 Claude will now run with Node.js runtime');
+    } catch (error) {
+      await log(`❌ Failed to restore Claude to Node.js: ${cleanErrorMessage(error)}`, { level: 'error' });
+      process.exit(1);
+    }
+
+    // Exit after restoring runtime
+    process.exit(0);
+  }
+};
+
+export default {
+  handleClaudeRuntimeSwitch,
+};

package/src/limits.lib.mjs

@@ -720,8 +720,8 @@ export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = nu
     message += '\n';
   }
 
-  // Current session (five_hour)
-  message += 'Current session\n';
+  // Claude 5 hour session (five_hour)
+  message += 'Claude 5 hour session\n';
   if (usage.currentSession.percentage !== null) {
     // Add time passed progress bar first
     const timePassed = calculateTimePassedPercentage(usage.currentSession.resetsAt, 5);
@@ -731,7 +731,9 @@ export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = nu
     }
 
     // Add usage progress bar second
-    const pct = usage.currentSession.percentage;
+    // Use Math.floor so 100% only appears when usage is exactly 100%
+    // See: https://github.com/link-assistant/hive-mind/issues/1133
+    const pct = Math.floor(usage.currentSession.percentage);
     const bar = getProgressBar(pct);
     message += `${bar} ${pct}% used\n`;
 
@@ -759,7 +761,9 @@ export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = nu
     }
 
     // Add usage progress bar second
-    const pct = usage.allModels.percentage;
+    // Use Math.floor so 100% only appears when usage is exactly 100%
+    // See: https://github.com/link-assistant/hive-mind/issues/1133
+    const pct = Math.floor(usage.allModels.percentage);
     const bar = getProgressBar(pct);
     message += `${bar} ${pct}% used\n`;
 
@@ -787,7 +791,9 @@ export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = nu
     }
 
     // Add usage progress bar second
-    const pct = usage.sonnetOnly.percentage;
+    // Use Math.floor so 100% only appears when usage is exactly 100%
+    // See: https://github.com/link-assistant/hive-mind/issues/1133
+    const pct = Math.floor(usage.sonnetOnly.percentage);
     const bar = getProgressBar(pct);
     message += `${bar} ${pct}% used\n`;
 

package/src/telegram-bot.mjs

@@ -858,9 +858,13 @@ bot.command('limits', async ctx => {
   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;
   const codeBlockEnd = message.lastIndexOf('```');
   if (codeBlockEnd !== -1) {
-    const queueStatus = queueStats.queued > 0 || queueStats.processing > 0 ? `Pending: ${queueStats.queued}, Processing: ${queueStats.processing}` : 'Empty (no pending commands)';
+    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);
   }
   await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, message, { parse_mode: 'Markdown' });

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

@@ -33,15 +33,17 @@ import { getCachedClaudeLimits, getCachedGitHubLimits, getCachedMemoryInfo, getC
  */
 export const QUEUE_CONFIG = {
   // Resource thresholds (usage ratios: 0.0 - 1.0)
-  RAM_THRESHOLD: 0.5, // Stop if RAM usage > 50%
+  // All thresholds use >= comparison (inclusive)
+  RAM_THRESHOLD: 0.5, // Stop if RAM 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%
+  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)
-  CLAUDE_SESSION_THRESHOLD: 0.9, // Stop if 5-hour limit > 90%
-  CLAUDE_WEEKLY_THRESHOLD: 0.99, // One-at-a-time if weekly limit > 99%
-  GITHUB_API_THRESHOLD: 0.8, // Stop if GitHub > 80% with parallel claude
+  // All thresholds use >= comparison (inclusive)
+  CLAUDE_5_HOUR_SESSION_THRESHOLD: 0.9, // Stop if 5-hour limit >= 90%
+  CLAUDE_WEEKLY_THRESHOLD: 0.99, // One-at-a-time if weekly limit >= 99%
+  GITHUB_API_THRESHOLD: 0.8, // Stop if GitHub >= 80% with parallel claude
 
   // Timing
   // MIN_START_INTERVAL_MS: Time to allow solve command to start actual claude process
@@ -135,8 +137,8 @@ function formatWaitingReason(metric, currentValue, threshold) {
       return `CPU usage is ${currentPercent}% (threshold: ${thresholdPercent})`;
     case 'disk':
       return `Disk usage is ${currentPercent}% (threshold: ${thresholdPercent})`;
-    case 'claude_session':
-      return `Claude session limit is ${currentPercent}% (threshold: ${thresholdPercent})`;
+    case 'claude_5_hour_session':
+      return `Claude 5 hour session limit is ${currentPercent}% (threshold: ${thresholdPercent})`;
     case 'claude_weekly':
       return `Claude weekly limit is ${currentPercent}% (threshold: ${thresholdPercent})`;
     case 'github':
@@ -394,22 +396,25 @@ 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
+    const totalProcessing = this.processing.size + claudeProcs.count;
+
     // Track claude_running as a metric (but don't add to reasons yet)
     if (hasRunningClaude) {
       this.recordThrottle('claude_running');
     }
 
-    // Check system resources
+    // Check system resources (ultimate restrictions - block unconditionally)
     const resourceCheck = await this.checkSystemResources();
     if (!resourceCheck.ok) {
       reasons.push(...resourceCheck.reasons);
     }
-    if (resourceCheck.oneAtATime) {
-      oneAtATime = true;
-    }
 
-    // Check API limits (pass hasRunningClaude to enable special handling)
-    const limitCheck = await this.checkApiLimits(hasRunningClaude);
+    // Check API limits (pass hasRunningClaude and totalProcessing for uniform checking)
+    const limitCheck = await this.checkApiLimits(hasRunningClaude, totalProcessing);
     if (!limitCheck.ok) {
       reasons.push(...limitCheck.reasons);
     }
@@ -438,6 +443,7 @@ export class SolveQueue {
       reasons,
       oneAtATime,
       claudeProcesses: claudeProcs.count,
+      totalProcessing,
     };
   }
 
@@ -448,17 +454,21 @@ export class SolveQueue {
    * 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}>}
+   * Note: System resource thresholds are ultimate restrictions - they block unconditionally
+   * when triggered. Unlike Claude API thresholds which allow one command at a time via
+   * totalProcessing check, system resources block all new commands immediately.
+   * See: https://github.com/link-assistant/hive-mind/issues/1133
+   *
+   * @returns {Promise<{ok: boolean, reasons: string[]}>}
    */
   async checkSystemResources() {
     const reasons = [];
-    let oneAtATime = false;
 
     // Check RAM (using cached value)
     const memResult = await getCachedMemoryInfo(this.verbose);
     if (memResult.success) {
       const usedRatio = memResult.memory.usedPercentage / 100;
-      if (usedRatio > QUEUE_CONFIG.RAM_THRESHOLD) {
+      if (usedRatio >= QUEUE_CONFIG.RAM_THRESHOLD) {
         reasons.push(formatWaitingReason('ram', memResult.memory.usedPercentage, QUEUE_CONFIG.RAM_THRESHOLD));
         this.recordThrottle('ram_high');
       }
@@ -481,42 +491,45 @@ export class SolveQueue {
         this.log(`CPU 5m load avg: ${loadAvg5.toFixed(2)}, cpus: ${cpuCount}, usage: ${usagePercent}%`);
       }
 
-      if (usageRatio > QUEUE_CONFIG.CPU_THRESHOLD) {
+      if (usageRatio >= QUEUE_CONFIG.CPU_THRESHOLD) {
         reasons.push(formatWaitingReason('cpu', usagePercent, QUEUE_CONFIG.CPU_THRESHOLD));
         this.recordThrottle('cpu_high');
       }
     }
 
     // Check disk space (using cached value)
+    // Note: Disk threshold is an ultimate restriction - it blocks unconditionally when triggered
+    // Unlike CLAUDE_5_HOUR_SESSION_THRESHOLD and CLAUDE_WEEKLY_THRESHOLD which use totalProcessing
+    // to allow one command at a time, disk threshold blocks all new commands immediately
+    // See: https://github.com/link-assistant/hive-mind/issues/1133
     const diskResult = await getCachedDiskInfo(this.verbose);
     if (diskResult.success) {
       // Calculate usage from free percentage
       const usedPercent = 100 - diskResult.diskSpace.freePercentage;
       const usedRatio = usedPercent / 100;
-      if (usedRatio > QUEUE_CONFIG.DISK_THRESHOLD) {
-        oneAtATime = true;
+      if (usedRatio >= QUEUE_CONFIG.DISK_THRESHOLD) {
+        reasons.push(formatWaitingReason('disk', usedPercent, QUEUE_CONFIG.DISK_THRESHOLD));
         this.recordThrottle('disk_high');
-        if (this.processing.size > 0) {
-          reasons.push(formatWaitingReason('disk', usedPercent, QUEUE_CONFIG.DISK_THRESHOLD) + ' (waiting for current command)');
-        }
       }
     }
 
-    return { ok: reasons.length === 0, reasons, oneAtATime };
+    return { ok: reasons.length === 0, reasons };
   }
 
   /**
    * Check API limits (Claude, GitHub) using cached values
    *
-   * Simplified logic per issue #1061:
-   * - When any limit >= threshold, allow exactly one claude command to pass
-   * - Only block if there's already a command in progress
-   * - Running claude is the ultimate test of whether limits are really exhausted
+   * 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
+   * - 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)
    * @returns {Promise<{ok: boolean, reasons: string[], oneAtATime: boolean}>}
    */
-  async checkApiLimits(hasRunningClaude = false) {
+  async checkApiLimits(hasRunningClaude = false, totalProcessing = 0) {
     const reasons = [];
     let oneAtATime = false;
 
@@ -527,15 +540,18 @@ export class SolveQueue {
       const weeklyPercent = claudeResult.usage.allModels.percentage;
 
       // Session limit (5-hour)
-      // When above threshold: allow exactly one command, block if one is running
+      // 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_SESSION_THRESHOLD) {
-          // Only block if Claude is already running
-          if (hasRunningClaude) {
-            reasons.push(formatWaitingReason('claude_session', sessionPercent, QUEUE_CONFIG.CLAUDE_SESSION_THRESHOLD));
+        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)');
           }
-          this.recordThrottle(sessionRatio >= 1.0 ? 'claude_session_100' : 'claude_session_high');
         }
       }
 
@@ -546,8 +562,9 @@ export class SolveQueue {
         if (weeklyRatio >= QUEUE_CONFIG.CLAUDE_WEEKLY_THRESHOLD) {
           oneAtATime = true;
           this.recordThrottle(weeklyRatio >= 1.0 ? 'claude_weekly_100' : 'claude_weekly_high');
-          // Only block if command is already in progress
-          if (this.processing.size > 0) {
+          // 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)');
           }
         }
@@ -664,8 +681,13 @@ export class SolveQueue {
       }
 
       // Check one-at-a-time mode
-      if (check.oneAtATime && this.processing.size > 0) {
-        this.log('One-at-a-time mode: waiting for current command to finish');
+      // 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;
       }