@link-assistant/hive-mind 2.0.26 → 2.0.28

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 2.0.28
+
+### Patch Changes
+
+- 5b4f3df: Recommend and accept `/queue` instead of the legacy solve-prefixed queue commands, and recommend `/stop` for cancelling running sessions.
+
+## 2.0.27
+
+### Patch Changes
+
+- d3fdb7b: Respect explicit `--base-branch` through solve sessions by instructing agents not to retarget PRs and restoring the requested PR base before verification or auto-merge handling.
+
 ## 2.0.26
 
 ### Patch Changes

package/package.json

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

package/src/agent.prompts.lib.mjs

@@ -7,6 +7,7 @@ import { getArchitectureCareSubPrompt } from './architecture-care.prompts.lib.mj
 import { getExperimentsExamplesSubPrompt } from './experiments-examples.prompts.lib.mjs';
 import { getThinkingPromptInstruction } from './thinking-prompt.lib.mjs';
 import { buildWorkLanguageDirective } from './work-language.prompts.lib.mjs';
+import { buildRequestedBaseBranchDirective } from './solve-option-contract.prompts.lib.mjs';
 
 /**
  * Build the user prompt for Agent
@@ -50,6 +51,11 @@ export const buildUserPrompt = params => {
     }
   }
 
+  const requestedBaseBranchDirective = buildRequestedBaseBranchDirective(argv);
+  if (requestedBaseBranchDirective) {
+    promptLines.push(requestedBaseBranchDirective);
+  }
+
   // Add blank line
   promptLines.push('');
 

package/src/bidirectional-interactive.lib.mjs

@@ -790,6 +790,20 @@ export const createBidirectionalHandler = options => {
     return writeFrameToStdin(state.claudeStdin, frame, log, verbose);
   };
 
+  /**
+   * Stream a non-comment feedback message into the attached Claude stdin.
+   *
+   * @param {string} feedbackText
+   * @param {Object} [options]
+   * @param {string} [options.kind='metadata']
+   * @returns {Promise<boolean>} Whether the write succeeded
+   */
+  const sendFeedback = async (feedbackText, options = {}) => {
+    if (!state.claudeStdin) return false;
+    const frame = formatFeedbackForClaude(feedbackText, { kind: options.kind || 'metadata' });
+    return writeFrameToStdin(state.claudeStdin, frame, log, verbose);
+  };
+
   /**
    * Get current handler state (for debugging)
    *
@@ -828,6 +842,7 @@ export const createBidirectionalHandler = options => {
     attachClaudeStdin,
     detachClaudeStdin,
     streamInitialPrompt,
+    sendFeedback,
     // Issue #1708: queue mode + status streaming
     markAiBusy,
     markAiIdle,

package/src/claude.lib.mjs

@@ -34,11 +34,10 @@ import { createThinkingBlockRecovery } from './claude.thinking-block-recovery.li
 import { buildMissingClaudeResultMessage, collectClaudeStreamEventFacts, getClaudeMessageContent, shouldFailClaudeStreamWithoutResult } from './claude.stream-events.lib.mjs';
 import { formatNumber, mapModelToId, checkModelVisionCapability } from './claude.model-utils.lib.mjs';
 import { showResumeCommand } from './claude.resume-output.lib.mjs';
+import { createPullRequestBaseBranchCommandIntervention } from './solve.pr-base-command-intervention.lib.mjs';
 export { availableModels, fetchModelInfo }; // Re-export for backward compatibility
 export { formatNumber, mapModelToId, checkModelVisionCapability };
-// Function to validate Claude CLI connection with retry logic
 export const validateClaudeConnection = async (model = 'haiku') => {
-  // Map model alias to full ID
   const mappedModel = mapModelToId(model);
   const maxRetries = 3;
   const baseDelay = timeouts.retryBaseDelay;
@@ -60,14 +59,12 @@ export const validateClaudeConnection = async (model = 'haiku') => {
           }
         }
       } catch (versionError) {
-        // Version check failed, but we'll continue with the main validation
         if (retryCount === 0) {
           await log(`⚠️  Claude CLI version check failed (${versionError.code}), proceeding with connection test...`);
         }
       }
       let result;
       try {
-        // Primary validation: use printf piping with specified model
         result = await $`printf hi | claude --model ${mappedModel} -p`;
       } catch (pipeError) {
         await log(`⚠️  Pipe validation failed (${pipeError.code}), trying timeout approach...`);
@@ -109,9 +106,7 @@ export const validateClaudeConnection = async (model = 'haiku') => {
         return null;
       };
       const jsonError = checkForJsonError(stdout) || checkForJsonError(stderr);
-      // Check for API overload error pattern (Issue #1439: also detect 529 overloaded_error)
       const isOverloadError = (stdout.includes('API Error: 500') && stdout.includes('Overloaded')) || (stdout.includes('API Error: 529') && stdout.includes('Overloaded')) || (stderr.includes('API Error: 500') && stderr.includes('Overloaded')) || (stderr.includes('API Error: 529') && stderr.includes('Overloaded')) || (jsonError && (jsonError.type === 'api_error' || jsonError.type === 'overloaded_error') && jsonError.message === 'Overloaded');
-      // Handle overload errors with retry
       if (isOverloadError) {
         if (retryCount < maxRetries) {
           const delay = baseDelay * Math.pow(2, retryCount);
@@ -187,8 +182,7 @@ export const validateClaudeConnection = async (model = 'haiku') => {
       await log('   💡 Make sure Claude CLI is installed and accessible', { level: 'error' });
       return false;
     }
-  }; // End of attemptValidation function
-  // Start the validation with retry logic
+  };
   return await attemptValidation();
 };
 export { handleClaudeRuntimeSwitch }; // Re-export from ./claude.runtime-switch.lib.mjs
@@ -203,18 +197,15 @@ export const setClaudeVersion = version => {
 /** Resolve thinking settings based on --think and --thinking-budget options */
 export const resolveThinkingSettings = async (argv, log) => {
   const minVersion = argv.thinkingBudgetClaudeMinimumVersion || '2.1.12';
-  const version = detectedClaudeVersion || '0.0.0'; // Assume old version if not detected
+  const version = detectedClaudeVersion || '0.0.0';
   const isNewVersion = supportsThinkingBudget(version, minVersion);
-  // Get max thinking budget from argv or use default (see issue #1146)
   const maxBudget = argv.maxThinkingBudget ?? DEFAULT_MAX_THINKING_BUDGET;
-  // Get thinking level mappings calculated from maxBudget
   const thinkingLevelToTokens = getThinkingLevelToTokens(maxBudget);
   const tokensToThinkingLevel = getTokensToThinkingLevel(maxBudget);
   let thinkingBudget = argv.thinkingBudget;
   let thinkLevel = argv.think;
   let translation = null;
   if (isNewVersion) {
-    // Claude Code >= 2.1.12: translate --think to --thinking-budget
     if (thinkLevel !== undefined && thinkingBudget === undefined) {
       thinkingBudget = thinkingLevelToTokens[thinkLevel];
       translation = `--think ${thinkLevel} → --thinking-budget ${thinkingBudget}`;
@@ -227,7 +218,6 @@ export const resolveThinkingSettings = async (argv, log) => {
       }
     }
   } else {
-    // Claude Code < 2.1.12: translate --thinking-budget to --think keywords
     if (thinkingBudget !== undefined && thinkLevel === undefined) {
       thinkLevel = tokensToThinkingLevel(thinkingBudget);
       translation = `--thinking-budget ${thinkingBudget} → --think ${thinkLevel}`;
@@ -235,7 +225,6 @@ export const resolveThinkingSettings = async (argv, log) => {
         await log(`📊 Translating for Claude Code ${version} (< ${minVersion}):`, { verbose: true });
         await log(`   ${translation}`, { verbose: true });
       }
-      // Clear thinkingBudget since old versions don't support it
       thinkingBudget = undefined;
     }
   }
@@ -243,10 +232,8 @@ export const resolveThinkingSettings = async (argv, log) => {
 };
 /** Check if Playwright MCP is available and connected to Claude @returns {Promise<boolean>} */
 export const checkPlaywrightMcpAvailability = ensureClaudePlaywrightMcpServer;
-/** Execute Claude with all prompts and settings - main entry point */
 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;
-  // Check if agent-commander is installed when the option is enabled
   if (argv.promptSubagentsViaAgentCommander) {
     try {
       await $`which start-agent`;
@@ -256,9 +243,7 @@ export const executeClaude = async params => {
       await log('⚠️  agent-commander not installed; prompt guidance will be skipped (npm i -g @link-assistant/agent-commander)');
     }
   }
-  // Import prompt building functions from claude.prompts.lib.mjs
   const { buildUserPrompt, buildSystemPrompt } = await import('./claude.prompts.lib.mjs');
-  // Check if the model supports vision using models.dev API
   const mappedModel = mapModelToId(argv.model);
   const modelSupportsVision = await checkModelVisionCapability(mappedModel);
   if (argv.verbose) {
@@ -304,7 +289,6 @@ export const executeClaude = async params => {
     if (feedbackLines && feedbackLines.length > 0) {
       await log('   Feedback info: Included', { verbose: true });
     }
-    // In dry-run mode, output the actual prompts for debugging
     if (argv.dryRun) {
       await log('\n📋 User prompt content:', { verbose: true });
       await log('---BEGIN USER PROMPT---', { verbose: true });
@@ -359,41 +343,30 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
   const os = (await use('os')).default;
   const homeDir = options.homeDir || os.homedir();
   const fetchModelInfoForUsage = options.fetchModelInfo || fetchModelInfo;
-  // Construct the path to the session JSONL file
-  // Format: ~/.claude/projects/<project-dir>/<session-id>.jsonl
-  // The project directory name is the full path with slashes replaced by dashes
-  // e.g., /tmp/gh-issue-solver-123 becomes -tmp-gh-issue-solver-123
   const projectDirName = tempDir.replace(/\//g, '-');
   const sessionFile = path.join(homeDir, '.claude', 'projects', projectDirName, `${sessionId}.jsonl`);
   try {
     await fs.access(sessionFile);
   } catch {
-    // File doesn't exist yet or can't be accessed
     return null;
   }
-  // Initialize per-model usage tracking
   const modelUsage = {};
   // Issue #1501: Deduplicate JSONL entries by message ID (stream-json splits responses)
   const seenMessageIds = new Set();
   let duplicateCount = 0;
-  // Issue #1501: Track peak context usage per request (not cumulative)
   const peakContextByModel = {};
   let globalPeakContext = 0;
-  // Issue #1491: Track sub-sessions between compactification events
   const subSessions = [];
   let currentSubSession = createEmptySubSessionUsage();
   const compactifications = [];
   try {
-    // Read the entire file
     const fileContent = await fs.readFile(sessionFile, 'utf8');
     const lines = fileContent.trim().split('\n');
     for (const line of lines) {
       if (!line.trim()) continue;
       try {
         const entry = JSON.parse(line);
-        // Issue #1491: Detect compactification boundary events
         if (entry.type === 'system' && entry.subtype === 'compact_boundary') {
-          // Save current sub-session and start a new one
           if (currentSubSession.messageCount > 0) {
             subSessions.push(currentSubSession);
           }
@@ -411,7 +384,7 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
           if (msgId) {
             if (seenMessageIds.has(msgId)) {
               duplicateCount++;
-              continue; // Skip — already counted this message's usage
+              continue;
             }
             seenMessageIds.add(msgId);
           }
@@ -429,7 +402,6 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
           if (requestContext > globalPeakContext) {
             globalPeakContext = requestContext;
           }
-          // Issue #1491: Also track per-sub-session usage
           if (usage.input_tokens) currentSubSession.inputTokens += usage.input_tokens;
           if (usage.cache_creation_input_tokens) currentSubSession.cacheCreationTokens += usage.cache_creation_input_tokens;
           if (usage.cache_read_input_tokens) currentSubSession.cacheReadTokens += usage.cache_read_input_tokens;
@@ -448,16 +420,13 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
         continue;
       }
     }
-    // Push the final sub-session
     if (currentSubSession.messageCount > 0) {
       subSessions.push(currentSubSession);
     }
     mergeResultModelUsage(modelUsage, resultModelUsage);
-    // If no usage data was found, return null
     if (Object.keys(modelUsage).length === 0) {
       return null;
     }
-    // Fetch model information for each model
     const modelInfoPromises = Object.keys(modelUsage).map(async modelId => {
       const modelInfo = await fetchModelInfoForUsage(modelId);
       return { modelId, modelInfo };
@@ -469,7 +438,6 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
         modelInfoMap[modelId] = modelInfo;
       }
     }
-    // Calculate cost for each model and store all characteristics
     for (const [modelId, usage] of Object.entries(modelUsage)) {
       const modelInfo = modelInfoMap[modelId];
       // Issue #1501: Attach peak context usage per model
@@ -480,7 +448,7 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
         usage.costUSD = costData.total;
         usage.costBreakdown = costData.breakdown;
         usage.modelName = modelInfo.name || modelId;
-        usage.modelInfo = modelInfo; // Store complete model info
+        usage.modelInfo = modelInfo;
       } else {
         usage.costUSD = usage._resultCostUSD ?? null;
         usage.costBreakdown = null;
@@ -491,7 +459,6 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
         usage.modelInfo = ctx || out ? { limit: { context: ctx || null, output: out || null } } : null;
       }
     }
-    // Calculate grand totals across all models
     let totalInputTokens = 0;
     let totalCacheCreationTokens = 0;
     let totalCacheReadTokens = 0;
@@ -508,12 +475,9 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
         hasCostData = true;
       }
     }
-    // Calculate total tokens (input + cache_creation + output, cache_read doesn't count as new tokens)
     const totalTokens = totalInputTokens + totalCacheCreationTokens + totalOutputTokens;
     return {
-      // Per-model breakdown
       modelUsage,
-      // Grand totals
       inputTokens: totalInputTokens,
       cacheCreationTokens: totalCacheCreationTokens,
       cacheReadTokens: totalCacheReadTokens,
@@ -540,7 +504,6 @@ export const executeClaudeCommand = async params => {
     branchName,
     prompt,
     systemPrompt,
-    escapedPrompt,
     escapedSystemPrompt,
     argv,
     log,
@@ -560,22 +523,19 @@ export const executeClaudeCommand = async params => {
     // and issue body/title polling in setupBidirectionalHandler.
     issueNumber,
   } = params;
-  // Issue #817: Apply bidirectional-mode composition and tool-support validation before running.
-  // This may enable argv.interactiveMode, argv.acceptIncommingCommentsAsInput, and
-  // argv.excludeAllOwnIncommingCommentsFromInput when --bidirectional-interactive-mode is set.
+  const expectedBaseBranch = String(argv?.baseBranch || '').trim();
+  const escapePromptForShell = promptText => String(promptText).replace(/"/g, '\\"').replace(/\$/g, '\\$');
   await validateBidirectionalModeConfig(argv, log);
-  // Issue #1331: Unified retry configuration for all transient API errors
-  // (Overloaded, 503 Network Error, Internal Server Error) - same params, all with session preservation
   let retryCount = 0;
+  let baseBranchInterventionPrompt = null;
+  let baseBranchInterventionResumeCount = 0;
   // Issue #1834 (PR #1835 feedback): corrupted-thinking-block recovery — resume the session first,
   // then escalate to a fresh restart, auto-committing uncommitted work before each attempt. Created
   // once so its resume/restart caps persist across recursive retry calls.
   const tryThinkingBlockRecovery = createThinkingBlockRecovery({ argv, tempDir, branchName, $, log });
-  // Helper `waitWithCountdown` (per-minute countdown for delays >1 minute, Issue #1331) is shared
-  // from tool-retry.lib.mjs so claude/codex/gemini/qwen/opencode all use one implementation.
-  // Function to execute with retry logic
   const executeWithRetry = async () => {
-    // Execute claude command from the cloned repository directory
+    const promptForAttempt = baseBranchInterventionPrompt ? `${prompt}\n\n${baseBranchInterventionPrompt}\n` : prompt;
+    const escapedPromptForAttempt = escapePromptForShell(promptForAttempt);
     if (retryCount === 0) {
       await log(`\n${formatAligned('🤖', 'Executing Claude:', argv.model.toUpperCase())}`);
     } else {
@@ -585,7 +545,7 @@ export const executeClaudeCommand = async params => {
       // Issue #1949: logExecutionContext shows the requested alias with its resolved
       // full ID (e.g. "opus (claude-opus-4-8)"). The old `argv.model === 'opus' ?
       // 'opus' : 'sonnet'` heuristic mislabelled every non-"opus" alias as "sonnet".
-      await logExecutionContext({ log, model: argv.model, tool: 'claude', tempDir, branchName, promptLength: prompt.length, systemPromptLength: systemPrompt.length, feedbackLines });
+      await logExecutionContext({ log, model: argv.model, tool: 'claude', tempDir, branchName, promptLength: promptForAttempt.length, systemPromptLength: systemPrompt.length, feedbackLines });
     }
     const resourcesBefore = await getResourceSnapshot();
     await log('📈 System resources before execution:', { verbose: true });
@@ -628,7 +588,6 @@ export const executeClaudeCommand = async params => {
       outputTokens: 0,
       eventCount: 0,
     };
-    // Create interactive mode handler if enabled
     let interactiveHandler = null;
     if (argv.interactiveMode && owner && repo && prNumber) {
       await log('🔌 Interactive mode: Creating handler for real-time PR comments', { verbose: true });
@@ -649,10 +608,6 @@ export const executeClaudeCommand = async params => {
     } else if (argv.interactiveMode) {
       await log('⚠️ Interactive mode: Disabled - missing PR info (owner/repo/prNumber)', { verbose: true });
     }
-    // Issue #817 / #1708: Set up bidirectional handler when --accept-incomming-comments-as-input
-    // (or composite --bidirectional-interactive-mode / --auto-input-until-mergeable) is enabled.
-    // Returns null when inactive. issueNumber + tempDir are forwarded so the handler can
-    // poll issue title/body changes and uncommitted changes during the session (Issue #1708).
     const bidirectionalHandler = await setupBidirectionalHandler({ argv, owner, repo, prNumber, issueNumber, tempDir, $, log });
     const progressMonitor = await initProgressMonitoring(argv, { owner, repo, prNumber, $, log }); // works with or without --interactive-mode
     let execCommand;
@@ -668,7 +623,6 @@ export const executeClaudeCommand = async params => {
     const useClaudeFallbackModel = !resolvedPlanModel && mappedFallbackModel && mappedFallbackModel !== effectiveModel;
     let claudeArgs = `--output-format stream-json --verbose --dangerously-skip-permissions --model ${effectiveModel}`;
     if (useClaudeFallbackModel) claudeArgs += ` --fallback-model ${mappedFallbackModel}`;
-    // Declare queuedFeedback for use in catch/finally blocks and return value
     let queuedFeedback = [];
     // Issue #817: When --accept-incomming-comments-as-input is set and we are
     // not resuming a prior session, drive Claude via NDJSON stream-json input
@@ -692,19 +646,18 @@ export const executeClaudeCommand = async params => {
       // Prompt is delivered as the first NDJSON frame on stdin (not as -p).
       claudeArgs += ` -p --input-format stream-json --append-system-prompt "${escapedSystemPrompt}"`;
     } else {
-      claudeArgs += ` -p "${escapedPrompt}" --append-system-prompt "${escapedSystemPrompt}"`;
+      claudeArgs += ` -p "${escapedPromptForAttempt}" --append-system-prompt "${escapedSystemPrompt}"`;
     }
     const fullCommand = `(cd "${tempDir}" && ${claudePath} ${claudeArgs} | jq -c .)`;
     await log(`\n${formatAligned('📝', 'Raw command:', '')}`);
     await log(`${fullCommand}`);
     await log('');
     if (argv.verbose) {
-      await log(`📋 User prompt:\n---BEGIN USER PROMPT---\n${prompt}\n---END USER PROMPT---`, { verbose: true });
+      await log(`📋 User prompt:\n---BEGIN USER PROMPT---\n${promptForAttempt}\n---END USER PROMPT---`, { verbose: true });
       await log(`📋 System prompt:\n---BEGIN SYSTEM PROMPT---\n${systemPrompt}\n---END SYSTEM PROMPT---`, { verbose: true });
     }
     try {
       const { thinkingBudget: resolvedThinkingBudget, thinkLevel, isNewVersion, maxBudget } = await resolveThinkingSettings(argv, log);
-      // Issue #1706: --sub-session-size + --disable-1m-context. Resolve here, then pass into getClaudeEnv along with the rest.
       const { parsed: parsedSubSessionSize, contextWindowTokens } = await resolveSubSessionSize({ rawValue: argv.subSessionSize, tool: 'claude', modelId: effectiveModel, fetchModelInfo, log });
       // Issue #817: streaming mode sets exitAfterStopDelayMs=60000 so the headless Claude process stays alive between NDJSON turns.
       const claudeEnv = getClaudeEnv({ thinkingBudget: resolvedThinkingBudget, model: effectiveModel, thinkLevel, maxBudget, planModel: resolvedPlanModel, executionModel: resolvedExecutionModel, subAgentModel: resolvedSubAgentModel, showThinkingContent: argv.showThinkingContent, exitAfterStopDelayMs: streamingInput ? 60_000 : undefined, disable1mContext: !!argv.disable1mContext, subSessionSize: parsedSubSessionSize, contextWindowTokens });
@@ -728,7 +681,7 @@ export const executeClaudeCommand = async params => {
       const fallbackModelArgs = useClaudeFallbackModel ? ['--fallback-model', mappedFallbackModel] : []; // Issue #1949: Claude Code's per-request overload fallback
       if (useClaudeFallbackModel && argv.verbose) await log(`📊 Claude --fallback-model: ${mappedFallbackModel} (Issue #1949 — primary --model ${effectiveModel} stays stable across overload retries)`, { verbose: true });
       if (argv.resume) {
-        const simpleEscapedPrompt = prompt.replace(/"/g, '\\"');
+        const simpleEscapedPrompt = promptForAttempt.replace(/"/g, '\\"');
         execCommand = $({ cwd: tempDir, mirror: false, env: claudeEnv })`${claudePath} --resume ${argv.resume} --output-format stream-json --verbose --dangerously-skip-permissions --model ${effectiveModel} ${fallbackModelArgs} ${mcpDisableArgs} ${disallowedToolsArgs} -p "${simpleEscapedPrompt}" --append-system-prompt "${simpleEscapedSystem}"`;
       } else if (streamingInput) {
         // Issue #817: Drive Claude via --input-format stream-json on a pipe
@@ -737,10 +690,10 @@ export const executeClaudeCommand = async params => {
         const streamingInputArgs = ['-p', '--input-format', 'stream-json'];
         execCommand = $({ cwd: tempDir, stdin: 'pipe', mirror: false, env: claudeEnv })`${claudePath} --output-format stream-json --verbose --dangerously-skip-permissions --model ${effectiveModel} ${fallbackModelArgs} ${mcpDisableArgs} ${disallowedToolsArgs} ${streamingInputArgs} --append-system-prompt "${simpleEscapedSystem}"`;
       } else {
-        execCommand = $({ cwd: tempDir, stdin: prompt, mirror: false, env: claudeEnv })`${claudePath} --output-format stream-json --verbose --dangerously-skip-permissions --model ${effectiveModel} ${fallbackModelArgs} ${mcpDisableArgs} ${disallowedToolsArgs} --append-system-prompt "${simpleEscapedSystem}"`;
+        execCommand = $({ cwd: tempDir, stdin: promptForAttempt, mirror: false, env: claudeEnv })`${claudePath} --output-format stream-json --verbose --dangerously-skip-permissions --model ${effectiveModel} ${fallbackModelArgs} ${mcpDisableArgs} ${disallowedToolsArgs} --append-system-prompt "${simpleEscapedSystem}"`;
       }
       if (streamingInput) {
-        await attachStreamingInput(bidirectionalHandler, execCommand, prompt, log, !!argv.verbose);
+        await attachStreamingInput(bidirectionalHandler, execCommand, promptForAttempt, log, !!argv.verbose);
       }
       await log(`${formatAligned('📋', 'Command details:', '')}`);
       await log(formatAligned('📂', 'Working directory:', tempDir, 2));
@@ -815,6 +768,19 @@ export const executeClaudeCommand = async params => {
           activityTimeoutId.unref();
         }
       };
+      const baseBranchCommandIntervention = createPullRequestBaseBranchCommandIntervention({
+        expectedBaseBranch,
+        prNumber,
+        log,
+        toolLabel: 'Claude',
+        sendInput: message => (streamingInput && bidirectionalHandler?.sendFeedback ? bidirectionalHandler.sendFeedback(message, { kind: 'metadata' }) : false),
+        stopSession: async () => {
+          if (forceExitTriggered || !execCommand?.kill) return false;
+          forceExitTriggered = true;
+          killProcessTree('SIGTERM');
+          return true;
+        },
+      });
       for await (const chunk of execCommand.stream()) {
         // Issue #1510: Continue processing stream after SIGTERM to capture final output
         // The stream will naturally end when the process exits (SIGTERM) or is force-killed (SIGKILL after 5s)
@@ -854,6 +820,7 @@ export const executeClaudeCommand = async params => {
                 }
               }
               await log(JSON.stringify(data, null, 2));
+              await baseBranchCommandIntervention.handleStreamEvent(data);
               if (!sessionId && data.session_id) {
                 sessionId = data.session_id;
                 await log(`📌 Session ID: ${sessionId}`);
@@ -1088,6 +1055,7 @@ export const executeClaudeCommand = async params => {
         try {
           const data = sanitizeObjectStrings(JSON.parse(stdoutLineBuffer));
           await log(JSON.stringify(data, null, 2));
+          await baseBranchCommandIntervention.handleStreamEvent(data);
           const eventFacts = collectClaudeStreamEventFacts(data);
           messageCount += eventFacts.messageCountDelta;
           toolUseCount += eventFacts.toolUseCountDelta;
@@ -1167,6 +1135,34 @@ export const executeClaudeCommand = async params => {
 
       // Issue #817: Stop bidirectional mode monitoring and collect queued feedback
       queuedFeedback = await finalizeBidirectionalHandler(bidirectionalHandler, log);
+      const baseBranchIntervention = baseBranchCommandIntervention.getIntervention();
+      if (baseBranchIntervention && !baseBranchCommandIntervention.wasSent()) {
+        if ((sessionId || argv.resume) && baseBranchInterventionResumeCount < 1) {
+          argv.resume = sessionId || argv.resume;
+          baseBranchInterventionPrompt = baseBranchIntervention.message;
+          baseBranchInterventionResumeCount++;
+          await log('\n🔄 Resuming Claude with requested base-branch correction prompt...');
+          return await executeWithRetry();
+        }
+
+        return {
+          success: false,
+          sessionId,
+          limitReached,
+          limitResetTime,
+          limitTimezone,
+          messageCount,
+          toolUseCount,
+          errorDuringExecution,
+          anthropicTotalCostUSD,
+          resultSummary,
+          errorInfo: {
+            message: baseBranchIntervention.message,
+            violation: baseBranchIntervention.violation,
+          },
+          queuedFeedback,
+        };
+      }
       const retryableLastError = classifyRetryableError(lastMessage);
       // Issue #1834: Corrupted extended-thinking blocks → try to resume the session first, then fall
       // back to a fresh restart (PR #1835 feedback). When both caps are reached, tryThinkingBlockRecovery

package/src/claude.prompts.lib.mjs

@@ -9,6 +9,7 @@ import { getExperimentsExamplesSubPrompt } from './experiments-examples.prompts.
 import { primaryModelNames } from './models/index.mjs';
 import { getThinkingPromptInstruction } from './thinking-prompt.lib.mjs';
 import { buildWorkLanguageDirective } from './work-language.prompts.lib.mjs';
+import { buildRequestedBaseBranchDirective } from './solve-option-contract.prompts.lib.mjs';
 
 /**
  * Build the user prompt for Claude
@@ -57,6 +58,11 @@ export const buildUserPrompt = params => {
     }
   }
 
+  const requestedBaseBranchDirective = buildRequestedBaseBranchDirective(argv);
+  if (requestedBaseBranchDirective) {
+    promptLines.push(requestedBaseBranchDirective);
+  }
+
   // Add contributing guidelines if available
   if (contributingGuidelines) {
     promptLines.push('');

package/src/codex.lib.mjs

@@ -35,6 +35,7 @@ import { classifyRetryableError, getRetryDelayMs, maybeSwitchToFallbackModel, wa
 import { parseSubSessionSize, buildCodexSubSessionSizeConfigArgs, buildCodexDisable1mContextConfigArgs } from './sub-session-size.lib.mjs'; // Issue #1706
 import { getCumulativeContextInputTokens } from './context-fill.lib.mjs';
 import { deployHandoffSkill } from './handoff-skill.lib.mjs'; // Issue #1877
+import { createPullRequestBaseBranchCommandIntervention } from './solve.pr-base-command-intervention.lib.mjs';
 import Decimal from 'decimal.js-light';
 
 const CODEX_USAGE_FIELD_NAMES = ['input_tokens', 'cached_input_tokens', 'output_tokens', 'cache_write_tokens', 'cache_creation_input_tokens', 'reasoning_tokens', 'reasoning_output_tokens', 'input_tokens_details.cached_tokens', 'input_tokens_details.cache_read_tokens', 'input_tokens_details.cache_write_tokens', 'input_tokens_details.cache_creation_tokens', 'input_tokens_details.cache_creation_input_tokens', 'output_tokens_details.reasoning_tokens'];
@@ -767,9 +768,12 @@ export const executeCodexCommand = async params => {
   const { tempDir, branchName, prompt, systemPrompt, argv, log, formatAligned, getResourceSnapshot, forkedRepo, feedbackLines, codexPath, $, owner, repo, prNumber, calculatePricing = calculateCodexPricing, waitForRetryDelay = waitWithCountdown } = params;
 
   const shellQuote = value => `"${String(value).replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+  const expectedBaseBranch = String(argv?.baseBranch || '').trim();
 
   // Retry configuration
   let retryCount = 0;
+  let baseBranchInterventionPrompt = null;
+  let baseBranchInterventionResumeCount = 0;
 
   const executeWithRetry = async () => {
     // Execute codex command from the cloned repository directory
@@ -806,7 +810,8 @@ export const executeCodexCommand = async params => {
 
     // For Codex, we combine system and user prompts into a single message
     // Codex doesn't have separate system prompt support in CLI mode
-    const combinedPrompt = systemPrompt ? `${systemPrompt}\n\n${prompt}` : prompt;
+    const promptForAttempt = baseBranchInterventionPrompt ? `${prompt}\n\n${baseBranchInterventionPrompt}\n` : prompt;
+    const combinedPrompt = systemPrompt ? `${systemPrompt}\n\n${promptForAttempt}` : promptForAttempt;
 
     // Write the combined prompt to a file for piping
     // Use OS temporary directory instead of repository workspace to avoid polluting the repo
@@ -919,6 +924,17 @@ export const executeCodexCommand = async params => {
       let lastMessage = '';
       let lastTextContent = ''; // Issue #1263: Track last text content for result summary
       let authError = false;
+      const baseBranchCommandIntervention = createPullRequestBaseBranchCommandIntervention({
+        expectedBaseBranch,
+        prNumber,
+        log,
+        toolLabel: 'Codex',
+        stopSession: async () => {
+          if (!execCommand?.kill) return false;
+          execCommand.kill('SIGTERM');
+          return true;
+        },
+      });
       let codexJsonState = {
         sessionId: null,
         authError: false,
@@ -949,6 +965,7 @@ export const executeCodexCommand = async params => {
           lastMessage = output;
 
           codexJsonState = parseCodexExecJsonOutput(output, codexJsonState, mappedModel);
+          await baseBranchCommandIntervention.handleCommandExecutions(codexJsonState.commandExecutions);
 
           if (interactiveHandler || progressMonitor) {
             for (const rawLine of output.split('\n')) {
@@ -990,6 +1007,7 @@ export const executeCodexCommand = async params => {
             await log(errorOutput, { stream: 'stderr' });
           }
           codexJsonState = parseCodexExecJsonOutput(errorOutput, codexJsonState, mappedModel);
+          await baseBranchCommandIntervention.handleCommandExecutions(codexJsonState.commandExecutions);
         } else if (chunk.type === 'exit') {
           exitCode = chunk.code;
         }
@@ -1064,6 +1082,31 @@ export const executeCodexCommand = async params => {
         await log(`🤖 Codex exec JSON did not expose model IDs; using requested model for reporting: ${mappedModel}`, { verbose: true });
       }
 
+      const baseBranchIntervention = baseBranchCommandIntervention.getIntervention();
+      if (baseBranchIntervention) {
+        if ((sessionId || argv.resume) && baseBranchInterventionResumeCount < 1) {
+          argv.resume = sessionId || argv.resume;
+          baseBranchInterventionPrompt = baseBranchIntervention.message;
+          baseBranchInterventionResumeCount++;
+          await log('\n🔄 Resuming Codex with requested base-branch correction prompt...');
+          return await executeWithRetry();
+        }
+
+        return {
+          success: false,
+          sessionId,
+          limitReached,
+          limitResetTime,
+          codexJsonDetails: codexJsonState,
+          errorInfo: {
+            message: baseBranchIntervention.message,
+            violation: baseBranchIntervention.violation,
+          },
+          result: baseBranchIntervention.message,
+          resultSummary: lastTextContent || null,
+        };
+      }
+
       const firstActualModelId = mappedModel;
       const pricingInfo = firstActualModelId ? await calculatePricing(firstActualModelId, codexJsonState.tokenUsage.stepCount > 0 ? codexJsonState.tokenUsage : null) : null;
       if (pricingInfo?.totalCostUSD !== null && pricingInfo?.totalCostUSD !== undefined) {

package/src/codex.prompts.lib.mjs

@@ -8,6 +8,7 @@ import { getHandoffSubPrompt } from './handoff.prompts.lib.mjs';
 import { getExperimentsExamplesSubPrompt } from './experiments-examples.prompts.lib.mjs';
 import { getThinkingPromptInstruction } from './thinking-prompt.lib.mjs';
 import { buildWorkLanguageDirective } from './work-language.prompts.lib.mjs';
+import { buildRequestedBaseBranchDirective } from './solve-option-contract.prompts.lib.mjs';
 
 /**
  * Build the user prompt for Codex
@@ -51,6 +52,11 @@ export const buildUserPrompt = params => {
     }
   }
 
+  const requestedBaseBranchDirective = buildRequestedBaseBranchDirective(argv);
+  if (requestedBaseBranchDirective) {
+    promptLines.push(requestedBaseBranchDirective);
+  }
+
   // Add blank line
   promptLines.push('');
 

package/src/gemini.prompts.lib.mjs

@@ -7,6 +7,7 @@ import { getArchitectureCareSubPrompt } from './architecture-care.prompts.lib.mj
 import { getExperimentsExamplesSubPrompt } from './experiments-examples.prompts.lib.mjs';
 import { getThinkingPromptInstruction } from './thinking-prompt.lib.mjs';
 import { buildWorkLanguageDirective } from './work-language.prompts.lib.mjs';
+import { buildRequestedBaseBranchDirective } from './solve-option-contract.prompts.lib.mjs';
 
 /**
  * Build the user prompt for Gemini
@@ -44,6 +45,11 @@ export const buildUserPrompt = params => {
     }
   }
 
+  const requestedBaseBranchDirective = buildRequestedBaseBranchDirective(argv);
+  if (requestedBaseBranchDirective) {
+    promptLines.push(requestedBaseBranchDirective);
+  }
+
   promptLines.push('');
 
   if (isContinueMode && feedbackLines && feedbackLines.length > 0) {