@link-assistant/hive-mind 1.36.0 → 1.37.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @link-assistant/hive-mind
 
+## 1.37.0
+
+### Minor Changes
+
+- f02c1fc: fix synthetic model appearing in PR comments by filtering internal Claude CLI router entries (Issue #1486)
+- dd87b23: Add opusplan model support and --plan-model option for flexible plan/execution model pairing
+
+## 1.36.1
+
+### Patch Changes
+
+- 74bf211: fix false positive 'Ready to merge' by adding workflow run grace period (Issue #1480)
+
 ## 1.36.0
 
 ### Minor Changes

package/README.md

@@ -859,6 +859,12 @@ ps axjf
 pkill -f gh-issue-solver-1773073065743
 ```
 
+### Kill all headless browsers spawned by ms-playwright
+
+```bash
+pkill -f ms-playwright/chromium_headless_shell-1200
+```
+
 That can be done, but not recommended as reboot have better effect.
 
 ## 📄 License

package/package.json

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

package/src/claude.lib.mjs

@@ -586,13 +586,13 @@ export const calculateSessionTokens = async (sessionId, tempDir) => {
     // Read the entire file
     const fileContent = await fs.readFile(sessionFile, 'utf8');
     const lines = fileContent.trim().split('\n');
-    // Parse each line and accumulate token counts per model
     for (const line of lines) {
       if (!line.trim()) continue;
       try {
         const entry = JSON.parse(line);
         if (entry.message && entry.message.usage && entry.message.model) {
           const model = entry.message.model;
+          if (model.startsWith('<') && model.endsWith('>')) continue; // Issue #1486: skip <synthetic> etc.
           const usage = entry.message.usage;
           // Initialize model entry if it doesn't exist
           if (!modelUsage[model]) {
@@ -842,11 +842,12 @@ export const executeClaudeCommand = async params => {
     } else if (argv.interactiveMode) {
       await log('⚠️ Interactive mode: Disabled - missing PR info (owner/repo/prNumber)', { verbose: true });
     }
-    // Build claude command with optional resume flag
     let execCommand;
     const mappedModel = mapModelToId(argv.model);
-    // Build claude command arguments
-    let claudeArgs = `--output-format stream-json --verbose --dangerously-skip-permissions --model ${mappedModel}`;
+    const resolvedPlanModel = argv.planModel ? mapModelToId(argv.planModel) : undefined; // Issue #1223
+    const effectiveModel = resolvedPlanModel ? 'opusplan' : mappedModel;
+    const resolvedExecutionModel = resolvedPlanModel ? mappedModel : undefined;
+    let claudeArgs = `--output-format stream-json --verbose --dangerously-skip-permissions --model ${effectiveModel}`;
     if (argv.resume) {
       await log(`🔄 Resuming from session: ${argv.resume}`);
       claudeArgs = `--resume ${argv.resume} ${claudeArgs}`;
@@ -862,22 +863,22 @@ export const executeClaudeCommand = async params => {
     }
     try {
       const { thinkingBudget: resolvedThinkingBudget, thinkLevel, isNewVersion, maxBudget } = await resolveThinkingSettings(argv, log);
-      const claudeEnv = getClaudeEnv({ thinkingBudget: resolvedThinkingBudget, model: mappedModel, thinkLevel, maxBudget });
+      const claudeEnv = getClaudeEnv({ thinkingBudget: resolvedThinkingBudget, model: effectiveModel, thinkLevel, maxBudget, planModel: resolvedPlanModel, executionModel: resolvedExecutionModel });
       if (argv.verbose) claudeEnv.ANTHROPIC_LOG = 'debug';
-      const modelMaxOutputTokens = getMaxOutputTokensForModel(mappedModel);
+      const modelMaxOutputTokens = getMaxOutputTokensForModel(effectiveModel);
       if (argv.verbose) {
         await log(`📊 CLAUDE_CODE_MAX_OUTPUT_TOKENS: ${modelMaxOutputTokens}, MCP_TIMEOUT: ${claudeCode.mcpTimeout}ms, MCP_TOOL_TIMEOUT: ${claudeCode.mcpToolTimeout}ms, ANTHROPIC_LOG: debug`, { verbose: true });
+        if (resolvedPlanModel) await log(`📊 opusplan: plan=${resolvedPlanModel}, exec=${resolvedExecutionModel}`, { verbose: true });
         if (resolvedThinkingBudget !== undefined) await log(`📊 MAX_THINKING_TOKENS: ${resolvedThinkingBudget}`, { verbose: true });
         if (claudeEnv.CLAUDE_CODE_EFFORT_LEVEL) await log(`📊 CLAUDE_CODE_EFFORT_LEVEL: ${claudeEnv.CLAUDE_CODE_EFFORT_LEVEL}`, { verbose: true });
         if (!isNewVersion && thinkLevel) await log(`📊 Thinking level (via keywords): ${thinkLevel}`, { verbose: true });
       }
+      const simpleEscapedSystem = systemPrompt.replace(/"/g, '\\"');
       if (argv.resume) {
         const simpleEscapedPrompt = prompt.replace(/"/g, '\\"');
-        const simpleEscapedSystem = systemPrompt.replace(/"/g, '\\"');
-        execCommand = $({ cwd: tempDir, mirror: false, env: claudeEnv })`${claudePath} --resume ${argv.resume} --output-format stream-json --verbose --dangerously-skip-permissions --model ${mappedModel} -p "${simpleEscapedPrompt}" --append-system-prompt "${simpleEscapedSystem}"`;
+        execCommand = $({ cwd: tempDir, mirror: false, env: claudeEnv })`${claudePath} --resume ${argv.resume} --output-format stream-json --verbose --dangerously-skip-permissions --model ${effectiveModel} -p "${simpleEscapedPrompt}" --append-system-prompt "${simpleEscapedSystem}"`;
       } else {
-        const simpleEscapedSystem = systemPrompt.replace(/"/g, '\\"');
-        execCommand = $({ cwd: tempDir, stdin: prompt, mirror: false, env: claudeEnv })`${claudePath} --output-format stream-json --verbose --dangerously-skip-permissions --model ${mappedModel} --append-system-prompt "${simpleEscapedSystem}"`;
+        execCommand = $({ cwd: tempDir, stdin: prompt, mirror: false, env: claudeEnv })`${claudePath} --output-format stream-json --verbose --dangerously-skip-permissions --model ${effectiveModel} --append-system-prompt "${simpleEscapedSystem}"`;
       }
       await log(`${formatAligned('📋', 'Command details:', '')}`);
       await log(formatAligned('📂', 'Working directory:', tempDir, 2));
@@ -1262,7 +1263,6 @@ export const executeClaudeCommand = async params => {
             sessionId,
             resumeCommand: argv.url ? `${process.argv[0]} ${process.argv[1]} --auto-continue ${argv.url}` : null,
           });
-
           for (const line of messageLines) {
             await log(line, { level: 'warning' });
           }

package/src/config.lib.mjs

@@ -174,9 +174,10 @@ export const DEFAULT_MAX_THINKING_BUDGET_OPUS_46 = parseIntWithDefault('HIVE_MIN
 export const isOpus46OrLater = model => {
   if (!model) return false;
   const normalizedModel = model.toLowerCase();
-  // Check for explicit opus-4-6 or later versions
+  // Check for explicit opus-4-6 or later versions, or opusplan (Issue #1223)
   // Note: The 'opus' alias now maps to Opus 4.6 (Issue #1433), so we also check for the alias directly
-  return normalizedModel === 'opus' || normalizedModel.includes('opus-4-6') || normalizedModel.includes('opus-4-7') || normalizedModel.includes('opus-5');
+  // opusplan uses Opus for planning, so it should get Opus-level settings
+  return normalizedModel === 'opus' || normalizedModel === 'opusplan' || normalizedModel.includes('opus-4-6') || normalizedModel.includes('opus-4-7') || normalizedModel.includes('opus-5');
 };
 
 /**
@@ -318,6 +319,10 @@ export const supportsThinkingBudget = (version, minVersion = '2.1.12') => {
 // Also sets MCP_TIMEOUT and MCP_TOOL_TIMEOUT for MCP tool execution (see issue #1066)
 // Supports model-specific max output tokens for Opus 4.6 (Issue #1221)
 // Sets CLAUDE_CODE_EFFORT_LEVEL for Opus 4.6 models (Issue #1238)
+// Supports planModel/executionModel for opusplan mode (Issue #1223)
+// See: https://code.claude.com/docs/en/model-config
+//   ANTHROPIC_DEFAULT_OPUS_MODEL  → model used in plan mode (and for 'opus' alias)
+//   ANTHROPIC_DEFAULT_SONNET_MODEL → model used in execution mode (and for 'sonnet' alias)
 export const getClaudeEnv = (options = {}) => {
   // Get max output tokens based on model (Issue #1221)
   const maxOutputTokens = options.model ? getMaxOutputTokensForModel(options.model) : claudeCode.maxOutputTokens;
@@ -327,8 +332,6 @@ export const getClaudeEnv = (options = {}) => {
     CLAUDE_CODE_MAX_OUTPUT_TOKENS: String(maxOutputTokens),
     // MCP timeout configurations to prevent tool calls from hanging indefinitely
     // See: https://github.com/link-assistant/hive-mind/issues/1066
-    // MCP_TIMEOUT: Timeout for MCP server startup
-    // MCP_TOOL_TIMEOUT: Timeout for MCP tool execution (the one that prevents stuck tools)
     MCP_TIMEOUT: String(claudeCode.mcpTimeout),
     MCP_TOOL_TIMEOUT: String(claudeCode.mcpToolTimeout),
   };
@@ -354,6 +357,17 @@ export const getClaudeEnv = (options = {}) => {
       env.CLAUDE_CODE_EFFORT_LEVEL = effortLevel;
     }
   }
+  // Set ANTHROPIC_DEFAULT_OPUS_MODEL when planModel is specified (Issue #1223)
+  // This tells Claude Code which model to use during plan mode in opusplan
+  if (options.planModel) {
+    env.ANTHROPIC_DEFAULT_OPUS_MODEL = String(options.planModel);
+  }
+  // Set ANTHROPIC_DEFAULT_SONNET_MODEL when executionModel is specified (Issue #1223)
+  // This tells Claude Code which model to use during execution mode in opusplan
+  // Enables combinations like --plan-model opus --model haiku
+  if (options.executionModel) {
+    env.ANTHROPIC_DEFAULT_SONNET_MODEL = String(options.executionModel);
+  }
 
   return env;
 };
@@ -413,6 +427,7 @@ const defaultAvailableModels = `(
   opus
   sonnet
   haiku
+  opusplan
 )`;
 
 export const modelConfig = {

package/src/github-merge.lib.mjs

@@ -1286,6 +1286,170 @@ export async function getActiveRepoWorkflows(owner, repo, verbose = false) {
   }
 }
 
+/**
+ * Get the committed date of a specific commit from GitHub API
+ * Issue #1480: Used to determine how recently a commit was pushed, to distinguish between
+ * "CI not yet registered in API" (race condition) and "CI definitively not triggered"
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {string} sha - Commit SHA
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{date: Date|null, ageSeconds: number|null}>}
+ */
+export async function getCommitDate(owner, repo, sha, verbose = false) {
+  try {
+    const { stdout } = await exec(`gh api repos/${owner}/${repo}/commits/${sha} --jq '.commit.committer.date'`);
+    const dateStr = stdout.trim();
+    if (!dateStr) {
+      return { date: null, ageSeconds: null };
+    }
+    const commitDate = new Date(dateStr);
+    const ageSeconds = Math.floor((Date.now() - commitDate.getTime()) / 1000);
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Commit ${sha.substring(0, 7)} date: ${dateStr} (${ageSeconds}s ago)`);
+    }
+    return { date: commitDate, ageSeconds };
+  } catch (error) {
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Error fetching commit date for ${sha}: ${error.message}`);
+    }
+    return { date: null, ageSeconds: null };
+  }
+}
+
+/**
+ * Check if any previous commits in a PR had workflow runs triggered.
+ * Issue #1480: If earlier commits in the same PR triggered CI, we should expect CI
+ * for the HEAD commit too (unless conditions changed). This provides an additional
+ * signal that CI should be expected and avoids false "CI not triggered" conclusions.
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {number} prNumber - Pull request number
+ * @param {string} headSha - Current HEAD SHA (to exclude from check)
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{hadPreviousCI: boolean, previousCommitsWithCI: number, totalPreviousCommits: number}>}
+ */
+export async function checkPreviousPRCommitsHadCI(owner, repo, prNumber, headSha, verbose = false) {
+  try {
+    // Get all commits in the PR
+    const { stdout: commitsJson } = await exec(`gh api "repos/${owner}/${repo}/pulls/${prNumber}/commits?per_page=100" --jq '[.[].sha]'`);
+    const allShas = JSON.parse(commitsJson.trim() || '[]');
+
+    // Exclude the current HEAD SHA
+    const previousShas = allShas.filter(sha => sha !== headSha);
+
+    if (previousShas.length === 0) {
+      if (verbose) {
+        console.log(`[VERBOSE] /merge: PR #${prNumber} has no previous commits to check for CI history`);
+      }
+      return { hadPreviousCI: false, previousCommitsWithCI: 0, totalPreviousCommits: 0 };
+    }
+
+    // Check the most recent previous commits (limit to last 3 to avoid excessive API calls)
+    const commitsToCheck = previousShas.slice(-3);
+    let commitsWithCI = 0;
+
+    for (const sha of commitsToCheck) {
+      try {
+        const { stdout } = await exec(`gh api "repos/${owner}/${repo}/actions/runs?head_sha=${sha}&per_page=1" --jq '.total_count'`);
+        const count = parseInt(stdout.trim(), 10);
+        if (count > 0) {
+          commitsWithCI++;
+        }
+      } catch {
+        // Skip errors for individual commits
+      }
+    }
+
+    const hadPreviousCI = commitsWithCI > 0;
+
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: PR #${prNumber} previous CI history: ${commitsWithCI}/${commitsToCheck.length} checked commits had workflow runs (total PR commits: ${allShas.length})`);
+    }
+
+    return { hadPreviousCI, previousCommitsWithCI: commitsWithCI, totalPreviousCommits: previousShas.length };
+  } catch (error) {
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Error checking previous PR commits CI history: ${error.message}`);
+    }
+    return { hadPreviousCI: false, previousCommitsWithCI: 0, totalPreviousCommits: 0 };
+  }
+}
+
+/**
+ * Check if any workflow files in the repository have PR-related triggers
+ * Issue #1480: Used as additional signal to determine if CI should run on PRs.
+ * Parses .github/workflows/*.yml files from the repository content API.
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{hasPRTriggers: boolean, hasWorkflowFiles: boolean, workflows: Array<{name: string, triggers: string[]}>}>}
+ */
+export async function checkWorkflowsHavePRTriggers(owner, repo, verbose = false) {
+  try {
+    // List workflow files in .github/workflows/
+    const { stdout: listJson } = await exec(`gh api "repos/${owner}/${repo}/contents/.github/workflows" --jq '[.[] | select(.name | test("\\\\.(yml|yaml)$")) | {name: .name, download_url: .download_url, path: .path}]' 2>/dev/null`);
+    const files = JSON.parse(listJson.trim() || '[]');
+
+    if (files.length === 0) {
+      if (verbose) {
+        console.log(`[VERBOSE] /merge: No workflow files found in ${owner}/${repo}/.github/workflows/ — no CI/CD will execute`);
+      }
+      // Issue #1480: hasWorkflowFiles=false is a strong signal that no CI/CD is configured at the file level
+      return { hasPRTriggers: false, hasWorkflowFiles: false, workflows: [] };
+    }
+
+    const prTriggerPatterns = [/\bon:\s*\n\s+pull_request/m, /\bon:\s*\[.*pull_request.*\]/m, /\bon:\s*pull_request\b/m, /\bpull_request_target\b/m];
+
+    // Also check for push triggers (push to PR branches triggers CI)
+    const pushTriggerPatterns = [/\bon:\s*\n\s+push/m, /\bon:\s*\[.*push.*\]/m, /\bon:\s*push\b/m];
+
+    const results = [];
+
+    for (const file of files) {
+      try {
+        // Fetch file content (use raw content from the API)
+        const { stdout: contentJson } = await exec(`gh api "repos/${owner}/${repo}/contents/${file.path}" --jq '.content'`);
+        const content = Buffer.from(contentJson.trim().replace(/"/g, ''), 'base64').toString('utf-8');
+
+        const triggers = [];
+        if (prTriggerPatterns.some(p => p.test(content))) {
+          triggers.push('pull_request');
+        }
+        if (pushTriggerPatterns.some(p => p.test(content))) {
+          triggers.push('push');
+        }
+
+        if (triggers.length > 0) {
+          results.push({ name: file.name, triggers });
+        }
+
+        if (verbose) {
+          console.log(`[VERBOSE] /merge: Workflow ${file.name}: triggers=[${triggers.join(', ')}]`);
+        }
+      } catch (fileError) {
+        if (verbose) {
+          console.log(`[VERBOSE] /merge: Error reading workflow file ${file.name}: ${fileError.message}`);
+        }
+      }
+    }
+
+    const hasPRTriggers = results.length > 0;
+
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: ${results.length}/${files.length} workflow files have PR/push triggers`);
+    }
+
+    return { hasPRTriggers, hasWorkflowFiles: true, workflows: results };
+  } catch (error) {
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Error checking workflow PR triggers: ${error.message}`);
+    }
+    // On error, assume workflows might have PR triggers (safer: avoids false positives)
+    return { hasPRTriggers: true, hasWorkflowFiles: true, workflows: [] };
+  }
+}
+
 // Issue #1341: Re-export post-merge CI functions from separate module
 import { waitForCommitCI, checkBranchCIHealth, getMergeCommitSha } from './github-merge-ci.lib.mjs';
 export { waitForCommitCI, checkBranchCIHealth, getMergeCommitSha };
@@ -1323,6 +1487,10 @@ export default {
   checkBranchCIHealth,
   getMergeCommitSha,
   getActiveRepoWorkflows,
+  // Issue #1480: Commit date, workflow PR triggers, and previous commit CI history for race condition detection
+  getCommitDate,
+  checkPreviousPRCommitsHadCI,
+  checkWorkflowsHavePRTriggers,
   // Issue #1413: Use issue timeline to find genuinely linked PRs (avoids false positives from text search)
   getLinkedPRsFromTimeline,
 };

package/src/github.lib.mjs

@@ -390,9 +390,7 @@ export async function attachLogToGitHub(options) {
     if (useLargeFileMode && verbose) {
       await log(`  📁 Large log file (${Math.round(logStats.size / 1024 / 1024)}MB), will use gh-upload-log`, { verbose: true });
     }
-    // Calculate token usage if sessionId and tempDir are provided (skip for agent tool with pricing)
-    let totalCostUSD = publicPricingEstimate;
-    // Issue #1225: Collect actual model IDs from Claude session JSON output
+    let totalCostUSD = publicPricingEstimate; // Issue #1225: token usage + actual model IDs
     let actualModelIds = null;
     if (totalCostUSD === null && sessionId && tempDir && !errorMessage) {
       try {
@@ -401,23 +399,15 @@ export async function attachLogToGitHub(options) {
         if (tokenUsage) {
           if (tokenUsage.totalCostUSD !== null && tokenUsage.totalCostUSD !== undefined) {
             totalCostUSD = tokenUsage.totalCostUSD;
-            if (verbose) {
-              await log(`  💰 Calculated cost: $${totalCostUSD.toFixed(6)}`, { verbose: true });
-            }
+            if (verbose) await log(`  💰 Calculated cost: $${totalCostUSD.toFixed(6)}`, { verbose: true });
           }
-          // Extract actual model IDs from session data (Issue #1225)
           if (tokenUsage.modelUsage && Object.keys(tokenUsage.modelUsage).length > 0) {
             actualModelIds = Object.keys(tokenUsage.modelUsage);
-            if (verbose) {
-              await log(`  🤖 Actual models used: ${actualModelIds.join(', ')}`, { verbose: true });
-            }
+            if (verbose) await log(`  🤖 Actual models used: ${actualModelIds.join(', ')}`, { verbose: true });
           }
         }
       } catch (tokenError) {
-        // Don't fail the entire upload if token calculation fails
-        if (verbose) {
-          await log(`  ⚠️  Could not calculate token cost: ${tokenError.message}`, { verbose: true });
-        }
+        if (verbose) await log(`  ⚠️  Could not calculate token cost: ${tokenError.message}`, { verbose: true });
       }
     }
     // Issue #1454: Use resultModelUsage from result JSON when it has more models (includes subagent models)
@@ -433,6 +423,11 @@ export async function attachLogToGitHub(options) {
     if (!actualModelIds && pricingInfo?.modelId) {
       actualModelIds = [pricingInfo.modelId];
     }
+    // Issue #1486: Filter out internal/synthetic model entries (e.g., "<synthetic>" from Claude CLI's inference router)
+    if (actualModelIds) {
+      actualModelIds = actualModelIds.filter(id => !(id.startsWith('<') && id.endsWith('>')));
+      if (actualModelIds.length === 0) actualModelIds = null;
+    }
     // Issue #1225: Fetch model information for comment using actual models from CLI output
     let modelInfoString = '';
     if (requestedModel || tool || actualModelIds) {

package/src/hive.config.lib.mjs

@@ -21,7 +21,7 @@ const HIVE_CUSTOM_SOLVE_OPTIONS = {
   model: {
     type: 'string',
     description: `${buildModelOptionDescription()}, or any model ID supported by the tool`,
-    alias: 'm',
+    alias: ['m', 'worker-model'],
     default: 'sonnet',
   },
   'dry-run': {

package/src/hive.mjs

@@ -152,9 +152,7 @@ if (isDirectExecution) {
         // Strategy 2: Fallback to gh api --paginate approach (comprehensive but slower)
         await log('   📋 Using gh api --paginate approach for comprehensive coverage...', { verbose: true });
 
-        // First, get list of ALL repositories using gh api with --paginate for unlimited pagination
-        // This approach uses the GitHub API directly to fetch all repositories without any limits
-        // Include isArchived field to filter out archived repositories
+        // Get list of ALL repositories using gh api with --paginate (includes isArchived for filtering)
         let repoListCmd;
         if (scope === 'organization') {
           repoListCmd = `gh api orgs/${owner}/repos --paginate --jq '.[] | {name: .name, owner: .owner.login, isArchived: .archived}'`;
@@ -436,8 +434,6 @@ if (isDirectExecution) {
     initializeExitHandler(getAbsoluteLogPath, log);
     installGlobalExitHandlers();
 
-    // Unhandled error handlers are now managed by exit-handler.lib.mjs
-
     // Validate GitHub URL requirement
     if (!githubUrl) {
       await log('❌ GitHub URL is required', { level: 'error' });
@@ -470,18 +466,28 @@ if (isDirectExecution) {
       }
     }
 
-    // Validate model name EARLY - this always runs regardless of --skip-tool-connection-check
-    // Model validation is a simple string check and should always be performed
+    // --plan flag expansion: shortcut for --plan-model opus --worker-model sonnet (Issue #1223)
+    if (argv.plan) {
+      if (!rawArgs.includes('--plan-model')) argv.planModel = 'opus';
+      if (!rawArgs.includes('--model') && !rawArgs.includes('-m') && !rawArgs.includes('--worker-model')) argv.model = 'sonnet';
+    }
+
+    // Validate model names EARLY (simple string check, always runs)
     const tool = argv.tool || 'claude';
     await validateAndExitOnInvalidModel(argv.model, tool, safeExit);
+    if (argv.planModel) {
+      if (tool !== 'claude') {
+        await log(`❌ --plan-model is only supported with --tool claude (current tool: ${tool})`, { level: 'error' });
+        await safeExit(1, '--plan-model requires --tool claude');
+      }
+      await validateAndExitOnInvalidModel(argv.planModel, tool, safeExit);
+    }
 
     // Handle -s (--skip-issues-with-prs) and --auto-continue interaction
-    // Detect if user explicitly passed --auto-continue or --no-auto-continue
     const hasExplicitAutoContinue = rawArgs.includes('--auto-continue');
     const hasExplicitNoAutoContinue = rawArgs.includes('--no-auto-continue');
 
     if (argv.skipIssuesWithPrs) {
-      // If user explicitly passed --auto-continue with -s, that's a conflict
       if (hasExplicitAutoContinue) {
         await log('❌ Conflicting options: --skip-issues-with-prs and --auto-continue cannot be used together', {
           level: 'error',
@@ -492,8 +498,7 @@ if (isDirectExecution) {
         await safeExit(1, 'Error occurred');
       }
 
-      // If user didn't explicitly set auto-continue, disable it when -s is used
-      // This is because -s means "skip issues with PRs" which conflicts with auto-continue
+      // -s implies disabling auto-continue unless explicitly set
       if (!hasExplicitNoAutoContinue) {
         argv.autoContinue = false;
       }
@@ -778,10 +783,8 @@ if (isDirectExecution) {
             }
             if (argv.skipToolConnectionCheck || argv.toolConnectionCheck === false) args.push('--skip-tool-connection-check');
             if (argv.dryRun) args.push('--dry-run');
-            if (argv.autoCleanup) args.push('--auto-cleanup'); // hive default differs from solve's auto-detect default
-
-            // Options already handled above or deprecated aliases (skip in generic loop)
-            const SKIP_AUTO_FORWARD = new Set(['model', 'base-branch', 'skip-tool-connection-check', 'tool-connection-check', 'skip-tool-check', 'skip-claude-check', 'tool-check', 'dry-run', 'auto-cleanup']);
+            if (argv.autoCleanup) args.push('--auto-cleanup');
+            const SKIP_AUTO_FORWARD = new Set(['model', 'worker-model', 'base-branch', 'skip-tool-connection-check', 'tool-connection-check', 'skip-tool-check', 'skip-claude-check', 'tool-check', 'dry-run', 'auto-cleanup']);
 
             for (const optionName of getSolvePassthroughOptionNames()) {
               if (SKIP_AUTO_FORWARD.has(optionName)) continue;
@@ -1431,8 +1434,7 @@ if (isDirectExecution) {
       await safeExit(0, 'Process completed');
     }
 
-    // Function to validate Claude CLI connection
-    // validateClaudeConnection is now imported from lib.mjs
+    // validateClaudeConnection is imported from lib.mjs
 
     // Handle graceful shutdown
     process.on('SIGINT', () => gracefulShutdown('interrupt'));
@@ -1484,8 +1486,7 @@ if (isDirectExecution) {
       await safeExit(1, 'Error occurred');
     }
   } catch (fatalError) {
-    // Handle any errors that occurred during initialization or execution
-    // This prevents silent failures when the script hangs or crashes
+    // Handle fatal errors during initialization or execution
     console.error('\n❌ Fatal error occurred during hive initialization or execution');
     console.error(`   ${fatalError.message || fatalError}`);
     if (fatalError.stack) {

package/src/models/index.mjs

@@ -30,6 +30,7 @@ export const claudeModels = {
   haiku: 'claude-haiku-4-5-20251001', // Haiku 4.5
   'haiku-3-5': 'claude-3-5-haiku-20241022', // Haiku 3.5
   'haiku-3': 'claude-3-haiku-20240307', // Haiku 3
+  opusplan: 'opusplan', // Special mode: Opus for planning, Sonnet for execution (Issue #1223)
   // Shorter version aliases (Issue #1221, Issue #1329 - PR comment feedback)
   'sonnet-4-6': 'claude-sonnet-4-6', // Sonnet 4.6 short alias (Issue #1329)
   'opus-4-6': 'claude-opus-4-6', // Opus 4.6 short alias
@@ -258,7 +259,7 @@ export const isModelCompatibleWithTool = (tool, model) => {
 
   switch (tool) {
     case 'claude':
-      return mappedModel.startsWith('claude-');
+      return mappedModel.startsWith('claude-') || mappedModel === 'opusplan';
     case 'agent':
       return mappedModel.includes('/') || Object.keys(agentModels).includes(model);
     case 'opencode':
@@ -293,7 +294,7 @@ export const getValidModelsForTool = tool => {
 // Primary (non-alias, non-deprecated) short names shown in CLI help descriptions
 // These are the recommended model names users should see in --model help text
 export const primaryModelNames = {
-  claude: ['opus', 'sonnet', 'haiku'],
+  claude: ['opus', 'sonnet', 'haiku', 'opusplan'],
   opencode: ['grok', 'gpt4o'],
   codex: ['gpt5', 'gpt5-codex', 'o3'],
   agent: ['minimax-m2.5-free', 'big-pickle', 'gpt-5-nano', 'glm-5-free', 'deepseek-r1-free'],

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

@@ -33,7 +33,7 @@ const { reportError } = sentryLib;
 
 // Import GitHub merge functions
 const githubMergeLib = await import('./github-merge.lib.mjs');
-const { checkPRMergeable, checkMergePermissions, mergePullRequest, waitForCI, checkForBillingLimitError, getRepoVisibility, BILLING_LIMIT_ERROR_PATTERN, getDetailedCIStatus, rerunWorkflowRun, getWorkflowRunsForSha, getActiveRepoWorkflows } = githubMergeLib;
+const { checkPRMergeable, checkMergePermissions, mergePullRequest, waitForCI, checkForBillingLimitError, getRepoVisibility, BILLING_LIMIT_ERROR_PATTERN, getDetailedCIStatus, rerunWorkflowRun, getWorkflowRunsForSha, getActiveRepoWorkflows, getCommitDate, checkPreviousPRCommitsHadCI, checkWorkflowsHavePRTriggers } = githubMergeLib;
 
 // Import GitHub functions for log attachment
 const githubLib = await import('./github.lib.mjs');
@@ -255,14 +255,86 @@ const getMergeBlockers = async (owner, repo, prNumber, verbose = false) => {
             details: workflowRuns.map(r => r.name),
           });
         } else {
-          // No workflow runs for this SHA — CI was definitively NOT triggered
-          // Issue #1442: This is the root cause of the infinite loop. Fork PRs needing
-          // maintainer approval, paths-ignore filtering, workflow conditions not matching,
-          // etc. all result in zero workflow runs. No need for timeout — exit immediately.
-          if (verbose) {
-            console.log(`[VERBOSE] /merge: PR #${prNumber} has no CI checks and no workflow runs for SHA ${ciStatus.sha.substring(0, 7)} — CI was not triggered (fork PR, paths-ignore, workflow conditions, etc.)`);
+          // No workflow runs for this SHA — but this could be a race condition!
+          // Issue #1480: GitHub Actions workflow runs take 30-120 seconds to appear in the
+          // API after a push. The previous fix (issue #1442) assumed 0 workflow runs meant
+          // "CI definitively NOT triggered", but this caused false positive "Ready to merge"
+          // when checked too soon after a push.
+          //
+          // Multi-layer defense (Issue #1480 enhanced):
+          // Layer 1: Grace period — check commit age
+          // Layer 2: Workflow file parsing — check .github/workflows for PR triggers
+          // Layer 3: Previous commit CI history — check if earlier PR commits had CI runs
+          const WORKFLOW_RUN_GRACE_PERIOD_SECONDS = 120; // 2 minutes — generous to cover slow GitHub API registration
+          const commitInfo = await getCommitDate(owner, repo, ciStatus.sha, verbose);
+
+          // Issue #1480: Parse workflow files for PR triggers (used in both grace period and post-grace checks)
+          const prTriggers = await checkWorkflowsHavePRTriggers(owner, repo, verbose);
+
+          // Issue #1480: If .github/workflows folder doesn't exist or has no workflow files,
+          // that's a definitive signal — no CI/CD will execute, skip grace period entirely
+          if (!prTriggers.hasWorkflowFiles) {
+            if (verbose) {
+              console.log(`[VERBOSE] /merge: PR #${prNumber} repo has no workflow files in .github/workflows/ — CI definitively not configured at file level`);
+            }
+            return { blockers, ciStatus, noCiConfigured: false, noCiTriggered: true };
+          }
+
+          if (commitInfo.ageSeconds !== null && commitInfo.ageSeconds < WORKFLOW_RUN_GRACE_PERIOD_SECONDS) {
+            // Commit is recent — workflow runs may not have appeared in the API yet
+            if (verbose) {
+              console.log(`[VERBOSE] /merge: PR #${prNumber} has no workflow runs for SHA ${ciStatus.sha.substring(0, 7)}, but commit is only ${commitInfo.ageSeconds}s old (grace period: ${WORKFLOW_RUN_GRACE_PERIOD_SECONDS}s) — treating as potential race condition`);
+            }
+
+            if (prTriggers.hasPRTriggers) {
+              // Workflows have PR/push triggers AND commit is recent — almost certainly a race condition
+              if (verbose) {
+                console.log(`[VERBOSE] /merge: Workflow files confirm PR/push triggers exist (${prTriggers.workflows.map(w => w.name).join(', ')}) — waiting for workflow runs to appear`);
+              }
+              blockers.push({
+                type: 'ci_pending',
+                message: `CI/CD workflow runs have not appeared yet — commit is ${commitInfo.ageSeconds}s old, waiting for GitHub to register workflow runs (grace period: ${WORKFLOW_RUN_GRACE_PERIOD_SECONDS}s)`,
+                details: prTriggers.workflows.map(w => w.name),
+              });
+            } else {
+              // No PR triggers found in workflow files — but commit is still recent, be safe and wait
+              if (verbose) {
+                console.log(`[VERBOSE] /merge: No PR/push triggers found in workflow files, but commit is only ${commitInfo.ageSeconds}s old — waiting to be safe`);
+              }
+              blockers.push({
+                type: 'ci_pending',
+                message: `CI/CD workflow runs have not appeared yet — commit is ${commitInfo.ageSeconds}s old, waiting for GitHub to register workflow runs (grace period: ${WORKFLOW_RUN_GRACE_PERIOD_SECONDS}s)`,
+                details: [],
+              });
+            }
+          } else {
+            // Commit is old enough (grace period elapsed) — but check additional signals before concluding
+            // Issue #1480: Layer 3 — Check if previous commits in this PR had CI runs.
+            // If earlier commits had CI, the HEAD commit should also have CI unless conditions changed.
+            const previousCI = await checkPreviousPRCommitsHadCI(owner, repo, prNumber, ciStatus.sha, verbose);
+
+            if (previousCI.hadPreviousCI && prTriggers.hasPRTriggers) {
+              // Previous commits had CI AND workflow files have PR triggers — something is wrong,
+              // this could be a GitHub API glitch or delayed registration beyond the grace period.
+              // Wait one more cycle to be safe.
+              if (verbose) {
+                console.log(`[VERBOSE] /merge: PR #${prNumber} previous commits had CI (${previousCI.previousCommitsWithCI}/${previousCI.totalPreviousCommits}) and workflows have PR triggers, but HEAD has no runs — waiting as safety measure`);
+              }
+              blockers.push({
+                type: 'ci_pending',
+                message: `CI/CD workflow runs missing for HEAD — previous PR commits had CI (${previousCI.previousCommitsWithCI} of ${previousCI.totalPreviousCommits}), workflows have PR triggers, possible API delay`,
+                details: prTriggers.workflows.map(w => w.name),
+              });
+            } else {
+              // CI was definitively NOT triggered
+              // Issue #1442: Fork PRs needing maintainer approval, paths-ignore filtering,
+              // workflow conditions not matching, etc. all result in zero workflow runs.
+              if (verbose) {
+                console.log(`[VERBOSE] /merge: PR #${prNumber} has no CI checks and no workflow runs for SHA ${ciStatus.sha.substring(0, 7)} (commit age: ${commitInfo.ageSeconds ?? 'unknown'}s, grace period: ${WORKFLOW_RUN_GRACE_PERIOD_SECONDS}s elapsed, previous CI: ${previousCI.hadPreviousCI}, PR triggers: ${prTriggers.hasPRTriggers}) — CI was not triggered`);
+              }
+              return { blockers, ciStatus, noCiConfigured: false, noCiTriggered: true };
+            }
           }
-          return { blockers, ciStatus, noCiConfigured: false, noCiTriggered: true };
         }
       } else {
         // Repo has NO workflows — this is truly "no CI configured"

package/src/solve.config.lib.mjs

@@ -284,6 +284,21 @@ export const SOLVE_OPTION_DEFINITIONS = {
     choices: ['claude', 'opencode', 'codex', 'agent'],
     default: 'claude',
   },
+  plan: {
+    type: 'boolean',
+    description: 'Enable plan mode: uses opus for planning, sonnet for execution (shortcut for --plan-model opus --worker-model sonnet). Only works with --tool claude.',
+    default: false,
+  },
+  'plan-model': {
+    type: 'string',
+    description: 'Model to use for plan mode (e.g., opus). When specified, auto-switches to opusplan mode and sets ANTHROPIC_DEFAULT_OPUS_MODEL. Use with --model/--worker-model to set separate plan and execution models (e.g., --plan-model opus --model sonnet). Only works with --tool claude.',
+    default: undefined,
+  },
+  'worker-model': {
+    type: 'string',
+    description: 'Alias for --model: Model to use for execution/worker mode when --plan-model is specified. When used with --plan-model, sets ANTHROPIC_DEFAULT_SONNET_MODEL for Claude Code opusplan mode.',
+    default: undefined,
+  },
   'execute-tool-with-bun': {
     type: 'boolean',
     description: 'Execute the AI tool using bunx (experimental, may improve speed and memory usage)',
@@ -441,7 +456,7 @@ export const createYargsConfig = yargsInstance => {
     .option('model', {
       type: 'string',
       description: buildModelOptionDescription(),
-      alias: 'm',
+      alias: ['m', 'worker-model'],
       default: currentParsedArgs => {
         // Dynamic default based on tool selection (Issue #1473: centralized in models/index.mjs)
         return defaultModels[currentParsedArgs?.tool] || defaultModels.claude;
@@ -549,7 +564,20 @@ export const parseArguments = async (yargs, hideBin) => {
   // Post-processing: Fix model default for opencode and codex tools
   // Yargs doesn't properly handle dynamic defaults based on other arguments,
   // so we need to handle this manually after parsing
-  const modelExplicitlyProvided = rawArgs.includes('--model') || rawArgs.includes('-m');
+  const modelExplicitlyProvided = rawArgs.includes('--model') || rawArgs.includes('-m') || rawArgs.includes('--worker-model');
+  const planModelExplicitlyProvided = rawArgs.includes('--plan-model');
+
+  // --plan flag expansion (Issue #1223)
+  // When --plan is set, it acts as a shortcut for --plan-model opus --worker-model sonnet
+  // Explicit --plan-model and --model/--worker-model values take precedence
+  if (argv && argv.plan) {
+    if (!planModelExplicitlyProvided) {
+      argv.planModel = 'opus';
+    }
+    if (!modelExplicitlyProvided) {
+      argv.model = 'sonnet';
+    }
+  }
 
   // Normalize alias flags: legacy --skip-tool-check and --skip-claude-check behave like --skip-tool-connection-check
   if (argv) {

package/src/solve.mjs

@@ -211,6 +211,15 @@ if (!(await validateContinueOnlyOnFeedback(argv, isPrUrl, isIssueUrl))) {
 const tool = argv.tool || 'claude';
 await validateAndExitOnInvalidModel(argv.model, tool, safeExit);
 
+// Validate --plan-model if provided (Issue #1223)
+if (argv.planModel) {
+  if (tool !== 'claude') {
+    await log(`❌ --plan-model is only supported with --tool claude (current tool: ${tool})`, { level: 'error' });
+    await safeExit(1, '--plan-model requires --tool claude');
+  }
+  await validateAndExitOnInvalidModel(argv.planModel, tool, safeExit);
+}
+
 // Perform all system checks (skip tool connection check in dry-run or when --skip-tool-connection-check; model validation always runs)
 const skipToolConnectionCheck = argv.dryRun || argv.skipToolConnectionCheck || argv.toolConnectionCheck === false;
 if (!(await performSystemChecks(argv.minDiskSpace || 2048, skipToolConnectionCheck, argv.model, argv))) {