@link-assistant/hive-mind 2.7.2 → 2.7.4

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 2.7.4
+
+### Patch Changes
+
+- 4bf1734: Cancel `/merge` immediately at every stage. Poll delays were uninterruptible `setTimeout` calls, so a cancel was only noticed once the delay expired — up to 5 minutes. Every merge wait now sleeps in short steps and aborts within ~100ms of the Cancel button, including the repo-wide actions wait, which previously had no cancellation support at all.
+
+## 2.7.3
+
+### Patch Changes
+
+- e6c67c0: Reset Anthropic cost accounting between fresh auto-restart working sessions while preserving cumulative totals for true session resumes.
+
 ## 2.7.2
 
 ### Patch Changes

package/package.json

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

package/src/anthropic-cost-accumulator.lib.mjs

@@ -29,12 +29,11 @@
  * shown next to the full-session public estimate covers the same scope. This
  * module is the single source of truth for that running total:
  *
- *   - Each `solve` process seeds the accumulator once from
- *     `--previous-anthropic-cost` (0 for the first run; the carried-forward
- *     total for an auto-resumed run).
- *   - Every finished Claude process adds its own `total_cost_usd` via
- *     `addAnthropicRunCost`, which also covers the in-process auto-merge loop
- *     (each iteration is a separate Claude process in the same node process).
+ *   - Each `executeClaude` call starts a scope. Fresh sessions reset it; true
+ *     resumes retain it or seed it from `--previous-anthropic-cost` when the
+ *     resume crosses a process boundary.
+ *   - Every finished Claude process in that logical session adds its own
+ *     `total_cost_usd` via `addAnthropicRunCost`.
  *   - The display and the cross-process spawn both read the cumulative total,
  *     so "Calculated by Anthropic" tracks the full session.
  *
@@ -43,12 +42,12 @@
  * future model. See docs/case-studies/issue-1886/ for the full analysis.
  */
 
-// Module-level singleton: the cumulative Anthropic cost for the current logical
-// session (this node process plus everything seeded from prior processes).
+// Module-level singleton: the cumulative Anthropic cost for the active logical
+// session (including anything seeded by a true resume from a prior process).
 let cumulativeAnthropicCostUSD = 0;
-// Seeding must happen exactly once per node process. The auto-merge loop calls
-// runClaude (and therefore the seed helper) repeatedly within a single process;
-// re-seeding from the same CLI flag each time would wipe out accumulation.
+// Seeding must happen exactly once per active scope. Resume retries may call the
+// seed helper repeatedly; re-seeding from the same CLI flag would wipe out the
+// costs already accumulated in this process.
 let seeded = false;
 
 /**
@@ -61,10 +60,34 @@ const toCostAmount = value => {
   return Number.isFinite(n) && n > 0 ? n : 0;
 };
 
+/**
+ * Start accounting for one logical Claude session.
+ *
+ * A fresh execution owns a new transcript and therefore a new cost scope. A
+ * true `--resume` execution continues the active scope (or restores it from
+ * `--previous-anthropic-cost` when the resume happens in a child process).
+ * Calling this at the public `executeClaude` boundary keeps retries inside one
+ * scope while preventing watch-mode and mergeability auto-restarts from
+ * inheriting the preceding working session's cost.
+ *
+ * @param {Object} [options]
+ * @param {boolean|string} [options.resume=false] - whether this execution resumes an existing Claude session
+ * @param {number|string|null} [options.previousAnthropicCost=0] - cumulative cost restored by a resumed child process
+ * @returns {number} the cumulative cost at the start of this execution
+ */
+export const beginAnthropicCostScope = ({ resume = false, previousAnthropicCost = 0 } = {}) => {
+  if (!resume) {
+    cumulativeAnthropicCostUSD = 0;
+    seeded = true;
+    return cumulativeAnthropicCostUSD;
+  }
+  return seedCumulativeAnthropicCost(previousAnthropicCost);
+};
+
 /**
  * Seed the accumulator from the carried-forward previous-run cost, exactly once
- * per node process. Subsequent calls are no-ops so the in-process auto-merge
- * loop does not reset the running total.
+ * per active scope. Subsequent calls are no-ops so resume retries do not reset
+ * the running total.
  * @param {number|string|null|undefined} previousAnthropicCostUSD
  * @returns {number} the cumulative total after seeding
  */
