@link-assistant/hive-mind 1.69.9 → 1.69.11

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @link-assistant/hive-mind
 
+## 1.69.11
+
+### Patch Changes
+
+- bdca974: Notify existing pull requests when solver pre-exit failures happen before a working session can post its own failure comment.
+
+## 1.69.10
+
+### Patch Changes
+
+- 7d58938: feat: add opt-in GitHub API rate-limit usage logging
+
+  Adds optional logging of current GitHub API rate-limit usage through the centralized `gh` retry wrapper so every wrapped GitHub CLI call can report quota usage while debugging.
+
+  Features:
+  - Disabled by default for backward compatibility
+  - Enable with `--github-rate-limits-logging` when debugging API usage
+  - Logs current `core`, `graphql`, and `search` rate-limit buckets after each centralized wrapped `gh` attempt
+  - Keeps the logging probe non-fatal so quota logging cannot break solve workflows
+
+  Example output:
+
+  ```
+  📊 GitHub rate limits after $gh (gh api repos): core: 780/5000 used (+29 since last check), 4220 remaining, resets 2026-05-12T10:30:00.000Z; graphql: 10/5000 used (no change), 4990 remaining, resets 2026-05-12T10:30:00.000Z
+  ```
+
 ## 1.69.9
 
 ### Patch Changes

package/CLAUDE.md

@@ -0,0 +1,5 @@
+Issue to solve: https://github.com/link-assistant/hive-mind/issues/962
+Your prepared branch: issue-962-7502f60e53a0
+Your prepared working directory: /tmp/gh-issue-solver-1766423610256
+
+Proceed.

package/package.json

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

package/src/github-rate-limit.lib.mjs

@@ -24,8 +24,16 @@ import { limitReset, retryLimits } from './config.lib.mjs';
 
 const exec = promisify(execCb);
 
+const GITHUB_RATE_LIMIT_USAGE_RESOURCES = ['core', 'graphql', 'search'];
 const RATE_LIMIT_PATTERNS = ['api rate limit exceeded', 'rate limit exceeded', 'you have exceeded a secondary rate limit', 'secondary rate limit', 'abuse detection', 'was submitted too quickly'];
 
