@link-assistant/hive-mind 1.17.1 → 1.18.0

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # @link-assistant/hive-mind
 
+## 1.18.0
+
+### Minor Changes
+
+- 6b7f026: Add threshold markers to /limits command progress bars
+
+  This change implements visual threshold markers in the progress bars displayed by the /limits command. Users can now see:
+  - **Threshold position marker (│)**: Shows where queue behavior changes (e.g., blocking, one-at-a-time mode)
+  - **Warning emoji (⚠️)**: Appears when usage exceeds the threshold
+
+  Thresholds displayed:
+  - RAM: 65% (blocks new commands)
+  - CPU: 65% (blocks new commands)
+  - Disk: 90% (one-at-a-time mode)
+  - Claude 5-hour session: 65% (one-at-a-time mode)
+  - Claude weekly: 97% (one-at-a-time mode)
+  - GitHub API: 75% (blocks parallel claude commands)
+
+  Example output:
+
+  ```
+  CPU
+  ▓▓▓▓▓▓▓░░░░░░░░░░░░│░░░░░░░░░░ 25%
+  0.04/6 CPU cores used
+
+  Claude 5 hour session
+  ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓│▓ 98% ⚠️
+  Resets in 2h 10m (Dec 6, 12:00pm UTC)
+  ```
+
+  Fixes #1242
+
+## 1.17.2
+
+### Patch Changes
+
+- ae013b3: Default thinking budget to zero (thinking disabled by default), align Opus 4.6 max thinking budget with standard models (31999), change `opus` alias to map to Opus 4.5 by default (supports both `opus-4-5` and `opus-4-6` aliases)
+
 ## 1.17.1
 
 ### Patch Changes

package/package.json

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

package/src/claude.lib.mjs

