@link-assistant/hive-mind 1.50.8 → 1.50.10

package/src/solve.results.lib.mjs

@@ -37,6 +37,41 @@ const { autoContinueWhenLimitResets } = autoContinue;
 const claudeCommandBuilder = await import('./claude.command-builder.lib.mjs');
 export const { buildClaudeResumeCommand, buildClaudeInitialCommand } = claudeCommandBuilder;
 
+/**
+ * Build a solve.mjs resume command for tools that do not have a first-party interactive
+ * resume CLI flow like Claude Code. This keeps the invocation within hive-mind so the
+ * original tool selection and working directory can be preserved.
+ *
+ * @param {Object} options
+ * @param {string} options.issueUrl - The issue URL passed to solve.mjs
+ * @param {string} options.sessionId - The session ID to resume
+ * @param {string|null} [options.tool] - Tool name (codex, opencode, agent)
+ * @param {string|null} [options.model] - Model name to preserve
+ * @param {string|null} [options.tempDir] - Working directory to preserve
+ * @param {string} [options.nodePath] - Node binary path
+ * @param {string} [options.scriptPath] - solve.mjs path
+ * @returns {string}
+ */
+export const buildSolveResumeCommand = ({ issueUrl, sessionId, tool = null, model = null, tempDir = null, nodePath = process.argv[0], scriptPath = process.argv[1] }) => {
+  const shellQuote = value => `"${String(value).replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+
+  const args = [shellQuote(scriptPath), shellQuote(issueUrl), '--resume', shellQuote(sessionId)];
+
+  if (tool && tool !== 'claude') {
+    args.push('--tool', shellQuote(tool));
+  }
+
+  if (model) {
+    args.push('--model', shellQuote(model));
+  }
+
+  if (tempDir) {
+    args.push('--working-directory', shellQuote(tempDir));
+  }
+
+  return `${shellQuote(nodePath)} ${args.join(' ')}`;
+};
+
 // Import error handling functions
 // const errorHandlers = await import('./solve.error-handlers.lib.mjs'); // Not currently used
 // Import Sentry integration
@@ -444,12 +479,8 @@ export const showSessionSummary = async (sessionId, limitReached, argv, issueUrl
     const absoluteLogPath = path.resolve(getLogFile());
     await log(`✅ Complete log file: ${absoluteLogPath}`);
 
-    // Show claude resume command only for --tool claude (or default)
-    // This allows users to investigate, resume, see context, and more
-    // Uses the (cd ... && claude --resume ...) pattern for a fully copyable, executable command
     const tool = argv.tool || 'claude';
     if (tool === 'claude') {
-      // Build the Claude CLI resume command using the command builder
       const claudeResumeCmd = buildClaudeResumeCommand({ tempDir, sessionId, model: argv.model });
 
       await log('');
@@ -457,6 +488,13 @@ export const showSessionSummary = async (sessionId, limitReached, argv, issueUrl
       await log('');
       await log(`   ${claudeResumeCmd}`);
       await log('');
+    } else if (issueUrl) {
+      const solveResumeCmd = buildSolveResumeCommand({ issueUrl, sessionId, tool, model: argv.model, tempDir });
+      await log('');
+      await log(`💡 To continue this ${tool} session with solve:`);
+      await log('');
+      await log(`   ${solveResumeCmd}`);
+      await log('');
     }
 
     if (limitReached) {
@@ -472,7 +510,7 @@ export const showSessionSummary = async (sessionId, limitReached, argv, issueUrl
           await log(`\n⏰ Limit resets at: ${global.limitResetTime}`);
         }
 
-        await log('\n💡 After the limit resets, resume using the Claude command above.');
+        await log('\n💡 After the limit resets, resume using the command above.');
 
         if (argv.autoCleanup !== false) {
           await log('');

package/src/solve.validation.lib.mjs

@@ -306,7 +306,7 @@ export const performSystemChecks = async (minDiskSpace = 2048, skipToolConnectio
     } else if (argv.tool === 'codex') {
       // Validate Codex connection
       const codexLib = await import('./codex.lib.mjs');
-      isToolConnected = await codexLib.validateCodexConnection(model);
+      isToolConnected = await codexLib.validateCodexConnection(model, argv.verbose);
       if (!isToolConnected) {
         await log('❌ Cannot proceed without Codex connection', { level: 'error' });
         return false;

package/src/telegram-bot.mjs

@@ -41,7 +41,7 @@ const { parseGitHubUrl, validateGitHubEntityExistence } = await import('./github
 const { validateModelName, buildModelOptionDescription } = await import('./models/index.mjs');
 const { validateBranchInArgs } = await import('./solve.branch.lib.mjs');
 const { extractIsolationFromArgs, isValidPerCommandIsolation, resolveIsolation, createIsolationAwareQueueCallback } = await import('./telegram-isolation.lib.mjs');
-const { formatUsageMessage, getAllCachedLimits } = await import('./limits.lib.mjs');
+const { formatUsageMessage, formatCodexLimitsSection, 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, createQueueExecuteCallback } = await import('./telegram-solve-queue.lib.mjs');
@@ -758,9 +758,11 @@ bot.command('limits', async ctx => {
 
   // Format message with usage limits and queue status (issues #1343, #1267)
   const claudeError = limits.claude.success ? null : limits.claude.error;
+  const codexError = limits.codex.success ? null : limits.codex.error;
   const solveQueue = getSolveQueue({ verbose: VERBOSE });
   const queueStatus = await solveQueue.formatStatus();
-  const message = '📊 *Usage Limits*\n\n' + formatUsageMessage(limits.claude.success ? limits.claude.usage : null, 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, claudeError, [queueStatus]);
+  const codexSection = formatCodexLimitsSection(limits.codex.success ? limits.codex : null, codexError);
+  const message = '📊 *Usage Limits*\n\n' + formatUsageMessage(limits.claude.success ? limits.claude.usage : null, 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, claudeError, [codexSection, queueStatus]);
   await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, message, { parse_mode: 'Markdown' });
 });
 bot.command('version', async ctx => {

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

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execAsync = promisify(exec);
+
+/**
+ * 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 getRunningProcesses(processName, verbose = false) {
+  try {
+    const { stdout } = await execAsync(`pgrep -l -x ${processName} 2>/dev/null || true`);
+    const lines = stdout
+      .trim()
+      .split('\n')
+      .filter(line => line.trim());
+
+    const processes = lines
+      .map(line => {
+        const parts = line.trim().split(/\s+/);
+        return {
+          pid: parts[0],
+          name: parts.slice(1).join(' ') || processName,
+        };
+      })
+      .filter(p => p.pid);
+
+    if (verbose) {
+      console.log(`[VERBOSE] /solve_queue found ${processes.length} running ${processName} processes`);
+      if (processes.length > 0) {
+        console.log(`[VERBOSE] /solve_queue processes: ${JSON.stringify(processes)}`);
+      }
+    }
+
+    return {
+      count: processes.length,
+      processes: processes.map(p => `${p.pid}:${p.name}`),
+    };
+  } catch (error) {
+    if (verbose) {
+      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);
+}
+
+/**
+ * Count running codex processes.
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{count: number, processes: string[]}>}
+ */
+export async function getRunningCodexProcesses(verbose = false) {
+  return getRunningProcesses('codex', verbose);
+}
+
+/**
+ * Format a threshold as percentage for display.
+ * @param {number} ratio - Ratio (0.0 - 1.0)
+ * @returns {string} Formatted percentage
+ */
+export 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.)
+ * @param {number} currentValue - Current value (as percentage 0-100)
+ * @param {number} threshold - Threshold ratio (0.0 - 1.0)
+ * @returns {string} Human-readable reason
+ */
+export function formatWaitingReason(metric, currentValue, threshold) {
+  const thresholdPercent = formatThresholdPercent(threshold);
+  const currentPercent = Math.round(currentValue);
+
+  switch (metric) {
+    case 'ram':
+      return `RAM usage is ${currentPercent}% (threshold: ${thresholdPercent})`;
+    case 'cpu':
+      return `CPU usage is ${currentPercent}% (threshold: ${thresholdPercent})`;
+    case 'disk':
+      return `Disk usage 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 'codex_5_hour_session':
+      return `Codex 5 hour session limit is ${currentPercent}% (threshold: ${thresholdPercent})`;
+    case 'codex_weekly':
+      return `Codex weekly limit is ${currentPercent}% (threshold: ${thresholdPercent})`;
+    case 'github':
+      return `GitHub API usage is ${currentPercent}% (threshold: ${thresholdPercent})`;
+    case 'min_interval':
+      return 'Minimum interval between commands not reached';
+    case 'claude_running':
+      return 'Claude process is already running';
+    case 'codex_running':
+      return 'Codex process is already running';
+    default:
+      return `${metric} threshold exceeded`;
+  }
+}

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

