@link-assistant/hive-mind 1.51.0 → 1.52.1

package/src/claude.lib.mjs

@@ -13,6 +13,7 @@ import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs
 import { createInteractiveHandler } from './interactive-mode.lib.mjs';
 import { initProgressMonitoring } from './solve.progress-monitoring.lib.mjs';
 import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
+import Decimal from 'decimal.js-light';
 import { displayBudgetStats, createEmptySubSessionUsage, accumulateModelUsage, displayModelUsage, displayCostComparison, mergeResultModelUsage, createSubAgentCallEntry, accumulateSubAgentUsage } from './claude.budget-stats.lib.mjs';
 import { buildClaudeResumeCommand } from './claude.command-builder.lib.mjs';
 import { handleClaudeRuntimeSwitch } from './claude.runtime-switch.lib.mjs'; // see issue #1141
@@ -301,6 +302,7 @@ export const executeClaude = async params => {
     owner,
     repo,
     argv,
+    claudeVersion: getClaudeVersion(),
   });
   // Build the system prompt
   const systemPrompt = buildSystemPrompt({
@@ -428,51 +430,48 @@ export const checkModelVisionCapability = async modelId => {
     return false;
   }
 };
-/** Calculate USD cost for a model's usage with detailed breakdown */
+/** Calculate USD cost for a model's usage with detailed breakdown (Issue #1600: uses Decimal for precision) */
 export const calculateModelCost = (usage, modelInfo, includeBreakdown = false) => {
   if (!modelInfo || !modelInfo.cost) {
     return includeBreakdown ? { total: 0, breakdown: null } : 0;
   }
   const cost = modelInfo.cost;
+  const million = new Decimal(1000000);
   const breakdown = {
     input: { tokens: 0, costPerMillion: 0, cost: 0 },
     cacheWrite: { tokens: 0, costPerMillion: 0, cost: 0 },
     cacheRead: { tokens: 0, costPerMillion: 0, cost: 0 },
     output: { tokens: 0, costPerMillion: 0, cost: 0 },
   };
-  // Input tokens cost (per million tokens)
   if (usage.inputTokens && cost.input) {
     breakdown.input = {
       tokens: usage.inputTokens,
       costPerMillion: cost.input,
-      cost: (usage.inputTokens / 1000000) * cost.input,
+      cost: new Decimal(usage.inputTokens).div(million).mul(new Decimal(cost.input)).toNumber(),
     };
   }
-  // Cache creation tokens cost
   if (usage.cacheCreationTokens && cost.cache_write) {
     breakdown.cacheWrite = {
       tokens: usage.cacheCreationTokens,
       costPerMillion: cost.cache_write,
-      cost: (usage.cacheCreationTokens / 1000000) * cost.cache_write,
+      cost: new Decimal(usage.cacheCreationTokens).div(million).mul(new Decimal(cost.cache_write)).toNumber(),
     };
   }
-  // Cache read tokens cost
   if (usage.cacheReadTokens && cost.cache_read) {
     breakdown.cacheRead = {
       tokens: usage.cacheReadTokens,
       costPerMillion: cost.cache_read,
-      cost: (usage.cacheReadTokens / 1000000) * cost.cache_read,
+      cost: new Decimal(usage.cacheReadTokens).div(million).mul(new Decimal(cost.cache_read)).toNumber(),
     };
   }
-  // Output tokens cost
   if (usage.outputTokens && cost.output) {
     breakdown.output = {
       tokens: usage.outputTokens,
       costPerMillion: cost.output,
-      cost: (usage.outputTokens / 1000000) * cost.output,
+      cost: new Decimal(usage.outputTokens).div(million).mul(new Decimal(cost.output)).toNumber(),
     };
   }
-  const totalCost = breakdown.input.cost + breakdown.cacheWrite.cost + breakdown.cacheRead.cost + breakdown.output.cost;
+  const totalCost = new Decimal(breakdown.input.cost).plus(breakdown.cacheWrite.cost).plus(breakdown.cacheRead.cost).plus(breakdown.output.cost).toNumber();
   if (includeBreakdown) {
     return {
       total: totalCost,
@@ -618,7 +617,7 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
     let totalCacheCreationTokens = 0;
     let totalCacheReadTokens = 0;
     let totalOutputTokens = 0;
-    let totalCostUSD = 0;
+    let totalCostDecimal = new Decimal(0);
     let hasCostData = false;
     for (const usage of Object.values(modelUsage)) {
       totalInputTokens += usage.inputTokens;
@@ -626,7 +625,7 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
       totalCacheReadTokens += usage.cacheReadTokens;
       totalOutputTokens += usage.outputTokens;
       if (usage.costUSD !== null) {
-        totalCostUSD += usage.costUSD;
+        totalCostDecimal = totalCostDecimal.plus(new Decimal(usage.costUSD));
         hasCostData = true;
       }
     }
@@ -641,7 +640,7 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
       cacheReadTokens: totalCacheReadTokens,
       outputTokens: totalOutputTokens,
       totalTokens,
-      totalCostUSD: hasCostData ? totalCostUSD : null,
+      totalCostUSD: hasCostData ? totalCostDecimal.toNumber() : null,
       // Issue #1501: Peak context usage (max single-request fill) and dedup stats
       peakContextUsage: globalPeakContext,
       duplicateEntriesSkipped: duplicateCount,
@@ -784,7 +783,7 @@ export const executeClaudeCommand = async params => {
     }
     try {
       const { thinkingBudget: resolvedThinkingBudget, thinkLevel, isNewVersion, maxBudget } = await resolveThinkingSettings(argv, log);
-      const claudeEnv = getClaudeEnv({ thinkingBudget: resolvedThinkingBudget, model: effectiveModel, thinkLevel, maxBudget, planModel: resolvedPlanModel, executionModel: resolvedExecutionModel });
+      const claudeEnv = getClaudeEnv({ thinkingBudget: resolvedThinkingBudget, model: effectiveModel, thinkLevel, maxBudget, planModel: resolvedPlanModel, executionModel: resolvedExecutionModel, showThinkingContent: argv.showThinkingContent });
       if (argv.verbose) claudeEnv.ANTHROPIC_LOG = 'debug';
       const modelMaxOutputTokens = getMaxOutputTokensForModel(effectiveModel);
       if (argv.verbose) {
@@ -792,6 +791,7 @@ export const executeClaudeCommand = async params => {
         if (resolvedPlanModel) await log(`📊 opusplan: plan=${resolvedPlanModel}, exec=${resolvedExecutionModel}`, { 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 (claudeEnv.CLAUDE_CODE_SHOW_THINKING) await log(`📊 CLAUDE_CODE_SHOW_THINKING: ${claudeEnv.CLAUDE_CODE_SHOW_THINKING}`, { verbose: true });
         if (!isNewVersion && thinkLevel) await log(`📊 Thinking level (via keywords): ${thinkLevel}`, { verbose: true });
       }
       const simpleEscapedSystem = systemPrompt.replace(/"/g, '\\"');

package/src/claude.prompts.lib.mjs

@@ -6,6 +6,7 @@
 import { getArchitectureCareSubPrompt } from './architecture-care.prompts.lib.mjs';
 import { getExperimentsExamplesSubPrompt } from './experiments-examples.prompts.lib.mjs';
 import { primaryModelNames } from './models/index.mjs';
+import { getThinkingPromptInstruction } from './thinking-prompt.lib.mjs';
 
 /**
  * Build the user prompt for Claude
@@ -13,7 +14,7 @@ import { primaryModelNames } from './models/index.mjs';
  * @returns {string} The formatted user prompt
  */
 export const buildUserPrompt = params => {
-  const { issueUrl, issueNumber, prNumber, prUrl, branchName, tempDir, workspaceTmpDir, isContinueMode, forkedRepo, feedbackLines, owner, repo, argv, contributingGuidelines } = params;
+  const { issueUrl, issueNumber, prNumber, prUrl, branchName, tempDir, workspaceTmpDir, isContinueMode, forkedRepo, feedbackLines, owner, repo, argv, contributingGuidelines, claudeVersion } = params;
 
   const promptLines = [];
 
@@ -65,18 +66,9 @@ export const buildUserPrompt = params => {
     promptLines.push('');
   }
 
-  // Note: --think keywords are deprecated for Claude Code >= 2.1.12
-  // Thinking is now enabled by default with 31,999 token budget
-  // Use --thinking-budget to control MAX_THINKING_TOKENS instead
-  // Keeping keywords for backward compatibility with older Claude Code versions
-  if (argv && argv.think) {
-    const thinkMessages = {
-      low: 'Think.',
-      medium: 'Think hard.',
-      high: 'Think harder.',
-      max: 'Ultrathink.',
-    };
-    promptLines.push(thinkMessages[argv.think]);
+  const thinkingPromptInstruction = getThinkingPromptInstruction({ tool: 'claude', argv, claudeVersion });
+  if (thinkingPromptInstruction) {
+    promptLines.push(thinkingPromptInstruction);
   }
 
   // Final instruction

package/src/codex.lib.mjs

@@ -22,7 +22,7 @@ import { mapModelToId, resolveCodexReasoningEffort } from './codex.options.lib.m
 import { createInteractiveHandler } from './interactive-mode.lib.mjs';
 import { initProgressMonitoring } from './solve.progress-monitoring.lib.mjs';
 
-const CODEX_USAGE_FIELD_NAMES = ['input_tokens', 'cached_input_tokens', 'output_tokens'];
+const CODEX_USAGE_FIELD_NAMES = ['input_tokens', 'cached_input_tokens', 'output_tokens', 'cache_write_tokens', 'cache_creation_input_tokens', 'reasoning_tokens', 'input_tokens_details.cached_tokens', 'input_tokens_details.cache_read_tokens', 'input_tokens_details.cache_write_tokens', 'input_tokens_details.cache_creation_tokens', 'input_tokens_details.cache_creation_input_tokens', 'output_tokens_details.reasoning_tokens'];
 const getCodexExecEnv = (verbose = false) => (verbose ? { ...process.env, RUST_LOG: 'debug' } : { ...process.env });
 const CODEX_MODEL_DIAGNOSTIC_PATHS = [
   ['model', data => data?.model],
@@ -32,6 +32,40 @@ const CODEX_MODEL_DIAGNOSTIC_PATHS = [
   ['message.model', data => data?.message?.model],
 ];
 
+const createCodexTokenFieldAvailability = () => ({
+  inputTokens: false,
+  outputTokens: false,
+  reasoningTokens: false,
+  cacheReadTokens: false,
+  cacheWriteTokens: false,
+});
+
+const hasOwnPath = (object, pathName) => {
+  let cursor = object;
+  for (const part of pathName.split('.')) {
+    if (!cursor || typeof cursor !== 'object' || !Object.hasOwn(cursor, part)) return false;
+    cursor = cursor[part];
+  }
+  return true;
+};
+
+const getPathValue = (object, pathName) => pathName.split('.').reduce((cursor, part) => cursor?.[part], object);
+
+const getFirstObservedNumber = (object, pathNames) => {
+  for (const pathName of pathNames) {
+    if (!hasOwnPath(object, pathName)) continue;
+    const value = getPathValue(object, pathName);
+    return Number.isFinite(value) ? value : 0;
+  }
+  return 0;
+};
+
+const hasAnyObservedPath = (object, pathNames) => pathNames.some(pathName => hasOwnPath(object, pathName));
+
+const CODEX_CACHE_READ_USAGE_PATHS = ['cached_input_tokens', 'input_tokens_details.cached_tokens', 'input_tokens_details.cache_read_tokens'];
+const CODEX_CACHE_WRITE_USAGE_PATHS = ['cache_write_tokens', 'cache_creation_input_tokens', 'input_tokens_details.cache_write_tokens', 'input_tokens_details.cache_creation_tokens', 'input_tokens_details.cache_creation_input_tokens'];
+const CODEX_REASONING_USAGE_PATHS = ['reasoning_tokens', 'output_tokens_details.reasoning_tokens'];
+
 export const createCodexTokenUsage = requestedModelId => ({
   inputTokens: 0,
   outputTokens: 0,
@@ -42,6 +76,7 @@ export const createCodexTokenUsage = requestedModelId => ({
   stepCount: 0,
   requestedModelId: requestedModelId || null,
   respondedModelId: requestedModelId || null,
+  tokenFieldAvailability: createCodexTokenFieldAvailability(),
 });
 
 const createEmptyCodexItemUsage = () => ({
@@ -162,6 +197,7 @@ export const parseCodexExecJsonOutput = (output, state = {}, requestedModelId =
     observedModelDiagnosticPaths: state.observedModelDiagnosticPaths || [],
   };
 
+  nextState.tokenUsage.tokenFieldAvailability ||= createCodexTokenFieldAvailability();
   const observedModelPaths = new Set(nextState.observedModelDiagnosticPaths);
 
   for (const rawLine of output.split('\n')) {
@@ -205,17 +241,28 @@ export const parseCodexExecJsonOutput = (output, state = {}, requestedModelId =
     }
 
     if (eventType === 'turn.completed' && data.usage && typeof data.usage === 'object') {
-      const inputTokens = Number.isFinite(data.usage.input_tokens) ? data.usage.input_tokens : 0;
-      const cachedInputTokens = Number.isFinite(data.usage.cached_input_tokens) ? data.usage.cached_input_tokens : 0;
-      const outputTokens = Number.isFinite(data.usage.output_tokens) ? data.usage.output_tokens : 0;
+      const inputTokens = getFirstObservedNumber(data.usage, ['input_tokens']);
+      const cachedInputTokens = getFirstObservedNumber(data.usage, CODEX_CACHE_READ_USAGE_PATHS);
+      const cacheWriteTokens = getFirstObservedNumber(data.usage, CODEX_CACHE_WRITE_USAGE_PATHS);
+      const outputTokens = getFirstObservedNumber(data.usage, ['output_tokens']);
+      const reasoningTokens = getFirstObservedNumber(data.usage, CODEX_REASONING_USAGE_PATHS);
+
+      if (hasOwnPath(data.usage, 'input_tokens')) nextState.tokenUsage.tokenFieldAvailability.inputTokens = true;
+      if (hasAnyObservedPath(data.usage, CODEX_CACHE_READ_USAGE_PATHS)) nextState.tokenUsage.tokenFieldAvailability.cacheReadTokens = true;
+      if (hasAnyObservedPath(data.usage, CODEX_CACHE_WRITE_USAGE_PATHS)) nextState.tokenUsage.tokenFieldAvailability.cacheWriteTokens = true;
+      if (hasOwnPath(data.usage, 'output_tokens')) nextState.tokenUsage.tokenFieldAvailability.outputTokens = true;
+      if (hasAnyObservedPath(data.usage, CODEX_REASONING_USAGE_PATHS)) nextState.tokenUsage.tokenFieldAvailability.reasoningTokens = true;
+
       const nonCachedInputTokens = Math.max(0, inputTokens - cachedInputTokens);
       nextState.tokenUsage.inputTokens += nonCachedInputTokens;
       nextState.tokenUsage.cacheReadTokens += cachedInputTokens;
+      nextState.tokenUsage.cacheWriteTokens += cacheWriteTokens;
       nextState.tokenUsage.outputTokens += outputTokens;
+      nextState.tokenUsage.reasoningTokens += reasoningTokens;
       nextState.tokenUsage.totalTokens = nextState.tokenUsage.inputTokens + nextState.tokenUsage.cacheReadTokens + nextState.tokenUsage.outputTokens + nextState.tokenUsage.cacheWriteTokens;
       nextState.tokenUsage.stepCount += 1;
 
-      const usageFieldSet = CODEX_USAGE_FIELD_NAMES.filter(fieldName => Object.hasOwn(data.usage, fieldName));
+      const usageFieldSet = CODEX_USAGE_FIELD_NAMES.filter(fieldName => hasOwnPath(data.usage, fieldName));
       if (usageFieldSet.length > 0) nextState.observedUsageFieldSets.push(usageFieldSet);
     }
 

package/src/codex.options.lib.mjs

@@ -9,6 +9,7 @@ const THINK_LEVEL_TO_CODEX_REASONING = {
   low: 'low',
   medium: 'medium',
   high: 'high',
+  xhigh: 'xhigh',
   max: 'xhigh',
 };
 

package/src/codex.prompts.lib.mjs

@@ -5,6 +5,7 @@
 
 import { getArchitectureCareSubPrompt } from './architecture-care.prompts.lib.mjs';
 import { getExperimentsExamplesSubPrompt } from './experiments-examples.prompts.lib.mjs';
+import { getThinkingPromptInstruction } from './thinking-prompt.lib.mjs';
 
 /**
  * Build the user prompt for Codex
@@ -58,15 +59,9 @@ export const buildUserPrompt = params => {
     promptLines.push('');
   }
 
-  // Add thinking instruction based on --think level
-  if (argv && argv.think) {
-    const thinkMessages = {
-      low: 'Think.',
-      medium: 'Think hard.',
-      high: 'Think harder.',
-      max: 'Ultrathink.',
-    };
-    promptLines.push(thinkMessages[argv.think]);
+  const thinkingPromptInstruction = getThinkingPromptInstruction({ tool: 'codex', argv });
+  if (thinkingPromptInstruction) {
+    promptLines.push(thinkingPromptInstruction);
   }
 
   // Final instruction

package/src/config.lib.mjs

@@ -178,11 +178,82 @@ export const isOpus46OrLater = model => {
   if (!model) return false;
   const normalizedModel = model.toLowerCase();
   // Check for explicit opus-4-6 or later versions, or opusplan (Issue #1223)
-  // Note: The 'opus' alias now maps to Opus 4.6 (Issue #1433), so we also check for the alias directly
+  // Note: The 'opus' alias now maps to Opus 4.7 (Issue #1620), so we also check for the alias directly
   // opusplan uses Opus for planning, so it should get Opus-level settings
   return normalizedModel === 'opus' || normalizedModel === 'opusplan' || normalizedModel.includes('opus-4-6') || normalizedModel.includes('opus-4-7') || normalizedModel.includes('opus-5');
 };
 
+const isOpus47 = model => {
+  if (!model) return false;
+  const normalizedModel = model.toLowerCase();
+  // 'opus' alias now maps to Opus 4.7 (Issue #1620)
+  // opusplan uses Opus for planning, so it gets Opus-level settings
+  return normalizedModel === 'opus' || normalizedModel === 'opusplan' || normalizedModel.includes('opus-4-7');
+};
+
+/**
+ * Check if a model is Opus 4.7 or later (Issue #1620)
+ * These models use Opus 4.7+ adaptive thinking behavior.
+ * @param {string} model - The model name or ID
+ * @returns {boolean} True if the model is Opus 4.7 or later
+ */
+export const isOpus47OrLater = model => {
+  if (!model) return false;
+  const normalizedModel = model.toLowerCase();
+  return isOpus47(model) || normalizedModel.includes('opus-5');
+};
+
+const isOpus45 = model => {
+  if (!model) return false;
+  const m = model.toLowerCase();
+  return m === 'opus-4-5' || m.includes('opus-4-5');
+};
+
+const isOpus46 = model => {
+  if (!model) return false;
+  const m = model.toLowerCase();
+  return m === 'opus-4-6' || m.includes('opus-4-6');
+};
+
+const isSonnet46OrLater = model => {
+  if (!model) return false;
+  const m = model.toLowerCase();
+  return m === 'sonnet' || m === 'sonnet-4-6' || m.includes('sonnet-4-6') || m.includes('sonnet-5');
+};
+
+const isMythosPreview = model => {
+  if (!model) return false;
+  return model.toLowerCase().includes('mythos');
+};
+
+/**
+ * Check if a model supports CLAUDE_CODE_EFFORT_LEVEL (Issue #1238, Issue #1620)
+ * Official effort support: Claude Mythos Preview, Opus 4.7, Opus 4.6, Sonnet 4.6, and Opus 4.5.
+ * Haiku 4.5 and older models use MAX_THINKING_TOKENS only.
+ * @param {string} model - The model name or ID
+ * @returns {boolean} True if the model supports effort levels
+ */
+export const supportsEffortLevel = model => {
+  if (!model) return false;
+  return isMythosPreview(model) || isOpus47OrLater(model) || isOpus46(model) || isSonnet46OrLater(model) || isOpus45(model);
+};
+
+/**
+ * Check if a model supports the xhigh effort level.
+ * Official docs list xhigh only for Claude Opus 4.7.
+ * @param {string} model - The model name or ID
+ * @returns {boolean} True if the model supports xhigh effort
+ */
+export const supportsXHighEffortLevel = model => isOpus47(model);
+
+/**
+ * Check if a model supports the max effort level.
+ * Official docs list max for Claude Mythos Preview, Opus 4.7, Opus 4.6, and Sonnet 4.6.
+ * @param {string} model - The model name or ID
+ * @returns {boolean} True if the model supports max effort
+ */
+export const supportsMaxEffortLevel = model => isMythosPreview(model) || isOpus47OrLater(model) || isOpus46(model) || isSonnet46OrLater(model);
+
 /**
  * Get the max output tokens for a specific model (Issue #1221)
  * @param {string} model - The model name or ID
@@ -218,6 +289,7 @@ export const getThinkingLevelToTokens = (maxBudget = DEFAULT_MAX_THINKING_BUDGET
   low: Math.floor(maxBudget / 4), // ~8000 for default 31999
   medium: Math.floor(maxBudget / 2), // ~16000 for default 31999
   high: Math.floor((maxBudget * 3) / 4), // ~24000 for default 31999
+  xhigh: maxBudget, // same as max when represented as MAX_THINKING_TOKENS
   max: maxBudget, // 31999 by default
 });
 
@@ -250,56 +322,73 @@ export const getTokensToThinkingLevel = (maxBudget = DEFAULT_MAX_THINKING_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
+ * Valid effort levels for Opus 4.6 and Sonnet 4.6 (Issue #1238, Issue #1620)
+ * These models use CLAUDE_CODE_EFFORT_LEVEL for thinking depth control
+ * @type {string[]}
+ */
+export const OPUS_46_EFFORT_LEVELS = ['low', 'medium', 'high', 'max'];
+
+/**
+ * Valid effort levels for Opus 4.7 (Issue #1620)
+ * Opus 4.7 supports the additional 'xhigh' level.
+ * See: https://platform.claude.com/docs/en/build-with-claude/effort
  * @type {string[]}
  */
-export const OPUS_46_EFFORT_LEVELS = ['low', 'medium', 'high'];
+export const OPUS_47_EFFORT_LEVELS = ['low', 'medium', 'high', 'xhigh', 'max'];
 
 /**
- * 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
+ * Convert thinking level to effort level (Issue #1238, Issue #1620)
+ * Models with max support keep max as max. Opus 4.7 keeps xhigh as xhigh.
+ * Models with effort but without max support use high for max/xhigh.
+ * @param {string|undefined} thinkLevel - The thinking level (off/low/medium/high/xhigh/max)
+ * @param {Object} [options] - Options
+ * @param {boolean} [options.isOpus47] - Backward-compatible shorthand for supportsXHigh
+ * @param {boolean} [options.supportsXHigh] - Whether the model supports xhigh effort
+ * @param {boolean} [options.supportsMax] - Whether the model supports max effort
+ * @returns {string|undefined} The effort level or undefined if thinking is off
  */
-export const thinkLevelToEffortLevel = thinkLevel => {
+export const thinkLevelToEffortLevel = (thinkLevel, options = {}) => {
   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
+  const supportsXHigh = options.supportsXHigh ?? options.isOpus47 ?? false;
+  const supportsMax = options.supportsMax ?? true;
+
   switch (thinkLevel) {
     case 'low':
       return 'low';
     case 'medium':
       return 'medium';
     case 'high':
-    case 'max':
       return 'high';
+    case 'xhigh':
+      return supportsXHigh ? 'xhigh' : supportsMax ? 'max' : 'high';
+    case 'max':
+      return supportsMax ? 'max' : 'high';
     default:
       return undefined;
   }
 };
 
 /**
- * Convert thinking budget (tokens) to Opus 4.6 effort level (Issue #1238)
+ * Convert thinking budget (tokens) to effort level (Issue #1238, Issue #1620)
  * 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
+ * @param {Object} [options] - Options
+ * @param {boolean} [options.isOpus47] - Backward-compatible shorthand for supportsXHigh
+ * @param {boolean} [options.supportsXHigh] - Whether the model supports xhigh effort
+ * @param {boolean} [options.supportsMax] - Whether the model supports max effort
+ * @returns {string|undefined} The effort level or undefined if thinking is off
  */
-export const thinkingBudgetToEffortLevel = (thinkingBudget, maxBudget = DEFAULT_MAX_THINKING_BUDGET) => {
+export const thinkingBudgetToEffortLevel = (thinkingBudget, maxBudget = DEFAULT_MAX_THINKING_BUDGET, options = {}) => {
   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);
+  return thinkLevelToEffortLevel(thinkLevel, options);
 };
 
 // Check if a version supports thinking budget (>= minimum version)
@@ -339,27 +428,40 @@ export const getClaudeEnv = (options = {}) => {
     MCP_TOOL_TIMEOUT: String(claudeCode.mcpToolTimeout),
   };
 
-  // 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);
+  // Opus 4.7+ always uses adaptive thinking — MAX_THINKING_TOKENS has no effect (Issue #1620)
+  // For Opus 4.6 and earlier, MAX_THINKING_TOKENS controls extended thinking (Claude Code >= 2.1.12)
+  // Default is 0 (thinking disabled) per Issue #1238.
+  const opus47 = options.model && isOpus47OrLater(options.model);
+  if (opus47) {
+    // Remove any inherited MAX_THINKING_TOKENS from process.env — Opus 4.7 ignores it
+    delete env.MAX_THINKING_TOKENS;
+  } else {
+    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
+  // Set CLAUDE_CODE_EFFORT_LEVEL for models that support it (Issue #1238, Issue #1620)
+  if (options.model && supportsEffortLevel(options.model)) {
+    const effortOptions = {
+      supportsXHigh: supportsXHighEffortLevel(options.model),
+      supportsMax: supportsMaxEffortLevel(options.model),
+    };
     let effortLevel;
     if (options.thinkLevel) {
-      effortLevel = thinkLevelToEffortLevel(options.thinkLevel);
+      effortLevel = thinkLevelToEffortLevel(options.thinkLevel, effortOptions);
     } else if (options.thinkingBudget !== undefined && options.thinkingBudget > 0) {
-      effortLevel = thinkingBudgetToEffortLevel(options.thinkingBudget, options.maxBudget);
+      effortLevel = thinkingBudgetToEffortLevel(options.thinkingBudget, options.maxBudget, effortOptions);
     }
 
     if (effortLevel) {
       env.CLAUDE_CODE_EFFORT_LEVEL = effortLevel;
     }
   }
+
+  // Opus 4.7 omits thinking content by default; opt in with --show-thinking-content (Issue #1620)
+  // Sets CLAUDE_CODE_SHOW_THINKING=1 which Claude Code uses to request display: "summarized"
+  if (options.showThinkingContent) {
+    env.CLAUDE_CODE_SHOW_THINKING = '1';
+  }
   // Set ANTHROPIC_DEFAULT_OPUS_MODEL when planModel is specified (Issue #1223)
   // This tells Claude Code which model to use during plan mode in opusplan
   if (options.planModel) {

package/src/github-cost-info.lib.mjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+import Decimal from 'decimal.js-light';
+
+const formatTokenCount = value => (Number.isFinite(value) ? value : 0).toLocaleString();
+
+const isObservedTokenField = (usage, fieldName) => {
+  const value = usage?.[fieldName];
+  if (Number.isFinite(value) && value > 0) return true;
+  if (usage?.tokenFieldAvailability?.[fieldName] === true) return true;
+  if (Array.isArray(usage?.availableTokenFields) && usage.availableTokenFields.includes(fieldName)) return true;
+  return false;
+};
+
+const buildTokenUsageString = tokenUsage => {
+  const parts = [`${formatTokenCount(tokenUsage.inputTokens)} input`, `${formatTokenCount(tokenUsage.outputTokens)} output`];
+  if (isObservedTokenField(tokenUsage, 'reasoningTokens')) parts.push(`${formatTokenCount(tokenUsage.reasoningTokens)} reasoning`);
+  if (isObservedTokenField(tokenUsage, 'cacheReadTokens')) parts.push(`${formatTokenCount(tokenUsage.cacheReadTokens)} cache read`);
+  if (isObservedTokenField(tokenUsage, 'cacheWriteTokens')) parts.push(`${formatTokenCount(tokenUsage.cacheWriteTokens)} cache write`);
+  return `\n- Token usage: ${parts.join(', ')}`;
+};
+
+/** Build cost estimation string for log comments (Issue #1250, Issue #1557, Issue #1600: Decimal precision) */
+export const buildCostInfoString = (totalCostUSD, anthropicTotalCostUSD, pricingInfo) => {
+  const hasPublic = totalCostUSD !== null && totalCostUSD !== undefined;
+  const hasAnthropic = anthropicTotalCostUSD !== null && anthropicTotalCostUSD !== undefined;
+  const hasPricing = pricingInfo && (pricingInfo.modelName || pricingInfo.tokenUsage || pricingInfo.isFreeModel || pricingInfo.isOpencodeFreeModel);
+  const hasOpencodeCost = pricingInfo?.opencodeCost !== null && pricingInfo?.opencodeCost !== undefined;
+  if (!hasPublic && !hasAnthropic && !hasPricing && !hasOpencodeCost) return '';
+  const publicDec = hasPublic ? new Decimal(totalCostUSD) : null;
+  const anthropicDec = hasAnthropic ? new Decimal(anthropicTotalCostUSD) : null;
+  if (publicDec && anthropicDec && publicDec.toFixed(6) === anthropicDec.toFixed(6)) return `\n\n### 💰 Cost: **$${anthropicDec.toFixed(6)}**`;
+  let costInfo = '\n\n### 💰 **Cost estimation:**';
+  if (pricingInfo?.modelName) {
+    costInfo += `\n- Model: ${pricingInfo.modelName}`;
+    if (pricingInfo.provider) costInfo += `\n- Provider: ${pricingInfo.provider}`;
+  }
+  if (hasPublic) {
+    if (pricingInfo?.isFreeModel && publicDec.eq(0) && !pricingInfo?.baseModelName) {
+      costInfo += '\n- Public pricing estimate: $0.00 (Free model)';
+    } else {
+      let pricingRef = '';
+      if (pricingInfo?.baseModelName && pricingInfo?.originalProvider) {
+        pricingRef = ` (based on ${pricingInfo.originalProvider} ${pricingInfo.baseModelName} prices)`;
+      } else if (pricingInfo?.originalProvider) {
+        pricingRef = ` (based on ${pricingInfo.originalProvider} prices)`;
+      }
+      costInfo += `\n- Public pricing estimate: $${publicDec.toFixed(6)}${pricingRef}`;
+    }
+  } else if (hasPricing) {
+    costInfo += '\n- Public pricing estimate: unknown';
+  }
+  if (hasOpencodeCost) {
+    if (pricingInfo.isOpencodeFreeModel) {
+      costInfo += '\n- Calculated by OpenCode Zen: $0.00 (Free model)';
+    } else {
+      costInfo += `\n- Calculated by OpenCode Zen: $${new Decimal(pricingInfo.opencodeCost).toFixed(6)}`;
+    }
+  }
+  if (pricingInfo?.tokenUsage) costInfo += buildTokenUsageString(pricingInfo.tokenUsage);
+  if (hasAnthropic) {
+    costInfo += `\n- Calculated by Anthropic: $${anthropicDec.toFixed(6)}`;
+    if (hasPublic) {
+      const diff = anthropicDec.minus(publicDec);
+      const pct = publicDec.gt(0) ? diff.div(publicDec).mul(100) : new Decimal(0);
+      costInfo += `\n- Difference: $${diff.toFixed(6)} (${pct.gt(0) ? '+' : ''}${pct.toFixed(2)}%)`;
+    }
+  }
+  return costInfo;
+};