@link-assistant/hive-mind 2.11.12 → 2.12.0

package/src/models/index.mjs

@@ -23,13 +23,16 @@ if (typeof globalThis.use === 'undefined') {
 }
 
 import { log } from '../lib.mjs';
+import { FORMAL_AI_MODEL_ALIAS, FORMAL_AI_PROVIDER_MODEL_ID, isFormalAiModel } from '../formal-ai-model.lib.mjs';
 
 const execFileAsync = promisify(execFile);
 
 // ─── MODEL DATA ──────────────────────────────────────────────────────────────
 
-export const FORMAL_AI_MODEL_ALIAS = 'formal-ai';
-export const FORMAL_AI_PROVIDER_MODEL_ID = 'formalai/formal-ai';
+// Defined in a leaf module so callers that only need the identity check (the
+// Formal AI sidecar lifecycle, issue #2146) do not have to import this catalogue
+// and its `use-m` bootstrap. Re-exported here so the public surface is unchanged.
+export { FORMAL_AI_MODEL_ALIAS, FORMAL_AI_PROVIDER_MODEL_ID, isFormalAiModel } from '../formal-ai-model.lib.mjs';
 
 const formalAiNativeModelAliases = {
   [FORMAL_AI_MODEL_ALIAS]: FORMAL_AI_MODEL_ALIAS,
@@ -41,8 +44,6 @@ const formalAiProviderModelAliases = {
   [FORMAL_AI_PROVIDER_MODEL_ID]: FORMAL_AI_PROVIDER_MODEL_ID,
 };
 
-export const isFormalAiModel = model => model === FORMAL_AI_MODEL_ALIAS || model === FORMAL_AI_PROVIDER_MODEL_ID;
-
 // Claude models (Anthropic API)
 // Updated for Opus 4.5/4.6/4.7/4.8/5, Sonnet 4.6/5, and Fable 5 / Mythos 5 support
 // (Issue #1221, Issue #1238, Issue #1329, Issue #1433, Issue #1620, Issue #1832, Issue #1875, Issue #2003, Issue #2096)

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

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+import { ensureUseM } from './use-m-bootstrap.lib.mjs';
+
+/**
+ * One-shot `--auto-merge` attempt after a session ends.
+ *
+ * Extracted from solve.auto-merge.lib.mjs (Issue #2144) to keep both files
+ * under the 1500-line limit while the stop-reporting paths were added.
+ *
+ * Issue #2144 behaviour: a closed or missing linked issue is *not* a terminal
+ * state here either. The merge requirements are still evaluated, and only the
+ * final merge is held back — with a comment asking the user to reopen the
+ * issue or merge manually. Every other stop path reports its exact reason to
+ * the pull request.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/2144
+ */
+
+if (typeof globalThis.use === 'undefined') {
+  await ensureUseM();
+}
+const use = globalThis.use;
+
+const { $: __rawDollar$ } = await use('command-stream');
+const { wrapDollarWithGhRetry } = await import('./github-rate-limit.lib.mjs');
+const $ = wrapDollarWithGhRetry(__rawDollar$);
+
+const lib = await import('./lib.mjs');
+const { log, formatAligned } = lib;
+
+const githubMergeLib = await import('./github-merge.lib.mjs');
+const { checkPRMergeable, checkMergePermissions, mergePullRequest, waitForCI } = githubMergeLib;
+
+const terminalStateLib = await import('./github-terminal-state.lib.mjs');
+const { checkGitHubTerminalState } = terminalStateLib;
+
+// Issue #2144: these probes answer with a ~33 KB pull request object and a full
+// issue object on every iteration. Issue #2130 made the helper's own default
+// runner quiet, but passing `$` here bypassed it and the payloads were still
+// mirrored into the attached log. Bind the quiet options to the injected `$`.
+const { quietProbe } = await import('./quiet-probe.lib.mjs');
+
+const toolComments = await import('./tool-comments.lib.mjs');
+const { AUTO_MERGED_MARKER, postTrackedComment } = toolComments;
+
+const stopReporting = await import('./automation-stop-reporting.lib.mjs');
+const { AUTO_MERGE_BLOCKED_MARKER, buildAutoMergeBlockedComment, reportAutomationStop } = stopReporting;
+
+const { ensureLinkedIssueClosedAfterMerge } = await import('./github-issue-auto-close.lib.mjs');
+
+const shouldDeleteBranchAfterMerge = argv => argv.autoDeleteBranchOnMerge || argv.deleteBranchAfterMerge || false;
+
+/**
+ * Report the merge blockers that prevent an automatic merge of a pull request
+ * which otherwise satisfies every merge requirement (Issue #2144).
+ *
+ * @returns {Promise<{posted: boolean, reason: string, skipped?: string, error?: string}>}
+ */
+export const reportAutoMergeBlockedByIssue = async ({ owner, repo, prNumber, issueNumber, mergeBlockers, verbose = false, commandRunner = $ }) => {
+  const blockers = (mergeBlockers || []).filter(Boolean);
+  if (blockers.length === 0) {
+    return { posted: false, reason: 'no_blockers', skipped: 'no_blockers' };
+  }
+
+  await log('');
+  await log(formatAligned('⚠️', 'AUTO-MERGE HELD BACK:', blockers.map(b => b.message).join('; '), 2), { level: 'warning' });
+  for (const blocker of blockers) {
+    if (blocker.resolution) {
+      await log(formatAligned('', 'Action:', blocker.resolution, 4), { level: 'warning' });
+    }
+  }
+
+  return reportAutomationStop({
+    $: commandRunner,
+    owner,
+    repo,
+    targetNumber: prNumber,
+    reason: blockers[0].reason,
+    mode: 'auto-merge',
+    verbose,
+    log,
+    body: buildAutoMergeBlockedComment({ blockers, issueNumber }),
+    signature: AUTO_MERGE_BLOCKED_MARKER,
+  });
+};
+
+/**
+ * Attempt to auto-merge a PR after the session ends.
+ * Implements the one-shot `--auto-merge` path.
+ */
+export const attemptAutoMerge = async params => {
+  const { owner, repo, prNumber, issueNumber = null, argv } = params;
+
+  await log('');
+  await log(formatAligned('🔀', 'AUTO-MERGE:', 'Checking if PR can be merged...'));
+
+  const terminalState = await checkGitHubTerminalState({
+    owner,
+    repo,
+    issueNumber,
+    prNumber,
+    commandRunner: quietProbe($),
+  });
+  if (terminalState.terminal) {
+    if (terminalState.success) {
+      await log(formatAligned('🎉', 'PR already merged:', `#${prNumber}`, 2));
+      return { success: true, reason: 'merged' };
+    }
+    await log(formatAligned('❌', 'GITHUB TARGET UNAVAILABLE:', terminalState.message, 2), { level: 'error' });
+    for (const detail of terminalState.details || []) {
+      await log(formatAligned('', 'Detail:', detail, 4), { level: 'error' });
+    }
+    // Issue #2144: never stop silently — publish the exact reason.
+    await reportAutomationStop({
+      $,
+      owner,
+      repo,
+      targetNumber: prNumber,
+      reason: terminalState.reason,
+      mode: 'auto-merge',
+      message: terminalState.message,
+      details: terminalState.details,
+      verbose: argv.verbose,
+      log,
+    });
+    return { success: false, reason: terminalState.reason, error: terminalState.message };
+  }
+
+  // Issue #2144: a closed/unavailable linked issue blocks only the merge step.
+  const issueMergeBlockers = terminalState.mergeBlockers || [];
+
+  // Issue #1226: Check merge permissions before attempting
+  const { canMerge, permission } = await checkMergePermissions(owner, repo, argv.verbose);
+  if (!canMerge) {
+    await log(formatAligned('⚠️', 'Cannot merge:', `Insufficient permissions (${permission || 'unknown'})`, 2));
+    return { success: false, reason: 'insufficient_permissions', error: `User has ${permission || 'unknown'} access, needs push/maintain/admin` };
+  }
+
+  // Wait for CI to complete (with timeout)
+  const ciWaitResult = await waitForCI(
+    owner,
+    repo,
+    prNumber,
+    {
+      timeout: argv.autoMergeCiTimeout || 30 * 60 * 1000, // 30 minutes default
+      pollInterval: argv.autoMergeCiPollInterval || 30 * 1000, // 30 seconds default
+      onStatusUpdate: async status => {
+        if (argv.verbose) {
+          await log(`   CI status: ${status.status}`, { verbose: true });
+        }
+      },
+    },
+    argv.verbose
+  );
+
+  if (!ciWaitResult.success) {
+    await log(formatAligned('⚠️', 'CI check failed or timed out:', ciWaitResult.error || ciWaitResult.status, 2));
+    return { success: false, reason: ciWaitResult.status, error: ciWaitResult.error };
+  }
+
+  await log(formatAligned('✅', 'CI checks passed:', 'Checking mergeability...', 2));
+
+  // Check if PR is mergeable
+  const mergeStatus = await checkPRMergeable(owner, repo, prNumber, argv.verbose);
+  if (mergeStatus.terminal) {
+    await log(formatAligned('❌', 'GITHUB TARGET UNAVAILABLE:', mergeStatus.reason || 'GitHub repository, pull request, issue, or branch is no longer accessible', 2), { level: 'error' });
+    await reportAutomationStop({
+      $,
+      owner,
+      repo,
+      targetNumber: prNumber,
+      reason: 'terminal_github_entity_error',
+      mode: 'auto-merge',
+      message: mergeStatus.reason,
+      verbose: argv.verbose,
+      log,
+    });
+    return { success: false, reason: 'terminal_github_entity_error', error: mergeStatus.reason };
+  }
+
+  if (!mergeStatus.mergeable) {
+    await log(formatAligned('⚠️', 'PR not mergeable:', mergeStatus.reason || 'Unknown reason', 2));
+    return { success: false, reason: 'not_mergeable', error: mergeStatus.reason };
+  }
+
+  // Issue #2144: the pull request is ready. If the linked issue is closed or
+  // gone, do not merge automatically — ask the user to reopen it or merge
+  // manually, and say so on the pull request.
+  if (issueMergeBlockers.length > 0) {
+    await reportAutoMergeBlockedByIssue({ owner, repo, prNumber, issueNumber, mergeBlockers: issueMergeBlockers, verbose: argv.verbose });
+    return { success: false, reason: issueMergeBlockers[0].reason, error: issueMergeBlockers[0].message, mergeBlockers: issueMergeBlockers };
+  }
+
+  await log(formatAligned('✅', 'PR is mergeable:', 'Attempting to merge...', 2));
+
+  // Attempt to merge
+  const deleteAfterMerge = shouldDeleteBranchAfterMerge(argv);
+  if (deleteAfterMerge) {
+    await log(formatAligned('', 'Branch cleanup:', 'will delete branch after successful merge', 2));
+  }
+  const mergeResult = await mergePullRequest(owner, repo, prNumber, { squash: argv.squash || false, deleteAfter: deleteAfterMerge }, argv.verbose);
+
+  if (mergeResult.success) {
+    await log(formatAligned('🎉', 'PR MERGED SUCCESSFULLY!', ''));
+
+    // Post success comment
+    try {
+      const commentBody = `## 🎉 ${AUTO_MERGED_MARKER}\n\nThis pull request has been automatically merged by hive-mind after all CI checks passed and the PR became mergeable.\n\n---\n*Auto-merged by hive-mind with --auto-merge flag*`;
+      await postTrackedComment({ $, owner, repo, targetNumber: prNumber, body: commentBody });
+    } catch {
+      // Don't fail if comment posting fails
+    }
+
+    // Issue #1895: close linked issue explicitly when GitHub will not (non-default base branch).
+    try {
+      const closeResult = await ensureLinkedIssueClosedAfterMerge({ $, log, owner, repo, prNumber, issueNumber, verbose: argv.verbose });
+      if (!closeResult.closed && !closeResult.skipped) {
+        await log(formatAligned('⚠️', 'Issue auto-close:', `could not close linked issue (${closeResult.reason})`, 2), { level: 'warning' });
+      }
+    } catch (closeError) {
+      await log(formatAligned('⚠️', 'Issue auto-close:', `error: ${closeError.message}`, 2), { level: 'warning' });
+    }
+
+    return { success: true, reason: 'merged' };
+  } else {
+    await log(formatAligned('⚠️', 'Merge failed:', mergeResult.error || 'Unknown error', 2));
+    await reportAutomationStop({
+      $,
+      owner,
+      repo,
+      targetNumber: prNumber,
+      reason: 'merge_failed',
+      mode: 'auto-merge',
+      message: mergeResult.error || 'GitHub rejected the merge request.',
+      verbose: argv.verbose,
+      log,
+    });
+    return { success: false, reason: 'merge_failed', error: mergeResult.error };
+  }
+};
+
+export default {
+  attemptAutoMerge,
+  reportAutoMergeBlockedByIssue,
+};

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

@@ -35,7 +35,7 @@ const { reportError } = sentryLib;
 
 // Import GitHub merge functions
 const githubMergeLib = await import('./github-merge.lib.mjs');
-const { checkPRMergeable, checkMergePermissions, mergePullRequest, waitForCI, getRepoVisibility, BILLING_LIMIT_ERROR_PATTERN, getDetailedCIStatus, rerunWorkflowRun, getWorkflowRunsForSha, getAllActiveRepoRuns, checkCIConsensus } = githubMergeLib;
+const { checkMergePermissions, mergePullRequest, getRepoVisibility, BILLING_LIMIT_ERROR_PATTERN, getDetailedCIStatus, rerunWorkflowRun, getWorkflowRunsForSha, getAllActiveRepoRuns, checkCIConsensus } = githubMergeLib;
 
 // Import GitHub functions for log attachment
 const githubLib = await import('./github.lib.mjs');
@@ -50,6 +50,18 @@ const { checkForUncommittedChanges, getUncommittedChangesDetails, executeToolIte
 const terminalStateLib = await import('./github-terminal-state.lib.mjs');
 const { checkGitHubTerminalState } = terminalStateLib;
 
+// Issue #2144: these probes answer with a ~33 KB pull request object and a full
+// issue object on every iteration. Issue #2130 made the helper's own default
+// runner quiet, but passing `$` here bypassed it and the payloads were still
+// mirrored into the attached log. Bind the quiet options to the injected `$`.
+const { quietProbe } = await import('./quiet-probe.lib.mjs');
+
+// Issue #2144: a closed linked issue is NOT terminal — it only blocks the final
+// automatic merge. Every stop of this loop is also published as a GitHub comment
+// stating exactly why it stopped.
+const stopReportingLib = await import('./automation-stop-reporting.lib.mjs');
+const { reportAutomationStop } = stopReportingLib;
+
 // Import validation functions for time parsing (used for usage limit wait)
 const validation = await import('./solve.validation.lib.mjs');
 const { calculateWaitTime } = validation;
@@ -184,7 +196,7 @@ export const watchUntilMergeable = async params => {
       issueNumber,
       prNumber,
       sourceBranchName: prBranch || branchName,
-      commandRunner: $,
+      commandRunner: quietProbe($),
     });
     if (terminalState.terminal && terminalState.success) {
       await log('');
@@ -201,9 +213,20 @@ export const watchUntilMergeable = async params => {
       }
       await log(formatAligned('', 'Action:', 'Stopping auto-restart-until-mergeable mode', 2), { level: 'error' });
       await log('');
+      // Issue #2144: report the stop on GitHub instead of exiting silently.
+      await reportAutomationStop({ $, owner, repo, targetNumber: prNumber, reason: terminalState.reason, mode: 'auto-restart-until-mergeable', message: terminalState.message, details: terminalState.details, verbose: argv.verbose, log });
       return { success: false, reason: terminalState.reason, latestSessionId, latestAnthropicCost };
     }
 
+    // Issue #2144: issue-scoped problems (closed / deleted linked issue) never
+    // stop this loop. They are carried to the merge decision below.
+    const issueMergeBlockers = terminalState.mergeBlockers || [];
+    if (issueMergeBlockers.length > 0 && iteration === 1) {
+      for (const blocker of issueMergeBlockers) {
+        await log(formatAligned('⚠️', 'Linked issue:', `${blocker.message} Continuing to make the pull request mergeable.`, 2), { level: 'warning' });
+      }
+    }
+
     await log(formatAligned('🔍', `Check #${iteration}:`, currentTime.toLocaleTimeString()));
 
     try {
@@ -243,6 +266,7 @@ export const watchUntilMergeable = async params => {
         }
         await log(formatAligned('', 'Action:', 'Stopping auto-restart-until-mergeable mode', 2), { level: 'error' });
         await log('');
+        await reportAutomationStop({ $, owner, repo, targetNumber: prNumber, reason: 'terminal_github_entity_error', mode: 'auto-restart-until-mergeable', message: terminalGitHubBlocker.message, details: terminalGitHubBlocker.details, verbose: argv.verbose, log });
         return { success: false, reason: 'terminal_github_entity_error', latestSessionId, latestAnthropicCost };
       }
 
@@ -356,6 +380,15 @@ export const watchUntilMergeable = async params => {
 
         await log(formatAligned('✅', 'PR IS MERGEABLE!', ''));
 
+        // Issue #2144: the pull request is ready. A closed/unavailable linked
+        // issue blocks only the *automatic* merge — the loop already did its
+        // job of making the pull request mergeable. Ask the user to reopen the
+        // issue or merge manually instead of merging behind their back.
+        if (isAutoMerge && issueMergeBlockers.length > 0) {
+          await reportAutoMergeBlockedByIssue({ owner, repo, prNumber, issueNumber, mergeBlockers: issueMergeBlockers, verbose: argv.verbose });
+          return { success: false, reason: issueMergeBlockers[0].reason, mergeBlockers: issueMergeBlockers, latestSessionId, latestAnthropicCost };
+        }
+
         if (isAutoMerge) {
           // Attempt to merge the PR
           await log(formatAligned('🔀', 'Auto-merging PR...', ''));
@@ -424,7 +457,17 @@ export const watchUntilMergeable = async params => {
               } else {
                 // Issue #1345: Differentiate message when no CI is configured
                 const ciLine = noCiConfigured ? '- No CI/CD checks are configured for this repository' : noCiTriggered ? (workflowRunConclusions ? `- CI workflows completed without executing (${workflowRunConclusions})` : '- CI workflows exist but were not triggered for this commit') : '- All CI checks have passed';
-                const commentBody = `## ✅ ${READY_TO_MERGE_MARKER}\n\nThis pull request is now ready to be merged:\n${ciLine}\n- No merge conflicts\n- No pending changes\n\n---\n*Monitored by hive-mind with --auto-restart-until-mergeable flag*`;
+                // Issue #2144: a closed/unavailable linked issue does not stop this
+                // mode, but it is worth stating in the comment so the reader knows
+                // why no automatic merge will follow.
+                const issueLine =
+                  issueMergeBlockers.length > 0
+                    ? `\n\nNote: ${issueMergeBlockers.map(b => b.message).join(' ')} ${issueMergeBlockers
+                        .map(b => b.resolution)
+                        .filter(Boolean)
+                        .join(' ')}`
+                    : '';
+                const commentBody = `## ✅ ${READY_TO_MERGE_MARKER}\n\nThis pull request is now ready to be merged:\n${ciLine}\n- No merge conflicts\n- No pending changes${issueLine}\n\n---\n*Monitored by hive-mind with --auto-restart-until-mergeable flag*`;
                 // Issue #1625: Track this comment ID so it can't falsely count as an AI-authored comment
                 await postTrackedComment({ $, owner, repo, targetNumber: prNumber, body: commentBody });
                 readyToMergeCommentPosted = true;
@@ -838,6 +881,8 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
               await log(formatAligned('⚠️', 'AUTO-RESUME LIMIT REACHED', `Stopping after ${limitResumeCount} limit-reset continuation${limitResumeCount !== 1 ? 's' : ''}`));
               await log(formatAligned('', 'Configured limit:', formatAutoIterationLimit(maxAutoResumeIterations), 2));
               await log('');
+              // Issue #2144: publish why the automation stopped.
+              await reportAutomationStop({ $, owner, repo, targetNumber: prNumber, reason: 'auto_resume_limit_reached', mode: 'auto-restart-until-mergeable', message: `Stopped after ${limitResumeCount} usage-limit continuation${limitResumeCount !== 1 ? 's' : ''} (limit: ${formatAutoIterationLimit(maxAutoResumeIterations)}).`, verbose: argv.verbose, log });
               return { success: false, reason: 'auto_resume_limit_reached', latestSessionId, latestAnthropicCost };
             }
 
@@ -991,6 +1036,7 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
                     await log(formatAligned('', `⚠️  Failure log upload error: ${cleanErrorMessage(logUploadError)}`, '', 2));
                   }
                 }
+                await reportAutomationStop({ $, owner, repo, targetNumber: prNumber, reason: 'tool_failure_after_resume', mode: 'auto-restart-until-mergeable', message: extractToolErrorCore({ toolResult: resumeResult }) || formatToolExecutionFailure({ tool: argv.tool, toolResult: resumeResult }), verbose: argv.verbose, log });
                 return { success: false, reason: 'tool_failure_after_resume', latestSessionId, latestAnthropicCost };
               }
             } else {
@@ -1043,6 +1089,7 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
               await log(formatAligned('', `⚠️  Failure log upload error: ${cleanErrorMessage(logUploadError)}`, '', 2));
             }
           }
