@link-assistant/hive-mind 1.37.0 → 1.37.2

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @link-assistant/hive-mind
 
+## 1.37.2
+
+### Patch Changes
+
+- f07ae29: fix false positive "Ready to merge" by cross-validating CI success status with GitHub Actions workflow runs API and removing unreliable commit-age-based grace period (Issue #1480)
+
+## 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.37.0",
+  "version": "1.37.2",
   "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';
@@ -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;
@@ -1027,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 });
@@ -1039,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 });
                   }
@@ -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/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) {
@@ -800,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/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/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, getCommitDate, checkPreviousPRCommitsHadCI, checkWorkflowsHavePRTriggers } = githubMergeLib;
+const { checkPRMergeable, checkMergePermissions, mergePullRequest, waitForCI, checkForBillingLimitError, getRepoVisibility, BILLING_LIMIT_ERROR_PATTERN, getDetailedCIStatus, rerunWorkflowRun, getWorkflowRunsForSha, getActiveRepoWorkflows, getCommitDate, checkWorkflowsHavePRTriggers } = githubMergeLib;
 
 // Import GitHub functions for log attachment
 const githubLib = await import('./github.lib.mjs');
@@ -187,7 +187,7 @@ const checkForNonBotComments = async (owner, repo, prNumber, issueNumber, lastCh
  * - billing_limit: Billing/spending limit reached → stop (private) or wait (public)
  * - no_checks: No CI checks yet (race condition) → wait
  */
-const getMergeBlockers = async (owner, repo, prNumber, verbose = false) => {
+const getMergeBlockers = async (owner, repo, prNumber, verbose = false, checkCount = 1) => {
   const blockers = [];
 
   // Use detailed CI status to distinguish between all possible states
@@ -280,60 +280,54 @@ const getMergeBlockers = async (owner, repo, prNumber, verbose = false) => {
             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 (prTriggers.hasPRTriggers) {
+            // Issue #1480 (enhanced): Workflows have PR/push triggers but no runs yet.
+            // This is almost certainly a race condition — GitHub takes 30-120s to register
+            // workflow runs after a push. We MUST wait regardless of commit age, because
+            // commit date reflects authoring time, NOT push time.
+            //
+            // The commit may have been authored hours ago but pushed just now (rebased branches,
+            // amended commits, cherry-picks). Using commit age as a proxy for push age caused
+            // false positives in Case 1 of Issue #1480.
+            //
+            // Safety valve: after MAX_NO_RUNS_CHECKS consecutive checks (typically 5 × 60s = 5 min),
+            // conclude CI was not triggered. This handles cases like paths-ignore excluding all
+            // changed files, conditional workflows that don't match, etc.
+            const MAX_NO_RUNS_CHECKS = 5;
+            if (checkCount >= MAX_NO_RUNS_CHECKS) {
+              // We've waited long enough — CI was genuinely not triggered
               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`);
+                console.log(`[VERBOSE] /merge: PR #${prNumber} has no workflow runs after ${checkCount} consecutive checks — concluding CI was not triggered despite PR triggers existing`);
               }
-              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: [],
-              });
+              return { blockers, ciStatus, noCiConfigured: false, noCiTriggered: true };
+            }
+
+            if (verbose) {
+              console.log(`[VERBOSE] /merge: PR #${prNumber} has no workflow runs for SHA ${ciStatus.sha.substring(0, 7)}, but workflows have PR/push triggers (${prTriggers.workflows.map(w => w.name).join(', ')}) — waiting for workflow runs to appear (check ${checkCount}/${MAX_NO_RUNS_CHECKS}, commit age: ${commitInfo.ageSeconds ?? 'unknown'}s)`);
+            }
+            blockers.push({
+              type: 'ci_pending',
+              message: `CI/CD workflow runs have not appeared yet — workflows have PR/push triggers (${prTriggers.workflows.map(w => w.name).join(', ')}), waiting for GitHub to register workflow runs (check ${checkCount}/${MAX_NO_RUNS_CHECKS})`,
+              details: prTriggers.workflows.map(w => w.name),
+            });
+          } else if (commitInfo.ageSeconds !== null && commitInfo.ageSeconds < WORKFLOW_RUN_GRACE_PERIOD_SECONDS) {
+            // 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 };
+            // No PR triggers AND commit is old enough — 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, no PR/push triggers in workflow files) — CI was not triggered`);
             }
+            return { blockers, ciStatus, noCiConfigured: false, noCiTriggered: true };
           }
         }
       } else {
@@ -355,6 +349,60 @@ const getMergeBlockers = async (owner, repo, prNumber, verbose = false) => {
         details: [],
       });
     }
