@link-assistant/hive-mind 1.36.1 → 1.37.1

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @link-assistant/hive-mind
 
+## 1.37.1
+
+### Patch Changes
+
+- 8df5a3d: Treat ENOSPC as immediate failure at all stages (issues #1212, #1211)
+
+  When disk space runs out during any stage — including git clone, execution, and log
+  upload — ENOSPC is now treated as a hard failure (not partial success). Added ENOSPC
+  detection to git clone error classification so disk-full clone failures are not
+  retried. The isENOSPC utility now detects git-specific patterns like "unable to write
+  file" and "cannot create directory". Actionable disk cleanup guidance is provided.
+
+## 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

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.1",
+  "version": "1.37.1",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/claude.lib.mjs

@@ -6,7 +6,7 @@ if (typeof globalThis.use === 'undefined') {
 const { $ } = await use('command-stream');
 const fs = (await use('fs')).promises;
 const path = (await use('path')).default;
-import { log } from './lib.mjs';
+import { log, isENOSPC } from './lib.mjs';
 import { reportError } from './sentry.lib.mjs';
 import { timeouts, retryLimits, claudeCode, getClaudeEnv, getThinkingLevelToTokens, getTokensToThinkingLevel, supportsThinkingBudget, DEFAULT_MAX_THINKING_BUDGET, getMaxOutputTokensForModel } from './config.lib.mjs';
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.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]) {
@@ -808,12 +808,10 @@ export const executeClaudeCommand = async params => {
         await log('   Feedback info included: No', { verbose: true });
       }
     }
-    // Take resource snapshot before execution
     const resourcesBefore = await getResourceSnapshot();
     await log('📈 System resources before execution:', { verbose: true });
     await log(`   Memory: ${resourcesBefore.memory.split('\n')[1]}`, { verbose: true });
     await log(`   Load: ${resourcesBefore.load}`, { verbose: true });
-    // Use command-stream's async iteration for real-time streaming with file logging
     let commandFailed = false;
     let sessionId = null;
     let limitReached = false;
