@link-assistant/hive-mind 1.69.2 → 1.69.4

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @link-assistant/hive-mind
 
+## 1.69.4
+
+### Patch Changes
+
+- 105172b: Fix auto-PR creation failure on fork-of-fork repositories. When `solve` runs against an issue in a repository that is itself a GitHub fork and the user has direct write access, `gh pr create` previously resolved the base repository to the upstream parent (because `gh repo clone` auto-adds an `upstream` remote for forks), producing a misleading "No commits between" error. The auto-PR command builder now always passes `--repo ${owner}/${repo}` so the PR is created against the explicit target. The fatal error block also detects the failure mode and prints a fork-aware diagnostic with the resolved remotes and a manual recovery command.
+- d89243f: Stabilize the version-info timing test that broke CI/CD by using the same 30 second reasonable bound as the broader version-info structure test. The version collector still runs commands in parallel, but individual commands can legally spend 5 seconds on a timeout and then another 5 seconds on a fallback, so the previous 10 second wall-clock assertion was too tight for GitHub-hosted runners.
+- db56b5a: Sync custom fork base branches proactively. When a user passes `--base-branch` in fork mode, the solver now copies the requested branch from `upstream` to the user's fork before creating the issue branch, and falls back to the same recovery if branch creation still trips on a missing `origin/<baseBranch>`. This prevents the `fatal: 'origin/<baseBranch>' is not a commit` failure that surfaced for issue #1772 when an existing fork pre-dated upstream's custom branch.
+
+## 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.69.2",
+  "version": "1.69.4",
   "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/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.auto-pr-fork-diagnostic.lib.mjs

@@ -0,0 +1,70 @@
+/**
+ * Fork-aware diagnostic for the auto-PR fatal error block.
+ *
+ * Issue #1774: when `gh pr create` fails with "No commits between" or
+ * "Head sha can't be blank", the most common cause is base-repo resolution
+ * picking the upstream parent of a fork (because `gh repo clone` auto-adds
+ * an `upstream` remote for forks). This helper inspects the local remotes
+ * and prints a self-explanatory diagnostic.
+ *
+ * Extracted from solve.auto-pr.lib.mjs to keep that file under the 1500-line
+ * CI cap.
+ */
+
+/**
+ * @param {object} params
+ * @param {string} params.errorMessage - prError.message from the auto-PR catch.
+ * @param {string} params.tempDir
+ * @param {string} params.owner
+ * @param {string} params.repo
+ * @param {string} params.defaultBranch
+ * @param {string} params.branchName
+ * @param {string|number} params.issueNumber
+ * @param {(msg: string, opts?: object) => Promise<void>} params.log
+ * @param {Function} params.$ - command-stream tagged function from solve.
+ * @param {Function} params.reportError
+ */
+export async function emitForkAwareDiagnostic({ errorMessage, tempDir, owner, repo, defaultBranch, branchName, issueNumber, log, $, reportError }) {
+  const errMsg = errorMessage || '';
+  if (!errMsg.includes('No commits between') && !errMsg.includes("Head sha can't be blank")) {
+    return;
+  }
+
+  try {
+    const remotesResult = await $({ cwd: tempDir, silent: true })`git remote -v`;
+    const remotesText = remotesResult.code === 0 ? remotesResult.stdout.toString().trim() : '';
+    const originLine = remotesText.split('\n').find(line => line.startsWith('origin\t') && line.includes('(fetch)'));
+    const upstreamLine = remotesText.split('\n').find(line => line.startsWith('upstream\t') && line.includes('(fetch)'));
+
+    await log('  🔬 Fork-aware diagnostic (Issue #1774):');
+    await log(`     Target repository:      ${owner}/${repo}`);
+    if (originLine) {
+      await log(`     origin remote:          ${originLine.replace(/^origin\t/, '').replace(/\s+\(fetch\)$/, '')}`);
+    }
+    if (upstreamLine) {
+      await log(`     upstream remote:        ${upstreamLine.replace(/^upstream\t/, '').replace(/\s+\(fetch\)$/, '')}`);
+      await log('');
+      await log('     `gh repo clone` automatically adds an `upstream` remote when the');
+      await log('     cloned repository is a fork. Without --repo, `gh pr create`');
+      await log('     resolves the base to that upstream parent instead of the fork');
+      await log('     where this branch was pushed, producing the misleading');
+      await log('     "No commits between" error. This version already pins --repo');
+      await log('     to the explicit target, so a fresh `solve` invocation should');
+      await log('     succeed. See docs/case-studies/issue-1774/README.md.');
+    } else {
+      await log('     (no `upstream` remote found locally)');
+    }
+    await log('');
+    await log('     Manual recovery command:');
+    await log(`     gh pr create --draft --base ${defaultBranch} --head ${branchName} --repo ${owner}/${repo}`);
+    await log('');
+  } catch (diagError) {
+    reportError(diagError, {
+      context: 'auto_pr_fork_diagnostic',
+      issueNumber,
+      operation: 'collect_fork_diagnostic',
+    });
+  }
+}
+
+export default { emitForkAwareDiagnostic };

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

