@link-assistant/hive-mind 2.11.11 → 2.11.13

package/src/error-text.lib.mjs

@@ -0,0 +1,130 @@
+/**
+ * Shared human-readable rendering of structured error payloads (issue #2141).
+ *
+ * Agentic CLIs publish errors as *objects*, not strings. `@link-assistant/agent`
+ * 0.25.x emits `NamedError.toObject()`:
+ *
+ *   {"type":"error","error":{"name":"RetryTimeoutExceededError","data":{"message":"…"}}}
+ *
+ * Every adapter that interpolated such a payload into a template literal
+ * (`Agent reported error: ${outputError.match}`) destroyed the diagnosis and
+ * published `AGENT execution failed with Agent reported error: [object Object]`
+ * to the GitHub issue, which is what issue #2141 reported. This module turns any
+ * of those shapes into text a human can act on, and is reused by every tool
+ * adapter so the defect cannot come back in one CLI at a time.
+ */
+
+export const MAX_ERROR_TEXT_LENGTH = 2000;
+
+/** Text that carries no diagnostic value even though it is a non-empty string. */
+const PLACEHOLDER_ERROR_TEXTS = new Set(['[object object]', '[object error]', 'undefined', 'null', '{}', '[]']);
+
+/**
+ * `[object Object]` (and friends) must never be published as a failure reason:
+ * it is the symptom this module exists to remove, so callers can assert on it.
+ */
+export const isPlaceholderErrorText = value => {
+  if (typeof value !== 'string') return false;
+  return PLACEHOLDER_ERROR_TEXTS.has(value.trim().toLowerCase());
+};
+
+const truncateErrorText = (text, maxLength) => {
+  if (typeof text !== 'string') return '';
+  if (!Number.isFinite(maxLength) || maxLength <= 0) return text;
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, maxLength)}… (truncated)`;
+};
+
+const safeJsonStringify = value => {
+  const seen = new WeakSet();
+  try {
+    return JSON.stringify(value, (_key, entry) => {
+      if (entry && typeof entry === 'object') {
+        if (seen.has(entry)) return '[Circular]';
+        seen.add(entry);
+      }
+      if (typeof entry === 'bigint') return entry.toString();
+      if (typeof entry === 'function') return `[Function ${entry.name || 'anonymous'}]`;
+      return entry;
+    });
+  } catch {
+    return null;
+  }
+};
+
+const joinParts = parts => parts.filter(part => typeof part === 'string' && part.trim().length > 0).join(': ');
+
+const stringifyValue = (value, depth) => {
+  if (value === null || value === undefined) return '';
+  if (typeof value === 'string') return value.trim();
+  if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') return String(value);
+  if (typeof value === 'symbol' || typeof value === 'function') return String(value);
+
+  if (Array.isArray(value)) {
+    if (depth > 4) return safeJsonStringify(value) || String(value);
+    const rendered = value
+      .map(entry => stringifyValue(entry, depth + 1))
+      .filter(Boolean)
+      .join('; ');
+    return rendered || safeJsonStringify(value) || String(value);
+  }
+
+  if (typeof value !== 'object') return String(value);
+  if (depth > 4) return safeJsonStringify(value) || String(value);
+
+  if (value instanceof Error) {
+    const rendered = joinParts([value.name && value.name !== 'Error' ? value.name : '', value.message]);
+    return rendered || value.name || 'Error';
+  }
+
+  // `NamedError.toObject()` from @link-assistant/agent: {name, data:{message,…}}.
+  // The name alone ("RetryTimeoutExceededError") is already actionable, so keep
+  // it even when `data` carries no message.
+  const name = typeof value.name === 'string' && value.name.trim() ? value.name.trim() : null;
+
+  const nestedCandidates = [value.message, value.data, value.error, value.reason, value.cause, value.detail, value.details, value.description, value.hint, value.result, value.stderr];
+
+  for (const candidate of nestedCandidates) {
+    if (candidate === null || candidate === undefined) continue;
+    const rendered = stringifyValue(candidate, depth + 1);
+    if (!rendered || isPlaceholderErrorText(rendered)) continue;
+    // Avoid "Foo: Foo" when the nested value repeats the name.
+    if (name && rendered === name) return name;
+    return joinParts([name, rendered]);
+  }
+
+  if (name) return name;
+
+  const json = safeJsonStringify(value);
+  if (json && json !== '{}') return json;
+  return '';
+};
+
+/**
+ * Render any error payload (string, Error, NamedError object, nested envelope,
+ * array of the above) as a single human-readable line.
+ *
+ * @param {unknown} value - the payload as received from the tool stream.
+ * @param {object} [options]
+ * @param {number} [options.maxLength] - truncation budget for the rendered text.
+ * @param {string} [options.fallback] - returned when nothing readable is found.
+ * @returns {string} readable text, never `[object Object]`.
+ */
+export const stringifyErrorValue = (value, { maxLength = MAX_ERROR_TEXT_LENGTH, fallback = '' } = {}) => {
+  const rendered = stringifyValue(value, 0);
+  if (!rendered || isPlaceholderErrorText(rendered)) return fallback;
+  return truncateErrorText(rendered, maxLength);
+};
+
+/**
+ * Pick the first readable rendering among several candidate payloads.
+ * Used where an adapter has to try `data.message`, then `data.error`, then the
+ * raw record text (the exact chain that produced `[object Object]` before).
+ */
+export const firstErrorText = (candidates, { maxLength = MAX_ERROR_TEXT_LENGTH, fallback = '' } = {}) => {
+  for (const candidate of Array.isArray(candidates) ? candidates : [candidates]) {
+    const rendered = stringifyErrorValue(candidate, { maxLength });
+    if (rendered) return rendered;
+  }
+  return fallback;
+};

package/src/gemini.lib.mjs

@@ -17,6 +17,7 @@ import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs
 import { buildSolveResumeCommand } from './solve.resume-command.lib.mjs'; // Issue #942
 const __geminiBuildSolveResumeCmd = (argv, sessionId, tempDir) => (sessionId && argv?.url ? buildSolveResumeCommand({ issueUrl: argv.url, sessionId, tool: 'gemini', model: argv.model, fallbackModel: argv.fallbackModel, tempDir }) : null);
 import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
+import { stringifyErrorValue } from './error-text.lib.mjs'; // Issue #2141
 import { defaultModels, geminiModels, isFormalAiModel } from './models/index.mjs';
 import { isPrepareOnly, logPreparedToolCommand, resolveFormalAiToolExecution } from './formal-ai.lib.mjs';
 import { buildFormalAiPricingInfo } from './formal-ai-pricing.lib.mjs'; // Issue #2119
@@ -210,7 +211,8 @@ const applyGeminiJsonEvent = (event, nextState, modelId = null) => {
   }
 
   if (data.error) {
-    nextState.errorMessages.push(extractGeminiTextContent(data.error) || JSON.stringify(data.error));
+    // Issue #2141: prefer readable text over a raw JSON dump of the payload.
+    nextState.errorMessages.push(extractGeminiTextContent(data.error) || stringifyErrorValue(data.error, { fallback: JSON.stringify(data.error) }));
   } else if (type.toLowerCase().includes('error')) {
     nextState.errorMessages.push(text || JSON.stringify(data));
   }

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/interactive-codex-events.lib.mjs

@@ -2,6 +2,7 @@
 
 import { createCollapsible, createRawJsonSection, createRedactedRawJsonSection, escapeMarkdown, redactImageData, safeJsonStringify, truncateMiddle } from './interactive-mode.shared.lib.mjs';
 import { INTERACTIVE_SESSION_STARTED_MARKER } from './tool-comments.lib.mjs';
+import { firstErrorText } from './error-text.lib.mjs'; // Issue #2141
 
 export const createCodexEventHandlers = ({ state, postComment, handleAssistantText, imageRenderer }) => {
   const handleCodexThreadStarted = async data => {
@@ -142,7 +143,9 @@ ${createRawJsonSection(data)}`);
   };
 
   const handleCodexError = async data => {
-    const message = data.message || data.error?.message || 'Unknown Codex error';
+    // Issue #2141: `data.error` is often an object, so render it as text instead
+    // of letting `[object Object]` reach the GitHub comment.
+    const message = firstErrorText([data?.message, data?.error, data], { fallback: 'Unknown Codex error' });
     await postComment(`## ❌ Codex error
 
 ${createCollapsible('View error', escapeMarkdown(message), true)}

package/src/lib.mjs

@@ -2,6 +2,7 @@
 import { ensureUseM } from './use-m-bootstrap.lib.mjs';
 import { createCredentialStreamSanitizer, maskToken, sanitizeCredentialText } from './credential-sanitization-core.lib.mjs';
 import { recordLogBytes, resetLogGrowth } from './log-growth.lib.mjs'; // issue #2135: notice a session log that is running away
+import { isPlaceholderErrorText } from './error-text.lib.mjs'; // issue #2141: never publish "[object Object]" as a reason
 
 export { maskToken };
 
@@ -762,6 +763,9 @@ export const isMeaningfulErrorText = value => {
   if (!value || typeof value !== 'string') return false;
   const collapsed = value.replace(/\s+/g, ' ').trim();
   if (!collapsed) return false;
+  // Issue #2141: "[object Object]" has letters, but it is the *absence* of an
+  // error message — a structured payload that was stringified by mistake.
+  if (isPlaceholderErrorText(collapsed)) return false;
   // Require at least one Unicode letter or number; pure punctuation/brackets
   // (e.g. "}", "{", "[]", ",") are stream fragments, not real errors.
   return /[\p{L}\p{N}]/u.test(collapsed);
@@ -820,6 +824,13 @@ export const extractToolErrorCore = ({ toolResult } = {}) => {
   // Issue #1941: reject stray fragments with no letters/digits (e.g. "}").
   if (!isMeaningfulErrorText(rawCore)) return null;
 
+  // Issue #2141: a core that embeds "[object Object]" (e.g. "Agent reported
+  // error: [object Object]") carries no diagnosis at all. Publishing the generic
+  // phrase is more honest than publishing a stringified object, and it keeps the
+  // symptom out of GitHub comments even if a new adapter forgets to render its
+  // payload as text.
+  if (rawCore.includes('[object Object]')) return null;
+
   // Collapse to a single clean line and strip noise.
   const core = rawCore.replace(/\s+/g, ' ').trim();
   return core || null;

package/src/qwen.lib.mjs

@@ -27,6 +27,7 @@ import { getCumulativeContextInputTokens, getRestoredContextInputTokens, toToken
 import { ensureAiToolScratchIgnored, filterAiToolScratchFromStatus } from './ai-tool-scratch.lib.mjs';
 import { getTerminalEventCompletionHealth } from './tool-run-health.lib.mjs'; // Issue #1990
 import { takeJsonRecords } from './json-stream.lib.mjs'; // Issue #2119
+import { stringifyErrorValue } from './error-text.lib.mjs'; // Issue #2141
 
 export const mapModelToId = model => qwenModels[model] || model;
 
@@ -41,18 +42,6 @@ const isQwenAuthError = output => {
   return text.includes('401') || text.includes('unauthorized') || text.includes('authentication') || text.includes('auth') || text.includes('login') || text.includes('api key') || text.includes('oauth free tier');
 };
 
-const stringifyErrorValue = value => {
-  if (value === null || value === undefined) return '';
-  if (typeof value === 'string') return value;
-  if (typeof value?.message === 'string') return value.message;
-  if (typeof value?.error?.message === 'string') return value.error.message;
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-};
-
 const getNestedValue = (object, pathParts) => {
   let cursor = object;
   for (const part of pathParts) {

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,
+};