@link-assistant/hive-mind 1.71.0 → 1.72.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 1.72.0
+
+### Minor Changes
+
+- fffdfbf: Add experimental `--resume-on-auto-restart` support for resuming Claude auto-restart sessions with a minimal uncommitted-change prompt.
+
+## 1.71.1
+
+### Patch Changes
+
+- aae5a08: Serialize merge queue auto-resolve sessions so conflicting pull requests resolve and drain CI one at a time.
+
 ## 1.71.0
 
 ### Minor Changes

package/CLAUDE.md

@@ -1,5 +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
+Issue to solve: undefined
+Your prepared branch: issue-644-cf3b8243
+Your prepared working directory: /tmp/gh-issue-solver-1762010397765
 
 Proceed.

package/package.json

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

package/src/claude.prompts.lib.mjs

@@ -17,6 +17,11 @@ import { buildWorkLanguageDirective } from './work-language.prompts.lib.mjs';
 export const buildUserPrompt = params => {
   const { issueUrl, issueNumber, prNumber, prUrl, branchName, tempDir, workspaceTmpDir, isContinueMode, forkedRepo, feedbackLines, owner, repo, argv, contributingGuidelines, claudeVersion } = params;
 
+  if (argv?.minimalRestartContext && argv.resume) {
+    const lines = feedbackLines && feedbackLines.length > 0 ? feedbackLines : ['Continue the auto-restart from the previous resumed session.'];
+    return `${lines.join('\n')}\n`;
+  }
+
   const promptLines = [];
 
   // Issue or PR reference
@@ -87,6 +92,10 @@ export const buildUserPrompt = params => {
 export const buildSystemPrompt = params => {
   const { owner, repo, issueNumber, prNumber, branchName, workspaceTmpDir, argv, modelSupportsVision, forkedRepo } = params;
 
+  if (argv?.minimalRestartContext && argv.resume) {
+    return '';
+  }
+
   // When in fork mode, screenshots are pushed to the fork, not the original repo
   const screenshotRepoPath = argv?.fork && forkedRepo ? forkedRepo : `${owner}/${repo}`;
 

package/src/config.lib.mjs

@@ -662,6 +662,15 @@ export const mergeQueue = {
   // Issue #1341: Polling interval for post-merge CI status (in milliseconds)
   // Default: 30 seconds (30000ms) - balance between responsiveness and API rate limits
   postMergeCIPollIntervalMs: parseIntWithDefault('HIVE_MIND_MERGE_QUEUE_POST_MERGE_CI_POLL_INTERVAL_MS', 30 * 1000),
+  // Issue #1807: Timeout (ms) the sequential auto-resolve pass will wait for
+  // a single `/solve <pr> --auto-merge` session to land its PR. Conflict-
+  // resolution sessions can be long-running because Claude has to recompute
+  // merges and re-run CI; default is 4 hours.
+  autoResolveWaitTimeoutMs: parseIntWithDefault('HIVE_MIND_MERGE_QUEUE_AUTO_RESOLVE_WAIT_TIMEOUT_MS', 4 * 60 * 60 * 1000),
+  // Issue #1807: Polling interval (ms) for `gh pr view` lifecycle checks
+  // during the auto-resolve wait. 60 seconds balances responsiveness with
+  // GitHub API rate limits over the timeout window above.
+  autoResolvePollIntervalMs: parseIntWithDefault('HIVE_MIND_MERGE_QUEUE_AUTO_RESOLVE_POLL_INTERVAL_MS', 60 * 1000),
 };
 
 // Helper function to validate configuration values

package/src/github-merge-ci.lib.mjs

@@ -289,8 +289,42 @@ export async function getMergeCommitSha(owner, repo, prNumber, verbose = false)
   }
 }
 
+/**
+ * Get the lifecycle state of a pull request (OPEN / CLOSED / MERGED) along
+ * with its mergeability state. Used by the sequential auto-resolve pass
+ * (issue #1807) to poll until a `/solve <pr> --auto-merge` session either
+ * lands the PR or fails.
+ *
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {number} prNumber - Pull request number
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{state: string|null, mergeStateStatus: string|null, mergeable: string|null, error: string|null}>}
+ */
+export async function getPRStatus(owner, repo, prNumber, verbose = false) {
+  try {
+    const { stdout } = await exec(`gh pr view ${prNumber} --repo ${owner}/${repo} --json state,mergeStateStatus,mergeable`);
+    const pr = JSON.parse(stdout.trim());
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: PR #${prNumber} state=${pr.state}, mergeStateStatus=${pr.mergeStateStatus}, mergeable=${pr.mergeable}`);
+    }
+    return {
+      state: pr.state || null,
+      mergeStateStatus: pr.mergeStateStatus || null,
+      mergeable: pr.mergeable || null,
+      error: null,
+    };
+  } catch (error) {
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Error getting PR #${prNumber} status: ${error.message}`);
+    }
+    return { state: null, mergeStateStatus: null, mergeable: null, error: error.message };
+  }
+}
+
 export default {
   waitForCommitCI,
   checkBranchCIHealth,
   getMergeCommitSha,
+  getPRStatus,
 };

