@link-assistant/hive-mind 1.56.6 → 1.56.8

package/src/session-monitor.lib.mjs

@@ -28,12 +28,6 @@ async function getIsolationRunner() {
   }
   return _isolationRunner;
 }
-// Legacy accessor for querySessionStatus
-async function getQuerySessionStatus() {
-  const mod = await getIsolationRunner();
-  return mod.querySessionStatus;
-}
-
 // In-memory session store
 const activeSessions = new Map();
 
@@ -65,51 +59,6 @@ export async function checkScreenSessionExists(sessionName) {
   }
 }
 
-/**
- * Check if an isolated session is still running.
- * Uses isolation-runner's isSessionRunning which includes screen -ls fallback
- * for screen-backend sessions to work around start-command UUID mismatch.
- *
- * @param {string} sessionId - UUID of the isolated session (screen session name)
- * @param {Object} [options] - Options
- * @param {string} [options.backend] - Isolation backend ('screen', 'tmux', 'docker')
- * @param {boolean} [options.verbose] - Whether to log verbose output
- * @returns {Promise<boolean>} True if session is still running
- * @see https://github.com/link-assistant/hive-mind/issues/1545
- */
-async function checkIsolatedSessionRunning(sessionId, options = {}) {
-  const opts = typeof options === 'boolean' ? { verbose: options } : options;
-  const { backend, verbose = false } = opts;
-  try {
-    const runner = await getIsolationRunner();
-    return await runner.isSessionRunning(sessionId, { backend, verbose });
-  } catch (error) {
-    if (verbose) {
-      console.error(`[VERBOSE] Error checking isolated session ${sessionId}: ${error.message}`);
-    }
-    return false;
-  }
-}
-
-/**
- * Get the exit code of a completed isolated session
- * @param {string} sessionId - UUID of the isolated session
- * @param {boolean} verbose - Whether to log verbose output
- * @returns {Promise<number|null>} Exit code or null if unknown
- */
-async function getIsolatedSessionExitCode(sessionId, verbose = false) {
-  try {
-    const queryStatus = await getQuerySessionStatus();
-    const result = await queryStatus(sessionId, verbose);
-    if (result.exists && result.status === 'executed') {
-      return result.exitCode;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-
 /**
  * Track a new session for completion monitoring
  *
@@ -172,6 +121,67 @@ function completeSession(sessionName, exitCode = 0, verbose = false) {
   }
 }
 
+function normalizeSessionUrl(url) {
+  return url.replace(/\/+$/, '').replace(/#.*$/, '').toLowerCase();
+}
+
+function isNonIsolationSessionActive(sessionName, sessionInfo, verbose = false) {
+  const startTime = sessionInfo.startTime instanceof Date ? sessionInfo.startTime : new Date(sessionInfo.startTime);
+  const elapsed = Date.now() - startTime.getTime();
+  if (elapsed >= NON_ISOLATION_SESSION_TIMEOUT_MS) {
+    if (verbose) {
+      console.log(`[VERBOSE] Non-isolation session ${sessionName} expired after ${Math.round(elapsed / 1000)}s (timeout: ${NON_ISOLATION_SESSION_TIMEOUT_MS / 1000}s), removing from tracking`);
+    }
+    activeSessions.delete(sessionName);
+    return false;
+  }
+  if (verbose) {
+    const remainingSec = Math.round((NON_ISOLATION_SESSION_TIMEOUT_MS - elapsed) / 1000);
+    console.log(`[VERBOSE] Non-isolation session ${sessionName} still within timeout (${remainingSec}s remaining)`);
+  }
+  return true;
+}
+
+async function getIsolationSessionState(sessionName, sessionInfo, options = {}) {
+  const { verbose = false, statusProvider = null } = options;
+  const sessionId = sessionInfo.sessionId || sessionName;
+
+  try {
+    const runner = await getIsolationRunner();
+    const statusResult = statusProvider ? await statusProvider(sessionId, sessionInfo) : await runner.querySessionStatus(sessionId, verbose);
+
+    if (statusResult?.exists && statusResult.status) {
+      if (runner.isExecutingSessionStatus(statusResult.status)) {
+        return { running: true, exitCode: null, status: statusResult.status, statusResult };
+      }
+      if (runner.isTerminalSessionStatus(statusResult.status)) {
+        return {
+          running: false,
+          exitCode: statusResult.exitCode !== undefined ? statusResult.exitCode : null,
+          status: statusResult.status,
+          statusResult,
+        };
+      }
+    }
+
+    const running = await runner.isSessionRunning(sessionId, {
+      backend: sessionInfo.isolationBackend,
+      verbose,
+    });
+    return {
+      running,
+      exitCode: running ? null : (statusResult?.exitCode ?? null),
+      status: statusResult?.status || null,
+      statusResult,
+    };
+  } catch (error) {
+    if (verbose) {
+      console.error(`[VERBOSE] Error refreshing isolated session ${sessionId}: ${error.message}`);
+    }
+    return { running: false, exitCode: null, status: null, statusResult: null };
+  }
+}
+
 /**
  * Monitor active sessions and send notifications when they complete
  * @param {Object} bot - Telegraf bot instance for sending messages
@@ -193,15 +203,12 @@ export async function monitorSessions(bot, verbose = false) {
     let exitCode = null;
 
     if (sessionInfo.isolationBackend && sessionInfo.sessionId) {
-      // Isolation mode: use $ --status with screen -ls fallback for screen backend
-      // See: https://github.com/link-assistant/hive-mind/issues/1545
-      stillRunning = await checkIsolatedSessionRunning(sessionInfo.sessionId, {
-        backend: sessionInfo.isolationBackend,
-        verbose,
-      });
-      if (!stillRunning) {
-        exitCode = await getIsolatedSessionExitCode(sessionInfo.sessionId, verbose);
-      }
+      // Isolation mode: use $ --status, with screen -ls only as a fallback
+      // when the status record is unavailable. Terminal $ statuses are
+      // authoritative so completed screen sessions do not stay blocked.
+      const state = await getIsolationSessionState(sessionName, sessionInfo, { verbose });
+      stillRunning = state.running;
+      exitCode = state.exitCode;
     } else {
       // Issue #1586: Non-isolation screen sessions cannot reliably detect
       // completion because start-screen keeps the screen alive via `exec bash`.
@@ -294,27 +301,14 @@ export function hasActiveSessionForUrl(url, verbose = false) {
   if (!url) return { isActive: false, sessionName: null };
 
   // Normalize the URL for comparison (remove trailing slashes, fragments, etc.)
-  const normalizeUrl = u => u.replace(/\/+$/, '').replace(/#.*$/, '').toLowerCase();
-  const normalizedUrl = normalizeUrl(url);
+  const normalizedUrl = normalizeSessionUrl(url);
 
   for (const [sessionName, sessionInfo] of activeSessions.entries()) {
     // Issue #1586: Auto-expire non-isolation sessions after timeout
-    if (!sessionInfo.isolationBackend) {
-      const startTime = sessionInfo.startTime instanceof Date ? sessionInfo.startTime : new Date(sessionInfo.startTime);
-      const elapsed = Date.now() - startTime.getTime();
-      if (elapsed >= NON_ISOLATION_SESSION_TIMEOUT_MS) {
-        if (verbose) {
-          console.log(`[VERBOSE] Non-isolation session ${sessionName} expired after ${Math.round(elapsed / 1000)}s (timeout: ${NON_ISOLATION_SESSION_TIMEOUT_MS / 1000}s), removing from tracking`);
-        }
-        activeSessions.delete(sessionName);
-        continue;
-      }
-      if (verbose) {
-        const remainingSec = Math.round((NON_ISOLATION_SESSION_TIMEOUT_MS - elapsed) / 1000);
-        console.log(`[VERBOSE] Non-isolation session ${sessionName} still within timeout (${remainingSec}s remaining)`);
-      }
+    if (!sessionInfo.isolationBackend && !isNonIsolationSessionActive(sessionName, sessionInfo, verbose)) {
+      continue;
     }
-    if (sessionInfo.url && normalizeUrl(sessionInfo.url) === normalizedUrl) {
+    if (sessionInfo.url && normalizeSessionUrl(sessionInfo.url) === normalizedUrl) {
       if (verbose) {
         const mode = sessionInfo.isolationBackend ? `isolation:${sessionInfo.isolationBackend}` : 'non-isolation (timeout-based)';
         console.log(`[VERBOSE] Found active session for URL ${url}: ${sessionName} (${mode})`);
@@ -329,6 +323,96 @@ export function hasActiveSessionForUrl(url, verbose = false) {
   return { isActive: false, sessionName: null };
 }
 
+/**
+ * Async active-session check for command handlers.
+ *
+ * Isolation-backed sessions are refreshed through `$ --status` before they
+ * block a duplicate URL, so completed screen-isolated runs no longer require
+ * waiting for the background polling interval.
+ *
+ * @param {string} url - The GitHub URL to check
+ * @param {boolean} verbose - Whether to log verbose output
+ * @param {Object} [options] - Test/support options
+ * @param {Function} [options.statusProvider] - Optional `$ --status` provider
+ * @returns {Promise<{isActive: boolean, sessionName: string|null, status?: string|null}>}
+ */
+export async function hasActiveSessionForUrlAsync(url, verbose = false, options = {}) {
+  if (!url) return { isActive: false, sessionName: null };
+
+  const normalizedUrl = normalizeSessionUrl(url);
+
+  for (const [sessionName, sessionInfo] of activeSessions.entries()) {
+    if (!sessionInfo.url || normalizeSessionUrl(sessionInfo.url) !== normalizedUrl) {
+      continue;
+    }
+
+    if (!sessionInfo.isolationBackend) {
+      if (isNonIsolationSessionActive(sessionName, sessionInfo, verbose)) {
+        return { isActive: true, sessionName, status: null };
+      }
+      continue;
+    }
+
+    const state = await getIsolationSessionState(sessionName, sessionInfo, {
+      verbose,
+      statusProvider: options.statusProvider,
+    });
+    if (state.running) {
+      if (verbose) {
+        console.log(`[VERBOSE] Found executing isolated session for URL ${url}: ${sessionName} (status: ${state.status || 'unknown'})`);
+      }
+      return { isActive: true, sessionName, status: state.status || null };
+    }
+
+    if (verbose) {
+      console.log(`[VERBOSE] Isolated session ${sessionName} for URL ${url} is no longer running (status: ${state.status || 'unknown'}), allowing retry while monitor sends completion`);
+    }
+    sessionInfo.lastKnownStatus = state.status || null;
+    sessionInfo.lastKnownExitCode = state.exitCode ?? null;
+  }
+
+  if (verbose) {
+    console.log(`[VERBOSE] No active session found for URL ${url}`);
+  }
+  return { isActive: false, sessionName: null };
+}
+
+/**
+ * Refresh tracked isolation sessions and count only those that are executing.
+ *
+ * @param {boolean} verbose - Whether to log verbose output
+ * @param {Object} [options] - Test/support options
+ * @param {Function} [options.statusProvider] - Optional `$ --status` provider
+ * @returns {Promise<{count: number, sessions: string[], byTool: Object}>}
+ */
+export async function getRunningTrackedIsolationSessions(verbose = false, options = {}) {
+  const sessions = [];
+  const byTool = {};
+
+  for (const [sessionName, sessionInfo] of activeSessions.entries()) {
+    if (!sessionInfo.isolationBackend) {
+      continue;
+    }
+
+    const state = await getIsolationSessionState(sessionName, sessionInfo, {
+      verbose,
+      statusProvider: options.statusProvider,
+    });
+
+    if (!state.running) {
+      sessionInfo.lastKnownStatus = state.status || null;
+      sessionInfo.lastKnownExitCode = state.exitCode ?? null;
+      continue;
+    }
+
+    const tool = sessionInfo.tool || 'claude';
+    sessions.push(sessionName);
+    byTool[tool] = (byTool[tool] || 0) + 1;
+  }
+
+  return { count: sessions.length, sessions, byTool };
+}
+
 /**
  * Get statistics about session tracking
  * @param {boolean} verbose - Whether to log verbose output

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

@@ -48,6 +48,7 @@ const { extractLinkedIssueNumber } = githubLinking;
 
 // Import configuration
 import { autoContinue, limitReset } from './config.lib.mjs';
+import { formatAutoIterationLimit, hasReachedAutoIterationLimit, normalizeAutoIterationCounter, normalizeAutoIterationLimit } from './auto-iteration-limits.lib.mjs';
 
 // Issue #1574: Interruptible sleep so CTRL+C is never blocked by a lingering timer
 const { interruptibleSleep } = await import('./interruptible-sleep.lib.mjs');
@@ -79,6 +80,15 @@ const formatWaitTime = ms => {
 // See: https://github.com/link-assistant/hive-mind/issues/1152
 export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, shouldAttachLogs, tempDir = null, isRestart = false) => {
   try {
+    const maxAutoResumeIterations = normalizeAutoIterationLimit(argv.autoResumeMaxIterations);
+    const currentAutoResumeIteration = normalizeAutoIterationCounter(argv.autoResumeIteration);
+
+    if (hasReachedAutoIterationLimit(currentAutoResumeIteration, maxAutoResumeIterations)) {
+      await log(`\n⚠️  Auto-${isRestart ? 'restart' : 'resume'} limit reached: ${currentAutoResumeIteration}/${formatAutoIterationLimit(maxAutoResumeIterations)}`);
+      await safeExit(1, `Auto-${isRestart ? 'restart' : 'resume'} limit reached`);
+    }
+
+    const nextAutoResumeIteration = currentAutoResumeIteration + 1;
     const resetTime = global.limitResetTime;
     const timezone = global.limitTimezone || null;
     const baseWaitMs = calculateWaitTime(resetTime);
@@ -125,6 +135,7 @@ export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, sho
     const actionType = isRestart ? 'Restarting' : 'Resuming';
     await log(`\n✅ Limit reset time reached (+ ${bufferMinutes} min buffer + ${jitterSeconds}s jitter)! ${actionType} session...`);
     await log(`   Current time: ${new Date().toLocaleTimeString()}`);
+    await log(`   Auto-${isRestart ? 'restart' : 'resume'} iteration: ${maxAutoResumeIterations === 0 ? nextAutoResumeIteration : `${nextAutoResumeIteration}/${maxAutoResumeIterations}`}`);
 
     // Recursively call the solve script
     // For resume: use --resume with session ID to maintain context
@@ -153,6 +164,8 @@ export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, sho
     if (argv.autoRestartOnLimitReset) {
       resumeArgs.push('--auto-restart-on-limit-reset');
     }
+    resumeArgs.push('--auto-resume-iteration', String(nextAutoResumeIteration));
+    resumeArgs.push('--auto-resume-max-iterations', String(maxAutoResumeIterations));
 
     // Pass session type for proper comment differentiation
     // See: https://github.com/link-assistant/hive-mind/issues/1152
@@ -162,6 +175,7 @@ export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, sho
     // Preserve other flags from original invocation
     if (argv.tool && argv.tool !== 'claude') resumeArgs.push('--tool', argv.tool);
     if (argv.model !== 'sonnet') resumeArgs.push('--model', argv.model);
+    if (argv.fallbackModel) resumeArgs.push('--fallback-model', argv.fallbackModel);
     if (argv.verbose) resumeArgs.push('--verbose');
     if (argv.fork) resumeArgs.push('--fork');
     if (shouldAttachLogs) resumeArgs.push('--attach-logs');

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

@@ -60,6 +60,7 @@ const { READY_TO_MERGE_MARKER, AUTO_RESTART_MARKER, AUTO_MERGED_MARKER, postTrac
 
 // Issue #1574: Interruptible sleep so CTRL+C is never blocked by a lingering timer
 const { interruptibleSleep } = await import('./interruptible-sleep.lib.mjs');
+const { formatAutoIterationLimit, hasReachedAutoIterationLimit, normalizeAutoIterationLimit, shouldSyncBeforeRestart } = await import('./auto-iteration-limits.lib.mjs');
 
 /**
  * Main function: Watch and restart until PR becomes mergeable
@@ -73,6 +74,8 @@ export const watchUntilMergeable = async params => {
   const MIN_CI_CHECK_INTERVAL_SECONDS = 120;
   const watchInterval = Math.max(rawWatchInterval, MIN_CI_CHECK_INTERVAL_SECONDS);
   const isAutoMerge = argv.autoMerge || false;
+  const maxAutoRestartIterations = normalizeAutoIterationLimit(argv.autoRestartMaxIterations);
+  const maxAutoResumeIterations = normalizeAutoIterationLimit(argv.autoResumeMaxIterations);
   // Issue #1503/#1573/#1612: repo-wide action gating is opt-in strict mode.
   // The config default may be bypassed when this module is reused directly, so normalize here.
   const waitForAllRepoActionsFlag = argv.waitForAllActionsInRepositoryBeforeMergeable ?? argv['wait-for-all-actions-in-repository-before-mergeable'] ?? argv.waitForAllActionsInRepositoryBeforeMergable ?? argv['wait-for-all-actions-in-repository-before-mergable'] ?? false;
@@ -83,6 +86,7 @@ export const watchUntilMergeable = async params => {
 
   // Issue #1323: Track actual AI restarts separately from check cycle iterations
   let restartCount = 0;
+  let limitResumeCount = 0;
 
   // Issue #1371: In-memory dedup for "Ready to merge" comment (per-session, not all-time)
   let readyToMergeCommentPosted = false;
@@ -102,6 +106,8 @@ export const watchUntilMergeable = async params => {
   await log(formatAligned('', 'Mode:', isAutoMerge ? 'Auto-merge (will merge when ready)' : 'Auto-restart-until-mergeable (will NOT auto-merge)', 2));
   await log(formatAligned('', 'Checking interval:', `${watchInterval} seconds (minimum: ${MIN_CI_CHECK_INTERVAL_SECONDS}s)`, 2));
   await log(formatAligned('', 'Initial cooldown:', `${INITIAL_COOLDOWN_SECONDS} seconds`, 2));
+  await log(formatAligned('', 'Max restart iterations:', formatAutoIterationLimit(maxAutoRestartIterations), 2));
+  await log(formatAligned('', 'Max limit resumes:', formatAutoIterationLimit(maxAutoResumeIterations), 2));
   await log(formatAligned('', 'Wait for all repo actions:', waitForAllRepoActionsFlag ? 'Yes (strict repo-wide safety)' : 'No (PR-scoped CI only)', 2));
   await log(formatAligned('', 'Stop conditions:', 'PR merged, PR closed, or becomes mergeable', 2));
   await log(formatAligned('', 'Restart triggers:', 'New non-bot comments, CI failures, merge conflicts', 2));
@@ -480,20 +486,85 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
       }
 
       if (shouldRestart) {
-        // Issue #1323: Increment restart count (actual AI executions, not check cycles)
-        restartCount++;
+        if (hasReachedAutoIterationLimit(restartCount, maxAutoRestartIterations)) {
+          await log('');
+          await log(formatAligned('⚠️', 'AUTO-RESTART LIMIT REACHED', `Stopping after ${restartCount} restart iteration${restartCount !== 1 ? 's' : ''}`));
+          await log(formatAligned('', 'Configured limit:', formatAutoIterationLimit(maxAutoRestartIterations), 2));
+          await log(formatAligned('', 'Remaining blockers:', restartReason, 2));
+          await log('');
+
+          try {
+            const limitComment = `## ⚠️ Auto-restart limit reached
+
+Hive Mind stopped auto-restart-until-mergeable after ${restartCount} restart iteration${restartCount !== 1 ? 's' : ''}.
+
+**Configured limit:** ${formatAutoIterationLimit(maxAutoRestartIterations)}
+**Remaining reason:** ${restartReason}
+
+No further AI sessions will be started automatically for this run. Please review the remaining blockers manually or rerun with a higher \`--auto-restart-max-iterations\` value.
+
+---
+*Auto-restart-until-mergeable stopped by the safety limit.*`;
+            await postTrackedComment({ $, owner, repo, targetNumber: prNumber, body: limitComment });
+          } catch (commentError) {
+            reportError(commentError, {
+              context: 'post_auto_restart_limit_comment',
+              owner,
+              repo,
+              prNumber,
+              operation: 'comment_on_pr',
+            });
+            await log(formatAligned('', '⚠️  Could not post auto-restart limit comment to PR', '', 2));
+          }
+
+          return { success: false, reason: 'auto_restart_limit_reached', latestSessionId, latestAnthropicCost };
+        }
 
         // Add standard instructions for auto-restart-until-mergeable mode using shared utility
         feedbackLines.push(...buildAutoRestartInstructions());
 
+        // Get PR merge state status
+        const prStateResult = await $`gh api repos/${owner}/${repo}/pulls/${prNumber} --jq '.mergeStateStatus'`;
+        const mergeStateStatus = prStateResult.code === 0 ? prStateResult.stdout.toString().trim() : null;
+
+        // Issue #1572: Sync clean local branches with remote before restarting to avoid push failures.
+        // Issue #1664: Do not run git pull over an unfinished merge or other uncommitted state.
+        // The tool must see that state and either commit, continue, abort, or otherwise resolve it.
+        const effectiveBranch = prBranch || branchName;
+        if (shouldSyncBeforeRestart({ hasUncommittedChanges })) {
+          const pullResult = await $({ cwd: tempDir })`git pull origin ${effectiveBranch} 2>&1`;
+          if (pullResult.code === 0) {
+            await log(formatAligned('🔄', 'Synced:', `Local branch ${effectiveBranch} updated from remote`));
+          } else {
+            const pullOutput = `${pullResult.stdout || ''}${pullResult.stderr || ''}`.trim() || 'no output';
+            const pullLeftLocalChanges = await checkForUncommittedChanges(tempDir, argv);
+            if (pullLeftLocalChanges && /CONFLICT|MERGE_HEAD|unmerged|Automatic merge failed|not concluded your merge/i.test(pullOutput)) {
+              await log(formatAligned('⚠️', 'Sync produced merge state:', 'Proceeding with AI restart to resolve it', 2));
+              feedbackLines.push('');
+              feedbackLines.push('⚠️ Branch sync encountered an unfinished merge or conflicts:');
+              feedbackLines.push(pullOutput);
+              feedbackLines.push('');
+              feedbackLines.push('Please resolve the merge state before finishing.');
+            } else {
+              throw new Error(`git pull failed (code ${pullResult.code}): ${pullOutput}`);
+            }
+          }
+        } else {
+          await log(formatAligned('↪️', 'Skipping branch sync:', 'Local uncommitted/merge state must be resolved by the AI session', 2));
+        }
+
+        // Issue #1323: Increment restart count only when a tool execution is about to start.
+        restartCount++;
+
         await log(formatAligned('🔄', 'RESTART TRIGGERED:', restartReason));
-        await log(formatAligned('', 'Restart iteration:', `${restartCount}`, 2));
+        await log(formatAligned('', 'Restart iteration:', maxAutoRestartIterations === 0 ? `${restartCount}` : `${restartCount}/${maxAutoRestartIterations}`, 2));
         await log('');
 
-        // Post a comment to PR about the restart
-        // Issue #1356: Include restart count for tracking and add deduplication
+        // Post a comment to PR about the restart after preflight succeeds, so every
+        // posted restart notification corresponds to an actual tool session.
         try {
-          const commentBody = `## 🔄 ${AUTO_RESTART_MARKER} triggered (iteration ${restartCount})\n\n**Reason:** ${restartReason}\n\nStarting new session to address the issues.\n\n---\n*Auto-restart-until-mergeable mode is active. Will continue until PR becomes mergeable.*`;
+          const limitText = maxAutoRestartIterations === 0 ? 'No automatic restart limit is configured.' : `This run will stop after ${maxAutoRestartIterations} restart iteration${maxAutoRestartIterations !== 1 ? 's' : ''}.`;
+          const commentBody = `## 🔄 ${AUTO_RESTART_MARKER} triggered (iteration ${restartCount})\n\n**Reason:** ${restartReason}\n\nStarting new session to address the issues.\n\n---\n*Auto-restart-until-mergeable mode is active. ${limitText}*`;
           // Issue #1625: Track so this doesn't falsely count as an AI-authored comment
           await postTrackedComment({ $, owner, repo, targetNumber: prNumber, body: commentBody });
           await log(formatAligned('', '💬 Posted auto-restart notification to PR', '', 2));
@@ -508,20 +579,6 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
           await log(formatAligned('', '⚠️  Could not post comment to PR', '', 2));
         }
 
-        // Get PR merge state status
-        const prStateResult = await $`gh api repos/${owner}/${repo}/pulls/${prNumber} --jq '.mergeStateStatus'`;
-        const mergeStateStatus = prStateResult.code === 0 ? prStateResult.stdout.toString().trim() : null;
-
-        // Issue #1572: Sync local branch with remote before restarting to avoid push failures.
-        // Without this, the restarted session works on stale local state and can't push.
-        const effectiveBranch = prBranch || branchName;
-        const pullResult = await $({ cwd: tempDir })`git pull origin ${effectiveBranch} 2>&1`;
-        if (pullResult.code === 0) {
-          await log(formatAligned('🔄', 'Synced:', `Local branch ${effectiveBranch} updated from remote`));
-        } else {
-          throw new Error(`git pull failed (code ${pullResult.code}): ${pullResult.stdout || pullResult.stderr || 'no output'}`);
-        }
-
         // Execute the AI tool using shared utility
         await log(formatAligned('🔄', 'Restarting:', `Running ${argv.tool.toUpperCase()} to address issues...`));
 
@@ -545,6 +602,15 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
           // Issue #1570: Always post a GitHub comment to notify the user about the delay
           // and when exactly execution will be resumed, so the user doesn't think the process is stuck.
           if (isUsageLimitReached(toolResult)) {
+            if (hasReachedAutoIterationLimit(limitResumeCount, maxAutoResumeIterations)) {
+              await log('');
+              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('');
+              return { success: false, reason: 'auto_resume_limit_reached', latestSessionId, latestAnthropicCost };
+            }
+
+            limitResumeCount++;
             const resumeSessionId = toolResult.sessionId;
             const resetTime = toolResult.limitResetTime;
             const baseWaitMs = resetTime ? calculateWaitTime(resetTime) : 0;
@@ -567,6 +633,7 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
             await log(formatAligned('', 'Reset time:', resetTime || 'Unknown', 2));
             await log(formatAligned('', 'Waiting:', `${waitMinutes} min (reset + ${bufferMinutes} min buffer + ${jitterSeconds}s jitter)`, 2));
             await log(formatAligned('', 'Resume at:', resumeTimeUTC, 2));
+            await log(formatAligned('', 'Auto-resume iteration:', maxAutoResumeIterations === 0 ? `${limitResumeCount}` : `${limitResumeCount}/${maxAutoResumeIterations}`, 2));
             await log(formatAligned('', 'Action:', 'Posting GitHub comment and waiting for limit reset', 2));
             if (resumeSessionId) {
               await log(formatAligned('', 'Session ID:', resumeSessionId, 2));
@@ -598,7 +665,7 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
                     toolName: `Anthropic ${(argv.tool || 'claude').charAt(0).toUpperCase() + (argv.tool || 'claude').slice(1)} Code`,
                     isAutoResumeEnabled: true,
                     autoResumeMode: 'restart',
-                    requestedModel: argv.model,
+                    requestedModel: argv.originalModel || argv.model,
                     tool: argv.tool || 'claude',
                     publicPricingEstimate: toolResult.publicPricingEstimate,
                     pricingInfo: toolResult.pricingInfo,
@@ -676,7 +743,7 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
                         errorMessage: `${argv.tool.toUpperCase()} execution failed after limit reset`,
                         sessionId: latestSessionId,
                         tempDir,
-                        requestedModel: argv.model,
+                        requestedModel: argv.originalModel || argv.model,
                         tool: argv.tool || 'claude',
                       });
                     }
@@ -726,7 +793,7 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
                   errorMessage: `${argv.tool.toUpperCase()} execution failed`,
                   sessionId: latestSessionId,
                   tempDir,
-                  requestedModel: argv.model,
+                  requestedModel: argv.originalModel || argv.model,
                   tool: argv.tool || 'claude',
                 });
               }
@@ -791,7 +858,7 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
                   publicPricingEstimate: toolResult.publicPricingEstimate,
                   pricingInfo: toolResult.pricingInfo,
                   // Issue #1225: Pass model and tool info for PR comments
-                  requestedModel: argv.model,
+                  requestedModel: argv.originalModel || argv.model,
                   tool: argv.tool || 'claude',
                   // Issue #1508: Include budget stats (context/token/cost) for auto-restart log
                   resultModelUsage: toolResult.resultModelUsage || null,

package/src/solve.config.lib.mjs

@@ -8,7 +8,7 @@
 // This approach was adopted per issue #482 feedback to minimize custom code maintenance
 
 import { enhanceErrorMessage, detectMalformedFlags } from './option-suggestions.lib.mjs';
-import { defaultModels, buildModelOptionDescription, resolveRuntimeDefaultModel } from './models/index.mjs';
+import { defaultModels, buildModelOptionDescription, resolveDefaultFallbackModel, resolveRuntimeDefaultModel } from './models/index.mjs';
 import { validateBranchName } from './solve.branch.lib.mjs';
 
 // Re-export for use by telegram-bot.mjs (avoids extra import lines there)
@@ -173,8 +173,19 @@ export const SOLVE_OPTION_DEFINITIONS = {
   },
   'auto-restart-max-iterations': {
     type: 'number',
-    description: 'Maximum number of auto-restart iterations when uncommitted changes are detected (default: 3)',
-    default: 3,
+    description: 'Maximum number of auto-restart iterations before stopping (default: 5, 0 = unlimited)',
+    default: 5,
+  },
+  'auto-resume-max-iterations': {
+    type: 'number',
+    description: 'Maximum number of automatic resume/restart continuations after usage-limit resets (default: 5, 0 = unlimited)',
+    default: 5,
+  },
+  'auto-resume-iteration': {
+    type: 'number',
+    description: 'Internal: current automatic resume/restart continuation count',
+    default: 0,
+    hidden: true,
   },
   'auto-merge': {
     type: 'boolean',
@@ -248,6 +259,11 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: 'Maximum thinking budget for calculating --think level mappings (default: 31999 for Claude Code). Values: off=0, low=max/4, medium=max/2, high=max*3/4, max=max.',
     default: 31999,
   },
+  'fallback-model': {
+    type: 'string',
+    description: 'Fallback model to switch to on model capacity/overload errors. When supported, retries resume the same session with this model. Defaults: claude opus/opus-4-7 -> opus-4-6; codex gpt-5.5 -> gpt-5.4; all others unset.',
+    default: undefined,
+  },
   'show-thinking-content': {
     type: 'boolean',
     description: 'Show thinking content in Claude responses. Opus 4.7 omits thinking content by default; this option opts in to receive summarized thinking blocks. Disabled by default. Only affects --tool claude.',
@@ -616,6 +632,7 @@ export const parseArguments = async (yargs, hideBin) => {
   // Yargs doesn't properly handle dynamic defaults based on other arguments,
   // so we need to handle this manually after parsing
   const modelExplicitlyProvided = rawArgs.includes('--model') || rawArgs.includes('-m') || rawArgs.includes('--worker-model');
+  const fallbackModelExplicitlyProvided = rawArgs.includes('--fallback-model');
   const planModelExplicitlyProvided = rawArgs.includes('--plan-model');
 
   // --plan flag expansion (Issue #1223)
@@ -681,6 +698,11 @@ export const parseArguments = async (yargs, hideBin) => {
     argv.model = await resolveRuntimeDefaultModel(argv.tool);
   }
 
+  if (argv.tool && !fallbackModelExplicitlyProvided) {
+    const defaultFallbackModel = resolveDefaultFallbackModel(argv.tool, argv.model);
+    argv.fallbackModel = defaultFallbackModel || undefined;
+  }
+
   // Validate mutual exclusivity of --claude-file and --gitkeep-file
   // Check if both are explicitly enabled (user passed both --claude-file and --gitkeep-file)
   if (argv.claudeFile && argv.gitkeepFile) {

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

@@ -65,7 +65,7 @@ export const handleFailure = async options => {
           verbose: argv.verbose,
           errorMessage: cleanErrorMessage(error),
           // Issue #1225: Pass model and tool info for PR comments
-          requestedModel: argv.model,
+          requestedModel: argv.originalModel || argv.model,
           tool: argv.tool || 'claude',
         });
         if (logUploadSuccess) {

package/src/solve.execution.lib.mjs

@@ -195,7 +195,7 @@ export const handleExecutionError = async (error, shouldAttachLogs, owner, repo,
           verbose: argv.verbose || false,
           errorMessage: cleanErrorMessage(error),
           // Issue #1225: Pass model and tool info for PR comments
-          requestedModel: argv.model,
+          requestedModel: argv.originalModel || argv.model,
           tool: argv.tool || 'claude',
         });