@link-assistant/hive-mind 1.30.4 → 1.31.0

package/CHANGELOG.md

@@ -1,5 +1,62 @@
 # @link-assistant/hive-mind
 
+## 1.31.0
+
+### Minor Changes
+
+- feat: add --finalize option (Issue #1383)
+
+  Adds new experimental CLI options to the `solve` command:
+  - `--finalize [N]`: After the main solve completes, automatically restarts the AI tool N times (default: 1 when used as a flag) with a requirements-check prompt to verify all requirements are met. Uses the same model as `--model` by default.
+  - `--finalize-model`: Override the model used during `--finalize` iterations (defaults to `--model`).
+  - `--prompt-ensure-all-requirements-are-met`: Adds a system prompt hint in the "Self review" section instructing the AI to ensure all changes are correct, consistent, validated, tested, logged and fully meet all discussed requirements. Enabled automatically during `--finalize` iterations only (not the first regular run).
+
+  This forces the AI tool to double-check itself after the main solve, verifying changes meet all requirements from the issue description and PR comments, and that CI/CD checks pass.
+
+  feat: auto-commit uncommitted changes and upload log on CTRL+C interrupt (Issue #1351)
+
+  Previously, when a user pressed CTRL+C to interrupt a running solve session, uncommitted changes were silently lost (or left uncommitted) and log files were not uploaded to the PR/issue even when `--attach-logs` was enabled. Additionally, the terminal showed "Claude command completed" instead of "Claude command interrupted".
+
+  Now on CTRL+C:
+  1. **Auto-commit**: Any uncommitted changes in the working directory are automatically committed and pushed to the branch before cleanup occurs.
+  2. **Log upload**: If `--attach-logs` is enabled, the log file is automatically uploaded to the GitHub PR/issue as a comment.
+  3. **Accurate message**: The terminal now correctly shows "Claude command interrupted" instead of "Claude command completed" when the process exits with code 130 (SIGINT).
+
+  Changes made:
+  - `src/exit-handler.lib.mjs`: Added optional `interrupt` parameter to `initializeExitHandler()`; SIGINT handler now calls it before cleanup, guarded against double invocation
+  - `src/solve.mjs`: Extended `cleanupContext` with branch/PR/owner/repo fields; new `interruptWrapper` auto-commits and uploads logs on CTRL+C
+  - `src/claude.lib.mjs`, `src/opencode.lib.mjs`, `src/codex.lib.mjs`, `src/agent.lib.mjs`: Detect exit code 130 and print "interrupted" instead of "completed"
+
+  Full case study analysis including timeline reconstruction, root cause analysis, and implementation details in `docs/case-studies/issue-1351/`.
+
+  fix: prevent false positive ready tag sync by using issue timeline API (Issue #1413)
+
+  Previously, `syncReadyTags()` used a GitHub full-text body search to find PRs linked to an issue:
+
+  ```js
+  gh pr list --search "in:body closes #1411 OR fixes #1411 OR resolves #1411"
+  ```
+
+  This caused a false positive: PR #843 matched because `1411` appeared as a source code line reference inside its body, not as a genuine issue-closing keyword.
+
+  Now uses the GitHub issue timeline API (`GET /repos/{owner}/{repo}/issues/{issue_number}/timeline`) to find PRs with genuine `cross-referenced` events, which is the same data GitHub uses to auto-close issues when PRs are merged.
+
+  fix: hide cancel button and show cancelling state on /merge cancel (Issue #1407)
+
+  When user clicked the "🛑 Cancel" button during `/merge` queue processing, the cancel button remained visible in the Telegram message until the current PR finished processing (potentially hours if waiting for CI). The toast message "The current PR will finish processing" was also confusing.
+
+  The fix immediately hides the cancel button by editing the message without `reply_markup`, shows a "🛑 Cancelling..." indicator in the progress message when cancellation is requested, and adds `isCancelled` support to `waitForCI()` for early exit when the operation is cancelled.
+
+## 1.30.5
+
+### Patch Changes
+
+- a9a58ab: Switch Docker builds to registry cache for faster arm64 builds
+  - Changed from GitHub Actions cache to Docker Hub registry cache backend
+  - Use architecture-specific cache tags (buildcache-amd64, buildcache-arm64) to prevent cross-platform cache overwriting
+  - Increased Docker job timeout from 45 to 60 minutes for safety margin
+  - Added comprehensive case study documentation for issue #1415
+
 ## 1.30.4
 
 ### Patch Changes

package/package.json

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

package/src/agent.lib.mjs

@@ -911,6 +911,9 @@ export const executeAgentCommand = async params => {
           // Explicit JSON error message from agent (Issue #1201: includes streaming-detected errors)
           errorInfo.message = `Agent reported error: ${outputError.match}`;
           await log(`\n\n❌ ${errorInfo.message}`, { level: 'error' });
+        } else if (exitCode === 130) {
+          errorInfo.message = 'Agent command interrupted (CTRL+C)';
+          await log('\n\n⚠️ Agent command interrupted (CTRL+C)');
         } else {
           errorInfo.message = `Agent command failed with exit code ${exitCode}`;
           await log(`\n\n❌ ${errorInfo.message}`, { level: 'error' });

package/src/agent.prompts.lib.mjs

@@ -212,7 +212,12 @@ Self review.
    - When you check your solution draft, run all tests locally.
    - When you check your solution draft, verify git status shows a clean working tree with no uncommitted changes.
    - When you compare with repo style, use gh pr diff [number].
-   - When you finalize, confirm code, tests, and description are consistent.
+   - When you finalize, confirm code, tests, and description are consistent.${
+     argv && argv.promptEnsureAllRequirementsAreMet
+       ? `
+   - When no explicit feedback or requirements is provided, ensure all changes are correct, consistent, validated, tested, logged and fully meet all discussed requirements (check issue description and all comments in issue and in pull request). Ensure all CI/CD checks pass.`
+       : ''
+   }
 
 GitHub CLI command patterns.
    - IMPORTANT: Always use --paginate flag when fetching lists from GitHub API to ensure all results are returned (GitHub returns max 30 per page by default).

package/src/claude.lib.mjs

@@ -1295,7 +1295,10 @@ export const executeClaudeCommand = async params => {
       }
       // Issue #1088: If error_during_execution occurred but command didn't fail,
       // log it as "Finished with errors" instead of pure success
-      if (errorDuringExecution) {
+      // Issue #1351: Distinguish interrupted sessions (exit code 130) from normal completion
+      if (exitCode === 130) {
+        await log('\n\n⚠️ Claude command interrupted (CTRL+C)');
+      } else if (errorDuringExecution) {
         await log('\n\n⚠️ Claude command finished with errors');
       } else {
         await log('\n\n✅ Claude command completed');

package/src/claude.prompts.lib.mjs

@@ -254,7 +254,12 @@ Self review.
    - When you check your solution draft, run all tests locally.
    - When you check your solution draft, verify git status shows a clean working tree with no uncommitted changes.
    - When you compare with repo style, use gh pr diff [number].
-   - When you finalize, confirm code, tests, and description are consistent.
+   - When you finalize, confirm code, tests, and description are consistent.${
+     argv && argv.promptEnsureAllRequirementsAreMet
+       ? `
+   - When no explicit feedback or requirements is provided, ensure all changes are correct, consistent, validated, tested, logged and fully meet all discussed requirements (check issue description and all comments in issue and in pull request). Ensure all CI/CD checks pass.`
+       : ''
+   }
 
 GitHub CLI command patterns.
    - IMPORTANT: Always use --paginate flag when fetching lists from GitHub API to ensure all results are returned (GitHub returns max 30 per page by default).

package/src/codex.lib.mjs

@@ -398,6 +398,8 @@ export const executeCodexCommand = async params => {
           for (const line of messageLines) {
             await log(line, { level: 'warning' });
           }
+        } else if (exitCode === 130) {
+          await log('\n\n⚠️ Codex command interrupted (CTRL+C)');
         } else {
           await log(`\n\n❌ Codex command failed with exit code ${exitCode}`, { level: 'error' });
         }

package/src/codex.prompts.lib.mjs

@@ -220,7 +220,12 @@ Self review.
    - When you check your solution draft, run all tests locally.
    - When you check your solution draft, verify git status shows a clean working tree with no uncommitted changes.
    - When you compare with repo style, use gh pr diff [number].
-   - When you finalize, confirm code, tests, and description are consistent.
+   - When you finalize, confirm code, tests, and description are consistent.${
+     argv && argv.promptEnsureAllRequirementsAreMet
+       ? `
+   - When no explicit feedback or requirements is provided, ensure all changes are correct, consistent, validated, tested, logged and fully meet all discussed requirements (check issue description and all comments in issue and in pull request). Ensure all CI/CD checks pass.`
+       : ''
+   }
 
 GitHub CLI command patterns.
    - IMPORTANT: Always use --paginate flag when fetching lists from GitHub API to ensure all results are returned (GitHub returns max 30 per page by default).

package/src/exit-handler.lib.mjs

@@ -25,17 +25,22 @@ let exitMessageShown = false;
 let getLogPathFunction = null;
 let logFunction = null;
 let cleanupFunction = null;
+let interruptFunction = null;
+let interruptHandlerRan = false;
 
 /**
  * Initialize the exit handler with required dependencies
  * @param {Function} getLogPath - Function that returns the current log path
  * @param {Function} log - Logging function
  * @param {Function} cleanup - Optional cleanup function to call on exit
+ * @param {Function} interrupt - Optional interrupt function to call on SIGINT/SIGTERM before cleanup
+ *                               (e.g., auto-commit uncommitted changes, upload logs)
  */
-export const initializeExitHandler = (getLogPath, log, cleanup = null) => {
+export const initializeExitHandler = (getLogPath, log, cleanup = null, interrupt = null) => {
   getLogPathFunction = getLogPath;
   logFunction = log;
   cleanupFunction = cleanup;
+  interruptFunction = interrupt;
 };
 
 /**
@@ -114,6 +119,15 @@ export const installGlobalExitHandlers = () => {
 
   // Handle SIGINT (CTRL+C)
   process.on('SIGINT', async () => {
+    // Run interrupt handler first (auto-commit, log upload, etc.) — guard against double invocation
+    if (interruptFunction && !interruptHandlerRan) {
+      interruptHandlerRan = true;
+      try {
+        await interruptFunction();
+      } catch {
+        // Ignore interrupt handler errors
+      }
+    }
     if (cleanupFunction) {
       try {
         await cleanupFunction();
@@ -208,4 +222,5 @@ export const installGlobalExitHandlers = () => {
  */
 export const resetExitHandler = () => {
   exitMessageShown = false;
+  interruptHandlerRan = false;
 };

package/src/github-merge-ready-sync.lib.mjs

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+/**
+ * GitHub Merge Ready Tag Sync Library
+ *
+ * Provides utilities for syncing 'ready' tags between linked PRs and issues,
+ * and for finding genuinely linked PRs via the GitHub issue timeline API.
+ * Split from github-merge.lib.mjs to maintain file size limits.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1413
+ */
+
+import { promisify } from 'util';
+import { exec as execCallback } from 'child_process';
+
+const exec = promisify(execCallback);
+
+import { extractLinkedIssueNumber } from './github-linking.lib.mjs';
+
+// READY_LABEL is also exported from github-merge.lib.mjs (which re-exports it from here)
+export const READY_LABEL = {
+  name: 'ready',
+  description: 'Is ready to be merged',
+  color: '0E8A16', // Green color
+};
+
+/**
+ * Add a label to a GitHub issue or pull request
+ * @param {'issue'|'pr'} type - Whether to add to issue or PR
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {number} number - Issue or PR number
+ * @param {string} labelName - Label name to add
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{success: boolean, error: string|null}>}
+ */
+async function addLabel(type, owner, repo, number, labelName, verbose = false) {
+  const cmd = type === 'issue' ? 'issue' : 'pr';
+  try {
+    await exec(`gh ${cmd} edit ${number} --repo ${owner}/${repo} --add-label "${labelName}"`);
+    if (verbose) console.log(`[VERBOSE] /merge: Added '${labelName}' label to ${type} #${number}`);
+    return { success: true, error: null };
+  } catch (error) {
+    if (verbose) console.log(`[VERBOSE] /merge: Failed to add label to ${type} #${number}: ${error.message}`);
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Get open PRs that are genuinely linked to an issue via GitHub's issue timeline.
+ *
+ * Issue #1413: This replaces the previous full-text body search approach which
+ * caused false positives. For example, a search for `fixes #1411` would incorrectly
+ * match PR #843 because its body contained the string `1411→` as a source code line
+ * number in a code snippet — not as an issue closing reference.
+ *
+ * The GitHub issue timeline API returns `cross-referenced` events for PRs that
+ * explicitly close the issue using GitHub's reserved keywords (fixes/closes/resolves).
+ * This is the same data GitHub uses to auto-close issues when PRs are merged, so
+ * it reliably identifies genuine closing references.
+ *
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {number} issueNumber - Issue number to find linked PRs for
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<Array<{number: number, title: string}>>} Array of open PRs that close this issue
+ */
+export async function getLinkedPRsFromTimeline(owner, repo, issueNumber, verbose = false) {
+  try {
+    const { stdout: timelineJson } = await exec(`gh api repos/${owner}/${repo}/issues/${issueNumber}/timeline --paginate`);
+    const timeline = JSON.parse(timelineJson.trim() || '[]');
+
+    // Extract cross-referenced events where the source is an open PR
+    // (source.issue.pull_request != null means the source is a PR, not a plain issue)
+    const linkedPRNumbers = new Set();
+    const linkedPRs = [];
+
+    for (const event of timeline) {
+      if (event.event === 'cross-referenced' && event.source?.issue?.pull_request != null && event.source?.issue?.state === 'open') {
+        const prNumber = event.source.issue.number;
+        if (!linkedPRNumbers.has(prNumber)) {
+          linkedPRNumbers.add(prNumber);
+          linkedPRs.push({
+            number: prNumber,
+            title: event.source.issue.title || '',
+          });
+        }
+      }
+    }
+
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Issue #${issueNumber} has ${linkedPRs.length} genuinely linked open PR(s) via timeline`);
+      for (const pr of linkedPRs) {
+        console.log(`[VERBOSE] /merge:   PR #${pr.number}: ${pr.title}`);
+      }
+    }
+
+    return linkedPRs;
+  } catch (error) {
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Error fetching timeline for issue #${issueNumber}: ${error.message}`);
+    }
+    return [];
+  }
+}
+
+/**
+ * Sync 'ready' tags between linked pull requests and issues
+ *
+ * Issue #1367: Before building the merge queue, ensure that:
+ * 1. If a PR has 'ready' label and is clearly linked to an issue (via standard GitHub
+ *    keywords in the PR body/title), the issue also gets 'ready' label.
+ * 2. If an issue has 'ready' label and has a clearly linked open PR, the PR also gets
+ *    'ready' label.
+ *
+ * This ensures the final list of ready PRs reflects all ready work, regardless of
+ * where the 'ready' label was originally applied.
+ *
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{synced: number, errors: number, details: Array<Object>}>}
+ */
+export async function syncReadyTags(owner, repo, verbose = false) {
+  const synced = [];
+  const errors = [];
+
+  if (verbose) {
+    console.log(`[VERBOSE] /merge: Syncing 'ready' tags for ${owner}/${repo}...`);
+  }
+
+  try {
+    // Fetch open PRs with 'ready' label (including body for link detection)
+    const { stdout: prsJson } = await exec(`gh pr list --repo ${owner}/${repo} --label "${READY_LABEL.name}" --state open --json number,title,body,labels --limit 100`);
+    const readyPRs = JSON.parse(prsJson.trim() || '[]');
+
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Found ${readyPRs.length} open PRs with 'ready' label for tag sync`);
+    }
+
+    // Fetch open issues with 'ready' label
+    const { stdout: issuesJson } = await exec(`gh issue list --repo ${owner}/${repo} --label "${READY_LABEL.name}" --state open --json number,title --limit 100`);
+    const readyIssues = JSON.parse(issuesJson.trim() || '[]');
+
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Found ${readyIssues.length} open issues with 'ready' label for tag sync`);
+    }
+
+    // Build a set of issue numbers that already have 'ready'
+    const readyIssueNumbers = new Set(readyIssues.map(i => String(i.number)));
+
+    // Step 1: For each PR with 'ready', find linked issue and sync label to it
+    for (const pr of readyPRs) {
+      try {
+        const prBody = pr.body || '';
+        const linkedIssueNumber = extractLinkedIssueNumber(prBody);
+
+        if (!linkedIssueNumber) {
+          if (verbose) {
+            console.log(`[VERBOSE] /merge: PR #${pr.number} has no linked issue (no closing keyword in body)`);
+          }
+          continue;
+        }
+
+        if (readyIssueNumbers.has(String(linkedIssueNumber))) {
+          if (verbose) {
+            console.log(`[VERBOSE] /merge: Issue #${linkedIssueNumber} already has 'ready' label (linked from PR #${pr.number})`);
+          }
+          continue;
+        }
+
+        // Issue doesn't have 'ready' label yet - add it
+        if (verbose) {
+          console.log(`[VERBOSE] /merge: PR #${pr.number} has 'ready', adding to linked issue #${linkedIssueNumber}`);
+        }
+
+        const result = await addLabel('issue', owner, repo, linkedIssueNumber, READY_LABEL.name, verbose);
+        if (result.success) {
+          synced.push({ type: 'pr-to-issue', prNumber: pr.number, issueNumber: Number(linkedIssueNumber) });
+          // Mark this issue as now having 'ready' so we don't process it again
+          readyIssueNumbers.add(String(linkedIssueNumber));
+        } else {
+          errors.push({ type: 'pr-to-issue', prNumber: pr.number, issueNumber: Number(linkedIssueNumber), error: result.error });
+        }
+      } catch (err) {
+        if (verbose) {
+          console.log(`[VERBOSE] /merge: Error syncing label from PR #${pr.number}: ${err.message}`);
+        }
+        errors.push({ type: 'pr-to-issue', prNumber: pr.number, error: err.message });
+      }
+    }
+
+    // Build a set of PR numbers that already have 'ready'
+    const readyPRNumbers = new Set(readyPRs.map(p => String(p.number)));
+
+    // Step 2: For each issue with 'ready', find linked PRs and sync label to them
+    for (const issue of readyIssues) {
+      try {
+        // Issue #1413: Use the GitHub issue timeline API to find PRs that genuinely
+        // close this issue via closing keywords. This avoids false positives from
+        // full-text search, which can match PRs that contain the issue number as a
+        // source code line number (e.g. "1411→  await log(...)") rather than as a
+        // real closing reference.
+        const linkedPRs = await getLinkedPRsFromTimeline(owner, repo, issue.number, verbose);
+
+        for (const linkedPR of linkedPRs) {
+          if (readyPRNumbers.has(String(linkedPR.number))) {
+            if (verbose) {
+              console.log(`[VERBOSE] /merge: PR #${linkedPR.number} already has 'ready' label (linked from issue #${issue.number})`);
+            }
+            continue;
+          }
+
+          // PR doesn't have 'ready' label yet - add it
+          if (verbose) {
+            console.log(`[VERBOSE] /merge: Issue #${issue.number} has 'ready', adding to linked PR #${linkedPR.number}`);
+          }
+
+          const result = await addLabel('pr', owner, repo, linkedPR.number, READY_LABEL.name, verbose);
+          if (result.success) {
+            synced.push({ type: 'issue-to-pr', issueNumber: issue.number, prNumber: linkedPR.number });
+            // Mark this PR as now having 'ready'
+            readyPRNumbers.add(String(linkedPR.number));
+          } else {
+            errors.push({ type: 'issue-to-pr', issueNumber: issue.number, prNumber: linkedPR.number, error: result.error });
+          }
+        }
+      } catch (err) {
+        if (verbose) {
+          console.log(`[VERBOSE] /merge: Error syncing label from issue #${issue.number}: ${err.message}`);
+        }
+        errors.push({ type: 'issue-to-pr', issueNumber: issue.number, error: err.message });
+      }
+    }
+  } catch (error) {
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Error during tag sync: ${error.message}`);
+    }
+    errors.push({ type: 'fetch', error: error.message });
+  }
+
+  if (verbose) {
+    console.log(`[VERBOSE] /merge: Tag sync complete. Synced: ${synced.length}, Errors: ${errors.length}`);
+  }
+
+  return {
+    synced: synced.length,
+    errors: errors.length,
+    details: synced,
+    errorDetails: errors,
+  };
+}

package/src/github-merge.lib.mjs

@@ -19,15 +19,10 @@ const exec = promisify(execCallback);
 // Import GitHub URL parser
 import { parseGitHubUrl } from './github.lib.mjs';
 
-// Import linking utilities
-import { extractLinkedIssueNumber } from './github-linking.lib.mjs';
-
-// Default label configuration
-export const READY_LABEL = {
-  name: 'ready',
-  description: 'Is ready to be merged',
-  color: '0E8A16', // Green color
-};
+// Issue #1413: Import ready tag sync, timeline, and label constant from separate module
+// to keep this file under the 1500 line limit
+import { syncReadyTags, getLinkedPRsFromTimeline, READY_LABEL } from './github-merge-ready-sync.lib.mjs';
+export { syncReadyTags, getLinkedPRsFromTimeline, READY_LABEL };
 
 /**
  * Check if 'ready' label exists in repository
@@ -254,172 +249,6 @@ export async function fetchReadyIssuesWithPRs(owner, repo, verbose = false) {
   }
 }
 
-/**
- * Add a label to a GitHub issue or pull request
- * @param {'issue'|'pr'} type - Whether to add to issue or PR
- * @param {string} owner - Repository owner
- * @param {string} repo - Repository name
- * @param {number} number - Issue or PR number
- * @param {string} labelName - Label name to add
- * @param {boolean} verbose - Whether to log verbose output
- * @returns {Promise<{success: boolean, error: string|null}>}
- */
-async function addLabel(type, owner, repo, number, labelName, verbose = false) {
-  const cmd = type === 'issue' ? 'issue' : 'pr';
-  try {
-    await exec(`gh ${cmd} edit ${number} --repo ${owner}/${repo} --add-label "${labelName}"`);
-    if (verbose) console.log(`[VERBOSE] /merge: Added '${labelName}' label to ${type} #${number}`);
-    return { success: true, error: null };
-  } catch (error) {
-    if (verbose) console.log(`[VERBOSE] /merge: Failed to add label to ${type} #${number}: ${error.message}`);
-    return { success: false, error: error.message };
-  }
-}
-
-/**
- * Sync 'ready' tags between linked pull requests and issues
- *
- * Issue #1367: Before building the merge queue, ensure that:
- * 1. If a PR has 'ready' label and is clearly linked to an issue (via standard GitHub
- *    keywords in the PR body/title), the issue also gets 'ready' label.
- * 2. If an issue has 'ready' label and has a clearly linked open PR, the PR also gets
- *    'ready' label.
- *
- * This ensures the final list of ready PRs reflects all ready work, regardless of
- * where the 'ready' label was originally applied.
- *
- * @param {string} owner - Repository owner
- * @param {string} repo - Repository name
- * @param {boolean} verbose - Whether to log verbose output
- * @returns {Promise<{synced: number, errors: number, details: Array<Object>}>}
- */
-export async function syncReadyTags(owner, repo, verbose = false) {
-  const synced = [];
-  const errors = [];
-
-  if (verbose) {
-    console.log(`[VERBOSE] /merge: Syncing 'ready' tags for ${owner}/${repo}...`);
-  }
-
-  try {
-    // Fetch open PRs with 'ready' label (including body for link detection)
-    const { stdout: prsJson } = await exec(`gh pr list --repo ${owner}/${repo} --label "${READY_LABEL.name}" --state open --json number,title,body,labels --limit 100`);
-    const readyPRs = JSON.parse(prsJson.trim() || '[]');
-
-    if (verbose) {
-      console.log(`[VERBOSE] /merge: Found ${readyPRs.length} open PRs with 'ready' label for tag sync`);
-    }
-
-    // Fetch open issues with 'ready' label
-    const { stdout: issuesJson } = await exec(`gh issue list --repo ${owner}/${repo} --label "${READY_LABEL.name}" --state open --json number,title --limit 100`);
-    const readyIssues = JSON.parse(issuesJson.trim() || '[]');
-
-    if (verbose) {
-      console.log(`[VERBOSE] /merge: Found ${readyIssues.length} open issues with 'ready' label for tag sync`);
-    }
-
-    // Build a set of issue numbers that already have 'ready'
-    const readyIssueNumbers = new Set(readyIssues.map(i => String(i.number)));
-
-    // Step 1: For each PR with 'ready', find linked issue and sync label to it
-    for (const pr of readyPRs) {
-      try {
-        const prBody = pr.body || '';
-        const linkedIssueNumber = extractLinkedIssueNumber(prBody);
-
-        if (!linkedIssueNumber) {
-          if (verbose) {
-            console.log(`[VERBOSE] /merge: PR #${pr.number} has no linked issue (no closing keyword in body)`);
-          }
-          continue;
-        }
-
-        if (readyIssueNumbers.has(String(linkedIssueNumber))) {
-          if (verbose) {
-            console.log(`[VERBOSE] /merge: Issue #${linkedIssueNumber} already has 'ready' label (linked from PR #${pr.number})`);
-          }
-          continue;
-        }
-
-        // Issue doesn't have 'ready' label yet - add it
-        if (verbose) {
-          console.log(`[VERBOSE] /merge: PR #${pr.number} has 'ready', adding to linked issue #${linkedIssueNumber}`);
-        }
-
-        const result = await addLabel('issue', owner, repo, linkedIssueNumber, READY_LABEL.name, verbose);
-        if (result.success) {
-          synced.push({ type: 'pr-to-issue', prNumber: pr.number, issueNumber: Number(linkedIssueNumber) });
-          // Mark this issue as now having 'ready' so we don't process it again
-          readyIssueNumbers.add(String(linkedIssueNumber));
-        } else {
-          errors.push({ type: 'pr-to-issue', prNumber: pr.number, issueNumber: Number(linkedIssueNumber), error: result.error });
-        }
-      } catch (err) {
-        if (verbose) {
-          console.log(`[VERBOSE] /merge: Error syncing label from PR #${pr.number}: ${err.message}`);
-        }
-        errors.push({ type: 'pr-to-issue', prNumber: pr.number, error: err.message });
-      }
-    }
-
-    // Build a set of PR numbers that already have 'ready'
-    const readyPRNumbers = new Set(readyPRs.map(p => String(p.number)));
-
-    // Step 2: For each issue with 'ready', find linked PRs and sync label to them
-    for (const issue of readyIssues) {
-      try {
-        // Search for open PRs linked to this issue via closing keywords
-        const { stdout: linkedPRsJson } = await exec(`gh pr list --repo ${owner}/${repo} --search "in:body closes #${issue.number} OR fixes #${issue.number} OR resolves #${issue.number}" --state open --json number,title,labels --limit 10`);
-        const linkedPRs = JSON.parse(linkedPRsJson.trim() || '[]');
-
-        for (const linkedPR of linkedPRs) {
-          if (readyPRNumbers.has(String(linkedPR.number))) {
-            if (verbose) {
-              console.log(`[VERBOSE] /merge: PR #${linkedPR.number} already has 'ready' label (linked from issue #${issue.number})`);
-            }
-            continue;
-          }
-
-          // PR doesn't have 'ready' label yet - add it
-          if (verbose) {
-            console.log(`[VERBOSE] /merge: Issue #${issue.number} has 'ready', adding to linked PR #${linkedPR.number}`);
-          }
-
-          const result = await addLabel('pr', owner, repo, linkedPR.number, READY_LABEL.name, verbose);
-          if (result.success) {
-            synced.push({ type: 'issue-to-pr', issueNumber: issue.number, prNumber: linkedPR.number });
-            // Mark this PR as now having 'ready'
-            readyPRNumbers.add(String(linkedPR.number));
-          } else {
-            errors.push({ type: 'issue-to-pr', issueNumber: issue.number, prNumber: linkedPR.number, error: result.error });
-          }
-        }
-      } catch (err) {
-        if (verbose) {
-          console.log(`[VERBOSE] /merge: Error syncing label from issue #${issue.number}: ${err.message}`);
-        }
-        errors.push({ type: 'issue-to-pr', issueNumber: issue.number, error: err.message });
-      }
-    }
-  } catch (error) {
-    if (verbose) {
-      console.log(`[VERBOSE] /merge: Error during tag sync: ${error.message}`);
-    }
-    errors.push({ type: 'fetch', error: error.message });
-  }
-
-  if (verbose) {
-    console.log(`[VERBOSE] /merge: Tag sync complete. Synced: ${synced.length}, Errors: ${errors.length}`);
-  }
-
-  return {
-    synced: synced.length,
-    errors: errors.length,
-    details: synced,
-    errorDetails: errors,
-  };
-}
-
 /**
  * Get combined list of ready PRs (from both direct PR labels and issue labels)
  * @param {string} owner - Repository owner
@@ -751,11 +580,15 @@ export async function waitForCI(owner, repo, prNumber, options = {}, verbose = f
     onStatusUpdate = null,
     // Issue #1269: Add timeout for callback to prevent infinite blocking
     callbackTimeout = 60 * 1000, // 1 minute max for callback
+    isCancelled = null, // Issue #1407: Support early exit when cancellation is requested
   } = options;
 
   const startTime = Date.now();
 
   while (Date.now() - startTime < timeout) {
+    // Issue #1407: Check for cancellation before each poll to allow early exit
+    if (isCancelled?.()) return { success: false, status: 'cancelled', error: 'Operation was cancelled' };
+
     let ciStatus;
     try {
       ciStatus = await checkPRCIStatus(owner, repo, prNumber, verbose);
@@ -1455,8 +1288,7 @@ export async function getActiveRepoWorkflows(owner, repo, verbose = false) {
   }
 }
 
-// Issue #1341: Import and re-export post-merge CI functions from separate module
-// to keep this file under the 1500 line limit
+// 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 };
 
@@ -1469,32 +1301,30 @@ export default {
   fetchReadyPullRequests,
   fetchReadyIssuesWithPRs,
   getAllReadyPRs,
-  // Issue #1367: Sync 'ready' tags between linked PRs and issues
-  syncReadyTags,
+  syncReadyTags, // Issue #1367: Sync 'ready' tags between linked PRs and issues
   checkPRCIStatus,
   checkPRMergeable,
   checkMergePermissions,
   mergePullRequest,
   waitForCI,
   parseRepositoryUrl,
-  // Issue #1307: New exports for target branch CI waiting
-  getActiveBranchRuns,
+  getActiveBranchRuns, // Issue #1307: New exports for target branch CI waiting
   waitForBranchCI,
   getDefaultBranch,
-  // Issue #1314: Billing limit detection
+  // Issue #1314: Billing limit detection and enhanced CI status and re-run capabilities
   getCheckRunAnnotations,
   getRepoVisibility,
   checkForBillingLimitError,
   BILLING_LIMIT_ERROR_PATTERN,
-  // Issue #1314: Enhanced CI status and re-run capabilities
   getDetailedCIStatus,
   rerunWorkflowRun,
   rerunFailedJobs,
   getWorkflowRunsForSha,
-  // Issue #1341: Post-merge CI waiting and branch health checking
+  // Issue #1341: Post-merge CI waiting; Issue #1363: Detect active workflows
   waitForCommitCI,
   checkBranchCIHealth,
   getMergeCommitSha,
-  // Issue #1363: Detect active workflows to distinguish "no CI" from race condition
   getActiveRepoWorkflows,
+  // Issue #1413: Use issue timeline to find genuinely linked PRs (avoids false positives from text search)
+  getLinkedPRsFromTimeline,
 };

package/src/opencode.lib.mjs

@@ -465,6 +465,8 @@ export const executeOpenCodeCommand = async params => {
           for (const line of messageLines) {
             await log(line, { level: 'warning' });
           }
+        } else if (exitCode === 130) {
+          await log('\n\n⚠️ OpenCode command interrupted (CTRL+C)');
         } else {
           await log(`\n\n❌ OpenCode command failed with exit code ${exitCode}`, { level: 'error' });
         }

package/src/opencode.prompts.lib.mjs

@@ -213,7 +213,12 @@ Workflow and collaboration.
 Self review.
    - When you check your solution draft, run all tests locally.
    - When you compare with repo style, use gh pr diff [number].
-   - When you finalize, confirm code, tests, and description are consistent.
+   - When you finalize, confirm code, tests, and description are consistent.${
+     argv && argv.promptEnsureAllRequirementsAreMet
+       ? `
+   - When no explicit feedback or requirements is provided, ensure all changes are correct, consistent, validated, tested, logged and fully meet all discussed requirements (check issue description and all comments in issue and in pull request). Ensure all CI/CD checks pass.`
+       : ''
+   }
 
 GitHub CLI command patterns.
    - IMPORTANT: Always use --paginate flag when fetching lists from GitHub API to ensure all results are returned (GitHub returns max 30 per page by default).

package/src/option-suggestions.lib.mjs

@@ -215,6 +215,9 @@ const KNOWN_OPTION_NAMES = [
   'prompt-examples-folder',
   'session-type',
   'working-directory',
+  'prompt-ensure-all-requirements-are-met',
+  'finalize',
+  'finalize-model',
 ];
 
 /**

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

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+
+/**
+ * Finalize module for solve.mjs
+ * After the main solve completes, restarts the AI tool N times with a
+ * requirements-check prompt to verify all requirements are met.
+ *
+ * Extracted from solve.mjs to keep files under 1500 lines.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1383
+ */
+
+// Check if use is already defined globally (when imported from solve.mjs)
+// If not, fetch it (when running standalone)
+if (typeof globalThis.use === 'undefined') {
+  globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
+}
+const use = globalThis.use;
+
+// Use command-stream for consistent $ behavior across runtimes
+const { $ } = await use('command-stream');
+
+// Import shared library functions
+const lib = await import('./lib.mjs');
+const { log } = lib;
+
+// Import shared restart utilities
+const restartShared = await import('./solve.restart-shared.lib.mjs');
+const { executeToolIteration } = restartShared;
+
+/**
+ * Runs finalize requirements-check iterations after the main solve.
+ *
+ * @param {object} params
+ * @param {string} params.issueUrl
+ * @param {string} params.owner
+ * @param {string} params.repo
+ * @param {string|number} params.issueNumber
+ * @param {string|number} params.prNumber
+ * @param {string} params.branchName
+ * @param {string} params.tempDir
+ * @param {object} params.argv - CLI arguments
+ * @param {function} params.cleanupClaudeFile - cleanup function
+ * @returns {Promise<{sessionId, anthropicTotalCostUSD, publicPricingEstimate, pricingInfo}|null>}
+ */
+export const runAutoEnsureRequirements = async ({ issueUrl, owner, repo, issueNumber, prNumber, branchName, tempDir, argv, cleanupClaudeFile }) => {
+  const finalizeCount = argv.finalize;
+  if (!finalizeCount || finalizeCount <= 0 || !prNumber) {
+    return null;
+  }
+
+  await log('');
+  await log(`🔍 FINALIZE: Starting ${finalizeCount} requirements-check restart(s)`);
+  await log('   Will restart the AI tool to verify all requirements are met');
+  await log('');
+
+  // Get PR merge state status for the iterations
+  let currentMergeStateStatus = null;
+  try {
+    const prStateResult = await $`gh api repos/${owner}/${repo}/pulls/${prNumber} --jq '.mergeStateStatus'`;
+    if (prStateResult.code === 0) {
+      currentMergeStateStatus = prStateResult.stdout.toString().trim();
+    }
+  } catch {
+    // Ignore errors getting merge state
+  }
+
+  let sessionId;
+  let anthropicTotalCostUSD;
+  let publicPricingEstimate;
+  let pricingInfo;
+
+  // Use --finalize-model if provided, otherwise fall back to --model
+  const finalizeModel = argv.finalizeModel || argv.model;
+
+  for (let ensureIteration = 1; ensureIteration <= finalizeCount; ensureIteration++) {
+    await log(`🔄 FINALIZE iteration ${ensureIteration}/${finalizeCount}: Restarting to verify requirements...`);
+
+    const ensureFeedbackLines = ['', '='.repeat(60), '🔍 FINALIZE REQUIREMENTS CHECK:', '='.repeat(60), '', 'We need to ensure all changes are correct, consistent, validated, tested, logged and fully meet all discussed requirements (check issue description and all comments in issue and in pull request). Ensure all CI/CD checks pass.', ''];
+
+    const ensureResult = await executeToolIteration({
+      issueUrl,
+      owner,
+      repo,
+      issueNumber,
+      prNumber,
+      branchName,
+      tempDir,
+      mergeStateStatus: currentMergeStateStatus,
+      feedbackLines: ensureFeedbackLines,
+      argv: {
+        ...argv,
+        // Override model with finalize-model for this iteration
+        model: finalizeModel,
+        // Enable prompt-ensure only during finalize cycle (not the first regular run)
+        promptEnsureAllRequirementsAreMet: true,
+        // Prevent recursive finalize
+        finalize: 0,
+      },
+    });
+
+    // Update session data from finalize restart
+    if (ensureResult) {
+      if (ensureResult.sessionId) sessionId = ensureResult.sessionId;
+      if (ensureResult.anthropicTotalCostUSD) anthropicTotalCostUSD = ensureResult.anthropicTotalCostUSD;
+      if (ensureResult.publicPricingEstimate) publicPricingEstimate = ensureResult.publicPricingEstimate;
+      if (ensureResult.pricingInfo) pricingInfo = ensureResult.pricingInfo;
+    }
+
+    await log(`✅ FINALIZE iteration ${ensureIteration}/${finalizeCount} complete`);
+    await log('');
+  }
+
+  // Clean up CLAUDE.md/.gitkeep after ensure restarts
+  await cleanupClaudeFile(tempDir, branchName, null, argv);
+
+  return { sessionId, anthropicTotalCostUSD, publicPricingEstimate, pricingInfo };
+};
+
+export default { runAutoEnsureRequirements };

package/src/solve.config.lib.mjs

@@ -374,6 +374,21 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: 'Automatically accept the pending GitHub repository or organization invitation for the specific repository/organization being solved, before checking write access. Unlike /accept_invites which accepts all pending invitations, this only accepts the invite for the target repo/org.',
     default: false,
   },
+  'prompt-ensure-all-requirements-are-met': {
+    type: 'boolean',
+    description: '[EXPERIMENTAL] Add a prompt hint to the system prompt to ensure all changes are correct, consistent, validated, tested, logged and fully meet all discussed requirements. Enabled automatically by --finalize during finalize cycle iterations only.',
+    default: false,
+  },
+  finalize: {
+    type: 'number',
+    description: '[EXPERIMENTAL] After the main solve completes, automatically restart the AI tool N times (default: 1) with a requirements-check prompt to verify all requirements are met. Use --finalize-model to override the model for finalize iterations.',
+    default: 0,
+  },
+  'finalize-model': {
+    type: 'string',
+    description: '[EXPERIMENTAL] Model to use for --finalize iterations. Defaults to the same model as --model.',
+    default: undefined,
+  },
 };
 
 // Function to create yargs configuration - avoids duplication
@@ -535,6 +550,17 @@ export const parseArguments = async (yargs, hideBin) => {
     }
   }
 
+  // --finalize normalization
+  // Issue #1383: When finalize is enabled (as boolean or number), normalize to iteration count
+  // NOTE: promptEnsureAllRequirementsAreMet is NOT set here — it is only enabled during
+  // the finalize cycle iterations themselves (not the first regular worker model run)
+  if (argv && argv.finalize) {
+    // Normalize: if passed as boolean true (flag without value), treat as 1 iteration
+    if (argv.finalize === true) {
+      argv.finalize = 1;
+    }
+  }
+
   if (argv.tool === 'opencode' && !modelExplicitlyProvided) {
     // User did not explicitly provide --model, so use the correct default for opencode
     argv.model = 'grok-code-fast-1';

package/src/solve.interrupt.lib.mjs

@@ -0,0 +1,70 @@
+/**
+ * Interrupt wrapper factory for CTRL+C handling in solve sessions.
+ *
+ * On SIGINT, auto-commits uncommitted changes and uploads session logs if --attach-logs is enabled.
+ */
+
+/**
+ * Creates an interrupt wrapper function that auto-commits and uploads logs on CTRL+C.
+ * @param {object} deps - Dependencies
+ * @param {object} deps.cleanupContext - Mutable context object with tempDir, argv, branchName, prNumber, owner, repo
+ * @param {Function} deps.checkForUncommittedChanges - Tool-specific function to check and commit changes
+ * @param {boolean} deps.shouldAttachLogs - Whether --attach-logs is enabled
+ * @param {Function} deps.attachLogToGitHub - Function to upload log to GitHub PR
+ * @param {Function} deps.getLogFile - Function that returns the current log file path
+ * @param {Function} deps.sanitizeLogContent - Function to sanitize log content before upload
+ * @param {object} deps.$ - Shell command runner
+ * @param {Function} deps.log - Logging function
+ * @returns {Function} Async interrupt wrapper
+ */
+export const createInterruptWrapper = ({ cleanupContext, checkForUncommittedChanges, shouldAttachLogs, attachLogToGitHub, getLogFile, sanitizeLogContent, $, log }) => {
+  return async () => {
+    const ctx = cleanupContext;
+    if (!ctx.tempDir || !ctx.argv) return;
+
+    await log('\n⚠️  Session interrupted by user (CTRL+C)');
+
+    // Always auto-commit uncommitted changes on CTRL+C to preserve work
+    if (ctx.branchName) {
+      try {
+        await checkForUncommittedChanges(
+          ctx.tempDir,
+          ctx.owner,
+          ctx.repo,
+          ctx.branchName,
+          $,
+          log,
+          true, // always autoCommit on CTRL+C to preserve work
+          false // no autoRestart
+        );
+      } catch (commitError) {
+        await log(`⚠️  Could not auto-commit changes on interrupt: ${commitError.message}`, {
+          level: 'warning',
+        });
+      }
+    }
+
+    // Upload logs if --attach-logs is enabled and we have a PR
+    if (shouldAttachLogs && ctx.prNumber && ctx.owner && ctx.repo) {
+      await log('📎 Uploading interrupted session logs to Pull Request...');
+      try {
+        await attachLogToGitHub({
+          logFile: getLogFile(),
+          targetType: 'pr',
+          targetNumber: ctx.prNumber,
+          owner: ctx.owner,
+          repo: ctx.repo,
+          $,
+          log,
+          sanitizeLogContent,
+          verbose: ctx.argv.verbose || false,
+          errorMessage: 'Session interrupted by user (CTRL+C)',
+        });
+      } catch (uploadError) {
+        await log(`⚠️  Could not upload logs on interrupt: ${uploadError.message}`, {
+          level: 'warning',
+        });
+      }
+    }
+  };
+};

package/src/solve.mjs

@@ -73,10 +73,12 @@ const { createUncaughtExceptionHandler, createUnhandledRejectionHandler, handleM
 
 const watchLib = await import('./solve.watch.lib.mjs');
 const { startWatchMode } = watchLib;
-const autoMergeLib = await import('./solve.auto-merge.lib.mjs');
-const { startAutoRestartUntilMergeable } = autoMergeLib;
+const { startAutoRestartUntilMergeable } = await import('./solve.auto-merge.lib.mjs');
+const { runAutoEnsureRequirements } = await import('./solve.auto-ensure.lib.mjs');
 const exitHandler = await import('./exit-handler.lib.mjs');
 const { initializeExitHandler, installGlobalExitHandlers, safeExit } = exitHandler;
+const interruptLib = await import('./solve.interrupt.lib.mjs');
+const { createInterruptWrapper } = interruptLib;
 const getResourceSnapshot = memoryCheck.getResourceSnapshot;
 
 // Import new modular components
@@ -162,22 +164,17 @@ if (argv.sentry) {
     },
   });
 }
-// Create a cleanup wrapper that will be populated with context later
-let cleanupContext = { tempDir: null, argv: null, limitReached: false };
+// Create cleanup/interrupt wrappers populated with context as solve progresses
+let cleanupContext = { tempDir: null, argv: null, limitReached: false, branchName: null, prNumber: null, owner: null, repo: null };
 const cleanupWrapper = async () => {
   if (cleanupContext.tempDir && cleanupContext.argv) {
     await cleanupTempDirectory(cleanupContext.tempDir, cleanupContext.argv, cleanupContext.limitReached);
   }
 };
-// Initialize the exit handler with getAbsoluteLogPath function and cleanup wrapper
-initializeExitHandler(getAbsoluteLogPath, log, cleanupWrapper);
+const interruptWrapper = createInterruptWrapper({ cleanupContext, checkForUncommittedChanges, shouldAttachLogs, attachLogToGitHub, getLogFile, sanitizeLogContent, $, log });
+initializeExitHandler(getAbsoluteLogPath, log, cleanupWrapper, interruptWrapper);
 installGlobalExitHandlers();
 
-// Note: Version and raw command are logged BEFORE parseArguments() (see above)
-// This ensures they appear even if strict validation fails
-// Strict options validation is now handled by yargs .strict() mode in solve.config.lib.mjs
-// This prevents unrecognized options from being silently ignored (issue #453, #482)
-
 // Now handle argument validation that was moved from early checks
 let issueUrl = argv['issue-url'] || argv._[0];
 if (!issueUrl) {
@@ -193,9 +190,11 @@ if (!urlValidation.isValid) {
 }
 const { isIssueUrl, isPrUrl, normalizedUrl, owner, repo, number: urlNumber } = urlValidation;
 issueUrl = normalizedUrl || issueUrl;
-// Store owner and repo globally for error handlers early
+// Store owner and repo globally for error handlers and interrupt context
 global.owner = owner;
 global.repo = repo;
+cleanupContext.owner = owner;
+cleanupContext.repo = repo;
 // Setup unhandled error handlers to ensure log path is always shown
 const errorHandlerOptions = {
   log,
@@ -492,8 +491,6 @@ if (isPrUrl) {
       }
     }
     await log(`📝 PR branch: ${prBranch}`);
-    // Extract issue number from PR body using GitHub linking detection library
-    // This ensures we only detect actual GitHub-recognized linking keywords
     const prBody = prData.body || '';
     const extractedIssueNumber = extractLinkedIssueNumber(prBody);
     if (extractedIssueNumber) {
@@ -524,9 +521,12 @@ if (isPrUrl) {
 // Pass workspace info for --enable-workspaces mode (works with all tools)
 const workspaceInfo = argv.enableWorkspaces ? { owner, repo, issueNumber } : null;
 const { tempDir, workspaceTmpDir, needsClone } = await setupTempDirectory(argv, workspaceInfo);
-// Populate cleanup context for signal handlers
+// Populate cleanup context for signal handlers (owner/repo updated again here for redundancy)
 cleanupContext.tempDir = tempDir;
 cleanupContext.argv = argv;
+cleanupContext.owner = owner;
+cleanupContext.repo = repo;
+if (prNumber) cleanupContext.prNumber = prNumber;
 // Initialize limitReached variable outside try block for finally clause
 let limitReached = false;
 try {
@@ -570,6 +570,7 @@ try {
     repo,
     prNumber,
   });
+  cleanupContext.branchName = branchName;
 
   // Auto-merge default branch to pull request branch if enabled
   let autoMergeFeedbackLines = [];
@@ -614,9 +615,6 @@ try {
     // prNumber is already set from earlier when we parsed the PR
   }
 
-  // Don't build the prompt yet - we'll build it after we have all the information
-  // This includes PR URL (if created) and comment info (if in continue mode)
-
   // Handle auto PR creation using the new module
   const autoPrResult = await handleAutoPrCreation({
     argv,
@@ -647,6 +645,7 @@ try {
       claudeCommitHash = autoPrResult.claudeCommitHash;
     }
   }
+  if (prNumber) cleanupContext.prNumber = prNumber;
 
   // CRITICAL: Validate that we have a PR number when required
   // This prevents continuing without a PR when one was supposed to be created
@@ -695,9 +694,6 @@ try {
     await log(formatAligned('', 'Workflow:', 'AI will create the PR', 2));
   }
 
-  // Don't build the prompt yet - we'll build it after we have all the information
-  // This includes PR URL (if created) and comment info (if in continue mode)
-
   // Start work session using the new module
   // Determine session type based on command line flags
   // See: https://github.com/link-assistant/hive-mind/issues/1152
@@ -1186,7 +1182,6 @@ try {
     await log('ℹ️  Playwright MCP auto-cleanup disabled via --no-playwright-mcp-auto-cleanup', { verbose: true });
   }
 
-  // Check for uncommitted changes
   // When limit is reached, force auto-commit of any uncommitted changes to preserve work
   const shouldAutoCommit = argv['auto-commit-uncommitted-changes'] || limitReached;
   const autoRestartEnabled = argv['autoRestartOnUncommittedChanges'] !== false;
@@ -1234,11 +1229,6 @@ try {
   }
 
   // Search for newly created pull requests and comments
-  // Pass shouldRestart to prevent early exit when auto-restart is needed
-  // Include agent tool pricing data when available (publicPricingEstimate, pricingInfo)
-  // Issue #1088: Pass errorDuringExecution for "Finished with errors" state
-  // Issue #1152: Pass sessionType for differentiated log comments
-  // Issue #1154: Track if logs were already uploaded to prevent duplicates
   const verifyResult = await verifyResults(owner, repo, branchName, issueNumber, prNumber, prUrl, referenceTime, argv, shouldAttachLogs, shouldRestart, sessionId, tempDir, anthropicTotalCostUSD, publicPricingEstimate, pricingInfo, errorDuringExecution, sessionType);
   const logsAlreadyUploaded = verifyResult?.logUploadSuccess || false;
 
@@ -1293,6 +1283,15 @@ try {
     }
   }
 
+  // Issue #1383: --finalize
+  const autoEnsureResult = await runAutoEnsureRequirements({ issueUrl, owner, repo, issueNumber, prNumber, branchName, tempDir, argv, cleanupClaudeFile });
+  if (autoEnsureResult) {
+    if (autoEnsureResult.sessionId) sessionId = autoEnsureResult.sessionId;
+    if (autoEnsureResult.anthropicTotalCostUSD) anthropicTotalCostUSD = autoEnsureResult.anthropicTotalCostUSD;
+    if (autoEnsureResult.publicPricingEstimate) publicPricingEstimate = autoEnsureResult.publicPricingEstimate;
+    if (autoEnsureResult.pricingInfo) pricingInfo = autoEnsureResult.pricingInfo;
+  }
+
   // Start watch mode if enabled OR if we need to handle uncommitted changes
   if (argv.verbose) {
     await log('');

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

@@ -366,7 +366,29 @@ export function registerMergeCommand(bot, options) {
 
     // Cancel the operation
     operation.processor.cancel();
-    await ctx.answerCbQuery('Merge operation cancellation requested. The current PR will finish processing.');
+    // Issue #1407: Acknowledge the cancel with a short toast message
+    await ctx.answerCbQuery('Cancellation requested.');
+
+    // Issue #1407: Immediately hide the cancel button and update the message to show
+    // that the queue is being cancelled. Without this, the button stays visible until
+    // the current PR finishes processing (which can take hours if waiting for CI).
+    try {
+      const cancellingMessage = operation.processor.formatProgressMessage();
+      await ctx.editMessageText(cancellingMessage, {
+        parse_mode: 'MarkdownV2',
+        // No reply_markup = cancel button is removed immediately
+      });
+    } catch (err) {
+      // If the full message edit fails, fall back to just removing the button
+      if (!err.message?.includes('message is not modified')) {
+        VERBOSE && console.log(`[VERBOSE] /merge: Error updating message on cancel: ${err.message}`);
+      }
+      try {
+        await ctx.editMessageReplyMarkup({ inline_keyboard: [] });
+      } catch {
+        // Ignore errors - the button will be removed when the operation completes
+      }
+    }
 
     VERBOSE && console.log(`[VERBOSE] /merge: Cancelled operation for ${repoKey}`);
   });

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

@@ -408,11 +408,22 @@ export class MergeQueueProcessor {
                 await this.onProgress(this.getProgressUpdate());
               }
             },
+            // Issue #1407: Pass cancellation check so CI wait can abort early
+            isCancelled: () => this.isCancelled,
           },
           this.verbose
         );
 
         if (!waitResult.success) {
+          // Issue #1407: If cancelled during CI wait, mark as skipped (not failed)
+          // so the queue can cleanly stop without misleading failure statistics
+          if (waitResult.status === 'cancelled') {
+            item.status = MergeItemStatus.SKIPPED;
+            item.error = 'Cancelled';
+            this.stats.skipped++;
+            this.log(`Skipped PR #${item.pr.number}: cancelled during CI wait`);
+            return;
+          }
           item.status = MergeItemStatus.FAILED;
           item.error = waitResult.error;
           this.stats.failed++;
@@ -686,6 +697,11 @@ export class MergeQueueProcessor {
     message += `${update.progress.processed}/${update.progress.total} PRs processed\n`;
     message += '```\n\n';
 
+    // Issue #1407: Show cancelling indicator when cancellation requested but queue still running
+    if (this.isCancelled) {
+      message += `🛑 *Cancelling\\.\\.\\.*\n\n`;
+    }
+
     // Status summary with emojis
     message += `✅ Merged: ${update.stats.merged}  `;
     message += `❌ Failed: ${update.stats.failed}  `;