@link-assistant/hive-mind 1.65.0 → 1.65.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/hive-mind
 
+## 1.65.1
+
+### Patch Changes
+
+- d5cd096: Add a solve flag to disable separate error-report issue creation while preserving original issue failure comments, and improve pre-PR branch divergence diagnostics.
+
 ## 1.65.0
 
 ### Minor Changes

package/package.json

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

package/src/github-error-reporter.lib.mjs

@@ -271,7 +271,7 @@ export const handleErrorWithIssueCreation = async options => {
 
   // --disable-report-issue takes highest precedence
   if (disableReport) {
-    await log('ℹ️  Issue reporting disabled via --disable-report-issue.');
+    await log('ℹ️  Error issue creation is disabled by CLI configuration.');
     return null;
   }
 

package/src/solve.auto-pr.lib.mjs

@@ -4,8 +4,10 @@
  */
 
 import { closingIssueNumbersContain, parseClosingIssueNumbers } from './pr-issue-linking.lib.mjs';
+import { buildPushRejectionExplanation, getRemoteBranchDivergenceSnapshot, synchronizeExistingIssueBranchBeforeAutoPrCreation } from './solve.branch-divergence.lib.mjs';
 
 import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller
+
 export async function handleAutoPrCreation({ argv, tempDir, branchName, issueNumber, owner, repo, defaultBranch, forkedRepo, isContinueMode, prNumber, log, formatAligned, $, reportError, path, fs }) {
   // Skip auto-PR creation if:
   // 1. Auto-PR creation is disabled AND we're not in continue mode with no PR
@@ -33,6 +35,16 @@ export async function handleAutoPrCreation({ argv, tempDir, branchName, issueNum
   const issueUrl = argv['issue-url'] || argv._[0];
 
   try {
+    await synchronizeExistingIssueBranchBeforeAutoPrCreation({
+      tempDir,
+      branchName,
+      isContinueMode,
+      prNumber,
+      log,
+      formatAligned,
+      $,
+    });
+
     // Determine which file to create based on CLI flags
     let useClaudeFile = argv.claudeFile !== false;
     const useAutoGitkeepFile = argv.autoGitkeepFile !== false;
@@ -527,6 +539,7 @@ Proceed.
           await log('');
           throw new Error('Permission denied - need fork or collaborator access');
         } else if (errorOutput.includes('non-fast-forward') || errorOutput.includes('rejected') || errorOutput.includes('! [rejected]')) {
+          const divergence = await getRemoteBranchDivergenceSnapshot({ $, tempDir, branchName });
           // Push rejected due to conflicts or diverged history
           await log('');
           await log(formatAligned('❌', 'PUSH REJECTED:', 'Branch has diverged from remote'), { level: 'error' });
@@ -534,6 +547,9 @@ Proceed.
           await log('  🔍 What happened:');
           await log('     The remote branch has changes that conflict with your local changes.');
           await log('     This typically means someone else has pushed to this branch.');
+          for (const line of buildPushRejectionExplanation({ branchName, isContinueMode, prNumber, divergence })) {
+            await log(line);
+          }
           await log('');
           await log('  💡 Why we cannot fix this automatically:');
           await log('     • We never use force push to preserve history');

package/src/solve.branch-divergence.lib.mjs

@@ -0,0 +1,93 @@
+const toCount = value => {
+  const parsed = Number.parseInt(String(value || '').trim(), 10);
+  return Number.isFinite(parsed) ? parsed : null;
+};
+
+const outputOf = result => {
+  const stdout = result?.stdout ? result.stdout.toString().trim() : '';
+  const stderr = result?.stderr ? result.stderr.toString().trim() : '';
+  return stdout || stderr;
+};
+
+export function buildPushRejectionExplanation({ branchName, isContinueMode, prNumber, divergence = null }) {
+  const lines = [];
+
+  if (isContinueMode && !prNumber) {
+    lines.push('     This run reused an existing issue branch because auto-continue found a matching branch with no PR.');
+    lines.push('     It is not a fresh branch created by this run, even though auto-PR creation is running now.');
+  } else {
+    lines.push('     The remote branch changed after the local branch state used for this push.');
+  }
+
+  if (divergence?.remoteExists && divergence.ahead !== null && divergence.behind !== null) {
+    lines.push(`     Current branch state for ${branchName}: ${divergence.ahead} commit(s) ahead, ${divergence.behind} commit(s) behind origin/${branchName}.`);
+  } else if (divergence?.fetchError) {
+    lines.push(`     Could not inspect origin/${branchName}: ${divergence.fetchError}`);
+  }
+
+  return lines;
+}
+
+export async function getRemoteBranchDivergenceSnapshot({ $, tempDir, branchName }) {
+  const fetchResult = await $({ cwd: tempDir, silent: true })`git fetch origin refs/heads/${branchName}:refs/remotes/origin/${branchName} 2>&1`;
+  if (fetchResult.code !== 0) {
+    return {
+      remoteExists: false,
+      ahead: null,
+      behind: null,
+      fetchError: outputOf(fetchResult) || 'remote branch not found',
+    };
+  }
+
+  const aheadResult = await $({ cwd: tempDir, silent: true })`git rev-list --count origin/${branchName}..HEAD 2>&1`;
+  const behindResult = await $({ cwd: tempDir, silent: true })`git rev-list --count HEAD..origin/${branchName} 2>&1`;
+
+  return {
+    remoteExists: aheadResult.code === 0 && behindResult.code === 0,
+    ahead: aheadResult.code === 0 ? toCount(aheadResult.stdout) : null,
+    behind: behindResult.code === 0 ? toCount(behindResult.stdout) : null,
+    fetchError: aheadResult.code === 0 && behindResult.code === 0 ? null : outputOf(aheadResult) || outputOf(behindResult) || 'could not compare local and remote branch',
+  };
+}
+
+export async function synchronizeExistingIssueBranchBeforeAutoPrCreation({ tempDir, branchName, isContinueMode, prNumber, log, formatAligned, $ }) {
+  if (!(isContinueMode && !prNumber)) {
+    return null;
+  }
+
+  await log(formatAligned('🔎', 'Existing branch sync:', branchName));
+  const divergence = await getRemoteBranchDivergenceSnapshot({ $, tempDir, branchName });
+  if (!divergence.remoteExists) {
+    await log(`   ⚠️ Could not inspect origin/${branchName}: ${divergence.fetchError || 'unknown error'}`, { level: 'warning' });
+    return divergence;
+  }
+
+  await log(`   Branch state before PR bootstrap commit: ${divergence.ahead} commit(s) ahead, ${divergence.behind} commit(s) behind origin/${branchName}`);
+
+  if (divergence.behind > 0 && divergence.ahead === 0) {
+    await log(`   Fast-forwarding ${branchName} to origin/${branchName} before creating the PR bootstrap commit...`);
+    const mergeResult = await $({ cwd: tempDir })`git merge --ff-only origin/${branchName} 2>&1`;
+    if (mergeResult.code !== 0) {
+      await log(`   ⚠️ Fast-forward failed: ${outputOf(mergeResult) || 'unknown error'}`, {
+        level: 'warning',
+      });
+      throw new Error('Existing issue branch could not be fast-forwarded before PR creation');
+    }
+    await log(`   ✅ Branch fast-forwarded to origin/${branchName}`);
+    return await getRemoteBranchDivergenceSnapshot({ $, tempDir, branchName });
+  }
+
+  if (divergence.behind > 0 && divergence.ahead > 0) {
+    for (const line of buildPushRejectionExplanation({
+      branchName,
+      isContinueMode,
+      prNumber,
+      divergence,
+    })) {
+      await log(line);
+    }
+    throw new Error('Existing issue branch has diverged before PR creation; manual resolution required');
+  }
+
+  return divergence;
+}

package/src/solve.config.lib.mjs

@@ -512,6 +512,11 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: 'Disable error issue creation entirely (no prompt, no automatic creation). Overrides --auto-report-issue if both are specified.',
     default: false,
   },
+  'disable-issue-auto-creation-on-error': {
+    type: 'boolean',
+    description: 'Disable creating a new GitHub error-report issue when solve fails, including the interactive prompt. This does not disable posting failure logs or comments to the original issue or pull request.',
+    default: false,
+  },
   'attach-solution-summary': {
     type: 'boolean',
     description: 'Attach the AI working session summary (from the result field) as a comment to the PR/issue after every working session. The summary is extracted from the AI tool JSON output and posted under a "Working session summary" header. Applies to the top-level run, auto-restart-until-mergeable iterations, and watch-mode iterations.',
@@ -718,6 +723,12 @@ export const parseArguments = async (yargs = getLinoYargsFactory(), hideBinFn =
     if (argv.toolCheck === false) {
       argv.toolConnectionCheck = false;
     }
+    // Issue #1752: new flag is the explicit user-facing switch for disabling
+    // creation of separate solver-error issues. Keep the existing internal
+    // disableReportIssue path as the single behavior flag.
+    if (argv.disableIssueAutoCreationOnError) {
+      argv.disableReportIssue = true;
+    }
   }
 
   // --finalize normalization

package/src/solve.error-handlers.lib.mjs

@@ -12,11 +12,14 @@ import { reportError } from './sentry.lib.mjs';
 // Import GitHub error reporter
 import { handleErrorWithIssueCreation } from './github-error-reporter.lib.mjs';
 
+export const isErrorIssueAutoCreationDisabled = argv => !!(argv?.disableReportIssue || argv?.disableIssueAutoCreationOnError);
+
 /**
  * Handles log attachment and PR closing on failure
  */
 export const handleFailure = async options => {
   const { error, errorType, shouldAttachLogs, argv, global, owner, repo, log, getLogFile, attachLogToGitHub, cleanErrorMessage, sanitizeLogContent, $ } = options;
+  const disableIssueCreation = isErrorIssueAutoCreationDisabled(argv);
 
   // Offer to create GitHub issue for the error
   try {
@@ -30,9 +33,9 @@ export const handleFailure = async options => {
         prNumber: global.createdPR?.number,
         errorType,
       },
-      skipPrompt: !process.stdin.isTTY || argv.noIssueCreation,
+      skipPrompt: !process.stdin.isTTY || argv.noIssueCreation || disableIssueCreation,
       autoReport: argv.autoReportIssue,
-      disableReport: argv.disableReportIssue,
+      disableReport: disableIssueCreation,
     });
   } catch (issueError) {
     reportError(issueError, {
@@ -49,7 +52,7 @@ export const handleFailure = async options => {
     const hasIssue = global.issueNumber;
     const targetType = hasPR ? 'pr' : hasIssue ? 'issue' : null;
     const targetNumber = hasPR ? global.createdPR.number : hasIssue ? global.issueNumber : null;
-    const targetLabel = hasPR ? 'Pull Request' : 'Issue';
+    const targetLabel = hasPR ? 'Pull Request' : `original issue #${targetNumber}`;
 
     if (targetType && targetNumber) {
       await log(`\n📄 Attempting to attach failure logs to ${targetLabel}...`);
@@ -70,7 +73,7 @@ export const handleFailure = async options => {
           tool: argv.tool || 'claude',
         });
         if (logUploadSuccess) {
-          await log(`📎 Failure log attached to ${targetLabel}`);
+          await log(`📎 Failure log posted to ${targetLabel}`);
           if (!hasPR && hasIssue) global.prePullRequestFailureNotificationPosted = true;
         }
       } catch (attachError) {
@@ -81,7 +84,7 @@ export const handleFailure = async options => {
           errorType,
           operation: `attach_log_to_${targetType}`,
         });
-        await log(`⚠️  Could not attach failure log to ${targetLabel}: ${attachError.message}`, { level: 'warning' });
+        await log(`⚠️  Could not post failure log to ${targetLabel}: ${attachError.message}`, { level: 'warning' });
       }
     }
   }

package/src/solve.mjs

@@ -162,6 +162,12 @@ const { isIssueUrl, isPrUrl, normalizedUrl, owner, repo, number: urlNumber } = u
 issueUrl = normalizedUrl || issueUrl;
 global.owner = owner;
 global.repo = repo;
+// Issue #1752: failures before PR creation can happen during checks that run
+// before the normal issue-mode setup below. Record the source issue as soon as
+// the URL is validated so the pre-exit notifier can still comment on it.
+if (isIssueUrl) {
+  global.issueNumber = urlNumber;
+}
 cleanupContext.owner = owner;
 cleanupContext.repo = repo;
 // Setup unhandled error handlers to ensure log path is always shown
@@ -331,6 +337,7 @@ if (autoContinueResult.isContinueMode) {
   } else {
     // We have a branch but no PR - we'll use the existing branch and create a PR later
     await log(`🔄 Using existing branch: ${prBranch} (no PR yet - will create one)`);
+    await log('   This branch was created by an earlier run; this run is reusing it rather than creating a fresh branch.');
     if (argv.verbose) {
       await log('   Branch will be checked out and PR will be created during auto-PR creation phase', {
         verbose: true,
@@ -1021,7 +1028,7 @@ try {
     const hasIssue = global.issueNumber;
     const logTargetType = hasPR ? 'pr' : hasIssue ? 'issue' : null;
     const logTargetNumber = hasPR ? global.createdPR.number : hasIssue ? global.issueNumber : null;
-    const logTargetLabel = hasPR ? 'Pull Request' : 'Issue';
+    const logTargetLabel = hasPR ? 'Pull Request' : `original issue #${logTargetNumber}`;
 
     if (shouldAttachLogs && logTargetType && logTargetNumber) {
       await log(`\n📄 Attaching failure logs to ${logTargetLabel}...`);
@@ -1054,7 +1061,7 @@ try {
         });
 
         if (logUploadSuccess) {
-          await log(`  📎 Failure logs attached to ${logTargetLabel}`);
+          await log(`  📎 Failure logs posted to ${logTargetLabel}`);
         } else {
           // Issue #1212: Always show log upload failures (not just verbose)
           await log('  ⚠️  Failed to upload failure logs');