@@ -5,6 +5,7 @@
 
 import { closingIssueNumbersContain, parseClosingIssueNumbers } from './pr-issue-linking.lib.mjs';
 import { buildPushRejectionExplanation, getRemoteBranchDivergenceSnapshot, synchronizeExistingIssueBranchBeforeAutoPrCreation } from './solve.branch-divergence.lib.mjs';
+import { emitForkAwareDiagnostic } from './solve.auto-pr-fork-diagnostic.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. Issue #1756: execGhWithRetry retries on transient 5xx (504) too.
 
@@ -1112,13 +1113,15 @@ ${prBody}`,
           // Build command with optional assignee and handle forks
           // Note: targetBranch is already defined above
           // IMPORTANT: Use --title-file instead of --title to avoid shell parsing issues with special characters
+          // --repo is always passed (Issue #1774) so a fork-of-fork target
+          // does not silently switch to the upstream parent via `gh repo clone`'s
+          // auto-added `upstream` remote.
           let command;
           if (argv.fork && forkedRepo) {
-            // For forks, specify the full head reference
             const forkUser = forkedRepo.split('/')[0];
             command = `cd "${tempDir}" && gh pr create --draft --title "$(cat '${prTitleFile}')" --body-file "${prBodyFile}" --base ${targetBranch} --head ${forkUser}:${branchName} --repo ${owner}/${repo}`;
           } else {
-            command = `cd "${tempDir}" && gh pr create --draft --title "$(cat '${prTitleFile}')" --body-file "${prBodyFile}" --base ${targetBranch} --head ${branchName}`;
+            command = `cd "${tempDir}" && gh pr create --draft --title "$(cat '${prTitleFile}')" --body-file "${prBodyFile}" --base ${targetBranch} --head ${branchName} --repo ${owner}/${repo}`;
           }
           // Only add assignee if user has permissions
           if (currentUser && canAssign) {
@@ -1157,12 +1160,12 @@ ${prBody}`,
               });
               await log('     Retrying PR creation without assignee...');
 