+  } else if (ciStatus.status === 'success') {
+    // Issue #1480: Cross-validate "success" with workflow runs API.
+    // A fast external check (e.g., CodeFactor) can register and pass before the main CI
+    // pipeline starts, causing getDetailedCIStatus to return 'success' prematurely.
+    // We must verify that all expected workflow runs have actually completed.
+    const workflowRuns = await getWorkflowRunsForSha(owner, repo, ciStatus.sha, verbose);
+
+    if (workflowRuns.length > 0) {
+      // Workflow runs exist — check if any are still running
+      const incompleteRuns = workflowRuns.filter(r => r.status !== 'completed');
+      if (incompleteRuns.length > 0) {
+        // Some workflow runs are still in progress — more check-runs may appear
+        if (verbose) {
+          console.log(`[VERBOSE] /merge: PR #${prNumber} CI status is 'success' (${ciStatus.passedChecks.length} checks passed), but ${incompleteRuns.length} workflow run(s) still in progress — waiting for completion`);
+        }
+        blockers.push({
+          type: 'ci_pending',
+          message: `CI checks show success (${ciStatus.passedChecks.length} passed) but ${incompleteRuns.length} workflow run(s) still in progress — waiting for all to complete`,
+          details: incompleteRuns.map(r => r.name),
+        });
+      }
+      // All workflow runs completed — the check-runs we see are the final set, trust the 'success' status
+    } else {
+      // No workflow runs for this SHA — the passed checks are from external services only
+      // (e.g., CodeFactor, Codecov). Check if the repo has workflows that should produce runs.
+      const repoWorkflows = await getActiveRepoWorkflows(owner, repo, verbose);
+      if (repoWorkflows.hasWorkflows) {
+        const prTriggers = await checkWorkflowsHavePRTriggers(owner, repo, verbose);
+        if (prTriggers.hasPRTriggers) {
+          // Repo has workflows with PR triggers but no runs yet — CI hasn't started
+          // This is the exact scenario from Case 2 of Issue #1480
+          //
+          // Safety valve: after MAX_NO_RUNS_CHECKS consecutive checks, trust the external checks
+          const MAX_NO_RUNS_CHECKS = 5;
+          if (checkCount >= MAX_NO_RUNS_CHECKS) {
+            if (verbose) {
+              console.log(`[VERBOSE] /merge: PR #${prNumber} CI 'success' with ${ciStatus.passedChecks.length} external checks, no workflow runs after ${checkCount} checks — trusting external checks`);
+            }
+            // Fall through — trust the success status from external checks
+          } else {
+            if (verbose) {
+              console.log(`[VERBOSE] /merge: PR #${prNumber} CI status is 'success' (${ciStatus.passedChecks.length} external checks), but repo has PR-triggered workflows with 0 workflow runs — likely race condition (check ${checkCount}/${MAX_NO_RUNS_CHECKS})`);
+            }
+            // Wait for GitHub Actions to register workflow runs
+            blockers.push({
+              type: 'ci_pending',
+              message: `CI shows ${ciStatus.passedChecks.length} passed check(s) from external services, but repo has PR-triggered workflows that haven't started yet — waiting for GitHub Actions to register (check ${checkCount}/${MAX_NO_RUNS_CHECKS})`,
+              details: prTriggers.workflows.map(w => w.name),
+            });
+          }
+        }
+      }
+      // No repo workflows → external checks are the only CI, trust the 'success' status
+    }
   } else if (ciStatus.status === 'pending') {
     // CI is still running or queued - wait for completion
     const pendingNames = [...ciStatus.pendingChecks, ...ciStatus.queuedChecks].map(c => c.name);
@@ -507,7 +555,7 @@ export const watchUntilMergeable = async params => {
 
     try {
       // Get merge blockers
-      const { blockers, noCiConfigured, noCiTriggered, workflowRunConclusions } = await getMergeBlockers(owner, repo, prNumber, argv.verbose);
+      const { blockers, noCiConfigured, noCiTriggered, workflowRunConclusions } = await getMergeBlockers(owner, repo, prNumber, argv.verbose, iteration);
 
       // Check for new comments from non-bot users
       const { hasNewComments, comments } = await checkForNonBotComments(owner, repo, prNumber, issueNumber, lastCheckTime, argv.verbose);

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

@@ -508,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);
@@ -961,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
@@ -1029,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
@@ -1093,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;
@@ -1133,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;