@@ -842,11 +840,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 +861,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));
@@ -1026,7 +1025,12 @@ export const executeClaudeCommand = async params => {
                   const subtype = data.subtype || 'unknown';
                   if (subtype === 'error_during_execution') {
                     errorDuringExecution = true;
-                    await log(`⚠️ Error during execution (subtype: ${subtype}) - work may be completed`, { verbose: true });
+                    if ((data.errors || []).some(e => isENOSPC(e))) {
+                      commandFailed = true;
+                      await log('❌ ENOSPC: No space left on device. Free disk space (check ~/.claude/debug).');
+                    } else {
+                      await log(`⚠️ Error during execution (subtype: ${subtype}) - work may be completed`, { verbose: true });
+                    }
                   } else {
                     commandFailed = true;
                     await log(`⚠️ Detected error from Claude CLI (subtype: ${subtype})`, { verbose: true });
@@ -1038,8 +1042,8 @@ export const executeClaudeCommand = async params => {
                   if (lastMessage.includes('Internal server error') && !lastMessage.includes('Overloaded')) {
                     isInternalServerError = true;
                   }
-                  // Issue #1353: Detect "Request timed out" — Claude CLI emits {type:"result",is_error:true,result:"Request timed out"} after exhausting retries
-                  if (lastMessage === 'Request timed out' || lastMessage.includes('Request timed out')) {
+                  // Issue #1353: Detect "Request timed out" from Claude CLI
+                  if (lastMessage.includes('Request timed out')) {
                     isRequestTimeout = true;
                     await log('⏱️ Detected request timeout from Claude CLI (will retry with --resume)', { verbose: true });
                   }
@@ -1262,7 +1266,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' });
           }
@@ -1277,8 +1280,7 @@ export const executeClaudeCommand = async params => {
           }
         }
       }
-      // Issue #1354: Detect silent failures (no messages + stderr errors, e.g. "kill EPERM" with exit 0).
-      // Skip if result event confirmed success (definitive proof regardless of messageCount).
+      // Issue #1354: Detect silent failures (no messages + stderr errors, skip if result confirmed success)
       if (!commandFailed && !resultSuccessReceived && stderrErrors.length > 0 && messageCount === 0 && toolUseCount === 0) {
         commandFailed = true;
         const errorsPreview = stderrErrors
@@ -1307,9 +1309,7 @@ export const executeClaudeCommand = async params => {
           resultSummary, // Issue #1263: Include result summary
         };
       }
-      // Issue #1088: If error_during_execution occurred but command didn't fail,
-      // log it as "Finished with errors" instead of pure success
-      // Issue #1351: Distinguish interrupted sessions (exit code 130) from normal completion
+      // Issue #1088/#1351: Log execution result status
       if (exitCode === 130) {
         await log('\n\n⚠️ Claude command interrupted (CTRL+C)');
       } else if (errorDuringExecution) {

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.lib.mjs

@@ -2,7 +2,7 @@
 // GitHub-related utility functions. Check if use is already defined (when imported from solve.mjs), if not, fetch it (when running standalone)
 if (typeof globalThis.use === 'undefined') globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
 const { $ } = await use('command-stream'); // Use command-stream for consistent $ behavior
-import { log, maskToken, cleanErrorMessage } from './lib.mjs';
+import { log, maskToken, cleanErrorMessage, isENOSPC } from './lib.mjs';
 import { reportError } from './sentry.lib.mjs';
 import { githubLimits, timeouts } from './config.lib.mjs';
 import { batchCheckPullRequestsForIssues as batchCheckPRs, batchCheckArchivedRepositories as batchCheckArchived } from './github.batch.lib.mjs';
@@ -162,16 +162,7 @@ export const checkGitHubPermissions = async () => {
     return true; // Continue despite permission check failure
   }
 };
-/**
- * Check if the current user has write (push) permissions to a specific repository
- * This helps fail early before wasting AI tokens when --fork option is not used
- * @param {string} owner - Repository owner
- * @param {string} repo - Repository name
- * @param {Object} options - Configuration options
- * @param {boolean} options.useFork - Whether --fork flag is enabled
- * @param {string} options.issueUrl - Original issue URL for error messages
- * @returns {Promise<boolean>} True if has write access OR fork mode is enabled, false otherwise
- */
+/** Check if user has write permissions to repo. Fails early if --fork not used. */
 export const checkRepositoryWritePermission = async (owner, repo, options = {}) => {
   const { useFork = false, issueUrl = '' } = options;
   // Skip check if fork mode is enabled - user will work in their own fork
@@ -379,6 +370,17 @@ export async function attachLogToGitHub(options) {
   const targetName = targetType === 'pr' ? 'Pull Request' : 'Issue';
   const ghCommand = targetType === 'pr' ? 'pr' : 'issue';
   try {
+    // Issue #1212: Check disk space before attempting log upload (100MB minimum)
+    try {
+      const { checkDiskSpace } = await import('./memory-check.mjs');
+      const diskCheck = await checkDiskSpace(100, { log: async () => {} });
+      if (!diskCheck.success) {
+        await log(`  ❌ Insufficient disk space for log upload (${diskCheck.availableMB}MB available, 100MB required). Free disk space and retry.`);
+        return false;
+      }
+    } catch {
+      /* disk check failure is non-fatal — continue to actual operation */
+    }
     // Check if log file exists and is not empty
     const logStats = await fs.stat(logFile);
     if (logStats.size === 0) {
@@ -390,9 +392,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 +401,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 +425,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) {
@@ -805,7 +802,9 @@ ${sessionNote}
       return await attachRegularComment(options, logComment);
     }
   } catch (uploadError) {
-    await log(`  ❌ Error uploading log file: ${uploadError.message}`);
+    // Issue #1212: ENOSPC-specific actionable guidance
+    const msg = isENOSPC(uploadError) ? 'ENOSPC: No space left on device during log upload. Free disk space and retry.' : `Error uploading log file: ${uploadError.message}`;
+    await log(`  ❌ ${msg}`);
     return false;
   }
 }

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

@@ -340,6 +340,28 @@ export const measureTime = async (fn, label = 'Operation') => {
   }
 };
 
+/**
+ * Check if an error is an ENOSPC (no space left on device) error
+ * Issue #1212: ENOSPC errors need specific handling because they cascade
+ * (once disk is full, all operations fail) and require user action (cleanup).
+ * @param {Error|string} error - Error object or message
+ * @returns {boolean} True if the error is an ENOSPC error
+ */
+export const isENOSPC = error => {
+  if (!error) return false;
+  const message = error?.message || (typeof error === 'string' ? error : '');
+  const lowerMessage = message.toLowerCase();
+  return (
+    error?.code === 'ENOSPC' ||
+    message.includes('ENOSPC') ||
+    lowerMessage.includes('no space left on device') ||
+    // Issue #1211: git clone ENOSPC patterns — "unable to write file" and
+    // "cannot create directory" occur when disk fills during checkout
+    (lowerMessage.includes('unable to write file') && lowerMessage.includes('error')) ||
+    (lowerMessage.includes('cannot create directory') && lowerMessage.includes('no space left'))
+  );
+};
+
 /**
  * Clean up error messages for better user experience
  * @param {Error|string} error - Error object or message
@@ -502,6 +524,7 @@ export default {
   retry,
   formatBytes,
   measureTime,
+  isENOSPC,
   cleanErrorMessage,
   formatAligned,
   displayFormattedError,

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

@@ -43,7 +43,7 @@ export const handleFailure = async options => {
 
   // If --attach-logs is enabled, try to attach failure logs
   if (shouldAttachLogs && getLogFile()) {
-    // Issue #1462: Upload logs to PR if available, otherwise fall back to the issue
+    // Issues #1212, #1462: Upload logs to PR if available, otherwise fall back to the issue
     const hasPR = global.createdPR && global.createdPR.number;
     const hasIssue = global.issueNumber;
     const targetType = hasPR ? 'pr' : hasIssue ? 'issue' : null;

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))) {
@@ -499,8 +508,7 @@ if (isPrUrl) {
   issueNumber = urlNumber;
   await log(`📝 Issue mode: Working with issue #${issueNumber}`);
 }
-// Issue #1462: Store issueNumber in global so error handlers can upload logs to the issue
-// as a fallback when PR creation fails and global.createdPR is not available
+// Issues #1212, #1462: Store issueNumber globally for error handlers (attach failure logs to issue when no PR exists)
 global.issueNumber = issueNumber;
 const workspaceInfo = argv.enableWorkspaces ? { owner, repo, issueNumber } : null;
 const { tempDir, workspaceTmpDir, needsClone } = await setupTempDirectory(argv, workspaceInfo);
@@ -952,10 +960,12 @@ try {
           if (logUploadSuccess) {
             await log('  ✅ Logs uploaded successfully');
           } else {
-            await log('  ⚠️  Failed to upload logs', { verbose: true });
+            // Issue #1212: Always show log upload failures (not just verbose)
+            await log('  ⚠️  Failed to upload logs');
           }
         } catch (uploadError) {
-          await log(`  ⚠️  Error uploading logs: ${uploadError.message}`, { verbose: true });
+          // Issue #1212: Always show log upload errors (not just verbose)
+          await log(`  ⚠️  Error uploading logs: ${uploadError.message}`);
         }
       } else if (prNumber) {
         // Fallback: Post simple failure comment if logs are not attached
@@ -1020,10 +1030,12 @@ try {
             if (logUploadSuccess) {
               await log('  ✅ Logs uploaded successfully');
             } else {
-              await log('  ⚠️  Failed to upload logs', { verbose: true });
+              // Issue #1212: Always show log upload failures (not just verbose)
+              await log('  ⚠️  Failed to upload logs');
             }
           } catch (uploadError) {
-            await log(`  ⚠️  Error uploading logs: ${uploadError.message}`, { verbose: true });
+            // Issue #1212: Always show log upload errors (not just verbose)
+            await log(`  ⚠️  Error uploading logs: ${uploadError.message}`);
           }
         } else {
           // Fallback: Post simple waiting comment if logs are not attached
@@ -1084,7 +1096,7 @@ try {
 
     // If --attach-logs is enabled, attach failure logs before exiting
     // Note: sessionId is not required - logs should be uploaded even if agent failed before establishing a session
-    // Issue #1462: Fall back to uploading logs to the issue if PR is not available
+    // Issues #1212, #1462: Fall back to uploading logs to the issue if PR is not available
     const hasPR = global.createdPR && global.createdPR.number;
     const hasIssue = global.issueNumber;
     const logTargetType = hasPR ? 'pr' : hasIssue ? 'issue' : null;
@@ -1124,10 +1136,12 @@ try {
         if (logUploadSuccess) {
           await log(`  ✅ Failure logs uploaded to ${logTargetLabel} successfully`);
         } else {
-          await log('  ⚠️  Failed to upload logs', { verbose: true });
+          // Issue #1212: Always show log upload failures (not just verbose)
+          await log('  ⚠️  Failed to upload failure logs');
         }
       } catch (uploadError) {
-        await log(`  ⚠️  Error uploading logs: ${uploadError.message}`, { verbose: true });
+        // Issue #1212: Always show log upload errors (not just verbose)
+        await log(`  ⚠️  Error uploading failure logs: ${uploadError.message}`);
       }
     }
 

package/src/solve.repository.lib.mjs

@@ -901,6 +901,11 @@ Thank you!`;
 export const classifyCloneError = errorOutput => {
   const output = errorOutput.toLowerCase();
 
+  // Issue #1211: ENOSPC (disk full) errors - NOT retryable, requires user action
+  if (lib.isENOSPC(errorOutput) || output.includes('no space left on device') || (output.includes('unable to write file') && output.includes('error')) || output.includes('errno -28')) {
+    return { type: 'ENOSPC', retryable: false, description: 'No space left on device' };
+  }
+
   // Transient server errors (5xx) - typically retryable
   if (output.includes('error: 500') || output.includes('internal server error') || output.includes('error: 502') || output.includes('error: 503') || output.includes('error: 504')) {
     return { type: 'TRANSIENT', retryable: true, description: 'GitHub server error' };
@@ -983,36 +988,34 @@ export const cloneRepository = async (repoToClone, tempDir, argv, owner, repo) =
         if (line.trim()) await log(`     ${line}`);
       }
       await log('');
-      await log('  💡 Common causes:');
-      await log("     • Repository doesn't exist or is private");
-      await log('     • No GitHub authentication');
-      await log('     • Network connectivity issues');
-      if (errorClassification.type === 'TRANSIENT') {
-        await log('     • GitHub server issues (temporary)');
-      }
-      if (errorClassification.type === 'RATE_LIMIT') {
-        await log('     • API rate limiting exceeded');
-      }
-      if (argv.fork) {
-        await log('     • Fork not ready yet (try again in a moment)');
-      }
-      await log('');
-      await log('  🔧 How to fix:');
-      await log('     1. Check authentication: gh auth status');
-      await log('     2. Login if needed: gh auth login');
-      await log(`     3. Verify access: gh repo view ${owner}/${repo}`);
-      if (argv.fork) {
-        await log(`     4. Check fork: gh repo view ${repoToClone}`);
-      }
-      if (errorClassification.type === 'TRANSIENT') {
-        await log('     5. Wait a few minutes and retry (GitHub server issue)');
-        await log('     6. Check GitHub status: https://www.githubstatus.com');
-      }
-      if (errorClassification.type === 'RATE_LIMIT') {
-        await log('     5. Wait for rate limit to reset (check your quota)');
-        await log('     6. Use --token flag with different token if available');
+
+      // Issue #1211: ENOSPC-specific guidance
+      if (errorClassification.type === 'ENOSPC') {
+        await log('  💡 Cause: Disk is full — not enough space to clone the repository');
+        await log('');
+        await log('  🔧 How to fix:');
+        await log('     1. Free disk space: sudo rm -rf /tmp/* /var/tmp/*');
+        await log('     2. Check disk usage: df -h');
+        await log('     3. Clean Docker/npm: docker system prune -af && npm cache clean --force');
+        await log('');
+      } else {
+        await log('  💡 Common causes:');
+        await log("     • Repository doesn't exist or is private");
+        await log('     • No GitHub authentication');
+        await log('     • Network connectivity issues');
+        if (errorClassification.type === 'TRANSIENT') await log('     • GitHub server issues (temporary)');
+        if (errorClassification.type === 'RATE_LIMIT') await log('     • API rate limiting exceeded');
+        if (argv.fork) await log('     • Fork not ready yet (try again in a moment)');
+        await log('');
+        await log('  🔧 How to fix:');
+        await log('     1. Check authentication: gh auth status');
+        await log('     2. Login if needed: gh auth login');
+        await log(`     3. Verify access: gh repo view ${owner}/${repo}`);
+        if (argv.fork) await log(`     4. Check fork: gh repo view ${repoToClone}`);
+        if (errorClassification.type === 'TRANSIENT') await log('     5. Wait and retry / check: https://www.githubstatus.com');
+        if (errorClassification.type === 'RATE_LIMIT') await log('     5. Wait for rate limit to reset or use --token with different token');
+        await log('');
       }
-      await log('');
       await safeExit(1, 'Repository setup failed');
     }
 

package/src/token-sanitization.lib.mjs

@@ -15,7 +15,7 @@
  */
 
 // Import shared utility from lib.mjs
-import { maskToken, log } from './lib.mjs';
+import { maskToken, log, isENOSPC } from './lib.mjs';
 import { reportError } from './sentry.lib.mjs';
 
 // Dynamic imports for runtime dependencies
@@ -537,11 +537,18 @@ export const sanitizeLogContent = async (logContent, options = {}) => {
       }
     }
   } catch (error) {
+    // Issue #1212: Detect ENOSPC specifically and log at non-verbose level
+    const isNoSpace = isENOSPC(error);
     reportError(error, {
       context: 'sanitize_log_content',
-      level: 'warning',
+      level: isNoSpace ? 'error' : 'warning',
     });
-    await log(`  ⚠️  Warning: Could not fully sanitize log content: ${error.message}`, { verbose: true });
+    if (isNoSpace) {
+      await log(`  ❌ ENOSPC: No space left on device during log sanitization. Skipping sanitization.`);
+      await log(`     Consider freeing disk space (e.g., rm -rf ~/.claude/debug/*.txt) and retrying.`);
+    } else {
+      await log(`  ⚠️  Warning: Could not fully sanitize log content: ${error.message}`, { verbose: true });
+    }
   }
 
   return sanitized;