@link-assistant/hive-mind 2.11.12 → 2.11.13

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # @link-assistant/hive-mind
 
+## 2.11.13
+
+### Patch Changes
+
+- 61f20ce: Closed issues no longer stop the mergeable loop, and every stop is now explained
+  in a GitHub comment (issue #2144).
+
+  A `solve …/pull/927 --auto-merge` run stopped after its first monitoring
+  iteration with `❌ GITHUB TARGET UNAVAILABLE: Issue #905 has been closed.` — in
+  the _same_ probe that reported the pull request as `"mergeable": true,
+"mergeable_state": "clean"`. Nothing was posted to GitHub and the process exited
+  `0`, so the run looked successful while the pull request sat unmerged until a
+  human merged it manually two hours later.
+
+  - `src/github-terminal-state.lib.mjs` now distinguishes _terminal_ states from
+    _merge blockers_. A closed or deleted **issue** is a merge blocker: the loop
+    keeps working to make the pull request mergeable. Only the pull request being
+    merged, closed or unreachable — or the repository/branches it needs being gone
+    — stops the loop.
+  - A closed issue holds back `--auto-merge` only. When it does, the tool comments
+    that the pull request is ready and asks the user to reopen the issue or merge
+    manually, instead of stopping silently.
+  - New `src/automation-stop-reporting.lib.mjs`: a registry of 13 stop reasons,
+    each with a title, an explanation and concrete next steps, plus a deduped,
+    never-throwing reporter. It is wired into all 11 stop paths of
+    `--auto-merge`, `--auto-restart-until-mergeable` and `--watch`. Unknown reason
+    codes degrade to a generic comment, so a new stop can never regress to
+    silence.
+  - `attemptAutoMerge` was extracted into
+    `src/solve.auto-merge-attempt.lib.mjs` to stay within the repository's
+    file-length policy.
+  - Fixed a second defect found in the same log: the quiet GitHub probes from
+    issue #2130 were silently defeated because all three callers injected their own
+    mirroring `$`, so ~33 KB of pull request JSON plus the full issue payload were
+    written to the attached log on every iteration. They now pass
+    `quietProbe($)`, with a regression test.
+
+  Timeline, requirement inventory, root causes, edge cases and the codebase sweep:
+  `docs/case-studies/issue-2144/README.md`. Reproduction:
+  `experiments/issue-2144/repro-closed-issue-stops-loop.mjs`.
+
 ## 2.11.12
 
 ### Patch Changes

package/package.json

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

package/src/automation-stop-reporting.lib.mjs

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+
+/**
+ * Announce on GitHub *why* a long-running automation loop stopped.
+ *
+ * Issue #2144: `--auto-restart-until-mergeable` and `--watch` used to exit
+ * silently on several paths (terminal GitHub entity states, tool execution
+ * failures, auto-resume limit). The reported incident stopped the loop on an
+ * open, mergeable pull request because its linked issue was closed, and left
+ * no GitHub comment at all — from the pull request's point of view the
+ * automation simply vanished.
+ *
+ * Two things live here:
+ *   1. A registry that turns an internal stop reason into human-readable text
+ *      (what happened, what it means, what the user should do next).
+ *   2. `reportAutomationStop`, which posts that text as a deduplicated,
+ *      tracked tool comment. Every stop path calls it, so "we stopped and
+ *      exactly why" is always published.
+ *
+ * The module is intentionally free of top-level `command-stream` /`use-m`
+ * imports: the comment builders are pure functions and can be unit-tested
+ * without a GitHub environment. The `$` helper is passed in by callers.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/2144
+ */
+
+import { AUTOMATION_STOPPED_MARKER, AUTO_MERGE_BLOCKED_MARKER, postTrackedComment } from './tool-comments.lib.mjs';
+
+export { AUTOMATION_STOPPED_MARKER, AUTO_MERGE_BLOCKED_MARKER };
+
+/**
+ * Human-readable descriptions for every stop reason the solver can return.
+ *
+ * `canComment: false` marks reasons where the comment target itself is gone
+ * (deleted repository / pull request), so posting is skipped instead of
+ * producing a guaranteed API failure.
+ */
+export const STOP_REASONS = {
+  pull_request_closed: {
+    title: 'the pull request was closed without merging',
+    detail: 'A closed pull request can never become mergeable, so continuing to work on it would be pointless.',
+    nextSteps: ['Reopen the pull request and re-run the command to continue.'],
+  },
+  pull_request_unavailable: {
+    title: 'the pull request is no longer accessible',
+    detail: 'GitHub answered with 404/410 for this pull request (deleted, transferred, or access revoked).',
+    nextSteps: ['Verify the pull request still exists and that the token has access to it.'],
+    canComment: false,
+  },
+  repository_unavailable: {
+    title: 'the repository is no longer accessible',
+    detail: 'GitHub answered with 404/410 for the repository (deleted, renamed, made private, or access revoked).',
+    nextSteps: ['Verify the repository still exists and that the token has access to it.'],
+    canComment: false,
+  },
+  source_branch_unavailable: {
+    title: 'the source branch of the pull request is gone',
+    detail: 'The head branch (or its repository) is no longer accessible, so no further commits can be pushed to this pull request.',
+    nextSteps: ['Restore the source branch, or open a new pull request from a branch that still exists.'],
+  },
+  target_branch_unavailable: {
+    title: 'the target branch of the pull request is gone',
+    detail: 'The base branch (or its repository) is no longer accessible, so this pull request can never be merged as-is.',
+    nextSteps: ['Restore the base branch, or retarget this pull request to an existing branch.'],
+  },
+  terminal_github_entity_error: {
+    title: 'a GitHub entity required by this automation is no longer accessible',
+    detail: 'A repository, pull request, or branch answered with 404/410 while checking CI status.',
+    nextSteps: ['Verify the repository, pull request, and branches still exist and that the token has access to them.'],
+  },
+  auto_resume_limit_reached: {
+    title: 'the usage-limit auto-resume budget was exhausted',
+    detail: 'The AI session hit provider usage limits more times than `--auto-resume-max-iterations` allows.',
+    nextSteps: ['Re-run the command after the usage limit resets, or raise `--auto-resume-max-iterations`.'],
+  },
+  tool_failure: {
+    title: 'the AI session failed',
+    detail: 'The AI tool exited with an error that is not a usage limit, so restarting it automatically would most likely fail the same way.',
+    nextSteps: ['Review the attached working session log for the failure, fix the cause, and re-run the command.'],
+  },
+  tool_failure_after_resume: {
+    title: 'the AI session failed after resuming from a usage limit',
+    detail: 'The session was resumed once the usage limit reset, but the resumed run exited with an error.',
+    nextSteps: ['Review the attached working session log for the failure, fix the cause, and re-run the command.'],
+  },
+  merge_failed: {
+    title: 'GitHub refused the merge',
+    detail: 'Every merge requirement was satisfied, but the merge API call itself failed (branch protection, required reviews, or a race with another push).',
+    nextSteps: ['Check the branch protection rules and required reviews, then merge manually or re-run the command.'],
+  },
+  issue_closed: {
+    title: 'the linked issue is closed, so auto-merge was held back',
+    detail: 'The pull request is ready to merge. A closed issue never stops work on the pull request — it only blocks the automatic merge.',
+    nextSteps: ['Reopen the linked issue and re-run the command so auto-merge can complete.', 'Or merge this pull request manually — it is ready.'],
+  },
+  issue_unavailable: {
+    title: 'the linked issue is no longer accessible, so auto-merge was held back',
+    detail: 'The pull request is ready to merge. A missing issue never stops work on the pull request — it only blocks the automatic merge.',
+    nextSteps: ['Restore or re-create the linked issue and re-run the command so auto-merge can complete.', 'Or merge this pull request manually — it is ready.'],
+  },
+  watch_stopped: {
+    title: 'watch mode stopped',
+    detail: 'The watch loop reached a state where it can no longer make progress.',
+    nextSteps: ['Re-run the command once the reported condition is resolved.'],
+  },
+};
+
+const MODE_LABELS = {
+  'auto-restart-until-mergeable': '`--auto-restart-until-mergeable`',
+  'auto-merge': '`--auto-merge`',
+  watch: '`--watch`',
+};
+
+/**
+ * Resolve a stop reason to its description, with a safe fallback so an unknown
+ * or newly added reason is still reported (never silently swallowed).
+ *
+ * @param {string} reason
+ * @returns {{reason: string, title: string, detail: string, nextSteps: string[], canComment: boolean, known: boolean}}
+ */
+export const describeStopReason = reason => {
+  const key = String(reason || 'unknown');
+  const known = Object.prototype.hasOwnProperty.call(STOP_REASONS, key);
+  const entry = known ? STOP_REASONS[key] : null;
+  return {
+    reason: key,
+    title: entry?.title || `the automation stopped with reason \`${key}\``,
+    detail: entry?.detail || 'No further automatic progress is possible in this state.',
+    nextSteps: entry?.nextSteps || ['Review the working session log, resolve the reported condition, and re-run the command.'],
+    canComment: entry?.canComment !== false,
+    known,
+  };
+};
+
+const bulletList = lines =>
+  (lines || [])
+    .filter(Boolean)
+    .map(line => `- ${line}`)
+    .join('\n');
+
+/**
+ * Build the "automation stopped" comment body.
+ *
+ * @param {Object} options
+ * @param {string} options.reason internal stop reason
+ * @param {string} [options.mode] which loop stopped
+ * @param {string} [options.message] concrete message from the detector
+ * @param {string[]} [options.details] extra evidence lines
+ * @returns {string} markdown comment body
+ */
+export const buildAutomationStopComment = ({ reason, mode = null, message = null, details = [] }) => {
+  const description = describeStopReason(reason);
+  const modeLabel = MODE_LABELS[mode] || (mode ? `\`${mode}\`` : 'This automation');
+  const sections = [`## 🛑 ${AUTOMATION_STOPPED_MARKER}: ${description.title}`, '', `${modeLabel} stopped working on this pull request.`, '', `**Reason code:** \`${description.reason}\``];
+
+  if (message) {
+    sections.push('', `**What happened:** ${message}`);
+  }
+  sections.push('', description.detail);
+
+  const evidence = (details || []).filter(Boolean);
+  if (evidence.length > 0) {
+    sections.push('', '**Details:**', bulletList(evidence));
+  }
+
+  sections.push('', '**What to do next:**', bulletList(description.nextSteps));
+  sections.push('', '---', `*Reported automatically by hive-mind (${mode || 'automation'}).*`);
+
+  return sections.join('\n');
+};
+
+/**
+ * Build the comment posted when the pull request is ready but `--auto-merge`
+ * is blocked by the state of the linked issue.
+ *
+ * Issue #2144: a closed issue must never stop the loop from making the pull
+ * request mergeable — it only blocks the *automatic* merge, and then the user
+ * is asked to reopen the issue or merge manually.
+ *
+ * @param {Object} options
+ * @param {Array<{reason: string, message: string, resolution?: string, details?: string[]}>} options.blockers
+ * @param {number|string|null} [options.issueNumber]
+ * @returns {string} markdown comment body
+ */
+export const buildAutoMergeBlockedComment = ({ blockers = [], issueNumber = null }) => {
+  const reasons = blockers.filter(Boolean);
+  const sections = [`## ⚠️ ${AUTO_MERGE_BLOCKED_MARKER}: this pull request is ready, but it was not merged automatically`, '', 'All merge requirements are satisfied — CI passed, there are no conflicts, and there are no pending changes.', '', 'Auto-merge (`--auto-merge`) was requested but is being held back:'];
+
+  for (const blocker of reasons) {
+    sections.push('', `- **${blocker.message}** (\`${blocker.reason}\`)`);
+    for (const detail of blocker.details || []) {
+      sections.push(`  - ${detail}`);
+    }
+    if (blocker.resolution) {
+      sections.push(`  - ➡️ ${blocker.resolution}`);
+    }
+  }
+
+  sections.push('', '**What to do next:**');
+  sections.push(bulletList([issueNumber ? `Reopen issue #${issueNumber} and re-run the command so auto-merge can complete.` : 'Reopen the linked issue and re-run the command so auto-merge can complete.', 'Or merge this pull request manually — it is ready.']));
+  sections.push('', '---', '*Reported automatically by hive-mind with the --auto-merge flag.*');
+
+  return sections.join('\n');
+};
+
+/**
+ * Post a stop report to the pull request (or issue), deduplicated per reason.
+ *
+ * Never throws: a failed comment must not mask the stop itself.
+ *
+ * @param {Object} options
+ * @param {Function} options.$ command-stream tagged template
+ * @param {string} options.owner
+ * @param {string} options.repo
+ * @param {number|string} options.targetNumber pull request (or issue) number
+ * @param {string} options.reason
+ * @param {string} [options.mode]
+ * @param {string} [options.message]
+ * @param {string[]} [options.details]
+ * @param {boolean} [options.verbose]
+ * @param {Function} [options.log]
+ * @param {string} [options.body] pre-built body (skips buildAutomationStopComment)
+ * @param {string} [options.signature] pre-built dedup signature
+ * @returns {Promise<{posted: boolean, reason: string, skipped?: string, error?: string}>}
+ */
+export const reportAutomationStop = async ({ $, owner, repo, targetNumber, reason, mode = null, message = null, details = [], verbose = false, log = null, body = null, signature = null }) => {
+  const description = describeStopReason(reason);
+  const write = async text => {
+    if (typeof log === 'function') await log(text);
+  };
+
+  if (!$ || !owner || !repo || !targetNumber) {
+    return { posted: false, reason: description.reason, skipped: 'missing_target' };
+  }
+
+  if (!description.canComment) {
+    await write(`   ℹ️  Not posting a stop comment: ${description.title}`);
+    return { posted: false, reason: description.reason, skipped: 'target_unavailable' };
+  }
+
+  const commentBody = body || buildAutomationStopComment({ reason, mode, message, details });
+  const dedupSignature = signature || `${AUTOMATION_STOPPED_MARKER}: ${description.title}`;
+
+  try {
+    const { checkForExistingComment } = await import('./solve.auto-merge-helpers.lib.mjs');
+    const alreadyPosted = await checkForExistingComment(owner, repo, targetNumber, dedupSignature, verbose);
+    if (alreadyPosted) {
+      await write(`   ℹ️  Stop reason already reported on #${targetNumber} (${description.reason})`);
+      return { posted: false, reason: description.reason, skipped: 'duplicate' };
+    }
+
+    const result = await postTrackedComment({ $, owner, repo, targetNumber, body: commentBody });
+    if (!result.ok) {
+      await write(`   ⚠️  Could not post stop reason comment: ${result.stderr || 'unknown error'}`);
+      return { posted: false, reason: description.reason, error: result.stderr || 'post_failed' };
+    }
+
+    await write(`   💬 Posted stop reason to #${targetNumber}: ${description.title}`);
+    return { posted: true, reason: description.reason };
+  } catch (error) {
+    await write(`   ⚠️  Could not post stop reason comment: ${error.message}`);
+    return { posted: false, reason: description.reason, error: error.message };
+  }
+};
+
+export default {
+  STOP_REASONS,
+  describeStopReason,
+  buildAutomationStopComment,
+  buildAutoMergeBlockedComment,
+  reportAutomationStop,
+};

package/src/github-terminal-state.lib.mjs

@@ -4,11 +4,18 @@ import { ensureUseM } from './use-m-bootstrap.lib.mjs';
 /**
  * Detect terminal GitHub entity states for long-running watch/merge loops.
  *
- * These checks intentionally treat 404-style repository, PR, issue, and branch
+ * These checks intentionally treat 404-style repository, PR, and branch
  * responses as terminal. In a solver loop, deleted entities and lost access are
  * not transient CI states; retrying them indefinitely wastes time and tokens.
  *
+ * Issue #2144: the linked *issue* is deliberately NOT terminal. A closed or
+ * deleted issue does not stop the pull request from becoming mergeable, so the
+ * watch/auto-restart loop must keep working. Those states are reported as
+ * `mergeBlockers` instead: they only block the final automatic merge, and the
+ * caller asks the user to reopen the issue or merge manually.
+ *
  * @see https://github.com/link-assistant/hive-mind/issues/1931
+ * @see https://github.com/link-assistant/hive-mind/issues/2144
  */
 
 let defaultCommandRunner = null;
@@ -65,15 +72,31 @@ const terminal = ({ reason, message, details = [], success = false, data = null
   message,
   details,
   data,
+  mergeBlockers: [],
 });
 
-const ok = (data = {}) => ({
+const ok = (data = {}, mergeBlockers = []) => ({
   terminal: false,
   success: null,
   reason: null,
   message: null,
   details: [],
   data,
+  mergeBlockers,
+});
+
+/**
+ * Issue #2144: a non-terminal state that still prevents an *automatic* merge.
+ *
+ * The watch/auto-restart loop must keep making the pull request mergeable; only
+ * the final `--auto-merge` step is gated, and the user is asked to reopen the
+ * issue or merge manually.
+ */
+const mergeBlocker = ({ reason, message, details = [], resolution }) => ({
+  reason,
+  message,
+  details,
+  resolution,
 });
 
 const safeJsonParse = value => {
@@ -241,27 +264,41 @@ export const checkGitHubTerminalState = async ({ owner, repo, issueNumber = null
     if (targetBranchState.terminal) return targetBranchState;
   }
 
+  // Issue #2144: issue-scoped problems never stop the loop. They are collected
+  // as merge blockers so the pull request still gets made mergeable.
+  const mergeBlockers = [];
+
   if (issueNumber && String(issueNumber) !== String(prNumber)) {
     const issueResult = await runCommand(runner, ['gh api repos/', '/', '/issues/', ''], owner, repo, issueNumber);
     if (commandFailedTerminally(issueResult)) {
-      return terminal({
-        reason: 'issue_unavailable',
-        message: `Issue #${issueNumber} in ${owner}/${repo} is no longer accessible.`,
-        details: [getTerminalGitHubEntityErrorMessage(issueResult)],
-      });
+      mergeBlockers.push(
+        mergeBlocker({
+          reason: 'issue_unavailable',
+          message: `Issue #${issueNumber} in ${owner}/${repo} is no longer accessible.`,
+          details: [getTerminalGitHubEntityErrorMessage(issueResult)],
+          resolution: `Restore or re-create issue #${issueNumber}, or merge this pull request manually.`,
+        })
+      );
+      return ok({ repo: repoData }, mergeBlockers);
     }
 
     const issueData = safeJsonParse(issueResult.stdout);
     if (String(issueData?.state || '').toLowerCase() === 'closed') {
-      return terminal({
-        reason: 'issue_closed',
-        message: `Issue #${issueNumber} has been closed.`,
-        data: { issue: issueData, repo: repoData },
-      });
+      mergeBlockers.push(
+        mergeBlocker({
+          reason: 'issue_closed',
+          message: `Issue #${issueNumber} has been closed.`,
+          details: [],
+          resolution: `Reopen issue #${issueNumber} so auto-merge can complete, or merge this pull request manually.`,
+        })
+      );
+      return ok({ issue: issueData, repo: repoData }, mergeBlockers);
     }
+
+    return ok({ issue: issueData, repo: repoData }, mergeBlockers);
   }
 
-  return ok({ repo: repoData });
+  return ok({ repo: repoData }, mergeBlockers);
 };
 
 export default {

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.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
             }
 

package/src/tool-comments.lib.mjs

@@ -62,6 +62,17 @@ export const BILLING_LIMIT_MARKER = 'GitHub Actions Billing Limit';
 // solve.auto-merge.lib.mjs — cancelled/stale CI needs manual review
 export const CANCELLED_CI_REVIEW_MARKER = 'Cancelled CI/CD Requires Review';
 
+// automation-stop-reporting.lib.mjs — Issue #2144: every automation stop is
+// announced on GitHub with the exact reason. Before this, watch mode and
+// auto-restart-until-mergeable exited silently on terminal states and tool
+// failures, leaving the pull request with no explanation at all.
+export const AUTOMATION_STOPPED_MARKER = 'Automation stopped';
+
+// automation-stop-reporting.lib.mjs — Issue #2144: the pull request is
+// mergeable but `--auto-merge` cannot complete because the linked issue is
+// closed or unavailable. The user is asked to reopen it or merge manually.
+export const AUTO_MERGE_BLOCKED_MARKER = 'Auto-merge blocked';
+
 // solve.results.lib.mjs — working session summary comments posted by
 // --attach-solution-summary / --auto-attach-solution-summary at the end of
 // every working session (top-level solve, auto-restart-until-mergeable
@@ -111,7 +122,7 @@ export const USAGE_LIMIT_REACHED_MARKER = 'Usage Limit Reached';
  * named constants above so that adding a new marker only requires adding
  * the constant and appending it here.
  */
-export const TOOL_GENERATED_COMMENT_MARKERS = [AI_WORK_SESSION_STARTED_MARKER, AI_WORK_SESSION_COMPLETED_MARKER, AI_WORK_SESSION_RESUMED_MARKER, AUTO_RESUME_ON_LIMIT_RESET_MARKER, AUTO_RESTART_ON_LIMIT_RESET_MARKER, SOLUTION_DRAFT_LOG_MARKER, AUTO_RESTART_MARKER, AUTO_RESTART_UNTIL_MERGEABLE_LOG_MARKER, READY_TO_MERGE_MARKER, READY_FOR_REVIEW_MARKER, AUTO_MERGED_MARKER, BILLING_LIMIT_MARKER, CANCELLED_CI_REVIEW_MARKER, MAINTAINER_ACCESS_REQUEST_MARKER, LIVE_PROGRESS_SECTION_START_MARKER, SESSION_FORCE_KILLED_MARKER, REPOSITORY_INITIALIZATION_REQUIRED_MARKER, INTERACTIVE_SESSION_STARTED_MARKER, INTERACTIVE_SESSION_ENDED_MARKER, NOW_WORKING_SESSION_IS_ENDED_MARKER, SOLUTION_DRAFT_FAILED_MARKER, SOLUTION_DRAFT_FINISHED_WITH_ERRORS_MARKER, USAGE_LIMIT_REACHED_MARKER, WORKING_SESSION_SUMMARY_AUTOMATION_MARKER];
+export const TOOL_GENERATED_COMMENT_MARKERS = [AI_WORK_SESSION_STARTED_MARKER, AI_WORK_SESSION_COMPLETED_MARKER, AI_WORK_SESSION_RESUMED_MARKER, AUTO_RESUME_ON_LIMIT_RESET_MARKER, AUTO_RESTART_ON_LIMIT_RESET_MARKER, SOLUTION_DRAFT_LOG_MARKER, AUTO_RESTART_MARKER, AUTO_RESTART_UNTIL_MERGEABLE_LOG_MARKER, READY_TO_MERGE_MARKER, READY_FOR_REVIEW_MARKER, AUTO_MERGED_MARKER, BILLING_LIMIT_MARKER, CANCELLED_CI_REVIEW_MARKER, AUTOMATION_STOPPED_MARKER, AUTO_MERGE_BLOCKED_MARKER, MAINTAINER_ACCESS_REQUEST_MARKER, LIVE_PROGRESS_SECTION_START_MARKER, SESSION_FORCE_KILLED_MARKER, REPOSITORY_INITIALIZATION_REQUIRED_MARKER, INTERACTIVE_SESSION_STARTED_MARKER, INTERACTIVE_SESSION_ENDED_MARKER, NOW_WORKING_SESSION_IS_ENDED_MARKER, SOLUTION_DRAFT_FAILED_MARKER, SOLUTION_DRAFT_FINISHED_WITH_ERRORS_MARKER, USAGE_LIMIT_REACHED_MARKER, WORKING_SESSION_SUMMARY_AUTOMATION_MARKER];
 
 /**
  * Markers that indicate the end of a working session. Used by