@link-assistant/hive-mind 2.13.0 → 2.13.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/hive-mind
 
+## 2.13.1
+
+### Patch Changes
+
+- 736f6f9: Stop reporting a host that ran out of disk space as failed tasks: `/hive` now checks free space before each task, requeues the task as a deferral while peers are still running, reclaims only temp directories that no process is using, and exits with `EX_TEMPFAIL` (75) when work remains blocked. Also fix the false alarms around it — `getLogFile is not a function` in the restart paths, the bogus `.gitkeep` cleanup warning, benign in-session tool results and defaulted source cleanup being reported as problems, merged solution drafts being summarized as `(no PR found)`, and `--auto-cleanup` being a no-op at one call site.
+
 ## 2.13.0
 
 ### Minor Changes

package/package.json

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

package/src/claude.budget-stats.lib.mjs

@@ -356,9 +356,11 @@ export const displaySessionTokenUsage = async ({ sessionId, tempDir, resultModel
   try {
     const tokenUsage = await calculateSessionTokens(sessionId, tempDir, resultModelUsage);
     if (!tokenUsage) return;
-    // Issue #1501: Log deduplication stats in verbose mode
+    // Issue #1501: Log deduplication stats in verbose mode.
+    // Issue #2160: informational, not a warning — the duplicates are a known upstream Claude Code
+    // accounting quirk and skipping them is exactly what keeps the token totals correct here.
     if (tokenUsage.duplicateEntriesSkipped > 0) {
-      await log(`\n⚠️  JSONL deduplication: skipped ${tokenUsage.duplicateEntriesSkipped} duplicate entries (upstream: anthropics/claude-code#6805)`, { verbose: true });
+      await log(`\nℹ️  JSONL deduplication: skipped ${tokenUsage.duplicateEntriesSkipped} duplicate entries so token totals stay correct (known upstream behaviour: anthropics/claude-code#87303)`, { verbose: true });
     }
     if (tokenUsage.peakContextUsage > 0) {
       await log(`📊 Peak restored-context input: ${formatNumber(tokenUsage.peakContextUsage)} tokens`, { verbose: true });

package/src/claude.lib.mjs

@@ -35,6 +35,7 @@ import { deployHandoffSkill } from './handoff-skill.lib.mjs'; // Issue #1877
 import { createThinkingBlockRecovery } from './claude.thinking-block-recovery.lib.mjs'; // Issue #1834 (PR #1835 feedback)
 import { buildMissingClaudeResultMessage, collectClaudeStreamEventFacts, getClaudeMessageContent, shouldFailClaudeStreamWithoutResult } from './claude.stream-events.lib.mjs';
 import { formatNumber, mapModelToId, checkModelVisionCapability } from './claude.model-utils.lib.mjs';
+import { renameLogToSessionId } from './session-log-rename.lib.mjs'; // Issue #2160
 import { showResumeCommand } from './claude.resume-output.lib.mjs';
 import { stringifyErrorValue } from './error-text.lib.mjs'; // Issue #2141
 import { createPullRequestBaseBranchCommandIntervention } from './solve.pr-base-command-intervention.lib.mjs';
@@ -393,6 +394,11 @@ export const executeClaudeCommand = async params => {
     let resultSummary = null;
     let resultModelUsage = null;
     let lastToolResultError = null;
+    // Issue #2160: an in-session tool failure the AI handles itself (a blocked command, its own
+    // Bash timeout, a bare non-zero exit status). Kept apart from lastToolResultError so it is not
+    // reported as the session error, but still available as the last-resort detail for a
+    // truncated stream that has nothing better to point at (issue #2023).
+    let lastBenignToolResultError = null;
     // Issue #1590: Track sub-agent calls (Agent tool invocations) for per-call stats
     const subAgentCalls = [];
     // Issue #1590: Map tool_use_id -> subAgentCalls index for accumulating per-call usage from parent_tool_use_id events
@@ -633,16 +639,16 @@ export const executeClaudeCommand = async params => {
               if (!sessionId && data.session_id) {
                 sessionId = data.session_id;
                 await log(`📌 Session ID: ${sessionId}`);
-                let sessionLogFile;
-                try {
-                  const currentLogFile = getLogFile();
-                  sessionLogFile = path.join(path.dirname(currentLogFile), `${sessionId}.log`);
-                  await fs.rename(currentLogFile, sessionLogFile);
-                  setLogFile(sessionLogFile);
-                  await log(`📁 Log renamed to: ${sessionLogFile}`);
-                } catch (renameError) {
-                  reportError(renameError, { context: 'rename_session_log', sessionId, sessionLogFile, operation: 'rename_log_file' });
-                  await log(`⚠️ Could not rename log file: ${renameError.message}`, { verbose: true });
+                // Issue #2160: shared implementation, so restart/watch iterations rename their
+                // logs too and a caller that forgets the accessors gets a named reason.
+                const renameResult = await renameLogToSessionId({ sessionId, getLogFile, setLogFile, log });
+                if (!renameResult.ok && renameResult.error) {
+                  reportError(renameResult.error, {
+                    context: 'rename_session_log',
+                    sessionId,
+                    sessionLogFile: renameResult.sessionLogFile,
+                    operation: 'rename_log_file',
+                  });
                 }
               }
               const eventFacts = collectClaudeStreamEventFacts(data);
@@ -654,9 +660,16 @@ export const executeClaudeCommand = async params => {
                 await log('📝 Captured fallback summary from Claude compaction context', { verbose: true });
               }
               if (eventFacts.toolResultError) {
-                lastToolResultError = eventFacts.toolResultError;
-                lastMessage = eventFacts.toolResultError;
-                await log(`⚠️ Tool result error detected: ${eventFacts.toolResultError.substring(0, 200)}`, { verbose: true });
+                // Issue #2160: an in-session tool failure the AI handles itself is not a warning,
+                // and it must not replace the last assistant message — that message is what a
+                // truncated-stream failure is reported "after".
+                if (eventFacts.toolResultErrorIsBenign) {
+                  lastBenignToolResultError = eventFacts.toolResultError;
+                  await log(`ℹ️ In-session tool result (${eventFacts.toolResultErrorCategory}): ${eventFacts.toolResultError.substring(0, 200)}`, { verbose: true });
+                } else {
+                  lastToolResultError = eventFacts.toolResultError;
+                  await log(`⚠️ Tool result error detected: ${eventFacts.toolResultError.substring(0, 200)}`, { verbose: true });
+                }
               }
               // Issue #1708: signal busy/idle to the bidirectional handler so
               // queue-comments-to-input mode can hold frames until the AI is
@@ -903,9 +916,11 @@ export const executeClaudeCommand = async params => {
           toolUseCount += eventFacts.toolUseCountDelta;
           if (eventFacts.lastText) lastMessage = eventFacts.lastText;
           if (!resultSummary && eventFacts.compactionSummary) resultSummary = eventFacts.compactionSummary;
-          if (eventFacts.toolResultError) {
+          // Issue #2160: same classification as the streaming path above.
+          if (eventFacts.toolResultError && eventFacts.toolResultErrorIsBenign) {
+            lastBenignToolResultError = eventFacts.toolResultError;
+          } else if (eventFacts.toolResultError) {
             lastToolResultError = eventFacts.toolResultError;
-            lastMessage = eventFacts.toolResultError;
           }
           if (data?.type === 'result') {
             resultEventReceived = true;
@@ -1006,7 +1021,7 @@ export const executeClaudeCommand = async params => {
       }
       if (shouldFailClaudeStreamWithoutResult({ commandFailed, streamingInput, resultEventReceived })) {
         commandFailed = true;
-        lastMessage = buildMissingClaudeResultMessage({ lastToolResultError, lastMessage });
+        lastMessage = buildMissingClaudeResultMessage({ lastToolResultError, lastMessage, lastBenignToolResultError });
         await log(`\n\n❌ Command failed: ${lastMessage}`, { level: 'error' });
       }
       const retryableLastError = classifyRetryableError(lastMessage);

package/src/claude.stream-events.lib.mjs

@@ -19,12 +19,46 @@ const normalizeToolResultError = value => {
   }
 };
 
+/**
+ * Issue #2160: not every `tool_result` marked `is_error` says something about the session.
+ * Most of them are the AI's own command failing inside the session — the AI sees the result and
+ * carries on. Run 4c1dedd8 logged 26 "⚠️ Tool result error detected" lines, all of them of this
+ * kind (11 harness-blocked `sleep`s, 9 × `Exit code 143` Bash timeouts, 4 × `Exit code 1`,
+ * 2 × `Exit code 127`), and each one also overwrote the
+ * last assistant message, so a truncated stream could be reported as having failed "after:
+ * Blocked: sleep 240 …" instead of after what the AI actually said.
+ *
+ * Categories:
+ *   - `harness_blocked`     the AI tool's own harness refused the command (e.g. foreground sleep)
+ *   - `command_timeout`     the AI's command hit its Bash timeout (SIGTERM ⇒ exit code 143)
+ *   - `command_exit_code`   a bare non-zero exit status with no further detail
+ * Anything else is left unclassified and keeps being treated as a real error signal.
+ *
+ * @param {string|null} toolResultError - normalized tool_result error text
+ * @returns {{benign: boolean, category: string|null}}
+ */
+export const classifyToolResultError = toolResultError => {
+  if (typeof toolResultError !== 'string' || !toolResultError.trim()) return { benign: false, category: null };
+  const text = toolResultError.trim();
+
+  if (/^Blocked:/i.test(text)) return { benign: true, category: 'harness_blocked' };
+  if (/Command timed out after/i.test(text)) return { benign: true, category: 'command_timeout' };
+  // A bare "Exit code 143" is the SIGTERM the AI tool sends when its own Bash timeout fires.
+  if (/^Exit code 143\.?$/i.test(text)) return { benign: true, category: 'command_timeout' };
+  if (/^Exit code \d+\.?$/i.test(text)) return { benign: true, category: 'command_exit_code' };
+
+  return { benign: false, category: null };
+};
+
 export const collectClaudeStreamEventFacts = data => {
   const facts = {
     messageCountDelta: 0,
     toolUseCountDelta: 0,
     lastText: null,
     toolResultError: null,
+    // Issue #2160: set when toolResultError is an in-session, self-handled tool failure.
+    toolResultErrorIsBenign: false,
+    toolResultErrorCategory: null,
     compactionSummary: null,
   };
   if (!data || typeof data !== 'object') return facts;
@@ -47,6 +81,12 @@ export const collectClaudeStreamEventFacts = data => {
     facts.toolResultError = data.tool_use_result.trim();
   }
 
+  if (facts.toolResultError) {
+    const classification = classifyToolResultError(facts.toolResultError);
+    facts.toolResultErrorIsBenign = classification.benign;
+    facts.toolResultErrorCategory = classification.category;
+  }
+
   return facts;
 };
 
@@ -54,8 +94,22 @@ export const shouldFailClaudeStreamWithoutResult = ({ commandFailed, streamingIn
   return !commandFailed && !streamingInput && !resultEventReceived;
 };
 
-export const buildMissingClaudeResultMessage = ({ lastToolResultError, lastMessage }) => {
-  const detail = lastToolResultError || lastMessage;
+/**
+ * Describe a stream that ended without a terminal result event (issue #2023).
+ *
+ * Detail preference, in order (issue #2160): a real tool error explains the truncation best; the
+ * last thing the AI said is next; a benign in-session tool result (a blocked command, a Bash
+ * timeout) is only used when there is nothing else, so it stays out of the message whenever the
+ * assistant actually said something.
+ *
+ * @param {Object} params
+ * @param {string|null} [params.lastToolResultError] - last non-benign tool_result error
+ * @param {string|null} [params.lastMessage] - last assistant text
+ * @param {string|null} [params.lastBenignToolResultError] - last self-handled tool_result error
+ * @returns {string}
+ */
+export const buildMissingClaudeResultMessage = ({ lastToolResultError, lastMessage, lastBenignToolResultError = null }) => {
+  const detail = lastToolResultError || lastMessage || lastBenignToolResultError;
   if (!detail) return 'Claude stream ended without a terminal result event';
   return `Claude stream ended without a terminal result event after: ${String(detail).slice(0, 500)}`;
 };

package/src/disk-guard.lib.mjs

@@ -0,0 +1,256 @@
+/**
+ * Disk-space guard for solver workspaces (issue #2160).
+ *
+ * Reported symptom: `hive … --all-issues` finished with `❌ 4 task(s) failed (completed: 6)` even
+ * though nothing was wrong with those 4 issues. The run log shows why:
+ *
+ *   - the target repository was public, so solve's auto-cleanup default resolved to OFF and every
+ *     `/tmp/gh-issue-solver-*` workspace (~10 GB each) was kept;
+ *   - hive checked free disk space exactly once, at startup (73.2 GB free), and kept dequeuing;
+ *   - after 6 completed tasks only 9.8 GB were left, so each remaining task tripped solve's
+ *     pre-flight check (`❌ Insufficient disk space: 10047MB available, 10240MB required`), exited
+ *     after ~12s, posted a "Solution Draft Failed" comment and was counted as a *task* failure.
+ *
+ * An exhausted disk is an environment condition: the task is still perfectly solvable once space is
+ * available. This module lets the orchestrator (a) reclaim workspaces nobody is using any more,
+ * (b) wait for in-flight work to release space, and (c) report the condition as a deferral instead
+ * of a task failure.
+ *
+ * Everything that touches the outside world (df, readdir, rm, clock, sleep) is injectable so the
+ * behaviour can be tested without a full disk.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/2160
+ */
+
+import fsPromises from 'node:fs/promises';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Exit code a solver uses when it refuses to start because the host is out of disk space.
+ * 75 is EX_TEMPFAIL ("temporary failure, the user is invited to retry") from sysexits.h — the
+ * closest standard meaning to "nothing is wrong with the request, retry later".
+ */
+export const EXIT_CODE_INSUFFICIENT_DISK_SPACE = 75;
+
+/** Prefix of the temporary directories solve clones repositories into. */
+export const SOLVER_WORKSPACE_PREFIX = 'gh-issue-solver-';
+
+export const DEFAULT_TMP_ROOT = '/tmp';
+
+/** A workspace whose contents changed this recently is never reclaimed. */
+export const DEFAULT_MIN_IDLE_MS = 5 * 60 * 1000;
+
+const defaultSleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+const defaultRemove = async targetPath => fsPromises.rm(targetPath, { recursive: true, force: true });
+
+/**
+ * Free space in MB on the filesystem holding `targetPath`, or null when it cannot be determined.
+ * `df -Pk` is POSIX-portable output (single line per filesystem, 1K blocks).
+ */
+export const getFreeDiskSpaceMB = async (targetPath = DEFAULT_TMP_ROOT, { exec = execFileAsync } = {}) => {
+  try {
+    const { stdout } = await exec('df', ['-Pk', targetPath]);
+    const lines = String(stdout).trim().split('\n');
+    if (lines.length < 2) return null;
+    const columns = lines[lines.length - 1].trim().split(/\s+/);
+    const availableKB = Number.parseInt(columns[3], 10);
+    if (!Number.isFinite(availableKB)) return null;
+    return Math.floor(availableKB / 1024);
+  } catch {
+    return null;
+  }
+};
+
+/** Every `/tmp/gh-issue-solver-*` directory, oldest modification first. */
+export const listSolverWorkspaces = async ({ tmpRoot = DEFAULT_TMP_ROOT, fileSystem = fsPromises } = {}) => {
+  let entries;
+  try {
+    entries = await fileSystem.readdir(tmpRoot);
+  } catch {
+    return [];
+  }
+  const workspaces = [];
+  for (const entry of entries) {
+    const name = typeof entry === 'string' ? entry : entry.name;
+    if (!name || !name.startsWith(SOLVER_WORKSPACE_PREFIX)) continue;
+    const workspacePath = path.join(tmpRoot, name);
+    let stats;
+    try {
+      stats = await fileSystem.stat(workspacePath);
+    } catch {
+      continue;
+    }
+    if (typeof stats.isDirectory === 'function' && !stats.isDirectory()) continue;
+    workspaces.push({ path: workspacePath, name, mtimeMs: Number(stats.mtimeMs) || 0 });
+  }
+  return workspaces.sort((a, b) => a.mtimeMs - b.mtimeMs);
+};
+
+/**
+ * Workspaces that a live process is currently sitting in. The AI tool runs with its workspace as
+ * cwd, so /proc/<pid>/cwd is an authoritative "do not touch" signal on Linux. When /proc cannot be
+ * read (macOS, restricted container) every workspace is reported as busy — refusing to guess is the
+ * only safe answer, since deleting a live workspace would destroy real work.
+ */
+export const findBusySolverWorkspaces = async ({ workspaces = [], procRoot = '/proc', fileSystem = fsPromises } = {}) => {
+  if (!workspaces.length) return new Set();
+  let pids;
+  try {
+    pids = (await fileSystem.readdir(procRoot)).map(entry => (typeof entry === 'string' ? entry : entry.name)).filter(name => /^\d+$/.test(name));
+  } catch {
+    return new Set(workspaces.map(workspace => workspace.path));
+  }
+  const cwds = [];
+  for (const pid of pids) {
+    try {
+      cwds.push(String(await fileSystem.readlink(path.join(procRoot, pid, 'cwd'))));
+    } catch {
+      // The process exited, or its cwd is not readable by this user — nothing to protect here.
+    }
+  }
+  const busy = new Set();
+  for (const workspace of workspaces) {
+    if (cwds.some(cwd => cwd === workspace.path || cwd.startsWith(`${workspace.path}/`))) busy.add(workspace.path);
+  }
+  return busy;
+};
+
+/**
+ * Entries of the given temp roots that `--auto-cleanup` may delete.
+ *
+ * The old implementation ran `sudo rm -rf /tmp/* /var/tmp/*`, which also destroys the workspaces,
+ * lock directories and log files of any *concurrent* hive/solve run on the same host — the run
+ * doing the cleanup is rarely the only tenant of /tmp. This builds an explicit list instead and
+ * leaves alone anything a live process is sitting in, anything the caller marked as protected, and
+ * the run's own log file.
+ *
+ * @param {Object} [options]
+ * @param {Array<string>} [options.roots=['/tmp','/var/tmp']] - Directories to clean
+ * @param {Iterable<string>} [options.protectedPaths] - Paths that must survive
+ * @returns {Promise<{remove: Array<string>, keep: Array<{path: string, reason: string}>}>}
+ */
+export const listCleanableTempEntries = async ({ roots = ['/tmp', '/var/tmp'], protectedPaths = new Set(), fileSystem = fsPromises, procRoot = '/proc' } = {}) => {
+  const protectedSet = new Set(Array.from(protectedPaths).filter(Boolean).map(String));
+  const remove = [];
+  const keep = [];
+  const candidates = [];
+  for (const root of roots) {
+    let entries;
+    try {
+      entries = await fileSystem.readdir(root);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const name = typeof entry === 'string' ? entry : entry.name;
+      if (!name || name === '.' || name === '..') continue;
+      candidates.push({ path: path.join(root, name), name, mtimeMs: 0 });
+    }
+  }
+  const busy = await findBusySolverWorkspaces({ workspaces: candidates, procRoot, fileSystem });
+  for (const candidate of candidates) {
+    const isProtected = protectedSet.has(candidate.path) || Array.from(protectedSet).some(protectedPath => protectedPath.startsWith(`${candidate.path}/`));
+    if (isProtected) {
+      keep.push({ path: candidate.path, reason: 'protected' });
+      continue;
+    }
+    if (busy.has(candidate.path)) {
+      keep.push({ path: candidate.path, reason: 'process_cwd' });
+      continue;
+    }
+    remove.push(candidate.path);
+  }
+  return { remove, keep };
+};
+
+/** Workspace paths mentioned in a line of solver output, used to protect in-flight workspaces. */
+export const extractSolverWorkspacePaths = (text, { tmpRoot = DEFAULT_TMP_ROOT } = {}) => {
+  if (!text) return [];
+  const pattern = new RegExp(`${tmpRoot.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}/${SOLVER_WORKSPACE_PREFIX}[A-Za-z0-9_-]+`, 'g');
+  return Array.from(new Set(String(text).match(pattern) || []));
+};
+
+/**
+ * Remove idle solver workspaces, oldest first, until `requiredMB` is free.
+ * A workspace is skipped when it is in flight, is some process's cwd, or was modified recently.
+ */
+export const reclaimSolverWorkspaces = async ({ requiredMB = 0, tmpRoot = DEFAULT_TMP_ROOT, protectedPaths = new Set(), minIdleMs = DEFAULT_MIN_IDLE_MS, now = Date.now, log = async () => {}, fileSystem = fsPromises, procRoot = '/proc', getFreeMB = getFreeDiskSpaceMB, remove = defaultRemove } = {}) => {
+  const removed = [];
+  const skipped = [];
+  let freeMB = await getFreeMB(tmpRoot);
+  const workspaces = await listSolverWorkspaces({ tmpRoot, fileSystem });
+  if (!workspaces.length) return { removed, skipped, freeMB };
+  const busy = await findBusySolverWorkspaces({ workspaces, procRoot, fileSystem });
+  const currentTime = now();
+  for (const workspace of workspaces) {
+    if (freeMB !== null && freeMB >= requiredMB) break;
+    if (protectedPaths.has(workspace.path)) {
+      skipped.push({ path: workspace.path, reason: 'in_flight' });
+      continue;
+    }
+    if (busy.has(workspace.path)) {
+      skipped.push({ path: workspace.path, reason: 'process_cwd' });
+      continue;
+    }
+    if (currentTime - workspace.mtimeMs < minIdleMs) {
+      skipped.push({ path: workspace.path, reason: 'recently_modified' });
+      continue;
+    }
+    try {
+      await remove(workspace.path);
+      removed.push(workspace.path);
+      await log(`   🧹 Reclaimed idle solver workspace: ${workspace.path}`);
+    } catch (error) {
+      skipped.push({ path: workspace.path, reason: 'remove_failed', error });
+      await log(`   ⚠️  Could not remove ${workspace.path}: ${error.message}`, { level: 'warning' });
+      continue;
+    }
+    freeMB = await getFreeMB(tmpRoot);
+  }
+  return { removed, skipped, freeMB };
+};
+
+/**
+ * Make sure `requiredMB` is free before a worker starts a task.
+ *
+ * Returns `{ ok: true }` when there is (or there now is) enough space, and
+ * `{ ok: false, reason: 'insufficient_disk_space' }` when the caller should defer the task instead
+ * of spawning a solver that would die in its pre-flight check.
+ *
+ * An unreadable `df` never blocks work: the guard is an optimisation over solve's own pre-flight
+ * check, not a replacement for it.
+ */
+export const ensureDiskSpaceForWorker = async ({ requiredMB = 10240, tmpRoot = DEFAULT_TMP_ROOT, protectedPaths = new Set(), minIdleMs = DEFAULT_MIN_IDLE_MS, maxWaitMs = 0, pollIntervalMs = 30000, log = async () => {}, now = Date.now, sleep = defaultSleep, getFreeMB = getFreeDiskSpaceMB, fileSystem = fsPromises, procRoot = '/proc', remove = defaultRemove } = {}) => {
+  const startedAt = now();
+  const reclaimed = [];
+  let freeMB = await getFreeMB(tmpRoot);
+  if (freeMB === null) {
+    await log('   💾 Could not determine free disk space — continuing and letting the solver pre-flight check decide', { verbose: true });
+    return { ok: true, freeMB: null, reason: 'unknown_free_space', reclaimed, waitedMs: 0 };
+  }
+  if (freeMB >= requiredMB) {
+    await log(`   💾 Disk space before starting work: ${freeMB}MB free (${requiredMB}MB required)`, { verbose: true });
+    return { ok: true, freeMB, reason: 'sufficient', reclaimed, waitedMs: 0 };
+  }
+  await log(`   💾 Low disk space: ${freeMB}MB free, ${requiredMB}MB required — reclaiming idle solver workspaces before starting work`, { level: 'warning' });
+  for (;;) {
+    const result = await reclaimSolverWorkspaces({ requiredMB, tmpRoot, protectedPaths, minIdleMs, now, log, fileSystem, procRoot, getFreeMB, remove });
+    reclaimed.push(...result.removed);
+    if (result.freeMB !== null && result.freeMB !== undefined) freeMB = result.freeMB;
+    if (freeMB >= requiredMB) {
+      await log(`   ✅ Disk space recovered: ${freeMB}MB free after reclaiming ${result.removed.length} workspace(s)`);
+      return { ok: true, freeMB, reason: 'reclaimed', reclaimed, waitedMs: now() - startedAt };
+    }
+    const elapsedMs = now() - startedAt;
+    if (elapsedMs + pollIntervalMs > maxWaitMs) {
+      return { ok: false, freeMB, reason: 'insufficient_disk_space', reclaimed, waitedMs: elapsedMs, skipped: result.skipped };
+    }
+    await log(`   ⏳ Still ${freeMB}MB free of the ${requiredMB}MB required — waiting ${Math.round(pollIntervalMs / 1000)}s for in-flight work to release disk space`);
+    await sleep(pollIntervalMs);
+  }
+};

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/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}`);
   }
 };

package/src/solve.restart-shared.lib.mjs

@@ -30,7 +30,10 @@ const fs = (await use('fs')).promises;
 
 // Import shared library functions
 const lib = await import('./lib.mjs');
-const { log, formatAligned, extractToolErrorCore } = lib;
+// Issue #2160: the real log-file accessors must be forwarded to every tool executor. Passing
+// no-op stubs (or omitting them entirely) broke session-log renaming in restart/watch iterations
+// ("⚠️ Could not rename log file: getLogFile is not a function").
+const { log, formatAligned, extractToolErrorCore, getLogFile, setLogFile } = lib;
 const { ensurePullRequestBaseBranch } = await import('./solve.pr-base-guard.lib.mjs');
 const { ensureAiToolScratchIgnored, filterAiToolScratchFromStatus } = await import('./ai-tool-scratch.lib.mjs');
 const { RESOURCE_PHASE_RESTART_AFTER, RESOURCE_PHASE_RESTART_BEFORE, recordResourceSnapshot } = await import('./solve.resource-diagnostics.lib.mjs');
@@ -240,8 +243,8 @@ export const executeToolIteration = async params => {
       log,
       formatAligned,
       getResourceSnapshot,
-      setLogFile: () => {},
-      getLogFile: () => '',
+      setLogFile,
+      getLogFile,
       $,
     });
   } else if (argv.tool === 'opencode') {
@@ -280,6 +283,8 @@ export const executeToolIteration = async params => {
       log,
       formatAligned,
       getResourceSnapshot,
+      setLogFile,
+      getLogFile,
       opencodePath,
       $,
     });
@@ -318,8 +323,8 @@ export const executeToolIteration = async params => {
       repo,
       argv,
       log,
-      setLogFile: () => {},
-      getLogFile: () => '',
+      setLogFile,
+      getLogFile,
       formatAligned,
       getResourceSnapshot,
       codexPath,
@@ -362,6 +367,8 @@ export const executeToolIteration = async params => {
       log,
       formatAligned,
       getResourceSnapshot,
+      setLogFile,
+      getLogFile,
       agentPath,
       $,
     });
@@ -400,8 +407,8 @@ export const executeToolIteration = async params => {
       repo,
       argv,
       log,
-      setLogFile: () => {},
-      getLogFile: () => '',
+      setLogFile,
+      getLogFile,
       formatAligned,
       getResourceSnapshot,
       geminiPath,
@@ -442,8 +449,8 @@ export const executeToolIteration = async params => {
       repo,
       argv,
       log,
-      setLogFile: () => {},
-      getLogFile: () => '',
+      setLogFile,
+      getLogFile,
       formatAligned,
       getResourceSnapshot,
       qwenPath,
@@ -488,6 +495,8 @@ export const executeToolIteration = async params => {
       log,
       formatAligned,
       getResourceSnapshot,
+      setLogFile,
+      getLogFile,
       claudePath,
       $,
     });

package/src/solve.results.lib.mjs

@@ -485,12 +485,15 @@ export const cleanupClaudeFile = async (tempDir, branchName, claudeCommitHash =
     const verifyResult = await $({ cwd: tempDir })`git ls-files ${fileName} 2>&1`;
     const fileStillExists = verifyResult.code === 0 && verifyResult.stdout && verifyResult.stdout.trim();
     if (fileStillExists) {
-      await log(`   ⚠️  WARNING: ${fileName} still exists after cleanup — attempting direct removal...`);
-      // Check if the file existed before the initial commit (parent)
+      // Issue #2160: the pre-existence check must come FIRST. A file that legitimately predates
+      // the session is not a cleanup failure, and warning about it produced a false positive
+      // ("⚠️ WARNING: .gitkeep still exists after cleanup" immediately followed by
+      // "ℹ️ .gitkeep existed before this session — keeping pre-existing file").
       const parentCommit = `${claudeCommitHash}~1`;
       const parentFileExists = await $({ cwd: tempDir })`git cat-file -e ${parentCommit}:${fileName} 2>&1`;
       if (parentFileExists.code !== 0) {
-        // File didn't exist before the session — force remove it
+        // File didn't exist before the session — this is a real leftover, force remove it
+        await log(`   ⚠️  WARNING: ${fileName} still exists after cleanup — attempting direct removal...`);
         await $({ cwd: tempDir })`git rm -f ${fileName} 2>&1`;
         const fallbackCommit = await $({ cwd: tempDir })`git commit -m "Remove leftover ${fileName} (post-cleanup fallback, Issue #1436)" 2>&1`;
         if (fallbackCommit.code === 0) {

package/src/solve.validation.lib.mjs

@@ -53,12 +53,6 @@ const { parseResetTime: parseResetTimeToDate } = usageLimitLib;
 
 const { validateClaudeConnection } = claudeLib;
 
-// Wrapper function for disk space check using imported module
-const checkDiskSpace = async (minSpaceMB = 10240) => {
-  const result = await memoryCheck.checkDiskSpace(minSpaceMB, { log });
-  return result.success;
-};
-
 // Wrapper function for memory check using imported module
 const checkMemory = async (minMemoryMB = 256) => {
   const result = await memoryCheck.checkMemory(minMemoryMB, { log });
@@ -217,9 +211,13 @@ export const validateContinueOnlyOnFeedback = async (argv, isPrUrl, isIssueUrl)
 // Note: skipToolConnection only skips the connection check, not model validation
 // Model validation should be done separately before calling this function
 export const performSystemChecks = async (minDiskSpace = 10240, skipToolConnection = false, model = 'sonnet', argv = {}) => {
-  // Check disk space before proceeding
-  const hasEnoughSpace = await checkDiskSpace(minDiskSpace);
-  if (!hasEnoughSpace) {
+  // Check disk space before proceeding.
+  // Issue #2160: record *which* check failed on argv. A full disk says nothing about the issue
+  // being solved, so the caller exits with a retry-later code and skips the "Solution Draft
+  // Failed" comment instead of blaming the task (hive counted 4 such exits as task failures).
+  const diskSpace = await memoryCheck.checkDiskSpace(minDiskSpace, { log });
+  if (!diskSpace.success) {
+    argv.systemCheckFailure = { check: 'disk-space', availableMB: diskSpace.availableMB, requiredMB: minDiskSpace };
     return false;
   }