@link-assistant/hive-mind 1.50.8 → 1.50.9

package/src/limits.lib.mjs

@@ -30,11 +30,87 @@ const execAsync = promisify(exec);
  * Default path to Claude credentials file
  */
 const DEFAULT_CREDENTIALS_PATH = join(homedir(), '.claude', '.credentials.json');
+const DEFAULT_CODEX_AUTH_PATH = join(homedir(), '.codex', 'auth.json');
+const DEFAULT_CODEX_CONFIG_PATH = join(homedir(), '.codex', 'config.toml');
 
 /**
  * Anthropic OAuth usage API endpoint
  */
 const USAGE_API_ENDPOINT = 'https://api.anthropic.com/api/oauth/usage';
+const CODEX_USAGE_API_DEFAULT_BASE_URL = 'https://chatgpt.com/backend-api';
+
+function decodeJwtPayload(token) {
+  if (!token || typeof token !== 'string') return null;
+
+  try {
+    const payload = token.split('.')[1];
+    if (!payload) return null;
+    const normalized = payload.replace(/-/g, '+').replace(/_/g, '/');
+    const padded = normalized + '='.repeat((4 - (normalized.length % 4)) % 4);
+    return JSON.parse(Buffer.from(padded, 'base64').toString('utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function unixSecondsToIsoDate(seconds) {
+  if (seconds === null || seconds === undefined) return null;
+  const numeric = Number(seconds);
+  if (!Number.isFinite(numeric) || numeric <= 0) return null;
+  return new Date(numeric * 1000).toISOString();
+}
+
+function mapCodexWindow(window) {
+  const resetsAt = unixSecondsToIsoDate(window?.reset_at);
+  return {
+    percentage: window?.used_percent ?? null,
+    resetTime: formatResetTime(resetsAt),
+    resetsAt,
+    windowSeconds: window?.limit_window_seconds ?? null,
+    resetAfterSeconds: window?.reset_after_seconds ?? null,
+  };
+}
+
+async function readCodexAuth(authPath = DEFAULT_CODEX_AUTH_PATH, verbose = false) {
+  try {
+    const content = await readFile(authPath, 'utf-8');
+    const auth = JSON.parse(content);
+
+    if (verbose) {
+      console.log('[VERBOSE] /limits Codex auth loaded from:', authPath);
+    }
+
+    return auth;
+  } catch (error) {
+    if (verbose) {
+      console.error('[VERBOSE] /limits failed to read Codex auth:', error.message);
+    }
+    return null;
+  }
+}
+
+async function getCodexUsageBaseUrl(configPath = DEFAULT_CODEX_CONFIG_PATH, verbose = false) {
+  try {
+    const content = await readFile(configPath, 'utf-8');
+    const match = content.match(/^\s*chatgpt_base_url\s*=\s*["']([^"']+)["']/m);
+    if (!match?.[1]) return CODEX_USAGE_API_DEFAULT_BASE_URL;
+
+    const baseUrl = match[1].trim().replace(/\/+$/, '');
+    const normalized = baseUrl.endsWith('/backend-api') ? baseUrl : `${baseUrl}/backend-api`;
+
+    if (verbose) {
+      console.log('[VERBOSE] /limits Codex base URL loaded from config:', normalized);
+    }
+
+    return normalized;
+  } catch (error) {
+    if (verbose) {
+      console.log('[VERBOSE] /limits using default Codex base URL:', CODEX_USAGE_API_DEFAULT_BASE_URL);
+      console.log('[VERBOSE] /limits failed to read Codex config:', error.message);
+    }
+    return CODEX_USAGE_API_DEFAULT_BASE_URL;
+  }
+}
 
 /**
  * Read Claude credentials from the credentials file
@@ -702,6 +778,162 @@ export async function getClaudeUsageLimits(verbose = false, credentialsPath = DE
   }
 }
 
+/**
+ * Get Codex usage limits through the ChatGPT-authenticated usage endpoint.
+ * Mirrors the supported upstream Codex account/rate-limits path.
+ *
+ * Returns usage data for:
+ * - Current session (5-hour) usage percentage and reset time
+ * - Current week usage percentage and reset date
+ * - Additional metered Codex limits when available
+ *
+ * @param {boolean} verbose - Whether to log verbose output
+ * @param {string} authPath - Optional path to Codex auth.json
+ * @param {string|null} baseUrl - Optional backend base URL override
+ * @returns {Object} Object with success boolean, and either usage data or error message
+ */
+export async function getCodexUsageLimits(verbose = false, authPath = DEFAULT_CODEX_AUTH_PATH, baseUrl = null) {
+  try {
+    const auth = await readCodexAuth(authPath, verbose);
+
+    if (!auth) {
+      return {
+        success: false,
+        error: 'Could not read Codex authentication. Make sure Codex is properly installed and authenticated.',
+      };
+    }
+
+    if (auth.auth_mode && auth.auth_mode !== 'chatgpt') {
+      return {
+        success: false,
+        error: 'Codex rate limits require ChatGPT authentication. API key auth does not expose account usage windows.',
+      };
+    }
+
+    const accessToken = auth?.tokens?.access_token;
+    if (!accessToken) {
+      return {
+        success: false,
+        error: 'No Codex access token found. Please authenticate Codex with your ChatGPT account.',
+      };
+    }
+
+    const resolvedBaseUrl = (baseUrl || (await getCodexUsageBaseUrl(undefined, verbose))).replace(/\/+$/, '');
+    const usageEndpoint = `${resolvedBaseUrl}/wham/usage`;
+    const tokenPayload = decodeJwtPayload(accessToken);
+    const requestHeaders = {
+      Accept: 'application/json',
+      Authorization: `Bearer ${accessToken}`,
+      'User-Agent': 'hive-mind-codex-limits/1.0',
+    };
+
+    if (verbose) {
+      console.log('[VERBOSE] /limits fetching Codex usage from API...');
+      console.log(`[VERBOSE] /limits Codex API request: GET ${usageEndpoint}`);
+      console.log('[VERBOSE] /limits Codex auth mode:', auth.auth_mode || 'unknown');
+      console.log('[VERBOSE] /limits Codex account id:', auth?.tokens?.account_id || tokenPayload?.['https://api.openai.com/auth']?.chatgpt_account_id || 'unknown');
+      console.log('[VERBOSE] /limits Codex plan type:', tokenPayload?.['https://api.openai.com/auth']?.chatgpt_plan_type || 'unknown');
+      console.log(
+        '[VERBOSE] /limits Codex API request headers:',
+        JSON.stringify(
+          {
+            Accept: requestHeaders.Accept,
+            Authorization: `Bearer ...${accessToken.slice(-8)}`,
+            'User-Agent': requestHeaders['User-Agent'],
+          },
+          null,
+          2
+        )
+      );
+    }
+
+    const response = await fetch(usageEndpoint, {
+      method: 'GET',
+      headers: requestHeaders,
+    });
+
+    if (verbose) {
+      console.log(`[VERBOSE] /limits Codex API HTTP status: ${response.status} ${response.statusText}`);
+      const responseHeaders = {};
+      response.headers.forEach((value, key) => {
+        responseHeaders[key] = value;
+      });
+      console.log('[VERBOSE] /limits Codex API response headers:', JSON.stringify(responseHeaders, null, 2));
+    }
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      if (verbose) {
+        console.error('[VERBOSE] /limits Codex API error body:', errorText);
+      }
+
+      if (response.status === 401) {
+        return {
+          success: false,
+          error: 'Codex authentication expired. Please re-authenticate Codex with your ChatGPT account.',
+        };
+      }
+
+      if (response.status === 429) {
+        const retryAfter = response.headers.get('retry-after');
+        return {
+          success: false,
+          error: `Codex usage API access has reached rate limit.${formatRetryAfterMessage(retryAfter)}`,
+        };
+      }
+
+      return {
+        success: false,
+        error: `Failed to fetch Codex usage from API: ${response.status} ${response.statusText}`,
+      };
+    }
+
+    const data = await response.json();
+
+    if (verbose) {
+      console.log('[VERBOSE] /limits Codex API response body:', JSON.stringify(data, null, 2));
+    }
+
+    const usage = {
+      currentSession: mapCodexWindow(data?.rate_limit?.primary_window),
+      allModels: mapCodexWindow(data?.rate_limit?.secondary_window),
+      sonnetOnly: {
+        percentage: null,
+        resetTime: null,
+        resetsAt: null,
+      },
+    };
+
+    const additionalRateLimits = Array.isArray(data?.additional_rate_limits)
+      ? data.additional_rate_limits.map(limit => ({
+          limitId: limit?.metered_feature || null,
+          limitName: limit?.limit_name || limit?.metered_feature || 'additional',
+          currentSession: mapCodexWindow(limit?.rate_limit?.primary_window),
+          allModels: mapCodexWindow(limit?.rate_limit?.secondary_window),
+          allowed: limit?.rate_limit?.allowed ?? null,
+          limitReached: limit?.rate_limit?.limit_reached ?? null,
+        }))
+      : [];
+
+    return {
+      success: true,
+      usage,
+      planType: data?.plan_type || tokenPayload?.['https://api.openai.com/auth']?.chatgpt_plan_type || null,
+      credits: data?.credits || null,
+      additionalRateLimits,
+      raw: data,
+    };
+  } catch (error) {
+    if (verbose) {
+      console.error('[VERBOSE] /limits Codex error:', error);
+    }
+    return {
+      success: false,
+      error: `Failed to get Codex usage limits: ${error.message}`,
+    };
+  }
+}
+
 /**
  * Generate a text-based progress bar for usage percentage
  * @param {number} percentage - Usage percentage (0-100)
@@ -953,6 +1185,85 @@ export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = nu
   return '```\n' + sections.join('\n') + '```';
 }
 
+/**
+ * Format Codex usage data into a section suitable for appending to /limits output.
+ *
+ * @param {Object|null} codexLimits - Result object from getCodexUsageLimits, or null
+ * @param {string|null} codexError - Optional error message
+ * @returns {string} Formatted section text
+ */
+export function formatCodexLimitsSection(codexLimits, codexError = null) {
+  if (codexError) {
+    return `Codex limits\n${codexError}\n`;
+  }
+
+  const usage = codexLimits?.usage || null;
+  const additionalRateLimits = codexLimits?.additionalRateLimits || [];
+  const credits = codexLimits?.credits || null;
+  const planType = codexLimits?.planType || null;
+
+  let section = 'Codex limits\n';
+  if (planType) {
+    section += `Plan: ${planType}\n`;
+  }
+
+  let sessionSection = 'Codex 5 hour session\n';
+  if (usage?.currentSession?.percentage !== null) {
+    const timePassed = calculateTimePassedPercentage(usage.currentSession.resetsAt, 5);
+    if (timePassed !== null) {
+      sessionSection += `${getProgressBar(timePassed)} ${timePassed}% passed\n`;
+    }
+    const pct = Math.floor(usage.currentSession.percentage);
+    const bar = getProgressBar(pct, DISPLAY_THRESHOLDS.CODEX_5_HOUR_SESSION);
+    const suffix = pct >= DISPLAY_THRESHOLDS.CODEX_5_HOUR_SESSION ? ' ⚠️' : ' used';
+    sessionSection += `${bar} ${pct}%${suffix}\n`;
+    if (usage.currentSession.resetTime) {
+      const relativeTime = formatRelativeTime(usage.currentSession.resetsAt);
+      sessionSection += relativeTime ? `Resets in ${relativeTime} (${usage.currentSession.resetTime})\n` : `Resets ${usage.currentSession.resetTime}\n`;
+    }
+  } else {
+    sessionSection += 'N/A\n';
+  }
+
+  let weeklySection = 'Current week (all models)\n';
+  if (usage?.allModels?.percentage !== null) {
+    const timePassed = calculateTimePassedPercentage(usage.allModels.resetsAt, 168);
+    if (timePassed !== null) {
+      weeklySection += `${getProgressBar(timePassed)} ${timePassed}% passed\n`;
+    }
+    const pct = Math.floor(usage.allModels.percentage);
+    const bar = getProgressBar(pct, DISPLAY_THRESHOLDS.CODEX_WEEKLY);
+    const suffix = pct >= DISPLAY_THRESHOLDS.CODEX_WEEKLY ? ' ⚠️' : ' used';
+    weeklySection += `${bar} ${pct}%${suffix}\n`;
+    if (usage.allModels.resetTime) {
+      const relativeTime = formatRelativeTime(usage.allModels.resetsAt);
+      weeklySection += relativeTime ? `Resets in ${relativeTime} (${usage.allModels.resetTime})\n` : `Resets ${usage.allModels.resetTime}\n`;
+    }
+  } else {
+    weeklySection += 'N/A\n';
+  }
+
+  section += `${sessionSection}\n${weeklySection}`;
+
+  if (additionalRateLimits.length > 0) {
+    section += '\nAdditional Codex limits\n';
+    for (const limit of additionalRateLimits) {
+      const sessionPct = limit.currentSession?.percentage;
+      const weeklyPct = limit.allModels?.percentage;
+      const sessionText = sessionPct === null ? 'session N/A' : `session ${Math.floor(sessionPct)}%`;
+      const weeklyText = weeklyPct === null ? 'week N/A' : `week ${Math.floor(weeklyPct)}%`;
+      section += `${limit.limitName}: ${sessionText}, ${weeklyText}\n`;
+    }
+  }
+
+  if (credits) {
+    const creditSummary = credits.unlimited ? 'unlimited' : `${credits.balance ?? '0'} balance`;
+    section += `\nCodex credits\n${creditSummary}\n`;
+  }
+
+  return section;
+}
+
 // ============================================================================
 // Caching Layer
 // ============================================================================
@@ -1064,6 +1375,29 @@ export async function getCachedClaudeLimits(verbose = false) {
   return result;
 }
 
+export async function getCachedCodexLimits(verbose = false) {
+  const cache = getLimitCache();
+  const cached = cache.get('codex', CACHE_TTL.USAGE_API);
+  if (cached) {
+    if (verbose) console.log('[VERBOSE] /limits-cache: Using cached Codex limits (TTL: ' + Math.round(CACHE_TTL.USAGE_API / 60000) + ' minutes)');
+    return cached;
+  }
+  const cachedError = cache.get('codex-rate-limited', CACHE_TTL.USAGE_API);
+  if (cachedError) {
+    if (verbose) console.log('[VERBOSE] /limits-cache: Using cached Codex rate-limit error');
+    return cachedError;
+  }
+  if (verbose) console.log('[VERBOSE] /limits-cache: Cache miss for Codex limits, fetching from API...');
+  const result = await getCodexUsageLimits(verbose);
+  if (result.success) {
+    cache.set('codex', result, CACHE_TTL.USAGE_API);
+  } else if (result.error && result.error.includes('rate limit')) {
+    cache.set('codex-rate-limited', result, CACHE_TTL.USAGE_API);
+    if (verbose) console.log('[VERBOSE] /limits-cache: Cached Codex rate-limit error for ' + Math.round(CACHE_TTL.USAGE_API / 60000) + ' minutes');
+  }
+  return result;
+}
+
 export async function getCachedGitHubLimits(verbose = false) {
   const cache = getLimitCache();
   const cached = cache.get('github', CACHE_TTL.API);
@@ -1113,13 +1447,14 @@ export async function getCachedDiskInfo(verbose = false) {
 }
 
 export async function getAllCachedLimits(verbose = false) {
-  const [claude, github, memory, cpu, disk] = await Promise.all([getCachedClaudeLimits(verbose), getCachedGitHubLimits(verbose), getCachedMemoryInfo(verbose), getCachedCpuInfo(verbose), getCachedDiskInfo(verbose)]);
-  return { claude, github, memory, cpu, disk };
+  const [claude, codex, github, memory, cpu, disk] = await Promise.all([getCachedClaudeLimits(verbose), getCachedCodexLimits(verbose), getCachedGitHubLimits(verbose), getCachedMemoryInfo(verbose), getCachedCpuInfo(verbose), getCachedDiskInfo(verbose)]);
+  return { claude, codex, github, memory, cpu, disk };
 }
 
 export default {
   // Raw functions (no caching)
   getClaudeUsageLimits,
+  getCodexUsageLimits,
   getCpuLoadInfo,
   getMemoryInfo,
   getDiskSpaceInfo,
@@ -1127,6 +1462,7 @@ export default {
   getProgressBar,
   calculateTimePassedPercentage,
   formatUsageMessage,
+  formatCodexLimitsSection,
   formatRetryAfterMessage,
   // Threshold constants for progress bar visualization
   DISPLAY_THRESHOLDS,
@@ -1136,6 +1472,7 @@ export default {
   resetLimitCache,
   // Cached functions
   getCachedClaudeLimits,
+  getCachedCodexLimits,
   getCachedGitHubLimits,
   getCachedMemoryInfo,
   getCachedCpuInfo,

package/src/models/index.mjs

@@ -103,14 +103,19 @@ export const opencodeModels = {
 // Codex models (OpenAI API)
 export const codexModels = {
   gpt5: 'gpt-5',
-  'gpt5-codex': 'gpt-5-codex',
-  o3: 'o3',
+  'gpt-5': 'gpt-5',
+  'gpt-5.4': 'gpt-5.4',
+  'gpt-5.4-mini': 'gpt-5.4-mini',
+  'gpt-5.4-nano': 'gpt-5.4-nano',
+  'gpt-5.2-codex': 'gpt-5.2-codex',
+  'gpt-5.3-codex': 'gpt-5.3-codex',
+  'gpt-5.3-codex-spark': 'gpt-5.3-codex-spark',
+  'gpt-5.1-codex-max': 'gpt-5.1-codex-max',
   'o3-mini': 'o3-mini',
   gpt4: 'gpt-4',
+  'gpt-4': 'gpt-4',
   gpt4o: 'gpt-4o',
-  claude: 'claude-3-5-sonnet',
-  sonnet: 'claude-3-5-sonnet',
-  opus: 'claude-3-opus',
+  'gpt-4o': 'gpt-4o',
 };
 
 // Default model for each tool (Issue #1473: centralized to avoid scattered hardcoded defaults)
@@ -118,7 +123,7 @@ export const defaultModels = {
   claude: 'sonnet',
   agent: 'nemotron-3-super-free', // Issue #1563: changed from qwen3.6-plus-free (free promotion ended) per agent PR #243
   opencode: 'grok-code-fast-1',
-  codex: 'gpt-5',
+  codex: 'gpt-5.4',
 };
 
 // Models that support 1M token context window via [1m] suffix (Issue #1221, Issue #1238, Issue #1329)
@@ -180,11 +185,15 @@ export const OPENCODE_MODELS = {
 export const CODEX_MODELS = {
   ...codexModels,
   'gpt-5': 'gpt-5',
-  'gpt-5-codex': 'gpt-5-codex',
+  'gpt-5.4': 'gpt-5.4',
+  'gpt-5.4-mini': 'gpt-5.4-mini',
+  'gpt-5.4-nano': 'gpt-5.4-nano',
+  'gpt-5.2-codex': 'gpt-5.2-codex',
+  'gpt-5.3-codex': 'gpt-5.3-codex',
+  'gpt-5.3-codex-spark': 'gpt-5.3-codex-spark',
+  'gpt-5.1-codex-max': 'gpt-5.1-codex-max',
   'gpt-4': 'gpt-4',
   'gpt-4o': 'gpt-4o',
-  'claude-3-5-sonnet': 'claude-3-5-sonnet',
-  'claude-3-opus': 'claude-3-opus',
 };
 
 export const AGENT_MODELS = {
@@ -273,7 +282,7 @@ export const isModelCompatibleWithTool = (tool, model) => {
     case 'opencode':
       return mappedModel.includes('/') || Object.keys(opencodeModels).includes(model);
     case 'codex':
-      return Object.keys(codexModels).includes(model) || mappedModel.startsWith('gpt-') || mappedModel.startsWith('o3') || mappedModel.startsWith('claude-');
+      return Object.keys(codexModels).includes(model) || mappedModel.startsWith('gpt-');
     default:
       return true;
   }
@@ -304,7 +313,7 @@ export const getValidModelsForTool = tool => {
 export const primaryModelNames = {
   claude: ['opus', 'sonnet', 'haiku', 'opusplan'],
   opencode: ['grok', 'gpt4o'],
-  codex: ['gpt5', 'gpt5-codex', 'o3'],
+  codex: ['gpt-5.4', 'gpt-5.4-mini', 'gpt-5.3-codex', 'gpt-5.3-codex-spark', 'gpt-5.2-codex'],
   agent: ['nemotron-3-super-free', 'minimax-m2.5-free', 'big-pickle', 'gpt-5-nano', 'glm-5-free', 'deepseek-r1-free'],
 };
 
@@ -375,7 +384,7 @@ export const getAvailableModelNames = tool => {
     // - Full model IDs with slashes (e.g., 'openai/gpt-4')
     // - Long claude-prefixed model IDs (e.g., 'claude-sonnet-4-5-20250929')
     // - Full gpt- prefixed IDs that are ONLY version numbers (e.g., 'gpt-4', 'gpt-4o', 'gpt-5')
-    // But keep descriptive aliases like 'gpt-5-nano', 'gpt-5-codex', 'o3', 'o3-mini', 'gpt5', etc.
+    // But keep descriptive aliases like 'gpt-5-nano', 'gpt-5.3-codex', 'o3-mini', 'gpt5', etc.
     // Issue #1185: Updated regex to not filter out gpt-5-nano (a valid short alias)
     if (key.includes('/')) return false;
     if (key.match(/^claude-.*-\d{8}$/)) return false; // Full claude model IDs with date

package/src/opencode.prompts.lib.mjs

@@ -87,18 +87,6 @@ export const buildSystemPrompt = params => {
   // When in fork mode, screenshots are pushed to the fork, not the original repo
   const screenshotRepoPath = argv?.fork && forkedRepo ? forkedRepo : `${owner}/${repo}`;
 
-  // Build thinking instruction based on --think level
-  let thinkLine = '';
-  if (argv && argv.think) {
-    const thinkMessages = {
-      low: 'You always think on every step.',
-      medium: 'You always think hard on every step.',
-      high: 'You always think harder on every step.',
-      max: 'You always ultrathink on every step.',
-    };
-    thinkLine = `\n${thinkMessages[argv.think]}\n`;
-  }
-
   // Build workspace-specific instructions and examples
   let workspaceInstructions = '';
   if (workspaceTmpDir) {
@@ -134,22 +122,22 @@ CI investigation with workspace tmp directory.
 `;
   }
 
-  return `You are AI issue solver using OpenCode.${thinkLine}
+  return `You are an AI issue solver using OpenCode.
 
 General guidelines.
-   - When you execute commands, always save their logs to files for easier reading if the output becomes large.
-   - When running commands, do not set a timeout yourself — let them run as long as needed.
-   - When running sudo commands (especially package installations), always run them in the background to avoid timeout issues.
-   - When CI is failing, make sure you download the logs locally and carefully investigate them.
+   - When you execute commands and the output becomes large, save the logs to files for easier review.
+   - When running commands, avoid setting a timeout yourself. Let them run as long as needed.
+   - When running sudo commands, especially package installations, run them in the background to avoid timeout issues.
+   - When CI is failing, download the logs locally and investigate them carefully.
    - When a code or log file has more than 1500 lines, read it in chunks of 1500 lines.
    - When facing a complex problem, do as much tracing as possible and turn on all verbose modes.
 ${getExperimentsExamplesSubPrompt(argv)}
-   - When you face something extremely hard, use divide and conquer — it always helps.
+   - When you face something extremely hard, use divide and conquer.
 ${workspaceInstructions}
 Initial research.
-   - When you start, make sure you create detailed plan for yourself and follow your todo list step by step, make sure that as many points from these guidelines are added to your todo list to keep track of everything that can help you solve the issue with highest possible quality.
-   - When you read issue, read all details and comments thoroughly.
-   - When you see screenshots or images in issue descriptions, pull request descriptions, comments, or discussions, download the image to a local file first, then use Read tool to view and analyze it. Before reading downloaded images with the Read tool, verify the file is a valid image (not HTML) using a CLI tool like the 'file' command to check the actual file format. When corrupted or non-image files (like GitHub's "Not Found" pages saved as .png) are read, they can cause "Could not process image" errors and crash the AI solver process. When the file command shows "HTML", "text", or "ASCII text", the download failed — do not call Read on this file. Instead: (1) When images are from GitHub issues/PRs (URLs containing "github.com/user-attachments"), these require authentication — retry with: curl -L -H "Authorization: token $(gh auth token)" -o <filename> "<url>" (2) When the retry still fails, skip the image and note it was unavailable.
+   - When you start, create a detailed plan for yourself and follow your todo list step by step. Add as many relevant points from these guidelines to the todo list as practical so you can track the work clearly.
+   - When you read the issue, read all details and comments thoroughly.
+   - When you see screenshots or images in issue descriptions, pull request descriptions, comments, or discussions, download the image to a local file first, then use the Read tool to view and analyze it. Before reading downloaded images with the Read tool, verify that the file is a valid image rather than HTML by using a CLI tool such as the 'file' command. When corrupted or non-image files, such as GitHub "Not Found" pages saved as `.png`, are read, they can cause "Could not process image" errors and crash the AI solver process. When the file command shows "HTML", "text", or "ASCII text", the download failed, so do not call Read on that file. Instead: (1) when images are from GitHub issues or PRs, such as URLs containing "github.com/user-attachments", retry with: curl -L -H "Authorization: token $(gh auth token)" -o <filename> "<url>" (2) when the retry still fails, skip the image and note that it was unavailable.
    - When you need issue details, use gh issue view https://github.com/${owner}/${repo}/issues/${issueNumber}.
    - When you need related code, use gh search code --owner ${owner} [keywords].
    - When you need repo context, read files in your working directory.${
@@ -158,21 +146,21 @@ Initial research.
    - When you study related work, study the most recent related pull requests.`
        : ''
    }
-   - When issue is not defined enough, write a comment to ask clarifying questions.
+   - When the issue is not defined clearly enough, write a comment with clarifying questions.
    - When accessing GitHub Gists, use gh gist view command instead of direct URL fetching.
-   - When you are fixing a bug, please make sure you first find the actual root cause, do as many experiments as needed.
-   - When you are fixing a bug and code does not have enough tracing/logs, add them and make sure they stay in the code, but are switched off by default.
+   - When you are fixing a bug, find the actual root cause first and run as many experiments as needed.
+   - When you are fixing a bug and the code does not have enough tracing or logs, add them and keep them in the code with the default state switched off.
    - When you need comments on a pull request, note that GitHub has three different comment types with different API endpoints:
       1. PR review comments (inline code comments): gh api repos/${owner}/${repo}/pulls/${prNumber}/comments --paginate
       2. PR conversation comments (general discussion): gh api repos/${owner}/${repo}/issues/${prNumber}/comments --paginate
       3. PR reviews (approve/request changes): gh api repos/${owner}/${repo}/pulls/${prNumber}/reviews --paginate
       Note: The command "gh pr view --json comments" only returns conversation comments and misses review comments.
-   - When you need latest comments on issue, use gh api repos/${owner}/${repo}/issues/${issueNumber}/comments --paginate.
+   - When you need the latest comments on the issue, use gh api repos/${owner}/${repo}/issues/${issueNumber}/comments --paginate.
 
 Solution development and testing.
    - When issue is solvable, first create a test that reproduces the problem, then implement the fix.
    - When implementing features, search for similar existing implementations in the codebase and use them as examples instead of implementing everything from scratch.
-   - When coding, each atomic step that can be useful by itself should be committed to the pull request's branch, meaning if work will be interrupted by any reason parts of solution will still be kept intact and safe in pull request.
+   - When coding, commit each atomic step that is useful on its own to the pull request branch so interrupted work remains preserved in the pull request.
    - When you test:
       start from testing of small functions using separate scripts;
       write unit tests with mocks for easy and quick start.
@@ -180,7 +168,7 @@ Solution development and testing.
    - When you test solution draft, include automated checks in pr.
    - When you write or modify tests, consider setting reasonable timeouts at test, suite, and CI job levels so failures surface quickly instead of hanging.
    - When you see repeated test timeout patterns in CI, investigate the root cause rather than increasing timeouts.
-   - When issue is unclear, write comment on issue asking questions.
+   - When the issue is unclear, write a comment on the issue with questions.
    - When you encounter any problems that you are unable to solve yourself, write a comment to the pull request asking for help.
    - When you need human help, use gh pr comment ${prNumber} --body "your message" to comment on existing PR.
 
@@ -188,9 +176,9 @@ Reproducible testing.
    - When fixing a bug, create a test that reproduces the problem before implementing the fix. When you cannot reproduce the problem, you cannot verify the fix.
    - When encountering logic bugs, write an automated test that fails due to the bug, then implement the fix to make it pass.
    - When encountering UI bugs, capture a screenshot showing the problem state, then create a visual regression test or manual verification screenshot after the fix.
-   - When creating tests, prefer minimum reproducible examples - the simplest test case that demonstrates the issue.
+   - When creating tests, prefer minimum reproducible examples, meaning the simplest test case that demonstrates the issue.
    - When submitting a fix, include in the PR description: (1) how to reproduce the issue, (2) the automated test that verifies the fix, (3) before/after screenshots for UI issues.
-   - When a bug fix doesn't have a reproducing test, the fix is incomplete - regressions can silently occur later.
+   - When a bug fix does not have a reproducing test, treat the fix as incomplete because regressions can occur later without notice.
 
 Preparing pull request.
    - When you code, follow contributing guidelines.
@@ -200,14 +188,14 @@ Preparing pull request.
    - When there is a package with version and GitHub Actions workflows for automatic release, update the version in your pull request to prepare for next release.
    - When you update existing pr ${prNumber}, use gh pr edit to modify title and description.
    - When you finalize the pull request:
-      check that pull request title and description are updated (the PR may start with a [WIP] prefix and placeholder description that should be replaced with actual title and description of the changes),
+      check that the pull request title and description are updated (the PR may start with a [WIP] prefix and a placeholder description that should be replaced with the actual title and description of the changes),
       follow style from merged prs for code, title, and description,
-      make sure no uncommitted changes corresponding to the original requirements are left behind,
-      make sure the default branch is merged to the pull request's branch,
-      make sure all CI checks passing if they exist before you finish,
-      double-check that all changes in the pull request answer to original requirements of the issue,
-      make sure no new bugs are introduced in pull request by carefully reading gh pr diff,
-      make sure no previously existing features were removed without an explicit request from users via the issue description, issue comments, and/or pull request comments.
+      check that no uncommitted changes corresponding to the original requirements are left behind,
+      check that the default branch is merged into the pull request branch,
+      check that all CI checks are passing if they exist before you finish,
+      double-check that all changes in the pull request address the original requirements of the issue,
+      check for newly introduced bugs in the pull request by carefully reading gh pr diff,
+      check that no previously existing features were removed without an explicit request in the issue description, issue comments, or pull request comments.
    - When you finish implementation, use gh pr ready ${prNumber}.
 
 Workflow and collaboration.
@@ -220,7 +208,7 @@ Workflow and collaboration.
    - When you contribute, keep repository history forward-moving with regular commits, pushes, and reverts if needed.
    - When you face conflict that you cannot resolve yourself, ask for help.
    - When you collaborate, respect branch protections by working only on ${branchName}.
-   - When you mention result, include pull request url or comment url.
+   - When you mention a result, include the pull request URL or comment URL.
    - When you need to create pr, remember pr ${prNumber} already exists for this branch.
 
 Self review.
@@ -229,7 +217,7 @@ Self review.
    - When you finalize, confirm code, tests, and description are consistent.${
      argv && argv.promptEnsureAllRequirementsAreMet
        ? `
-   - When no explicit feedback or requirements are provided, ensure all changes are correct, consistent, validated, tested, logged and fully meet all discussed requirements (check issue description and all comments in issue and in pull request). Ensure all CI/CD checks pass.`
+   - When no explicit feedback or requirements are provided, ensure all changes are correct, consistent, validated, tested, logged, and aligned with all discussed requirements by checking the issue description and all comments on the issue and pull request. Check that all CI or CD checks are passing.`
        : ''
    }
 

package/src/queue-config.lib.mjs

@@ -246,6 +246,8 @@ export const QUEUE_CONFIG = {
     disk: getThresholdConfig('disk', 'HIVE_MIND_DISK_THRESHOLD', 'HIVE_MIND_DISK_STRATEGY', 0.9, 'reject'),
     claude5Hour: getThresholdConfig('claude5Hour', 'HIVE_MIND_CLAUDE_5_HOUR_SESSION_THRESHOLD', 'HIVE_MIND_CLAUDE_5_HOUR_SESSION_STRATEGY', 0.65, 'dequeue-one-at-a-time'),
     claudeWeekly: getThresholdConfig('claudeWeekly', 'HIVE_MIND_CLAUDE_WEEKLY_THRESHOLD', 'HIVE_MIND_CLAUDE_WEEKLY_STRATEGY', 0.97, 'dequeue-one-at-a-time'),
+    codex5Hour: getThresholdConfig('codex5Hour', 'HIVE_MIND_CODEX_5_HOUR_SESSION_THRESHOLD', 'HIVE_MIND_CODEX_5_HOUR_SESSION_STRATEGY', 0.65, 'dequeue-one-at-a-time'),
+    codexWeekly: getThresholdConfig('codexWeekly', 'HIVE_MIND_CODEX_WEEKLY_THRESHOLD', 'HIVE_MIND_CODEX_WEEKLY_STRATEGY', 0.97, 'dequeue-one-at-a-time'),
     githubApi: getThresholdConfig('githubApi', 'HIVE_MIND_GITHUB_API_THRESHOLD', 'HIVE_MIND_GITHUB_API_STRATEGY', 0.75, 'enqueue'),
   },
 
@@ -256,6 +258,8 @@ export const QUEUE_CONFIG = {
   DISK_THRESHOLD: getThresholdConfig('disk', 'HIVE_MIND_DISK_THRESHOLD', 'HIVE_MIND_DISK_STRATEGY', 0.9, 'reject').value,
   CLAUDE_5_HOUR_SESSION_THRESHOLD: getThresholdConfig('claude5Hour', 'HIVE_MIND_CLAUDE_5_HOUR_SESSION_THRESHOLD', 'HIVE_MIND_CLAUDE_5_HOUR_SESSION_STRATEGY', 0.65, 'dequeue-one-at-a-time').value,
   CLAUDE_WEEKLY_THRESHOLD: getThresholdConfig('claudeWeekly', 'HIVE_MIND_CLAUDE_WEEKLY_THRESHOLD', 'HIVE_MIND_CLAUDE_WEEKLY_STRATEGY', 0.97, 'dequeue-one-at-a-time').value,
+  CODEX_5_HOUR_SESSION_THRESHOLD: getThresholdConfig('codex5Hour', 'HIVE_MIND_CODEX_5_HOUR_SESSION_THRESHOLD', 'HIVE_MIND_CODEX_5_HOUR_SESSION_STRATEGY', 0.65, 'dequeue-one-at-a-time').value,
+  CODEX_WEEKLY_THRESHOLD: getThresholdConfig('codexWeekly', 'HIVE_MIND_CODEX_WEEKLY_THRESHOLD', 'HIVE_MIND_CODEX_WEEKLY_STRATEGY', 0.97, 'dequeue-one-at-a-time').value,
   GITHUB_API_THRESHOLD: getThresholdConfig('githubApi', 'HIVE_MIND_GITHUB_API_THRESHOLD', 'HIVE_MIND_GITHUB_API_STRATEGY', 0.75, 'enqueue').value,
 
   // Timing
@@ -290,6 +294,8 @@ export const DISPLAY_THRESHOLDS = {
   DISK: thresholdToPercent(QUEUE_CONFIG.DISK_THRESHOLD),
   CLAUDE_5_HOUR_SESSION: thresholdToPercent(QUEUE_CONFIG.CLAUDE_5_HOUR_SESSION_THRESHOLD),
   CLAUDE_WEEKLY: thresholdToPercent(QUEUE_CONFIG.CLAUDE_WEEKLY_THRESHOLD),
+  CODEX_5_HOUR_SESSION: thresholdToPercent(QUEUE_CONFIG.CODEX_5_HOUR_SESSION_THRESHOLD),
+  CODEX_WEEKLY: thresholdToPercent(QUEUE_CONFIG.CODEX_WEEKLY_THRESHOLD),
   GITHUB_API: thresholdToPercent(QUEUE_CONFIG.GITHUB_API_THRESHOLD),
 };
 

package/src/solve.auto-continue.lib.mjs

@@ -160,6 +160,7 @@ export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, sho
     resumeArgs.push('--session-type', sessionType);
 
     // Preserve other flags from original invocation
+    if (argv.tool && argv.tool !== 'claude') resumeArgs.push('--tool', argv.tool);
     if (argv.model !== 'sonnet') resumeArgs.push('--model', argv.model);
     if (argv.verbose) resumeArgs.push('--verbose');
     if (argv.fork) resumeArgs.push('--fork');