@link-assistant/hive-mind 1.8.0 → 1.9.1

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # @link-assistant/hive-mind
 
+## 1.9.1
+
+### Patch Changes
+
+- 06da02c: Improve /accept_invites command output with grouped items and real-time updates
+
+  **Changes:**
+  - Group output by "Repositories:" and "Organizations:" instead of repeating "Repository:" for each item
+  - Add clickable GitHub links for each repository and organization
+  - Implement real-time message updates after each invitation is processed
+  - Show progress indicator (e.g., "Processing GitHub Invitations (3/10)") during processing
+
+  Fixes #1148
+
+## 1.9.0
+
+### Minor Changes
+
+- e15f307: Add bidirectional translation between --think and --thinking-budget options for Claude Code
+
+  **Changes:**
+  - Add 'off' option to --think values: ['off', 'low', 'medium', 'high', 'max']
+  - Add --thinking-budget-claude-minimum-version option (default: 2.1.12)
+  - For Claude Code >= 2.1.12: translate --think to --thinking-budget (off→0, low→8000, medium→16000, high→24000, max→31999)
+  - For Claude Code < 2.1.12: translate --thinking-budget back to --think thinking keywords
+  - Both options now coexist and support all Claude Code versions
+
+  **Rationale:**
+  Claude Code v2.1.12+ no longer responds to thinking keywords (think, think hard, ultrathink) because extended thinking is enabled by default. The only way to control thinking budget programmatically is via MAX_THINKING_TOKENS environment variable.
+
+  Fixes #1146
+
 ## 1.8.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.8.0",
+  "version": "1.9.1",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",
@@ -68,7 +68,8 @@
     "@sentry/node": "^10.15.0",
     "@sentry/profiling-node": "^10.15.0",
     "dayjs": "^1.11.19",
