@link-assistant/hive-mind 1.72.4 → 1.72.6

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 1.72.6
+
+### Patch Changes
+
+- 57f15ec: Detect same-account human feedback in auto-restart comment monitoring only when the AI tool is idle, while still filtering hive-mind tool-generated comments by marker and tracked ID.
+
+## 1.72.5
+
+### Patch Changes
+
+- c3a89a3: Recover auto-PR creation when a rejected push leaves the remote branch matching local HEAD, and improve push rejection diagnostics with exact branch and compare links.
+
 ## 1.72.4
 
 ### Patch Changes

package/package.json

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

package/src/solve.auto-merge-helpers.lib.mjs

@@ -76,7 +76,7 @@ const formatRunLine = run => {
 // search scope for checkForExistingComment() stays in lock-step with the
 // markers actually embedded in tool-posted comments.
 const toolComments = await import('./tool-comments.lib.mjs');
-const { SESSION_ENDING_MARKERS } = toolComments;
+const { SESSION_ENDING_MARKERS, isToolGeneratedComment, isToolTrackedCommentId } = toolComments;
 
 /**
  * Issue #1323: Check if a comment with specific content already exists on the PR
@@ -168,14 +168,25 @@ export const checkForExistingComment = async (owner, repo, prNumber, commentSign
 
 /**
  * Check for new comments from non-bot users since last commit
+ *
+ * Same-account comments are only considered feedback when
+ * `trustAuthenticatedUserComments` is true. Keep the default false for callers
+ * that may run while an AI tool is still active: those tools can post through
+ * the authenticated GitHub account.
+ *
+ * @param {Function} commandRunner - Tagged-template command runner, injectable for tests
+ * @param {Object} options - Comment classification options
+ * @param {boolean} options.trustAuthenticatedUserComments - True only when the caller knows the AI tool is not running
  * @returns {Promise<{hasNewComments: boolean, comments: Array}>}
  */
-export const checkForNonBotComments = async (owner, repo, prNumber, issueNumber, lastCheckTime, verbose = false) => {
+export const checkForNonBotComments = async (owner, repo, prNumber, issueNumber, lastCheckTime, verbose = false, commandRunner = $, options = {}) => {
   try {
+    const { trustAuthenticatedUserComments = false } = options;
+
     // Get current GitHub user to identify which comments are from the bot/hive-mind
     let currentUser = null;
     try {
-      const userResult = await $`gh api user --jq .login`;
+      const userResult = await commandRunner`gh api user --jq .login`;
       if (userResult.code === 0) {
         currentUser = userResult.stdout.toString().trim();
       }
@@ -183,7 +194,12 @@ export const checkForNonBotComments = async (owner, repo, prNumber, issueNumber,
       // If we can't get the current user, continue without filtering
     }
 
-    // Common bot usernames and patterns to filter out
+    // Common bot usernames and patterns to filter out.
+    // Issue #1821: In same-account operation, humans and AI tools can both
+    // post through the authenticated account. The safe default treats that
+    // account as tool-owned; auto-restart-until-mergeable opts in to trusting
+    // same-account comments only while no AI tool execution is active, and
+    // still filters tool-generated comments by tracked IDs and marker strings.
     // Note: Patterns use word boundaries or end-of-string to avoid false positives
     // (e.g., "claudeuser" should NOT match as a bot)
     const botPatterns = [
@@ -201,21 +217,21 @@ export const checkForNonBotComments = async (owner, repo, prNumber, issueNumber,
 
     const isBot = login => {
       if (!login) return false;
-      // Check if it's the current user (the bot running hive-mind)
-      if (currentUser && login === currentUser) return true;
       // Check against known bot patterns
       return botPatterns.some(pattern => pattern.test(login));
     };
 
+    const isToolComment = comment => isToolTrackedCommentId(comment.id) || isToolGeneratedComment(comment.body);
+
     // Fetch PR conversation comments
-    const prCommentsResult = await $`gh api repos/${owner}/${repo}/issues/${prNumber}/comments --paginate`;
+    const prCommentsResult = await commandRunner`gh api repos/${owner}/${repo}/issues/${prNumber}/comments --paginate`;
     let prComments = [];
     if (prCommentsResult.code === 0 && prCommentsResult.stdout) {
       prComments = JSON.parse(prCommentsResult.stdout.toString() || '[]');
     }
 
     // Fetch PR review comments (inline code comments)
-    const prReviewCommentsResult = await $`gh api repos/${owner}/${repo}/pulls/${prNumber}/comments --paginate`;
+    const prReviewCommentsResult = await commandRunner`gh api repos/${owner}/${repo}/pulls/${prNumber}/comments --paginate`;
     let prReviewComments = [];
     if (prReviewCommentsResult.code === 0 && prReviewCommentsResult.stdout) {
       prReviewComments = JSON.parse(prReviewCommentsResult.stdout.toString() || '[]');
@@ -224,7 +240,7 @@ export const checkForNonBotComments = async (owner, repo, prNumber, issueNumber,
     // Fetch issue comments if we have an issue number
     let issueComments = [];
     if (issueNumber && issueNumber !== prNumber) {
-      const issueCommentsResult = await $`gh api repos/${owner}/${repo}/issues/${issueNumber}/comments --paginate`;
+      const issueCommentsResult = await commandRunner`gh api repos/${owner}/${repo}/issues/${issueNumber}/comments --paginate`;
       if (issueCommentsResult.code === 0 && issueCommentsResult.stdout) {
         issueComments = JSON.parse(issueCommentsResult.stdout.toString() || '[]');
       }
@@ -233,14 +249,28 @@ export const checkForNonBotComments = async (owner, repo, prNumber, issueNumber,
     // Combine all comments
     const allComments = [...prComments, ...prReviewComments, ...issueComments];
 
-    // Filter for new comments from non-bot users
+    // Filter for new comments from non-bot users. Automated hive-mind/tool
+    // comments are excluded by marker/ID, including comments posted by the
+    // authenticated user during the current or a previous process.
     const newNonBotComments = allComments.filter(comment => {
       const commentTime = new Date(comment.created_at);
       const isAfterLastCheck = commentTime > lastCheckTime;
-      const isFromNonBot = !isBot(comment.user?.login);
-
-      if (verbose && isAfterLastCheck && isFromNonBot) {
-        console.log(`[VERBOSE] New non-bot comment from ${comment.user?.login} at ${comment.created_at}`);
+      const login = comment.user?.login;
+      const isFromAuthenticatedUser = Boolean(currentUser && login === currentUser);
+      const isFromTool = isToolComment(comment);
+      const isFromAuthenticatedUserToolContext = isFromAuthenticatedUser && !trustAuthenticatedUserComments;
+      const isFromBot = isBot(login) || isFromAuthenticatedUserToolContext;
+      const isFromNonBot = !isFromBot && !isFromTool;
+
+      if (verbose && isAfterLastCheck && isFromTool) {
+        console.log(`[VERBOSE] Skipping tool-generated comment from ${login} at ${comment.created_at}`);
+      } else if (verbose && isAfterLastCheck && isFromAuthenticatedUserToolContext) {
+        console.log(`[VERBOSE] Skipping authenticated-user comment from ${login} at ${comment.created_at} because same-account feedback is not trusted in this context`);
+      } else if (verbose && isAfterLastCheck && isFromBot) {
+        console.log(`[VERBOSE] Skipping bot comment from ${login} at ${comment.created_at}`);
+      } else if (verbose && isAfterLastCheck && isFromNonBot) {
+        const sameAccountSuffix = currentUser && login === currentUser ? ' (authenticated user)' : '';
+        console.log(`[VERBOSE] New non-bot comment from ${login}${sameAccountSuffix} at ${comment.created_at}`);
       }
 
       return isAfterLastCheck && isFromNonBot;

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

@@ -206,8 +206,12 @@ export const watchUntilMergeable = async params => {
         // Keep the counter as-is (it reached the safety valve or wasn't needed).
       }
 
-      // Check for new comments from non-bot users
-      const { hasNewComments, comments } = await checkForNonBotComments(owner, repo, prNumber, issueNumber, lastCheckTime, argv.verbose);
+      // Check for new comments from non-bot users. At this point the AI tool
+      // is not executing, so same-account non-tool comments can be trusted as
+      // human feedback while known tool comments remain filtered by markers/IDs.
+      const { hasNewComments, comments } = await checkForNonBotComments(owner, repo, prNumber, issueNumber, lastCheckTime, argv.verbose, $, {
+        trustAuthenticatedUserComments: true,
+      });
 
       // Check for uncommitted changes using shared utility
       const hasUncommittedChanges = await checkForUncommittedChanges(tempDir, argv);

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

@@ -4,7 +4,7 @@
  */
 
 import { closingIssueNumbersContain, parseClosingIssueNumbers } from './pr-issue-linking.lib.mjs';
-import { buildPushRejectionExplanation, getRemoteBranchDivergenceSnapshot, synchronizeExistingIssueBranchBeforeAutoPrCreation } from './solve.branch-divergence.lib.mjs';
+import { handleRejectedPushForAutoPr, synchronizeExistingIssueBranchBeforeAutoPrCreation } from './solve.branch-divergence.lib.mjs';
 import { emitForkAwareDiagnostic } from './solve.auto-pr-fork-diagnostic.lib.mjs';
 
 import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry, execGhWithRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller. Issue #1756: execGhWithRetry retries on transient 5xx (504) too.
@@ -409,6 +409,9 @@ Proceed.
         }
       }
 
+      let branchReadyForPrCreation = pushResult.code === 0;
+      let recoveredFromPushRejection = false;
+
       if (pushResult.code !== 0) {
         const errorOutput = pushResult.stderr ? pushResult.stderr.toString() : pushResult.stdout ? pushResult.stdout.toString() : 'Unknown error';
 
@@ -539,48 +542,41 @@ 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' });
-          await log('');
-          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);
+        } else {
+          const rejectedPush = await handleRejectedPushForAutoPr({
+            errorOutput,
+            $,
+            tempDir,
+            log,
+            formatAligned,
+            branchName,
+            isContinueMode,
+            prNumber,
+            owner,
+            repo,
+            defaultBranch,
+            forkedRepo,
+          });
+
+          if (rejectedPush.handled) {
+            branchReadyForPrCreation = rejectedPush.branchReadyForPrCreation;
+            recoveredFromPushRejection = rejectedPush.recoveredFromPushRejection;
+          } else {
+            // Other push errors
+            await log(`${formatAligned('❌', 'Failed to push:', 'See error below')}`, { level: 'error' });
+            await log(`   Error: ${errorOutput}`, { level: 'error' });
+            throw new Error('Failed to push branch');
           }
-          await log('');
-          await log('  💡 Why we cannot fix this automatically:');
-          await log('     • We never use force push to preserve history');
-          await log('     • We never use rebase or reset to avoid altering git history');
-          await log('     • Manual conflict resolution is required');
-          await log('');
-          await log('  🔧 How to fix:');
-          await log('     1. Clone the repository and checkout the branch:');
-          await log(`        git clone https://github.com/${owner}/${repo}.git`);
-          await log(`        cd ${repo}`);
-          await log(`        git checkout ${branchName}`);
-          await log('');
-          await log('     2. Pull and merge the remote changes:');
-          await log(`        git pull origin ${branchName}`);
-          await log('');
-          await log('     3. Resolve any conflicts manually, then:');
-          await log(`        git push origin ${branchName}`);
-          await log('');
-          await log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-          await log('');
-          throw new Error('Push rejected - branch has diverged, manual resolution required');
+        }
+      }
+
+      if (branchReadyForPrCreation) {
+        if (recoveredFromPushRejection) {
+          await log(`${formatAligned('✅', 'Branch available:', 'Remote branch matches local HEAD')}`);
         } else {
-          // Other push errors
-          await log(`${formatAligned('❌', 'Failed to push:', 'See error below')}`, { level: 'error' });
-          await log(`   Error: ${errorOutput}`, { level: 'error' });
-          throw new Error('Failed to push branch');
+          await log(`${formatAligned('✅', 'Branch pushed:', 'Successfully to remote')}`);
         }
-      } else {
-        await log(`${formatAligned('✅', 'Branch pushed:', 'Successfully to remote')}`);
-        if (argv.verbose) {
+        if (argv.verbose && pushResult.code === 0) {
           await log(`   Push output: ${pushResult.stdout.toString().trim()}`, { verbose: true });
         }
 
@@ -1454,6 +1450,10 @@ ${prBody}`,
       operation: 'handle_auto_pr',
     });
 
+    if (prError?.hiveMindUserFacingLogged) {
+      throw prError;
+    }
+
     // Issue #1462: Single consolidated error message for PR creation failure.
     // Previously this was the third of three error blocks, causing confusing output.
     // Now this is the ONLY error block shown for PR creation failures.

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

@@ -9,18 +9,117 @@ const outputOf = result => {
   return stdout || stderr;
 };
 
-export function buildPushRejectionExplanation({ branchName, isContinueMode, prNumber, divergence = null }) {
+const shortSha = sha => (sha ? String(sha).slice(0, 12) : null);
+
+const encodeRefForGitHubUrl = ref =>
+  encodeURI(String(ref || ''))
+    .replaceAll('#', '%23')
+    .replaceAll('?', '%3F');
+
+export function classifyPushRejection(errorOutput = '') {
+  const normalized = String(errorOutput || '').toLowerCase();
+
+  if (normalized.includes('cannot lock ref') && normalized.includes('reference already exists')) {
+    return 'remote-ref-already-exists';
+  }
+
+  if (normalized.includes('non-fast-forward') || normalized.includes('not fast-forward') || normalized.includes('fetch first') || normalized.includes('stale info') || normalized.includes('tip of your current branch is behind') || normalized.includes('updates were rejected')) {
+    return 'non-fast-forward';
+  }
+
+  if (normalized.includes('remote rejected') || normalized.includes('[remote rejected]')) {
+    return 'remote-rejected';
+  }
+
+  if (normalized.includes('rejected') || normalized.includes('failed to push some refs')) {
+    return 'rejected';
+  }
+
+  return 'unknown';
+}
+
+export function shouldTreatPushRejectionAsRemoteSynchronized(divergence = null) {
+  if (!divergence?.remoteExists || divergence.ahead !== 0 || divergence.behind !== 0) {
+    return false;
+  }
+
+  if (divergence.localSha && divergence.remoteSha) {
+    return divergence.localSha === divergence.remoteSha;
+  }
+
+  return true;
+}
+
+export function buildBranchSubjectLinks({ owner, repo, branchName, defaultBranch, forkedRepo = null }) {
+  const repository = `${owner}/${repo}`;
+  const headRepository = forkedRepo || repository;
+  const headOwner = headRepository.split('/')[0];
+  const baseBranch = defaultBranch || 'main';
+  const compareHead = forkedRepo ? `${headOwner}:${branchName}` : branchName;
+
+  return {
+    repository,
+    headRepository,
+    baseBranchRef: `${repository}:${baseBranch}`,
+    headBranchRef: `${headRepository}:${branchName}`,
+    remoteBranchRef: `origin/${branchName}`,
+    repositoryUrl: `https://github.com/${repository}`,
+    branchUrl: `https://github.com/${headRepository}/tree/${encodeRefForGitHubUrl(branchName)}`,
+    compareUrl: `https://github.com/${repository}/compare/${encodeRefForGitHubUrl(baseBranch)}...${encodeRefForGitHubUrl(compareHead)}`,
+  };
+}
+
+export function buildPushRejectionFailureActionSection({ owner, repo, branchName, defaultBranch, forkedRepo = null }) {
+  if (!owner || !repo || !branchName) {
+    return `### What you can do
+- Inspect the remote branch and compare it with the local branch before retrying.
+- If the remote branch already contains the intended commit, rerun the solver.
+- If the histories differ, merge or resolve the branch manually, then rerun the solver.`;
+  }
+
+  const links = buildBranchSubjectLinks({ owner, repo, branchName, defaultBranch, forkedRepo });
+
+  return `### What you can do
+- Inspect the remote branch: ${links.branchUrl}
+- Compare the base and head branches: ${links.compareUrl}
+- If the remote branch already contains the intended commit, rerun the solver. Matching remote branches are treated as usable after this fix.
+- If the histories differ, merge or resolve \`${links.headBranchRef}\` against \`${links.baseBranchRef}\`, then rerun the solver.
+
+Administrator-only CLI details, if any, are printed in the solver terminal log rather than in this GitHub comment.`;
+}
+
+export function buildPushRejectionExplanation({ branchName, isContinueMode, prNumber, divergence = null, owner = null, repo = null, defaultBranch = null, forkedRepo = null, classification = 'unknown' }) {
   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 if (classification === 'remote-ref-already-exists') {
+    lines.push('     GitHub rejected the push while creating or updating the remote ref because that ref already exists.');
   } else {
     lines.push('     The remote branch changed after the local branch state used for this push.');
   }
 
+  if (owner && repo) {
+    const links = buildBranchSubjectLinks({ owner, repo, branchName, defaultBranch, forkedRepo });
+    lines.push(`     Repository: ${links.repositoryUrl}`);
+    lines.push(`     Base branch: ${links.baseBranchRef}`);
+    lines.push(`     Remote branch: ${links.headBranchRef}`);
+    lines.push(`     Branch URL: ${links.branchUrl}`);
+    lines.push(`     Compare URL: ${links.compareUrl}`);
+  }
+
   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}.`);
+    if (divergence.localSha) {
+      lines.push(`     Local HEAD: ${shortSha(divergence.localSha)}`);
+    }
+    if (divergence.remoteSha) {
+      lines.push(`     Remote HEAD: ${shortSha(divergence.remoteSha)}`);
+    }
+    if (shouldTreatPushRejectionAsRemoteSynchronized(divergence)) {
+      lines.push('     The remote branch currently matches local HEAD, so this is not a branch divergence.');
+    }
   } else if (divergence?.fetchError) {
     lines.push(`     Could not inspect origin/${branchName}: ${divergence.fetchError}`);
   }
@@ -28,6 +127,142 @@ export function buildPushRejectionExplanation({ branchName, isContinueMode, prNu
   return lines;
 }
 
+export async function logRecoverablePushRejection({ log, formatAligned, branchName, isContinueMode, prNumber, divergence, owner, repo, defaultBranch, forkedRepo, classification }) {
+  const links = buildBranchSubjectLinks({ owner, repo, branchName, defaultBranch, forkedRepo });
+
+  await log('');
+  await log(formatAligned('⚠️', 'PUSH REPORTED FAILURE:', 'Remote branch already matches local HEAD'), { level: 'warning' });
+  await log('');
+  await log('  🔍 What happened:');
+  for (const line of buildPushRejectionExplanation({
+    branchName,
+    isContinueMode,
+    prNumber,
+    divergence,
+    owner,
+    repo,
+    defaultBranch,
+    forkedRepo,
+    classification,
+  })) {
+    await log(line);
+  }
+  await log('');
+  await log('  ✅ Recovery:');
+  await log(`     The branch is available at ${links.branchUrl}.`);
+  await log('     Continuing with PR creation because no local commit would be lost.');
+  await log('');
+
+  return links;
+}
+
+export async function logBlockingPushRejection({ log, formatAligned, branchName, isContinueMode, prNumber, divergence, owner, repo, defaultBranch, forkedRepo, classification }) {
+  const links = buildBranchSubjectLinks({ owner, repo, branchName, defaultBranch, forkedRepo });
+  const isRefCollision = classification === 'remote-ref-already-exists';
+
+  await log('');
+  await log(formatAligned('❌', isRefCollision ? 'REMOTE BRANCH COLLISION:' : 'PUSH REJECTED:', isRefCollision ? 'Remote ref already exists and differs from local branch' : 'Local and remote branch histories differ'), { level: 'error' });
+  await log('');
+  await log('  🔍 What happened:');
+  if (isRefCollision) {
+    await log(`     GitHub rejected creation or update of ${links.headBranchRef} because that remote ref already exists.`);
+    await log('     The existing remote branch does not match this local branch, so hive-mind cannot assume it is safe to continue.');
+  } else {
+    await log(`     Git rejected updating ${links.headBranchRef} from this local branch.`);
+    await log('     The local and remote histories are not in a state that a normal push can update safely.');
+  }
+  for (const line of buildPushRejectionExplanation({
+    branchName,
+    isContinueMode,
+    prNumber,
+    divergence,
+    owner,
+    repo,
+    defaultBranch,
+    forkedRepo,
+    classification,
+  })) {
+    await log(line);
+  }
+  await log('');
+  await log('  💡 Why we cannot fix this automatically:');
+  await log('     • We never use force push to preserve history');
+  await log('     • We never use rebase or reset to avoid altering git history');
+  await log(`     • Manual review is required before changing ${links.headBranchRef}`);
+  await log('');
+  await log('  🔧 How to fix:');
+  await log(`     1. Inspect the remote branch: ${links.branchUrl}`);
+  await log(`     2. Compare base and head: ${links.compareUrl}`);
+  await log('     3. Clone the repository and checkout the branch:');
+  await log(`        git clone https://github.com/${links.headRepository}.git`);
+  await log(`        cd ${links.headRepository.split('/')[1]}`);
+  await log(`        git checkout ${branchName}`);
+  await log('');
+  await log('     4. Merge the remote branch state, resolve conflicts if any, then push:');
+  await log(`        git pull origin ${branchName}`);
+  await log(`        git push origin ${branchName}`);
+  await log('');
+  await log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  await log('');
+
+  return {
+    links,
+    failureActionSection: buildPushRejectionFailureActionSection({ owner, repo, branchName, defaultBranch, forkedRepo }),
+  };
+}
+
+export async function handleRejectedPushForAutoPr({ errorOutput, $, tempDir, log, formatAligned, branchName, isContinueMode, prNumber, owner, repo, defaultBranch, forkedRepo }) {
+  const classification = classifyPushRejection(errorOutput);
+  if (classification === 'unknown') {
+    return {
+      handled: false,
+      branchReadyForPrCreation: false,
+      recoveredFromPushRejection: false,
+    };
+  }
+
+  const divergence = await getRemoteBranchDivergenceSnapshot({ $, tempDir, branchName });
+
+  if (shouldTreatPushRejectionAsRemoteSynchronized(divergence)) {
+    await logRecoverablePushRejection({
+      log,
+      formatAligned,
+      branchName,
+      isContinueMode,
+      prNumber,
+      divergence,
+      owner,
+      repo,
+      defaultBranch,
+      forkedRepo,
+      classification,
+    });
+    return {
+      handled: true,
+      branchReadyForPrCreation: true,
+      recoveredFromPushRejection: true,
+    };
+  }
+
+  const { links, failureActionSection } = await logBlockingPushRejection({
+    log,
+    formatAligned,
+    branchName,
+    isContinueMode,
+    prNumber,
+    divergence,
+    owner,
+    repo,
+    defaultBranch,
+    forkedRepo,
+    classification,
+  });
+  const error = new Error(`Push rejected for ${links.headBranchRef}; compare ${links.compareUrl} and inspect ${links.branchUrl}`);
+  error.hiveMindUserFacingLogged = true;
+  error.failureActionSection = failureActionSection;
+  throw error;
+}
+
 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) {
@@ -41,11 +276,15 @@ export async function getRemoteBranchDivergenceSnapshot({ $, tempDir, branchName
 
   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`;
+  const localShaResult = await $({ cwd: tempDir, silent: true })`git rev-parse HEAD 2>&1`;
+  const remoteShaResult = await $({ cwd: tempDir, silent: true })`git rev-parse 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,
+    localSha: localShaResult.code === 0 ? outputOf(localShaResult) : null,
+    remoteSha: remoteShaResult.code === 0 ? outputOf(remoteShaResult) : null,
     fetchError: aheadResult.code === 0 && behindResult.code === 0 ? null : outputOf(aheadResult) || outputOf(behindResult) || 'could not compare local and remote branch',
   };
 }

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

@@ -68,6 +68,7 @@ export const handleFailure = async options => {
           sanitizeLogContent,
           verbose: argv.verbose,
           errorMessage: cleanErrorMessage(error),
+          failureActionSection: error?.failureActionSection || null,
           // Issue #1225: Pass model and tool info for PR comments
           requestedModel: argv.originalModel || argv.model,
           tool: argv.tool || 'claude',
@@ -236,7 +237,9 @@ export const handleMainExecutionError = async options => {
     return;
   }
 
-  await log('Error executing command:', cleanErrorMessage(error));
+  if (!error?.hiveMindUserFacingLogged) {
+    await log('Error executing command:', cleanErrorMessage(error));
+  }
   await log(`Stack trace: ${error.stack}`, { verbose: true });
   await log(`   📁 Full log file: ${absoluteLogPath}`, { level: 'error' });
 

package/src/solve.pre-pr-failure-notifier.lib.mjs

@@ -15,6 +15,16 @@ const isForkDivergenceFailure = reason => {
   return normalizedReason.includes('fork divergence') || (normalizedReason.includes('fork') && normalizedReason.includes('non-fast-forward')) || normalizedReason.includes('force-with-lease');
 };
 
+const extractUrlAfter = (reason, label) => {
+  const match = String(reason || '').match(new RegExp(`${label}\\s+(https://github\\.com/[^\\s;]+)`, 'i'));
+  return match ? match[1] : null;
+};
+
+const isPushRejectionFailure = reason => {
+  const normalizedReason = String(reason || '').toLowerCase();
+  return normalizedReason.includes('push rejected for ') || (normalizedReason.includes('failed to push') && normalizedReason.includes('github.com'));
+};
+
 export function buildPrePullRequestFailureActionSection(reason = '') {
   const normalizedReason = String(reason || '').toLowerCase();
   const isForkOrRecoveryFailure = normalizedReason.includes('fork') || normalizedReason.includes('auto-recovery') || normalizedReason.includes('repository setup');
@@ -25,6 +35,18 @@ export function buildPrePullRequestFailureActionSection(reason = '') {
 - If the fork has commits you need to preserve, resolve the divergence manually, then rerun the solver.
 - If this requires elevated Hive Mind access, ask a Hive Mind administrator to handle the affected fork or repository.
 
+Administrator-only CLI details, if any, are printed in the solver terminal log rather than in this GitHub comment.`;
+  }
+
+  if (isPushRejectionFailure(reason)) {
+    const branchUrl = extractUrlAfter(reason, 'inspect');
+    const compareUrl = extractUrlAfter(reason, 'compare');
+    return `### What you can do
+- Inspect the remote branch${branchUrl ? `: ${branchUrl}` : ' named in the failure'}.
+- Compare the base and head histories${compareUrl ? `: ${compareUrl}` : ' using the compare link named in the failure'}.
+- If the branch belongs to you, merge the remote branch state or choose a new branch name, then rerun the solver.
+- Do not force-push unless you have manually confirmed that overwriting the remote branch is safe.
+
 Administrator-only CLI details, if any, are printed in the solver terminal log rather than in this GitHub comment.`;
   }