@@ -15,24 +15,12 @@
  * @see https://github.com/link-assistant/hive-mind/issues/1041
  */
 
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
-
-const execAsync = promisify(exec);
-
-// Import centralized limits and caching
-import { getCachedClaudeLimits, getCachedGitHubLimits, getCachedMemoryInfo, getCachedCpuInfo, getCachedDiskInfo, getLimitCache } from './limits.lib.mjs';
-
-// Import centralized queue configuration
-// This ensures thresholds are consistent between queue logic and display formatting
-// See: https://github.com/link-assistant/hive-mind/issues/1242
-// See: https://github.com/link-assistant/hive-mind/issues/1253 (configurable strategies)
+import { getCachedClaudeLimits, getCachedCodexLimits, getCachedGitHubLimits, getCachedMemoryInfo, getCachedCpuInfo, getCachedDiskInfo, getLimitCache } from './limits.lib.mjs';
+export { formatDuration, getRunningAgentProcesses, getRunningClaudeProcesses, getRunningCodexProcesses, getRunningProcesses } from './telegram-solve-queue.helpers.lib.mjs';
+import { formatDuration, formatWaitingReason, getRunningAgentProcesses, getRunningClaudeProcesses, getRunningCodexProcesses, getRunningProcesses } from './telegram-solve-queue.helpers.lib.mjs';
 export { QUEUE_CONFIG, THRESHOLD_STRATEGIES } from './queue-config.lib.mjs';
 import { QUEUE_CONFIG } from './queue-config.lib.mjs';
 
