@link-assistant/hive-mind 0.46.1 → 0.47.1

package/src/claude.lib.mjs

@@ -20,7 +20,7 @@ import { displayBudgetStats } from './claude.budget-stats.lib.mjs';
  * @param {number|null|undefined} num - Number to format
  * @returns {string} Formatted number string
  */
-export const formatNumber = (num) => {
+export const formatNumber = num => {
   if (num === null || num === undefined) return 'N/A';
   // Convert to string and split on decimal point
   const parts = num.toString().split('.');
@@ -29,20 +29,18 @@ export const formatNumber = (num) => {
   // Add spaces every 3 digits from the right
   const formattedInteger = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
   // Return with decimal part if it exists
-  return decimalPart !== undefined
-    ? `${formattedInteger}.${decimalPart}`
-    : formattedInteger;
+  return decimalPart !== undefined ? `${formattedInteger}.${decimalPart}` : formattedInteger;
 };
 // Available model configurations
 export const availableModels = {
-  'sonnet': 'claude-sonnet-4-5-20250929',  // Sonnet 4.5
-  'opus': 'claude-opus-4-5-20251101',      // Opus 4.5
-  'haiku': 'claude-haiku-4-5-20251001',    // Haiku 4.5
+  sonnet: 'claude-sonnet-4-5-20250929', // Sonnet 4.5
+  opus: 'claude-opus-4-5-20251101', // Opus 4.5
+  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
+  'haiku-3': 'claude-3-haiku-20240307', // Haiku 3
 };
 // Model mapping to translate aliases to full model IDs
-export const mapModelToId = (model) => {
+export const mapModelToId = model => {
   return availableModels[model] || model;
 };
 // Function to validate Claude CLI connection with retry logic
@@ -86,21 +84,25 @@ export const validateClaudeConnection = async (model = 'haiku-3') => {
           result = await $`timeout ${Math.floor(timeouts.claudeCli / 1000)} claude --model ${mappedModel} -p hi`;
         } catch (timeoutError) {
           if (timeoutError.code === 124) {
-            await log(`❌ Claude CLI timed out after ${Math.floor(timeouts.claudeCli / 1000)} seconds`, { level: 'error' });
+            await log(`❌ Claude CLI timed out after ${Math.floor(timeouts.claudeCli / 1000)} seconds`, {
+              level: 'error',
+            });
             await log('   💡 This may indicate Claude CLI is taking too long to respond', { level: 'error' });
-            await log(`   💡 Try running 'claude --model ${mappedModel} -p hi' manually to verify it works`, { level: 'error' });
+            await log(`   💡 Try running 'claude --model ${mappedModel} -p hi' manually to verify it works`, {
+              level: 'error',
+            });
             return false;
           }
           // Re-throw if it's not a timeout error
           throw timeoutError;
         }
       }
-    
+
       // Check for common error patterns
       const stdout = result.stdout?.toString() || '';
       const stderr = result.stderr?.toString() || '';
       // Check for JSON errors in stdout or stderr
-      const checkForJsonError = (text) => {
+      const checkForJsonError = text => {
         try {
           // Look for JSON error patterns
           if (text.includes('"error"') && text.includes('"type"')) {
@@ -115,7 +117,7 @@ export const validateClaudeConnection = async (model = 'haiku-3') => {
           if (global.verboseMode) {
             reportError(e, {
               context: 'claude_json_error_parse',
-              level: 'debug'
+              level: 'debug',
             });
           }
         }
@@ -123,20 +125,22 @@ export const validateClaudeConnection = async (model = 'haiku-3') => {
       };
       const jsonError = checkForJsonError(stdout) || checkForJsonError(stderr);
       // Check for API overload error pattern
-      const isOverloadError = (stdout.includes('API Error: 500') && stdout.includes('Overloaded')) ||
-                             (stderr.includes('API Error: 500') && stderr.includes('Overloaded')) ||
-                             (jsonError && jsonError.type === 'api_error' && jsonError.message === 'Overloaded');
-    
+      const isOverloadError = (stdout.includes('API Error: 500') && stdout.includes('Overloaded')) || (stderr.includes('API Error: 500') && stderr.includes('Overloaded')) || (jsonError && jsonError.type === 'api_error' && jsonError.message === 'Overloaded');
+
       // Handle overload errors with retry
       if (isOverloadError) {
         if (retryCount < maxRetries) {
           const delay = baseDelay * Math.pow(2, retryCount);
-          await log(`⚠️ API overload error during validation. Retrying in ${delay / 1000} seconds...`, { level: 'warning' });
+          await log(`⚠️ API overload error during validation. Retrying in ${delay / 1000} seconds...`, {
+            level: 'warning',
+          });
           await new Promise(resolve => setTimeout(resolve, delay));
           retryCount++;
           return await attemptValidation();
         } else {
-          await log(`❌ API overload error persisted after ${maxRetries} retries during validation`, { level: 'error' });
+          await log(`❌ API overload error persisted after ${maxRetries} retries during validation`, {
+            level: 'error',
+          });
           await log('   The API appears to be heavily loaded. Please try again later.', { level: 'error' });
           return false;
         }
@@ -146,7 +150,9 @@ export const validateClaudeConnection = async (model = 'haiku-3') => {
       if (exitCode !== 0) {
         // Command failed
         if (jsonError) {
-          await log(`❌ Claude CLI authentication failed: ${jsonError.type} - ${jsonError.message}`, { level: 'error' });
+          await log(`❌ Claude CLI authentication failed: ${jsonError.type} - ${jsonError.message}`, {
+            level: 'error',
+          });
         } else {
           await log(`❌ Claude CLI failed with exit code ${exitCode}`, { level: 'error' });
           if (stderr) await log(`   Error: ${stderr.trim()}`, { level: 'error' });
@@ -161,7 +167,9 @@ export const validateClaudeConnection = async (model = 'haiku-3') => {
         if (jsonError.type === 'api_error' && jsonError.message === 'Overloaded') {
           if (retryCount < maxRetries) {
             const delay = baseDelay * Math.pow(2, retryCount);
-            await log(`⚠️ API overload error in response. Retrying in ${delay / 1000} seconds...`, { level: 'warning' });
+            await log(`⚠️ API overload error in response. Retrying in ${delay / 1000} seconds...`, {
+              level: 'warning',
+            });
             await new Promise(resolve => setTimeout(resolve, delay));
             retryCount++;
             return await attemptValidation();
@@ -181,11 +189,12 @@ export const validateClaudeConnection = async (model = 'haiku-3') => {
       return true;
     } catch (error) {
       const errorStr = error.message || error.toString();
-      if ((errorStr.includes('API Error: 500') && errorStr.includes('Overloaded')) ||
-          (errorStr.includes('api_error') && errorStr.includes('Overloaded'))) {
+      if ((errorStr.includes('API Error: 500') && errorStr.includes('Overloaded')) || (errorStr.includes('api_error') && errorStr.includes('Overloaded'))) {
         if (retryCount < maxRetries) {
           const delay = baseDelay * Math.pow(2, retryCount);
-          await log(`⚠️ API overload error during validation. Retrying in ${delay / 1000} seconds...`, { level: 'warning' });
+          await log(`⚠️ API overload error during validation. Retrying in ${delay / 1000} seconds...`, {
+            level: 'warning',
+          });
           await new Promise(resolve => setTimeout(resolve, delay));
           retryCount++;
           return await attemptValidation();
@@ -203,7 +212,7 @@ export const validateClaudeConnection = async (model = 'haiku-3') => {
   return await attemptValidation();
 };
 // Function to handle Claude runtime switching between Node.js and Bun
-export const handleClaudeRuntimeSwitch = async (argv) => {
+export const handleClaudeRuntimeSwitch = async argv => {
   if (argv['force-claude-bun-run']) {
     await log('\n🔧 Switching Claude runtime to bun...');
     try {
@@ -213,29 +222,29 @@ export const handleClaudeRuntimeSwitch = async (argv) => {
       } catch (bunError) {
         reportError(bunError, {
           context: 'claude.lib.mjs - bun availability check',
-          level: 'error'
+          level: 'error',
         });
         await log('❌ Bun runtime not found. Please install bun first: https://bun.sh/', { level: 'error' });
         process.exit(1);
       }
-      
+
       // Find Claude executable path
       const claudePathResult = await $`which claude`;
       const claudePath = claudePathResult.stdout.toString().trim();
-      
+
       if (!claudePath) {
         await log('❌ Claude executable not found', { level: 'error' });
         process.exit(1);
       }
-      
+
       await log(`   Claude path: ${claudePath}`);
-      
+
       try {
         await fs.access(claudePath, fs.constants.W_OK);
       } catch (accessError) {
         reportError(accessError, {
           context: 'claude.lib.mjs - Claude executable write permission check (bun)',
-          level: 'error'
+          level: 'error',
         });
         await log('❌ Cannot write to Claude executable (permission denied)', { level: 'error' });
         await log('   Try running with sudo or changing file permissions', { level: 'error' });
@@ -249,35 +258,34 @@ export const handleClaudeRuntimeSwitch = async (argv) => {
         await log('   ✅ Claude is already configured to use bun');
         process.exit(0);
       }
-      
+
       // Create backup
       const backupPath = `${claudePath}.nodejs-backup`;
       await $`cp "${claudePath}" "${backupPath}"`;
       await log(`   📦 Backup created: ${backupPath}`);
-      
+
       // Read file content and replace shebang
       const content = await fs.readFile(claudePath, 'utf8');
       const newContent = content.replace(/^#!.*node.*$/m, '#!/usr/bin/env bun');
-      
+
       if (content === newContent) {
         await log('⚠️  No Node.js shebang found to replace', { level: 'warning' });
         await log(`   Current shebang: ${currentShebang}`, { level: 'warning' });
         process.exit(0);
       }
-      
+
       await fs.writeFile(claudePath, newContent);
       await log('   ✅ Claude shebang updated to use bun');
       await log('   🔄 Claude will now run with bun runtime');
-      
     } catch (error) {
       await log(`❌ Failed to switch Claude to bun: ${cleanErrorMessage(error)}`, { level: 'error' });
       process.exit(1);
     }
-    
+
     // Exit after switching runtime
     process.exit(0);
   }
-  
+
   if (argv['force-claude-nodejs-run']) {
     await log('\n🔧 Restoring Claude runtime to Node.js...');
     try {
@@ -287,29 +295,29 @@ export const handleClaudeRuntimeSwitch = async (argv) => {
       } catch (nodeError) {
         reportError(nodeError, {
           context: 'claude.lib.mjs - Node.js availability check',
-          level: 'error'
+          level: 'error',
         });
         await log('❌ Node.js runtime not found. Please install Node.js first', { level: 'error' });
         process.exit(1);
       }
-      
+
       // Find Claude executable path
       const claudePathResult = await $`which claude`;
       const claudePath = claudePathResult.stdout.toString().trim();
-      
+
       if (!claudePath) {
         await log('❌ Claude executable not found', { level: 'error' });
         process.exit(1);
       }
-      
+
       await log(`   Claude path: ${claudePath}`);
-      
+
       try {
         await fs.access(claudePath, fs.constants.W_OK);
       } catch (accessError) {
         reportError(accessError, {
           context: 'claude.lib.mjs - Claude executable write permission check (nodejs)',
-          level: 'error'
+          level: 'error',
         });
         await log('❌ Cannot write to Claude executable (permission denied)', { level: 'error' });
         await log('   Try running with sudo or changing file permissions', { level: 'error' });
@@ -323,7 +331,7 @@ export const handleClaudeRuntimeSwitch = async (argv) => {
         await log('   ✅ Claude is already configured to use Node.js');
         process.exit(0);
       }
-      
+
       const backupPath = `${claudePath}.nodejs-backup`;
       try {
         await fs.access(backupPath);
@@ -333,30 +341,29 @@ export const handleClaudeRuntimeSwitch = async (argv) => {
       } catch (backupError) {
         reportError(backupError, {
           context: 'claude_restore_backup',
-          level: 'info'
+          level: 'info',
         });
         // No backup available, manually update shebang
         await log('   📝 No backup found, manually updating shebang...');
         const content = await fs.readFile(claudePath, 'utf8');
         const newContent = content.replace(/^#!.*bun.*$/m, '#!/usr/bin/env node');
-        
+
         if (content === newContent) {
           await log('⚠️  No bun shebang found to replace', { level: 'warning' });
           await log(`   Current shebang: ${currentShebang}`, { level: 'warning' });
           process.exit(0);
         }
-        
+
         await fs.writeFile(claudePath, newContent);
         await log('   ✅ Claude shebang updated to use Node.js');
       }
-      
+
       await log('   🔄 Claude will now run with Node.js runtime');
-      
     } catch (error) {
       await log(`❌ Failed to restore Claude to Node.js: ${cleanErrorMessage(error)}`, { level: 'error' });
       process.exit(1);
     }
-    
+
     // Exit after restoring runtime
     process.exit(0);
   }
@@ -394,30 +401,8 @@ export const checkPlaywrightMcpAvailability = async () => {
  * @param {Object} params - Parameters for Claude execution
  * @returns {Object} Result of the execution including success status and session info
  */
-export const executeClaude = async (params) => {
-  const {
-    issueUrl,
-    issueNumber,
-    prNumber,
-    prUrl,
-    branchName,
-    tempDir,
-    isContinueMode,
-    mergeStateStatus,
-    forkedRepo,
-    feedbackLines,
-    forkActionsUrl,
-    owner,
-    repo,
-    argv,
-    log,
-    setLogFile,
-    getLogFile,
-    formatAligned,
-    getResourceSnapshot,
-    claudePath,
-    $
-  } = params;
+export const executeClaude = async params => {
+  const { issueUrl, issueNumber, prNumber, prUrl, branchName, tempDir, isContinueMode, mergeStateStatus, forkedRepo, feedbackLines, forkActionsUrl, owner, repo, argv, log, setLogFile, getLogFile, formatAligned, getResourceSnapshot, claudePath, $ } = params;
   // Import prompt building functions from claude.prompts.lib.mjs
   const { buildUserPrompt, buildSystemPrompt } = await import('./claude.prompts.lib.mjs');
   // Build the user prompt
@@ -435,7 +420,7 @@ export const executeClaude = async (params) => {
     forkActionsUrl,
     owner,
     repo,
-    argv
+    argv,
   });
   // Build the system prompt
   const systemPrompt = buildSystemPrompt({
@@ -449,7 +434,7 @@ export const executeClaude = async (params) => {
     tempDir,
     isContinueMode,
     forkedRepo,
-    argv
+    argv,
   });
   // Log prompt details in verbose mode
   if (argv.verbose) {
@@ -495,7 +480,7 @@ export const executeClaude = async (params) => {
     // For interactive mode
     owner,
     repo,
-    prNumber
+    prNumber,
   });
 };
 /**
@@ -509,45 +494,47 @@ export const executeClaude = async (params) => {
  * @param {string} modelId - The model ID (e.g., "claude-sonnet-4-5-20250929")
  * @returns {Promise<Object|null>} Model information or null if not found
  */
-export const fetchModelInfo = async (modelId) => {
+export const fetchModelInfo = async modelId => {
   try {
     const https = (await use('https')).default;
     return new Promise((resolve, reject) => {
-      https.get('https://models.dev/api.json', (res) => {
-        let data = '';
-        res.on('data', (chunk) => {
-          data += chunk;
-        });
-        res.on('end', () => {
-          try {
-            const apiData = JSON.parse(data);
-            // For public pricing calculation, prefer Anthropic provider for Claude models
-            // Check Anthropic provider first
-            if (apiData.anthropic?.models?.[modelId]) {
-              const modelInfo = apiData.anthropic.models[modelId];
-              modelInfo.provider = apiData.anthropic.name || 'Anthropic';
-              resolve(modelInfo);
-              return;
-            }
-            // Search for the model across all other providers
-            for (const provider of Object.values(apiData)) {
-              if (provider.models && provider.models[modelId]) {
-                const modelInfo = provider.models[modelId];
-                // Add provider info
-                modelInfo.provider = provider.name || provider.id;
+      https
+        .get('https://models.dev/api.json', res => {
+          let data = '';
+          res.on('data', chunk => {
+            data += chunk;
+          });
+          res.on('end', () => {
+            try {
+              const apiData = JSON.parse(data);
+              // For public pricing calculation, prefer Anthropic provider for Claude models
+              // Check Anthropic provider first
+              if (apiData.anthropic?.models?.[modelId]) {
+                const modelInfo = apiData.anthropic.models[modelId];
+                modelInfo.provider = apiData.anthropic.name || 'Anthropic';
                 resolve(modelInfo);
                 return;
               }
+              // Search for the model across all other providers
+              for (const provider of Object.values(apiData)) {
+                if (provider.models && provider.models[modelId]) {
+                  const modelInfo = provider.models[modelId];
+                  // Add provider info
+                  modelInfo.provider = provider.name || provider.id;
+                  resolve(modelInfo);
+                  return;
+                }
+              }
+              // Model not found
+              resolve(null);
+            } catch (parseError) {
+              reject(parseError);
             }
-            // Model not found
-            resolve(null);
-          } catch (parseError) {
-            reject(parseError);
-          }
+          });
+        })
+        .on('error', err => {
+          reject(err);
         });
-      }).on('error', (err) => {
-        reject(err);
-      });
     });
   } catch {
     // If we can't fetch model info, return null and continue without it
@@ -570,14 +557,14 @@ export const calculateModelCost = (usage, modelInfo, includeBreakdown = false) =
     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 }
+    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: (usage.inputTokens / 1000000) * cost.input,
     };
   }
   // Cache creation tokens cost
@@ -585,7 +572,7 @@ export const calculateModelCost = (usage, modelInfo, includeBreakdown = false) =
     breakdown.cacheWrite = {
       tokens: usage.cacheCreationTokens,
       costPerMillion: cost.cache_write,
-      cost: (usage.cacheCreationTokens / 1000000) * cost.cache_write
+      cost: (usage.cacheCreationTokens / 1000000) * cost.cache_write,
     };
   }
   // Cache read tokens cost
@@ -593,7 +580,7 @@ export const calculateModelCost = (usage, modelInfo, includeBreakdown = false) =
     breakdown.cacheRead = {
       tokens: usage.cacheReadTokens,
       costPerMillion: cost.cache_read,
-      cost: (usage.cacheReadTokens / 1000000) * cost.cache_read
+      cost: (usage.cacheReadTokens / 1000000) * cost.cache_read,
     };
   }
   // Output tokens cost
@@ -601,14 +588,14 @@ export const calculateModelCost = (usage, modelInfo, includeBreakdown = false) =
     breakdown.output = {
       tokens: usage.outputTokens,
       costPerMillion: cost.output,
-      cost: (usage.outputTokens / 1000000) * cost.output
+      cost: (usage.outputTokens / 1000000) * cost.output,
     };
   }
   const totalCost = breakdown.input.cost + breakdown.cacheWrite.cost + breakdown.cacheRead.cost + breakdown.output.cost;
   if (includeBreakdown) {
     return {
       total: totalCost,
-      breakdown
+      breakdown,
     };
   }
   return totalCost;
@@ -631,8 +618,11 @@ const displayModelUsage = async (usage, log) => {
       { label: 'Output modalities', value: info.modalities?.output?.join(', ') || 'N/A' },
       { label: 'Knowledge cutoff', value: info.knowledge },
       { label: 'Released', value: info.release_date },
-      { label: 'Capabilities', value: [info.attachment && 'Attachments', info.reasoning && 'Reasoning', info.temperature && 'Temperature', info.tool_call && 'Tool calls'].filter(Boolean).join(', ') || 'N/A' },
-      { label: 'Open weights', value: info.open_weights ? 'Yes' : 'No' }
+      {
+        label: 'Capabilities',
+        value: [info.attachment && 'Attachments', info.reasoning && 'Reasoning', info.temperature && 'Temperature', info.tool_call && 'Tool calls'].filter(Boolean).join(', ') || 'N/A',
+      },
+      { label: 'Open weights', value: info.open_weights ? 'Yes' : 'No' },
     ];
     for (const { label, value } of fields) {
       if (value) await log(`      ${label}: ${value}`);
@@ -663,7 +653,7 @@ const displayModelUsage = async (usage, log) => {
       { key: 'input', label: 'Input' },
       { key: 'cacheWrite', label: 'Cache write' },
       { key: 'cacheRead', label: 'Cache read' },
-      { key: 'output', label: 'Output' }
+      { key: 'output', label: 'Output' },
     ];
     for (const { key, label } of types) {
       if (breakdown[key].tokens > 0) {
@@ -715,7 +705,7 @@ export const calculateSessionTokens = async (sessionId, tempDir) => {
               cacheCreation1hTokens: 0,
               cacheReadTokens: 0,
               outputTokens: 0,
-              webSearchRequests: 0
+              webSearchRequests: 0,
             };
           }
           // Add input tokens
@@ -754,7 +744,7 @@ export const calculateSessionTokens = async (sessionId, tempDir) => {
       return null;
     }
     // Fetch model information for each model
-    const modelInfoPromises = Object.keys(modelUsage).map(async (modelId) => {
+    const modelInfoPromises = Object.keys(modelUsage).map(async modelId => {
       const modelInfo = await fetchModelInfo(modelId);
       return { modelId, modelInfo };
     });
@@ -810,13 +800,13 @@ export const calculateSessionTokens = async (sessionId, tempDir) => {
       cacheReadTokens: totalCacheReadTokens,
       outputTokens: totalOutputTokens,
       totalTokens,
-      totalCostUSD: hasCostData ? totalCostUSD : null
+      totalCostUSD: hasCostData ? totalCostUSD : null,
     };
   } catch (readError) {
     throw new Error(`Failed to read session file: ${readError.message}`);
   }
 };
-export const executeClaudeCommand = async (params) => {
+export const executeClaudeCommand = async params => {
   const {
     tempDir,
     branchName,
@@ -833,11 +823,11 @@ export const executeClaudeCommand = async (params) => {
     forkedRepo,
     feedbackLines,
     claudePath,
-    $,  // Add command-stream $ to params
+    $, // Add command-stream $ to params
     // For interactive mode
     owner,
     repo,
-    prNumber
+    prNumber,
   } = params;
   // Retry configuration for API overload errors
   const maxRetries = 3;
@@ -852,24 +842,24 @@ export const executeClaudeCommand = async (params) => {
       await log(`\n${formatAligned('🔄', 'Retry attempt:', `${retryCount}/${maxRetries}`)}`);
     }
     if (argv.verbose) {
-    // Output the actual model being used
-    const modelName = argv.model === 'opus' ? 'opus' : 'sonnet';
-    await log(`   Model: ${modelName}`, { verbose: true });
-    await log(`   Working directory: ${tempDir}`, { verbose: true });
-    await log(`   Branch: ${branchName}`, { verbose: true });
-    await log(`   Prompt length: ${prompt.length} chars`, { verbose: true });
-    await log(`   System prompt length: ${systemPrompt.length} chars`, { verbose: true });
-    if (feedbackLines && feedbackLines.length > 0) {
-      await log(`   Feedback info included: Yes (${feedbackLines.length} lines)`, { verbose: true });
-    } else {
-      await log('   Feedback info included: No', { verbose: true });
+      // Output the actual model being used
+      const modelName = argv.model === 'opus' ? 'opus' : 'sonnet';
+      await log(`   Model: ${modelName}`, { verbose: true });
+      await log(`   Working directory: ${tempDir}`, { verbose: true });
+      await log(`   Branch: ${branchName}`, { verbose: true });
+      await log(`   Prompt length: ${prompt.length} chars`, { verbose: true });
+      await log(`   System prompt length: ${systemPrompt.length} chars`, { verbose: true });
+      if (feedbackLines && feedbackLines.length > 0) {
+        await log(`   Feedback info included: Yes (${feedbackLines.length} lines)`, { verbose: true });
+      } else {
+        await log('   Feedback info included: No', { verbose: true });
+      }
     }
-  }
-  // Take resource snapshot before execution
-  const resourcesBefore = await getResourceSnapshot();
-  await log('📈 System resources before execution:', { verbose: true });
-  await log(`   Memory: ${resourcesBefore.memory.split('\n')[1]}`, { verbose: true });
-  await log(`   Load: ${resourcesBefore.load}`, { verbose: true });
+    // Take resource snapshot before execution
+    const resourcesBefore = await getResourceSnapshot();
+    await log('📈 System resources before execution:', { verbose: true });
+    await log(`   Memory: ${resourcesBefore.memory.split('\n')[1]}`, { verbose: true });
+    await log(`   Load: ${resourcesBefore.load}`, { verbose: true });
     // Use command-stream's async iteration for real-time streaming with file logging
     let commandFailed = false;
     let sessionId = null;
@@ -883,534 +873,527 @@ export const executeClaudeCommand = async (params) => {
     let stderrErrors = [];
     let anthropicTotalCostUSD = null; // Capture Anthropic's official total_cost_usd from result
 
-  // Create interactive mode handler if enabled
-  let interactiveHandler = null;
-  if (argv.interactiveMode && owner && repo && prNumber) {
-    await log('🔌 Interactive mode: Creating handler for real-time PR comments', { verbose: true });
-    interactiveHandler = createInteractiveHandler({
-      owner,
-      repo,
-      prNumber,
-      $,
-      log,
-      verbose: argv.verbose
-    });
-  } else if (argv.interactiveMode) {
-    await log('⚠️ Interactive mode: Disabled - missing PR info (owner/repo/prNumber)', { verbose: true });
-  }
+    // Create interactive mode handler if enabled
+    let interactiveHandler = null;
+    if (argv.interactiveMode && owner && repo && prNumber) {
+      await log('🔌 Interactive mode: Creating handler for real-time PR comments', { verbose: true });
+      interactiveHandler = createInteractiveHandler({
+        owner,
+        repo,
+        prNumber,
+        $,
+        log,
+        verbose: argv.verbose,
+      });
+    } else if (argv.interactiveMode) {
+      await log('⚠️ Interactive mode: Disabled - missing PR info (owner/repo/prNumber)', { verbose: true });
+    }
 
-  // Build claude command with optional resume flag
-  let execCommand;
-  // Map model alias to full ID
-  const mappedModel = mapModelToId(argv.model);
-  // Build claude command arguments
-  let claudeArgs = `--output-format stream-json --verbose --dangerously-skip-permissions --model ${mappedModel}`;
-  if (argv.resume) {
-    await log(`🔄 Resuming from session: ${argv.resume}`);
-    claudeArgs = `--resume ${argv.resume} ${claudeArgs}`;
-  }
-  claudeArgs += ` -p "${escapedPrompt}" --append-system-prompt "${escapedSystemPrompt}"`;
-  // Build the full command for display (with jq for formatting as in v0.3.2)
-  const fullCommand = `(cd "${tempDir}" && ${claudePath} ${claudeArgs} | jq -c .)`;
-  // Print the actual raw command being executed
-  await log(`\n${formatAligned('📝', 'Raw command:', '')}`);
-  await log(`${fullCommand}`);
-  await log('');
-  // Output prompts in verbose mode for debugging
-  if (argv.verbose) {
-    await log('📋 User prompt:', { verbose: true });
-    await log('---BEGIN USER PROMPT---', { verbose: true });
-    await log(prompt, { verbose: true });
-    await log('---END USER PROMPT---', { verbose: true });
-    await log('', { verbose: true });
-    await log('📋 System prompt:', { verbose: true });
-    await log('---BEGIN SYSTEM PROMPT---', { verbose: true });
-    await log(systemPrompt, { verbose: true });
-    await log('---END SYSTEM PROMPT---', { verbose: true });
-    await log('', { verbose: true });
-  }
-  try {
+    // Build claude command with optional resume flag
+    let execCommand;
+    // Map model alias to full ID
+    const mappedModel = mapModelToId(argv.model);
+    // Build claude command arguments
+    let claudeArgs = `--output-format stream-json --verbose --dangerously-skip-permissions --model ${mappedModel}`;
     if (argv.resume) {
-      // When resuming, pass prompt directly with -p flag
-      // Use simpler escaping - just escape double quotes
-      const simpleEscapedPrompt = prompt.replace(/"/g, '\\"');
-      const simpleEscapedSystem = systemPrompt.replace(/"/g, '\\"');
-      execCommand = $({
-        cwd: tempDir,
-        mirror: false
-      })`${claudePath} --resume ${argv.resume} --output-format stream-json --verbose --dangerously-skip-permissions --model ${mappedModel} -p "${simpleEscapedPrompt}" --append-system-prompt "${simpleEscapedSystem}"`;
-    } else {
-      // When not resuming, pass prompt via stdin
-      // For system prompt, escape it properly for shell - just escape double quotes
-      const simpleEscapedSystem = systemPrompt.replace(/"/g, '\\"');
-      execCommand = $({
-        cwd: tempDir,
-        stdin: prompt,
-        mirror: false
-      })`${claudePath} --output-format stream-json --verbose --dangerously-skip-permissions --model ${mappedModel} --append-system-prompt "${simpleEscapedSystem}"`;
+      await log(`🔄 Resuming from session: ${argv.resume}`);
+      claudeArgs = `--resume ${argv.resume} ${claudeArgs}`;
     }
-    await log(`${formatAligned('📋', 'Command details:', '')}`);
-    await log(formatAligned('📂', 'Working directory:', tempDir, 2));
-    await log(formatAligned('🌿', 'Branch:', branchName, 2));
-    await log(formatAligned('🤖', 'Model:', `Claude ${argv.model.toUpperCase()}`, 2));
-    if (argv.fork && forkedRepo) {
-      await log(formatAligned('🍴', 'Fork:', forkedRepo, 2));
+    claudeArgs += ` -p "${escapedPrompt}" --append-system-prompt "${escapedSystemPrompt}"`;
+    // Build the full command for display (with jq for formatting as in v0.3.2)
+    const fullCommand = `(cd "${tempDir}" && ${claudePath} ${claudeArgs} | jq -c .)`;
+    // Print the actual raw command being executed
+    await log(`\n${formatAligned('📝', 'Raw command:', '')}`);
+    await log(`${fullCommand}`);
+    await log('');
+    // Output prompts in verbose mode for debugging
+    if (argv.verbose) {
+      await log('📋 User prompt:', { verbose: true });
+      await log('---BEGIN USER PROMPT---', { verbose: true });
+      await log(prompt, { verbose: true });
+      await log('---END USER PROMPT---', { verbose: true });
+      await log('', { verbose: true });
+      await log('📋 System prompt:', { verbose: true });
+      await log('---BEGIN SYSTEM PROMPT---', { verbose: true });
+      await log(systemPrompt, { verbose: true });
+      await log('---END SYSTEM PROMPT---', { verbose: true });
+      await log('', { verbose: true });
     }
-    await log(`\n${formatAligned('▶️', 'Streaming output:', '')}\n`);
-    // Use command-stream's async iteration for real-time streaming
-    let exitCode = 0;
-    for await (const chunk of execCommand.stream()) {
-      if (chunk.type === 'stdout') {
-        const output = chunk.data.toString();
-        // Split output into individual lines for NDJSON parsing
-        // Claude CLI outputs NDJSON (newline-delimited JSON) format where each line is a separate JSON object
-        // This allows us to parse each event independently and extract structured data like session IDs,
-        // message counts, and error patterns. Attempting to parse the entire chunk as single JSON would fail
-        // since multiple JSON objects aren't valid JSON together.
-        const lines = output.split('\n');
-        for (const line of lines) {
-          if (!line.trim()) continue;
-          try {
-            const data = JSON.parse(line);
-            // Process event in interactive mode (posts PR comments in real-time)
-            if (interactiveHandler) {
-              try {
-                await interactiveHandler.processEvent(data);
-              } catch (interactiveError) {
-                // Don't let interactive mode errors stop the main execution
-                await log(`⚠️ Interactive mode error: ${interactiveError.message}`, { verbose: true });
+    try {
+      if (argv.resume) {
+        // When resuming, pass prompt directly with -p flag
+        // Use simpler escaping - just escape double quotes
+        const simpleEscapedPrompt = prompt.replace(/"/g, '\\"');
+        const simpleEscapedSystem = systemPrompt.replace(/"/g, '\\"');
+        execCommand = $({
+          cwd: tempDir,
+          mirror: false,
+        })`${claudePath} --resume ${argv.resume} --output-format stream-json --verbose --dangerously-skip-permissions --model ${mappedModel} -p "${simpleEscapedPrompt}" --append-system-prompt "${simpleEscapedSystem}"`;
+      } else {
+        // When not resuming, pass prompt via stdin
+        // For system prompt, escape it properly for shell - just escape double quotes
+        const simpleEscapedSystem = systemPrompt.replace(/"/g, '\\"');
+        execCommand = $({
+          cwd: tempDir,
+          stdin: prompt,
+          mirror: false,
+        })`${claudePath} --output-format stream-json --verbose --dangerously-skip-permissions --model ${mappedModel} --append-system-prompt "${simpleEscapedSystem}"`;
+      }
+      await log(`${formatAligned('📋', 'Command details:', '')}`);
+      await log(formatAligned('📂', 'Working directory:', tempDir, 2));
+      await log(formatAligned('🌿', 'Branch:', branchName, 2));
+      await log(formatAligned('🤖', 'Model:', `Claude ${argv.model.toUpperCase()}`, 2));
+      if (argv.fork && forkedRepo) {
+        await log(formatAligned('🍴', 'Fork:', forkedRepo, 2));
+      }
+      await log(`\n${formatAligned('▶️', 'Streaming output:', '')}\n`);
+      // Use command-stream's async iteration for real-time streaming
+      let exitCode = 0;
+      for await (const chunk of execCommand.stream()) {
+        if (chunk.type === 'stdout') {
+          const output = chunk.data.toString();
+          // Split output into individual lines for NDJSON parsing
+          // Claude CLI outputs NDJSON (newline-delimited JSON) format where each line is a separate JSON object
+          // This allows us to parse each event independently and extract structured data like session IDs,
+          // message counts, and error patterns. Attempting to parse the entire chunk as single JSON would fail
+          // since multiple JSON objects aren't valid JSON together.
+          const lines = output.split('\n');
+          for (const line of lines) {
+            if (!line.trim()) continue;
+            try {
+              const data = JSON.parse(line);
+              // Process event in interactive mode (posts PR comments in real-time)
+              if (interactiveHandler) {
+                try {
+                  await interactiveHandler.processEvent(data);
+                } catch (interactiveError) {
+                  // Don't let interactive mode errors stop the main execution
+                  await log(`⚠️ Interactive mode error: ${interactiveError.message}`, { verbose: true });
+                }
               }
-            }
-            // Output formatted JSON as in v0.3.2
-            await log(JSON.stringify(data, null, 2));
-            // Capture session ID from the first message
-            if (!sessionId && data.session_id) {
-              sessionId = data.session_id;
-              await log(`📌 Session ID: ${sessionId}`);
-              // Try to rename log file to include session ID
-              let sessionLogFile;
-              try {
-                const currentLogFile = getLogFile();
-                const logDir = path.dirname(currentLogFile);
-                sessionLogFile = path.join(logDir, `${sessionId}.log`);
-                // Use fs.promises to rename the file
-                await fs.rename(currentLogFile, sessionLogFile);
-                // Update the global log file reference
-                setLogFile(sessionLogFile);
-                await log(`📁 Log renamed to: ${sessionLogFile}`);
-              } catch (renameError) {
-                reportError(renameError, {
-                  context: 'rename_session_log',
-                  sessionId,
-                  sessionLogFile,
-                  operation: 'rename_log_file'
-                });
-                // If rename fails, keep original filename
-                await log(`⚠️ Could not rename log file: ${renameError.message}`, { verbose: true });
+              // Output formatted JSON as in v0.3.2
+              await log(JSON.stringify(data, null, 2));
+              // Capture session ID from the first message
+              if (!sessionId && data.session_id) {
+                sessionId = data.session_id;
+                await log(`📌 Session ID: ${sessionId}`);
+                // Try to rename log file to include session ID
+                let sessionLogFile;
+                try {
+                  const currentLogFile = getLogFile();
+                  const logDir = path.dirname(currentLogFile);
+                  sessionLogFile = path.join(logDir, `${sessionId}.log`);
+                  // Use fs.promises to rename the file
+                  await fs.rename(currentLogFile, sessionLogFile);
+                  // Update the global log file reference
+                  setLogFile(sessionLogFile);
+                  await log(`📁 Log renamed to: ${sessionLogFile}`);
+                } catch (renameError) {
+                  reportError(renameError, {
+                    context: 'rename_session_log',
+                    sessionId,
+                    sessionLogFile,
+                    operation: 'rename_log_file',
+                  });
+                  // If rename fails, keep original filename
+                  await log(`⚠️ Could not rename log file: ${renameError.message}`, { verbose: true });
+                }
               }
-            }
-            // Track message and tool use counts
-            if (data.type === 'message') {
-              messageCount++;
-            } else if (data.type === 'tool_use') {
-              toolUseCount++;
-            }
-            // Handle session result type from Claude CLI
-            // This is emitted when a session completes, either successfully or with an error
-            // Example: {"type": "result", "subtype": "success", "is_error": true, "result": "Session limit reached ∙ resets 10am"}
-            if (data.type === 'result') {
-              // Capture Anthropic's official total_cost_usd from the result
-              if (data.total_cost_usd !== undefined && data.total_cost_usd !== null) {
-                anthropicTotalCostUSD = data.total_cost_usd;
-                await log(`💰 Anthropic official cost captured: $${anthropicTotalCostUSD.toFixed(6)}`, { verbose: true });
+              // Track message and tool use counts
+              if (data.type === 'message') {
+                messageCount++;
+              } else if (data.type === 'tool_use') {
+                toolUseCount++;
               }
-              if (data.is_error === true) {
-                commandFailed = true;
-                lastMessage = data.result || JSON.stringify(data);
-                await log('⚠️ Detected error result from Claude CLI', { verbose: true });
-                if (lastMessage.includes('Session limit reached') || lastMessage.includes('limit reached')) {
-                  limitReached = true;
-                  await log('⚠️ Detected session limit in result', { verbose: true });
+              // Handle session result type from Claude CLI
+              // This is emitted when a session completes, either successfully or with an error
+              // Example: {"type": "result", "subtype": "success", "is_error": true, "result": "Session limit reached ∙ resets 10am"}
+              if (data.type === 'result') {
+                // Capture Anthropic's official total_cost_usd from the result
+                if (data.total_cost_usd !== undefined && data.total_cost_usd !== null) {
+                  anthropicTotalCostUSD = data.total_cost_usd;
+                  await log(`💰 Anthropic official cost captured: $${anthropicTotalCostUSD.toFixed(6)}`, {
+                    verbose: true,
+                  });
                 }
-              }
-            }
-            // Store last message for error detection
-            if (data.type === 'text' && data.text) {
-              lastMessage = data.text;
-            } else if (data.type === 'error') {
-              lastMessage = data.error || JSON.stringify(data);
-            }
-            // Check for API overload error and 503 errors
-            if (data.type === 'assistant' && data.message && data.message.content) {
-              const content = Array.isArray(data.message.content) ? data.message.content : [data.message.content];
-              for (const item of content) {
-                if (item.type === 'text' && item.text) {
-                  // Check for the specific 500 overload error pattern
-                  if (item.text.includes('API Error: 500') &&
-                      item.text.includes('api_error') &&
-                      item.text.includes('Overloaded')) {
-                    isOverloadError = true;
-                    lastMessage = item.text;
-                    await log('⚠️ Detected API overload error', { verbose: true });
+                if (data.is_error === true) {
+                  commandFailed = true;
+                  lastMessage = data.result || JSON.stringify(data);
+                  await log('⚠️ Detected error result from Claude CLI', { verbose: true });
+                  if (lastMessage.includes('Session limit reached') || lastMessage.includes('limit reached')) {
+                    limitReached = true;
+                    await log('⚠️ Detected session limit in result', { verbose: true });
                   }
-                  // Check for 503 errors
-                  if (item.text.includes('API Error: 503') ||
-                      (item.text.includes('503') && item.text.includes('upstream connect error')) ||
-                      (item.text.includes('503') && item.text.includes('remote connection failure'))) {
-                    is503Error = true;
-                    lastMessage = item.text;
-                    await log('⚠️ Detected 503 network error', { verbose: true });
+                }
+              }
+              // Store last message for error detection
+              if (data.type === 'text' && data.text) {
+                lastMessage = data.text;
+              } else if (data.type === 'error') {
+                lastMessage = data.error || JSON.stringify(data);
+              }
+              // Check for API overload error and 503 errors
+              if (data.type === 'assistant' && data.message && data.message.content) {
+                const content = Array.isArray(data.message.content) ? data.message.content : [data.message.content];
+                for (const item of content) {
+                  if (item.type === 'text' && item.text) {
+                    // Check for the specific 500 overload error pattern
+                    if (item.text.includes('API Error: 500') && item.text.includes('api_error') && item.text.includes('Overloaded')) {
+                      isOverloadError = true;
+                      lastMessage = item.text;
+                      await log('⚠️ Detected API overload error', { verbose: true });
+                    }
+                    // Check for 503 errors
+                    if (item.text.includes('API Error: 503') || (item.text.includes('503') && item.text.includes('upstream connect error')) || (item.text.includes('503') && item.text.includes('remote connection failure'))) {
+                      is503Error = true;
+                      lastMessage = item.text;
+                      await log('⚠️ Detected 503 network error', { verbose: true });
+                    }
                   }
                 }
               }
-            }
-          } catch (parseError) {
-            // JSON parse errors are expected for non-JSON output
-            // Only report in verbose mode
-            if (global.verboseMode) {
-              reportError(parseError, {
-                context: 'parse_claude_output',
-                line,
-                operation: 'parse_json_output',
-                level: 'debug'
-              });
-            }
-            // Not JSON or parsing failed, output as-is if it's not empty
-            if (line.trim() && !line.includes('node:internal')) {
-              await log(line, { stream: 'raw' });
-              lastMessage = line;
+            } catch (parseError) {
+              // JSON parse errors are expected for non-JSON output
+              // Only report in verbose mode
+              if (global.verboseMode) {
+                reportError(parseError, {
+                  context: 'parse_claude_output',
+                  line,
+                  operation: 'parse_json_output',
+                  level: 'debug',
+                });
+              }
+              // Not JSON or parsing failed, output as-is if it's not empty
+              if (line.trim() && !line.includes('node:internal')) {
+                await log(line, { stream: 'raw' });
+                lastMessage = line;
+              }
             }
           }
         }
-      }
-      if (chunk.type === 'stderr') {
-        const errorOutput = chunk.data.toString();
-        // Log stderr immediately
-        if (errorOutput) {
-          await log(errorOutput, { stream: 'stderr' });
-          // Track stderr errors for failure detection
-          const trimmed = errorOutput.trim();
-          // Exclude warnings (messages starting with ⚠️) from being treated as errors
-          // Example: "⚠️  [BashTool] Pre-flight check is taking longer than expected. Run with ANTHROPIC_LOG=debug to check for failed or slow API requests."
-          // Even though this contains the word "failed", it's a warning, not an error
-          const isWarning = trimmed.startsWith('⚠️') || trimmed.startsWith('⚠');
-          if (trimmed && !isWarning && (trimmed.includes('Error:') || trimmed.includes('error') || trimmed.includes('failed'))) {
-            stderrErrors.push(trimmed);
+        if (chunk.type === 'stderr') {
+          const errorOutput = chunk.data.toString();
+          // Log stderr immediately
+          if (errorOutput) {
+            await log(errorOutput, { stream: 'stderr' });
+            // Track stderr errors for failure detection
+            const trimmed = errorOutput.trim();
+            // Exclude warnings (messages starting with ⚠️) from being treated as errors
+            // Example: "⚠️  [BashTool] Pre-flight check is taking longer than expected. Run with ANTHROPIC_LOG=debug to check for failed or slow API requests."
+            // Even though this contains the word "failed", it's a warning, not an error
+            const isWarning = trimmed.startsWith('⚠️') || trimmed.startsWith('⚠');
+            if (trimmed && !isWarning && (trimmed.includes('Error:') || trimmed.includes('error') || trimmed.includes('failed'))) {
+              stderrErrors.push(trimmed);
+            }
           }
+        } else if (chunk.type === 'exit') {
+          exitCode = chunk.code;
+          if (chunk.code !== 0) {
+            commandFailed = true;
+          }
+          // Don't break here - let the loop finish naturally to process all output
         }
-      } else if (chunk.type === 'exit') {
-        exitCode = chunk.code;
-        if (chunk.code !== 0) {
-          commandFailed = true;
-        }
-        // Don't break here - let the loop finish naturally to process all output
       }
-    }
 
-    // Flush any remaining queued comments from interactive mode
-    if (interactiveHandler) {
-      try {
-        await interactiveHandler.flush();
-      } catch (flushError) {
-        await log(`⚠️ Interactive mode flush error: ${flushError.message}`, { verbose: true });
+      // Flush any remaining queued comments from interactive mode
+      if (interactiveHandler) {
+        try {
+          await interactiveHandler.flush();
+        } catch (flushError) {
+          await log(`⚠️ Interactive mode flush error: ${flushError.message}`, { verbose: true });
+        }
       }
-    }
 
-    if ((commandFailed || isOverloadError) &&
-        (isOverloadError ||
-         (lastMessage.includes('API Error: 500') && lastMessage.includes('Overloaded')) ||
-         (lastMessage.includes('api_error') && lastMessage.includes('Overloaded')))) {
-      if (retryCount < maxRetries) {
-        // Calculate exponential backoff delay
-        const delay = baseDelay * Math.pow(2, retryCount);
-        await log(`\n⚠️ API overload error detected. Retrying in ${delay / 1000} seconds...`, { level: 'warning' });
-        await log(`   Error: ${lastMessage.substring(0, 200)}`, { verbose: true });
-        // Wait before retrying
-        await new Promise(resolve => setTimeout(resolve, delay));
-        // Increment retry count and retry
-        retryCount++;
-        return await executeWithRetry();
-      } else {
-        await log(`\n\n❌ API overload error persisted after ${maxRetries} retries`, { level: 'error' });
-        await log('   The API appears to be heavily loaded. Please try again later.', { level: 'error' });
-        return {
-          success: false,
-          sessionId,
-          limitReached: false,
-          limitResetTime: null,
-          messageCount,
-          toolUseCount
-        };
-      }
-    }
-    if ((commandFailed || is503Error) && argv.autoResumeOnErrors &&
-        (is503Error ||
-         lastMessage.includes('API Error: 503') ||
-         (lastMessage.includes('503') && lastMessage.includes('upstream connect error')) ||
-         (lastMessage.includes('503') && lastMessage.includes('remote connection failure')))) {
-      if (retryCount < retryLimits.max503Retries) {
-        // Calculate exponential backoff delay starting from 5 minutes
-        const delay = retryLimits.initial503RetryDelayMs * Math.pow(retryLimits.retryBackoffMultiplier, retryCount);
-        const delayMinutes = Math.round(delay / (1000 * 60));
-        await log(`\n⚠️ 503 network error detected. Retrying in ${delayMinutes} minutes...`, { level: 'warning' });
-        await log(`   Error: ${lastMessage.substring(0, 200)}`, { verbose: true });
-        await log(`   Retry ${retryCount + 1}/${retryLimits.max503Retries}`, { verbose: true });
-        // Show countdown for long waits
-        if (delay > 60000) {
-          const countdownInterval = 60000; // Every minute
-          let remainingMs = delay;
-          const countdownTimer = setInterval(async () => {
-            remainingMs -= countdownInterval;
-            if (remainingMs > 0) {
-              const remainingMinutes = Math.round(remainingMs / (1000 * 60));
-              await log(`⏳ ${remainingMinutes} minutes remaining until retry...`);
-            }
-          }, countdownInterval);
+      if ((commandFailed || isOverloadError) && (isOverloadError || (lastMessage.includes('API Error: 500') && lastMessage.includes('Overloaded')) || (lastMessage.includes('api_error') && lastMessage.includes('Overloaded')))) {
+        if (retryCount < maxRetries) {
+          // Calculate exponential backoff delay
+          const delay = baseDelay * Math.pow(2, retryCount);
+          await log(`\n⚠️ API overload error detected. Retrying in ${delay / 1000} seconds...`, { level: 'warning' });
+          await log(`   Error: ${lastMessage.substring(0, 200)}`, { verbose: true });
           // Wait before retrying
           await new Promise(resolve => setTimeout(resolve, delay));
-          clearInterval(countdownTimer);
+          // Increment retry count and retry
+          retryCount++;
+          return await executeWithRetry();
         } else {
-          // Wait before retrying
-          await new Promise(resolve => setTimeout(resolve, delay));
+          await log(`\n\n❌ API overload error persisted after ${maxRetries} retries`, { level: 'error' });
+          await log('   The API appears to be heavily loaded. Please try again later.', { level: 'error' });
+          return {
+            success: false,
+            sessionId,
+            limitReached: false,
+            limitResetTime: null,
+            messageCount,
+            toolUseCount,
+          };
         }
-        await log('\n🔄 Retrying now...');
-        // Increment retry count and retry
-        retryCount++;
-        return await executeWithRetry();
-      } else {
-        await log(`\n\n❌ 503 network error persisted after ${retryLimits.max503Retries} retries`, { level: 'error' });
-        await log('   The Anthropic API appears to be experiencing network issues.', { level: 'error' });
-        await log('   Please try again later or check https://status.anthropic.com/', { level: 'error' });
-        return {
-          success: false,
-          sessionId,
-          limitReached: false,
-          limitResetTime: null,
-          messageCount,
-          toolUseCount,
-          is503Error: true
-        };
       }
-    }
-    if (commandFailed) {
-      // Check for usage limit errors first (more specific)
-      const limitInfo = detectUsageLimit(lastMessage);
-      if (limitInfo.isUsageLimit) {
-        limitReached = true;
-        limitResetTime = limitInfo.resetTime;
+      if ((commandFailed || is503Error) && argv.autoResumeOnErrors && (is503Error || lastMessage.includes('API Error: 503') || (lastMessage.includes('503') && lastMessage.includes('upstream connect error')) || (lastMessage.includes('503') && lastMessage.includes('remote connection failure')))) {
+        if (retryCount < retryLimits.max503Retries) {
+          // Calculate exponential backoff delay starting from 5 minutes
+          const delay = retryLimits.initial503RetryDelayMs * Math.pow(retryLimits.retryBackoffMultiplier, retryCount);
+          const delayMinutes = Math.round(delay / (1000 * 60));
+          await log(`\n⚠️ 503 network error detected. Retrying in ${delayMinutes} minutes...`, { level: 'warning' });
+          await log(`   Error: ${lastMessage.substring(0, 200)}`, { verbose: true });
+          await log(`   Retry ${retryCount + 1}/${retryLimits.max503Retries}`, { verbose: true });
+          // Show countdown for long waits
+          if (delay > 60000) {
+            const countdownInterval = 60000; // Every minute
+            let remainingMs = delay;
+            const countdownTimer = setInterval(async () => {
+              remainingMs -= countdownInterval;
+              if (remainingMs > 0) {
+                const remainingMinutes = Math.round(remainingMs / (1000 * 60));
+                await log(`⏳ ${remainingMinutes} minutes remaining until retry...`);
+              }
+            }, countdownInterval);
+            // Wait before retrying
+            await new Promise(resolve => setTimeout(resolve, delay));
+            clearInterval(countdownTimer);
+          } else {
+            // Wait before retrying
+            await new Promise(resolve => setTimeout(resolve, delay));
+          }
+          await log('\n🔄 Retrying now...');
+          // Increment retry count and retry
+          retryCount++;
+          return await executeWithRetry();
+        } else {
+          await log(`\n\n❌ 503 network error persisted after ${retryLimits.max503Retries} retries`, {
+            level: 'error',
+          });
+          await log('   The Anthropic API appears to be experiencing network issues.', { level: 'error' });
+          await log('   Please try again later or check https://status.anthropic.com/', { level: 'error' });
+          return {
+            success: false,
+            sessionId,
+            limitReached: false,
+            limitResetTime: null,
+            messageCount,
+            toolUseCount,
+            is503Error: true,
+          };
+        }
+      }
+      if (commandFailed) {
+        // Check for usage limit errors first (more specific)
+        const limitInfo = detectUsageLimit(lastMessage);
+        if (limitInfo.isUsageLimit) {
+          limitReached = true;
+          limitResetTime = limitInfo.resetTime;
 
-        // Format and display user-friendly message
-        const messageLines = formatUsageLimitMessage({
-          tool: 'Claude',
-          resetTime: limitInfo.resetTime,
-          sessionId,
-          resumeCommand: argv.url ? `${process.argv[0]} ${process.argv[1]} --auto-continue ${argv.url}` : null
-        });
+          // Format and display user-friendly message
+          const messageLines = formatUsageLimitMessage({
+            tool: 'Claude',
+            resetTime: limitInfo.resetTime,
+            sessionId,
+            resumeCommand: argv.url ? `${process.argv[0]} ${process.argv[1]} --auto-continue ${argv.url}` : null,
+          });
 
-        for (const line of messageLines) {
-          await log(line, { level: 'warning' });
+          for (const line of messageLines) {
+            await log(line, { level: 'warning' });
+          }
+        } else if (lastMessage.includes('context_length_exceeded')) {
+          await log('\n\n❌ Context length exceeded. Try with a smaller issue or split the work.', { level: 'error' });
+        } else {
+          await log(`\n\n❌ Claude command failed with exit code ${exitCode}`, { level: 'error' });
+          if (sessionId && !argv.resume) {
+            await log(`📌 Session ID for resuming: ${sessionId}`);
+            await log('\nTo resume this session, run:');
+            await log(`   ${process.argv[0]} ${process.argv[1]} ${argv.url} --resume ${sessionId}`);
+          }
         }
-      } else if (lastMessage.includes('context_length_exceeded')) {
-        await log('\n\n❌ Context length exceeded. Try with a smaller issue or split the work.', { level: 'error' });
-      } else {
-        await log(`\n\n❌ Claude command failed with exit code ${exitCode}`, { level: 'error' });
-        if (sessionId && !argv.resume) {
-          await log(`📌 Session ID for resuming: ${sessionId}`);
-          await log('\nTo resume this session, run:');
-          await log(`   ${process.argv[0]} ${process.argv[1]} ${argv.url} --resume ${sessionId}`);
+      }
+      // Additional failure detection: if no messages were processed and there were stderr errors,
+      // or if the command produced no output at all, treat it as a failure
+      //
+      // This is critical for detecting "silent failures" where:
+      // 1. Claude CLI encounters an internal error (e.g., "kill EPERM" from timeout)
+      // 2. The error is logged to stderr but exit code is 0 or exit event is never sent
+      // 3. Result: messageCount=0, toolUseCount=0, but stderrErrors has content
+      //
+      // Common cause: sudo commands that timeout
+      // - Timeout triggers process.kill() in Claude CLI
+      // - If child process runs with sudo (root), parent can't kill it → EPERM error
+      // - Error logged to stderr, but command doesn't properly fail
+      //
+      // Workaround (applied in system prompt):
+      // - Instruct Claude to run sudo commands (installations) in background
+      // - Background processes avoid timeout kill mechanism
+      // - Prevents EPERM errors and false success reports
+      //
+      // See: docs/dependencies-research/claude-code-issues/README.md for full details
+      if (!commandFailed && stderrErrors.length > 0 && messageCount === 0 && toolUseCount === 0) {
+        commandFailed = true;
+        await log('\n\n❌ Command failed: No messages processed and errors detected in stderr', { level: 'error' });
+        await log('Stderr errors:', { level: 'error' });
+        for (const err of stderrErrors.slice(0, 5)) {
+          await log(`   ${err.substring(0, 200)}`, { level: 'error' });
         }
       }
-    }
-    // Additional failure detection: if no messages were processed and there were stderr errors,
-    // or if the command produced no output at all, treat it as a failure
-    //
-    // This is critical for detecting "silent failures" where:
-    // 1. Claude CLI encounters an internal error (e.g., "kill EPERM" from timeout)
-    // 2. The error is logged to stderr but exit code is 0 or exit event is never sent
-    // 3. Result: messageCount=0, toolUseCount=0, but stderrErrors has content
-    //
-    // Common cause: sudo commands that timeout
-    // - Timeout triggers process.kill() in Claude CLI
-    // - If child process runs with sudo (root), parent can't kill it → EPERM error
-    // - Error logged to stderr, but command doesn't properly fail
-    //
-    // Workaround (applied in system prompt):
-    // - Instruct Claude to run sudo commands (installations) in background
-    // - Background processes avoid timeout kill mechanism
-    // - Prevents EPERM errors and false success reports
-    //
-    // See: docs/dependencies-research/claude-code-issues/README.md for full details
-    if (!commandFailed && stderrErrors.length > 0 && messageCount === 0 && toolUseCount === 0) {
-      commandFailed = true;
-      await log('\n\n❌ Command failed: No messages processed and errors detected in stderr', { level: 'error' });
-      await log('Stderr errors:', { level: 'error' });
-      for (const err of stderrErrors.slice(0, 5)) {
-        await log(`   ${err.substring(0, 200)}`, { level: 'error' });
+      if (commandFailed) {
+        // Take resource snapshot after failure
+        const resourcesAfter = await getResourceSnapshot();
+        await log('\n📈 System resources after execution:', { verbose: true });
+        await log(`   Memory: ${resourcesAfter.memory.split('\n')[1]}`, { verbose: true });
+        await log(`   Load: ${resourcesAfter.load}`, { verbose: true });
+        // Log attachment will be handled by solve.mjs when it receives success=false
+        await log('', { verbose: true });
+        return {
+          success: false,
+          sessionId,
+          limitReached,
+          limitResetTime,
+          messageCount,
+          toolUseCount,
+        };
       }
-    }
-    if (commandFailed) {
-      // Take resource snapshot after failure
-      const resourcesAfter = await getResourceSnapshot();
-      await log('\n📈 System resources after execution:', { verbose: true });
-      await log(`   Memory: ${resourcesAfter.memory.split('\n')[1]}`, { verbose: true });
-      await log(`   Load: ${resourcesAfter.load}`, { verbose: true });
-      // Log attachment will be handled by solve.mjs when it receives success=false
-      await log('', { verbose: true });
-      return {
-        success: false,
-        sessionId,
-        limitReached,
-        limitResetTime,
-        messageCount,
-        toolUseCount
-      };
-    }
-    await log('\n\n✅ Claude command completed');
-    await log(`📊 Total messages: ${messageCount}, Tool uses: ${toolUseCount}`);
-    // Calculate and display total token usage from session JSONL file
-    if (sessionId && tempDir) {
-      try {
-        const tokenUsage = await calculateSessionTokens(sessionId, tempDir);
-        if (tokenUsage) {
-          await log('\n💰 Token Usage Summary:');
-          // Display per-model breakdown
-          if (tokenUsage.modelUsage) {
-            const modelIds = Object.keys(tokenUsage.modelUsage);
-            for (const modelId of modelIds) {
-              const usage = tokenUsage.modelUsage[modelId];
-              await log(`\n   📊 ${usage.modelName || modelId}:`);
-              await displayModelUsage(usage, log);
-              // Display budget stats if flag is enabled
-              if (argv.tokensBudgetStats && usage.modelInfo?.limit) {
-                await displayBudgetStats(usage, log);
-              }
-            }
-            // Show totals if multiple models were used
-            if (modelIds.length > 1) {
-              await log('\n   📈 Total across all models:');
-              // Show cost comparison
-              await log('\n   💰 Cost estimation:');
-              if (tokenUsage.totalCostUSD !== null && tokenUsage.totalCostUSD !== undefined) {
-                await log(`      Public pricing estimate: $${tokenUsage.totalCostUSD.toFixed(6)} USD`);
-              } else {
-                await log('      Public pricing estimate: unknown');
+      await log('\n\n✅ Claude command completed');
+      await log(`📊 Total messages: ${messageCount}, Tool uses: ${toolUseCount}`);
+      // Calculate and display total token usage from session JSONL file
+      if (sessionId && tempDir) {
+        try {
+          const tokenUsage = await calculateSessionTokens(sessionId, tempDir);
+          if (tokenUsage) {
+            await log('\n💰 Token Usage Summary:');
+            // Display per-model breakdown
+            if (tokenUsage.modelUsage) {
+              const modelIds = Object.keys(tokenUsage.modelUsage);
+              for (const modelId of modelIds) {
+                const usage = tokenUsage.modelUsage[modelId];
+                await log(`\n   📊 ${usage.modelName || modelId}:`);
+                await displayModelUsage(usage, log);
+                // Display budget stats if flag is enabled
+                if (argv.tokensBudgetStats && usage.modelInfo?.limit) {
+                  await displayBudgetStats(usage, log);
+                }
               }
-              if (anthropicTotalCostUSD !== null && anthropicTotalCostUSD !== undefined) {
-                await log(`      Calculated by Anthropic: $${anthropicTotalCostUSD.toFixed(6)} USD`);
-                // Show comparison if both are available
+              // Show totals if multiple models were used
+              if (modelIds.length > 1) {
+                await log('\n   📈 Total across all models:');
+                // Show cost comparison
+                await log('\n   💰 Cost estimation:');
                 if (tokenUsage.totalCostUSD !== null && tokenUsage.totalCostUSD !== undefined) {
-                  const difference = anthropicTotalCostUSD - tokenUsage.totalCostUSD;
-                  const percentDiff = tokenUsage.totalCostUSD > 0 ? ((difference / tokenUsage.totalCostUSD) * 100) : 0;
-                  await log(`      Difference:              $${difference.toFixed(6)} (${percentDiff > 0 ? '+' : ''}${percentDiff.toFixed(2)}%)`);
+                  await log(`      Public pricing estimate: $${tokenUsage.totalCostUSD.toFixed(6)} USD`);
                 } else {
+                  await log('      Public pricing estimate: unknown');
+                }
+                if (anthropicTotalCostUSD !== null && anthropicTotalCostUSD !== undefined) {
+                  await log(`      Calculated by Anthropic: $${anthropicTotalCostUSD.toFixed(6)} USD`);
+                  // Show comparison if both are available
+                  if (tokenUsage.totalCostUSD !== null && tokenUsage.totalCostUSD !== undefined) {
+                    const difference = anthropicTotalCostUSD - tokenUsage.totalCostUSD;
+                    const percentDiff = tokenUsage.totalCostUSD > 0 ? (difference / tokenUsage.totalCostUSD) * 100 : 0;
+                    await log(`      Difference:              $${difference.toFixed(6)} (${percentDiff > 0 ? '+' : ''}${percentDiff.toFixed(2)}%)`);
+                  } else {
+                    await log('      Difference:              unknown');
+                  }
+                } else {
+                  await log('      Calculated by Anthropic: unknown');
                   await log('      Difference:              unknown');
                 }
               } else {
-                await log('      Calculated by Anthropic: unknown');
-                await log('      Difference:              unknown');
-              }
-            } else {
-              // Single model - show cost comparison
-              await log('\n   💰 Cost estimation:');
-              if (tokenUsage.totalCostUSD !== null && tokenUsage.totalCostUSD !== undefined) {
-                await log(`      Public pricing estimate: $${tokenUsage.totalCostUSD.toFixed(6)} USD`);
-              } else {
-                await log('      Public pricing estimate: unknown');
-              }
-              if (anthropicTotalCostUSD !== null && anthropicTotalCostUSD !== undefined) {
-                await log(`      Calculated by Anthropic: $${anthropicTotalCostUSD.toFixed(6)} USD`);
-                // Show comparison if both are available
+                // Single model - show cost comparison
+                await log('\n   💰 Cost estimation:');
                 if (tokenUsage.totalCostUSD !== null && tokenUsage.totalCostUSD !== undefined) {
-                  const difference = anthropicTotalCostUSD - tokenUsage.totalCostUSD;
-                  const percentDiff = tokenUsage.totalCostUSD > 0 ? ((difference / tokenUsage.totalCostUSD) * 100) : 0;
-                  await log(`      Difference:              $${difference.toFixed(6)} (${percentDiff > 0 ? '+' : ''}${percentDiff.toFixed(2)}%)`);
+                  await log(`      Public pricing estimate: $${tokenUsage.totalCostUSD.toFixed(6)} USD`);
                 } else {
+                  await log('      Public pricing estimate: unknown');
+                }
+                if (anthropicTotalCostUSD !== null && anthropicTotalCostUSD !== undefined) {
+                  await log(`      Calculated by Anthropic: $${anthropicTotalCostUSD.toFixed(6)} USD`);
+                  // Show comparison if both are available
+                  if (tokenUsage.totalCostUSD !== null && tokenUsage.totalCostUSD !== undefined) {
+                    const difference = anthropicTotalCostUSD - tokenUsage.totalCostUSD;
+                    const percentDiff = tokenUsage.totalCostUSD > 0 ? (difference / tokenUsage.totalCostUSD) * 100 : 0;
+                    await log(`      Difference:              $${difference.toFixed(6)} (${percentDiff > 0 ? '+' : ''}${percentDiff.toFixed(2)}%)`);
+                  } else {
+                    await log('      Difference:              unknown');
+                  }
+                } else {
+                  await log('      Calculated by Anthropic: unknown');
                   await log('      Difference:              unknown');
                 }
-              } else {
-                await log('      Calculated by Anthropic: unknown');
-                await log('      Difference:              unknown');
+                await log(`      Total tokens: ${formatNumber(tokenUsage.totalTokens)}`);
               }
-              await log(`      Total tokens: ${formatNumber(tokenUsage.totalTokens)}`);
-            }
-          } else {
-            // Fallback to old format if modelUsage is not available
-            await log(`   Input tokens: ${formatNumber(tokenUsage.inputTokens)}`);
-            if (tokenUsage.cacheCreationTokens > 0) {
-              await log(`   Cache creation tokens: ${formatNumber(tokenUsage.cacheCreationTokens)}`);
-            }
-            if (tokenUsage.cacheReadTokens > 0) {
-              await log(`   Cache read tokens: ${formatNumber(tokenUsage.cacheReadTokens)}`);
+            } else {
+              // Fallback to old format if modelUsage is not available
+              await log(`   Input tokens: ${formatNumber(tokenUsage.inputTokens)}`);
+              if (tokenUsage.cacheCreationTokens > 0) {
+                await log(`   Cache creation tokens: ${formatNumber(tokenUsage.cacheCreationTokens)}`);
+              }
+              if (tokenUsage.cacheReadTokens > 0) {
+                await log(`   Cache read tokens: ${formatNumber(tokenUsage.cacheReadTokens)}`);
+              }
+              await log(`   Output tokens: ${formatNumber(tokenUsage.outputTokens)}`);
+              await log(`   Total tokens: ${formatNumber(tokenUsage.totalTokens)}`);
             }
-            await log(`   Output tokens: ${formatNumber(tokenUsage.outputTokens)}`);
-            await log(`   Total tokens: ${formatNumber(tokenUsage.totalTokens)}`);
           }
+        } catch (tokenError) {
+          reportError(tokenError, {
+            context: 'calculate_session_tokens',
+            sessionId,
+            operation: 'read_session_jsonl',
+          });
+          await log(`   ⚠️ Could not calculate token usage: ${tokenError.message}`, { verbose: true });
         }
-      } catch (tokenError) {
-        reportError(tokenError, {
-          context: 'calculate_session_tokens',
-          sessionId,
-          operation: 'read_session_jsonl'
-        });
-        await log(`   ⚠️ Could not calculate token usage: ${tokenError.message}`, { verbose: true });
       }
-    }
-    return {
-      success: true,
-      sessionId,
-      limitReached,
-      limitResetTime,
-      messageCount,
-      toolUseCount,
-      anthropicTotalCostUSD // Pass Anthropic's official total cost
-    };
-  } catch (error) {
-    reportError(error, {
-      context: 'execute_claude',
-      command: params.command,
-      claudePath: params.claudePath,
-      operation: 'run_claude_command'
-    });
-    const errorStr = error.message || error.toString();
-    if ((errorStr.includes('API Error: 500') && errorStr.includes('Overloaded')) ||
-        (errorStr.includes('api_error') && errorStr.includes('Overloaded'))) {
-      if (retryCount < maxRetries) {
-        // Calculate exponential backoff delay
-        const delay = baseDelay * Math.pow(2, retryCount);
-        await log(`\n⚠️ API overload error in exception. Retrying in ${delay / 1000} seconds...`, { level: 'warning' });
-        // Wait before retrying
-        await new Promise(resolve => setTimeout(resolve, delay));
-        // Increment retry count and retry
-        retryCount++;
-        return await executeWithRetry();
+      return {
+        success: true,
+        sessionId,
+        limitReached,
+        limitResetTime,
+        messageCount,
+        toolUseCount,
+        anthropicTotalCostUSD, // Pass Anthropic's official total cost
+      };
+    } catch (error) {
+      reportError(error, {
+        context: 'execute_claude',
+        command: params.command,
+        claudePath: params.claudePath,
+        operation: 'run_claude_command',
+      });
+      const errorStr = error.message || error.toString();
+      if ((errorStr.includes('API Error: 500') && errorStr.includes('Overloaded')) || (errorStr.includes('api_error') && errorStr.includes('Overloaded'))) {
+        if (retryCount < maxRetries) {
+          // Calculate exponential backoff delay
+          const delay = baseDelay * Math.pow(2, retryCount);
+          await log(`\n⚠️ API overload error in exception. Retrying in ${delay / 1000} seconds...`, {
+            level: 'warning',
+          });
+          // Wait before retrying
+          await new Promise(resolve => setTimeout(resolve, delay));
+          // Increment retry count and retry
+          retryCount++;
+          return await executeWithRetry();
+        }
       }
-    }
-    if (argv.autoResumeOnErrors &&
-        (errorStr.includes('API Error: 503') ||
-         (errorStr.includes('503') && errorStr.includes('upstream connect error')) ||
-         (errorStr.includes('503') && errorStr.includes('remote connection failure')))) {
-      if (retryCount < retryLimits.max503Retries) {
-        // Calculate exponential backoff delay starting from 5 minutes
-        const delay = retryLimits.initial503RetryDelayMs * Math.pow(retryLimits.retryBackoffMultiplier, retryCount);
-        const delayMinutes = Math.round(delay / (1000 * 60));
-        await log(`\n⚠️ 503 network error in exception. Retrying in ${delayMinutes} minutes...`, { level: 'warning' });
-        // Wait before retrying
-        await new Promise(resolve => setTimeout(resolve, delay));
-        // Increment retry count and retry
-        retryCount++;
-        return await executeWithRetry();
+      if (argv.autoResumeOnErrors && (errorStr.includes('API Error: 503') || (errorStr.includes('503') && errorStr.includes('upstream connect error')) || (errorStr.includes('503') && errorStr.includes('remote connection failure')))) {
+        if (retryCount < retryLimits.max503Retries) {
+          // Calculate exponential backoff delay starting from 5 minutes
+          const delay = retryLimits.initial503RetryDelayMs * Math.pow(retryLimits.retryBackoffMultiplier, retryCount);
+          const delayMinutes = Math.round(delay / (1000 * 60));
+          await log(`\n⚠️ 503 network error in exception. Retrying in ${delayMinutes} minutes...`, {
+            level: 'warning',
+          });
+          // Wait before retrying
+          await new Promise(resolve => setTimeout(resolve, delay));
+          // Increment retry count and retry
+          retryCount++;
+          return await executeWithRetry();
+        }
       }
+      await log(`\n\n❌ Error executing Claude command: ${error.message}`, { level: 'error' });
+      return {
+        success: false,
+        sessionId,
+        limitReached,
+        limitResetTime: null,
+        messageCount,
+        toolUseCount,
+      };
     }
-    await log(`\n\n❌ Error executing Claude command: ${error.message}`, { level: 'error' });
-    return {
-      success: false,
-      sessionId,
-      limitReached,
-      limitResetTime: null,
-      messageCount,
-      toolUseCount
-    };
-  }
   }; // End of executeWithRetry function
   // Start the execution with retry logic
   return await executeWithRetry();
@@ -1440,13 +1423,19 @@ export const checkForUncommittedChanges = async (tempDir, owner, repo, branchNam
               if (pushResult.code === 0) {
                 await log('✅ Changes pushed successfully');
               } else {
-                await log(`⚠️ Warning: Could not push changes: ${pushResult.stderr?.toString().trim()}`, { level: 'warning' });
+                await log(`⚠️ Warning: Could not push changes: ${pushResult.stderr?.toString().trim()}`, {
+                  level: 'warning',
+                });
               }
             } else {
-              await log(`⚠️ Warning: Could not commit changes: ${commitResult.stderr?.toString().trim()}`, { level: 'warning' });
+              await log(`⚠️ Warning: Could not commit changes: ${commitResult.stderr?.toString().trim()}`, {
+                level: 'warning',
+              });
             }
           } else {
-            await log(`⚠️ Warning: Could not stage changes: ${addResult.stderr?.toString().trim()}`, { level: 'warning' });
+            await log(`⚠️ Warning: Could not stage changes: ${addResult.stderr?.toString().trim()}`, {
+              level: 'warning',
+            });
           }
           return false;
         } else if (autoRestartEnabled) {
@@ -1465,7 +1454,9 @@ export const checkForUncommittedChanges = async (tempDir, owner, repo, branchNam
         return false;
       }
     } else {
-      await log(`⚠️ Warning: Could not check git status: ${gitStatusResult.stderr?.toString().trim()}`, { level: 'warning' });
+      await log(`⚠️ Warning: Could not check git status: ${gitStatusResult.stderr?.toString().trim()}`, {
+        level: 'warning',
+      });
       return false;
     }
   } catch (gitError) {
@@ -1481,5 +1472,5 @@ export default {
   executeClaude,
   executeClaudeCommand,
   checkForUncommittedChanges,
-  calculateSessionTokens
-};
+  calculateSessionTokens,
+};