@link-assistant/hive-mind 1.69.1 → 1.69.3

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @link-assistant/hive-mind
 
+## 1.69.3
+
+### Patch Changes
+
+- d7f95e8: Add experimental `--auto-support-agents-md-as-claude-md` support for temporarily exposing AGENTS.md as CLAUDE.md during Claude runs.
+- 890e81f: Stop auto-merge from waiting forever when cancelled CI cannot be re-run automatically.
+
+## 1.69.2
+
+### Patch Changes
+
+- 0ff36b4: Count open draft pull requests when `/hive --skip-issues-with-prs` checks linked solution drafts, preventing duplicate work while an existing PR is still in progress.
+
 ## 1.69.1
 
 ### Patch Changes

package/package.json

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

package/src/agents-md-claude-support.lib.mjs

@@ -0,0 +1,158 @@
+const AGENTS_MD_FILENAMES = Object.freeze(['AGENTS.md', 'agents.md']);
+const CLAUDE_MD_FILENAME = 'CLAUDE.md';
+
+const noopLog = async () => {};
+const fallbackFormatAligned = (_icon, label, value) => `${label} ${value}`;
+
+const readFileIfExists = async (fs, filePath) => {
+  try {
+    return { exists: true, content: await fs.readFile(filePath, 'utf8') };
+  } catch (error) {
+    if (error.code === 'ENOENT') return { exists: false, content: null };
+    throw error;
+  }
+};
+
+export const userInputMentionsClaudeMd = input => /\bCLAUDE\.md\b/i.test(String(input || ''));
+
+export const findAgentsMdFile = async ({ tempDir, fs, path }) => {
+  for (const fileName of AGENTS_MD_FILENAMES) {
+    const filePath = path.join(tempDir, fileName);
+    const result = await readFileIfExists(fs, filePath);
+    if (result.exists) return { fileName, filePath, content: result.content };
+  }
+  return null;
+};
+
+export const prepareAgentsMdAsClaudeMd = async params => {
+  const { tempDir, argv, prompt = '', fs, path, log = noopLog, formatAligned = fallbackFormatAligned } = params;
+  const state = {
+    enabled: !!argv?.autoSupportAgentsMdAsClaudeMd,
+    created: false,
+    cleanupCandidate: false,
+    userInputMentionsClaudeMd: userInputMentionsClaudeMd(prompt),
+    claudePath: path.join(tempDir, CLAUDE_MD_FILENAME),
+    agentsPath: null,
+  };
+
+  if (!state.enabled) return state;
+
+  const tool = argv?.tool || 'claude';
+  if (tool !== 'claude') {
+    await log('   AGENTS.md as CLAUDE.md support skipped: only supported for --tool claude', { verbose: true });
+    return { ...state, skippedReason: 'non-claude-tool' };
+  }
+
+  const agentsFile = await findAgentsMdFile({ tempDir, fs, path });
+  if (!agentsFile) {
+    await log('   AGENTS.md as CLAUDE.md support enabled, but no AGENTS.md file was found', { verbose: true });
+    return { ...state, skippedReason: 'missing-agents-md' };
+  }
+
+  state.agentsPath = agentsFile.filePath;
+  const claudeFile = await readFileIfExists(fs, state.claudePath);
+  if (claudeFile.exists) {
+    if (claudeFile.content === agentsFile.content) {
+      state.cleanupCandidate = !state.userInputMentionsClaudeMd;
+      const action = state.cleanupCandidate ? 'will remove it after Claude exits' : 'leaving it untouched because user input mentions CLAUDE.md';
+      await log(`   CLAUDE.md already matches AGENTS.md; ${action}`, { verbose: true });
+      return { ...state, skippedReason: 'claude-md-already-matches-agents-md' };
+    }
+    await log('   Existing CLAUDE.md differs from AGENTS.md; leaving it untouched', { verbose: true });
+    return { ...state, skippedReason: 'claude-md-differs' };
+  }
+
+  await fs.writeFile(state.claudePath, agentsFile.content);
+  state.created = true;
+  await log(formatAligned('AGENTS.md', 'Temporary CLAUDE.md:', `created from ${agentsFile.fileName}`));
+  return state;
+};
+
+const gitStatusForClaudeMd = async ({ $, tempDir }) => {
+  if (!$) return '';
+  const result = await $({ cwd: tempDir })`git status --porcelain -- ${CLAUDE_MD_FILENAME} 2>&1`;
+  return result.stdout?.toString().trim() || '';
+};
+
+const isClaudeMdTracked = async ({ $, tempDir }) => {
+  if (!$) return false;
+  const result = await $({ cwd: tempDir })`git ls-files --error-unmatch -- ${CLAUDE_MD_FILENAME} 2>&1`;
+  return result.code === 0;
+};
+
+const removeTrackedClaudeMd = async ({ $, tempDir }) => {
+  if (!$) return { code: 1, stdout: '', stderr: 'No git runner provided' };
+  return await $({ cwd: tempDir })`git rm -f -- ${CLAUDE_MD_FILENAME} 2>&1`;
+};
+
+const commitClaudeMdRemoval = async ({ $, tempDir }) => {
+  const message = 'Remove temporary CLAUDE.md copy from AGENTS.md';
+  return await $({ cwd: tempDir })`git commit -m ${message} -- ${CLAUDE_MD_FILENAME} 2>&1`;
+};
+
+export const cleanupAgentsMdAsClaudeMd = async params => {
+  const { state, tempDir, branchName, fs, path, $, log = noopLog, formatAligned = fallbackFormatAligned } = params;
+  if (!state?.created && !state?.cleanupCandidate) return { action: 'skipped' };
+
+  const claudePath = state.claudePath || path.join(tempDir, CLAUDE_MD_FILENAME);
+  const claudeFile = await readFileIfExists(fs, claudePath);
+  if (!claudeFile.exists) return { action: 'already-removed' };
+
+  const agentsFile = await findAgentsMdFile({ tempDir, fs, path });
+  if (!agentsFile || claudeFile.content !== agentsFile.content) {
+    await log('   Temporary CLAUDE.md changed or AGENTS.md is missing; leaving it untouched', { verbose: true });
+    return { action: 'left-modified' };
+  }
+
+  const status = await gitStatusForClaudeMd({ $, tempDir });
+  const tracked = await isClaudeMdTracked({ $, tempDir });
+  const isUntracked = status.split('\n').some(line => line.startsWith('??'));
+
+  if (isUntracked || (!tracked && !status)) {
+    await fs.rm(claudePath, { force: true });
+    await log(formatAligned('AGENTS.md', 'Temporary CLAUDE.md:', 'removed'));
+    return { action: 'removed-untracked' };
+  }
+
+  if (state.userInputMentionsClaudeMd) {
+    await log('   Temporary CLAUDE.md matches AGENTS.md but user input mentions CLAUDE.md; leaving it untouched', { verbose: true });
+    return { action: 'left-user-mentioned-claude-md' };
+  }
+
+  const rmResult = await removeTrackedClaudeMd({ $, tempDir });
+  if (rmResult.code !== 0) {
+    await log(`   Warning: could not remove temporary CLAUDE.md from git: ${rmResult.stderr || rmResult.stdout}`, { verbose: true });
+    return { action: 'remove-failed' };
+  }
+
+  const postRemoveStatus = await gitStatusForClaudeMd({ $, tempDir });
+  if (!postRemoveStatus) {
+    await log(formatAligned('AGENTS.md', 'Temporary CLAUDE.md:', 'removed from git index'));
+    return { action: 'removed-staged-addition' };
+  }
+
+  const commitResult = await commitClaudeMdRemoval({ $, tempDir });
+  if (commitResult.code !== 0) {
+    await log(`   Warning: temporary CLAUDE.md was removed locally but commit failed: ${commitResult.stderr || commitResult.stdout}`, { verbose: true });
+    return { action: 'removed-uncommitted' };
+  }
+
+  if (branchName) {
+    const pushResult = await $({ cwd: tempDir })`git push origin ${branchName} 2>&1`;
+    if (pushResult.code !== 0) {
+      await log(`   Warning: temporary CLAUDE.md removal commit was created but push failed: ${pushResult.stderr || pushResult.stdout}`, { verbose: true });
+    }
+  }
+
+  await log(formatAligned('AGENTS.md', 'Temporary CLAUDE.md:', 'removed from committed changes'));
+  return { action: 'removed-committed-copy' };
+};
+
+export const withAgentsMdAsClaudeMd = async (params, execute) => {
+  const state = await prepareAgentsMdAsClaudeMd(params);
+  try {
+    return await execute();
+  } finally {
+    await cleanupAgentsMdAsClaudeMd({ ...params, state });
+  }
+};