-/**
- * Status enum for queue items
- */
 export const QueueItemStatus = {
   QUEUED: 'queued',
   WAITING: 'waiting',
@@ -42,136 +30,6 @@ export const QueueItemStatus = {
   CANCELLED: 'cancelled',
 };
 
-/**
- * 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 getRunningProcesses(processName, verbose = false) {
-  try {
-    const { stdout } = await execAsync(`pgrep -l -x ${processName} 2>/dev/null || true`);
-    const lines = stdout
-      .trim()
-      .split('\n')
-      .filter(line => line.trim());
-
-    const processes = lines
-      .map(line => {
-        const parts = line.trim().split(/\s+/);
-        return {
-          pid: parts[0],
-          name: parts.slice(1).join(' ') || processName,
-        };
-      })
-      .filter(p => p.pid);
-
-    if (verbose) {
-      console.log(`[VERBOSE] /solve_queue found ${processes.length} running ${processName} processes`);
-      if (processes.length > 0) {
-        console.log(`[VERBOSE] /solve_queue processes: ${JSON.stringify(processes)}`);
-      }
-    }
-
-    return {
-      count: processes.length,
-      processes: processes.map(p => `${p.pid}:${p.name}`),
-    };
-  } catch (error) {
-    if (verbose) {
-      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)
- * @returns {string} Formatted percentage
- */
-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.)
- * @param {number} currentValue - Current value (as percentage 0-100)
- * @param {number} threshold - Threshold ratio (0.0 - 1.0)
- * @returns {string} Human-readable reason
- */
-function formatWaitingReason(metric, currentValue, threshold) {
-  const thresholdPercent = formatThresholdPercent(threshold);
-  const currentPercent = Math.round(currentValue);
-
-  switch (metric) {
-    case 'ram':
-      return `RAM usage is ${currentPercent}% (threshold: ${thresholdPercent})`;
-    case 'cpu':
-      return `CPU usage is ${currentPercent}% (threshold: ${thresholdPercent})`;
-    case 'disk':
-      return `Disk usage 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':
-      return `GitHub API usage is ${currentPercent}% (threshold: ${thresholdPercent})`;
-    case 'min_interval':
-      return `Minimum interval between commands not reached`;
-    case 'claude_running':
-      return `Claude process is already running`;
-    default:
-      return `${metric} threshold exceeded`;
-  }
-}
-
 /**
  * Queue item representing a /solve command request
  */
@@ -281,6 +139,7 @@ export class SolveQueue {
     this.queues = {
       claude: [],
       agent: [],
+      codex: [],
     };
     this.processing = new Map();
     this.completed = [];
@@ -291,6 +150,7 @@ export class SolveQueue {
     this.lastStartTimeByTool = {
       claude: null,
       agent: null,
+      codex: null,
     };
     // Legacy: keep for compatibility with existing code that uses lastStartTime
     this.lastStartTime = null;
@@ -647,22 +507,29 @@ export class SolveQueue {
 
     // Check running claude processes (this is a metric, not a blocking reason by itself)
     const claudeProcs = await getRunningClaudeProcesses(this.verbose);
+    const codexProcs = await getRunningCodexProcesses(this.verbose);
+    const agentProcs = await getRunningAgentProcesses(this.verbose);
     const hasRunningClaude = claudeProcs.count > 0;
+    const hasRunningCodex = codexProcs.count > 0;
 
     // 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;
+    const totalProcessing = this.processing.size + claudeProcs.count + codexProcs.count + agentProcs.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');
+    const codexProcessingCount = this.getProcessingCountByTool('codex');
 
     // Track claude_running as a metric (but don't add to reasons yet)
     if (hasRunningClaude) {
       this.recordThrottle('claude_running');
     }
+    if (hasRunningCodex) {
+      this.recordThrottle('codex_running');
+    }
 
     // Check system resources with strategy support
     // System resources apply to ALL tools, not just Claude
@@ -685,7 +552,9 @@ export class SolveQueue {
     // This allows agent tasks to proceed when Claude limits are reached
     // See: https://github.com/link-assistant/hive-mind/issues/1159
     // See: https://github.com/link-assistant/hive-mind/issues/1253 (strategies)
-    const limitCheck = await this.checkApiLimits(hasRunningClaude, claudeProcessingCount, tool);
+    const hasRunningToolProcess = tool === 'codex' ? hasRunningCodex : hasRunningClaude;
+    const toolProcessingCount = tool === 'codex' ? codexProcessingCount : claudeProcessingCount;
+    const limitCheck = await this.checkApiLimits(hasRunningToolProcess, toolProcessingCount, tool);
     if (limitCheck.rejected) {
       rejected = true;
       rejectReason = limitCheck.rejectReason;
@@ -705,6 +574,9 @@ export class SolveQueue {
       // See: https://github.com/link-assistant/hive-mind/issues/1078
       reasons.push(formatWaitingReason('claude_running', claudeProcs.count, 0) + ` (${claudeProcs.count} processes)`);
     }
+    if (tool === 'codex' && hasRunningCodex && reasons.length > 0) {
+      reasons.push(formatWaitingReason('codex_running', codexProcs.count, 0) + ` (${codexProcs.count} processes)`);
+    }
 
     const canStart = reasons.length === 0 && !rejected;
 
@@ -724,8 +596,10 @@ export class SolveQueue {
       reasons,
       oneAtATime,
       claudeProcesses: claudeProcs.count,
+      codexProcesses: codexProcs.count,
       totalProcessing,
       claudeProcessingCount,
+      codexProcessingCount,
     };
   }
 
@@ -868,12 +742,12 @@ export class SolveQueue {
    * - All thresholds now support configurable strategies (reject, enqueue, dequeue-one-at-a-time)
    * - Configuration via HIVE_MIND_QUEUE_CONFIG or individual env vars
    *
-   * @param {boolean} hasRunningClaude - Whether claude processes are running (from pgrep)
-   * @param {number} claudeProcessingCount - Count of 'claude' tool items being processed in queue
+   * @param {boolean} hasRunningToolProcess - Whether matching tool processes are running (from pgrep)
+   * @param {number} toolProcessingCount - Count of matching tool items being processed in queue
    * @param {string} tool - The tool being used ('claude', 'agent', etc.)
    * @returns {Promise<{ok: boolean, reasons: string[], oneAtATime: boolean, rejected: boolean, rejectReason: string|null}>}
    */
-  async checkApiLimits(hasRunningClaude = false, claudeProcessingCount = 0, tool = 'claude') {
+  async checkApiLimits(hasRunningToolProcess = false, toolProcessingCount = 0, tool = 'claude') {
     const reasons = [];
     let oneAtATime = false;
     let rejected = false;
@@ -884,12 +758,9 @@ export class SolveQueue {
     // affected by Claude API limits (5-hour session, weekly limits)
     // See: https://github.com/link-assistant/hive-mind/issues/1159
     const applyClaudeLimits = tool === 'claude';
+    const applyCodexLimits = tool === 'codex';
 
-    // 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);
+    const totalToolProcessing = toolProcessingCount + (hasRunningToolProcess ? 1 : 0);
 
     // Check Claude limits (using cached value)
     // Only applied when tool is 'claude'
@@ -914,7 +785,7 @@ export class SolveQueue {
               rejectReason = reason;
             } else if (strategy === 'dequeue-one-at-a-time') {
               oneAtATime = true;
-              if (totalClaudeProcessing > 0) {
+              if (totalToolProcessing > 0) {
                 reasons.push(reason + ' (waiting for current command)');
               }
             } else {
@@ -939,7 +810,7 @@ export class SolveQueue {
               rejectReason = reason;
             } else if (strategy === 'dequeue-one-at-a-time') {
               oneAtATime = true;
-              if (totalClaudeProcessing > 0) {
+              if (totalToolProcessing > 0) {
                 reasons.push(reason + ' (waiting for current command)');
               }
             } else {
@@ -949,13 +820,62 @@ export class SolveQueue {
           }
         }
       }
+    } else if (applyCodexLimits) {
+      const codexResult = await getCachedCodexLimits(this.verbose);
+      if (codexResult.success) {
+        const sessionPercent = codexResult.usage.currentSession.percentage;
+        const weeklyPercent = codexResult.usage.allModels.percentage;
+
+        if (sessionPercent !== null) {
+          const sessionRatio = sessionPercent / 100;
+          if (sessionRatio >= QUEUE_CONFIG.thresholds.codex5Hour.value) {
+            const reason = formatWaitingReason('codex_5_hour_session', sessionPercent, QUEUE_CONFIG.thresholds.codex5Hour.value);
+            const strategy = QUEUE_CONFIG.thresholds.codex5Hour.strategy;
+            this.recordThrottle(sessionRatio >= 1.0 ? 'codex_5_hour_session_100' : `codex_5_hour_session_${strategy}`);
+
+            if (strategy === 'reject') {
+              rejected = true;
+              rejectReason = reason;
+            } else if (strategy === 'dequeue-one-at-a-time') {
+              oneAtATime = true;
+              if (totalToolProcessing > 0) {
+                reasons.push(reason + ' (waiting for current command)');
+              }
+            } else {
+              reasons.push(reason);
+            }
+          }
+        }
+
+        if (weeklyPercent !== null) {
+          const weeklyRatio = weeklyPercent / 100;
+          if (weeklyRatio >= QUEUE_CONFIG.thresholds.codexWeekly.value) {
+            const reason = formatWaitingReason('codex_weekly', weeklyPercent, QUEUE_CONFIG.thresholds.codexWeekly.value);
+            const strategy = QUEUE_CONFIG.thresholds.codexWeekly.strategy;
+            this.recordThrottle(weeklyRatio >= 1.0 ? 'codex_weekly_100' : `codex_weekly_${strategy}`);
+
+            if (strategy === 'reject') {
+              rejected = true;
+              rejectReason = reason;
+            } else if (strategy === 'dequeue-one-at-a-time') {
+              oneAtATime = true;
+              if (totalToolProcessing > 0) {
+                reasons.push(reason + ' (waiting for current command)');
+              }
+            } else {
+              reasons.push(reason);
+            }
+          }
+        }
+      }
     } else if (this.verbose) {
       this.log(`Claude limits not applied for --tool ${tool}`);
     }
 
-    // Check GitHub limits (only relevant if claude processes running)
+    // Check GitHub limits when the active tool already has a running process.
+    // This keeps the queue behavior aligned with the existing one-at-a-time throttling model.
     // Configurable strategy via HIVE_MIND_QUEUE_CONFIG or HIVE_MIND_GITHUB_API_STRATEGY
-    if (hasRunningClaude) {
+    if (hasRunningToolProcess) {
       const githubResult = await getCachedGitHubLimits(this.verbose);
       if (githubResult.success) {
         const usedPercent = githubResult.githubRateLimit.usedPercentage;
@@ -970,7 +890,7 @@ export class SolveQueue {
             rejectReason = reason;
           } else if (strategy === 'dequeue-one-at-a-time') {
             oneAtATime = true;
-            if (totalClaudeProcessing > 0) {
+            if (totalToolProcessing > 0) {
               reasons.push(reason + ' (waiting for current command)');
             }
           } else {
@@ -1273,22 +1193,11 @@ export class SolveQueue {
    * @see https://github.com/link-assistant/hive-mind/issues/1267
    */
   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;
+      const processing = (await getRunningProcesses(tool, this.verbose)).count;
       message += `${tool} (pending: ${pending}, processing: ${processing})\n`;
     }
 
@@ -1326,20 +1235,12 @@ export class SolveQueue {
     // 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,
-    };
-
     let message = '📋 *Solve Queue Status*\n\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;
+      const processing = (await getRunningProcesses(tool, this.verbose)).count;
       message += `*${tool}* (pending: ${pending}, processing: ${processing})\n`;
 
       // Show first 5 queued items for this tool