@link-assistant/hive-mind 1.70.0 → 1.71.1

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # @link-assistant/hive-mind
 
+## 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
+
+- aacdb06: Make the `--tool gemini` integration produce meaningful JSON output and reach
+  feature parity with `--tool claude` / `--tool codex`. Resolves #1809.
+  - The wrapper now feeds the prompt to gemini-cli through `command-stream`'s
+    `stdin` option instead of `cat <prompt-file> | gemini`, so the upstream
+    non-zero exit code is no longer swallowed by the pipeline.
+  - A new `detectGeminiPlainTextError` helper surfaces gemini-cli's plain-text
+    failures (auth required, quota exceeded, invalid model, unknown argument,
+    fatal error) as structured wrapper errors so headless callers stop seeing
+    silent `success: true` runs when authentication is missing. Tracked upstream
+    in [`google-gemini/gemini-cli`'s `validateNonInteractiveAuth`](https://github.com/google-gemini/gemini-cli/blob/main/packages/cli/src/validateNonInterActiveAuth.ts);
+    see `docs/case-studies/issue-1809/upstream-issue-draft.md` for the proposed
+    upstream fix.
+  - A run that emits zero `init`/`message`/`tool_use`/`result` JSONL events is
+    now classified as a failure regardless of exit code, so empty runs cannot be
+    reported as success anymore.
+  - New optional flags wired through to gemini-cli: `--gemini-sandbox`
+    (`--sandbox`), `--gemini-extensions` (`--extensions`),
+    `--gemini-include-directories` (`--include-directories`, in addition to
+    `tempDir`/`workspaceTmpDir` which are always included), and
+    `--gemini-allowed-mcp-servers` (`--allowed-mcp-server-names`). `--verbose`
+    now also toggles gemini-cli's own `--debug` flag.
+  - New tests in `tests/test-gemini-support.mjs` lock in plain-text auth-error
+    surfacing, zero-event failure detection, and the verbose/include-directories
+    argv plumbing.
+  - Case study published in `docs/case-studies/issue-1809/`.
+
 ## 1.70.0
 
 ### Minor Changes

package/package.json

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

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/gemini.lib.mjs

@@ -8,9 +8,6 @@ if (typeof globalThis.use === 'undefined') {
 }
 
 const { $ } = await use('command-stream');
-const fs = (await use('fs')).promises;
-const path = (await use('path')).default;
-const os = (await use('os')).default;
 
 import { log } from './lib.mjs';
 import { reportError } from './sentry.lib.mjs';
@@ -24,6 +21,80 @@ import { getCumulativeContextInputTokens, toTokenCount } from './context-fill.li
 
 const shellQuote = value => `"${String(value).replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
 
+// Patterns gemini-cli prints to stdout/stderr when no JSONL event can be emitted.
+// Issue #1809: validateNonInteractiveAuth in gemini-cli bypasses the structured
+// stream-json error path; we surface those plain-text failures ourselves until
+// the upstream fix lands. See docs/case-studies/issue-1809/upstream-issue-draft.md.
+const GEMINI_PLAIN_TEXT_ERROR_PATTERNS = [
+  { type: 'AuthenticationRequired', regex: /Please set an Auth method/i },
+  { type: 'AuthenticationRequired', regex: /authentication (?:failed|required)/i },
+  { type: 'AuthenticationRequired', regex: /invalid (?:api[_ ]?key|credentials)/i },
+  { type: 'QuotaExceeded', regex: /quota (?:exceeded|reached)/i },
+  { type: 'InvalidModel', regex: /(?:invalid|unknown) model/i },
+  { type: 'InvalidArgument', regex: /Unknown (?:argument|option)/i },
+  { type: 'FatalError', regex: /^Error:\s/m },
+];
+
+export const detectGeminiPlainTextError = text => {
+  if (!text || typeof text !== 'string') return null;
+  for (const { type, regex } of GEMINI_PLAIN_TEXT_ERROR_PATTERNS) {
+    const match = text.match(regex);
+    if (match) {
+      const line = (text.split(/\r?\n/).find(l => regex.test(l)) || match[0]).trim();
+      return { type, message: line };
+    }
+  }
+  return null;
+};
+
+// Issue #1809: Build the gemini-cli argument list once so verbose mode, includes,
+// sandbox, extensions and MCP allow-list can all be toggled by argv consistently.
+// Returns an array suitable for tagged-template interpolation through command-stream.
+export const buildGeminiArgs = (argv, mappedModel, options = {}) => {
+  const { tempDir, workspaceTmpDir } = options;
+  const args = ['--output-format', 'stream-json', '--model', mappedModel, '--approval-mode', 'yolo', '--skip-trust'];
+
+  if (argv?.verbose) args.push('--debug');
+
+  if (argv?.resume) {
+    args.unshift('--resume', String(argv.resume));
+  }
+
+  const includeDirs = [];
+  if (tempDir) includeDirs.push(tempDir);
+  if (workspaceTmpDir && workspaceTmpDir !== tempDir) includeDirs.push(workspaceTmpDir);
+  if (Array.isArray(argv?.geminiIncludeDirectories)) {
+    for (const dir of argv.geminiIncludeDirectories) if (dir) includeDirs.push(String(dir));
+  } else if (typeof argv?.geminiIncludeDirectories === 'string' && argv.geminiIncludeDirectories.trim()) {
+    includeDirs.push(
+      ...argv.geminiIncludeDirectories
+        .split(',')
+        .map(d => d.trim())
+        .filter(Boolean)
+    );
+  }
+  if (includeDirs.length > 0) {
+    args.push('--include-directories', includeDirs.join(','));
+  }
+
+  if (argv?.geminiSandbox) args.push('--sandbox');
+
+  const collectList = value => {
+    if (!value) return [];
+    if (Array.isArray(value)) return value.map(String).filter(Boolean);
+    return String(value)
+      .split(',')
+      .map(v => v.trim())
+      .filter(Boolean);
+  };
+  const extensions = collectList(argv?.geminiExtensions);
+  if (extensions.length) args.push('--extensions', extensions.join(','));
+  const allowedMcp = collectList(argv?.geminiAllowedMcpServers);
+  if (allowedMcp.length) args.push('--allowed-mcp-server-names', allowedMcp.join(','));
+
+  return args;
+};
+
 // Model mapping to translate aliases to full model IDs for Gemini.
 // Issue #1473: Uses centralized geminiModels from models/index.mjs.
 export const mapModelToId = model => {
@@ -304,6 +375,7 @@ export const executeGemini = async params => {
 
   return await executeGeminiCommand({
     tempDir,
+    workspaceTmpDir,
     branchName,
     prompt,
     systemPrompt,
@@ -321,7 +393,7 @@ export const executeGemini = async params => {
 };
 
 export const executeGeminiCommand = async params => {
-  const { tempDir, branchName, prompt, systemPrompt, argv, log, formatAligned, getResourceSnapshot, forkedRepo, feedbackLines, geminiPath, $, waitForRetryDelay = waitWithCountdown } = params;
+  const { tempDir, workspaceTmpDir, branchName, prompt, systemPrompt, argv, log, formatAligned, getResourceSnapshot, forkedRepo, feedbackLines, geminiPath, $, waitForRetryDelay = waitWithCountdown } = params;
 
   let retryCount = 0;
 
@@ -348,16 +420,15 @@ export const executeGeminiCommand = async params => {
 
     const mappedModel = mapModelToId(argv.model || defaultModels.gemini);
     const combinedPrompt = systemPrompt ? `${systemPrompt}\n\n${prompt}` : prompt;
-    const promptFile = path.join(os.tmpdir(), `gemini_prompt_${Date.now()}_${process.pid}.txt`);
-    await fs.writeFile(promptFile, combinedPrompt);
 
-    let geminiArgs = `--output-format stream-json --model ${shellQuote(mappedModel)} --approval-mode yolo --skip-trust`;
     if (argv.resume) {
       await log(`🔄 Resuming from Gemini session: ${argv.resume}`);
-      geminiArgs = `--resume ${shellQuote(argv.resume)} ${geminiArgs}`;
     }
 
-    const fullCommand = `(cd ${shellQuote(tempDir)} && cat ${shellQuote(promptFile)} | ${geminiPath} ${geminiArgs})`;
+    // Issue #1809: build args via shared helper so verbose/sandbox/include-dirs
+    // toggles stay consistent between the logged command and the real invocation.
+    const geminiArgList = buildGeminiArgs(argv, mappedModel, { tempDir, workspaceTmpDir });
+    const fullCommand = `(cd ${shellQuote(tempDir)} && ${geminiPath} ${geminiArgList.map(shellQuote).join(' ')} <<< <prompt>)`;
 
     await log(`\n${formatAligned('📝', 'Raw command:', '')}`);
     await log(fullCommand);
@@ -370,17 +441,17 @@ export const executeGeminiCommand = async params => {
     let limitReached = false;
     let limitResetTime = null;
     let lastMessage = '';
+    let plainTextError = null;
 
     try {
-      const execCommand = argv.resume
-        ? $({
-            cwd: tempDir,
-            mirror: false,
-          })`cat ${promptFile} | ${geminiPath} --resume ${argv.resume} --output-format stream-json --model ${mappedModel} --approval-mode yolo --skip-trust`
-        : $({
-            cwd: tempDir,
-            mirror: false,
-          })`cat ${promptFile} | ${geminiPath} --output-format stream-json --model ${mappedModel} --approval-mode yolo --skip-trust`;
+      // Issue #1809: feed the prompt directly to gemini-cli stdin via command-stream
+      // instead of "cat <file> | gemini" — the pipeline form swallowed the upstream
+      // non-zero exit code (no pipefail) and yielded false success: true reports.
+      const execCommand = $({
+        cwd: tempDir,
+        stdin: combinedPrompt,
+        mirror: false,
+      })`${geminiPath} ${geminiArgList}`;
 
       await log(`${formatAligned('📋', 'Command details:', '')}`);
       await log(formatAligned('📂', 'Working directory:', tempDir, 2));
@@ -406,21 +477,41 @@ export const executeGeminiCommand = async params => {
           } else {
             lastMessage = output;
           }
-        }
-
-        if (chunk.type === 'stderr') {
+          if (!plainTextError) plainTextError = detectGeminiPlainTextError(output);
+        } else if (chunk.type === 'stderr') {
           const errorOutput = chunk.data.toString();
           if (errorOutput) {
             await log(errorOutput, { stream: 'stderr' });
             allOutput += errorOutput;
             lastMessage = errorOutput;
+            if (!plainTextError) plainTextError = detectGeminiPlainTextError(errorOutput);
           }
         } else if (chunk.type === 'exit') {
           exitCode = chunk.code;
         }
       }
 
-      if (exitCode !== 0 || geminiJsonState.errorMessages?.length > 0) {
+      // Issue #1809: require positive evidence that gemini-cli actually ran.
+      // An empty JSONL stream + exit 0 (e.g. when stdin is closed early) used
+      // to be reported as success: true with messageCount: 0.
+      const observedJsonEvents = Object.values(geminiJsonState.eventCounts || {}).reduce((sum, count) => sum + count, 0);
+      const hasMeaningfulOutput = observedJsonEvents > 0;
+
+      // Promote the detected plain-text error into the structured error list
+      // so downstream retry / usage-limit detection picks it up.
+      if (plainTextError && !geminiJsonState.errorMessages?.some(m => m === plainTextError.message)) {
+        geminiJsonState.errorMessages = geminiJsonState.errorMessages || [];
+        geminiJsonState.errorMessages.push(plainTextError.message);
+        await log(`⚠️ Gemini CLI reported a plain-text error: [${plainTextError.type}] ${plainTextError.message}`, { level: 'warning', verbose: false });
+      }
+
+      const failedExit = exitCode !== 0;
+      const hasJsonError = (geminiJsonState.errorMessages?.length || 0) > 0;
+      // Zero JSONL events => the wrapper has nothing to attribute as model work,
+      // so this run was effectively a no-op and must be reported as failure.
+      const emittedNoEvents = !hasMeaningfulOutput;
+
+      if (failedExit || hasJsonError || emittedNoEvents) {
         const errorText = geminiJsonState.errorMessages?.length > 0 ? geminiJsonState.errorMessages.join('\n') : allOutput || lastMessage;
         const retryableError = classifyRetryableError(errorText);
         if (retryableError.isRetryable) {
@@ -522,8 +613,6 @@ export const executeGeminiCommand = async params => {
         publicPricingEstimate: null,
         resultSummary: null,
       };
-    } finally {
-      await fs.unlink(promptFile).catch(() => {});
     }
   };
 

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

@@ -588,6 +588,25 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: 'Experimental and disabled by default. Automatically detect the target issue or pull request language and set the AI work language to English or Russian when one language has more than 51% of all words. Explicit --work-language or --prompt-language takes precedence.',
     default: false,
   },
+  // Issue #1809: gemini-cli native flags surfaced as solve.mjs options so users
+  // can control sandboxing, extensions and MCP server allow-lists per run.
+  'gemini-sandbox': {
+    type: 'boolean',
+    description: 'Run gemini-cli inside its sandbox (passes --sandbox to gemini-cli). Only used when --tool gemini.',
+    default: false,
+  },
+  'gemini-extensions': {
+    type: 'string',
+    description: 'Comma-separated list of gemini-cli extensions to load (passes --extensions to gemini-cli). Only used when --tool gemini.',
+  },
+  'gemini-include-directories': {
+    type: 'string',
+    description: 'Extra directories to expose to gemini-cli (passes --include-directories to gemini-cli, in addition to tempDir/workspaceTmpDir which are always included). Only used when --tool gemini.',
+  },
+  'gemini-allowed-mcp-servers': {
+    type: 'string',
+    description: 'Comma-separated list of MCP server names that gemini-cli is allowed to call (passes --allowed-mcp-server-names to gemini-cli). Only used when --tool gemini.',
+  },
 };
 
 function hasRawOption(rawArgs, optionName) {

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 ? '⏱️' : '🔄';