package/src/cancelled-ci-rerun.lib.mjs

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+
+/**
+ * Helpers for cancelled/stale CI handling in auto-merge mode.
+ *
+ * GitHub can expose several operational cases as a cancelled/stale status:
+ * manual cancellation, concurrency cancellation, queue/run limits, or a
+ * workflow/job timeout. If hive-mind cannot re-trigger the run, a human has to
+ * inspect the logs because polling the same conclusion will not make progress.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1769
+ */
+
+import { CANCELLED_CI_REVIEW_MARKER } from './tool-comments.lib.mjs';
+
+const CANCELLED_OR_STALE_CONCLUSIONS = new Set(['cancelled', 'stale']);
+
+export { CANCELLED_CI_REVIEW_MARKER };
+
+export const getRetriggerableWorkflowRuns = (runs = []) => runs.filter(run => CANCELLED_OR_STALE_CONCLUSIONS.has(run?.conclusion));
+
+export const shouldStopForCancelledCIReview = ({ retriggerableRuns = [], rerunTriggered = false, rerunFailures = [] }) => {
+  if (rerunTriggered) {
+    return false;
+  }
+
+  return retriggerableRuns.length === 0 || rerunFailures.length > 0;
+};
+
+const formatMarkdownList = (items, fallback) => {
+  if (!items || items.length === 0) {
+    return `- ${fallback}`;
+  }
+
+  return items.map(item => `- ${item}`).join('\n');
+};
+
+const formatRunReference = run => {
+  if (!run) {
+    return 'Unknown workflow run';
+  }
+
+  const name = run.name || run.path || (run.id ? `Workflow run ${run.id}` : 'Workflow run');
+  const runId = run.id ? ` (${run.id})` : '';
+  const status = [run.status, run.conclusion].filter(Boolean).join('/');
+  const statusPart = status ? ` [${status}]` : '';
+  const urlPart = run.html_url ? ` - ${run.html_url}` : '';
+
+  return `${name}${runId}${statusPart}${urlPart}`;
+};
+
+const formatRerunFailure = failure => {
+  const runPart = formatRunReference(failure?.run);
+  const error = failure?.error || 'Unknown error';
+  return `${runPart}: ${error}`;
+};
+
+export const buildCancelledCIReviewComment = ({ blocker, runs = [], rerunFailures = [], rerunAttempted = false, sha }) => {
+  const cancelledDetails = blocker?.details || [];
+  const effectiveSha = sha || blocker?.sha;
+  const shaLine = effectiveSha ? `\n\n**Commit:** ${effectiveSha}` : '';
+  const rerunSummary = rerunAttempted ? 'Automatic re-run was attempted, but no workflow run was successfully re-triggered.' : 'Automatic re-run was not possible.';
+
+  return `## ${CANCELLED_CI_REVIEW_MARKER}
+
+Hive Mind detected cancelled or stale CI/CD checks and cannot get them running automatically.${shaLine}
+
+**Cancelled checks**
+${formatMarkdownList(cancelledDetails, 'No cancelled check details were available.')}
+
+**Workflow runs inspected**
+${formatMarkdownList(runs.map(formatRunReference), 'No cancelled/stale workflow run was found for this commit SHA.')}
+
+**Automatic re-run result**
+${rerunSummary}
+${formatMarkdownList(rerunFailures.map(formatRerunFailure), 'No successful automatic re-run was recorded.')}
+
+**Action required**
+1. Review the cancelled CI logs to decide whether this was a real timeout/failure or a deliberate manual cancellation.
+2. If the cancelled check is required, re-run the workflow manually from GitHub Actions or push a new commit.
+3. If the cancellation was deliberate and non-blocking, decide whether this PR can be merged outside automation.
+
+If workflow/job \`timeout-minutes\` or a runner execution limit caused the cancellation, treat it as a CI failure and fix the timeout, test, or infrastructure before merging.
+
+---
+Hive Mind is stopping because continuing to poll the same cancelled/stale check would not change the mergeability result.`;
+};