+          await reportAutomationStop({ $, owner, repo, targetNumber: prNumber, reason: 'tool_failure', mode: 'auto-restart-until-mergeable', message: extractToolErrorCore({ toolResult }) || formatToolExecutionFailure({ tool: argv.tool, toolResult }), verbose: argv.verbose, log });
           return { success: false, reason: 'tool_failure', latestSessionId, latestAnthropicCost };
         } else {
           // Success - capture latest session data
@@ -1279,114 +1326,10 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
   }
 };
 
-/**
- * Attempt to auto-merge PR after session ends
- * This implements the --auto-merge functionality for one-shot merge attempts
- */
-export const attemptAutoMerge = async params => {
-  const { owner, repo, prNumber, issueNumber = null, argv } = params;
-
-  await log('');
-  await log(formatAligned('🔀', 'AUTO-MERGE:', 'Checking if PR can be merged...'));
-
-  const terminalState = await checkGitHubTerminalState({
-    owner,
-    repo,
-    issueNumber,
-    prNumber,
-    commandRunner: $,
-  });
-  if (terminalState.terminal) {
-    if (terminalState.success) {
-      await log(formatAligned('🎉', 'PR already merged:', `#${prNumber}`, 2));
-      return { success: true, reason: 'merged' };
-    }
-    await log(formatAligned('❌', 'GITHUB TARGET UNAVAILABLE:', terminalState.message, 2), { level: 'error' });
-    for (const detail of terminalState.details || []) {
-      await log(formatAligned('', 'Detail:', detail, 4), { level: 'error' });
-    }
-    return { success: false, reason: terminalState.reason, error: terminalState.message };
-  }
-
-  // Issue #1226: Check merge permissions before attempting
-  const { canMerge, permission } = await checkMergePermissions(owner, repo, argv.verbose);
-  if (!canMerge) {
-    await log(formatAligned('⚠️', 'Cannot merge:', `Insufficient permissions (${permission || 'unknown'})`, 2));
-    return { success: false, reason: 'insufficient_permissions', error: `User has ${permission || 'unknown'} access, needs push/maintain/admin` };
-  }
-
-  // Wait for CI to complete (with timeout)
-  const ciWaitResult = await waitForCI(
-    owner,
-    repo,
-    prNumber,
-    {
-      timeout: argv.autoMergeCiTimeout || 30 * 60 * 1000, // 30 minutes default
-      pollInterval: argv.autoMergeCiPollInterval || 30 * 1000, // 30 seconds default
-      onStatusUpdate: async status => {
-        if (argv.verbose) {
-          await log(`   CI status: ${status.status}`, { verbose: true });
-        }
-      },
-    },
-    argv.verbose
-  );
-
-  if (!ciWaitResult.success) {
-    await log(formatAligned('⚠️', 'CI check failed or timed out:', ciWaitResult.error || ciWaitResult.status, 2));
-    return { success: false, reason: ciWaitResult.status, error: ciWaitResult.error };
-  }
-
-  await log(formatAligned('✅', 'CI checks passed:', 'Checking mergeability...', 2));
-
-  // Check if PR is mergeable
-  const mergeStatus = await checkPRMergeable(owner, repo, prNumber, argv.verbose);
-  if (mergeStatus.terminal) {
-    await log(formatAligned('❌', 'GITHUB TARGET UNAVAILABLE:', mergeStatus.reason || 'GitHub repository, pull request, issue, or branch is no longer accessible', 2), { level: 'error' });
-    return { success: false, reason: 'terminal_github_entity_error', error: mergeStatus.reason };
-  }
-
-  if (!mergeStatus.mergeable) {
-    await log(formatAligned('⚠️', 'PR not mergeable:', mergeStatus.reason || 'Unknown reason', 2));
-    return { success: false, reason: 'not_mergeable', error: mergeStatus.reason };
-  }
-
-  await log(formatAligned('✅', 'PR is mergeable:', 'Attempting to merge...', 2));
-
-  // Attempt to merge
-  const deleteAfterMerge = shouldDeleteBranchAfterMerge(argv);
-  if (deleteAfterMerge) {
-    await log(formatAligned('', 'Branch cleanup:', 'will delete branch after successful merge', 2));
-  }
-  const mergeResult = await mergePullRequest(owner, repo, prNumber, { squash: argv.squash || false, deleteAfter: deleteAfterMerge }, argv.verbose);
-
-  if (mergeResult.success) {
-    await log(formatAligned('🎉', 'PR MERGED SUCCESSFULLY!', ''));
-
-    // Post success comment
-    try {
-      const commentBody = `## 🎉 ${AUTO_MERGED_MARKER}\n\nThis pull request has been automatically merged by hive-mind after all CI checks passed and the PR became mergeable.\n\n---\n*Auto-merged by hive-mind with --auto-merge flag*`;
-      await postTrackedComment({ $, owner, repo, targetNumber: prNumber, body: commentBody });
-    } catch {
-      // Don't fail if comment posting fails
-    }
-
-    // Issue #1895: close linked issue explicitly when GitHub will not (non-default base branch).
-    try {
-      const closeResult = await ensureLinkedIssueClosedAfterMerge({ $, log, owner, repo, prNumber, issueNumber, verbose: argv.verbose });
-      if (!closeResult.closed && !closeResult.skipped) {
-        await log(formatAligned('⚠️', 'Issue auto-close:', `could not close linked issue (${closeResult.reason})`, 2), { level: 'warning' });
-      }
-    } catch (closeError) {
-      await log(formatAligned('⚠️', 'Issue auto-close:', `error: ${closeError.message}`, 2), { level: 'warning' });
-    }
-
-    return { success: true, reason: 'merged' };
-  } else {
-    await log(formatAligned('⚠️', 'Merge failed:', mergeResult.error || 'Unknown error', 2));
-    return { success: false, reason: 'merge_failed', error: mergeResult.error };
-  }
-};
+// Issue #2144: the one-shot `--auto-merge` attempt moved to its own module so
+// both files stay under the 1500-line limit. Re-exported for API compatibility.
+const autoMergeAttempt = await import('./solve.auto-merge-attempt.lib.mjs');
+export const { attemptAutoMerge, reportAutoMergeBlockedByIssue } = autoMergeAttempt;
 
 /**
  * Start auto-restart-until-mergeable mode

package/src/solve.results.lib.mjs

@@ -68,7 +68,7 @@ const { buildIssueReference, ensureIssueLinkInPullRequestBody } = prIssueLinking
 
 // Issue #2119: the one place that decides whether a pull request changed anything.
 const { formatChangeSummary, getPullRequestChangeStats } = await import('./pull-request-changes.lib.mjs');
-const { buildNoChangesNotice, redactWorkspacePaths } = await import('./working-session-summary.lib.mjs');
+const { buildNoChangesNotice, formatWorkingSessionSummaryMarkdown, redactWorkspacePaths } = await import('./working-session-summary.lib.mjs');
 
 /**
  * Placeholder patterns used to detect auto-generated PR content that was not updated by the agent.
@@ -1309,7 +1309,7 @@ export const attachSolutionSummary = async ({ resultSummary, prNumber, issueNumb
     // summary said "The `pwd` command completed" and printed the solver's own
     // /tmp workspace, on a pull request that was still empty.
     const noChangesNotice = buildNoChangesNotice(changeStats);
-    const summaryBody = redactWorkspacePaths(resultSummary);
+    const summaryBody = formatWorkingSessionSummaryMarkdown(redactWorkspacePaths(resultSummary));
 
     const comment = `${toolComments.WORKING_SESSION_SUMMARY_AUTOMATION_MARKER}
 ## ${toolComments.WORKING_SESSION_SUMMARY_MARKER}

package/src/solve.watch.lib.mjs

@@ -44,6 +44,18 @@ const { checkPRMerged, checkForUncommittedChanges, getUncommittedChangesDetails,
 const terminalStateLib = await import('./github-terminal-state.lib.mjs');
 const { checkGitHubTerminalState } = terminalStateLib;
 
+// Issue #2144: these probes answer with a ~33 KB pull request object and a full
+// issue object on every iteration. Issue #2130 made the helper's own default
+// runner quiet, but passing `$` here bypassed it and the payloads were still
+// mirrored into the attached log. Bind the quiet options to the injected `$`.
+const { quietProbe } = await import('./quiet-probe.lib.mjs');
+
+// Issue #2144: watch mode must never exit silently — every stop is published as
+// a GitHub comment naming the exact reason. A closed linked issue is not a stop
+// condition here at all.
+const stopReportingLib = await import('./automation-stop-reporting.lib.mjs');
+const { reportAutomationStop } = stopReportingLib;
+
 // Issue #1574: Interruptible sleep so CTRL+C is never blocked by a lingering timer
 const { interruptibleSleep } = await import('./interruptible-sleep.lib.mjs');
 // Issue #2119: one auto-restart budget shared with solve.auto-merge.lib.mjs, so
@@ -142,7 +154,7 @@ export const watchForFeedback = async params => {
       issueNumber,
       prNumber,
       sourceBranchName: prBranch || branchName,
-      commandRunner: $,
+      commandRunner: quietProbe($),
     });
     if (terminalState.terminal && !terminalState.success) {
       await log('');
@@ -152,9 +164,19 @@ export const watchForFeedback = async params => {
       }
       await log(formatAligned('', 'Action:', 'Stopping watch mode', 2), { level: 'error' });
       await log('');
+      // Issue #2144: report the stop on GitHub instead of exiting silently.
+      await reportAutomationStop({ $, owner, repo, targetNumber: prNumber, reason: terminalState.reason, mode: 'watch', message: terminalState.message, details: terminalState.details, verbose: argv.verbose, log });
       break;
     }
 
+    // Issue #2144: issue-scoped problems (closed / deleted linked issue) are not
+    // watch-mode stop conditions; the loop keeps working on the pull request.
+    if ((terminalState.mergeBlockers || []).length > 0 && iteration === 1) {
+      for (const blocker of terminalState.mergeBlockers) {
+        await log(formatAligned('⚠️', 'Linked issue:', `${blocker.message} Watch mode continues.`, 2), { level: 'warning' });
+      }
+    }
+
     // Check if PR is merged
     const isMerged = terminalState.terminal && terminalState.success ? true : await checkPRMerged(owner, repo, prNumber);
     if (isMerged) {
@@ -472,6 +494,18 @@ export const watchForFeedback = async params => {
               await log('  2. You have proper authentication configured');
               await log('  3. The API endpoint is accessible');
               await log('');
+              // Issue #2144: say on GitHub why the loop stopped.
+              await reportAutomationStop({
+                $,
+                owner,
+                repo,
+                targetNumber: prNumber,
+                reason: 'tool_failure',
+                mode: 'watch',
+                message: `${argv.tool.toUpperCase()} failed ${consecutiveApiErrors} times in a row: ${extractToolErrorCore({ toolResult }) || 'unknown API error'}`,
+                verbose: argv.verbose,
+                log,
+              });
               break; // Exit the watch loop
             }