@@ -911,23 +911,20 @@ export const executeClaudeCommand = async params => {
     try {
       // Resolve thinking settings (handles translation between --think and --thinking-budget based on Claude version)
       // See issue #1146 for details on thinking budget translation
-      const { thinkingBudget: resolvedThinkingBudget, thinkLevel, isNewVersion } = await resolveThinkingSettings(argv, log);
+      const { thinkingBudget: resolvedThinkingBudget, thinkLevel, isNewVersion, maxBudget } = await resolveThinkingSettings(argv, log);
 
       // Set CLAUDE_CODE_MAX_OUTPUT_TOKENS (see issue #1076), MAX_THINKING_TOKENS (see issue #1146),
-      // and MCP timeout configurations (see issue #1066)
+      // MCP timeout configurations (see issue #1066), and CLAUDE_CODE_EFFORT_LEVEL for Opus 4.6 (Issue #1238)
       // Pass model for model-specific max output tokens (Issue #1221)
-      const claudeEnv = getClaudeEnv({ thinkingBudget: resolvedThinkingBudget, model: mappedModel });
+      // Pass thinkLevel and maxBudget for Opus 4.6 effort level conversion (Issue #1238)
+      const claudeEnv = getClaudeEnv({ thinkingBudget: resolvedThinkingBudget, model: mappedModel, thinkLevel, maxBudget });
       const modelMaxOutputTokens = getMaxOutputTokensForModel(mappedModel);
       if (argv.verbose) await log(`📊 CLAUDE_CODE_MAX_OUTPUT_TOKENS: ${modelMaxOutputTokens}`, { verbose: true });
       if (argv.verbose) await log(`📊 MCP_TIMEOUT: ${claudeCode.mcpTimeout}ms (server startup)`, { verbose: true });
       if (argv.verbose) await log(`📊 MCP_TOOL_TIMEOUT: ${claudeCode.mcpToolTimeout}ms (tool execution)`, { verbose: true });
-      if (resolvedThinkingBudget !== undefined) {
-        await log(`📊 MAX_THINKING_TOKENS: ${resolvedThinkingBudget}`, { verbose: true });
-      }
-      // Log thinking level for older Claude Code versions that use thinking keywords
-      if (!isNewVersion && thinkLevel) {
-        await log(`📊 Thinking level (via keywords): ${thinkLevel}`, { verbose: true });
-      }
+      if (resolvedThinkingBudget !== undefined) await log(`📊 MAX_THINKING_TOKENS: ${resolvedThinkingBudget}`, { verbose: true });
+      if (claudeEnv.CLAUDE_CODE_EFFORT_LEVEL) await log(`📊 CLAUDE_CODE_EFFORT_LEVEL: ${claudeEnv.CLAUDE_CODE_EFFORT_LEVEL}`, { verbose: true });
+      if (!isNewVersion && thinkLevel) await log(`📊 Thinking level (via keywords): ${thinkLevel}`, { verbose: true });
       if (argv.resume) {
         // When resuming, pass prompt directly with -p flag. Escape double quotes for shell.
         const simpleEscapedPrompt = prompt.replace(/"/g, '\\"');

package/src/config.lib.mjs

@@ -119,21 +119,24 @@ export const claudeCode = {
 // Can be overridden via --max-thinking-budget option
 export const DEFAULT_MAX_THINKING_BUDGET = 31999;
 
-// Default max thinking budget for Opus 4.6 (Issue #1221)
-// Opus 4.6 supports higher thinking budgets due to 128K max output tokens
+// Default max thinking budget for Opus 4.6 (Issue #1221, updated in Issue #1238)
+// Aligned with standard models (31999) for consistency.
+// Opus 4.6 uses CLAUDE_CODE_EFFORT_LEVEL for thinking depth instead of MAX_THINKING_TOKENS
+// (MAX_THINKING_TOKENS is ignored for Opus 4.6 unless set to 0 to disable thinking).
 // Can be overridden via --max-thinking-budget option or HIVE_MIND_MAX_THINKING_BUDGET_OPUS_46
-export const DEFAULT_MAX_THINKING_BUDGET_OPUS_46 = parseIntWithDefault('HIVE_MIND_MAX_THINKING_BUDGET_OPUS_46', 64000);
+export const DEFAULT_MAX_THINKING_BUDGET_OPUS_46 = parseIntWithDefault('HIVE_MIND_MAX_THINKING_BUDGET_OPUS_46', 31999);
 
 /**
- * Check if a model is Opus 4.6 or later (Issue #1221)
+ * Check if a model is Opus 4.6 or later (Issue #1221, updated in Issue #1238)
  * @param {string} model - The model name or ID
  * @returns {boolean} True if the model is Opus 4.6 or later
  */
 export const isOpus46OrLater = model => {
   if (!model) return false;
   const normalizedModel = model.toLowerCase();
-  // Check for opus alias (which maps to 4.6) or explicit opus-4-6
-  return normalizedModel === 'opus' || normalizedModel.includes('opus-4-6') || normalizedModel.includes('opus-4-7') || normalizedModel.includes('opus-5');
+  // Check for explicit opus-4-6 or later versions
+  // Note: The 'opus' alias now maps to Opus 4.5 (Issue #1238), so we only check explicit version identifiers
+  return normalizedModel.includes('opus-4-6') || normalizedModel.includes('opus-4-7') || normalizedModel.includes('opus-5');
 };
 
 /**
@@ -202,6 +205,59 @@ export const getTokensToThinkingLevel = (maxBudget = DEFAULT_MAX_THINKING_BUDGET
 // Default tokens to thinking level function (using default max budget)
 export const tokensToThinkingLevel = getTokensToThinkingLevel(DEFAULT_MAX_THINKING_BUDGET);
 
+/**
+ * Valid effort levels for Opus 4.6 (Issue #1238)
+ * Opus 4.6 uses CLAUDE_CODE_EFFORT_LEVEL for thinking depth control
+ * @type {string[]}
+ */
+export const OPUS_46_EFFORT_LEVELS = ['low', 'medium', 'high'];
+
+/**
+ * Convert thinking level to Opus 4.6 effort level (Issue #1238)
+ * Opus 4.6 uses CLAUDE_CODE_EFFORT_LEVEL (low/medium/high) instead of MAX_THINKING_TOKENS
+ * @param {string|undefined} thinkLevel - The thinking level (off/low/medium/high/max)
+ * @returns {string|undefined} The effort level (low/medium/high) or undefined if thinking is off
+ */
+export const thinkLevelToEffortLevel = thinkLevel => {
+  if (!thinkLevel || thinkLevel === 'off') {
+    // No effort level when thinking is disabled
+    return undefined;
+  }
+
+  // Map hive-mind thinking levels to Opus 4.6 effort levels
+  // Note: Opus 4.6 only supports low/medium/high, not 'max'
+  // We map 'max' to 'high' as it's the highest available level
+  switch (thinkLevel) {
+    case 'low':
+      return 'low';
+    case 'medium':
+      return 'medium';
+    case 'high':
+    case 'max':
+      return 'high';
+    default:
+      return undefined;
+  }
+};
+
+/**
+ * Convert thinking budget (tokens) to Opus 4.6 effort level (Issue #1238)
+ * Uses token thresholds to determine the appropriate effort level
+ * @param {number|undefined} thinkingBudget - The thinking budget in tokens
+ * @param {number} maxBudget - Maximum thinking budget (default: 31999)
+ * @returns {string|undefined} The effort level (low/medium/high) or undefined if thinking is off
+ */
+export const thinkingBudgetToEffortLevel = (thinkingBudget, maxBudget = DEFAULT_MAX_THINKING_BUDGET) => {
+  if (thinkingBudget === undefined || thinkingBudget === 0) {
+    // No effort level when thinking is disabled
+    return undefined;
+  }
+
+  // Convert tokens to thinking level, then to effort level
+  const thinkLevel = getTokensToThinkingLevel(maxBudget)(thinkingBudget);
+  return thinkLevelToEffortLevel(thinkLevel);
+};
+
 // Check if a version supports thinking budget (>= minimum version)
 // Uses semver npm package for reliable version comparison (see issue #1146)
 export const supportsThinkingBudget = (version, minVersion = '2.1.12') => {
@@ -221,6 +277,7 @@ export const supportsThinkingBudget = (version, minVersion = '2.1.12') => {
 // Optionally sets MAX_THINKING_TOKENS when thinkingBudget is provided (see issue #1146)
 // Also sets MCP_TIMEOUT and MCP_TOOL_TIMEOUT for MCP tool execution (see issue #1066)
 // Supports model-specific max output tokens for Opus 4.6 (Issue #1221)
+// Sets CLAUDE_CODE_EFFORT_LEVEL for Opus 4.6 models (Issue #1238)
 export const getClaudeEnv = (options = {}) => {
   // Get max output tokens based on model (Issue #1221)
   const maxOutputTokens = options.model ? getMaxOutputTokensForModel(options.model) : claudeCode.maxOutputTokens;
@@ -235,12 +292,29 @@ export const getClaudeEnv = (options = {}) => {
     MCP_TIMEOUT: String(claudeCode.mcpTimeout),
     MCP_TOOL_TIMEOUT: String(claudeCode.mcpToolTimeout),
   };
-  // Set MAX_THINKING_TOKENS if thinkingBudget is provided
-  // This controls Claude Code's extended thinking feature (Claude Code >= 2.1.12)
-  // Default is 31999 (or 64000 for Opus 4.6), set to 0 to disable thinking
-  if (options.thinkingBudget !== undefined) {
-    env.MAX_THINKING_TOKENS = String(options.thinkingBudget);
+
+  // Set MAX_THINKING_TOKENS to control Claude Code's extended thinking feature (Claude Code >= 2.1.12)
+  // Default is 0 (thinking disabled) per Issue #1238. Set to 0 to disable thinking.
+  // Users can explicitly enable thinking via --think or --thinking-budget options.
+  env.MAX_THINKING_TOKENS = String(options.thinkingBudget ?? 0);
+
+  // For Opus 4.6+, also set CLAUDE_CODE_EFFORT_LEVEL to control thinking depth (Issue #1238)
+  // Opus 4.6 uses effort level (low/medium/high) instead of MAX_THINKING_TOKENS for thinking depth.
+  // MAX_THINKING_TOKENS is only used to disable thinking (when set to 0).
+  if (options.model && isOpus46OrLater(options.model)) {
+    // Convert thinkLevel or thinkingBudget to effort level
+    let effortLevel;
+    if (options.thinkLevel) {
+      effortLevel = thinkLevelToEffortLevel(options.thinkLevel);
+    } else if (options.thinkingBudget !== undefined && options.thinkingBudget > 0) {
+      effortLevel = thinkingBudgetToEffortLevel(options.thinkingBudget, options.maxBudget);
+    }
+
+    if (effortLevel) {
+      env.CLAUDE_CODE_EFFORT_LEVEL = effortLevel;
+    }
   }
+
   return env;
 };
 

package/src/limits.lib.mjs

@@ -18,6 +18,12 @@ dayjs.extend(utc);
 // Import cache TTL configuration
 import { cacheTtl } from './config.lib.mjs';
 
+// Import centralized queue thresholds for progress bar visualization
+// This ensures thresholds are consistent between queue logic and display formatting
+// See: https://github.com/link-assistant/hive-mind/issues/1242
+export { DISPLAY_THRESHOLDS } from './queue-config.lib.mjs';
+import { DISPLAY_THRESHOLDS } from './queue-config.lib.mjs';
+
 const execAsync = promisify(exec);
 
 /**
@@ -626,13 +632,35 @@ export async function getClaudeUsageLimits(verbose = false, credentialsPath = DE
 /**
  * Generate a text-based progress bar for usage percentage
  * @param {number} percentage - Usage percentage (0-100)
+ * @param {number|null} thresholdPercentage - Optional threshold position to show in the bar (0-100)
  * @returns {string} Text-based progress bar
+ * @see https://github.com/link-assistant/hive-mind/issues/1242
  */
-export function getProgressBar(percentage) {
+export function getProgressBar(percentage, thresholdPercentage = null) {
   const totalBlocks = 30;
   const filledBlocks = Math.round((percentage / 100) * totalBlocks);
-  const emptyBlocks = totalBlocks - filledBlocks;
-  return '\u2593'.repeat(filledBlocks) + '\u2591'.repeat(emptyBlocks);
+
+  if (thresholdPercentage === null) {
+    // No threshold - original behavior
+    const emptyBlocks = totalBlocks - filledBlocks;
+    return '\u2593'.repeat(filledBlocks) + '\u2591'.repeat(emptyBlocks);
+  }
+
+  // With threshold marker
+  const thresholdPos = Math.round((thresholdPercentage / 100) * totalBlocks);
+  let bar = '';
+
+  for (let i = 0; i < totalBlocks; i++) {
+    if (i === thresholdPos) {
+      bar += '│'; // Threshold marker (U+2502 Box Drawings Light Vertical)
+    } else if (i < filledBlocks) {
+      bar += '▓'; // Filled (U+2593)
+    } else {
+      bar += '░'; // Empty (U+2591)
+    }
+  }
+
+  return bar;
 }
 
 /**
@@ -664,12 +692,15 @@ export function calculateTimePassedPercentage(resetsAt, periodHours) {
 
 /**
  * Format Claude usage data into a Telegram-friendly message
+ * Shows threshold markers in progress bars to indicate where queue behavior changes.
+ *
  * @param {Object} usage - The usage object from getClaudeUsageLimits
  * @param {Object} diskSpace - Optional disk space info from getDiskSpaceInfo
  * @param {Object} githubRateLimit - Optional GitHub rate limit info from getGitHubRateLimits
  * @param {Object} cpuLoad - Optional CPU load info from getCpuLoadInfo
  * @param {Object} memory - Optional memory info from getMemoryInfo
  * @returns {string} Formatted message
+ * @see https://github.com/link-assistant/hive-mind/issues/1242
  */
 export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = null, cpuLoad = null, memory = null) {
   // Use code block for monospace font to align progress bars properly
@@ -679,38 +710,46 @@ export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = nu
   message += `Current time: ${formatCurrentTime()}\n\n`;
 
   // CPU load section (if provided)
+  // Threshold: Blocks new commands when usage >= 65%
   if (cpuLoad) {
     message += 'CPU\n';
-    const usedBar = getProgressBar(cpuLoad.usagePercentage);
-    message += `${usedBar} ${cpuLoad.usagePercentage}% used\n`;
+    const usedBar = getProgressBar(cpuLoad.usagePercentage, DISPLAY_THRESHOLDS.CPU);
+    const warning = cpuLoad.usagePercentage >= DISPLAY_THRESHOLDS.CPU ? ' ⚠️' : '';
+    message += `${usedBar} ${cpuLoad.usagePercentage}%${warning}\n`;
     // Show cores used based on 5m load average (e.g., "0.04/6 CPU cores used" or "3/6 CPU cores used")
     // Use parseFloat to strip unnecessary trailing zeros (3.00 -> 3, 0.10 -> 0.1, 0.04 -> 0.04)
     message += `${parseFloat(cpuLoad.loadAvg5.toFixed(2))}/${cpuLoad.cpuCount} CPU cores used\n\n`;
   }
 
   // Memory section (if provided)
+  // Threshold: Blocks new commands when usage >= 65%
   if (memory) {
     message += 'RAM\n';
-    const usedBar = getProgressBar(memory.usedPercentage);
-    message += `${usedBar} ${memory.usedPercentage}% used\n`;
+    const usedBar = getProgressBar(memory.usedPercentage, DISPLAY_THRESHOLDS.RAM);
+    const warning = memory.usedPercentage >= DISPLAY_THRESHOLDS.RAM ? ' ⚠️' : '';
+    message += `${usedBar} ${memory.usedPercentage}%${warning}\n`;
     message += `${formatBytesRange(memory.usedBytes, memory.totalBytes)}\n\n`;
   }
 
   // Disk space section (if provided)
+  // Threshold: One-at-a-time mode when usage >= 90%
   if (diskSpace) {
     message += 'Disk space\n';
-    // Show used percentage with progress bar
-    const usedBar = getProgressBar(diskSpace.usedPercentage);
-    message += `${usedBar} ${diskSpace.usedPercentage}% used\n`;
+    // Show used percentage with progress bar and threshold marker
+    const usedBar = getProgressBar(diskSpace.usedPercentage, DISPLAY_THRESHOLDS.DISK);
+    const warning = diskSpace.usedPercentage >= DISPLAY_THRESHOLDS.DISK ? ' ⚠️' : '';
+    message += `${usedBar} ${diskSpace.usedPercentage}%${warning}\n`;
     message += `${formatBytesRange(diskSpace.usedBytes, diskSpace.totalBytes)}\n\n`;
   }
 
   // GitHub API rate limits section (if provided)
+  // Threshold: Blocks parallel claude commands when >= 75%
   if (githubRateLimit) {
     message += 'GitHub API\n';
-    // Show used percentage with progress bar
-    const usedBar = getProgressBar(githubRateLimit.usedPercentage);
-    message += `${usedBar} ${githubRateLimit.usedPercentage}% used\n`;
+    // Show used percentage with progress bar and threshold marker
+    const usedBar = getProgressBar(githubRateLimit.usedPercentage, DISPLAY_THRESHOLDS.GITHUB_API);
+    const warning = githubRateLimit.usedPercentage >= DISPLAY_THRESHOLDS.GITHUB_API ? ' ⚠️' : '';
+    message += `${usedBar} ${githubRateLimit.usedPercentage}%${warning}\n`;
     message += `${githubRateLimit.used}/${githubRateLimit.limit} requests used\n`;
     if (githubRateLimit.relativeReset) {
       message += `Resets in ${githubRateLimit.relativeReset} (${githubRateLimit.resetTime})\n`;
@@ -721,21 +760,23 @@ export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = nu
   }
 
   // Claude 5 hour session (five_hour)
+  // Threshold: One-at-a-time mode when usage >= 65%
   message += 'Claude 5 hour session\n';
   if (usage.currentSession.percentage !== null) {
-    // Add time passed progress bar first
+    // Add time passed progress bar first (no threshold marker for time)
     const timePassed = calculateTimePassedPercentage(usage.currentSession.resetsAt, 5);
     if (timePassed !== null) {
       const timeBar = getProgressBar(timePassed);
       message += `${timeBar} ${timePassed}% passed\n`;
     }
 
-    // Add usage progress bar second
+    // Add usage progress bar second with threshold marker
     // 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`;
+    const bar = getProgressBar(pct, DISPLAY_THRESHOLDS.CLAUDE_5_HOUR_SESSION);
+    const warning = pct >= DISPLAY_THRESHOLDS.CLAUDE_5_HOUR_SESSION ? ' ⚠️' : '';
+    message += `${bar} ${pct}%${warning}\n`;
 
     if (usage.currentSession.resetTime) {
       const relativeTime = formatRelativeTime(usage.currentSession.resetsAt);
@@ -751,21 +792,23 @@ export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = nu
   message += '\n';
 
   // Current week (all models / seven_day)
+  // Threshold: One-at-a-time mode when usage >= 97%
   message += 'Current week (all models)\n';
   if (usage.allModels.percentage !== null) {
-    // Add time passed progress bar first (168 hours = 7 days)
+    // Add time passed progress bar first (no threshold marker for time)
     const timePassed = calculateTimePassedPercentage(usage.allModels.resetsAt, 168);
     if (timePassed !== null) {
       const timeBar = getProgressBar(timePassed);
       message += `${timeBar} ${timePassed}% passed\n`;
     }
 
-    // Add usage progress bar second
+    // Add usage progress bar second with threshold marker
     // 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`;
+    const bar = getProgressBar(pct, DISPLAY_THRESHOLDS.CLAUDE_WEEKLY);
+    const warning = pct >= DISPLAY_THRESHOLDS.CLAUDE_WEEKLY ? ' ⚠️' : '';
+    message += `${bar} ${pct}%${warning}\n`;
 
     if (usage.allModels.resetTime) {
       const relativeTime = formatRelativeTime(usage.allModels.resetsAt);
@@ -781,21 +824,23 @@ export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = nu
   message += '\n';
 
   // Current week (Sonnet only / seven_day_sonnet)
+  // Threshold: One-at-a-time mode when usage >= 97% (same as all models)
   message += 'Current week (Sonnet only)\n';
   if (usage.sonnetOnly.percentage !== null) {
-    // Add time passed progress bar first (168 hours = 7 days)
+    // Add time passed progress bar first (no threshold marker for time)
     const timePassed = calculateTimePassedPercentage(usage.sonnetOnly.resetsAt, 168);
     if (timePassed !== null) {
       const timeBar = getProgressBar(timePassed);
       message += `${timeBar} ${timePassed}% passed\n`;
     }
 
-    // Add usage progress bar second
+    // Add usage progress bar second with threshold marker
     // 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`;
+    const bar = getProgressBar(pct, DISPLAY_THRESHOLDS.CLAUDE_WEEKLY);
+    const warning = pct >= DISPLAY_THRESHOLDS.CLAUDE_WEEKLY ? ' ⚠️' : '';
+    message += `${bar} ${pct}%${warning}\n`;
 
     if (usage.sonnetOnly.resetTime) {
       const relativeTime = formatRelativeTime(usage.sonnetOnly.resetsAt);
@@ -973,6 +1018,8 @@ export default {
   getProgressBar,
   calculateTimePassedPercentage,
   formatUsageMessage,
+  // Threshold constants for progress bar visualization
+  DISPLAY_THRESHOLDS,
   // Cache management
   CACHE_TTL,
   getLimitCache,

package/src/model-mapping.lib.mjs

@@ -6,10 +6,10 @@
  */
 
 // Claude models (Anthropic API)
-// Updated for Opus 4.6 support (Issue #1221)
+// Updated for Opus 4.5/4.6 support (Issue #1221, Issue #1238)
 export const claudeModels = {
   sonnet: 'claude-sonnet-4-5-20250929', // Sonnet 4.5
-  opus: 'claude-opus-4-6', // Opus 4.6 (latest)
+  opus: 'claude-opus-4-5-20251101', // Opus 4.5 (default, Issue #1238)
   haiku: 'claude-haiku-4-5-20251001', // Haiku 4.5
   'haiku-3-5': 'claude-3-5-haiku-20241022', // Haiku 3.5
   'haiku-3': 'claude-3-haiku-20240307', // Haiku 3

package/src/model-validation.lib.mjs

@@ -15,7 +15,7 @@ import { log } from './lib.mjs';
 export const CLAUDE_MODELS = {
   // Short aliases (single word)
   sonnet: 'claude-sonnet-4-5-20250929',
-  opus: 'claude-opus-4-6', // Updated to Opus 4.6 (Issue #1221)
+  opus: 'claude-opus-4-5-20251101', // Changed to Opus 4.5 (Issue #1238)
   haiku: 'claude-haiku-4-5-20251001',
   'haiku-3-5': 'claude-3-5-haiku-20241022',
   'haiku-3': 'claude-3-haiku-20240307',
@@ -25,8 +25,8 @@ export const CLAUDE_MODELS = {
   'sonnet-4-5': 'claude-sonnet-4-5-20250929', // Sonnet 4.5 short alias
   'haiku-4-5': 'claude-haiku-4-5-20251001', // Haiku 4.5 short alias
   // Opus version aliases (Issue #1221)
-  'claude-opus-4-6': 'claude-opus-4-6', // Latest Opus
-  'claude-opus-4-5': 'claude-opus-4-5-20251101', // Backward compatibility alias
+  'claude-opus-4-6': 'claude-opus-4-6', // Opus 4.6
+  'claude-opus-4-5': 'claude-opus-4-5-20251101', // Opus 4.5
   // Sonnet version aliases
   'claude-sonnet-4-5': 'claude-sonnet-4-5-20250929',
   // Haiku version aliases
@@ -39,15 +39,17 @@ export const CLAUDE_MODELS = {
   'claude-3-haiku-20240307': 'claude-3-haiku-20240307',
 };
 
-// Models that support 1M token context window via [1m] suffix (Issue #1221)
+// Models that support 1M token context window via [1m] suffix (Issue #1221, Issue #1238)
 // See: https://code.claude.com/docs/en/model-config
 export const MODELS_SUPPORTING_1M_CONTEXT = [
   'claude-opus-4-6',
+  'claude-opus-4-5-20251101',
   'claude-sonnet-4-5-20250929',
   'claude-sonnet-4-5',
   'sonnet',
   'opus',
   'opus-4-6', // Short alias (Issue #1221 - PR comment feedback)
+  'opus-4-5', // Short alias (Issue #1238)
   'sonnet-4-5', // Short alias (Issue #1221 - PR comment feedback)
 ];
 

package/src/queue-config.lib.mjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+
+/**
+ * Queue Configuration Module
+ *
+ * Centralized configuration for queue throttling and resource thresholds.
+ * This module is used by both telegram-solve-queue.lib.mjs (queue logic)
+ * and limits.lib.mjs (display formatting).
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1242
+ */
+
+// Use use-m to dynamically import modules
+if (typeof globalThis.use === 'undefined') {
+  try {
+    globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
+  } catch (error) {
+    console.error('❌ Fatal error: Failed to load dependencies for queue configuration');
+    console.error(`   ${error.message}`);
+    console.error('   This might be due to network issues or missing dependencies.');
+    console.error('   Please check your internet connection and try again.');
+    process.exit(1);
+  }
+}
+
+const getenv = await use('getenv');
+
+// Helper function to safely parse floats with fallback
+const parseFloatWithDefault = (envVar, defaultValue) => {
+  const value = getenv(envVar, defaultValue.toString());
+  const parsed = parseFloat(value);
+  return isNaN(parsed) ? defaultValue : parsed;
+};
+
+// Helper function to safely parse integers with fallback
+const parseIntWithDefault = (envVar, defaultValue) => {
+  const value = getenv(envVar, defaultValue.toString());
+  const parsed = parseInt(value);
+  return isNaN(parsed) ? defaultValue : parsed;
+};
+
+/**
+ * Configuration constants for queue throttling
+ * All thresholds use ratios (0.0 - 1.0) representing usage percentage
+ *
+ * IMPORTANT: Running claude processes is NOT a blocking limit by itself.
+ * Commands can run in parallel as long as actual limits (CPU, API, etc.) are not exceeded.
+ * See: https://github.com/link-assistant/hive-mind/issues/1078
+ */
+export const QUEUE_CONFIG = {
+  // Resource thresholds (usage ratios: 0.0 - 1.0)
+  // All thresholds use >= comparison (inclusive)
+  RAM_THRESHOLD: parseFloatWithDefault('HIVE_MIND_RAM_THRESHOLD', 0.65), // Enqueue if RAM usage >= 65%
+  // CPU threshold uses 5-minute load average, not instantaneous CPU usage
+  CPU_THRESHOLD: parseFloatWithDefault('HIVE_MIND_CPU_THRESHOLD', 0.65), // Enqueue if 5-minute load average >= 65% of CPU count
+  DISK_THRESHOLD: parseFloatWithDefault('HIVE_MIND_DISK_THRESHOLD', 0.9), // One-at-a-time if disk usage >= 90%, tuned for VM with 100 GB drive
+
+  // API limit thresholds (usage ratios: 0.0 - 1.0)
+  // All thresholds use >= comparison (inclusive)
+  // Fine-tuned for Claude MAX $200 subscription
+  CLAUDE_5_HOUR_SESSION_THRESHOLD: parseFloatWithDefault('HIVE_MIND_CLAUDE_5_HOUR_SESSION_THRESHOLD', 0.65), // One-at-a-time if 5-hour limit >= 65%
+  CLAUDE_WEEKLY_THRESHOLD: parseFloatWithDefault('HIVE_MIND_CLAUDE_WEEKLY_THRESHOLD', 0.97), // One-at-a-time if weekly limit >= 97%
+  GITHUB_API_THRESHOLD: parseFloatWithDefault('HIVE_MIND_GITHUB_API_THRESHOLD', 0.75), // Enqueue if GitHub >= 75% with parallel claude
+
+  // Timing
+  // MIN_START_INTERVAL_MS: Time to allow solve command to start actual claude process
+  // This ensures that when API limits are checked, the running process is counted
+  MIN_START_INTERVAL_MS: parseIntWithDefault('HIVE_MIND_MIN_START_INTERVAL_MS', 60000), // 1 minute between starts
+  CONSUMER_POLL_INTERVAL_MS: parseIntWithDefault('HIVE_MIND_CONSUMER_POLL_INTERVAL_MS', 60000), // 1 minute between queue checks
+  MESSAGE_UPDATE_INTERVAL_MS: parseIntWithDefault('HIVE_MIND_MESSAGE_UPDATE_INTERVAL_MS', 60000), // 1 minute between status message updates
+
+  // Process detection
+  CLAUDE_PROCESS_NAMES: ['claude'], // Process names to detect
+};
+
+/**
+ * Convert threshold ratio to percentage for display
+ * @param {number} ratio - Threshold ratio (0.0 - 1.0)
+ * @returns {number} Percentage value (0 - 100)
+ */
+export function thresholdToPercent(ratio) {
+  return Math.round(ratio * 100);
+}
+
+/**
+ * Display threshold constants for progress bar visualization
+ * These are derived from QUEUE_CONFIG and converted to percentages (0-100)
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1242
+ */
+export const DISPLAY_THRESHOLDS = {
+  RAM: thresholdToPercent(QUEUE_CONFIG.RAM_THRESHOLD), // Blocks at 65%
+  CPU: thresholdToPercent(QUEUE_CONFIG.CPU_THRESHOLD), // Blocks at 65%
+  DISK: thresholdToPercent(QUEUE_CONFIG.DISK_THRESHOLD), // One-at-a-time at 90%
+  CLAUDE_5_HOUR_SESSION: thresholdToPercent(QUEUE_CONFIG.CLAUDE_5_HOUR_SESSION_THRESHOLD), // One-at-a-time at 65%
+  CLAUDE_WEEKLY: thresholdToPercent(QUEUE_CONFIG.CLAUDE_WEEKLY_THRESHOLD), // One-at-a-time at 97%
+  GITHUB_API: thresholdToPercent(QUEUE_CONFIG.GITHUB_API_THRESHOLD), // Blocks parallel claude at 75%
+};
+
+export default {
+  QUEUE_CONFIG,
+  DISPLAY_THRESHOLDS,
+  thresholdToPercent,
+};

package/src/solve.config.lib.mjs

@@ -220,7 +220,7 @@ export const SOLVE_OPTION_DEFINITIONS = {
   },
   'thinking-budget': {
     type: 'number',
-    description: 'Thinking token budget for Claude Code (0-63999). Controls MAX_THINKING_TOKENS. Default: 31999 (Claude default). Set to 0 to disable thinking. For older Claude Code versions, translated back to --think level.',
+    description: 'Thinking token budget for Claude Code (0-31999). Controls MAX_THINKING_TOKENS. Default: 0 (thinking disabled). For older Claude Code versions, translated back to --think level.',
     default: undefined,
   },
   'thinking-budget-claude-minimum-version': {

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

@@ -23,39 +23,11 @@ const execAsync = promisify(exec);
 // Import centralized limits and caching
 import { getCachedClaudeLimits, getCachedGitHubLimits, getCachedMemoryInfo, getCachedCpuInfo, getCachedDiskInfo, getLimitCache } from './limits.lib.mjs';
 
-/**
- * Configuration constants for queue throttling
- * All thresholds use ratios (0.0 - 1.0) representing usage percentage
- *
- * IMPORTANT: Running claude processes is NOT a blocking limit by itself.
- * Commands can run in parallel as long as actual limits (CPU, API, etc.) are not exceeded.
- * See: https://github.com/link-assistant/hive-mind/issues/1078
- */
-export const QUEUE_CONFIG = {
-  // Resource thresholds (usage ratios: 0.0 - 1.0)
-  // All thresholds use >= comparison (inclusive)
-  RAM_THRESHOLD: 0.65, // Enqueue if RAM usage >= 65%
-  // CPU threshold uses 5-minute load average, not instantaneous CPU usage
-  CPU_THRESHOLD: 0.65, // Enqueue if 5-minute load average >= 65% of CPU count
-  DISK_THRESHOLD: 0.9, // One-at-a-time if disk usage >= 90%, tuned for VM with 100 GB drive
-
-  // API limit thresholds (usage ratios: 0.0 - 1.0)
-  // All thresholds use >= comparison (inclusive)
-  // Fine-tuned for Claude MAX $200 subscription
-  CLAUDE_5_HOUR_SESSION_THRESHOLD: 0.65, // One-at-a-time if 5-hour limit >= 65%
-  CLAUDE_WEEKLY_THRESHOLD: 0.97, // One-at-a-time if weekly limit >= 97%
-  GITHUB_API_THRESHOLD: 0.75, // Enqueue if GitHub >= 75% with parallel claude
-
-  // Timing
-  // MIN_START_INTERVAL_MS: Time to allow solve command to start actual claude process
-  // This ensures that when API limits are checked, the running process is counted
-  MIN_START_INTERVAL_MS: 60000, // 1 minutes between starts
-  CONSUMER_POLL_INTERVAL_MS: 60000, // 1 minute between queue checks
-  MESSAGE_UPDATE_INTERVAL_MS: 60000, // 1 minute between status message updates
-
-  // Process detection
-  CLAUDE_PROCESS_NAMES: ['claude'], // Process names to detect
-};
+// 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
+export { QUEUE_CONFIG } from './queue-config.lib.mjs';
+import { QUEUE_CONFIG } from './queue-config.lib.mjs';
 
 /**
  * Status enum for queue items