@link-assistant/hive-mind 0.46.1 → 0.47.1

package/src/solve.repository.lib.mjs

@@ -24,10 +24,7 @@ const lib = await import('./lib.mjs');
 const sentryLib = await import('./sentry.lib.mjs');
 const { reportError } = sentryLib;
 
-const {
-  log,
-  formatAligned
-} = lib;
+const { log, formatAligned } = lib;
 
 // Import exit handler
 import { safeExit } from './exit-handler.lib.mjs';
@@ -58,14 +55,14 @@ export const getRootRepository = async (owner, repo) => {
       context: 'get_root_repository',
       owner,
       repo,
-      operation: 'determine_fork_root'
+      operation: 'determine_fork_root',
     });
     return null;
   }
 };
 
 // Check if current user has a fork of the given root repository
-export const checkExistingForkOfRoot = async (rootRepo) => {
+export const checkExistingForkOfRoot = async rootRepo => {
   try {
     const userResult = await $`gh api user --jq .login`;
     if (userResult.code !== 0) {
@@ -79,7 +76,11 @@ export const checkExistingForkOfRoot = async (rootRepo) => {
       return null;
     }
 
-    const forks = forksResult.stdout.toString().trim().split('\n').filter(f => f);
+    const forks = forksResult.stdout
+      .toString()
+      .trim()
+      .split('\n')
+      .filter(f => f);
 
     if (forks.length > 0) {
       return forks[0];
@@ -90,14 +91,14 @@ export const checkExistingForkOfRoot = async (rootRepo) => {
     reportError(error, {
       context: 'check_existing_fork_of_root',
       rootRepo,
-      operation: 'search_user_forks'
+      operation: 'search_user_forks',
     });
     return null;
   }
 };
 
 // Create or find temporary directory for cloning the repository
-export const setupTempDirectory = async (argv) => {
+export const setupTempDirectory = async argv => {
   let tempDir;
   let isResuming = argv.resume;
 
@@ -119,7 +120,7 @@ export const setupTempDirectory = async (argv) => {
       reportError(err, {
         context: 'resume_session_lookup',
         sessionId: argv.resume,
-        operation: 'find_session_log'
+        operation: 'find_session_log',
       });
       await log(`Warning: Session log for ${argv.resume} not found, but continuing with resume attempt`);
       tempDir = path.join(os.tmpdir(), `gh-issue-solver-resume-${argv.resume}-${Date.now()}`);
@@ -169,8 +170,7 @@ const tryInitializeEmptyRepository = async (owner, repo) => {
     } else {
       const errorOutput = createResult.stdout.toString() + createResult.stderr.toString();
       // Check if it's a permission error
-      if (errorOutput.includes('403') || errorOutput.includes('Forbidden') ||
-          errorOutput.includes('not have permission') || errorOutput.includes('Resource not accessible')) {
+      if (errorOutput.includes('403') || errorOutput.includes('Forbidden') || errorOutput.includes('not have permission') || errorOutput.includes('Resource not accessible')) {
         await log(`${formatAligned('❌', 'No access:', 'You do not have write access to this repository')}`);
         return false;
       } else {
@@ -184,7 +184,7 @@ const tryInitializeEmptyRepository = async (owner, repo) => {
       context: 'initialize_empty_repository',
       owner,
       repo,
-      operation: 'create_readme'
+      operation: 'create_readme',
     });
     await log(`${formatAligned('❌', 'Error:', 'Failed to initialize repository')}`);
     return false;
@@ -225,7 +225,7 @@ export const setupRepository = async (argv, owner, repo, forkOwner = null, issue
 
         if (existingForkOwner === currentUser) {
           const targetRepo = `${owner}/${repo}`;
-          const targetIsRoot = (targetRepo === rootRepo);
+          const targetIsRoot = targetRepo === rootRepo;
 
           if (!targetIsRoot) {
             await log('');
@@ -234,7 +234,7 @@ export const setupRepository = async (argv, owner, repo, forkOwner = null, issue
             await log('  🔍 What happened:');
             await log(`     You are trying to fork ${targetRepo}`);
             await log(`     But you already have a fork of ${rootRepo}: ${existingFork}`);
-            await log('     GitHub doesn\'t allow multiple forks of the same root repository');
+            await log("     GitHub doesn't allow multiple forks of the same root repository");
             await log('');
             await log('  📦 Root repository analysis:');
             await log(`     • Target repository: ${targetRepo}`);
@@ -330,8 +330,7 @@ export const setupRepository = async (argv, owner, repo, forkOwner = null, issue
         }
 
         // Always capture output to parse actual fork name
-        const forkOutput = (forkResult.stderr ? forkResult.stderr.toString() : '') +
-                          (forkResult.stdout ? forkResult.stdout.toString() : '');
+        const forkOutput = (forkResult.stderr ? forkResult.stderr.toString() : '') + (forkResult.stdout ? forkResult.stdout.toString() : '');
 
         // Parse actual fork name from output (e.g., "konard/netkeep80-jsonRVM already exists")
         // GitHub may create forks with modified names to avoid conflicts
@@ -354,10 +353,7 @@ export const setupRepository = async (argv, owner, repo, forkOwner = null, issue
           break;
         } else {
           // Fork creation failed - check if it's because fork already exists
-          if (forkOutput.includes('already exists') ||
-              forkOutput.includes('Name already exists') ||
-              forkOutput.includes('fork of') ||
-              forkOutput.includes('HTTP 422')) {
+          if (forkOutput.includes('already exists') || forkOutput.includes('Name already exists') || forkOutput.includes('fork of') || forkOutput.includes('HTTP 422')) {
             // Fork already exists (likely created by another concurrent worker)
             await log(`${formatAligned('ℹ️', 'Fork exists:', actualForkName)}`);
             forkExists = true;
@@ -365,9 +361,7 @@ export const setupRepository = async (argv, owner, repo, forkOwner = null, issue
           }
 
           // Check if it's an empty repository (HTTP 403) - try to auto-fix
-          if (forkOutput.includes('HTTP 403') &&
-              (forkOutput.includes('Empty repositories cannot be forked') ||
-               forkOutput.includes('contains no Git content'))) {
+          if (forkOutput.includes('HTTP 403') && (forkOutput.includes('Empty repositories cannot be forked') || forkOutput.includes('contains no Git content'))) {
             // Empty repository detected - try to initialize it
             await log('');
             await log(`${formatAligned('⚠️', 'EMPTY REPOSITORY', 'detected')}`, { level: 'warn' });
@@ -388,11 +382,13 @@ export const setupRepository = async (argv, owner, repo, forkOwner = null, issue
             } else {
               // Failed to initialize - provide helpful suggestions
               await log('');
-              await log(`${formatAligned('❌', 'Cannot proceed:', 'Unable to initialize empty repository')}`, { level: 'error' });
+              await log(`${formatAligned('❌', 'Cannot proceed:', 'Unable to initialize empty repository')}`, {
+                level: 'error',
+              });
               await log('');
               await log('  🔍 What happened:');
               await log(`     The repository ${owner}/${repo} is empty and cannot be forked.`);
-              await log('     GitHub doesn\'t allow forking repositories with no content.');
+              await log("     GitHub doesn't allow forking repositories with no content.");
               await log('     Auto-fix failed: You need write access to initialize the repository.');
               await log('');
               await log('  💡 How to fix:');
@@ -462,7 +458,7 @@ Thank you!`;
           // Fork still doesn't exist and creation failed
           if (attempt < maxForkRetries) {
             const delay = baseDelay * Math.pow(2, attempt - 1); // Exponential backoff
-            await log(`${formatAligned('⏳', 'Retry:', `Attempt ${attempt}/${maxForkRetries} failed, waiting ${delay/1000}s before retry...`)}`);
+            await log(`${formatAligned('⏳', 'Retry:', `Attempt ${attempt}/${maxForkRetries} failed, waiting ${delay / 1000}s before retry...`)}`);
             await log(`   Error: ${forkOutput.split('\n')[0]}`); // Show first line of error
             await new Promise(resolve => setTimeout(resolve, delay));
           } else {
@@ -485,7 +481,7 @@ Thank you!`;
         for (let attempt = 1; attempt <= maxVerifyRetries; attempt++) {
           const delay = baseDelay * Math.pow(2, attempt - 1);
           if (attempt > 1) {
-            await log(`${formatAligned('⏳', 'Verifying fork:', `Attempt ${attempt}/${maxVerifyRetries} (waiting ${delay/1000}s)...`)}`);
+            await log(`${formatAligned('⏳', 'Verifying fork:', `Attempt ${attempt}/${maxVerifyRetries} (waiting ${delay / 1000}s)...`)}`);
             await new Promise(resolve => setTimeout(resolve, delay));
           }
 
@@ -582,7 +578,7 @@ export const cloneRepository = async (repoToClone, tempDir, argv, owner, repo) =
     }
     await log('');
     await log('  💡 Common causes:');
-    await log('     • Repository doesn\'t exist or is private');
+    await log("     • Repository doesn't exist or is private");
     await log('     • No GitHub authentication');
     await log('     • Network connectivity issues');
     if (argv.fork) {
@@ -688,9 +684,7 @@ export const setupUpstreamAndSync = async (tempDir, forkedRepo, upstreamRemote,
               } else {
                 // Check if it's a non-fast-forward error (fork has diverged from upstream)
                 const errorMsg = pushResult.stderr ? pushResult.stderr.toString().trim() : '';
-                const isNonFastForward = errorMsg.includes('non-fast-forward') ||
-                                        errorMsg.includes('rejected') ||
-                                        errorMsg.includes('tip of your current branch is behind');
+                const isNonFastForward = errorMsg.includes('non-fast-forward') || errorMsg.includes('rejected') || errorMsg.includes('tip of your current branch is behind');
 
                 if (isNonFastForward) {
                   // Fork has diverged from upstream
@@ -716,7 +710,9 @@ export const setupUpstreamAndSync = async (tempDir, forkedRepo, upstreamRemote,
                     // Use --force-with-lease for safer force push
                     // This will only force push if the remote hasn't changed since our last fetch
                     await log(`${formatAligned('🔄', 'Force pushing:', 'Syncing fork with upstream (--force-with-lease)')}`);
-                    const forcePushResult = await $({ cwd: tempDir })`git push --force-with-lease origin ${upstreamDefaultBranch}`;
+                    const forcePushResult = await $({
+                      cwd: tempDir,
+                    })`git push --force-with-lease origin ${upstreamDefaultBranch}`;
 
                     if (forcePushResult.code === 0) {
                       await log(`${formatAligned('✅', 'Fork synced:', 'Successfully force-pushed to align with upstream')}`);
@@ -724,7 +720,9 @@ export const setupUpstreamAndSync = async (tempDir, forkedRepo, upstreamRemote,
                     } else {
                       // Force push also failed - this is a more serious issue
                       await log('');
-                      await log(`${formatAligned('❌', 'FATAL ERROR:', 'Failed to sync fork with upstream')}`, { level: 'error' });
+                      await log(`${formatAligned('❌', 'FATAL ERROR:', 'Failed to sync fork with upstream')}`, {
+                        level: 'error',
+                      });
                       await log('');
                       await log('  🔍 What happened:');
                       await log(`     Fork branch ${upstreamDefaultBranch} has diverged from upstream`);
@@ -862,12 +860,14 @@ export const setupPrForkRemote = async (tempDir, argv, prForkOwner, repo, isCont
     prForkRepoName = `${owner}-${repo}`;
   }
 
-  await log(`${formatAligned('🔗', 'Setting up pr-fork:', 'Branch exists in another user\'s fork')}`);
+  await log(`${formatAligned('🔗', 'Setting up pr-fork:', "Branch exists in another user's fork")}`);
   await log(`${formatAligned('', 'PR fork owner:', prForkOwner)}`);
   await log(`${formatAligned('', 'Current user:', currentUser)}`);
   await log(`${formatAligned('', 'Action:', `Adding ${prForkOwner}/${prForkRepoName} as pr-fork remote`)}`);
 
-  const addRemoteResult = await $({ cwd: tempDir })`git remote add pr-fork https://github.com/${prForkOwner}/${prForkRepoName}.git`;
+  const addRemoteResult = await $({
+    cwd: tempDir,
+  })`git remote add pr-fork https://github.com/${prForkOwner}/${prForkRepoName}.git`;
   if (addRemoteResult.code !== 0) {
     await log(`${formatAligned('❌', 'Error:', 'Failed to add pr-fork remote')}`);
     if (addRemoteResult.stderr) {
@@ -945,7 +945,7 @@ export const cleanupTempDirectory = async (tempDir, argv, limitReached) => {
       reportError(cleanupError, {
         context: 'cleanup_temp_directory',
         tempDir,
-        operation: 'remove_temp_dir'
+        operation: 'remove_temp_dir',
       });
       await log(' ⚠️  (failed)');
     }

package/src/solve.results.lib.mjs

@@ -18,27 +18,18 @@ const path = (await use('path')).default;
 
 // Import shared library functions
 const lib = await import('./lib.mjs');
-const {
-  log,
-  getLogFile,
-  formatAligned
-} = lib;
+const { log, getLogFile, formatAligned } = lib;
 
 // Import exit handler
 import { safeExit } from './exit-handler.lib.mjs';
 
 // Import GitHub-related functions
 const githubLib = await import('./github.lib.mjs');
-const {
-  sanitizeLogContent,
-  attachLogToGitHub
-} = githubLib;
+const { sanitizeLogContent, attachLogToGitHub } = githubLib;
 
 // Import auto-continue functions
 const autoContinue = await import('./solve.auto-continue.lib.mjs');
-const {
-  autoContinueWhenLimitResets
-} = autoContinue;
+const { autoContinueWhenLimitResets } = autoContinue;
 
 // Import error handling functions
 // const errorHandlers = await import('./solve.error-handlers.lib.mjs'); // Not currently used
@@ -122,24 +113,26 @@ const detectClaudeMdCommitFromBranch = async (tempDir, branchName) => {
     const firstCommitLine = branchCommits[0];
     const [firstCommitHash, firstCommitMessage] = firstCommitLine.split('|');
 
-    await log(`   First commit on branch: ${firstCommitHash.substring(0, 7)} - "${firstCommitMessage}"`, { verbose: true });
+    await log(`   First commit on branch: ${firstCommitHash.substring(0, 7)} - "${firstCommitMessage}"`, {
+      verbose: true,
+    });
 
     // Safety check: Verify commit message matches expected pattern
-    const expectedMessagePatterns = [
-      /^Initial commit with task details/i,
-      /^Add CLAUDE\.md/i,
-      /^CLAUDE\.md/i
-    ];
+    const expectedMessagePatterns = [/^Initial commit with task details/i, /^Add CLAUDE\.md/i, /^CLAUDE\.md/i];
 
     const messageMatches = expectedMessagePatterns.some(pattern => pattern.test(firstCommitMessage));
     if (!messageMatches) {
       await log('   First commit message does not match expected CLAUDE.md pattern', { verbose: true });
-      await log('   Expected patterns: "Initial commit with task details...", "Add CLAUDE.md", etc.', { verbose: true });
+      await log('   Expected patterns: "Initial commit with task details...", "Add CLAUDE.md", etc.', {
+        verbose: true,
+      });
       return null;
     }
 
     // Safety check: Verify the commit ONLY adds CLAUDE.md file (no other files)
-    const filesChangedResult = await $({ cwd: tempDir })`git diff-tree --no-commit-id --name-only -r ${firstCommitHash} 2>&1`;
+    const filesChangedResult = await $({
+      cwd: tempDir,
+    })`git diff-tree --no-commit-id --name-only -r ${firstCommitHash} 2>&1`;
     if (filesChangedResult.code !== 0 || !filesChangedResult.stdout) {
       await log('   Could not get files changed in first commit', { verbose: true });
       return null;
@@ -157,7 +150,9 @@ const detectClaudeMdCommitFromBranch = async (tempDir, branchName) => {
     // CRITICAL SAFETY CHECK: Only allow revert if CLAUDE.md is the ONLY file changed
     // This prevents Issue #617 where reverting a commit deleted .gitignore, LICENSE, README.md
     if (filesChanged.length > 1) {
-      await log(`   ⚠️  First commit changes more than just CLAUDE.md (${filesChanged.length} files)`, { verbose: true });
+      await log(`   ⚠️  First commit changes more than just CLAUDE.md (${filesChanged.length} files)`, {
+        verbose: true,
+      });
       await log(`   Files: ${filesChanged.join(', ')}`, { verbose: true });
       await log('   Refusing to revert to prevent data loss (Issue #617 safety)', { verbose: true });
       return null;
@@ -174,7 +169,7 @@ const detectClaudeMdCommitFromBranch = async (tempDir, branchName) => {
       context: 'detect_claude_md_commit',
       tempDir,
       branchName,
-      operation: 'detect_commit_from_branch_structure'
+      operation: 'detect_commit_from_branch_structure',
     });
     await log(`   Error detecting CLAUDE.md commit: ${error.message}`, { verbose: true });
     return null;
@@ -226,7 +221,9 @@ export const cleanupClaudeFile = async (tempDir, branchName, claudeCommitHash =
       }
 
       // Create a manual revert commit
-      const commitResult = await $({ cwd: tempDir })`git commit -m "Revert: Remove CLAUDE.md changes from initial commit" 2>&1`;
+      const commitResult = await $({
+        cwd: tempDir,
+      })`git commit -m "Revert: Remove CLAUDE.md changes from initial commit" 2>&1`;
 
       if (commitResult.code === 0) {
         await log(formatAligned('📦', 'Committed:', 'CLAUDE.md revert (manual)'));
@@ -324,7 +321,7 @@ export const cleanupClaudeFile = async (tempDir, branchName, claudeCommitHash =
     reportError(e, {
       context: 'cleanup_claude_file',
       tempDir,
-      operation: 'revert_claude_md_commit'
+      operation: 'revert_claude_md_commit',
     });
     // If revert fails, that's okay - the task is still complete
     await log('   CLAUDE.md revert failed or not needed', { verbose: true });
@@ -338,7 +335,7 @@ export const showSessionSummary = async (sessionId, limitReached, argv, issueUrl
   if (sessionId) {
     await log(`✅ Session ID: ${sessionId}`);
     // Always use absolute path for log file display
-    const path = (await use('path'));
+    const path = await use('path');
     const absoluteLogPath = path.resolve(getLogFile());
     await log(`✅ Complete log file: ${absoluteLogPath}`);
 
@@ -423,10 +420,7 @@ export const verifyResults = async (owner, repo, branchName, issueNumber, prNumb
 
       // If we created a PR earlier in this session, it would be prNumber
       // Or if the PR was updated during the session (updatedAt > referenceTime)
-      const isPrFromSession = (prNumber && pr.number.toString() === prNumber) ||
-                              (prUrl && pr.url === prUrl) ||
-                              new Date(pr.updatedAt) > referenceTime ||
-                              new Date(pr.createdAt) > referenceTime;
+      const isPrFromSession = (prNumber && pr.number.toString() === prNumber) || (prUrl && pr.url === prUrl) || new Date(pr.updatedAt) > referenceTime || new Date(pr.createdAt) > referenceTime;
 
       if (isPrFromSession) {
         await log(`  ✅ Found pull request #${pr.number}: "${pr.title}"`);
@@ -441,12 +435,7 @@ export const verifyResults = async (owner, repo, branchName, issueNumber, prNumb
           // This ensures we only detect actual GitHub-recognized linking keywords
           // (fixes, closes, resolves and their variants) in proper format
           // See: https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue
-          const hasLinkingKeyword = hasGitHubLinkingKeyword(
-            prBody,
-            issueNumber,
-            argv.fork ? owner : null,
-            argv.fork ? repo : null
-          );
+          const hasLinkingKeyword = hasGitHubLinkingKeyword(prBody, issueNumber, argv.fork ? owner : null, argv.fork ? repo : null);
 
           if (!hasLinkingKeyword) {
             await log(`  📝 Updating PR body to link issue #${issueNumber}...`);
@@ -514,7 +503,7 @@ export const verifyResults = async (owner, repo, branchName, issueNumber, prNumb
             anthropicTotalCostUSD,
             // Pass agent tool pricing data when available
             publicPricingEstimate,
-            pricingInfo
+            pricingInfo,
           });
         }
 
@@ -552,9 +541,7 @@ export const verifyResults = async (owner, repo, branchName, issueNumber, prNumb
     const allComments = JSON.parse(allCommentsResult.stdout.toString().trim() || '[]');
 
     // Filter for new comments by current user
-    const newCommentsByUser = allComments.filter(comment =>
-      comment.user.login === currentUser && new Date(comment.created_at) > referenceTime
-    );
+    const newCommentsByUser = allComments.filter(comment => comment.user.login === currentUser && new Date(comment.created_at) > referenceTime);
 
     if (newCommentsByUser.length > 0) {
       const lastComment = newCommentsByUser[newCommentsByUser.length - 1];
@@ -578,7 +565,7 @@ export const verifyResults = async (owner, repo, branchName, issueNumber, prNumb
           anthropicTotalCostUSD,
           // Pass agent tool pricing data when available
           publicPricingEstimate,
-          pricingInfo
+          pricingInfo,
         });
       }
 
@@ -611,12 +598,11 @@ export const verifyResults = async (owner, repo, branchName, issueNumber, prNumb
       await safeExit(0, 'Process completed successfully');
     }
     return; // Return normally for watch mode
-
   } catch (searchError) {
     reportError(searchError, {
       context: 'verify_pr_creation',
       issueNumber,
-      operation: 'search_for_pr'
+      operation: 'search_for_pr',
     });
     await log('\n⚠️  Could not verify results:', searchError.message);
     await log('\n💡 Check the log file for details:');
@@ -654,7 +640,7 @@ export const handleExecutionError = async (error, shouldAttachLogs, owner, repo,
           log,
           sanitizeLogContent,
           verbose: argv.verbose || false,
-          errorMessage: cleanErrorMessage(error)
+          errorMessage: cleanErrorMessage(error),
         });
 
         if (logUploadSuccess) {
@@ -664,7 +650,7 @@ export const handleExecutionError = async (error, shouldAttachLogs, owner, repo,
         reportError(attachError, {
           context: 'attach_success_log',
           prNumber: global.createdPR?.number,
-          operation: 'attach_log_to_pr'
+          operation: 'attach_log_to_pr',
         });
         await log(`⚠️  Could not attach failure log: ${attachError.message}`, { level: 'warning' });
       }
@@ -685,11 +671,11 @@ export const handleExecutionError = async (error, shouldAttachLogs, owner, repo,
       reportError(closeError, {
         context: 'close_success_pr',
         prNumber: global.createdPR?.number,
-        operation: 'close_pull_request'
+        operation: 'close_pull_request',
       });
       await log(`⚠️  Could not close pull request: ${closeError.message}`, { level: 'warning' });
     }
   }
 
   await safeExit(1, 'Execution error');
-};
+};

package/src/solve.session.lib.mjs

@@ -3,14 +3,7 @@
  * Handles starting and ending work sessions, PR status changes, and session comments
  */
 
-export async function startWorkSession({
-  isContinueMode,
-  prNumber,
-  argv,
-  log,
-  formatAligned,
-  $
-}) {
+export async function startWorkSession({ isContinueMode, prNumber, argv, log, formatAligned, $ }) {
   // Record work start time and convert PR to draft if in continue/watch mode
   const workStartTime = new Date();
   if (isContinueMode && prNumber && (argv.watch || argv.autoContinue)) {
@@ -39,7 +32,7 @@ export async function startWorkSession({
       reportError(error, {
         context: 'convert_pr_to_draft',
         prNumber,
-        operation: 'pr_status_change'
+        operation: 'pr_status_change',
       });
       await log('Warning: Could not check/convert PR draft status', { level: 'warning' });
     }
@@ -57,7 +50,7 @@ export async function startWorkSession({
       reportError(error, {
         context: 'post_start_comment',
         prNumber,
-        operation: 'create_pr_comment'
+        operation: 'create_pr_comment',
       });
       await log('Warning: Could not post work start comment', { level: 'warning' });
     }
@@ -66,15 +59,7 @@ export async function startWorkSession({
   return workStartTime;
 }
 
-export async function endWorkSession({
-  isContinueMode,
-  prNumber,
-  argv,
-  log,
-  formatAligned,
-  $,
-  logsAttached = false
-}) {
+export async function endWorkSession({ isContinueMode, prNumber, argv, log, formatAligned, $, logsAttached = false }) {
   // Post end work session comment and convert PR back to ready if in continue mode
   if (isContinueMode && prNumber && (argv.watch || argv.autoContinue)) {
     const workEndTime = new Date();
@@ -96,7 +81,7 @@ export async function endWorkSession({
         reportError(error, {
           context: 'post_end_comment',
           prNumber,
-          operation: 'create_pr_comment'
+          operation: 'create_pr_comment',
         });
         await log('Warning: Could not post work end comment', { level: 'warning' });
       }
@@ -127,9 +112,9 @@ export async function endWorkSession({
       reportError(error, {
         context: 'convert_pr_to_ready',
         prNumber,
-        operation: 'pr_status_change'
+        operation: 'pr_status_change',
       });
       await log('Warning: Could not convert PR to ready status', { level: 'warning' });
     }
   }
-}
+}

package/src/solve.validation.lib.mjs

@@ -21,7 +21,7 @@ const memoryCheck = await import('./memory-check.mjs');
 const lib = await import('./lib.mjs');
 const {
   log,
-  setLogFile
+  setLogFile,
   // getLogFile - not currently used
 } = lib;
 
@@ -29,7 +29,7 @@ const {
 const githubLib = await import('./github.lib.mjs');
 const {
   checkGitHubPermissions,
-  parseGitHubUrl
+  parseGitHubUrl,
   // isGitHubUrlType - not currently used
 } = githubLib;
 
@@ -39,9 +39,7 @@ const claudeLib = await import('./claude.lib.mjs');
 const sentryLib = await import('./sentry.lib.mjs');
 const { reportError } = sentryLib;
 
-const {
-  validateClaudeConnection
-} = claudeLib;
+const { validateClaudeConnection } = claudeLib;
 
 // Wrapper function for disk space check using imported module
 const checkDiskSpace = async (minSpaceMB = 500) => {
@@ -56,7 +54,7 @@ const checkMemory = async (minMemoryMB = 256) => {
 };
 
 // Validate GitHub issue or pull request URL format
-export const validateGitHubUrl = (issueUrl) => {
+export const validateGitHubUrl = issueUrl => {
   if (!issueUrl) {
     return { isValid: false, isIssueUrl: null, isPrUrl: null };
   }
@@ -100,12 +98,12 @@ export const validateGitHubUrl = (issueUrl) => {
     normalizedUrl: parsedUrl.normalized,
     owner: parsedUrl.owner,
     repo: parsedUrl.repo,
-    number: parsedUrl.number
+    number: parsedUrl.number,
   };
 };
 
 // Show security warning for attach-logs option
-export const showAttachLogsWarning = async (shouldAttachLogs) => {
+export const showAttachLogsWarning = async shouldAttachLogs => {
   if (!shouldAttachLogs) return;
 
   await log('');
@@ -146,7 +144,7 @@ export const initializeLogFile = async (logDir = null) => {
   } catch (error) {
     reportError(error, {
       context: 'create_log_directory',
-      operation: 'mkdir_log_dir'
+      operation: 'mkdir_log_dir',
     });
     // If directory doesn't exist, try to create it
     try {
@@ -155,7 +153,7 @@ export const initializeLogFile = async (logDir = null) => {
       reportError(mkdirError, {
         context: 'create_log_directory_fallback',
         targetDir,
-        operation: 'mkdir_recursive'
+        operation: 'mkdir_recursive',
       });
       await log(`⚠️  Unable to create log directory: ${targetDir}`, { level: 'error' });
       await log('   Falling back to current working directory', { level: 'error' });
@@ -179,7 +177,7 @@ export const initializeLogFile = async (logDir = null) => {
 };
 
 // Validate GitHub URL requirement
-export const validateUrlRequirement = async (issueUrl) => {
+export const validateUrlRequirement = async issueUrl => {
   if (!issueUrl) {
     await log('❌ GitHub issue URL is required', { level: 'error' });
     await log('   Usage: solve <github-issue-url> [options]', { level: 'error' });
@@ -263,25 +261,29 @@ export const performSystemChecks = async (minDiskSpace = 500, skipToolConnection
       return false;
     }
   } else {
-    await log('⏩ Skipping tool connection validation (dry-run mode or skip-tool-connection-check enabled)', { verbose: true });
-    await log('⏩ Skipping GitHub authentication check (dry-run mode or skip-tool-connection-check enabled)', { verbose: true });
+    await log('⏩ Skipping tool connection validation (dry-run mode or skip-tool-connection-check enabled)', {
+      verbose: true,
+    });
+    await log('⏩ Skipping GitHub authentication check (dry-run mode or skip-tool-connection-check enabled)', {
+      verbose: true,
+    });
   }
 
   return true;
 };
 
 // Parse URL components
-export const parseUrlComponents = (issueUrl) => {
+export const parseUrlComponents = issueUrl => {
   const urlParts = issueUrl.split('/');
   return {
     owner: urlParts[3],
     repo: urlParts[4],
-    urlNumber: urlParts[6] // Could be issue or PR number
+    urlNumber: urlParts[6], // Could be issue or PR number
   };
 };
 
 // Helper function to parse time string and calculate wait time
-export const parseResetTime = (timeStr) => {
+export const parseResetTime = timeStr => {
   // Normalize and parse time formats like:
   // "5:30am", "11:45pm", "12:16 PM", "07:05 Am", "5am", "5 AM"
   const normalized = (timeStr || '').toString().trim();
@@ -308,7 +310,7 @@ export const parseResetTime = (timeStr) => {
 };
 
 // Calculate milliseconds until the next occurrence of the specified time
-export const calculateWaitTime = (resetTime) => {
+export const calculateWaitTime = resetTime => {
   const { hour, minute } = parseResetTime(resetTime);
 
   const now = new Date();