@link-assistant/hive-mind 2.13.0 → 2.13.2

package/src/github.batch.lib.mjs

@@ -17,19 +17,27 @@ import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry, execGhWithRetry } from
 export { prClosesIssue };
 
 /**
- * Extract open pull requests that are linked to an issue with closing keywords.
+ * Extract pull requests that are linked to an issue with closing keywords.
  * Draft pull requests are still open in-progress solution drafts, so they must
  * count for /hive --skip-issues-with-prs.
+ *
+ * Issue #2160: reporting needs the opposite default from gating. `--skip-issues-with-prs` only
+ * cares about OPEN pull requests, but the end-of-run summary must also see the ones `--auto-merge`
+ * already merged, otherwise a merged solution draft is reported as "(no PR found)".
+ *
  * @param {Object} issueData - GraphQL issue node with timelineItems
  * @param {number} issueNum - Issue number to check
  * @param {Function} logger - Async logger, defaults to shared log helper
- * @returns {Promise<Array<Object>>} Linked open PRs that close the issue
+ * @param {Object} [options]
+ * @param {Array<string>} [options.includeStates=['OPEN']] - PR states to report
+ * @returns {Promise<Array<Object>>} Linked PRs (in the requested states) that close the issue
  */
-export async function extractLinkedPullRequestsForIssue(issueData, issueNum, logger = log) {
+export async function extractLinkedPullRequestsForIssue(issueData, issueNum, logger = log, { includeStates = ['OPEN'] } = {}) {
   const linkedPRs = [];
+  const wantedStates = new Set(includeStates);
 
   for (const item of issueData.timelineItems?.nodes || []) {
-    if (item?.source && item.source.state === 'OPEN') {
+    if (item?.source && wantedStates.has(item.source.state)) {
       // Check if PR actually closes this issue (has "fixes #N", "closes #N", or "resolves #N")
       const prBody = item.source.body || '';
       const prTitle = item.source.title || '';
@@ -58,9 +66,12 @@ export async function extractLinkedPullRequestsForIssue(issueData, issueNum, log
  * @param {string} owner - Repository owner
  * @param {string} repo - Repository name
  * @param {Array<number>} issueNumbers - Array of issue numbers to check
+ * @param {Object} [options]
+ * @param {Array<string>} [options.includeStates=['OPEN']] - PR states to report in `linkedPRs`
+ *   (issue #2160). `openPRCount` always counts only OPEN pull requests.
  * @returns {Promise<Object>} Object mapping issue numbers to their linked PRs
  */
-export async function batchCheckPullRequestsForIssues(owner, repo, issueNumbers) {
+export async function batchCheckPullRequestsForIssues(owner, repo, issueNumbers, { includeStates = ['OPEN'] } = {}) {
   try {
     if (!issueNumbers || issueNumbers.length === 0) {
       return {};
@@ -138,12 +149,14 @@ export async function batchCheckPullRequestsForIssues(owner, repo, issueNumbers)
             // Issue #1094: Only count PRs that explicitly fix/close/resolve this issue
             // This prevents false positives from PRs that only mention issues without solving them
             // Issue #1760: Draft PRs are still active solution drafts and must block duplicate work
-            const linkedPRs = await extractLinkedPullRequestsForIssue(issueData, issueNum);
+            const linkedPRs = await extractLinkedPullRequestsForIssue(issueData, issueNum, log, { includeStates });
 
             results[issueNum] = {
               title: issueData.title,
               state: issueData.state,
-              openPRCount: linkedPRs.length,
+              // Issue #2160: linkedPRs may now include merged/closed PRs for reporting, so the
+              // gate count has to be derived from the open ones only.
+              openPRCount: linkedPRs.filter(pr => pr.state === 'OPEN').length,
               linkedPRs: linkedPRs,
             };
           } else {
@@ -165,18 +178,25 @@ export async function batchCheckPullRequestsForIssues(owner, repo, issueNumbers)
 
         for (const issueNum of batch) {
           try {
-            const cmd = `gh api repos/${owner}/${repo}/issues/${issueNum}/timeline --paginate --jq '[.[] | select(.event == "cross-referenced" and .source.issue.pull_request != null and .source.issue.state == "open")] | length'`;
+            // Issue #2160: return the PRs themselves, not just a count, so the end-of-run summary
+            // can name a merged solution draft even when GraphQL was unavailable.
+            const cmd = `gh api repos/${owner}/${repo}/issues/${issueNum}/timeline --paginate --jq '[.[] | select(.event == "cross-referenced" and .source.issue.pull_request != null) | {number: .source.issue.number, title: .source.issue.title, body: .source.issue.body, state: (if .source.issue.pull_request.merged_at then "MERGED" else (.source.issue.state | ascii_upcase) end), isDraft: (.source.issue.draft // false), url: .source.issue.html_url}]'`;
 
             // #1756: route REST fallback through execGhWithRetry for transient 5xx + rate-limit
             const { stdout } = await execGhWithRetry(cmd, {
               execOptions: { encoding: 'utf8', env: process.env },
               label: `gh api timeline (issue #${issueNum})`,
             });
-            const openPrCount = parseInt(stdout.trim()) || 0;
+            const wantedStates = new Set(includeStates);
+            const crossReferenced = JSON.parse(stdout.trim() || '[]');
+            const linkedPRs = crossReferenced
+              .filter(pr => wantedStates.has(pr.state))
+              .filter(pr => prClosesIssue(pr.body || '', issueNum) || prClosesIssue(pr.title || '', issueNum))
+              .map(({ number, title, state, isDraft, url }) => ({ number, title, state, isDraft: Boolean(isDraft), url }));
 
             results[issueNum] = {
-              openPRCount: openPrCount,
-              linkedPRs: [], // REST API doesn't give us PR details easily
+              openPRCount: linkedPRs.filter(pr => pr.state === 'OPEN').length,
+              linkedPRs,
             };
           } catch (restError) {
             results[issueNum] = {

package/src/github.lib.mjs

@@ -579,7 +579,9 @@ ${logContent}
       if (useLargeFileMode) {
         await log(`  📁 Log file too large for inline comment (${Math.round(logStats.size / 1024 / 1024)}MB), using gh-upload-log`);
       } else {
-        await log(`  ⚠️  Log comment too long (${logComment.length} chars), GitHub limit is ${githubLimits.commentMaxSize} chars`);
+        // Issue #2160: this is the expected route for a long log, not a problem — the upload
+        // below handles it. Reporting it as a warning made every normal run look degraded.
+        await log(`  ℹ️  Log comment too long (${logComment.length} chars, GitHub limit is ${githubLimits.commentMaxSize} chars), using gh-upload-log`);
       }
       await log('  📎 Uploading log using gh-upload-log...');
       try {

package/src/hive.mjs

@@ -39,6 +39,8 @@ import { attachChildExitHandlers } from './child-exit.lib.mjs';
 import { SUBSCRIPTION_BLOCKED_MARKER } from './subscription-error.lib.mjs'; // Issue #2161
 import { isDirectExecution, withTimeout } from './hive.bootstrap.lib.mjs';
 import { createShutdownManager } from './hive.shutdown.lib.mjs';
+// Issue #2160: keep dequeuing safe when the host disk fills up mid-run.
+import { EXIT_CODE_INSUFFICIENT_DISK_SPACE, ensureDiskSpaceForWorker, extractSolverWorkspacePaths } from './disk-guard.lib.mjs';
 const isRunningDirectly = isDirectExecution(process.argv[1], import.meta.url);
 if (isRunningDirectly) {
   console.log('🐝 Hive Mind - AI-powered issue solver');
@@ -603,6 +605,7 @@ if (isRunningDirectly) {
         this.processing = new Set();
         this.completed = new Set();
         this.failed = new Set();
+        this.deferrals = new Map(); // Issue #2160: issueUrl -> environment deferral count
         this.workers = [];
         this.isRunning = true;
       }
@@ -633,6 +636,18 @@ if (isRunningDirectly) {
         this.processing.delete(issueUrl);
         this.failed.add(issueUrl);
       }
+      // Issue #2160: put an issue back at the head of the queue after an *environment* block (a
+      // full host disk). It is neither completed nor failed — the task was never attempted.
+      // Returns how many times this issue has been deferred so the caller can stop looping.
+      requeue(issueUrl) {
+        this.processing.delete(issueUrl);
+        const deferrals = (this.deferrals.get(issueUrl) || 0) + 1;
+        this.deferrals.set(issueUrl, deferrals);
+        if (!this.completed.has(issueUrl) && !this.queue.includes(issueUrl)) {
+          this.queue.unshift(issueUrl);
+        }
+        return deferrals;
+      }
       // Get queue statistics
       getStats() {
         return {
@@ -654,6 +669,16 @@ if (isRunningDirectly) {
     // controlled SIGTERM to each (they run in their own detached process group, so the
     // terminal's SIGINT never reaches them); a *second* interrupt force-kills the groups.
     const activeSolveChildren = new Set();
+    // Issue #2160: workspaces owned by in-flight workers, learned from the solver's own output.
+    // The disk guard must never reclaim these — they hold work in progress.
+    const workerWorkspaces = new Map(); // workerId -> Set<workspace path>
+    const getProtectedWorkspacePaths = () => new Set(Array.from(workerWorkspaces.values()).flatMap(paths => Array.from(paths)));
+    // How long a worker waits for in-flight work to release disk space before deferring its task,
+    // and how many deferrals of one task are tolerated before hive stops: with nothing else
+    // running, no amount of waiting will free space.
+    const DISK_SPACE_WAIT_MS = 10 * 60 * 1000;
+    const MAX_DISK_SPACE_DEFERRALS = 3;
+    let diskSpaceHalt = null;
     // Issue #2161: an account/subscription block is hive-wide, not per-issue. The
     // credentials every worker shares have been refused, so each remaining issue
     // would spin up a full solve run only to die the same way — burning clones,
@@ -690,8 +715,35 @@ if (isRunningDirectly) {
           await log(`   📊 Queue: ${stats.queued} waiting, ${stats.processing} processing, ${stats.completed} completed, ${stats.failed} failed`);
           continue;
         }
+        // Issue #2160: re-check free disk space before every task. hive used to check it once at
+        // startup, so a run whose kept workspaces filled the disk kept spawning solvers that died
+        // in their own pre-flight check — and each of those was counted as a *task* failure
+        // (`❌ 4 task(s) failed (completed: 6)`). Reclaim idle workspaces, wait for in-flight ones,
+        // and defer the task rather than burn it.
+        if (!argv.dryRun) {
+          const requiredDiskSpaceMB = argv.minDiskSpace || 10240;
+          const otherWorkInFlight = issueQueue.getStats().processing > 1;
+          const diskGuard = await ensureDiskSpaceForWorker({
+            requiredMB: requiredDiskSpaceMB,
+            protectedPaths: getProtectedWorkspacePaths(),
+            maxWaitMs: otherWorkInFlight ? DISK_SPACE_WAIT_MS : 0,
+            log,
+          });
+          if (!diskGuard.ok) {
+            const deferrals = issueQueue.requeue(issueUrl);
+            await log(`   ⏸️  Worker ${workerId} deferred ${issueUrl}: ${diskGuard.freeMB}MB free, ${requiredDiskSpaceMB}MB required (deferral ${deferrals}/${MAX_DISK_SPACE_DEFERRALS}, not a task failure)`, { level: 'warning' });
+            if (deferrals >= MAX_DISK_SPACE_DEFERRALS && issueQueue.getStats().processing === 0) {
+              diskSpaceHalt = `Insufficient disk space: ${diskGuard.freeMB}MB free, ${requiredDiskSpaceMB}MB required`;
+              await log('   🛑 Stopping: no in-flight work can release disk space. Free space on this host (or enable --auto-cleanup) and rerun.', { level: 'error' });
+              issueQueue.stop();
+            }
+            continue;
+          }
+        }
         // Track if this issue failed
         let issueFailed = false;
+        // Issue #2160: an environment block (full disk) reported by solve itself — requeue, don't fail.
+        let environmentDeferral = false;
         // Issue #1823: Track a graceful shutdown stop so it is neither failed nor completed.
         let gracefulStop = false;
         // Process the issue multiple times if needed
@@ -769,12 +821,17 @@ if (isRunningDirectly) {
               });
               // Issue #1823: register the in-flight child for optional force-kill on a 2nd signal
               activeSolveChildren.add(child);
+              // Issue #2160: start collecting the workspaces this worker owns so the disk guard
+              // (running in the other workers) never reclaims a directory that is still in use.
+              const ownedWorkspaces = new Set();
+              workerWorkspaces.set(workerId, ownedWorkspaces);
               log(`   🧒 Spawned ${solveCommand} worker-${workerId} (pid ${child.pid}, detached process group)`, { verbose: true }).catch(() => {});
               // Handle stdout data - stream output in real-time
               child.stdout.on('data', data => {
                 const lines = data.toString().split('\n');
                 for (const line of lines) {
                   if (line.trim()) {
+                    for (const workspacePath of extractSolverWorkspacePaths(line)) ownedWorkspaces.add(workspacePath);
                     // Issue #2161: solve prints SUBSCRIPTION_BLOCKED_MARKER on a terminal
                     // account block. Seen here, it stops the whole hive (see noteSubscriptionBlock).
                     if (line.includes(SUBSCRIPTION_BLOCKED_MARKER)) noteSubscriptionBlock(workerId, line);
@@ -819,6 +876,8 @@ if (isRunningDirectly) {
                 onLogError: (logError, operation) => reportError(logError, { context: 'worker_child_exit_log', workerId, operation }),
                 onExit: result => {
                   activeSolveChildren.delete(child); // Issue #1823: no longer in-flight
+                  // Issue #2160: the worker released its workspaces — they become reclaimable.
+                  workerWorkspaces.delete(workerId);
                   exitCode = result.exitCode;
                   resolve();
                 },
@@ -834,6 +893,12 @@ if (isRunningDirectly) {
               await log(`   🛑 Worker ${workerId} stopped gracefully during shutdown on ${issueUrl} (exit ${exitCode}, ${duration}s)`);
               gracefulStop = true;
               break; // stop processing more PRs for this issue
+            } else if (exitCode === EXIT_CODE_INSUFFICIENT_DISK_SPACE) {
+              // Issue #2160: solve refused to start because this host is out of disk space. The
+              // issue was never attempted, so it must not be counted as a task failure.
+              await log(`   ⏸️  Worker ${workerId} could not start ${issueUrl}: the host is out of disk space (exit ${exitCode}, ${duration}s) — requeued, not a task failure`, { level: 'warning' });
+              environmentDeferral = true;
+              break;
             } else if (subscriptionBlock) {
               // Issue #2161: the run did not fail because of this issue — the account
               // lost access mid-flight. Report the real reason and stop; solve has
@@ -867,7 +932,16 @@ if (isRunningDirectly) {
         // Only mark as completed if it didn't fail and wasn't gracefully stopped mid-shutdown.
         // Issue #1823: a graceful stop is neither a success nor a failure — leave it in
         // "processing" so it is not miscounted as completed (which would also trigger cleanup).
-        if (!issueFailed && !gracefulStop) {
+        if (environmentDeferral) {
+          // Issue #2160: back to the queue (neither completed nor failed). Stop the run when
+          // nothing else is in flight, since no other worker can release disk space.
+          const deferrals = issueQueue.requeue(issueUrl);
+          if (deferrals >= MAX_DISK_SPACE_DEFERRALS && issueQueue.getStats().processing === 0) {
+            diskSpaceHalt = 'Insufficient disk space reported by the solver pre-flight check';
+            await log('   🛑 Stopping: no in-flight work can release disk space. Free space on this host (or enable --auto-cleanup) and rerun.', { level: 'error' });
+            issueQueue.stop();
+          }
+        } else if (!issueFailed && !gracefulStop) {
           issueQueue.markCompleted(issueUrl);
         }
         // Show queue stats
@@ -1285,7 +1359,9 @@ if (isRunningDirectly) {
       // Perform cleanup if enabled and there were successful completions
       const finalStats = issueQueue.getStats();
       if (finalStats.completed > 0) {
-        await cleanupTempDirectories();
+        // Issue #2160: argv must be forwarded — cleanupTempDirectories returns immediately
+        // without it, so this branch used to be a silent no-op even with --auto-cleanup.
+        await cleanupTempDirectories(argv);
       }
       await log('\n👋 Hive Mind monitoring stopped');
       await log(`   📁 Full log file: ${absoluteLogPath}`);
@@ -1331,16 +1407,20 @@ if (isRunningDirectly) {
         verbose: true,
       });
     } else {
-      const systemCheck = await checkSystem(
-        {
-          minDiskSpaceMB: argv.minDiskSpace || 10240,
-          minMemoryMB: 256,
-          exitOnFailure: true,
-        },
-        { log }
-      );
+      // Issue #2160: reclaim idle solver workspaces left behind by earlier runs before refusing to
+      // start, and report an exhausted disk as the environment condition it is (exit 75) instead of
+      // a generic error. `exitOnFailure` is deliberately not used: it calls process.exit(1)
+      // directly, which skips the log-flushing safeExit path and printed no actionable reason.
+      const startupRequiredDiskSpaceMB = argv.minDiskSpace || 10240;
+      const startupDiskGuard = await ensureDiskSpaceForWorker({ requiredMB: startupRequiredDiskSpaceMB, log });
+      if (!startupDiskGuard.ok) {
+        await log(`❌ Insufficient disk space to start: ${startupDiskGuard.freeMB}MB available, ${startupRequiredDiskSpaceMB}MB required`, { level: 'error' });
+        await log('   Free space on this host, or run with --auto-cleanup so workspaces are removed after each task.', { level: 'error' });
+        await safeExit(EXIT_CODE_INSUFFICIENT_DISK_SPACE, `Insufficient disk space (${startupDiskGuard.freeMB}MB available, ${startupRequiredDiskSpaceMB}MB required)`);
+      }
+      const systemCheck = await checkSystem({ minDiskSpaceMB: startupRequiredDiskSpaceMB, minMemoryMB: 256 }, { log });
       if (!systemCheck.success) {
-        await safeExit(1, 'Error occurred');
+        await safeExit(1, 'System resource check failed');
       }
       // Validate the selected AI tool connection before starting monitoring with the same model that will be used
       const isToolConnected = await validateToolConnection({ tool: argv.tool, model: argv.model, verbose: argv.verbose, validateClaudeConnection });
@@ -1365,6 +1445,12 @@ if (isRunningDirectly) {
     }
     const finalStats = issueQueue.getStats(); // Issue #1718: surface worker failures via exit code
     if (finalStats.failed > 0) await safeExit(1, `${finalStats.failed} task(s) failed (completed: ${finalStats.completed})`);
+    // Issue #2160: report an exhausted host disk as the environment problem it is, with its own
+    // exit code, instead of letting it be counted as "N task(s) failed". Genuine task failures are
+    // reported first above, because they say more about the run than the environment condition.
+    if (diskSpaceHalt) {
+      await safeExit(EXIT_CODE_INSUFFICIENT_DISK_SPACE, `${diskSpaceHalt} — ${finalStats.completed} task(s) completed, ${finalStats.queued} left queued (no task failures)`);
+    }
   } catch (fatalError) {
     // Handle fatal errors during initialization or execution
     console.error('\n❌ Fatal error occurred during hive initialization or execution');

package/src/lib.mjs

@@ -950,9 +950,16 @@ export const displayFormattedError = async options => {
 };
 
 /**
- * Clean up temporary directories
+ * Clean up temporary directories.
+ *
+ * Issue #2160: this used to run `sudo rm -rf /tmp/* /var/tmp/*`, which also wipes the workspaces,
+ * lock directories and logs of any *concurrent* hive/solve process on the same host. The entries
+ * are now enumerated first and anything a live process is sitting in (or that the caller protects)
+ * is left alone.
+ *
  * @param {Object} argv - Command line arguments
  * @param {boolean} [argv.autoCleanup] - Whether auto-cleanup is enabled
+ * @param {Iterable<string>} [argv.protectedTempPaths] - Paths this run still needs
  * @returns {Promise<void>}
  */
 export const cleanupTempDirectories = async argv => {
@@ -962,13 +969,26 @@ export const cleanupTempDirectories = async argv => {
 
   // Dynamic import for command-stream
   const { $ } = await use('command-stream');
+  const { listCleanableTempEntries } = await import('./disk-guard.lib.mjs');
+  const path = await use('path');
 
   try {
     await log('\n🧹 Auto-cleanup enabled, removing temporary directories...');
-    await log('   ⚠️  Executing: sudo rm -rf /tmp/* /var/tmp/*', { verbose: true });
+    const protectedPaths = new Set(argv.protectedTempPaths || []);
+    const currentLogFile = getLogFile();
+    if (currentLogFile) protectedPaths.add(path.resolve(currentLogFile));
+    const { remove, keep } = await listCleanableTempEntries({ protectedPaths });
+    for (const kept of keep) {
+      await log(`   🔒 Keeping ${kept.path} (${kept.reason === 'process_cwd' ? 'a live process is using it' : 'needed by this run'})`, { verbose: true });
+    }
+    if (remove.length === 0) {
+      await log('   ✅ Nothing to clean: every temporary entry is still in use');
+      return;
+    }
+    await log(`   ⚠️  Executing: sudo rm -rf on ${remove.length} temporary entr${remove.length === 1 ? 'y' : 'ies'} (${keep.length} kept)`, { verbose: true });
 
     // Execute cleanup command using command-stream
-    const cleanupCommand = $`sudo rm -rf /tmp/* /var/tmp/*`;
+    const cleanupCommand = $`sudo rm -rf ${remove}`;
 
     let exitCode = 0;
     for await (const chunk of cleanupCommand.stream()) {

package/src/list-solution-drafts.lib.mjs

@@ -1,8 +1,15 @@
 /**
  * Solution Drafts Listing Module
  * Displays completed issues with their linked pull requests
+ *
+ * Issue #2160: this listing used to ask only for OPEN pull requests, so every issue whose draft
+ * `--auto-merge` had already merged was reported as "(no PR found)" — a false negative in the
+ * summary a human reads to judge the run. Merged and closed drafts are now listed with their state.
  */
 
+/** Pull request states worth reporting at the end of a run, in the order they are most useful. */
+const REPORTED_PULL_REQUEST_STATES = ['OPEN', 'MERGED', 'CLOSED'];
+
 /**
  * Lists all completed issues with their solution drafts (PRs)
  * @param {Object} issueQueue - The issue queue containing completed issues
@@ -10,10 +17,12 @@
  * @param {Function} batchCheckPullRequestsForIssues - Function to batch check PRs for issues
  */
 export async function listSolutionDrafts(issueQueue, log, batchCheckPullRequestsForIssues) {
-  if (!issueQueue.completed || issueQueue.completed.length === 0) return;
+  // `completed` is a Set in hive.mjs, but callers/tests may pass an array.
+  const completedUrls = issueQueue?.completed ? Array.from(issueQueue.completed) : [];
+  if (completedUrls.length === 0) return;
   await log('\n📋 Issues with solution drafts:');
   const byRepo = {};
-  for (const url of issueQueue.completed) {
+  for (const url of completedUrls) {
     const m = url.match(/github\.com\/([^/]+)\/([^/]+)\/issues\/(\d+)/);
     if (m) (byRepo[`${m[1]}/${m[2]}`] ||= { owner: m[1], repo: m[2], iss: [] }).iss.push({ n: +m[3], url });
   }
@@ -21,12 +30,16 @@ export async function listSolutionDrafts(issueQueue, log, batchCheckPullRequests
     const prs = await batchCheckPullRequestsForIssues(
       r.owner,
       r.repo,
-      r.iss.map(i => i.n)
+      r.iss.map(i => i.n),
+      { includeStates: REPORTED_PULL_REQUEST_STATES }
     );
     for (const i of r.iss)
       if (prs[i.n]?.linkedPRs?.length) {
         await log(`   - ${i.url}`);
-        for (const p of prs[i.n].linkedPRs) await log(`     → PR #${p.number}: ${p.url}`);
+        for (const p of prs[i.n].linkedPRs) {
+          const state = p.state && p.state !== 'OPEN' ? ` (${p.state.toLowerCase()})` : '';
+          await log(`     → PR #${p.number}${state}: ${p.url}`);
+        }
       } else await log(`   - ${i.url} (no PR found)`);
   }
 }

package/src/locales/en.lino

@@ -755,6 +755,7 @@ en
                - When you execute commands and the output becomes large, save the logs to files for easier review.
                - When running commands, avoid setting a timeout yourself. Let them run as long as needed. The default timeout of 2 minutes is usually enough, and once commands finish, review the logs in the file.
                - When running sudo commands, especially package installations like apt-get, yum, or npm install, run them in the background to avoid timeout issues and permission errors when the process needs to be killed. Use the run_in_background parameter or append & to the command.
+               - When you need to wait for something (CI checks, a background job, a deploy), do not run a long foreground `sleep`: agent harnesses block it ("Blocked: sleep 240 followed by: ..."). Poll instead with a short until-loop (e.g. `until <check>; do sleep 10; done`) or re-check the condition on your next step.
           """
         purpose
           subagent "   - When the task is large and requires processing many files or folders, use `general-purpose` sub-agents to delegate work. Each separate file or folder can be delegated to a sub-agent for more efficient processing."

package/src/locales/hi.lino

@@ -755,6 +755,7 @@ hi
                - जब आप कमांड चलाते हैं और आउटपुट बड़ा हो जाता है, तो आसान समीक्षा के लिए लॉग को फ़ाइलों में सहेजें।
                - जब आप कमांड चलाते हैं, तो स्वयं टाइमआउट सेट न करें। उन्हें जितना आवश्यक हो उतना चलने दें। डिफ़ॉल्ट 2 मिनट का टाइमआउट आमतौर पर पर्याप्त होता है, और कमांड समाप्त होने के बाद फ़ाइल में लॉग की समीक्षा करें।
                - जब आप sudo कमांड चलाते हैं, विशेष रूप से apt-get, yum, या npm install जैसी पैकेज स्थापना, तो टाइमआउट और प्रोसेस को मारने पर अनुमति त्रुटियों से बचने के लिए उन्हें पृष्ठभूमि में चलाएँ। run_in_background पैरामीटर का उपयोग करें या कमांड के अंत में & जोड़ें।
+               - जब आपको किसी चीज़ की प्रतीक्षा करनी हो (CI जाँच, पृष्ठभूमि कार्य, डिप्लॉय), तो लंबा `sleep` अग्रभूमि में न चलाएँ: एजेंट हार्नेस उसे रोक देते हैं ("Blocked: sleep 240 followed by: ...")। इसके बजाय छोटे अंतराल वाले until लूप से पोलिंग करें (उदाहरण: `until <जाँच>; do sleep 10; done`) या अगले चरण में स्थिति फिर से जाँचें।
           """
         purpose
           subagent "   - जब कार्य बड़ा हो और कई फ़ाइलों या फ़ोल्डरों के प्रसंस्करण की आवश्यकता हो, तो कार्य सौंपने के लिए `general-purpose` sub-agents का उपयोग करें। प्रत्येक अलग फ़ाइल या फ़ोल्डर को अधिक कुशल प्रसंस्करण के लिए एक sub-agent को सौंपा जा सकता है।"

package/src/locales/ru.lino

@@ -755,6 +755,7 @@ ru
                - Когда выполняешь команды и вывод становится большим, сохраняй логи в файлы для удобного просмотра.
                - Когда запускаешь команды, не задавай таймаут самостоятельно. Дай им работать столько, сколько нужно. Стандартного таймаута в 2 минуты обычно достаточно, и после завершения команды просмотри логи в файле.
                - Когда запускаешь команды sudo, особенно установку пакетов вроде apt-get, yum или npm install, запускай их в фоне, чтобы избежать таймаутов и ошибок прав доступа при необходимости остановить процесс. Используй параметр run_in_background или добавляй & в конце команды.
+               - Когда нужно чего-то дождаться (проверок CI, фоновой задачи, деплоя), не запускай длинный `sleep` в основном потоке: агентные окружения блокируют его ("Blocked: sleep 240 followed by: ..."). Вместо этого опрашивай состояние коротким циклом until (например, `until <проверка>; do sleep 10; done`) или проверяй условие заново на следующем шаге.
           """
         purpose
           subagent "   - Когда задача большая и требует обработки многих файлов или папок, используй `general-purpose` суб-агентов, чтобы делегировать работу. Каждый отдельный файл или папка может быть делегирован суб-агенту для более эффективной обработки."

package/src/locales/zh.lino

@@ -755,6 +755,7 @@ zh
                - 当你执行的命令输出变得很大时，将日志保存到文件以便复查。
                - 当你运行命令时，不要自行设置超时。让它们按需运行。默认 2 分钟超时通常足够，命令完成后再查看文件中的日志。
                - 当你运行 sudo 命令（尤其是 apt-get、yum 或 npm install 等包安装）时，请在后台运行以避免超时和需要终止进程时的权限错误。使用 run_in_background 参数或在命令末尾追加 &。
+               - 当你需要等待某件事（CI 检查、后台任务、部署）时，不要在前台运行长时间的 `sleep`：智能体运行环境会拦截它（"Blocked: sleep 240 followed by: ..."）。请改用短间隔的 until 轮询循环（例如 `until <检查>; do sleep 10; done`），或在下一步重新检查条件。
           """
         purpose
           subagent "   - 当任务很大且需要处理许多文件或文件夹时，使用 `general-purpose` 子代理来委派工作。每个单独的文件或文件夹都可以委派给一个子代理以更高效地处理。"

package/src/session-log-rename.lib.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+/**
+ * Session log renaming (Issue #2160)
+ *
+ * When an AI tool reports its session id, the run log is renamed to `<sessionId>.log` so that
+ * the log file can be correlated with the tool session. The logic used to live inline in
+ * src/claude.lib.mjs and depended on `getLogFile`/`setLogFile` being forwarded through every
+ * caller. Restart/watch iterations (src/solve.restart-shared.lib.mjs) either omitted those
+ * parameters or passed no-op stubs, which produced this on every restart iteration:
+ *
+ *   ⚠️ Could not rename log file: getLogFile is not a function
+ *
+ * Extracting the logic makes the failure mode explicit (a named reason instead of a TypeError)
+ * and testable.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/2160
+ */
+
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Rename the current log file to `<sessionId>.log`.
+ *
+ * Never throws: every failure is returned as `{ ok: false, reason }` so callers can log it.
+ *
+ * @param {Object} params
+ * @param {string} params.sessionId - Session id reported by the AI tool
+ * @param {Function} params.getLogFile - Accessor returning the current log file path
+ * @param {Function} params.setLogFile - Accessor updating the current log file path
+ * @param {Function} [params.log] - Async logger
+ * @param {Object} [params.fileSystem] - Injectable fs.promises replacement (tests)
+ * @returns {Promise<{ok: boolean, reason?: string, error?: Error, sessionLogFile?: string}>}
+ */
+export const renameLogToSessionId = async ({ sessionId, getLogFile, setLogFile, log, fileSystem = fs }) => {
+  if (!sessionId) return { ok: false, reason: 'missing_session_id' };
+  if (typeof getLogFile !== 'function' || typeof setLogFile !== 'function') {
+    // Issue #2160: a caller that forgot to forward the accessors. Report it as a real defect
+    // instead of surfacing "getLogFile is not a function" as a mysterious warning.
+    if (log) await log('⚠️ Could not rename log file: log file accessors were not provided by the caller', { verbose: true });
+    return { ok: false, reason: 'missing_log_file_accessors' };
+  }
+
+  const currentLogFile = getLogFile();
+  if (!currentLogFile) {
+    if (log) await log('⚠️ Could not rename log file: no current log file is configured', { verbose: true });
+    return { ok: false, reason: 'no_current_log_file' };
+  }
+
+  const sessionLogFile = path.join(path.dirname(currentLogFile), `${sessionId}.log`);
+  if (sessionLogFile === currentLogFile) return { ok: true, reason: 'already_named', sessionLogFile };
+
+  try {
+    await fileSystem.rename(currentLogFile, sessionLogFile);
+    setLogFile(sessionLogFile);
+    if (log) await log(`📁 Log renamed to: ${sessionLogFile}`);
+    return { ok: true, sessionLogFile };
+  } catch (error) {
+    if (log) await log(`⚠️ Could not rename log file: ${error.message}`, { verbose: true });
+    return { ok: false, reason: 'rename_failed', error, sessionLogFile };
+  }
+};
+
+export default { renameLogToSessionId };

package/src/session-monitor.lib.mjs

@@ -23,6 +23,7 @@ import fs from 'fs/promises';
 import { promisify } from 'util';
 import { formatSessionCompletionMessage, getSessionCompletionExitCode, classifySessionOutcome } from './work-session-formatting.lib.mjs';
 import { notifySubscribers, getSubscriberCount } from './telegram-subscribers.lib.mjs';
+import { safeSendMessage, safeEditMessageText } from './telegram-safe-reply.lib.mjs';
 import { classifyExitStatus, normalizeExitCode } from './session-status.lib.mjs';
 import { readLastSessionIdFromLog, buildResumeCommand, formatResumeSection } from './session-resume.lib.mjs';
 import { resolveFailedSessionPullRequestState } from './github-pr-state.lib.mjs';
@@ -942,11 +943,11 @@ export async function monitorSessions(bot, verbose = false, options = {}) {
         let notifyFromChatId = null;
         let notifyMessageId = null;
         if (sessionInfo.messageId) {
-          await bot.telegram.editMessageText(sessionInfo.chatId, sessionInfo.messageId, undefined, message, { parse_mode: 'Markdown' });
+          await safeEditMessageText(bot.telegram, sessionInfo.chatId, sessionInfo.messageId, undefined, message, { verbose });
           notifyFromChatId = sessionInfo.chatId;
           notifyMessageId = sessionInfo.messageId;
         } else {
-          const sent = await bot.telegram.sendMessage(sessionInfo.chatId, message, { parse_mode: 'Markdown' });
+          const sent = await safeSendMessage(bot.telegram, sessionInfo.chatId, message, { verbose });
           notifyFromChatId = sent?.chat?.id || sessionInfo.chatId;
           notifyMessageId = sent?.message_id || null;
         }

package/src/solve.mjs

@@ -223,6 +223,15 @@ const skipToolConnectionCheck = prepareOnly || argv.skipToolConnectionCheck || a
 const { cascadePlaywrightMcpDisable, ensureSolvePlaywrightMcpReady } = await import('./playwright-mcp.lib.mjs');
 await cascadePlaywrightMcpDisable(argv, log);
 if (!(await performSystemChecks(argv.minDiskSpace || 10240, skipToolConnectionCheck, argv.model, argv))) {
+  // Issue #2160: an exhausted host disk is an environment condition, not a defect in the issue.
+  // Exit with EX_TEMPFAIL (75) so an orchestrator can requeue the task, and skip the pre-exit
+  // notifier: posting "🚨 Solution Draft Failed — Reason: System checks failed" on the target
+  // repository's issue told its maintainers nothing they could act on.
+  if (argv.systemCheckFailure?.check === 'disk-space') {
+    const { EXIT_CODE_INSUFFICIENT_DISK_SPACE } = await import('./disk-guard.lib.mjs');
+    const { availableMB, requiredMB } = argv.systemCheckFailure;
+    await safeExit(EXIT_CODE_INSUFFICIENT_DISK_SPACE, `Insufficient disk space on this host (${availableMB}MB available, ${requiredMB}MB required) — the issue itself was not attempted`, { skipPreExit: true });
+  }
   await safeExit(1, 'System checks failed');
 }
 // Playwright MCP preflight is local/free and stays independent from paid tool connection checks.
@@ -271,6 +280,9 @@ const { isPublic: isRepoPublic } = await detectRepositoryVisibility(owner, repo)
 if (argv.autoCleanup === undefined) {
   // For public repos: keep temp directories (default false) For private repos: clean up temp directories (default true)
   argv.autoCleanup = !isRepoPublic;
+  // Issue #2160: remember that this was a default, not a flag, so the "keeping directory"
+  // message at the end of the session can say why the workspace is being kept.
+  argv.autoCleanupSource = 'repository-visibility-default';
   if (argv.verbose) {
     await log(`   Auto-cleanup default: ${argv.autoCleanup} (repository is ${isRepoPublic ? 'public' : 'private'})`, {
       verbose: true,

package/src/solve.repository.lib.mjs

@@ -1338,6 +1338,10 @@ export const cleanupTempDirectory = async (tempDir, argv, limitReached) => {
   } else if (limitReached) {
     await log(`\n📁 Keeping directory for future resume: ${tempDir}`);
   } else if (!argv.autoCleanup) {
-    await log(`\n📁 Keeping directory (--no-auto-cleanup): ${tempDir}`);
+    // Issue #2160: `--no-auto-cleanup` is only one of the two ways to get here. On a public
+    // repository auto-cleanup defaults to off, and reporting a flag that was never passed made
+    // the run log misleading — the disk kept filling with no hint of why.
+    const reason = argv.autoCleanupSource === 'repository-visibility-default' ? 'auto-cleanup is off by default for public repositories' : '--no-auto-cleanup';
+    await log(`\n📁 Keeping directory (${reason}): ${tempDir}`);
   }
 };