-    "secretlint": "^11.2.5"
+    "secretlint": "^11.2.5",
+    "semver": "^7.7.3"
   },
   "lint-staged": {
     "*.{js,mjs,json,md}": [

package/src/claude.lib.mjs

@@ -10,7 +10,7 @@ const path = (await use('path')).default;
 // Import log from general lib
 import { log } from './lib.mjs';
 import { reportError } from './sentry.lib.mjs';
-import { timeouts, retryLimits, claudeCode, getClaudeEnv } from './config.lib.mjs';
+import { timeouts, retryLimits, claudeCode, getClaudeEnv, getThinkingLevelToTokens, getTokensToThinkingLevel, supportsThinkingBudget, DEFAULT_MAX_THINKING_BUDGET } from './config.lib.mjs';
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
 import { createInteractiveHandler } from './interactive-mode.lib.mjs';
 import { displayBudgetStats } from './claude.budget-stats.lib.mjs';
@@ -68,6 +68,8 @@ export const validateClaudeConnection = async (model = 'haiku-3') => {
         const versionResult = await $`timeout ${Math.floor(timeouts.claudeCli / 6000)} claude --version`;
         if (versionResult.code === 0) {
           const version = versionResult.stdout?.toString().trim();
+          // Store the version for thinking settings translation (issue #1146)
+          detectedClaudeVersion = version;
           if (retryCount === 0) {
             await log(`📦 Claude CLI version: ${version}`);
           }
@@ -219,6 +221,76 @@ export const validateClaudeConnection = async (model = 'haiku-3') => {
 // handleClaudeRuntimeSwitch is imported from ./claude.runtime-switch.lib.mjs (see issue #1141)
 // Re-export it for backwards compatibility
 export { handleClaudeRuntimeSwitch };
+
+// Store Claude Code version globally (set during validation)
+let detectedClaudeVersion = null;
+
+/**
+ * Get the detected Claude Code version
+ * @returns {string|null} The detected version or null if not yet detected
+ */
+export const getClaudeVersion = () => detectedClaudeVersion;
+
+/**
+ * Set the detected Claude Code version (called during validation)
+ * @param {string} version - The detected version string
+ */
+export const setClaudeVersion = version => {
+  detectedClaudeVersion = version;
+};
+
+/**
+ * Resolve thinking settings based on --think and --thinking-budget options
+ * Handles translation between thinking levels and token budgets based on Claude Code version
+ * @param {Object} argv - Command line arguments
+ * @param {Function} log - Logging function
+ * @returns {Object} { thinkingBudget, thinkLevel, translation, maxBudget } - Resolved settings
+ */
+export const resolveThinkingSettings = async (argv, log) => {
+  const minVersion = argv.thinkingBudgetClaudeMinimumVersion || '2.1.12';
+  const version = detectedClaudeVersion || '0.0.0'; // Assume old version if not detected
+  const isNewVersion = supportsThinkingBudget(version, minVersion);
+
+  // Get max thinking budget from argv or use default (see issue #1146)
+  const maxBudget = argv.maxThinkingBudget ?? DEFAULT_MAX_THINKING_BUDGET;
+
+  // Get thinking level mappings calculated from maxBudget
+  const thinkingLevelToTokens = getThinkingLevelToTokens(maxBudget);
+  const tokensToThinkingLevel = getTokensToThinkingLevel(maxBudget);
+
+  let thinkingBudget = argv.thinkingBudget;
+  let thinkLevel = argv.think;
+  let translation = null;
+
+  if (isNewVersion) {
+    // Claude Code >= 2.1.12: translate --think to --thinking-budget
+    if (thinkLevel !== undefined && thinkingBudget === undefined) {
+      thinkingBudget = thinkingLevelToTokens[thinkLevel];
+      translation = `--think ${thinkLevel} → --thinking-budget ${thinkingBudget}`;
+      if (argv.verbose) {
+        await log(`📊 Translating for Claude Code ${version} (>= ${minVersion}):`, { verbose: true });
+        await log(`   ${translation}`, { verbose: true });
+        if (maxBudget !== DEFAULT_MAX_THINKING_BUDGET) {
+          await log(`   Using custom --max-thinking-budget: ${maxBudget}`, { verbose: true });
+        }
+      }
+    }
+  } else {
+    // Claude Code < 2.1.12: translate --thinking-budget to --think keywords
+    if (thinkingBudget !== undefined && thinkLevel === undefined) {
+      thinkLevel = tokensToThinkingLevel(thinkingBudget);
+      translation = `--thinking-budget ${thinkingBudget} → --think ${thinkLevel}`;
+      if (argv.verbose) {
+        await log(`📊 Translating for Claude Code ${version} (< ${minVersion}):`, { verbose: true });
+        await log(`   ${translation}`, { verbose: true });
+      }
+      // Clear thinkingBudget since old versions don't support it
+      thinkingBudget = undefined;
+    }
+  }
+
+  return { thinkingBudget, thinkLevel, translation, isNewVersion, maxBudget };
+};
 /**
  * Check if Playwright MCP is available and connected to Claude
  * @returns {Promise<boolean>} True if Playwright MCP is available, false otherwise
@@ -805,8 +877,20 @@ export const executeClaudeCommand = async params => {
       await log('', { verbose: true });
     }
     try {
-      const claudeEnv = getClaudeEnv(); // Set CLAUDE_CODE_MAX_OUTPUT_TOKENS (see issue #1076)
+      // 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);
+
+      // Set CLAUDE_CODE_MAX_OUTPUT_TOKENS (see issue #1076) and optionally MAX_THINKING_TOKENS (see issue #1146)
+      const claudeEnv = getClaudeEnv({ thinkingBudget: resolvedThinkingBudget });
       if (argv.verbose) await log(`📊 CLAUDE_CODE_MAX_OUTPUT_TOKENS: ${claudeCode.maxOutputTokens}`, { 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 (argv.resume) {
         // When resuming, pass prompt directly with -p flag. Escape double quotes for shell.
         const simpleEscapedPrompt = prompt.replace(/"/g, '\\"');
@@ -1351,4 +1435,7 @@ export default {
   executeClaudeCommand,
   checkForUncommittedChanges,
   calculateSessionTokens,
+  getClaudeVersion,
+  setClaudeVersion,
+  resolveThinkingSettings,
 };

package/src/claude.prompts.lib.mjs

@@ -63,7 +63,10 @@ export const buildUserPrompt = params => {
     promptLines.push('');
   }
 
-  // Add thinking instruction based on --think level
+  // 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.',
@@ -89,7 +92,10 @@ export const buildUserPrompt = params => {
 export const buildSystemPrompt = params => {
   const { owner, repo, issueNumber, prNumber, branchName, workspaceTmpDir, argv } = params;
 
-  // Build thinking instruction based on --think level
+  // 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
   let thinkLine = '';
   if (argv && argv.think) {
     const thinkMessages = {

package/src/config.lib.mjs

@@ -20,6 +20,9 @@ if (typeof globalThis.use === 'undefined') {
 
 const getenv = await use('getenv');
 
+// Use semver package for version comparison (see issue #1146)
+import semver from 'semver';
+
 // Import lino for parsing Links Notation format
 const { lino } = await import('./lino.lib.mjs');
 
@@ -89,8 +92,80 @@ export const claudeCode = {
   maxOutputTokens: parseIntWithDefault('CLAUDE_CODE_MAX_OUTPUT_TOKENS', parseIntWithDefault('HIVE_MIND_CLAUDE_CODE_MAX_OUTPUT_TOKENS', 64000)),
 };
 
+// Default max thinking budget for Claude Code (see issue #1146)
+// This is the default value used by Claude Code when extended thinking is enabled
+// Can be overridden via --max-thinking-budget option
+export const DEFAULT_MAX_THINKING_BUDGET = 31999;
+
+/**
+ * Get thinking level token values calculated from max budget
+ * Values are evenly distributed: off=0, low=max/4, medium=max/2, high=max*3/4, max=max
+ * @param {number} maxBudget - Maximum thinking budget (default: 31999)
+ * @returns {Object} Mapping of thinking levels to token values
+ */
+export const getThinkingLevelToTokens = (maxBudget = DEFAULT_MAX_THINKING_BUDGET) => ({
+  off: 0,
+  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
+  max: maxBudget, // 31999 by default
+});
+
+// Default thinking level to tokens mapping (using default max budget)
+export const thinkingLevelToTokens = getThinkingLevelToTokens(DEFAULT_MAX_THINKING_BUDGET);
+
+/**
+ * Get tokens to thinking level mapping function with configurable max budget
+ * Uses midpoint ranges to determine the level
+ * @param {number} maxBudget - Maximum thinking budget (default: 31999)
+ * @returns {Function} Function that converts tokens to thinking level
+ */
+export const getTokensToThinkingLevel = (maxBudget = DEFAULT_MAX_THINKING_BUDGET) => {
+  const levels = getThinkingLevelToTokens(maxBudget);
+  // Calculate midpoints between levels for range determination
+  const lowMediumMidpoint = Math.floor((levels.low + levels.medium) / 2);
+  const mediumHighMidpoint = Math.floor((levels.medium + levels.high) / 2);
+  const highMaxMidpoint = Math.floor((levels.high + levels.max) / 2);
+
+  return tokens => {
+    if (tokens === 0) return 'off';
+    if (tokens <= lowMediumMidpoint) return 'low';
+    if (tokens <= mediumHighMidpoint) return 'medium';
+    if (tokens <= highMaxMidpoint) return 'high';
+    return 'max';
+  };
+};
+
+// Default tokens to thinking level function (using default max budget)
+export const tokensToThinkingLevel = getTokensToThinkingLevel(DEFAULT_MAX_THINKING_BUDGET);
+
+// 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') => {
+  // Clean the version string (remove any leading 'v' and extra text)
+  const cleanVersion = semver.clean(version) || semver.coerce(version)?.version;
+  const cleanMinVersion = semver.clean(minVersion) || semver.coerce(minVersion)?.version;
+
+  if (!cleanVersion || !cleanMinVersion) {
+    // If versions can't be parsed, assume old version (doesn't support budget)
+    return false;
+  }
+
+  return semver.gte(cleanVersion, cleanMinVersion);
+};
+
 // Helper function to get Claude CLI environment with CLAUDE_CODE_MAX_OUTPUT_TOKENS set
-export const getClaudeEnv = () => ({ ...process.env, CLAUDE_CODE_MAX_OUTPUT_TOKENS: String(claudeCode.maxOutputTokens) });
+// Optionally sets MAX_THINKING_TOKENS when thinkingBudget is provided (see issue #1146)
+export const getClaudeEnv = (options = {}) => {
+  const env = { ...process.env, CLAUDE_CODE_MAX_OUTPUT_TOKENS: String(claudeCode.maxOutputTokens) };
+  // Set MAX_THINKING_TOKENS if thinkingBudget is provided
+  // This controls Claude Code's extended thinking feature (Claude Code >= 2.1.12)
+  // Default is 31999, set to 0 to disable thinking, max is 63999 for 64K output models
+  if (options.thinkingBudget !== undefined) {
+    env.MAX_THINKING_TOKENS = String(options.thinkingBudget);
+  }
+  return env;
+};
 
 // Cache TTL configurations (in milliseconds)
 // The Usage API (Claude limits) has stricter rate limiting than regular APIs

package/src/github.lib.mjs

@@ -1319,6 +1319,7 @@ export async function handlePRNotFoundError({ prNumber, owner, repo, argv, shoul
       if (argv.verbose) commandParts.push('--verbose');
       if (argv.model && argv.model !== 'sonnet') commandParts.push('--model', argv.model);
       if (argv.think) commandParts.push('--think', argv.think);
+      if (argv.thinkingBudget !== undefined) commandParts.push('--thinking-budget', argv.thinkingBudget);
       await log(`   ${commandParts.join(' ')}`, { level: 'error' });
       await log('', { level: 'error' });
     }

package/src/hive.config.lib.mjs

@@ -209,10 +209,20 @@ export const createYargsConfig = yargsInstance => {
     })
     .option('think', {
       type: 'string',
-      description: 'Thinking level: low (Think.), medium (Think hard.), high (Think harder.), max (Ultrathink.)',
-      choices: ['low', 'medium', 'high', 'max'],
+      description: 'Thinking level for Claude. Translated to --thinking-budget for Claude Code >= 2.1.12 (off=0, low=~8000, medium=~16000, high=~24000, max=31999). For older versions, uses thinking keywords.',
+      choices: ['off', 'low', 'medium', 'high', 'max'],
       default: undefined,
     })
+    .option('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.',
+      default: undefined,
+    })
+    .option('max-thinking-budget', {
+      type: 'number',
+      description: 'Maximum thinking budget for calculating --think level mappings (default: 31999 for Claude Code). Values: off=0, low=max/4, medium=max/2, high=max*3/4, max=max.',
+      default: 31999,
+    })
     .option('prompt-plan-sub-agent', {
       type: 'boolean',
       description: 'Encourage AI to use Plan sub-agent for initial planning (only works with --tool claude)',

package/src/hive.mjs

@@ -759,6 +759,8 @@ if (isDirectExecution) {
             args.push(argv.autoContinue ? '--auto-continue' : '--no-auto-continue');
             if (argv.autoResumeOnLimitReset) args.push('--auto-resume-on-limit-reset');
             if (argv.think) args.push('--think', argv.think);
+            if (argv.thinkingBudget !== undefined) args.push('--thinking-budget', argv.thinkingBudget);
+            if (argv.maxThinkingBudget !== undefined && argv.maxThinkingBudget !== 31999) args.push('--max-thinking-budget', argv.maxThinkingBudget);
             if (argv.promptPlanSubAgent) args.push('--prompt-plan-sub-agent');
             if (!argv.sentry) args.push('--no-sentry');
             if (argv.watch) args.push('--watch');

package/src/option-suggestions.lib.mjs

@@ -160,6 +160,9 @@ const KNOWN_OPTION_NAMES = [
   'dry-run',
   'tool',
   'think',
+  'thinking-budget',
+  'thinking-budget-claude-minimum-version',
+  'max-thinking-budget',
   'watch',
   'sentry',
   'attach-logs',

package/src/solve.config.lib.mjs

@@ -216,10 +216,25 @@ export const createYargsConfig = yargsInstance => {
       })
       .option('think', {
         type: 'string',
-        description: 'Thinking level: low (Think.), medium (Think hard.), high (Think harder.), max (Ultrathink.)',
-        choices: ['low', 'medium', 'high', 'max'],
+        description: 'Thinking level for Claude. Translated to --thinking-budget for Claude Code >= 2.1.12 (off=0, low=~8000, medium=~16000, high=~24000, max=31999). For older versions, uses thinking keywords.',
+        choices: ['off', 'low', 'medium', 'high', 'max'],
         default: undefined,
       })
+      .option('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.',
+        default: undefined,
+      })
+      .option('thinking-budget-claude-minimum-version', {
+        type: 'string',
+        description: 'Minimum Claude Code version that supports --thinking-budget (MAX_THINKING_TOKENS env var). Versions below this use thinking keywords instead.',
+        default: '2.1.12',
+      })
+      .option('max-thinking-budget', {
+        type: 'number',
+        description: 'Maximum thinking budget for calculating --think level mappings (default: 31999 for Claude Code). Values: off=0, low=max/4, medium=max/2, high=max*3/4, max=max.',
+        default: 31999,
+      })
       .option('prompt-plan-sub-agent', {
         type: 'boolean',
         description: 'Encourage AI to use Plan sub-agent for initial planning (only works with --tool claude)',

package/src/telegram-accept-invitations.lib.mjs

@@ -7,7 +7,9 @@
  * Features:
  * - Accepts all pending repository invitations
  * - Accepts all pending organization invitations
- * - Provides detailed feedback on accepted invitations
+ * - Groups output by Repositories and Organizations
+ * - Provides clickable links to repositories and organizations
+ * - Real-time progress updates during processing
  * - Error handling with detailed error messages
  *
  * @see https://docs.github.com/en/rest/collaborators/invitations
@@ -28,6 +30,83 @@ function escapeMarkdown(text) {
   return String(text).replace(/[_*[\]()~`>#+\-=|{}.!]/g, '\\$&');
 }
 
+/**
+ * Build progress message from current state
+ * @param {Object} state - Current state object
+ * @param {string[]} state.acceptedRepos - List of accepted repo names
+ * @param {string[]} state.acceptedOrgs - List of accepted org names
+ * @param {string[]} state.errors - List of errors
+ * @param {number} state.totalRepos - Total number of repo invitations
+ * @param {number} state.totalOrgs - Total number of org invitations
+ * @param {number} state.processedRepos - Number of processed repo invitations
+ * @param {number} state.processedOrgs - Number of processed org invitations
+ * @param {boolean} state.isComplete - Whether processing is complete
+ * @returns {string} Formatted message
+ */
+function buildProgressMessage(state) {
+  const { acceptedRepos, acceptedOrgs, errors, totalRepos, totalOrgs, processedRepos, processedOrgs, isComplete } = state;
+
+  // Calculate totals
+  const totalInvitations = totalRepos + totalOrgs;
+  const processedTotal = processedRepos + processedOrgs;
+  const acceptedTotal = acceptedRepos.length + acceptedOrgs.length;
+
+  // Build header with progress indicator
+  let message = isComplete ? '✅ *GitHub Invitations Processed*\n\n' : `🔄 *Processing GitHub Invitations* \\(${processedTotal}/${totalInvitations}\\)\n\n`;
+
+  // Show Repositories section if any
+  if (acceptedRepos.length > 0 || (!isComplete && totalRepos > 0)) {
+    message += '*Repositories:*\n';
+    for (const repoName of acceptedRepos) {
+      // Create clickable link: [owner/repo](https://github.com/owner/repo)
+      const escapedName = escapeMarkdown(repoName);
+      const escapedLink = escapeMarkdown(`https://github.com/${repoName}`);
+      message += `  • 📦 [${escapedName}](${escapedLink})\n`;
+    }
+    // Show pending indicator if still processing repos
+    if (!isComplete && processedRepos < totalRepos) {
+      const remaining = totalRepos - processedRepos;
+      message += `  • _\\.\\.\\. ${remaining} more pending_\n`;
+    }
+    message += '\n';
+  }
+
+  // Show Organizations section if any
+  if (acceptedOrgs.length > 0 || (!isComplete && totalOrgs > 0)) {
+    message += '*Organizations:*\n';
+    for (const orgName of acceptedOrgs) {
+      // Create clickable link: [org](https://github.com/org)
+      const escapedName = escapeMarkdown(orgName);
+      const escapedLink = escapeMarkdown(`https://github.com/${orgName}`);
+      message += `  • 🏢 [${escapedName}](${escapedLink})\n`;
+    }
+    // Show pending indicator if still processing orgs
+    if (!isComplete && processedOrgs < totalOrgs) {
+      const remaining = totalOrgs - processedOrgs;
+      message += `  • _\\.\\.\\. ${remaining} more pending_\n`;
+    }
+    message += '\n';
+  }
+
+  // Show errors if any
+  if (errors.length > 0) {
+    message += '*Errors:*\n' + errors.map(e => `  • ${escapeMarkdown(e)}`).join('\n') + '\n\n';
+  }
+
+  // Show summary
+  if (isComplete) {
+    if (acceptedTotal === 0 && errors.length === 0) {
+      message += 'No pending invitations found\\.';
+    } else if (acceptedTotal > 0 && errors.length === 0) {
+      message += `\n🎉 Successfully accepted ${acceptedTotal} invitation\\(s\\)\\!`;
+    } else if (acceptedTotal > 0 && errors.length > 0) {
+      message += `\n⚠️ Accepted ${acceptedTotal} invitation\\(s\\), ${errors.length} error\\(s\\)\\.`;
+    }
+  }
+
+  return message;
+}
+
 /**
  * Registers the /accept_invites command handler with the bot
  * @param {Object} bot - The Telegraf bot instance
@@ -61,68 +140,97 @@ export function registerAcceptInvitesCommand(bot, options) {
         reply_to_message_id: ctx.message.message_id,
       });
 
-    const fetchingMessage = await ctx.reply('🔄 Fetching pending GitHub invitations...', { reply_to_message_id: ctx.message.message_id });
-    const accepted = [];
-    const errors = [];
+    const fetchingMessage = await ctx.reply('🔄 Fetching pending GitHub invitations\\.\\.\\.', {
+      reply_to_message_id: ctx.message.message_id,
+      parse_mode: 'MarkdownV2',
+    });
+
+    // State for tracking progress
+    const state = {
+      acceptedRepos: [],
+      acceptedOrgs: [],
+      errors: [],
+      totalRepos: 0,
+      totalOrgs: 0,
+      processedRepos: 0,
+      processedOrgs: 0,
+      isComplete: false,
+    };
+
+    // Helper to update the message safely
+    const updateMessage = async () => {
+      try {
+        const message = buildProgressMessage(state);
+        await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, message, { parse_mode: 'MarkdownV2' });
+      } catch (err) {
+        // Ignore "message not modified" errors
+        if (!err.message?.includes('message is not modified')) {
+          VERBOSE && console.log(`[VERBOSE] /accept-invites: Error updating message: ${err.message}`);
+        }
+      }
+    };
 
     try {
       // Fetch repository invitations
       const { stdout: repoInvJson } = await exec('gh api /user/repository_invitations 2>/dev/null || echo "[]"');
       const repoInvitations = JSON.parse(repoInvJson.trim() || '[]');
+      state.totalRepos = repoInvitations.length;
       VERBOSE && console.log(`[VERBOSE] Found ${repoInvitations.length} pending repo invitations`);
 
-      // Accept each repo invitation
+      // Fetch organization invitations
+      const { stdout: orgMemJson } = await exec('gh api /user/memberships/orgs 2>/dev/null || echo "[]"');
+      const orgMemberships = JSON.parse(orgMemJson.trim() || '[]');
+      const pendingOrgs = orgMemberships.filter(m => m.state === 'pending');
+      state.totalOrgs = pendingOrgs.length;
+      VERBOSE && console.log(`[VERBOSE] Found ${pendingOrgs.length} pending org invitations`);
+
+      // Check if there are any invitations
+      if (state.totalRepos === 0 && state.totalOrgs === 0) {
+        state.isComplete = true;
+        await updateMessage();
+        return;
+      }
+
+      // Update to show we found invitations
+      await updateMessage();
+
+      // Accept each repo invitation with progress updates
       for (const inv of repoInvitations) {
         const repoName = inv.repository?.full_name || 'unknown';
         try {
           await exec(`gh api -X PATCH /user/repository_invitations/${inv.id}`);
-          accepted.push(`📦 Repository: ${repoName}`);
+          state.acceptedRepos.push(repoName);
           VERBOSE && console.log(`[VERBOSE] Accepted repo invitation: ${repoName}`);
         } catch (e) {
-          errors.push(`📦 ${repoName}: ${e.message}`);
+          state.errors.push(`📦 ${repoName}: ${e.message}`);
           VERBOSE && console.log(`[VERBOSE] Failed to accept repo invitation ${repoName}: ${e.message}`);
         }
+        state.processedRepos++;
+        await updateMessage();
       }
 
-      // Fetch organization invitations
-      const { stdout: orgMemJson } = await exec('gh api /user/memberships/orgs 2>/dev/null || echo "[]"');
-      const orgMemberships = JSON.parse(orgMemJson.trim() || '[]');
-      const pendingOrgs = orgMemberships.filter(m => m.state === 'pending');
-      VERBOSE && console.log(`[VERBOSE] Found ${pendingOrgs.length} pending org invitations`);
-
-      // Accept each org invitation
+      // Accept each org invitation with progress updates
       for (const membership of pendingOrgs) {
         const orgName = membership.organization?.login || 'unknown';
         try {
           await exec(`gh api -X PATCH /user/memberships/orgs/${orgName} -f state=active`);
-          accepted.push(`🏢 Organization: ${orgName}`);
+          state.acceptedOrgs.push(orgName);
           VERBOSE && console.log(`[VERBOSE] Accepted org invitation: ${orgName}`);
         } catch (e) {
-          errors.push(`🏢 ${orgName}: ${e.message}`);
+          state.errors.push(`🏢 ${orgName}: ${e.message}`);
           VERBOSE && console.log(`[VERBOSE] Failed to accept org invitation ${orgName}: ${e.message}`);
         }
+        state.processedOrgs++;
+        await updateMessage();
       }
 
-      // Build response message
-      let message = '✅ *GitHub Invitations Processed*\n\n';
-      if (accepted.length === 0 && errors.length === 0) {
-        message += 'No pending invitations found.';
-      } else {
-        if (accepted.length > 0) {
-          message += '*Accepted:*\n' + accepted.map(a => `  • ${escapeMarkdown(a)}`).join('\n') + '\n\n';
-        }
-        if (errors.length > 0) {
-          message += '*Errors:*\n' + errors.map(e => `  • ${escapeMarkdown(e)}`).join('\n');
-        }
-        if (accepted.length > 0 && errors.length === 0) {
-          message += `\n🎉 Successfully accepted ${accepted.length} invitation(s)!`;
-        }
-      }
-
-      await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, message, { parse_mode: 'Markdown' });
+      // Final update
+      state.isComplete = true;
+      await updateMessage();
     } catch (error) {
       console.error('Error in /accept-invites:', error);
-      await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, `❌ Error fetching invitations: ${escapeMarkdown(error.message)}\n\nMake sure \`gh\` CLI is installed and authenticated.`, { parse_mode: 'Markdown' });
+      const escapedError = escapeMarkdown(error.message);
+      await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, `❌ Error fetching invitations: ${escapedError}\n\nMake sure \`gh\` CLI is installed and authenticated\\.`, { parse_mode: 'MarkdownV2' });
     }
   });
 }

package/src/telegram-bot.mjs

@@ -770,7 +770,7 @@ bot.command('help', async ctx => {
   message += '🔧 *Common Options:*\n';
   message += '• `--model <model>` or `-m` - Specify AI model (sonnet, opus, haiku, haiku-3-5, haiku-3)\n';
   message += '• `--base-branch <branch>` or `-b` - Target branch for PR (default: repo default branch)\n';
-  message += '• `--think <level>` - Thinking level (low/medium/high/max)\n';
+  message += '• `--think <level>` - Thinking level (off/low/medium/high/max) | `--thinking-budget <num>` - Token budget (0-63999)\n';
   message += '• `--verbose` or `-v` - Verbose output | `--attach-logs` - Attach logs to PR\n';
   message += '\n💡 *Tip:* Many more options available. See full documentation for complete list.\n';