@@ -98,8 +121,8 @@ export const getCumulativeAnthropicCost = () => cumulativeAnthropicCostUSD;
 export const hasCumulativeAnthropicCost = () => cumulativeAnthropicCostUSD > 0;
 
 /**
- * Reset the accumulator. Intended for tests — production code seeds once and
- * accumulates for the lifetime of the process.
+ * Reset the accumulator. Intended for tests; production code starts scopes via
+ * `beginAnthropicCostScope`.
  */
 export const resetCumulativeAnthropicCost = () => {
   cumulativeAnthropicCostUSD = 0;

package/src/claude.lib.mjs

@@ -17,7 +17,7 @@ import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
 import Decimal from 'decimal.js-light';
 import { createEmptySubSessionUsage, accumulateModelUsage, mergeResultModelUsage, createSubAgentCallEntry, accumulateSubAgentUsage, getRawRequestInputTokens, displaySessionTokenUsage } from './claude.budget-stats.lib.mjs';
 import { buildClaudeResumeCommand, buildClaudeAutonomousResumeCommand } from './claude.command-builder.lib.mjs';
-import { seedCumulativeAnthropicCost, addAnthropicRunCost } from './anthropic-cost-accumulator.lib.mjs'; // Issue #1886
+import { beginAnthropicCostScope, seedCumulativeAnthropicCost, addAnthropicRunCost } from './anthropic-cost-accumulator.lib.mjs'; // Issues #1886, #2056
 import { buildSolveResumeCommand } from './solve.resume-command.lib.mjs'; // Issue #942
 import { SESSION_FORCE_KILLED_MARKER, postTrackedComment } from './tool-comments.lib.mjs'; // Issue #1625
 import { handleClaudeRuntimeSwitch } from './claude.runtime-switch.lib.mjs'; // see issue #1141
@@ -236,6 +236,8 @@ export const resolveThinkingSettings = async (argv, log) => {
 export const checkPlaywrightMcpAvailability = ensureClaudePlaywrightMcpServer;
 export const executeClaude = async params => {
   const { issueUrl, issueNumber, prNumber, prUrl, branchName, tempDir, workspaceTmpDir, isContinueMode, mergeStateStatus, forkedRepo, feedbackLines, forkActionsUrl, owner, repo, argv, log, setLogFile, getLogFile, formatAligned, getResourceSnapshot, claudePath, $ } = params;
+  // Issue #2056: reset fresh sessions while retaining issue #1886's true-resume accumulation.
+  beginAnthropicCostScope({ resume: argv.resume, previousAnthropicCost: argv.previousAnthropicCost });
   if (argv.promptSubagentsViaAgentCommander) {
     try {
       await $`which start-agent`;
@@ -304,11 +306,9 @@ export const executeClaude = async params => {
   }
   const escapedPrompt = prompt.replace(/"/g, '\\"').replace(/\$/g, '\\$');
   const escapedSystemPrompt = systemPrompt.replace(/"/g, '\\"').replace(/\$/g, '\\$');
-
   // Issue #1877: deploy the experimental HANDOFF.md Agent Skill so Claude loads
   // it natively from .claude/skills/handoff/SKILL.md (no-op unless --use-handoff).
   await deployHandoffSkill({ tempDir, argv, log, $ });
-
   return await withAgentsMdAsClaudeMd({ tempDir, branchName, argv, prompt, fs, path, $, log, formatAligned }, () =>
     executeClaudeCommand({
       tempDir,
@@ -1176,6 +1176,7 @@ export const executeClaudeCommand = async params => {
       // logs the failure and returns false; we fall through to the normal commandFailed return below
       // (the 400 is not a transient pattern, so it is not retried).
       if (commandFailed && retryableLastError.requiresFreshSession && (await tryThinkingBlockRecovery({ classified: retryableLastError, source: 'result', sessionId }))) {
+        beginAnthropicCostScope({ resume: argv.resume, previousAnthropicCost: argv.previousAnthropicCost });
         return await executeWithRetry();
       }
       // Issues #1331, #1353, #1472/#1475: Unified transient error retry (exponential backoff, session preservation)
@@ -1376,6 +1377,7 @@ export const executeClaudeCommand = async params => {
       // Issue #1834: Corrupted extended-thinking blocks surfaced as a thrown exception. Same recovery
       // as the streamed-result path: resume the session first, then fall back to a fresh restart.
       if (retryableException.requiresFreshSession && (await tryThinkingBlockRecovery({ classified: retryableException, source: 'exception', sessionId }))) {
+        beginAnthropicCostScope({ resume: argv.resume, previousAnthropicCost: argv.previousAnthropicCost });
         retryCount++;
         return await executeWithRetry();
       }

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

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+/**
+ * GitHub Merge CI Wait Loops
+ *
+ * The long-running CI polling loops used by the /merge command.
+ * Split from github-merge.lib.mjs to maintain file size limits.
+ *
+ * Every wait here is cancellable: the poll delay is slept in short steps via
+ * `cancellableSleep`, so pressing the Cancel button takes effect within ~100ms
+ * instead of after a full poll interval.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/2072
+ */
+
+import { checkPRCIStatus, getActiveBranchRuns } from './github-merge.lib.mjs';
+import { cancellableSleep } from './interruptible-sleep.lib.mjs';
+
+/**
+ * Wait for CI/CD to complete with polling
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {number} prNumber - Pull request number
+ * @param {Object} options - Wait options
+ * @param {number} options.timeout - Maximum wait time in ms (default: 30 minutes)
+ * @param {number} options.pollInterval - Polling interval in ms (default: 30 seconds)
+ * @param {Function} options.onStatusUpdate - Callback for status updates
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{success: boolean, status: string, error: string|null}>}
+ */
+export async function waitForCI(owner, repo, prNumber, options = {}, verbose = false) {
+  const {
+    timeout = 30 * 60 * 1000,
+    pollInterval = 30 * 1000,
+    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);
+    } catch (error) {
+      // Issue #1269: Log and continue on CI check errors instead of crashing
+      console.error(`[ERROR] /merge: Error checking CI status for PR #${prNumber}: ${error.message}`);
+      verbose && console.error(`[VERBOSE] /merge: CI check error details:`, error);
+      // Wait and retry
+      await cancellableSleep(pollInterval, isCancelled);
+      continue;
+    }
+
+    if (onStatusUpdate) {
+      // Issue #1269: Wrap callback with timeout to prevent infinite blocking; #1346: capture and clear timeout handle to prevent dangling timer
+      try {
+        let callbackTimeoutId;
+        await Promise.race([
+          onStatusUpdate(ciStatus),
+          new Promise((_, reject) => {
+            callbackTimeoutId = setTimeout(() => reject(new Error(`Callback timeout after ${callbackTimeout}ms`)), callbackTimeout);
+          }),
+        ]).finally(() => clearTimeout(callbackTimeoutId));
+      } catch (callbackError) {
+        // Issue #1269: Log callback errors but continue processing
+        console.error(`[ERROR] /merge: Status update callback failed for PR #${prNumber}: ${callbackError.message}`);
+        verbose && console.error(`[VERBOSE] /merge: Callback error details:`, callbackError);
+        // Continue processing even if callback fails - don't let UI issues block merging
+      }
+    }
+
+    if (ciStatus.status === 'success') {
+      return { success: true, status: 'success', error: null };
+    }
+
+    if (ciStatus.status === 'failure') {
+      return { success: false, status: 'failure', error: 'CI checks failed' };
+    }
+
+    if (ciStatus.status === 'terminal_github_entity_error') {
+      return {
+        success: false,
+        status: 'terminal_github_entity_error',
+        error: ciStatus.error || 'GitHub repository, pull request, issue, or branch is no longer accessible',
+      };
+    }
+
+    if (ciStatus.status === 'pending') {
+      if (verbose) {
+        console.log(`[VERBOSE] /merge: Waiting for CI... (${Math.round((Date.now() - startTime) / 1000)}s elapsed)`);
+      }
+      await cancellableSleep(pollInterval, isCancelled);
+      continue;
+    }
+
+    // Unknown status - wait and retry
+    await cancellableSleep(pollInterval, isCancelled);
+  }
+
+  return { success: false, status: 'timeout', error: 'CI check timeout exceeded' };
+}
+
+/**
+ * Wait for all active workflow runs on a branch to complete
+ * Issue #1307: Ensures all CI runs on target branch are complete before merging
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {string} branch - Branch name (default: main)
+ * @param {Object} options - Wait options
+ * @param {number} options.timeout - Maximum wait time in ms (default: 45 minutes)
+ * @param {number} options.pollInterval - Polling interval in ms (default: 30 seconds)
+ * @param {Function} options.onStatusUpdate - Callback for status updates
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{success: boolean, waitedForRuns: boolean, completedRuns: number, error: string|null}>}
+ */
+export async function waitForBranchCI(owner, repo, branch = 'main', options = {}, verbose = false) {
+  const { timeout = 45 * 60 * 1000, pollInterval = 30 * 1000, onStatusUpdate = null, isCancelled = null } = options;
+
+  const startTime = Date.now();
+  let totalWaitedRuns = 0;
+
+  if (verbose) {
+    console.log(`[VERBOSE] /merge: Checking for active CI runs on ${owner}/${repo} branch ${branch}...`);
+  }
+
+  while (Date.now() - startTime < timeout) {
+    if (isCancelled?.()) return { success: false, waitedForRuns: totalWaitedRuns > 0, completedRuns: totalWaitedRuns, error: 'Operation was cancelled' };
+    let activeRuns;
+    try {
+      activeRuns = await getActiveBranchRuns(owner, repo, branch, verbose);
+    } catch (error) {
+      // Log and continue on errors
+      console.error(`[ERROR] /merge: Error checking branch CI: ${error.message}`);
+      await cancellableSleep(pollInterval, isCancelled);
+      continue;
+    }
+
+    if (onStatusUpdate) {
+      try {
+        await onStatusUpdate({
+          hasActiveRuns: activeRuns.hasActiveRuns,
+          count: activeRuns.count,
+          runs: activeRuns.runs,
+          elapsedMs: Date.now() - startTime,
+        });
+      } catch (callbackError) {
+        // Log callback errors but continue
+        console.error(`[ERROR] /merge: Status update callback failed: ${callbackError.message}`);
+      }
+    }
+
+    if (!activeRuns.hasActiveRuns) {
+      if (verbose) {
+        console.log(`[VERBOSE] /merge: No active CI runs on ${branch} branch. Ready to proceed.`);
+      }
+      return {
+        success: true,
+        waitedForRuns: totalWaitedRuns > 0,
+        completedRuns: totalWaitedRuns,
+        error: null,
+      };
+    }
+
+    totalWaitedRuns = Math.max(totalWaitedRuns, activeRuns.count);
+
+    if (verbose) {
+      const elapsedSec = Math.round((Date.now() - startTime) / 1000);
+      console.log(`[VERBOSE] /merge: Waiting for ${activeRuns.count} active runs on ${branch}... (${elapsedSec}s elapsed)`);
+    }
+
+    await cancellableSleep(pollInterval, isCancelled);
+  }
+
+  // Issue #2072: a cancel landing as the timeout expires must still report 'cancelled'
+  // rather than falling through to the extra API round-trip below.
+  if (isCancelled?.()) return { success: false, waitedForRuns: totalWaitedRuns > 0, completedRuns: totalWaitedRuns, error: 'Operation was cancelled' };
+
+  // Timeout reached
+  // Issue #1722: if the final check throws, do NOT silently report "ready".
+  // Treat it the same as still-active (force a timeout failure), so /merge
+  // waits/retries instead of merging on top of a still-running CI run.
+  let finalCheck;
+  try {
+    finalCheck = await getActiveBranchRuns(owner, repo, branch, verbose);
+  } catch (error) {
+    return {
+      success: false,
+      waitedForRuns: true,
+      completedRuns: totalWaitedRuns,
+      error: `Timeout reached and final CI check failed on ${branch}: ${error.message}`,
+    };
+  }
+  if (finalCheck.hasActiveRuns) {
+    return {
+      success: false,
+      waitedForRuns: true,
+      completedRuns: totalWaitedRuns - finalCheck.count,
+      error: `Timeout waiting for ${finalCheck.count} CI runs on ${branch} branch`,
+    };
+  }
+
+  return {
+    success: true,
+    waitedForRuns: totalWaitedRuns > 0,
+    completedRuns: totalWaitedRuns,
+    error: null,
+  };
+}
+
+export default {
+  waitForCI,
+  waitForBranchCI,
+};

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

@@ -12,6 +12,7 @@ import { getWorkflowRunsForSha } from './github-merge.lib.mjs';
 import { promisify } from 'util';
 import { exec as execCallback } from 'child_process';
 import { ghWithRateLimitRetry } from './github-rate-limit.lib.mjs';
+import { cancellableSleep } from './interruptible-sleep.lib.mjs';
 
 const execRaw = promisify(execCallback);
 // Issue #1726: every gh call must be rate-limit safe.
@@ -54,7 +55,7 @@ export async function waitForCommitCI(owner, repo, sha, options = {}, verbose =
       runs = await getWorkflowRunsForSha(owner, repo, sha, verbose);
     } catch (error) {
       console.error(`[ERROR] /merge: Error checking commit CI: ${error.message}`);
-      await new Promise(resolve => setTimeout(resolve, pollInterval));
+      await cancellableSleep(pollInterval, isCancelled);
       continue;
     }
 
@@ -71,7 +72,7 @@ export async function waitForCommitCI(owner, repo, sha, options = {}, verbose =
       if (verbose) {
         console.log(`[VERBOSE] /merge: No CI runs yet for commit ${sha.substring(0, 7)} (attempt ${noRunsIterations}/${MAX_NO_RUNS_ITERATIONS}). Waiting...`);
       }
-      await new Promise(resolve => setTimeout(resolve, pollInterval));
+      await cancellableSleep(pollInterval, isCancelled);
       continue;
     }
 
@@ -134,7 +135,13 @@ export async function waitForCommitCI(owner, repo, sha, options = {}, verbose =
       console.log(`[VERBOSE] /merge: Waiting for ${inProgressRuns.length} CI run(s) to complete... (${elapsedSec}s elapsed)`);
     }
 
-    await new Promise(resolve => setTimeout(resolve, pollInterval));
+    await cancellableSleep(pollInterval, isCancelled);
+  }
+
+  // Issue #2072: a cancel that lands while the timeout is expiring must still report
+  // 'cancelled' rather than falling through to an extra API round-trip below.
+  if (isCancelled?.()) {
+    return { success: false, status: 'cancelled', runs: [], failedRuns: [], error: 'Operation was cancelled' };
   }
 
   // Timeout reached

package/src/github-merge-repo-actions.lib.mjs

@@ -13,6 +13,7 @@ import { promisify } from 'util';
 import { exec as execCallback } from 'child_process';
 import { githubLimits } from './config.lib.mjs';
 import { ghWithRateLimitRetry } from './github-rate-limit.lib.mjs';
+import { cancellableSleep } from './interruptible-sleep.lib.mjs';
 const execRaw = promisify(execCallback);
 // Issue #1722: raise exec maxBuffer above Node's 1 MB default for paginated gh
 // API responses (workflow runs can easily exceed that on busy repos).
@@ -70,15 +71,21 @@ export async function getAllActiveRepoRuns(owner, repo, verbose = false) {
  * @param {string} owner - Repository owner
  * @param {string} repo - Repository name
  * @param {Object} options - Wait options (timeout, pollInterval, onStatusUpdate)
+ * @param {Function} [options.isCancelled] - Issue #2072: polled during the poll delay so a
+ *   cancel (or SIGINT/SIGTERM) aborts the wait instead of sleeping out a full 5-minute interval
  * @param {boolean} verbose - Whether to log verbose output
  * @returns {Promise<{success: boolean, waitedForRuns: boolean, timedOut: boolean, remainingRuns: Array}>}
  */
 export async function waitForAllRepoActions(owner, repo, options = {}, verbose = false) {
-  const { timeout = 45 * 60 * 1000, pollInterval = 5 * 60 * 1000, onStatusUpdate = null } = options;
+  const { timeout = 45 * 60 * 1000, pollInterval = 5 * 60 * 1000, onStatusUpdate = null, isCancelled = null } = options;
   const startTime = Date.now();
   let peakRunCount = 0;
 
   while (Date.now() - startTime < timeout) {
+    // Issue #2072: no stage of the merge flow may hold up a cancel.
+    if (isCancelled?.()) {
+      return { success: false, waitedForRuns: peakRunCount > 0, timedOut: false, cancelled: true, remainingRuns: [] };
+    }
     let active;
     try {
       active = await getAllActiveRepoRuns(owner, repo, verbose);
@@ -86,7 +93,7 @@ export async function waitForAllRepoActions(owner, repo, options = {}, verbose =
       // Issue #1722: do not silently treat fetch errors as "no active runs".
       // Log and retry on the next poll instead.
       console.error(`[ERROR] repo-actions: Error checking repo CI: ${error.message}`);
-      await new Promise(resolve => setTimeout(resolve, pollInterval));
+      await cancellableSleep(pollInterval, isCancelled);
       continue;
     }
     if (onStatusUpdate) {
@@ -100,7 +107,11 @@ export async function waitForAllRepoActions(owner, repo, options = {}, verbose =
       return { success: true, waitedForRuns: peakRunCount > 0, timedOut: false, remainingRuns: [] };
     }
     peakRunCount = Math.max(peakRunCount, active.count);
-    await new Promise(resolve => setTimeout(resolve, pollInterval));
+    await cancellableSleep(pollInterval, isCancelled);
+  }
+  // Issue #2072: a cancel landing as the timeout expires must not trigger another API round-trip.
+  if (isCancelled?.()) {
+    return { success: false, waitedForRuns: peakRunCount > 0, timedOut: false, cancelled: true, remainingRuns: [] };
   }
   // Issue #1722: if the timeout-final check throws, surface that as an error
   // rather than reporting "no remaining runs".

package/src/github-merge.lib.mjs

@@ -20,6 +20,7 @@ import { parseGitHubUrl } from './github.lib.mjs';
 import { githubLimits } from './config.lib.mjs';
 import { ghWithRateLimitRetry } from './github-rate-limit.lib.mjs';
 import { getTerminalGitHubEntityErrorMessage, isTerminalGitHubEntityError } from './github-terminal-state.lib.mjs';
+import { cancellableSleep } from './interruptible-sleep.lib.mjs';
 
 // Issue #1722: gh api `--paginate --slurp` responses for repos with many
 // historical workflow runs can easily exceed Node's default 1 MB exec buffer
@@ -49,6 +50,11 @@ export { syncReadyTags, getLinkedPRsFromTimeline, READY_LABEL };
 import { closeLinkedIssueIfNotAutoClosed } from './github-merge-issue-close.lib.mjs';
 export { closeLinkedIssueIfNotAutoClosed };
 
+// Issue #2072: the long CI polling loops live in their own module (file size limit).
+// Re-exported here so existing importers keep working.
+import { waitForCI, waitForBranchCI } from './github-merge-ci-wait.lib.mjs';
+export { waitForCI, waitForBranchCI };
+
 /**
  * Check if 'ready' label exists in repository
  * @param {string} owner - Repository owner
@@ -446,15 +452,19 @@ export async function checkPRCIStatus(owner, repo, prNumber, verbose = false) {
  * @param {string} repo - Repository name
  * @param {number} prNumber - Pull request number
  * @param {boolean} verbose - Whether to log verbose output
- * @returns {Promise<{mergeable: boolean, mergeableState?: string|null, mergeStateStatus?: string|null, reason: string|null, terminal?: boolean}>}
+ * @param {Object} [options] - Extra options
+ * @param {Function} [options.isCancelled] - Issue #2072: polled during the retry delay so a cancel aborts the wait
+ * @returns {Promise<{mergeable: boolean, mergeableState?: string|null, mergeStateStatus?: string|null, reason: string|null, terminal?: boolean, cancelled?: boolean}>}
  */
-export async function checkPRMergeable(owner, repo, prNumber, verbose = false) {
+export async function checkPRMergeable(owner, repo, prNumber, verbose = false, options = {}) {
+  const { isCancelled = null } = options;
   // Issue #1339: GitHub computes mergeability asynchronously. When mergeStateStatus is
   // 'UNKNOWN', it means GitHub hasn't calculated the merge state yet. Retry a few times.
   const MAX_UNKNOWN_RETRIES = 3;
   const UNKNOWN_RETRY_DELAY_MS = 5000;
 
   for (let attempt = 0; attempt < MAX_UNKNOWN_RETRIES; attempt++) {
+    if (isCancelled?.()) return { mergeable: false, reason: 'Operation was cancelled', cancelled: true };
     try {
       const { stdout } = await exec(`gh pr view ${prNumber} --repo ${owner}/${repo} --json mergeable,mergeStateStatus`);
       const pr = JSON.parse(stdout.trim());
@@ -466,7 +476,7 @@ export async function checkPRMergeable(owner, repo, prNumber, verbose = false) {
           if (verbose) {
             console.log(`[VERBOSE] /merge: PR #${prNumber} mergeability is UNKNOWN (attempt ${attempt + 1}/${MAX_UNKNOWN_RETRIES}), retrying in ${UNKNOWN_RETRY_DELAY_MS / 1000}s...`);
           }
-          await new Promise(resolve => setTimeout(resolve, UNKNOWN_RETRY_DELAY_MS));
+          await cancellableSleep(UNKNOWN_RETRY_DELAY_MS, isCancelled);
           continue;
         }
         // All retries exhausted, still UNKNOWN - treat as not mergeable
@@ -604,95 +614,6 @@ export async function mergePullRequest(owner, repo, prNumber, options = {}, verb
   }
 }
 
-/**
- * Wait for CI/CD to complete with polling
- * @param {string} owner - Repository owner
- * @param {string} repo - Repository name
- * @param {number} prNumber - Pull request number
- * @param {Object} options - Wait options
- * @param {number} options.timeout - Maximum wait time in ms (default: 30 minutes)
- * @param {number} options.pollInterval - Polling interval in ms (default: 30 seconds)
- * @param {Function} options.onStatusUpdate - Callback for status updates
- * @param {boolean} verbose - Whether to log verbose output
- * @returns {Promise<{success: boolean, status: string, error: string|null}>}
- */
-export async function waitForCI(owner, repo, prNumber, options = {}, verbose = false) {
-  const {
-    timeout = 30 * 60 * 1000,
-    pollInterval = 30 * 1000,
-    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);
-    } catch (error) {
-      // Issue #1269: Log and continue on CI check errors instead of crashing
-      console.error(`[ERROR] /merge: Error checking CI status for PR #${prNumber}: ${error.message}`);
-      verbose && console.error(`[VERBOSE] /merge: CI check error details:`, error);
-      // Wait and retry
-      await new Promise(resolve => setTimeout(resolve, pollInterval));
-      continue;
-    }
-
-    if (onStatusUpdate) {
-      // Issue #1269: Wrap callback with timeout to prevent infinite blocking; #1346: capture and clear timeout handle to prevent dangling timer
-      try {
-        let callbackTimeoutId;
-        await Promise.race([
-          onStatusUpdate(ciStatus),
-          new Promise((_, reject) => {
-            callbackTimeoutId = setTimeout(() => reject(new Error(`Callback timeout after ${callbackTimeout}ms`)), callbackTimeout);
-          }),
-        ]).finally(() => clearTimeout(callbackTimeoutId));
-      } catch (callbackError) {
-        // Issue #1269: Log callback errors but continue processing
-        console.error(`[ERROR] /merge: Status update callback failed for PR #${prNumber}: ${callbackError.message}`);
-        verbose && console.error(`[VERBOSE] /merge: Callback error details:`, callbackError);
-        // Continue processing even if callback fails - don't let UI issues block merging
-      }
-    }
-
-    if (ciStatus.status === 'success') {
-      return { success: true, status: 'success', error: null };
-    }
-
-    if (ciStatus.status === 'failure') {
-      return { success: false, status: 'failure', error: 'CI checks failed' };
-    }
-
-    if (ciStatus.status === 'terminal_github_entity_error') {
-      return {
-        success: false,
-        status: 'terminal_github_entity_error',
-        error: ciStatus.error || 'GitHub repository, pull request, issue, or branch is no longer accessible',
-      };
-    }
-
-    if (ciStatus.status === 'pending') {
-      if (verbose) {
-        console.log(`[VERBOSE] /merge: Waiting for CI... (${Math.round((Date.now() - startTime) / 1000)}s elapsed)`);
-      }
-      await new Promise(resolve => setTimeout(resolve, pollInterval));
-      continue;
-    }
-
-    // Unknown status - wait and retry
-    await new Promise(resolve => setTimeout(resolve, pollInterval));
-  }
-
-  return { success: false, status: 'timeout', error: 'CI check timeout exceeded' };
-}
-
 /**
  * Parse and validate a repository URL for the merge command
  * @param {string} url - Repository URL
@@ -782,109 +703,6 @@ export async function getActiveBranchRuns(owner, repo, branch = 'main', verbose
   };
 }
 
-/**
- * Wait for all active workflow runs on a branch to complete
- * Issue #1307: Ensures all CI runs on target branch are complete before merging
- * @param {string} owner - Repository owner
- * @param {string} repo - Repository name
- * @param {string} branch - Branch name (default: main)
- * @param {Object} options - Wait options
- * @param {number} options.timeout - Maximum wait time in ms (default: 45 minutes)
- * @param {number} options.pollInterval - Polling interval in ms (default: 30 seconds)
- * @param {Function} options.onStatusUpdate - Callback for status updates
- * @param {boolean} verbose - Whether to log verbose output
- * @returns {Promise<{success: boolean, waitedForRuns: boolean, completedRuns: number, error: string|null}>}
- */
-export async function waitForBranchCI(owner, repo, branch = 'main', options = {}, verbose = false) {
-  const { timeout = 45 * 60 * 1000, pollInterval = 30 * 1000, onStatusUpdate = null, isCancelled = null } = options;
-
-  const startTime = Date.now();
-  let totalWaitedRuns = 0;
-
-  if (verbose) {
-    console.log(`[VERBOSE] /merge: Checking for active CI runs on ${owner}/${repo} branch ${branch}...`);
-  }
-
-  while (Date.now() - startTime < timeout) {
-    if (isCancelled?.()) return { success: false, waitedForRuns: totalWaitedRuns > 0, completedRuns: totalWaitedRuns, error: 'Operation was cancelled' };
-    let activeRuns;
-    try {
-      activeRuns = await getActiveBranchRuns(owner, repo, branch, verbose);
-    } catch (error) {
-      // Log and continue on errors
-      console.error(`[ERROR] /merge: Error checking branch CI: ${error.message}`);
-      await new Promise(resolve => setTimeout(resolve, pollInterval));
-      continue;
-    }
-
-    if (onStatusUpdate) {
-      try {
-        await onStatusUpdate({
-          hasActiveRuns: activeRuns.hasActiveRuns,
-          count: activeRuns.count,
-          runs: activeRuns.runs,
-          elapsedMs: Date.now() - startTime,
-        });
-      } catch (callbackError) {
-        // Log callback errors but continue
-        console.error(`[ERROR] /merge: Status update callback failed: ${callbackError.message}`);
-      }
-    }
-
-    if (!activeRuns.hasActiveRuns) {
-      if (verbose) {
-        console.log(`[VERBOSE] /merge: No active CI runs on ${branch} branch. Ready to proceed.`);
-      }
-      return {
-        success: true,
-        waitedForRuns: totalWaitedRuns > 0,
-        completedRuns: totalWaitedRuns,
-        error: null,
-      };
-    }
-
-    totalWaitedRuns = Math.max(totalWaitedRuns, activeRuns.count);
-
-    if (verbose) {
-      const elapsedSec = Math.round((Date.now() - startTime) / 1000);
-      console.log(`[VERBOSE] /merge: Waiting for ${activeRuns.count} active runs on ${branch}... (${elapsedSec}s elapsed)`);
-    }
-
-    await new Promise(resolve => setTimeout(resolve, pollInterval));
-  }
-
-  // Timeout reached
-  // Issue #1722: if the final check throws, do NOT silently report "ready".
-  // Treat it the same as still-active (force a timeout failure), so /merge
-  // waits/retries instead of merging on top of a still-running CI run.
-  let finalCheck;
-  try {
-    finalCheck = await getActiveBranchRuns(owner, repo, branch, verbose);
-  } catch (error) {
-    return {
-      success: false,
-      waitedForRuns: true,
-      completedRuns: totalWaitedRuns,
-      error: `Timeout reached and final CI check failed on ${branch}: ${error.message}`,
-    };
-  }
-  if (finalCheck.hasActiveRuns) {
-    return {
-      success: false,
-      waitedForRuns: true,
-      completedRuns: totalWaitedRuns - finalCheck.count,
-      error: `Timeout waiting for ${finalCheck.count} CI runs on ${branch} branch`,
-    };
-  }
-
-  return {
-    success: true,
-    waitedForRuns: totalWaitedRuns > 0,
-    completedRuns: totalWaitedRuns,
-    error: null,
-  };
-}
-
 /**
  * Get the default branch for a repository
  * @param {string} owner - Repository owner

package/src/interruptible-sleep.lib.mjs

@@ -49,4 +49,37 @@ export function interruptibleSleep(ms) {
   });
 }
 
-export default { interruptibleSleep };
+/**
+ * Sleep for `ms` milliseconds, resolving early if SIGINT/SIGTERM arrives or if
+ * `isCancelled()` starts returning true.
+ *
+ * Issue #2072: polling loops used to `await new Promise(r => setTimeout(r, pollInterval))`
+ * and only re-check cancellation on the next iteration. With a 30s poll interval that
+ * made `/merge` keep running for up to a full interval after the Cancel button was
+ * pressed. Sleeping in short steps lets cancellation take effect within `stepMs`.
+ *
+ * @param {number} ms - Duration in milliseconds
+ * @param {Function|null} isCancelled - Predicate polled during the sleep
+ * @param {Object} [options]
+ * @param {number} [options.stepMs=100] - Granularity at which `isCancelled` is polled
+ * @returns {Promise<{interrupted: boolean, cancelled: boolean}>}
+ */
+export async function cancellableSleep(ms, isCancelled = null, options = {}) {
+  const { stepMs = 100 } = options;
+
+  if (!isCancelled) {
+    const { interrupted } = await interruptibleSleep(ms);
+    return { interrupted, cancelled: false };
+  }
+
+  const deadline = Date.now() + ms;
+  while (Date.now() < deadline) {
+    if (isCancelled()) return { interrupted: false, cancelled: true };
+    const { interrupted } = await interruptibleSleep(Math.min(stepMs, deadline - Date.now()));
+    if (interrupted) return { interrupted: true, cancelled: isCancelled() };
+  }
+
+  return { interrupted: false, cancelled: isCancelled() };
+}
+
+export default { interruptibleSleep, cancellableSleep };

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

@@ -181,7 +181,11 @@ export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, sho
     // cost folded in at the runClaude return, plus anything carried from prior
     // iterations via --previous-anthropic-cost.
     const carriedAnthropicCost = getCumulativeAnthropicCost();
-    if (carriedAnthropicCost > 0) {
+    // Issue #2056: only a real resume reads the same transcript and belongs to
+    // the same cost scope. A configured auto-restart deliberately starts a
+    // fresh Claude session, so carrying the old cost would recreate the exact
+    // cross-session overcount reported in the issue.
+    if (!isRestart && carriedAnthropicCost > 0) {
       resumeArgs.push('--previous-anthropic-cost', String(carriedAnthropicCost));
       await log(`💰 Carrying forward cumulative Anthropic cost: $${carriedAnthropicCost.toFixed(6)} (issue #1886)`, { verbose: true });
     }

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

@@ -21,6 +21,7 @@ import { resolveMergeTargetItems } from './github-merge-targets.lib.mjs';
 import { waitForPRReady as waitForPRReadyHelper } from './telegram-merge-wait.lib.mjs';
 import { mergeQueue as mergeQueueConfig } from './config.lib.mjs';
 import { getProgressBar } from './limits.lib.mjs';
+import { cancellableSleep as cancellableSleepUntil } from './interruptible-sleep.lib.mjs';
 
 /**
  * Status enum for merge queue operations
@@ -495,7 +496,17 @@ export class MergeQueueProcessor {
     try {
       // Step 1: Check if PR is mergeable
       item.status = MergeItemStatus.CHECKING_CI;
-      const mergeableCheck = await this.checkPRMergeable(this.owner, this.repo, item.pr.number, this.verbose);
+      // Issue #2072: pass cancellation down so the UNKNOWN-mergeability retry delay aborts early
+      const mergeableCheck = await this.checkPRMergeable(this.owner, this.repo, item.pr.number, this.verbose, { isCancelled: () => this.isCancelled });
+
+      // Issue #2072: a cancel during the mergeability check must skip the PR, not fail it.
+      if (mergeableCheck.cancelled || this.isCancelled) {
+        item.status = MergeItemStatus.SKIPPED;
+        item.error = 'Cancelled';
+        this.stats.skipped++;
+        this.log(`Skipped PR #${item.pr.number}: cancelled during mergeability check`);
+        return;
+      }
 
       if (mergeableCheck.terminal) {
         item.status = MergeItemStatus.FAILED;
@@ -893,7 +904,7 @@ export class MergeQueueProcessor {
         if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
           return { outcome: 'error', error: error.message };
         }
-        await this.cancellableSleep(pollInterval);
+        await this.sleep(pollInterval);
         continue;
       }
 
@@ -912,27 +923,12 @@ export class MergeQueueProcessor {
         }
       }
 
-      await this.cancellableSleep(pollInterval);
+      await this.sleep(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));
-    }
-  }
-
   /**
    * Wait for any active CI runs on the target branch to complete
    * Issue #1307: Prevents merging while post-merge CI from previous merges is still running
@@ -1456,10 +1452,17 @@ export class MergeQueueProcessor {
   }
 
   /**
-   * Sleep helper
+   * Sleep helper.
+   *
+   * Issue #2072: this is the single sleep primitive for the queue, and it is
+   * cancellable — it returns as soon as `cancel()` is called (checked every
+   * 100ms) or SIGINT/SIGTERM arrives, instead of sleeping out the full delay.
+   * Every wait in the queue routes through here, so no stage of `/merge` can
+   * hold up a cancel by more than ~100ms. This supersedes the separate
+   * `cancellableSleep` helper added for #1807.
    */
   sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
+    return cancellableSleepUntil(ms, () => this.isCancelled);
   }
 }
 

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

@@ -65,8 +65,14 @@ export async function waitForPRReady(processor, item, initialCheck, options) {
       await processor.onProgress(processor.getProgressUpdate());
     }
 
+    // Issue #2072: `processor.sleep` returns early on cancel. The poll interval defaults
+    // to 5 minutes, which previously kept `/merge` running long after Cancel was pressed.
     await processor.sleep(pollIntervalMs);
-    latestCheck = await processor.checkPRMergeable(processor.owner, processor.repo, item.pr.number, processor.verbose);
+    if (processor.isCancelled) {
+      return { success: false, status: 'cancelled', error: 'Cancelled' };
+    }
+
+    latestCheck = await processor.checkPRMergeable(processor.owner, processor.repo, item.pr.number, processor.verbose, { isCancelled: () => processor.isCancelled });
   }
 }