package/src/github-merge.lib.mjs

@@ -1389,8 +1389,9 @@ import { getCommitDate, checkPreviousPRCommitsHadCI, checkWorkflowsHavePRTrigger
 export { getCommitDate, checkPreviousPRCommitsHadCI, checkWorkflowsHavePRTriggers };
 
 // Issue #1341: Re-export post-merge CI functions from separate module
-import { waitForCommitCI, checkBranchCIHealth, getMergeCommitSha } from './github-merge-ci.lib.mjs';
-export { waitForCommitCI, checkBranchCIHealth, getMergeCommitSha };
+// Issue #1807: getPRStatus is used by the sequential auto-resolve pass to poll PR lifecycle state.
+import { waitForCommitCI, checkBranchCIHealth, getMergeCommitSha, getPRStatus } from './github-merge-ci.lib.mjs';
+export { waitForCommitCI, checkBranchCIHealth, getMergeCommitSha, getPRStatus };
 
 import { getAllActiveRepoRuns, waitForAllRepoActions, checkCIConsensus, checkAllPRCommitsCI, getPRCommitShas, getActivePRWorkflowRuns } from './github-merge-repo-actions.lib.mjs'; // Issue #1503, #1712
 export { getAllActiveRepoRuns, waitForAllRepoActions, checkCIConsensus, checkAllPRCommitsCI, getPRCommitShas, getActivePRWorkflowRuns };
@@ -1427,6 +1428,7 @@ export default {
   waitForCommitCI,
   checkBranchCIHealth,
   getMergeCommitSha,
+  getPRStatus, // Issue #1807: sequential auto-resolve PR lifecycle polling
   getActiveRepoWorkflows,
   getCommitDate,
   checkPreviousPRCommitsHadCI,

package/src/solve.config.lib.mjs

@@ -187,6 +187,11 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: 'Maximum number of auto-restart iterations before stopping (default: 5, 0 = unlimited)',
     default: 5,
   },
+  'resume-on-auto-restart': {
+    type: 'boolean',
+    description: '[EXPERIMENTAL] Resume the previous Claude session on uncommitted-change auto-restart and send only a minimal restart prompt. Disabled by default.',
+    default: false,
+  },
   'auto-resume-max-iterations': {
     type: 'number',
     description: 'Maximum number of automatic resume/restart continuations after usage-limit resets (default: 5, 0 = unlimited)',

package/src/solve.minimal-restart-prompt.lib.mjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+
+/**
+ * Generate minimal prompt for auto-restart with session resume
+ * This module provides functions to create lightweight prompts for auto-restart
+ * that assume the AI has full context from the previous session
+ *
+ * Part of the cost optimization feature for issue #661
+ * @see case-studies/issue-661-session-resume-cost-optimization/
+ */
+
+// Note: This module does not import $ directly
+// Functions receive $ as a parameter from the calling module
+// This ensures consistent command executor usage across the codebase
+
+/**
+ * Generate minimal prompt for auto-restart with session resume
+ * This prompt assumes the AI has full context from the previous session
+ * Target: ~500 tokens (compared to 50k-200k in full context)
+ *
+ * @param {string} tempDir - Working directory
+ * @param {object} $ - Command executor
+ * @returns {Promise<string>} Minimal restart prompt
+ */
+export const generateMinimalRestartPrompt = async (tempDir, $) => {
+  // Get uncommitted changes
+  const gitStatus = await $({ cwd: tempDir })`git status --porcelain`;
+  const uncommittedFiles = gitStatus.stdout.toString().trim();
+
+  // Get brief diff summaries (not full diffs to keep the prompt minimal)
+  const gitDiffStat = await $({ cwd: tempDir })`git diff --stat`;
+  const unstagedDiffSummary = gitDiffStat.stdout.toString().trim();
+  const gitCachedDiffStat = await $({ cwd: tempDir })`git diff --cached --stat`;
+  const stagedDiffSummary = gitCachedDiffStat.stdout.toString().trim();
+  const summarySections = [];
+  if (unstagedDiffSummary) summarySections.push(`Unstaged changes:\n${unstagedDiffSummary}`);
+  if (stagedDiffSummary) summarySections.push(`Staged changes:\n${stagedDiffSummary}`);
+  const diffSummary = summarySections.join('\n\n') || 'No tracked-file diff summary available.';
+
+  // Count changes
+  const fileCount = uncommittedFiles.split('\n').filter(line => line.trim()).length;
+
+  return `🔄 Auto-restart: resume the previous session and handle its uncommitted changes.
+
+Uncommitted files (${fileCount}):
+${uncommittedFiles}
+
+Changes summary:
+${diffSummary}
+
+Please review these changes and commit them with an appropriate commit message.
+Follow the repository's commit message conventions from previous commits.`;
+};
+
+/**
+ * Generate full context prompt (fallback when resume fails or not enabled)
+ * This is used when session resume is not available or failed
+ *
+ * @param {string} issueUrl - Issue URL
+ * @param {string} issueBody - Issue description
+ * @param {number} prNumber - PR number
+ * @param {Array<string>} feedbackLines - Feedback from reviewers
+ * @param {string} tempDir - Working directory
+ * @param {object} $ - Command executor
+ * @returns {Promise<string>} Full restart prompt
+ */
+export const generateFullRestartPrompt = async (issueUrl, issueBody, prNumber, feedbackLines, tempDir, $) => {
+  // Get uncommitted changes with full diff
+  const gitStatus = await $({ cwd: tempDir })`git status --porcelain`;
+  const uncommittedFiles = gitStatus.stdout.toString().trim();
+
+  const gitDiff = await $({ cwd: tempDir })`git diff`;
+  const fullDiff = gitDiff.stdout.toString();
+
+  let prompt = `
+Continuing work on issue: ${issueUrl}
+
+Previous session completed but left uncommitted changes.
+  `.trim();
+
+  if (feedbackLines && feedbackLines.length > 0) {
+    prompt += `\n\nFeedback from reviewers:\n${feedbackLines.join('\n')}`;
+  }
+
+  prompt += `\n\nUncommitted changes:\n${uncommittedFiles}\n\nFull diff:\n${fullDiff}`;
+
+  prompt += '\n\nPlease review these changes and commit them appropriately.';
+
+  return prompt;
+};

package/src/solve.mjs

@@ -826,6 +826,13 @@ try {
   limitReached = toolResult.limitReached;
   cleanupContext.limitReached = limitReached;
 
+  if (sessionId && (argv.resumeOnAutoRestart || argv['resume-on-auto-restart'])) {
+    global.previousSessionId = sessionId;
+    if (argv.verbose) {
+      await log(`Session ID stored for auto-restart resume: ${sessionId}`, { verbose: true });
+    }
+  }
+
   // Capture limit reset time and timezone globally for downstream handlers (auto-continue, cleanup decisions)
   if (toolResult && toolResult.limitResetTime) {
     global.limitResetTime = toolResult.limitResetTime;

package/src/solve.watch.lib.mjs

@@ -290,6 +290,38 @@ export const watchForFeedback = async params => {
         // to comments posted during *this* iteration only, not across the whole watch loop.
         const iterationStartTime = new Date();
 
+        let restartFeedbackLines = feedbackLines;
+        let restartArgv = argv;
+        const shouldUseSessionResume = Boolean(isTemporaryWatch && (firstIterationInTemporaryMode || hasUncommittedInTempMode) && (argv.resumeOnAutoRestart || argv['resume-on-auto-restart']) && (argv.tool === 'claude' || !argv.tool) && global.previousSessionId);
+
+        if (shouldUseSessionResume) {
+          await log(formatAligned('', 'Experimental session resume: using minimal auto-restart prompt', '', 2));
+          await log(formatAligned('', `Resuming session: ${global.previousSessionId}`, '', 2));
+
+          if (argv.verbose) {
+            try {
+              const { calculateSessionTokens } = await import('./claude.lib.mjs');
+              const tokenUsage = await calculateSessionTokens(global.previousSessionId, tempDir);
+              if (tokenUsage?.totalTokens) {
+                await log(formatAligned('', `Previous session tokens: ${tokenUsage.totalTokens.toLocaleString()}`, '', 2));
+              }
+            } catch {
+              await log(formatAligned('', 'Could not read previous session token usage', '', 2));
+            }
+          }
+
+          const { generateMinimalRestartPrompt } = await import('./solve.minimal-restart-prompt.lib.mjs');
+          const minimalPrompt = await generateMinimalRestartPrompt(tempDir, $);
+          restartFeedbackLines = [minimalPrompt];
+          restartArgv = {
+            ...argv,
+            resume: global.previousSessionId,
+            minimalRestartContext: true,
+          };
+
+          await log(formatAligned('', `Minimal restart prompt size: ${minimalPrompt.length} characters`, '', 2));
+        }
+
         // Execute tool using shared utility
         const toolResult = await executeToolIteration({
           issueUrl,
@@ -300,10 +332,14 @@ export const watchForFeedback = async params => {
           branchName: prBranch || branchName,
           tempDir,
           mergeStateStatus,
-          feedbackLines,
-          argv,
+          feedbackLines: restartFeedbackLines,
+          argv: restartArgv,
         });
 
+        if (toolResult.sessionId && (argv.resumeOnAutoRestart || argv['resume-on-auto-restart'])) {
+          global.previousSessionId = toolResult.sessionId;
+        }
+
         if (!toolResult.success) {
           // Check if this is an API error using shared utility
           if (isApiError(toolResult)) {

package/src/telegram-merge-queue.lib.mjs

@@ -16,7 +16,7 @@
  * @see https://github.com/link-assistant/hive-mind/issues/1143
  */
 
-import { getAllReadyPRs, checkPRCIStatus, checkPRMergeable, mergePullRequest, waitForCI, ensureReadyLabel, waitForBranchCI, getDefaultBranch, waitForCommitCI, checkBranchCIHealth, getMergeCommitSha, syncReadyTags } from './github-merge.lib.mjs';
+import { getAllReadyPRs, checkPRCIStatus, checkPRMergeable, mergePullRequest, waitForCI, ensureReadyLabel, waitForBranchCI, getDefaultBranch, waitForCommitCI, checkBranchCIHealth, getMergeCommitSha, getPRStatus, syncReadyTags } from './github-merge.lib.mjs';
 import { mergeQueue as mergeQueueConfig } from './config.lib.mjs';
 import { getProgressBar } from './limits.lib.mjs';
 
@@ -102,6 +102,12 @@ export const MERGE_QUEUE_CONFIG = {
   CHECK_BRANCH_CI_HEALTH_BEFORE_START: mergeQueueConfig.checkBranchCIHealthBeforeStart,
   POST_MERGE_CI_TIMEOUT_MS: mergeQueueConfig.postMergeCITimeoutMs,
   POST_MERGE_CI_POLL_INTERVAL_MS: mergeQueueConfig.postMergeCIPollIntervalMs,
+
+  // Issue #1807: Sequential auto-resolve — wait for each `/solve --auto-merge`
+  // session to land its PR (or fail) before spawning the next one. These
+  // timeouts apply to the polling loop in `waitForAutoResolveCompletion`.
+  AUTO_RESOLVE_WAIT_TIMEOUT_MS: mergeQueueConfig.autoResolveWaitTimeoutMs,
+  AUTO_RESOLVE_POLL_INTERVAL_MS: mergeQueueConfig.autoResolvePollIntervalMs,
 };
 
 /**
@@ -191,6 +197,17 @@ export class MergeQueueProcessor {
     // Issue #1805: track auto-resolve progress so the renderer can surface it.
     this.autoResolveActive = false;
     this.autoResolveCurrent = null;
+    // Issue #1807: sequential auto-resolve — track which wait phase is active
+    // for the current auto-resolve item so the progress message can render
+    // distinct "spawning…", "waiting for merge…", and "waiting for CI…" lines.
+    // Values: null | 'spawning' | 'awaiting-resolution' | 'awaiting-ci'.
+    this.autoResolvePhase = null;
+    this.autoResolveWaitStartedAt = null;
+    // For dependency injection in tests (issue #1807) — when set, the
+    // sequential auto-resolve pass uses this in place of `getPRStatus()`.
+    this.getPRStatus = typeof options.getPRStatus === 'function' ? options.getPRStatus : getPRStatus;
+    // Same idea for `getMergeCommitSha` so tests don't need to stub gh.
+    this.getMergeCommitSha = typeof options.getMergeCommitSha === 'function' ? options.getMergeCommitSha : getMergeCommitSha;
 
     // Statistics
     this.stats = {
@@ -539,11 +556,17 @@ export class MergeQueueProcessor {
   }
 
   /**
-   * Issue #1805: Iterate every conflict-skipped item and hand it off to a
-   * `/solve <pr-url> --auto-merge` session via the injected
-   * `spawnSolveSession` callback. Each spawn is awaited so the bot doesn't
-   * fan out unbounded Claude sessions. The PR's status is updated as the
-   * spawn succeeds or fails.
+   * Issue #1805 / #1807: Iterate every conflict-skipped item and hand it off
+   * to a `/solve <pr-url> --auto-merge` session via the injected
+   * `spawnSolveSession` callback. Sessions are processed STRICTLY
+   * sequentially — for each PR we:
+   *   1. Spawn the solve session and confirm the spawn succeeded.
+   *   2. Poll the PR until it becomes MERGED or CLOSED, or until
+   *      `AUTO_RESOLVE_WAIT_TIMEOUT_MS` elapses.
+   *   3. If MERGED, await post-merge CI via `waitForPostMergeCI()` so the
+   *      release pipeline drains before the next resolution starts.
+   * This back-pressure is what keeps the conflict pass from spinning up
+   * eight parallel Claude sessions (issue #1807).
    *
    * @returns {Promise<void>}
    */
@@ -571,7 +594,7 @@ export class MergeQueueProcessor {
     }
 
     this.autoResolveActive = true;
-    this.log(`Auto-resolve: dispatching ${conflicted.length} conflict PR(s) to /solve --auto-merge`);
+    this.log(`Auto-resolve: dispatching ${conflicted.length} conflict PR(s) sequentially to /solve --auto-merge`);
     try {
       for (const item of conflicted) {
         if (this.isCancelled) {
@@ -581,10 +604,14 @@ export class MergeQueueProcessor {
 
         item.status = MergeItemStatus.RESOLVING;
         this.autoResolveCurrent = item.pr.number;
+        this.autoResolvePhase = 'spawning';
+        this.autoResolveWaitStartedAt = new Date();
         if (this.onProgress) {
           await this.onProgress(this.getProgressUpdate());
         }
 
+        // Step 1 — spawn the solve session.
+        let spawned = false;
         try {
           const result = await this.spawnSolveSession({
             url: item.pr.url,
@@ -596,8 +623,8 @@ export class MergeQueueProcessor {
 
           if (result && result.success) {
             item.autoResolveSession = result.sessionName || result.session || null;
-            this.stats.autoResolved++;
             this.log(`Auto-resolve: spawned solve session for PR #${item.pr.number}${item.autoResolveSession ? ` (session ${item.autoResolveSession})` : ''}`);
+            spawned = true;
           } else {
             item.status = MergeItemStatus.RESOLVE_FAILED;
             item.autoResolveError = (result && (result.error || result.warning)) || 'spawn failed';
@@ -611,6 +638,97 @@ export class MergeQueueProcessor {
           console.error(`[ERROR] /merge-queue: auto-resolve error for PR #${item.pr.number}: ${item.autoResolveError}`);
         }
 
+        if (!spawned) {
+          this.autoResolvePhase = null;
+          this.autoResolveWaitStartedAt = null;
+          if (this.onProgress) {
+            await this.onProgress(this.getProgressUpdate());
+          }
+          continue;
+        }
+
+        // Step 2 — wait for the spawned session to actually land (or fail)
+        // before starting the next one. This is the heart of issue #1807.
+        this.autoResolvePhase = 'awaiting-resolution';
+        this.autoResolveWaitStartedAt = new Date();
+        if (this.onProgress) {
+          await this.onProgress(this.getProgressUpdate());
+        }
+
+        const waitResult = await this.waitForAutoResolveCompletion(item);
+
+        if (waitResult.outcome === 'merged') {
+          // Treat the PR as merged for accounting purposes. We bump the
+          // dedicated `autoResolved` counter (kept for backwards-compat with
+          // issue #1805 reporting) and also fold the merge into `stats.merged`
+          // so the final report's success percentage reflects what the queue
+          // ultimately accomplished.
+          item.status = MergeItemStatus.MERGED;
+          item.completedAt = new Date();
+          this.stats.autoResolved++;
+          this.stats.merged++;
+          // The PR previously sat in `skipped` because of the merge conflict;
+          // now that it's merged via auto-resolve, decrement that counter so
+          // we don't double-count it.
+          if (this.stats.skipped > 0) this.stats.skipped--;
+          this.log(`Auto-resolve: PR #${item.pr.number} merged by solve session`);
+
+          // Best-effort: capture the merge commit SHA so post-merge CI wait
+          // has something to poll on.
+          try {
+            await this.sleep(5000);
+            const sha = await this.getMergeCommitSha(this.owner, this.repo, item.pr.number, this.verbose);
+            if (sha && sha.sha) {
+              item.mergeCommitSha = sha.sha;
+            }
+          } catch (error) {
+            this.log(`Auto-resolve: could not get merge commit SHA for PR #${item.pr.number}: ${error.message}`);
+          }
+
+          // Step 3 — drain the merged PR's CI before continuing. We reuse
+          // the same `waitForPostMergeCI` path the main loop already uses so
+          // release workflows finish before the next resolution starts.
+          if (MERGE_QUEUE_CONFIG.WAIT_FOR_POST_MERGE_CI && item.mergeCommitSha && !this.isCancelled) {
+            this.autoResolvePhase = 'awaiting-ci';
+            this.autoResolveWaitStartedAt = new Date();
+            if (this.onProgress) {
+              await this.onProgress(this.getProgressUpdate());
+            }
+            const postCi = await this.waitForPostMergeCI(item);
+            if (!postCi.success && MERGE_QUEUE_CONFIG.STOP_ON_POST_MERGE_CI_FAILURE) {
+              // Stop the auto-resolve pass on CI failure so humans can
+              // investigate before more resolutions run on a broken branch.
+              // Mirrors the main loop's behaviour for issue #1341.
+              this.postMergeCIFailedRuns = postCi.failedRuns;
+              this.error = postCi.error;
+              this.log(`Auto-resolve: stopping pass after post-merge CI failure for PR #${item.pr.number}`);
+              break;
+            }
+          }
+        } else if (waitResult.outcome === 'closed') {
+          item.status = MergeItemStatus.RESOLVE_FAILED;
+          item.autoResolveError = 'PR was closed without merging';
+          this.stats.autoResolveFailed++;
+          this.log(`Auto-resolve: PR #${item.pr.number} was closed without merging`);
+        } else if (waitResult.outcome === 'cancelled') {
+          this.log(`Auto-resolve: cancelled while waiting for PR #${item.pr.number}`);
+          // Don't downgrade the item status — the user can resume later.
+          break;
+        } else if (waitResult.outcome === 'timeout') {
+          item.status = MergeItemStatus.RESOLVE_FAILED;
+          item.autoResolveError = `timed out after ${Math.round((MERGE_QUEUE_CONFIG.AUTO_RESOLVE_WAIT_TIMEOUT_MS || 0) / 60000)}m waiting for resolution`;
+          this.stats.autoResolveFailed++;
+          this.log(`Auto-resolve: timed out waiting for PR #${item.pr.number}`);
+        } else {
+          // 'error' — surface the cause but don't halt the whole pass.
+          item.status = MergeItemStatus.RESOLVE_FAILED;
+          item.autoResolveError = waitResult.error || 'unknown error while waiting';
+          this.stats.autoResolveFailed++;
+          this.log(`Auto-resolve: error waiting for PR #${item.pr.number}: ${item.autoResolveError}`);
+        }
+
+        this.autoResolvePhase = null;
+        this.autoResolveWaitStartedAt = null;
         if (this.onProgress) {
           await this.onProgress(this.getProgressUpdate());
         }
@@ -618,6 +736,89 @@ export class MergeQueueProcessor {
     } finally {
       this.autoResolveActive = false;
       this.autoResolveCurrent = null;
+      this.autoResolvePhase = null;
+      this.autoResolveWaitStartedAt = null;
+    }
+  }
+
+  /**
+   * Issue #1807: Poll the PR's lifecycle state until the spawned solve
+   * session either lands (MERGED), gives up (CLOSED without merge), or the
+   * caller hits a configured timeout. The polling cadence and overall
+   * timeout come from `MERGE_QUEUE_CONFIG`. Cancellation is checked between
+   * polls so the user can abort a long resolution wait via the inline
+   * cancel button.
+   *
+   * Implementation note: we deliberately use `gh pr view --json
+   * state,mergeStateStatus` rather than tracking the screen session
+   * itself. `start-screen` keeps the screen alive after `solve` exits
+   * (via `exec bash`), so the screen lifecycle is not a reliable
+   * completion signal. The PR's lifecycle, on the other hand, is the
+   * authoritative source of truth for "did the resolution succeed?".
+   *
+   * @param {MergeQueueItem} item
+   * @returns {Promise<{outcome: 'merged'|'closed'|'cancelled'|'timeout'|'error', error?: string}>}
+   */
+  async waitForAutoResolveCompletion(item) {
+    const timeout = MERGE_QUEUE_CONFIG.AUTO_RESOLVE_WAIT_TIMEOUT_MS;
+    const pollInterval = MERGE_QUEUE_CONFIG.AUTO_RESOLVE_POLL_INTERVAL_MS;
+    const startTime = Date.now();
+    let consecutiveErrors = 0;
+    const MAX_CONSECUTIVE_ERRORS = 5;
+
+    this.log(`Auto-resolve: polling PR #${item.pr.number} until merged/closed (timeout=${Math.round(timeout / 60000)}m, poll=${Math.round(pollInterval / 1000)}s)`);
+
+    while (Date.now() - startTime < timeout) {
+      if (this.isCancelled) {
+        return { outcome: 'cancelled' };
+      }
+
+      let status;
+      try {
+        status = await this.getPRStatus(this.owner, this.repo, item.pr.number, this.verbose);
+      } catch (error) {
+        consecutiveErrors++;
+        this.log(`Auto-resolve: error polling PR #${item.pr.number} (${consecutiveErrors}/${MAX_CONSECUTIVE_ERRORS}): ${error.message}`);
+        if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+          return { outcome: 'error', error: error.message };
+        }
+        await this.cancellableSleep(pollInterval);
+        continue;
+      }
+
+      if (status && !status.error) {
+        consecutiveErrors = 0;
+        if (status.state === 'MERGED') {
+          return { outcome: 'merged' };
+        }
+        if (status.state === 'CLOSED') {
+          return { outcome: 'closed' };
+        }
+      } else if (status && status.error) {
+        consecutiveErrors++;
+        if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+          return { outcome: 'error', error: status.error };
+        }
+      }
+
+      await this.cancellableSleep(pollInterval);
+    }
+
+    return { outcome: 'timeout' };
+  }
+
+  /**
+   * Issue #1807: Sleep helper that bails out as soon as cancellation is
+   * requested. Used by the auto-resolve poll loop so a `cancel()` call
+   * doesn't have to wait a full polling interval before taking effect.
+   */
+  async cancellableSleep(ms) {
+    const step = Math.min(ms, 1000);
+    const deadline = Date.now() + ms;
+    while (Date.now() < deadline) {
+      if (this.isCancelled) return;
+      const remaining = deadline - Date.now();
+      await this.sleep(Math.min(step, remaining));
     }
   }
 
@@ -802,6 +1003,11 @@ export class MergeQueueProcessor {
         enabled: this.autoResolve,
         active: this.autoResolveActive,
         currentPrNumber: this.autoResolveCurrent,
+        // Issue #1807: expose the sequential wait phase so the progress
+        // renderer (and tests) can show whether we're spawning, waiting on
+        // resolution, or waiting on post-merge CI.
+        phase: this.autoResolvePhase,
+        waitElapsedMs: this.autoResolveWaitStartedAt ? Date.now() - this.autoResolveWaitStartedAt.getTime() : 0,
       },
       progress: {
         processed,
@@ -917,7 +1123,24 @@ export class MergeQueueProcessor {
     if (update.autoResolve && update.autoResolve.active && update.autoResolve.currentPrNumber) {
       const activeItem = update.items.find(it => it.prNumber === update.autoResolve.currentPrNumber);
       const link = activeItem ? this.formatPrLink(activeItem.prNumber, activeItem.title, activeItem.prUrl) : `\\#${update.autoResolve.currentPrNumber}`;
-      message += `🛠️ Auto\\-resolving ${link}\n\n`;
+      // Issue #1807: differentiate the wait phases so the user can tell at
+      // a glance whether we're still spawning, polling for merge, or
+      // waiting on post-merge CI to drain.
+      const phase = update.autoResolve.phase;
+      const elapsedMs = update.autoResolve.waitElapsedMs || 0;
+      const elapsedSec = Math.round(elapsedMs / 1000);
+      const elapsedMin = Math.floor(elapsedSec / 60);
+      const elapsedSecRemainder = elapsedSec % 60;
+      const elapsed = elapsedMs > 0 ? ` \\(${elapsedMin}m ${elapsedSecRemainder}s\\)` : '';
+      if (phase === 'awaiting-resolution') {
+        message += `🛠️ Auto\\-resolving ${link}: waiting for resolution${elapsed}\\.\\.\\.\n\n`;
+      } else if (phase === 'awaiting-ci') {
+        message += `🛠️ Auto\\-resolving ${link}: waiting for post\\-merge CI${elapsed}\\.\\.\\.\n\n`;
+      } else if (phase === 'spawning') {
+        message += `🛠️ Auto\\-resolving ${link}: dispatching solve session${elapsed}\\.\\.\\.\n\n`;
+      } else {
+        message += `🛠️ Auto\\-resolving ${link}\n\n`;
+      }
     } else if (update.current && !this.waitingForTargetBranchCI && !this.waitingForPostMergeCI) {
       // Current item being processed
       const statusEmoji = update.currentStatus === MergeItemStatus.WAITING_CI ? '⏱️' : '🔄';