-              // Rebuild command without --assignee flag
+              // Rebuild command without --assignee flag (Issue #1774: --repo always pinned)
               if (argv.fork && forkedRepo) {
                 const forkUser = forkedRepo.split('/')[0];
                 command = `cd "${tempDir}" && gh pr create --draft --title "$(cat '${prTitleFile}')" --body-file "${prBodyFile}" --base ${targetBranch} --head ${forkUser}:${branchName} --repo ${owner}/${repo}`;
               } else {
-                command = `cd "${tempDir}" && gh pr create --draft --title "$(cat '${prTitleFile}')" --body-file "${prBodyFile}" --base ${targetBranch} --head ${branchName}`;
+                command = `cd "${tempDir}" && gh pr create --draft --title "$(cat '${prTitleFile}')" --body-file "${prBodyFile}" --base ${targetBranch} --head ${branchName} --repo ${owner}/${repo}`;
               }
 
               if (argv.verbose) {
@@ -1460,6 +1463,10 @@ ${prBody}`,
     await log('  🔍 What happened:');
     await log(`     ${prError.message}`);
     await log('');
+
+    // Issue #1774: fork-base resolution failure diagnostic.
+    await emitForkAwareDiagnostic({ errorMessage: prError.message, tempDir, owner, repo, defaultBranch, branchName, issueNumber, log, $, reportError });
+
     await log('  💡 The solve command cannot continue without a pull request.');
     await log('');
     await log('  🔧 How to fix:');
@@ -1470,14 +1477,14 @@ ${prBody}`,
     await log('');
     await log('  Option 2: Create PR manually first');
     await log(`     cd ${tempDir}`);
-    await log(`     gh pr create --draft --title "Fix issue #${issueNumber}" --body "Fixes #${issueNumber}"`);
+    await log(`     gh pr create --draft --title "Fix issue #${issueNumber}" --body "Fixes #${issueNumber}" --repo ${owner}/${repo}`);
     await log(`     Then use: ./solve.mjs "${issueUrl}" --continue`);
     await log('');
     await log('  Option 3: Debug the issue');
     await log(`     cd ${tempDir}`);
     await log('     git status');
     await log('     git log --oneline -5');
-    await log('     gh pr create --draft  # Try manually to see detailed error');
+    await log(`     gh pr create --draft --repo ${owner}/${repo}  # Try manually to see detailed error`);
     await log('');
 
     // Re-throw the error to stop execution - use prError.message directly

package/src/solve.branch.lib.mjs

@@ -205,6 +205,105 @@ export function validateBranchInArgs(args) {
   return null;
 }
 
+function isMissingOriginBaseRefError(errorOutput, baseBranch) {
+  return errorOutput.includes(`origin/${baseBranch}`) && (errorOutput.includes('is not a commit') || errorOutput.includes('not a valid object name') || errorOutput.includes('unknown revision'));
+}
+
+async function hasUpstreamRemote(tempDir, $) {
+  const result = await $({ cwd: tempDir })`git remote get-url upstream 2>/dev/null`;
+  return result.code === 0;
+}
+
+async function originHasBaseBranch(tempDir, baseBranch, $) {
+  const result = await $({ cwd: tempDir })`git show-ref --verify --quiet refs/remotes/origin/${baseBranch}`;
+  return result.code === 0;
+}
+
+/**
+ * Ensure the requested base branch exists on the fork (origin) by syncing it from upstream.
+ * Returns true if origin/<baseBranch> exists at the end of the call (was already there or was synced).
+ * Returns false if syncing was attempted and failed (caller should propagate the original error).
+ *
+ * Design note (issue #1772 follow-up): when working in fork mode against a public upstream, the user
+ * expects their fork to mirror the upstream branch they want to base work on. Before relying on
+ * git's create-from-origin path, we proactively copy the upstream branch into the fork so that the
+ * branch creation, the later PR comparison, and any ahead/behind checks all see a consistent state.
+ */
+async function ensureBaseBranchInFork({ baseBranch, tempDir, log, formatAligned, $, reason = 'proactive' }) {
+  if (!(await hasUpstreamRemote(tempDir, $))) {
+    return false;
+  }
+
+  if (reason === 'proactive') {
+    await log(`${formatAligned('🔄', 'Syncing base branch:', `ensuring origin/${baseBranch} matches upstream`)}`);
+  } else {
+    await log(`${formatAligned('🔄', 'Base branch not in fork:', `checking upstream/${baseBranch}`)}`);
+  }
+
+  const fetchResult = await $({ cwd: tempDir })`git fetch upstream`;
+  if (fetchResult.code !== 0) {
+    await log(`${formatAligned('⚠️', 'Warning:', 'Failed to fetch upstream base branch')}`, { level: 'warning' });
+    return false;
+  }
+
+  const upstreamRefResult = await $({ cwd: tempDir })`git show-ref --verify --quiet refs/remotes/upstream/${baseBranch}`;
+  if (upstreamRefResult.code !== 0) {
+    await log(`${formatAligned('⚠️', 'Warning:', `Base branch not found in upstream/${baseBranch}`)}`, { level: 'warning' });
+    return false;
+  }
+
+  await log(`${formatAligned('✅', 'Base branch found:', `upstream/${baseBranch}`)}`);
+  const checkoutBaseResult = await $({ cwd: tempDir })`git checkout -B ${baseBranch} upstream/${baseBranch}`;
+  if (checkoutBaseResult.code !== 0) {
+    await log(`${formatAligned('⚠️', 'Warning:', `Failed to prepare local ${baseBranch}`)}`, { level: 'warning' });
+    return false;
+  }
+
+  await log(`${formatAligned('🔄', 'Pushing to fork:', `${baseBranch} branch`)}`);
+  const pushBaseResult = await $({ cwd: tempDir })`git push origin ${baseBranch} 2>&1`;
+  if (pushBaseResult.code !== 0) {
+    const pushError = (pushBaseResult.stderr || pushBaseResult.stdout || 'Unknown error').toString().trim();
+    await log(`${formatAligned('⚠️', 'Warning:', `Failed to push ${baseBranch} to fork`)}`, { level: 'warning' });
+    if (pushError) await log(`${formatAligned('', 'Push error:', pushError)}`, { level: 'warning' });
+    return false;
+  }
+
+  await log(`${formatAligned('✅', 'Fork updated:', `Custom base branch ${baseBranch} pushed to fork`)}`);
+  return true;
+}
+
+async function proactivelySyncBaseBranchToFork({ baseBranch, defaultBranch, tempDir, log, formatAligned, $ }) {
+  // Default branch is already synced by setupUpstreamAndSync; skip to avoid redundant work.
+  if (baseBranch === defaultBranch) {
+    return;
+  }
+
+  if (!(await hasUpstreamRemote(tempDir, $))) {
+    return;
+  }
+
+  if (await originHasBaseBranch(tempDir, baseBranch, $)) {
+    return;
+  }
+
+  await ensureBaseBranchInFork({ baseBranch, tempDir, log, formatAligned, $, reason: 'proactive' });
+}
+
+async function retryBranchCreationFromUpstreamBase({ checkoutResult, branchName, baseBranch, tempDir, log, formatAligned, $ }) {
+  const errorOutput = `${checkoutResult.stderr || ''}${checkoutResult.stdout || ''}`;
+  if (!isMissingOriginBaseRefError(errorOutput, baseBranch)) {
+    return checkoutResult;
+  }
+
+  const synced = await ensureBaseBranchInFork({ baseBranch, tempDir, log, formatAligned, $, reason: 'reactive' });
+  if (!synced) {
+    return checkoutResult;
+  }
+
+  await log(`${formatAligned('🌿', 'Retrying branch:', `${branchName} from ${baseBranch}`)}`);
+  return await $({ cwd: tempDir })`git checkout -b ${branchName} ${baseBranch}`;
+}
+
 export async function createOrCheckoutBranch({ isContinueMode, prBranch, issueNumber, tempDir, defaultBranch, argv, log, formatAligned, $, crypto, owner, repo, prNumber }) {
   // Create a branch for the issue or checkout existing PR branch
   let branchName;
@@ -234,10 +333,33 @@ export async function createOrCheckoutBranch({ isContinueMode, prBranch, issueNu
 
     await log(`\n${formatAligned('🌿', 'Creating branch:', `${branchName} from ${baseBranch} (${branchSource})`)}`);
 
+    // Issue #1772: when a custom base branch is requested in fork mode, proactively copy it from
+    // upstream to the fork before branch creation. The fork's `gh repo fork` snapshot may pre-date
+    // upstream's custom branches, so we cannot assume origin already has the requested base.
+    if (argv.baseBranch) {
+      await proactivelySyncBaseBranchToFork({
+        baseBranch,
+        defaultBranch,
+        tempDir,
+        log,
+        formatAligned,
+        $,
+      });
+    }
+
     // IMPORTANT: Don't use 2>&1 here as it can interfere with exit codes
     // Git checkout -b outputs to stderr but that's normal
     // Create branch from the specified base branch (origin/baseBranch)
     checkoutResult = await $({ cwd: tempDir })`git checkout -b ${branchName} origin/${baseBranch}`;
+    checkoutResult = await retryBranchCreationFromUpstreamBase({
+      checkoutResult,
+      branchName,
+      baseBranch,
+      tempDir,
+      log,
+      formatAligned,
+      $,
+    });
   }
 
   if (checkoutResult.code !== 0) {

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/solve.error-handlers.lib.mjs

@@ -175,7 +175,10 @@ export const createUnhandledRejectionHandler = options => {
 /**
  * Handles the case where no PR is available when one is required
  */
-export const handleNoPrAvailableError = async ({ isContinueMode, tempDir, issueNumber, issueUrl, log, formatAligned }) => {
+export const handleNoPrAvailableError = async ({ isContinueMode, tempDir, issueNumber, issueUrl, owner, repo, log, formatAligned }) => {
+  // Issue #1774: when an explicit target repo is known, surface --repo in the
+  // recovery hint so users do not hit the same fork-base resolution trap.
+  const repoFlag = owner && repo ? ` --repo ${owner}/${repo}` : '';
   await log('');
   await log(formatAligned('❌', 'FATAL ERROR:', 'No pull request available'), { level: 'error' });
   await log('');
@@ -199,7 +202,7 @@ export const handleNoPrAvailableError = async ({ isContinueMode, tempDir, issueN
   await log('');
   await log('  Option 1: Create PR manually and use --continue');
   await log(`     cd ${tempDir}`);
-  await log(`     gh pr create --draft --title "Fix issue #${issueNumber}" --body "Fixes #${issueNumber}"`);
+  await log(`     gh pr create --draft --title "Fix issue #${issueNumber}" --body "Fixes #${issueNumber}"${repoFlag}`);
   await log('     # Then use the PR URL with solve.mjs');
   await log('');
   await log('  Option 2: Start fresh without continue mode');

package/src/solve.mjs

@@ -576,7 +576,7 @@ try {
   // CRITICAL: Validate that we have a PR number when required
   // This prevents continuing without a PR when one was supposed to be created
   if ((isContinueMode || argv.autoPullRequestCreation) && !prNumber) {
-    await handleNoPrAvailableError({ isContinueMode, tempDir, issueNumber, issueUrl, log, formatAligned });
+    await handleNoPrAvailableError({ isContinueMode, tempDir, issueNumber, issueUrl, owner, repo, log, formatAligned });
   }
 
   if (isContinueMode) {

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