+const githubRateLimitLogging = {
+  enabled: false,
+  log: null,
+  fetchUsage: null,
+  lastUsageByResource: null,
+};
+
 /**
  * Pull every plausible string out of a thrown error/result so pattern matches
  * survive whatever shape the upstream caller gave us (Error, exec result with
@@ -120,6 +128,116 @@ export const fetchNextRateLimitReset = async () => {
   }
 };
 
+const toFiniteNumber = value => {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : null;
+};
+
+const normalizeRateLimitUsageEntry = (resource, entry) => {
+  if (!resource || !entry) return null;
+  const limit = toFiniteNumber(entry.limit);
+  const used = toFiniteNumber(entry.used);
+  const remaining = toFiniteNumber(entry.remaining);
+  const reset = toFiniteNumber(entry.reset);
+  if (limit === null || used === null || remaining === null) return null;
+  return {
+    resource,
+    limit,
+    used,
+    remaining,
+    reset,
+    resetDate: reset === null ? null : new Date(reset * 1000),
+  };
+};
+
+/**
+ * Fetch the current GitHub API usage buckets we commonly exercise via `gh`.
+ * This intentionally calls `gh api rate_limit` directly so the logging probe
+ * does not recursively pass through the retry/logging wrapper it supports.
+ *
+ * @returns {Promise<Array<{resource: string, limit: number, used: number, remaining: number, reset: number|null, resetDate: Date|null}>>}
+ */
+export const fetchGitHubRateLimitUsage = async () => {
+  try {
+    // eslint-disable-next-line gh-rate-limit/no-direct-gh-exec -- this IS the centralized rate-limit helper; routing through itself would recurse.
+    const { stdout } = await exec('gh api rate_limit');
+    const data = JSON.parse(stdout);
+    const resources = data?.resources || {};
+    return GITHUB_RATE_LIMIT_USAGE_RESOURCES.map(resource => normalizeRateLimitUsageEntry(resource, resources[resource])).filter(Boolean);
+  } catch {
+    return [];
+  }
+};
+
+/**
+ * Enable optional debug logging of actual GitHub API quota usage after each
+ * centralized `gh` wrapper attempt. Disabled by default for backward
+ * compatibility and to avoid extra `gh api rate_limit` probes in normal runs.
+ *
+ * @param {object} [options]
+ * @param {boolean} [options.enabled=false]
+ * @param {(msg: string, options?: object) => Promise<void>|void} [options.log]
+ * @param {() => Promise<Array<object>>} [options.fetchUsage] - injectable for tests.
+ */
+export const configureGitHubRateLimitLogging = ({ enabled = false, log = null, fetchUsage = null } = {}) => {
+  githubRateLimitLogging.enabled = enabled === true;
+  githubRateLimitLogging.log = typeof log === 'function' ? log : null;
+  githubRateLimitLogging.fetchUsage = typeof fetchUsage === 'function' ? fetchUsage : fetchGitHubRateLimitUsage;
+  githubRateLimitLogging.lastUsageByResource = null;
+};
+
+export const isGitHubRateLimitLoggingEnabled = () => githubRateLimitLogging.enabled;
+
+const formatUsageReset = entry => {
+  if (!(entry.resetDate instanceof Date) || Number.isNaN(entry.resetDate.getTime())) return '';
+  return `, resets ${entry.resetDate.toISOString()}`;
+};
+
+const formatRateLimitUsageEntry = entry => {
+  const previous = githubRateLimitLogging.lastUsageByResource?.[entry.resource];
+  let deltaText = '';
+  if (previous && Number.isFinite(previous.used)) {
+    const delta = entry.used - previous.used;
+    if (delta > 0) {
+      deltaText = ` (+${delta} since last check)`;
+    } else if (delta === 0) {
+      deltaText = ' (no change)';
+    } else {
+      deltaText = ' (usage reset since last check)';
+    }
+  }
+  return `${entry.resource}: ${entry.used}/${entry.limit} used${deltaText}, ${entry.remaining} remaining${formatUsageReset(entry)}`;
+};
+
+const safelyLogRateLimitUsage = async (logger, message, options) => {
+  try {
+    await Promise.resolve(logger(message, options));
+  } catch {
+    // Debug logging must never replace the original gh result or error.
+  }
+};
+
+export const logGitHubRateLimitUsage = async ({ label = 'gh' } = {}) => {
+  if (!githubRateLimitLogging.enabled) return [];
+  const logger = githubRateLimitLogging.log || (msg => console.warn(msg));
+
+  try {
+    const rawUsage = await githubRateLimitLogging.fetchUsage();
+    const usage = (Array.isArray(rawUsage) ? rawUsage : []).map(entry => normalizeRateLimitUsageEntry(entry.resource || entry.name, entry)).filter(Boolean);
+    if (usage.length === 0) return [];
+
+    const details = usage.map(formatRateLimitUsageEntry).join('; ');
+    await safelyLogRateLimitUsage(logger, `📊 GitHub rate limits after ${label}: ${details}`);
+    githubRateLimitLogging.lastUsageByResource = Object.fromEntries(usage.map(entry => [entry.resource, entry]));
+    return usage;
+  } catch (error) {
+    if (global.verboseMode) {
+      await safelyLogRateLimitUsage(logger, `⚠️ GitHub rate-limit logging failed after ${label}: ${error.message}`, { verbose: true });
+    }
+    return [];
+  }
+};
+
 /**
  * Compute the absolute wait deadline that satisfies issue #1726:
  *   reset + bufferMs (default 10 min) + random(0..jitterMs) (default 0-5 min)
@@ -226,8 +344,11 @@ export const ghWithRateLimitRetry = async (fn, options = {}) => {
 
   for (let i = 0; i < hardCap; i++) {
     try {
-      return await fn();
+      const result = await fn();
+      await logGitHubRateLimitUsage({ label });
+      return result;
     } catch (error) {
+      await logGitHubRateLimitUsage({ label });
       lastError = error;
 
       if (isRateLimitError(error)) {
@@ -324,6 +445,10 @@ export default {
   isTransientNetworkError,
   parseRateLimitReset,
   fetchNextRateLimitReset,
+  fetchGitHubRateLimitUsage,
+  configureGitHubRateLimitLogging,
+  isGitHubRateLimitLoggingEnabled,
+  logGitHubRateLimitUsage,
   computeRateLimitWait,
   ghWithRateLimitRetry,
   execGhWithRetry,

package/src/github.lib.mjs

@@ -35,6 +35,11 @@ const buildIssueFailureActionSection = targetType => {
 
 Administrator-only CLI details, if any, are printed in the solver terminal log rather than in this issue comment.`;
 };
+const normalizeFailureActionSection = section => {
+  const text = section || '';
+  if (!text) return '';
+  return text.startsWith('\n') ? text : `\n\n${text}`;
+};
 export const checkFileInBranch = async (owner, repo, fileName, branchName) => {
   const { $ } = await use('command-stream');
 
@@ -353,6 +358,7 @@ export async function attachLogToGitHub(options) {
     tool = null, // The tool used (claude, agent, opencode, codex)
     resultModelUsage = null, // Issue #1454
     budgetStatsData = null, // Issue #1491: budget stats for comment
+    failureActionSection = null,
   } = options;
   const budgetStats = budgetStatsData ? buildBudgetStatsString(budgetStatsData.tokenUsage, budgetStatsData.subAgentCalls) : '';
   const targetName = targetType === 'pr' ? 'Pull Request' : 'Issue';
@@ -444,6 +450,7 @@ export async function attachLogToGitHub(options) {
       await log('  🔧 Escaping code blocks in log content for safe embedding...', { verbose: true });
     }
     logContent = escapeCodeBlocksInLog(logContent);
+    const failureAction = normalizeFailureActionSection(failureActionSection ?? buildIssueFailureActionSection(targetType));
     // Create formatted comment
     let logComment;
     // Usage limit comments should be shown whenever isUsageLimit is true,
@@ -520,7 +527,7 @@ ${footerNote}`;
 The automated solution draft encountered an error:
 \`\`\`
 ${errorMessage}
-\`\`\`${buildIssueFailureActionSection(targetType)}${modelInfoString}
+\`\`\`${failureAction}${modelInfoString}
 
 <details>
 <summary>Click to expand failure log (${Math.round(logStats.size / 1024)}KB)</summary>
@@ -718,7 +725,7 @@ ${uploadFooterNote}`;
 The automated solution draft encountered an error:
 \`\`\`
 ${errorMessage}
-\`\`\`${buildIssueFailureActionSection(targetType)}${modelInfoString}
+\`\`\`${failureAction}${modelInfoString}
 
 ### 📎 **Failure log uploaded as ${uploadTypeLabel}${chunkInfo}** (${Math.round(logStats.size / 1024)}KB)
 - [View complete failure log](${logUrl})

package/src/solve.config.lib.mjs

@@ -461,6 +461,11 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: 'Include prompt to check related/sibling pull requests when studying related work. Enabled by default, use --no-prompt-check-sibling-pull-requests to disable.',
     default: true,
   },
+  'github-rate-limits-logging': {
+    type: 'boolean',
+    description: 'Log GitHub API rate-limit usage after each centralized gh command retry wrapper call. Disabled by default; use --github-rate-limits-logging to enable.',
+    default: false,
+  },
   'prompt-experiments-folder': {
     type: 'string',
     description: 'Path to experiments folder used in system prompt. Set to empty string to disable experiments folder prompt. Default: ./experiments',

package/src/solve.mjs

@@ -8,7 +8,7 @@ await handleSolveEarlyExit(earlyArgs);
 const { use } = eval(await (await fetch('https://unpkg.com/use-m/use.js')).text());
 globalThis.use = use;
 const { $: __rawDollar$ } = await use('command-stream');
-const { wrapDollarWithGhRetry } = await import('./github-rate-limit.lib.mjs');
+const { configureGitHubRateLimitLogging, wrapDollarWithGhRetry } = await import('./github-rate-limit.lib.mjs');
 const $ = wrapDollarWithGhRetry(__rawDollar$);
 const config = await import('./solve.config.lib.mjs');
 const { initializeConfig, parseArguments } = config;
@@ -86,6 +86,10 @@ global.verboseMode = argv.verbose;
 
 setupVerboseLogInterceptor(); // Issue #1466: capture [VERBOSE] output in log files
 setupStdioLogInterceptor(); // Issue #1549: capture ALL terminal output in log file
+configureGitHubRateLimitLogging({
+  enabled: argv.githubRateLimitsLogging === true,
+  log,
+});
 
 // Early logs go to cwd; custom log dir takes effect after argv is parsed
 // Conditionally import tool-specific functions after argv is parsed
@@ -144,6 +148,14 @@ const cleanupWrapper = async () => {
 const interruptWrapper = createInterruptWrapper({ cleanupContext, checkForUncommittedChanges, shouldAttachLogs, attachLogToGitHub, getLogFile, sanitizeLogContent, $, log });
 initializeExitHandler(getAbsoluteLogPath, log, cleanupWrapper, interruptWrapper, ({ code, reason }) => notifyIssueAboutPrePullRequestFailure({ code, reason, argv, globalState: global, $, log, getLogFile, shouldAttachLogs, attachLogToGitHub, sanitizeLogContent, rawCommand }));
 installGlobalExitHandlers();
+const markFailureNotificationPosted = targetType => {
+  global.preExitFailureNotificationPosted = true;
+  if (targetType === 'pr') {
+    global.pullRequestFailureNotificationPosted = true;
+  } else if (targetType === 'issue') {
+    global.prePullRequestFailureNotificationPosted = true;
+  }
+};
 
 // Now handle argument validation that was moved from early checks
 let issueUrl = argv['issue-url'] || argv._[0];
@@ -896,6 +908,7 @@ try {
           });
 
           if (logUploadSuccess) {
+            markFailureNotificationPosted('pr');
             await log('  ✅ Logs uploaded successfully');
           } else {
             // Issue #1212: Always show log upload failures (not just verbose)
@@ -920,6 +933,7 @@ try {
 
           const posted = await postTrackedComment({ $, owner, repo, targetNumber: prNumber, body: failureComment });
           if (posted.ok) {
+            markFailureNotificationPosted('pr');
             await log(`   Posted failure comment to PR${posted.commentId ? ` (id=${posted.commentId})` : ''}`);
           }
         } catch (error) {
@@ -1074,6 +1088,7 @@ try {
         });
 
         if (logUploadSuccess) {
+          markFailureNotificationPosted(logTargetType);
           await log(`  📎 Failure logs posted to ${logTargetLabel}`);
         } else {
           // Issue #1212: Always show log upload failures (not just verbose)

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

@@ -1,5 +1,7 @@
 import { getTrackedToolCommentIds, postTrackedComment, SOLUTION_DRAFT_FAILED_MARKER } from './tool-comments.lib.mjs';
 
+export const FORK_DIVERGENCE_RESOLUTION_OPTION = '--allow-fork-divergence-resolution-using-force-push-with-lease';
+
 const truncate = (value, maxLength = 2000) => {
   const text = value === null || value === undefined ? '' : String(value);
   if (text.length <= maxLength) return text;
@@ -8,10 +10,24 @@ const truncate = (value, maxLength = 2000) => {
 
 const fence = value => truncate(value || 'Unknown error').replaceAll('```', '` ` `');
 
+const isForkDivergenceFailure = reason => {
+  const normalizedReason = String(reason || '').toLowerCase();
+  return normalizedReason.includes('fork divergence') || (normalizedReason.includes('fork') && normalizedReason.includes('non-fast-forward')) || normalizedReason.includes('force-with-lease');
+};
+
 export function buildPrePullRequestFailureActionSection(reason = '') {
   const normalizedReason = String(reason || '').toLowerCase();
   const isForkOrRecoveryFailure = normalizedReason.includes('fork') || normalizedReason.includes('auto-recovery') || normalizedReason.includes('repository setup');
 
+  if (isForkDivergenceFailure(reason)) {
+    return `### What you can do
+- If the fork's default branch can be overwritten safely, rerun with \`${FORK_DIVERGENCE_RESOLUTION_OPTION}\` to allow a guarded force-with-lease sync.
+- If the fork has commits you need to preserve, resolve the divergence manually, then rerun the solver.
+- If this requires elevated Hive Mind access, ask a Hive Mind administrator to handle the affected fork or repository.
+
+Administrator-only CLI details, if any, are printed in the solver terminal log rather than in this GitHub comment.`;
+  }
+
   if (isForkOrRecoveryFailure) {
     return `### What you can do
 - If the affected fork or repository belongs to you, remove, rename, archive, initialize, or otherwise repair it in GitHub, then rerun the solver.
@@ -36,6 +52,42 @@ export function shouldNotifyIssueAboutPrePullRequestFailure({ code, globalState
   return getTrackedToolCommentIds().size === 0;
 }
 
+export function resolvePreExitFailureNotificationTarget({ code, globalState }) {
+  if (code === 0) return null;
+  if (!globalState?.owner || !globalState?.repo) return null;
+  if (globalState.preExitFailureNotificationPosted || globalState.preExitFailureNotificationInProgress) return null;
+
+  const owner = globalState.owner;
+  const repo = globalState.repo;
+  const issueNumber = globalState.issueNumber || null;
+  const prNumber = globalState.createdPR?.number || globalState.prNumber || null;
+
+  if (prNumber) {
+    if (globalState.pullRequestFailureNotificationPosted || globalState.pullRequestFailureNotificationInProgress) return null;
+    return {
+      targetType: 'pr',
+      targetNumber: prNumber,
+      owner,
+      repo,
+      issueNumber,
+      prNumber,
+    };
+  }
+
+  if (!issueNumber) return null;
+  if (globalState.prePullRequestFailureNotificationPosted || globalState.prePullRequestFailureNotificationInProgress) return null;
+  if (getTrackedToolCommentIds().size !== 0) return null;
+
+  return {
+    targetType: 'issue',
+    targetNumber: issueNumber,
+    owner,
+    repo,
+    issueNumber,
+    prNumber: null,
+  };
+}
+
 export function buildPrePullRequestFailureComment({ reason, owner, repo, issueNumber, argv = {}, logAttachmentAttempted = false }) {
   const tool = argv.tool || 'claude';
   const modelLine = argv.model ? `\n- **Requested model**: \`${argv.model}\`` : '';
@@ -62,60 +114,124 @@ ${logLine}
 `;
 }
 
+export function buildExistingPullRequestFailureComment({ reason, owner, repo, prNumber, issueNumber = null, argv = {}, logAttachmentAttempted = false }) {
+  const tool = argv.tool || 'claude';
+  const modelLine = argv.model ? `\n- **Requested model**: \`${argv.model}\`` : '';
+  const issueLine = issueNumber ? `\n- **Linked issue**: #${issueNumber}` : '';
+  const logLine = logAttachmentAttempted ? 'Log attachment was attempted but failed. Check the solver terminal log for the complete failure output.' : 'Logs were not attached because `--attach-logs` was not enabled.';
+  const actionSection = buildPrePullRequestFailureActionSection(reason);
+
+  return `## 🚨 ${SOLUTION_DRAFT_FAILED_MARKER}
+
+The automated solver stopped while continuing this existing pull request, so the failure details are posted here for review.
+
+### Failure
+- **Repository**: \`${owner}/${repo}\`
+- **Pull request**: #${prNumber}${issueLine}
+- **Tool**: \`${tool}\`${modelLine}
+
+**Reason**
+\`\`\`text
+${fence(reason)}
+\`\`\`
+
+${actionSection}
+
+${logLine}
+`;
+}
+
+const markNotificationPosted = ({ globalState, targetType }) => {
+  globalState.preExitFailureNotificationPosted = true;
+  if (targetType === 'pr') {
+    globalState.pullRequestFailureNotificationPosted = true;
+  } else {
+    globalState.prePullRequestFailureNotificationPosted = true;
+  }
+};
+
 export async function notifyIssueAboutPrePullRequestFailure(options) {
   const { code, reason, argv = {}, globalState = globalThis, $, log = async () => {}, getLogFile, shouldAttachLogs = false, attachLogToGitHub, sanitizeLogContent, rawCommand = null, postComment = postTrackedComment } = options;
 
-  if (!shouldNotifyIssueAboutPrePullRequestFailure({ code, globalState })) {
+  const target = resolvePreExitFailureNotificationTarget({ code, globalState });
+  if (!target) {
     return { notified: false, skipped: true };
   }
 
-  const owner = globalState.owner;
-  const repo = globalState.repo;
-  const issueNumber = globalState.issueNumber;
-  globalState.prePullRequestFailureNotificationInProgress = true;
+  const { owner, repo, issueNumber, prNumber, targetType, targetNumber } = target;
+  const targetLabel = targetType === 'pr' ? `pull request #${targetNumber}` : `issue #${targetNumber}`;
+  globalState.preExitFailureNotificationInProgress = true;
+  if (targetType === 'pr') {
+    globalState.pullRequestFailureNotificationInProgress = true;
+  } else {
+    globalState.prePullRequestFailureNotificationInProgress = true;
+  }
 
   try {
     if (shouldAttachLogs && getLogFile && attachLogToGitHub && sanitizeLogContent) {
-      await log(`\n📄 Notifying issue #${issueNumber} about pre-PR failure with logs...`);
-      const uploaded = await attachLogToGitHub({
-        logFile: getLogFile(),
-        targetType: 'issue',
-        targetNumber: issueNumber,
-        owner,
-        repo,
-        $,
-        log,
-        sanitizeLogContent,
-        verbose: argv.verbose,
-        errorMessage: `The solver stopped before creating a pull request.\n\nReason: ${reason || 'Unknown error'}`,
-        requestedModel: argv.originalModel || argv.model,
-        tool: argv.tool || 'claude',
-      });
-      if (uploaded) {
-        globalState.prePullRequestFailureNotificationPosted = true;
-        return { notified: true, method: 'log-upload' };
+      await log(`\n📄 Notifying ${targetLabel} about solver failure with logs...`);
+      const errorPrefix = targetType === 'pr' ? `The solver stopped while continuing pull request #${targetNumber}.` : 'The solver stopped before creating a pull request.';
+      try {
+        const uploaded = await attachLogToGitHub({
+          logFile: getLogFile(),
+          targetType,
+          targetNumber,
+          owner,
+          repo,
+          $,
+          log,
+          sanitizeLogContent,
+          verbose: argv.verbose,
+          errorMessage: `${errorPrefix}\n\nReason: ${reason || 'Unknown error'}`,
+          failureActionSection: buildPrePullRequestFailureActionSection(reason),
+          requestedModel: argv.originalModel || argv.model,
+          tool: argv.tool || 'claude',
+        });
+        if (uploaded) {
+          markNotificationPosted({ globalState, targetType });
+          return { notified: true, method: 'log-upload' };
+        }
+      } catch (error) {
+        const message = error && error.message ? error.message : String(error);
+        await log(`  ⚠️  Could not upload solver failure log: ${message}`, { level: 'warning' });
       }
     }
 
-    await log(`\n💬 Notifying issue #${issueNumber} about pre-PR failure...`);
-    const body = buildPrePullRequestFailureComment({
-      reason,
-      owner,
-      repo,
-      issueNumber,
-      argv,
-      rawCommand,
-      logAttachmentAttempted: shouldAttachLogs,
-    });
-    const posted = await postComment({ $, owner, repo, targetNumber: issueNumber, body });
+    await log(`\n💬 Notifying ${targetLabel} about solver failure...`);
+    const body =
+      targetType === 'pr'
+        ? buildExistingPullRequestFailureComment({
+            reason,
+            owner,
+            repo,
+            prNumber,
+            issueNumber,
+            argv,
+            rawCommand,
+            logAttachmentAttempted: shouldAttachLogs,
+          })
+        : buildPrePullRequestFailureComment({
+            reason,
+            owner,
+            repo,
+            issueNumber,
+            argv,
+            rawCommand,
+            logAttachmentAttempted: shouldAttachLogs,
+          });
+    const posted = await postComment({ $, owner, repo, targetNumber, body });
     if (posted.ok) {
-      globalState.prePullRequestFailureNotificationPosted = true;
-      await log(`  ✅ Pre-PR failure comment posted to issue #${issueNumber}${posted.commentId ? ` (id=${posted.commentId})` : ''}`);
+      markNotificationPosted({ globalState, targetType });
+      await log(`  ✅ Solver failure comment posted to ${targetLabel}${posted.commentId ? ` (id=${posted.commentId})` : ''}`);
       return { notified: true, method: 'comment', commentId: posted.commentId || null };
     }
-    await log(`  ⚠️  Could not post pre-PR failure comment: ${posted.stderr || 'unknown error'}`, { level: 'warning' });
+    await log(`  ⚠️  Could not post solver failure comment: ${posted.stderr || 'unknown error'}`, { level: 'warning' });
     return { notified: false, error: posted.stderr || 'unknown error' };
   } finally {
+    globalState.preExitFailureNotificationInProgress = false;
+    if (targetType === 'pr') {
+      globalState.pullRequestFailureNotificationInProgress = false;
+    }
     globalState.prePullRequestFailureNotificationInProgress = false;
   }
 }