package/src/claude.lib.mjs

@@ -26,6 +26,7 @@ import { ensureClaudeQuietConfig } from './claude-quiet-config.lib.mjs';
 import { fetchModelInfo } from './model-info.lib.mjs';
 import { classifyRetryableError, maybeSwitchToFallbackModel } from './tool-retry.lib.mjs';
 import { resolveSubSessionSize } from './sub-session-size.lib.mjs'; // Issue #1706
+import { withAgentsMdAsClaudeMd } from './agents-md-claude-support.lib.mjs';
 export { availableModels }; // Re-export for backward compatibility
 export { fetchModelInfo };
 const showResumeCommand = async (sessionId, tempDir, claudePath, model, log) => {
@@ -294,7 +295,6 @@ export const executeClaude = async params => {
   if (argv.verbose) {
     await log(`👁️  Model vision capability: ${modelSupportsVision ? 'supported' : 'not supported'}`, { verbose: true });
   }
-  // Build the user prompt
   const prompt = buildUserPrompt({
     issueUrl,
     issueNumber,
@@ -313,7 +313,6 @@ export const executeClaude = async params => {
     argv,
     claudeVersion: getClaudeVersion(),
   });
-  // Build the system prompt
   const systemPrompt = buildSystemPrompt({
     owner,
     repo,
@@ -329,7 +328,6 @@ export const executeClaude = async params => {
     argv,
     modelSupportsVision,
   });
-  // Log prompt details in verbose mode
   if (argv.verbose) {
     await log('\n📝 Final prompt structure:', { verbose: true });
     await log(`   Characters: ${prompt.length}`, { verbose: true });
@@ -349,35 +347,36 @@ export const executeClaude = async params => {
       await log('---END SYSTEM PROMPT---', { verbose: true });
     }
   }
-  // Escape prompts for shell usage
   const escapedPrompt = prompt.replace(/"/g, '\\"').replace(/\$/g, '\\$');
   const escapedSystemPrompt = systemPrompt.replace(/"/g, '\\"').replace(/\$/g, '\\$');
-  // Execute the Claude command
-  return await executeClaudeCommand({
-    tempDir,
-    branchName,
-    prompt,
-    systemPrompt,
-    escapedPrompt,
-    escapedSystemPrompt,
-    argv,
-    log,
-    setLogFile,
-    getLogFile,
-    formatAligned,
-    getResourceSnapshot,
-    forkedRepo,
-    feedbackLines,
-    claudePath,
-    $,
-    // For interactive mode
-    owner,
-    repo,
-    prNumber,
-    // Issue #1708: forwarded so the bidirectional handler can poll
-    // issue title/body changes and uncommitted changes during the session.
-    issueNumber,
-  });
+
+  return await withAgentsMdAsClaudeMd({ tempDir, branchName, argv, prompt, fs, path, $, log, formatAligned }, () =>
+    executeClaudeCommand({
+      tempDir,
+      branchName,
+      prompt,
+      systemPrompt,
+      escapedPrompt,
+      escapedSystemPrompt,
+      argv,
+      log,
+      setLogFile,
+      getLogFile,
+      formatAligned,
+      getResourceSnapshot,
+      forkedRepo,
+      feedbackLines,
+      claudePath,
+      $,
+      // For interactive mode
+      owner,
+      repo,
+      prNumber,
+      // Issue #1708: forwarded so the bidirectional handler can poll
+      // issue title/body changes and uncommitted changes during the session.
+      issueNumber,
+    })
+  );
 };
 /** Check if a model supports vision (image input) using models.dev API @returns {Promise<boolean>} */
 export const checkModelVisionCapability = async modelId => {

package/src/github-linking.lib.mjs

@@ -26,66 +26,71 @@ export function getGitHubLinkingKeywords() {
   return ['close', 'closes', 'closed', 'fix', 'fixes', 'fixed', 'resolve', 'resolves', 'resolved'];
 }
 
-/**
- * Check if PR body contains a valid GitHub linking keyword for the given issue
- *
- * @param {string} prBody - The pull request body text
- * @param {string|number} issueNumber - The issue number to check for
- * @param {string} [owner] - Repository owner (for cross-repo references)
- * @param {string} [repo] - Repository name (for cross-repo references)
- * @returns {boolean} True if a valid linking keyword is found
- */
-export function hasGitHubLinkingKeyword(prBody, issueNumber, owner = null, repo = null) {
-  if (!prBody || !issueNumber) {
-    return false;
-  }
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 
-  const keywords = getGitHubLinkingKeywords();
-  const issueNumStr = issueNumber.toString();
+function buildClosingReferencePatterns(keyword, issueNumber, owner = null, repo = null) {
+  const issueNumStr = escapeRegExp(issueNumber);
+  const separator = String.raw`(?:\s+|\s*:\s*)`;
+  const prefix = String.raw`\b${keyword}${separator}`;
+  const references = [String.raw`#${issueNumStr}\b`];
 
-  // Build regex patterns for each valid format:
-  // 1. KEYWORD #123
-  // 2. KEYWORD owner/repo#123
-  // 3. KEYWORD https://github.com/owner/repo/issues/123
+  if (owner && repo) {
+    references.push(`${escapeRegExp(owner)}/${escapeRegExp(repo)}#${issueNumStr}\\b`);
+    references.push(`https://github\\.com/${escapeRegExp(owner)}/${escapeRegExp(repo)}/issues/${issueNumStr}\\b`);
+  }
 
-  for (const keyword of keywords) {
-    // Pattern 1: KEYWORD #123
-    // Must have word boundary before keyword and # immediately before number
-    const pattern1 = new RegExp(`\\b${keyword}\\s+#${issueNumStr}\\b`, 'i');
+  references.push(String.raw`[\w.-]+/[\w.-]+#${issueNumStr}\b`);
+  references.push(`https://github\\.com/[^/\\s]+/[^/\\s]+/issues/${issueNumStr}\\b`);
 
-    if (pattern1.test(prBody)) {
-      return true;
-    }
-
-    // Pattern 2: KEYWORD owner/repo#123 (for cross-repo or fork references)
-    if (owner && repo) {
-      const pattern2 = new RegExp(`\\b${keyword}\\s+${owner}/${repo}#${issueNumStr}\\b`, 'i');
+  return references.map(reference => new RegExp(`${prefix}${reference}`, 'i'));
+}
 
-      if (pattern2.test(prBody)) {
-        return true;
-      }
-    }
+/**
+ * Check whether text contains a GitHub closing keyword for a specific issue.
+ *
+ * This is the shared parser used by solve and hive code paths so they agree on
+ * which PR body/title references are real closing links.
+ *
+ * @param {string} text - Pull request body or title text
+ * @param {string|number} issueNumber - Issue number to check for
+ * @param {string} [owner] - Repository owner for exact owner/repo references
+ * @param {string} [repo] - Repository name for exact owner/repo references
+ * @returns {boolean} True if a valid closing reference is found
+ */
+export function prClosesIssue(text, issueNumber, owner = null, repo = null) {
+  if (!text || typeof text !== 'string' || issueNumber === null || issueNumber === undefined || String(issueNumber).trim() === '') {
+    return false;
+  }
 
-    // Pattern 3: KEYWORD https://github.com/owner/repo/issues/123
-    if (owner && repo) {
-      const pattern3 = new RegExp(`\\b${keyword}\\s+https://github\\.com/${owner}/${repo}/issues/${issueNumStr}\\b`, 'i');
+  const issueNumStr = String(issueNumber).trim();
 
-      if (pattern3.test(prBody)) {
+  for (const keyword of getGitHubLinkingKeywords()) {
+    const patterns = buildClosingReferencePatterns(keyword, issueNumStr, owner, repo);
+    for (const pattern of patterns) {
+      if (pattern.test(text)) {
         return true;
       }
     }
-
-    // Pattern 4: Also check for any URL format (generic)
-    const pattern4 = new RegExp(`\\b${keyword}\\s+https://github\\.com/[^/]+/[^/]+/issues/${issueNumStr}\\b`, 'i');
-
-    if (pattern4.test(prBody)) {
-      return true;
-    }
   }
 
   return false;
 }
 
+/**
+ * Check if PR body contains a valid GitHub linking keyword for the given issue
+ *
+ * @param {string} prBody - The pull request body text
+ * @param {string|number} issueNumber - The issue number to check for
+ * @param {string} [owner] - Repository owner (for cross-repo references)
+ * @param {string} [repo] - Repository name (for cross-repo references)
+ * @returns {boolean} True if a valid linking keyword is found
+ */
+export function hasGitHubLinkingKeyword(prBody, issueNumber, owner = null, repo = null) {
+  return prClosesIssue(prBody, issueNumber, owner, repo);
+}
+
 /**
  * Extract issue number from PR body using GitHub linking keywords
  * This is used to find which issue a PR is linked to

package/src/github.batch.lib.mjs

@@ -10,53 +10,46 @@ if (typeof globalThis.use === 'undefined') {
 // Import dependencies
 import { log, cleanErrorMessage } from './lib.mjs';
 import { githubLimits, timeouts } from './config.lib.mjs';
+import { prClosesIssue } from './github-linking.lib.mjs';
 
 import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry, execGhWithRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller. execGhWithRetry adds transient-network retry (#1756).
+export { prClosesIssue };
+
 /**
- * Check if a PR body/title indicates it fixes/closes/resolves a specific issue number
- * GitHub auto-closes issues when PR body contains keywords like "fixes #123", "closes #123", "resolves #123"
- * See: https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue
- * @param {string} text - PR body or title text
- * @param {number} issueNumber - Issue number to check for
- * @returns {boolean} True if the text contains a closing keyword for this issue
+ * Extract open pull requests that are linked to an issue with closing keywords.
+ * Draft pull requests are still open in-progress solution drafts, so they must
+ * count for /hive --skip-issues-with-prs.
+ * @param {Object} issueData - GraphQL issue node with timelineItems
+ * @param {number} issueNum - Issue number to check
+ * @param {Function} logger - Async logger, defaults to shared log helper
+ * @returns {Promise<Array<Object>>} Linked open PRs that close the issue
  */
-export function prClosesIssue(text, issueNumber) {
-  if (!text || typeof text !== 'string') {
-    return false;
-  }
-
-  // GitHub closing keywords (case-insensitive)
-  // Supports: fix, fixes, fixed, close, closes, closed, resolve, resolves, resolved
-  // Also supports variations with repository prefix like "fixes owner/repo#123"
-  const closingKeywords = ['fix', 'fixes', 'fixed', 'close', 'closes', 'closed', 'resolve', 'resolves', 'resolved'];
-
-  // Build regex pattern that matches any of the keywords followed by #N or repo#N
-  // Examples matched:
-  //   - "fixes #123"
-  //   - "Closes #123"
-  //   - "RESOLVED #123"
-  //   - "fixes owner/repo#123"
-  //   - "fix: #123" (common commit style)
-  const issueNum = issueNumber.toString();
-
-  for (const keyword of closingKeywords) {
-    // Pattern: keyword + optional colon/space + optional repo prefix + # + issue number
-    // Must be followed by word boundary (not part of larger number)
-    const patterns = [
-      // Standard format: "fixes #123"
-      new RegExp(`\\b${keyword}\\s*:?\\s*#${issueNum}\\b`, 'i'),
-      // With repo prefix: "fixes owner/repo#123"
-      new RegExp(`\\b${keyword}\\s*:?\\s*[\\w.-]+/[\\w.-]+#${issueNum}\\b`, 'i'),
-    ];
-
-    for (const pattern of patterns) {
-      if (pattern.test(text)) {
-        return true;
+export async function extractLinkedPullRequestsForIssue(issueData, issueNum, logger = log) {
+  const linkedPRs = [];
+
+  for (const item of issueData.timelineItems?.nodes || []) {
+    if (item?.source && item.source.state === 'OPEN') {
+      // Check if PR actually closes this issue (has "fixes #N", "closes #N", or "resolves #N")
+      const prBody = item.source.body || '';
+      const prTitle = item.source.title || '';
+      const closesThisIssue = prClosesIssue(prBody, issueNum) || prClosesIssue(prTitle, issueNum);
+
+      if (closesThisIssue) {
+        linkedPRs.push({
+          number: item.source.number,
+          title: item.source.title,
+          state: item.source.state,
+          isDraft: Boolean(item.source.isDraft),
+          url: item.source.url,
+        });
+      } else {
+        // Log that we're skipping a PR that only mentions the issue
+        await logger(`      ℹ️  PR #${item.source.number} mentions issue #${issueNum} but doesn't close it (no fixes/closes/resolves keyword)`, { verbose: true });
       }
     }
   }
 
-  return false;
+  return linkedPRs;
 }
 
 /**
@@ -140,31 +133,11 @@ export async function batchCheckPullRequestsForIssues(owner, repo, issueNumbers)
         for (const issueNum of batch) {
           const issueData = data.data?.repository?.[`issue${issueNum}`];
           if (issueData) {
-            const linkedPRs = [];
-
-            // Extract linked PRs from timeline items
+            // Extract linked PRs from timeline items, including draft PRs.
             // Issue #1094: Only count PRs that explicitly fix/close/resolve this issue
             // This prevents false positives from PRs that only mention issues without solving them
-            for (const item of issueData.timelineItems?.nodes || []) {
-              if (item?.source && item.source.state === 'OPEN' && !item.source.isDraft) {
-                // Check if PR actually closes this issue (has "fixes #N", "closes #N", or "resolves #N")
-                const prBody = item.source.body || '';
-                const prTitle = item.source.title || '';
-                const closesThisIssue = prClosesIssue(prBody, issueNum) || prClosesIssue(prTitle, issueNum);
-
-                if (closesThisIssue) {
-                  linkedPRs.push({
-                    number: item.source.number,
-                    title: item.source.title,
-                    state: item.source.state,
-                    url: item.source.url,
-                  });
-                } else {
-                  // Log that we're skipping a PR that only mentions the issue
-                  await log(`      ℹ️  PR #${item.source.number} mentions issue #${issueNum} but doesn't close it (no fixes/closes/resolves keyword)`, { verbose: true });
-                }
-              }
-            }
+            // Issue #1760: Draft PRs are still active solution drafts and must block duplicate work
+            const linkedPRs = await extractLinkedPullRequestsForIssue(issueData, issueNum);
 
             results[issueNum] = {
               title: issueData.title,
@@ -337,6 +310,7 @@ export async function batchCheckArchivedRepositories(repositories) {
 // Export all functions as default object too
 export default {
   prClosesIssue,
+  extractLinkedPullRequestsForIssue,
   batchCheckPullRequestsForIssues,
   batchCheckArchivedRepositories,
 };

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

@@ -55,6 +55,10 @@ import { limitReset } from './config.lib.mjs';
 const autoMergeHelpers = await import('./solve.auto-merge-helpers.lib.mjs');
 const { checkForExistingComment, checkForNonBotComments, getMergeBlockers } = autoMergeHelpers;
 
+// Issue #1769: cancelled/stale CI re-run failures need a human action stop, not polling forever.
+const cancelledCiRerunLib = await import('./cancelled-ci-rerun.lib.mjs');
+const { buildCancelledCIReviewComment, getRetriggerableWorkflowRuns, shouldStopForCancelledCIReview } = cancelledCiRerunLib;
+
 // Issue #1625: Shared marker constants + posting/tracking helpers
 const toolComments = await import('./tool-comments.lib.mjs');
 const { READY_TO_MERGE_MARKER, AUTO_RESTART_MARKER, AUTO_MERGED_MARKER, postTrackedComment } = toolComments;
@@ -432,23 +436,37 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
       if (cancelledBlocker && !billingBlocker) {
         await log('');
         await log(formatAligned('🔄', 'CANCELLED CI/CD CHECKS DETECTED', ''));
-        await log(formatAligned('', 'Cancelled checks:', cancelledBlocker.details.join(', '), 2));
+        await log(formatAligned('', 'Cancelled checks:', (cancelledBlocker.details || []).join(', '), 2));
 
         // Attempt to re-trigger the cancelled/stale workflow runs
         const sha = cancelledBlocker.sha;
+        let runs = [];
+        let retriggerable = [];
+        let rerunTriggered = false;
+        let rerunAttempted = false;
+        const rerunFailures = [];
+
         if (sha) {
-          const runs = await getWorkflowRunsForSha(owner, repo, sha, argv.verbose);
-          const retriggerable = runs.filter(r => r.conclusion === 'cancelled' || r.conclusion === 'stale');
-          let rerunTriggered = false;
+          runs = await getWorkflowRunsForSha(owner, repo, sha, argv.verbose);
+          retriggerable = getRetriggerableWorkflowRuns(runs);
+
+          if (retriggerable.length === 0) {
+            await log(formatAligned('', '⚠️  No cancelled/stale workflow run found for this SHA', '', 2));
+            rerunFailures.push({
+              error: 'No cancelled/stale workflow run was found for this commit SHA.',
+            });
+          }
 
           for (const run of retriggerable) {
             await log(formatAligned('', `Re-triggering workflow "${run.name}" (${run.id})...`, '', 2));
+            rerunAttempted = true;
             const rerunResult = await rerunWorkflowRun(owner, repo, run.id, argv.verbose);
             if (rerunResult.success) {
               await log(formatAligned('', `✅ Re-triggered: ${run.name}`, '', 2));
               rerunTriggered = true;
             } else {
               await log(formatAligned('', `⚠️  Could not re-trigger ${run.name}: ${rerunResult.error}`, '', 2));
+              rerunFailures.push({ run, error: rerunResult.error });
             }
           }
 
@@ -457,6 +475,38 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
             // Don't restart AI - just wait for re-triggered jobs to complete
             // The next iteration of the loop will check the new status
           }
+        } else {
+          await log(formatAligned('', '⚠️  Cancelled CI blocker did not include a commit SHA', '', 2));
+          rerunFailures.push({
+            error: 'Cancelled CI blocker did not include a commit SHA, so automatic workflow re-run could not identify the run.',
+          });
+        }
+
+        if (shouldStopForCancelledCIReview({ retriggerableRuns: retriggerable, rerunTriggered, rerunFailures })) {
+          await log(formatAligned('🛑', 'CANCELLED CI/CD NEEDS HUMAN REVIEW', 'Automatic re-run could not be started'));
+
+          try {
+            const commentBody = buildCancelledCIReviewComment({
+              blocker: cancelledBlocker,
+              runs,
+              rerunFailures,
+              rerunAttempted,
+              sha,
+            });
+            await postTrackedComment({ $, owner, repo, targetNumber: prNumber, body: commentBody });
+            await log(formatAligned('', '💬 Posted cancelled CI review notification to PR', '', 2));
+          } catch (commentError) {
+            reportError(commentError, {
+              context: 'post_cancelled_ci_review_comment',
+              owner,
+              repo,
+              prNumber,
+              operation: 'comment_on_pr',
+            });
+            await log(formatAligned('', '⚠️  Could not post cancelled CI review comment to PR', '', 2));
+          }
+
+          return { success: false, reason: 'ci_cancelled_requires_review', latestSessionId, latestAnthropicCost };
         }
         // Don't set shouldRestart for cancelled checks - wait for re-triggered jobs instead
       }

package/src/solve.config.lib.mjs

@@ -110,6 +110,11 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: 'Automatically use .gitkeep if CLAUDE.md is in .gitignore (pre-checks before creating file)',
     default: true,
   },
+  'auto-support-agents-md-as-claude-md': {
+    type: 'boolean',
+    description: '[EXPERIMENTAL] Temporarily copy AGENTS.md/agents.md to CLAUDE.md while Claude runs, then remove the temporary copy',
+    default: false,
+  },
   'attach-logs': {
     type: 'boolean',
     description: 'Upload the solution draft log file to the Pull Request on completion (⚠️ WARNING: May expose sensitive data)',

package/src/tool-comments.lib.mjs

@@ -55,6 +55,9 @@ export const AUTO_MERGED_MARKER = 'Auto-merged';
 // solve.auto-merge.lib.mjs — billing-limit notification (spending cap / free tier)
 export const BILLING_LIMIT_MARKER = 'GitHub Actions Billing Limit';
 
+// solve.auto-merge.lib.mjs — cancelled/stale CI needs manual review
+export const CANCELLED_CI_REVIEW_MARKER = 'Cancelled CI/CD Requires Review';
+
 // solve.results.lib.mjs — working session summary comments posted by
 // --attach-solution-summary / --auto-attach-solution-summary at the end of
 // every working session (top-level solve, auto-restart-until-mergeable
@@ -99,7 +102,7 @@ export const USAGE_LIMIT_REACHED_MARKER = 'Usage Limit Reached';
  * named constants above so that adding a new marker only requires adding
  * the constant and appending it here.
  */
-export const TOOL_GENERATED_COMMENT_MARKERS = [AI_WORK_SESSION_STARTED_MARKER, AI_WORK_SESSION_COMPLETED_MARKER, AI_WORK_SESSION_RESUMED_MARKER, AUTO_RESUME_ON_LIMIT_RESET_MARKER, AUTO_RESTART_ON_LIMIT_RESET_MARKER, SOLUTION_DRAFT_LOG_MARKER, AUTO_RESTART_MARKER, AUTO_RESTART_UNTIL_MERGEABLE_LOG_MARKER, READY_TO_MERGE_MARKER, AUTO_MERGED_MARKER, BILLING_LIMIT_MARKER, MAINTAINER_ACCESS_REQUEST_MARKER, LIVE_PROGRESS_SECTION_START_MARKER, SESSION_FORCE_KILLED_MARKER, REPOSITORY_INITIALIZATION_REQUIRED_MARKER, INTERACTIVE_SESSION_STARTED_MARKER, INTERACTIVE_SESSION_ENDED_MARKER, NOW_WORKING_SESSION_IS_ENDED_MARKER, SOLUTION_DRAFT_FAILED_MARKER, SOLUTION_DRAFT_FINISHED_WITH_ERRORS_MARKER, USAGE_LIMIT_REACHED_MARKER, WORKING_SESSION_SUMMARY_MARKER];
+export const TOOL_GENERATED_COMMENT_MARKERS = [AI_WORK_SESSION_STARTED_MARKER, AI_WORK_SESSION_COMPLETED_MARKER, AI_WORK_SESSION_RESUMED_MARKER, AUTO_RESUME_ON_LIMIT_RESET_MARKER, AUTO_RESTART_ON_LIMIT_RESET_MARKER, SOLUTION_DRAFT_LOG_MARKER, AUTO_RESTART_MARKER, AUTO_RESTART_UNTIL_MERGEABLE_LOG_MARKER, READY_TO_MERGE_MARKER, AUTO_MERGED_MARKER, BILLING_LIMIT_MARKER, CANCELLED_CI_REVIEW_MARKER, MAINTAINER_ACCESS_REQUEST_MARKER, LIVE_PROGRESS_SECTION_START_MARKER, SESSION_FORCE_KILLED_MARKER, REPOSITORY_INITIALIZATION_REQUIRED_MARKER, INTERACTIVE_SESSION_STARTED_MARKER, INTERACTIVE_SESSION_ENDED_MARKER, NOW_WORKING_SESSION_IS_ENDED_MARKER, SOLUTION_DRAFT_FAILED_MARKER, SOLUTION_DRAFT_FINISHED_WITH_ERRORS_MARKER, USAGE_LIMIT_REACHED_MARKER, WORKING_SESSION_SUMMARY_MARKER];
 
 /**
  * Markers that indicate the end of a working session. Used by