@link-assistant/hive-mind 2.0.5 → 2.0.7

package/CHANGELOG.md

@@ -1,5 +1,58 @@
 # @link-assistant/hive-mind
 
+## 2.0.7
+
+### Patch Changes
+
+- 6d9a2bb: feat(solve): log working-tree size before/after the AI agent and warn on Telegram when disk usage exceeds 5 GB (#1945)
+
+  `/solve` now records the size of its temporary working tree at two checkpoints:
+  after the repository is cloned (before the AI agent starts) and after the AI
+  working session ends. Both checkpoints emit a structured `📊 [DISK]` marker into
+  the captured solve log, so the cloned-repo size, the AI-induced delta, and the
+  final total are visible in `tail -f`-style debugging.
+
+  The session monitor parses those markers from the captured log and appends a
+  `💾 Disk usage` block to the Telegram completion message. The block raises a
+  warning when the cloned repository exceeds 5 GB, when the working tree grew by
+  more than 5 GB during the run, or when the total disk usage for the task
+  exceeds 5 GB — exactly the three conditions called out in the issue.
+
+  Sizing uses `du -sb` (byte-accurate on Linux), falls back to `du -sk` on BSD/
+  macOS, and finally to `fs.statSync` for single-file targets — no new runtime
+  dependency. The threshold is 5 GiB and uses a strict `>` comparison, so a tree
+  that lands at exactly 5 GiB does not warn.
+
+## 2.0.6
+
+### Patch Changes
+
+- 0c63706: Stop surfacing meaningless stream fragments as tool errors (#1941). When a tool
+  run is interrupted mid-stream (CTRL+C / SIGINT, exit code 130), the last captured
+  stdout line could be a stray structural character such as a lone `}`, which leaked
+  into the GitHub failure comment as "CLAUDE execution failed with }". A new shared
+  `isMeaningfulErrorText` helper (any error with at least one Unicode letter or digit
+  is real; pure punctuation is not) now guards the `extractToolErrorCore` chokepoint,
+  and a new `buildToolErrorMessage` helper labels interruptions explicitly
+  ("Claude command interrupted (CTRL+C)") across the Claude and OpenCode runners.
+- d4efc82: fix(playwright-mcp): do not abort the solve when the Playwright MCP preflight probe is inconclusive (#1943)
+
+  A `solve` run aborted before creating a pull request with
+  `❌ Playwright MCP preflight failed for Claude Code`. The local preflight ran
+  `timeout 5 claude mcp list`, but that command performs a live health check that
+  launches a browser and can take longer than five seconds; when the `timeout`
+  killed the probe, `ensureConnectedPlaywrightMcpServer` treated the non-zero exit
+  as a failure and stopped the whole run.
+
+  An inconclusive `mcp list` probe (timeout / crash / missing CLI) now falls back
+  to the local `@playwright/mcp` package check instead of aborting: if the package
+  is installed, the server connects on demand via Tool Search (issue #1901), so the
+  working session proceeds. The probe timeout now defaults to 30s and is overridable
+  via `PLAYWRIGHT_MCP_PREFLIGHT_TIMEOUT_SECONDS`, and the preflight emits verbose
+  diagnostics (probe exit code, matched rows, decision branch) so failures are
+  diagnosable from the log. The preflight still fails only when `@playwright/mcp`
+  is genuinely unavailable.
+
 ## 2.0.5
 
 ### Patch Changes

package/package.json

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

package/src/claude.lib.mjs

@@ -6,7 +6,7 @@ if (typeof globalThis.use === 'undefined') {
 const { $ } = await use('command-stream');
 const fs = (await use('fs')).promises;
 const path = (await use('path')).default;
-import { log, isENOSPC } from './lib.mjs';
+import { log, isENOSPC, buildToolErrorMessage } from './lib.mjs';
 import { reportError } from './sentry.lib.mjs';
 import { timeouts, retryLimits, claudeCode, getClaudeEnv, getThinkingLevelToTokens, getTokensToThinkingLevel, supportsThinkingBudget, DEFAULT_MAX_THINKING_BUDGET, getMaxOutputTokensForModel } from './config.lib.mjs';
 import { detectUsageLimit, formatUsageLimitMessage, isUsageLimitError } from './usage-limit.lib.mjs';
@@ -1211,8 +1211,8 @@ export const executeClaudeCommand = async params => {
             is503Error,
             anthropicTotalCostUSD: cumulativeAnthropicCostUSDOnStuckRetry, // Issue #1104/#1886
             resultSummary,
-            // Issue #1845: surface the actual error so callers can show it to users
-            errorInfo: { message: lastMessage || 'API explicitly marked error as not retryable', exitCode },
+            // Issue #1845/#1941: surface the actual error, rejecting meaningless fragments (e.g. a lone "}")
+            errorInfo: { message: buildToolErrorMessage({ lastMessage, exitCode, fallback: 'API explicitly marked error as not retryable', toolLabel: 'Claude' }), exitCode },
             queuedFeedback, // Issue #817: Bidirectional mode feedback
           };
         }
@@ -1260,8 +1260,8 @@ export const executeClaudeCommand = async params => {
             is503Error, // preserve for callers that check this
             anthropicTotalCostUSD: cumulativeAnthropicCostUSDOnRetriesExhausted, // Issue #1104/#1886: Include cumulative cost even on failure
             resultSummary, // Issue #1263: Include result summary
-            // Issue #1845: surface the actual error so callers can show it to users
-            errorInfo: { message: lastMessage || `Transient API error persisted after ${maxRetries} retries`, exitCode },
+            // Issue #1845/#1941: surface the actual error, rejecting meaningless fragments (e.g. a lone "}")
+            errorInfo: { message: buildToolErrorMessage({ lastMessage, exitCode, fallback: `Transient API error persisted after ${maxRetries} retries`, toolLabel: 'Claude' }), exitCode },
             queuedFeedback, // Issue #817: Bidirectional mode feedback
           };
         }
@@ -1327,9 +1327,9 @@ export const executeClaudeCommand = async params => {
           errorDuringExecution,
           anthropicTotalCostUSD: cumulativeAnthropicCostUSDOnFailure, // Issue #1104/#1886: cumulative cost even on failure
           resultSummary, // Issue #1263: Include result summary
-          // Issue #1845: surface the core error (e.g. "API Error: Output blocked by content
-          // filtering policy") so users see what actually went wrong, not just a generic message.
-          errorInfo: { message: lastMessage || `Claude command failed with exit code ${exitCode}`, exitCode },
+          // Issue #1845: surface the core error (e.g. "API Error: Output blocked by content filtering policy").
+          // Issue #1941: a lone "}" fragment at interrupt time must not become "CLAUDE execution failed with }".
+          errorInfo: { message: buildToolErrorMessage({ lastMessage, exitCode, fallback: `Claude command failed with exit code ${exitCode}`, toolLabel: 'Claude' }), exitCode },
           queuedFeedback, // Issue #817: Bidirectional mode feedback
         };
       }

package/src/gemini.lib.mjs

@@ -10,7 +10,7 @@ if (typeof globalThis.use === 'undefined') {
 
 const { $ } = await use('command-stream');
 
-import { log } from './lib.mjs';
+import { log, buildToolErrorMessage } from './lib.mjs';
 import { reportError } from './sentry.lib.mjs';
 import { timeouts, retryLimits } from './config.lib.mjs';
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
@@ -576,8 +576,8 @@ export const executeGeminiCommand = async params => {
           pricingInfo: { modelId: mappedModel, modelName: mappedModel, provider: 'Google', totalCostUSD: null },
           publicPricingEstimate: null,
           resultSummary: geminiJsonState.resultSummary || null,
-          // Issue #1845: surface the actual error so callers can show it to users
-          errorInfo: { message: errorText || `Gemini command failed with exit code ${exitCode}`, exitCode },
+          // Issue #1845/#1941: surface the actual error, rejecting meaningless fragments (e.g. a lone "}")
+          errorInfo: { message: buildToolErrorMessage({ lastMessage: errorText, exitCode, fallback: `Gemini command failed with exit code ${exitCode}`, toolLabel: 'Gemini' }), exitCode },
         };
       }
 

package/src/lib.mjs

@@ -665,6 +665,53 @@ export const cleanErrorMessage = error => {
   return message;
 };
 
+/**
+ * Decide whether a string looks like a meaningful, human-readable error message
+ * rather than a stray structural fragment (Issue #1941).
+ *
+ * When a tool process is interrupted mid-stream (CTRL+C / SIGINT) or killed, the
+ * last captured stdout line can be a lone JSON-structural character left over
+ * from a truncated stream — for example a bare `}` or `{`. Surfacing that as the
+ * "core error" produced nonsense failure messages such as
+ * "CLAUDE execution failed with }" / "failed by {". A real error message always
+ * contains at least one letter or digit (in any script), so we treat fragments
+ * that contain none as not meaningful.
+ *
+ * @param {*} value - Candidate error string
+ * @returns {boolean} True when the value contains usable error text
+ */
+export const isMeaningfulErrorText = value => {
+  if (!value || typeof value !== 'string') return false;
+  const collapsed = value.replace(/\s+/g, ' ').trim();
+  if (!collapsed) return false;
+  // Require at least one Unicode letter or number; pure punctuation/brackets
+  // (e.g. "}", "{", "[]", ",") are stream fragments, not real errors.
+  return /[\p{L}\p{N}]/u.test(collapsed);
+};
+
+/**
+ * Build a clean tool error message for `errorInfo.message`, rejecting
+ * meaningless stream fragments (Issue #1941).
+ *
+ * Picks the tool-reported `lastMessage` only when it is meaningful; otherwise
+ * falls back to an interrupt label (exit code 130 = SIGINT/CTRL+C) or the
+ * provided generic fallback. This keeps junk like a lone `}` out of the stored
+ * error so every downstream surface (GitHub comment, terminal, retry logic)
+ * shows something honest.
+ *
+ * @param {Object} options
+ * @param {string} [options.lastMessage] - The last message captured from the tool stream
+ * @param {number} [options.exitCode] - Process exit code
+ * @param {string} [options.fallback] - Generic fallback message
+ * @param {string} [options.toolLabel='Tool'] - Human tool label for the interrupt message
+ * @returns {string} A clean, meaningful error message
+ */
+export const buildToolErrorMessage = ({ lastMessage, exitCode, fallback, toolLabel = 'Tool' } = {}) => {
+  if (isMeaningfulErrorText(lastMessage)) return lastMessage.replace(/\s+/g, ' ').trim();
+  if (exitCode === 130) return `${toolLabel} command interrupted (CTRL+C)`;
+  return fallback;
+};
+
 /**
  * Extract the core/root error string from a tool runner result (Issue #1845).
  *
@@ -675,6 +722,10 @@ export const cleanErrorMessage = error => {
  * (GitHub comments / exit message) and the terminal "Error details:" lines in
  * watch / auto-merge so they never diverge.
  *
+ * Issue #1941: a meaningless structural fragment (e.g. a lone `}` captured when
+ * a tool is interrupted mid-stream) is treated as "no usable error" so callers
+ * fall back to the generic phrase instead of "execution failed with }".
+ *
  * @param {Object} options
  * @param {Object} [options.toolResult] - Result object returned by the tool runner
  * @returns {string|null} The core error string, or null when none is available
@@ -688,6 +739,9 @@ export const extractToolErrorCore = ({ toolResult } = {}) => {
 
   if (!rawCore || typeof rawCore !== 'string') return null;
 
+  // Issue #1941: reject stray fragments with no letters/digits (e.g. "}").
+  if (!isMeaningfulErrorText(rawCore)) return null;
+
   // Collapse to a single clean line and strip noise.
   const core = rawCore.replace(/\s+/g, ' ').trim();
   return core || null;

package/src/opencode.lib.mjs

@@ -14,7 +14,7 @@ const path = (await use('path')).default;
 const os = (await use('os')).default;
 
 // Import log from general lib
-import { log } from './lib.mjs';
+import { log, isMeaningfulErrorText, buildToolErrorMessage } from './lib.mjs';
 import { reportError } from './sentry.lib.mjs';
 import { timeouts, retryLimits } from './config.lib.mjs';
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
@@ -532,7 +532,8 @@ export const executeOpenCodeCommand = async params => {
           ...pricingResult,
           resultSummary: lastTextContent || null, // Issue #1263: Use last text content from JSON output stream
           // Issue #1845: surface the actual error so callers can show it to users
-          errorInfo: { message: lastMessage || allOutput || `OpenCode command failed with exit code ${exitCode}`, exitCode },
+          // Issue #1941: reject meaningless stream fragments (e.g. a lone "}").
+          errorInfo: { message: buildToolErrorMessage({ lastMessage: isMeaningfulErrorText(lastMessage) ? lastMessage : allOutput, exitCode, fallback: `OpenCode command failed with exit code ${exitCode}`, toolLabel: 'OpenCode' }), exitCode },
         };
       }
 

package/src/playwright-mcp.lib.mjs

@@ -30,44 +30,109 @@ export const hasConnectedPlaywrightMcpServer = output => {
   return rows.some(row => PLAYWRIGHT_MCP_CONNECTED_PATTERN.test(row) && !PLAYWRIGHT_MCP_UNAVAILABLE_PATTERN.test(row));
 };
 
-export const checkPlaywrightMcpPackageAvailability = async () => {
+// `claude mcp list` / `codex mcp list` perform live health checks against every
+// registered MCP server (Playwright MCP launches a browser to report status),
+// which can take noticeably longer than a couple of seconds on a cold cache or
+// a busy CI host. A too-aggressive `timeout` kills the probe before it answers,
+// which previously aborted the entire solve (issue #1943). The probe timeout is
+// therefore generous by default and overridable for slow/fast environments.
+export const PLAYWRIGHT_MCP_LIST_TIMEOUT_SECONDS_DEFAULT = 30;
+
+export const getPlaywrightMcpListTimeoutSeconds = (env = process.env) => {
+  const parsed = Number.parseInt(env?.PLAYWRIGHT_MCP_PREFLIGHT_TIMEOUT_SECONDS ?? '', 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : PLAYWRIGHT_MCP_LIST_TIMEOUT_SECONDS_DEFAULT;
+};
+
+const diagLog =
+  (log, opts = { verbose: true }) =>
+  async message => {
+    if (log) await log(message, opts);
+  };
+
+export const checkPlaywrightMcpPackageAvailability = async ({ log } = {}) => {
+  const diag = diagLog(log);
   try {
-    const result = await $`timeout 5 npx --no-install @playwright/mcp --help 2>&1`.catch(() => null);
-    if (isCommandResultSuccess(result)) return true;
-    const npmResult = await $`timeout 5 npm ls -g @playwright/mcp 2>&1`.catch(() => null);
-    return getCommandResultOutput(npmResult).includes('@playwright/mcp');
-  } catch {
+    const timeoutSeconds = getPlaywrightMcpListTimeoutSeconds();
+    const result = await $`timeout ${timeoutSeconds} npx --no-install @playwright/mcp --help 2>&1`.catch(() => null);
+    if (isCommandResultSuccess(result)) {
+      await diag('🎭 @playwright/mcp package is available via npx');
+      return true;
+    }
+    const npmResult = await $`timeout ${timeoutSeconds} npm ls -g @playwright/mcp 2>&1`.catch(() => null);
+    const available = getCommandResultOutput(npmResult).includes('@playwright/mcp');
+    await diag(`🎭 @playwright/mcp global package ${available ? 'is installed' : 'was not found'}`);
+    return available;
+  } catch (error) {
+    await diag(`⚠️  @playwright/mcp package availability check threw: ${error.message}`);
     return false;
   }
 };
 
-export const ensureConnectedPlaywrightMcpServer = async ({ list, add, hasPackage = checkPlaywrightMcpPackageAvailability }) => {
+export const ensureConnectedPlaywrightMcpServer = async ({ list, add, hasPackage = checkPlaywrightMcpPackageAvailability, log } = {}) => {
+  const diag = diagLog(log);
   try {
     const result = await list().catch(() => null);
-    if (!isCommandResultSuccess(result)) return false;
+    const code = getCommandResultCode(result);
     const output = getCommandResultOutput(result);
-    if (hasConnectedPlaywrightMcpServer(output)) return true;
-    if (getPlaywrightMcpListRows(output).length > 0) return false;
-    if (!(await hasPackage())) return false;
+    const rows = getPlaywrightMcpListRows(output);
+    await diag(`🎭 Playwright MCP probe: 'mcp list' exit=${code === null ? 'timeout/none' : code}, playwright rows=${rows.length}${rows.length ? ` [${rows.join(' | ')}]` : ''}`);
+
+    // Inconclusive probe: the `mcp list` command itself failed (timed out,
+    // crashed, or its binary is missing). That tells us NOTHING about whether
+    // Playwright MCP actually works, so it must not abort the whole solve as it
+    // did in issue #1943. A still-connecting server is normal — Tool Search
+    // loads MCP tools on demand (issue #1901) — so fall back to the local
+    // @playwright/mcp package check: if the package is installed, the server can
+    // connect on demand and the working session should proceed.
+    if (!isCommandResultSuccess(result)) {
+      const packageAvailable = await hasPackage({ log });
+      await diag(`⚠️  Playwright MCP 'mcp list' probe was inconclusive (exit=${code === null ? 'timeout' : code}); @playwright/mcp package ${packageAvailable ? 'is installed, so Tool Search can connect it on demand — preflight passes' : 'is NOT installed — preflight fails'}`);
+      return packageAvailable;
+    }
 
+    if (hasConnectedPlaywrightMcpServer(output)) {
+      await diag('🎭 Playwright MCP reported as connected by mcp list');
+      return true;
+    }
+
+    // A registration row exists but is not reported connected (pending /
+    // disabled / failed). Leave it untouched (do not overwrite an intentional
+    // or in-progress registration) and let the caller decide.
+    if (rows.length > 0) {
+      await diag('🎭 Playwright MCP is registered but not reported connected by mcp list; leaving registration unchanged');
+      return false;
+    }
+
+    // No registration at all → register the default server when the package is
+    // available, then re-probe.
+    if (!(await hasPackage({ log }))) {
+      await diag('⚠️  No Playwright MCP registration found and @playwright/mcp package is unavailable');
+      return false;
+    }
+    await diag('🎭 No Playwright MCP registration found; registering the default server...');
     await add().catch(() => null);
     const retryResult = await list().catch(() => null);
-    return isCommandResultSuccess(retryResult) && hasConnectedPlaywrightMcpServer(getCommandResultOutput(retryResult));
-  } catch {
+    const connected = isCommandResultSuccess(retryResult) && hasConnectedPlaywrightMcpServer(getCommandResultOutput(retryResult));
+    await diag(`🎭 Playwright MCP registration ${connected ? 'succeeded and is now connected' : 'did not report connected after add'}`);
+    return connected;
+  } catch (error) {
+    await diag(`⚠️  Playwright MCP preflight probe threw: ${error.message}`);
     return false;
   }
 };
 
-export const ensureClaudePlaywrightMcpServer = async () =>
+export const ensureClaudePlaywrightMcpServer = async ({ log } = {}) =>
   ensureConnectedPlaywrightMcpServer({
-    list: () => $`timeout 5 claude mcp list 2>&1`,
+    list: () => $`timeout ${getPlaywrightMcpListTimeoutSeconds()} claude mcp list 2>&1`,
     add: () => $`claude mcp add playwright -s user -- npx -y @playwright/mcp@latest --isolated --headless --no-sandbox --timeout-action=600000 --viewport-size 1920x1080`,
+    log,
   });
 
-export const ensureCodexPlaywrightMcpServer = async () =>
+export const ensureCodexPlaywrightMcpServer = async ({ log } = {}) =>
   ensureConnectedPlaywrightMcpServer({
-    list: () => $`timeout 5 codex mcp list 2>&1`,
+    list: () => $`timeout ${getPlaywrightMcpListTimeoutSeconds()} codex mcp list 2>&1`,
     add: () => $`codex mcp add playwright -- npx -y @playwright/mcp@latest --isolated --headless --no-sandbox --timeout-action=600000 --viewport-size 1920x1080`,
+    log,
   });
 
 const SOLVE_PLAYWRIGHT_MCP_CHECKS = {
@@ -102,7 +167,7 @@ export const ensureSolvePlaywrightMcpReady = async ({ argv = {}, log = async ()
   await log(`🎭 Checking Playwright MCP preflight for ${label}...`, { verbose: true });
 
   try {
-    if (await checkFn()) {
+    if (await checkFn({ log })) {
       await log(`🎭 Playwright MCP ready for ${label}`, { verbose: true });
       return { ok: true, checkedTools: [tool], skipped: false };
     }

package/src/qwen.lib.mjs

@@ -13,7 +13,7 @@ const fs = (await use('fs')).promises;
 const path = (await use('path')).default;
 const os = (await use('os')).default;
 
-import { log } from './lib.mjs';
+import { log, buildToolErrorMessage } from './lib.mjs';
 import { reportError } from './sentry.lib.mjs';
 import { timeouts, retryLimits } from './config.lib.mjs';
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
@@ -633,8 +633,8 @@ export const executeQwenCommand = async params => {
           limitResetTime: null,
           ...usageResult,
           resultSummary,
-          // Issue #1845: surface the actual error so callers can show it to users
-          errorInfo: { message: combinedErrorText || errorMessage || `Qwen Code command failed${exitCode !== 0 ? ` with exit code ${exitCode}` : ''}`, exitCode },
+          // Issue #1845/#1941: surface the actual error, rejecting meaningless fragments (e.g. a lone "}")
+          errorInfo: { message: buildToolErrorMessage({ lastMessage: combinedErrorText || errorMessage, exitCode, fallback: `Qwen Code command failed${exitCode !== 0 ? ` with exit code ${exitCode}` : ''}`, toolLabel: 'Qwen Code' }), exitCode },
         };
       }
 

package/src/session-monitor.lib.mjs

@@ -297,6 +297,28 @@ async function resolvePullRequestUrlFromSessionLog(logPath, ctx, { verbose = fal
   }
 }
 
+/**
+ * Issue #1945: Parse `📊 [DISK]` checkpoint markers out of the captured solve
+ * log and, when the captured sizes cross the 5 GB threshold(s), build a
+ * Telegram extraSection that warns the operator. Returns an empty string if
+ * the log is unreadable or contains no markers.
+ */
+async function buildDiskDiagnosticsExtraSection(logPath, { verbose = false, readFile = fs.readFile } = {}) {
+  if (!logPath) return '';
+  try {
+    const diskLib = await import('./solve.disk-diagnostics.lib.mjs');
+    const logText = await readFile(logPath, 'utf8');
+    const parsed = diskLib.parseDiskMarkers(logText);
+    if (!parsed.afterClone && !parsed.afterAgent) return '';
+    return diskLib.formatDiskDiagnosticsBlock(parsed);
+  } catch (error) {
+    if (verbose) {
+      console.log(`[VERBOSE] Could not inspect session log ${logPath} for disk diagnostics: ${error?.message || error}`);
+    }
+    return '';
+  }
+}
+
 function isNonIsolationSessionActive(sessionName, sessionInfo, verbose = false) {
   const startTime = sessionInfo.startTime instanceof Date ? sessionInfo.startTime : new Date(sessionInfo.startTime);
   const elapsed = Date.now() - startTime.getTime();
@@ -648,6 +670,20 @@ export async function monitorSessions(bot, verbose = false, options = {}) {
           }
         }
 
+        // Issue #1945: append a "💾 Disk usage" block (with warnings when the
+        // cloned repo, the delta during the run, or the total exceed 5 GB)
+        // parsed from the captured solve log markers.
+        const diskExtraSections = [];
+        try {
+          const diskLogPath = statusResult?.logPath || sessionInfo?.logPath || null;
+          const diskBlock = await buildDiskDiagnosticsExtraSection(diskLogPath, { verbose });
+          if (diskBlock) diskExtraSections.push(diskBlock);
+        } catch (diskError) {
+          if (verbose) {
+            console.log(`[VERBOSE] Could not build disk diagnostics section for ${sessionName}: ${diskError?.message || diskError}`);
+          }
+        }
+
         const message = formatSessionCompletionMessage({
           sessionName,
           sessionInfo,
@@ -656,7 +692,7 @@ export async function monitorSessions(bot, verbose = false, options = {}) {
           exitCode: finalExitCode,
           infoBlock: sessionInfo?.infoBlock || '',
           pullRequestUrl,
-          extraSections: [...limitsExtraSections, ...resumeExtraSections],
+          extraSections: [...limitsExtraSections, ...resumeExtraSections, ...diskExtraSections],
         });
 
         // Update the original reply message if messageId is available, otherwise send new message

package/src/solve.disk-diagnostics.lib.mjs

@@ -0,0 +1,342 @@
+/**
+ * Disk-space diagnostics for the `/solve` command (issue #1945).
+ *
+ * Captures two checkpoints around the AI working session:
+ *
+ *   1. AFTER_CLONE  — size of the freshly-cloned `tempDir` BEFORE the AI agent
+ *      starts. Tells us how large the repository itself is.
+ *   2. AFTER_AGENT  — size of the same `tempDir` AFTER the AI agent has
+ *      finished, so we can see how many bytes the working session added.
+ *
+ * Both checkpoints are written to the captured solve log as a single-line
+ * structured marker. The Telegram bot's `session-monitor.lib.mjs` parses those
+ * markers and, on the completion message, surfaces a Telegram block plus
+ * warnings when any of the three thresholds from the issue are crossed:
+ *
+ *   - cloned repository  > WARNING_THRESHOLD_BYTES
+ *   - delta during run   > WARNING_THRESHOLD_BYTES
+ *   - total space used   > WARNING_THRESHOLD_BYTES
+ *
+ * Implementation notes:
+ *
+ *   - Uses `du -sb <path>` on Linux for byte-accurate sizing, falls back to
+ *     `du -sk <path>` (kilobytes ×1024) on systems without GNU coreutils
+ *     (macOS BSD `du` doesn't support `-b`). A final fs.statSync fallback
+ *     keeps the helper non-throwing for plain files / inaccessible dirs.
+ *   - The marker format is deliberately ASCII and key=value so it survives
+ *     log truncation and stays parseable with a one-line regex. We DO NOT
+ *     emit JSON because the existing log is human-tailing-friendly and a
+ *     stray closing brace from another logger could confuse JSON.parse.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1945
+ */
+
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+
+/** 5 GB threshold (binary). Matches the issue body verbatim. */
+export const WARNING_THRESHOLD_BYTES = 5 * 1024 * 1024 * 1024;
+
+export const DISK_MARKER_PREFIX = '📊 [DISK]';
+export const DISK_PHASE_AFTER_CLONE = 'after_clone';
+export const DISK_PHASE_AFTER_AGENT = 'after_agent';
+
+/**
+ * Measure the size of a path in bytes. Robust to missing tools / paths.
+ *
+ * @param {string} targetPath
+ * @returns {number|null} Bytes, or null if the path is missing/unreadable.
+ */
+export function measureDirectorySize(targetPath) {
+  if (!targetPath) return null;
+  // Prefer `du -sb` (GNU coreutils) for byte-accurate sizing.
+  try {
+    const out = execFileSync('du', ['-sb', targetPath], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 60_000,
+      maxBuffer: 4 * 1024 * 1024,
+    }).trim();
+    const bytes = parseInt(out.split(/\s+/)[0], 10);
+    if (Number.isFinite(bytes) && bytes >= 0) return bytes;
+  } catch {
+    // Fall through to -sk fallback for BSD du / macOS.
+  }
+  // BSD `du` (macOS) doesn't support -b but does support -sk (kilobytes).
+  try {
+    const out = execFileSync('du', ['-sk', targetPath], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 60_000,
+      maxBuffer: 4 * 1024 * 1024,
+    }).trim();
+    const kb = parseInt(out.split(/\s+/)[0], 10);
+    if (Number.isFinite(kb) && kb >= 0) return kb * 1024;
+  } catch {
+    // Fall through to fs.statSync — last resort for single-file paths.
+  }
+  try {
+    const stat = fs.statSync(targetPath);
+    return stat.size;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Human-readable byte format. Two flavours:
+ *   - `formatBytes(bytes)`      → `"12.0 GB"` (matches limits.lib.mjs style)
+ *   - `formatBytesCompact(b)`   → `"12G"`   (matches the issue body verbatim
+ *     and cleanup.lib.mjs)
+ *
+ * @param {number|null|undefined} bytes
+ * @returns {string}
+ */
+export function formatBytes(bytes) {
+  if (bytes == null || Number.isNaN(bytes)) return '? B';
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ['KB', 'MB', 'GB', 'TB', 'PB'];
+  let value = bytes / 1024;
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit++;
+  }
+  // 1 decimal for GB and above (matches limits.lib formatBytes), none below.
+  const decimals = units[unit] === 'GB' || units[unit] === 'TB' || units[unit] === 'PB' ? 1 : 0;
+  return `${value.toFixed(decimals)} ${units[unit]}`;
+}
+
+/**
+ * Signed byte delta — adds a leading "+" for positive non-zero values so a
+ * growth like 500 MB renders as "+500 MB" in both logs and Telegram.
+ */
+export function formatBytesDelta(bytes) {
+  if (bytes == null || Number.isNaN(bytes)) return '? B';
+  if (bytes === 0) return '±0 B';
+  const sign = bytes > 0 ? '+' : '-';
+  return `${sign}${formatBytes(Math.abs(bytes))}`;
+}
+
+function escapeForMarker(value) {
+  // Strip newlines and the marker prefix so a path containing the literal
+  // "📊 [DISK]" cannot inject a fake marker. Paths almost never contain spaces
+  // in /tmp but we still quote with backticks for the human-readable suffix
+  // and use key=value pairs for the parseable head.
+  return String(value)
+    .replace(/[\r\n]+/g, ' ')
+    .slice(0, 2048);
+}
+
+/**
+ * Build a single-line structured log marker the parent (Telegram bot) can
+ * parse out of the captured log to surface size warnings.
+ *
+ * Example (after_clone):
+ *   📊 [DISK] phase=after_clone bytes=12884901888 path=/tmp/foo size=12.0 GB
+ *
+ * Example (after_agent):
+ *   📊 [DISK] phase=after_agent bytes=13312000000 deltaBytes=524288000 path=/tmp/foo size=12.4 GB delta=+500.0 MB
+ *
+ * @param {Object} params
+ * @param {string} params.phase  - 'after_clone' | 'after_agent'
+ * @param {number|null} params.bytes - Current size of tempDir in bytes
+ * @param {number|null} [params.deltaBytes] - Bytes added since after_clone (after_agent only)
+ * @param {string} params.path - The measured path
+ * @returns {string}
+ */
+export function buildDiskMarker({ phase, bytes, deltaBytes = null, path: targetPath }) {
+  const head = [`phase=${phase}`];
+  if (Number.isFinite(bytes)) head.push(`bytes=${bytes}`);
+  if (Number.isFinite(deltaBytes)) head.push(`deltaBytes=${deltaBytes}`);
+  head.push(`path=${escapeForMarker(targetPath || '')}`);
+  const suffixParts = [];
+  if (Number.isFinite(bytes)) suffixParts.push(`size=${formatBytes(bytes)}`);
+  if (Number.isFinite(deltaBytes)) suffixParts.push(`delta=${formatBytesDelta(deltaBytes)}`);
+  const suffix = suffixParts.length ? ` ${suffixParts.join(' ')}` : '';
+  return `${DISK_MARKER_PREFIX} ${head.join(' ')}${suffix}`;
+}
+
+/**
+ * Parse all `📊 [DISK]` markers out of a captured solve log. The LAST marker
+ * for each phase wins (sessions that restart can emit more than one).
+ *
+ * @param {string} logText
+ * @returns {{
+ *   afterClone: {bytes:number|null, path:string|null} | null,
+ *   afterAgent: {bytes:number|null, deltaBytes:number|null, path:string|null} | null
+ * }}
+ */
+export function parseDiskMarkers(logText) {
+  const result = { afterClone: null, afterAgent: null };
+  if (!logText || typeof logText !== 'string') return result;
+  // Anchor to the marker prefix so a quoted user comment containing this
+  // string mid-line is not mistakenly parsed.
+  const re = /📊 \[DISK\] ([^\n\r]+)/g;
+  let m;
+  while ((m = re.exec(logText)) !== null) {
+    const pairs = {};
+    // key=value tokens, where value runs until next " key=" or EOL.
+    const tokenRe = /(\w+)=([^\s][^\n\r]*?)(?=\s+\w+=|$)/g;
+    let t;
+    while ((t = tokenRe.exec(m[1])) !== null) {
+      pairs[t[1]] = t[2];
+    }
+    const phase = pairs.phase;
+    if (phase !== DISK_PHASE_AFTER_CLONE && phase !== DISK_PHASE_AFTER_AGENT) continue;
+    const bytes = parseInt(pairs.bytes, 10);
+    const deltaBytes = parseInt(pairs.deltaBytes, 10);
+    const entry = {
+      bytes: Number.isFinite(bytes) ? bytes : null,
+      path: pairs.path || null,
+    };
+    if (phase === DISK_PHASE_AFTER_AGENT) {
+      entry.deltaBytes = Number.isFinite(deltaBytes) ? deltaBytes : null;
+      result.afterAgent = entry;
+    } else {
+      result.afterClone = entry;
+    }
+  }
+  return result;
+}
+
+/**
+ * Decide which of the three issue thresholds were crossed.
+ *
+ * @param {{afterClone: object|null, afterAgent: object|null}} parsed
+ * @param {number} [threshold=WARNING_THRESHOLD_BYTES]
+ * @returns {{cloneTooLarge:boolean, deltaTooLarge:boolean, totalTooLarge:boolean}}
+ */
+export function computeDiskWarnings(parsed, threshold = WARNING_THRESHOLD_BYTES) {
+  const cloneBytes = parsed?.afterClone?.bytes ?? null;
+  const totalBytes = parsed?.afterAgent?.bytes ?? cloneBytes;
+  const deltaBytes = parsed?.afterAgent?.deltaBytes ?? null;
+  return {
+    cloneTooLarge: Number.isFinite(cloneBytes) && cloneBytes > threshold,
+    deltaTooLarge: Number.isFinite(deltaBytes) && deltaBytes > threshold,
+    totalTooLarge: Number.isFinite(totalBytes) && totalBytes > threshold,
+  };
+}
+
+/**
+ * Telegram block (Markdown code fence) describing the captured sizes plus,
+ * when any threshold is crossed, a `⚠️ Warnings:` tail. Returns an empty
+ * string when there are no markers in the log (no logs ⇒ no surprise output).
+ *
+ * Returned shape:
+ *
+ *   💾 Disk usage (gh-issue-solver-…)
+ *   ```
+ *   Cloned repository: 12.0 GB
+ *   After agent:       12.4 GB (+500.0 MB)
+ *   Threshold:         5.0 GB
+ *
+ *   ⚠️ Cloned repository exceeds 5.0 GB
+ *   ⚠️ Total disk usage exceeds 5.0 GB
+ *   ```
+ *
+ * @param {{afterClone: object|null, afterAgent: object|null}} parsed
+ * @param {Object} [options]
+ * @param {number} [options.threshold=WARNING_THRESHOLD_BYTES]
+ * @param {string} [options.title='💾 Disk usage']
+ * @returns {string}
+ */
+export function formatDiskDiagnosticsBlock(parsed, options = {}) {
+  if (!parsed || (!parsed.afterClone && !parsed.afterAgent)) return '';
+  const threshold = Number.isFinite(options.threshold) ? options.threshold : WARNING_THRESHOLD_BYTES;
+  const title = options.title || '💾 Disk usage';
+  const warnings = computeDiskWarnings(parsed, threshold);
+  const lines = [];
+  const cloneBytes = parsed.afterClone?.bytes ?? null;
+  const totalBytes = parsed.afterAgent?.bytes ?? null;
+  const deltaBytes = parsed.afterAgent?.deltaBytes ?? null;
+  if (cloneBytes !== null) {
+    lines.push(`Cloned repository: ${formatBytes(cloneBytes)}`);
+  }
+  if (totalBytes !== null) {
+    const deltaStr = deltaBytes !== null ? ` (${formatBytesDelta(deltaBytes)})` : '';
+    lines.push(`After agent:       ${formatBytes(totalBytes)}${deltaStr}`);
+  } else if (deltaBytes !== null) {
+    lines.push(`Delta during run:  ${formatBytesDelta(deltaBytes)}`);
+  }
+  lines.push(`Threshold:         ${formatBytes(threshold)}`);
+  const warningLines = [];
+  if (warnings.cloneTooLarge) warningLines.push(`⚠️ Cloned repository exceeds ${formatBytes(threshold)}`);
+  if (warnings.deltaTooLarge) warningLines.push(`⚠️ Folder grew by more than ${formatBytes(threshold)} during the run`);
+  if (warnings.totalTooLarge) warningLines.push(`⚠️ Total disk usage exceeds ${formatBytes(threshold)}`);
+  if (warningLines.length) {
+    lines.push('');
+    lines.push(...warningLines);
+  }
+  return `${title}\n\`\`\`\n${lines.join('\n')}\n\`\`\``;
+}
+
+/**
+ * Capture the AFTER_CLONE checkpoint and log it. Safe to call when `log`
+ * is missing; degrades to console.log so a CLI-only run still shows the size.
+ *
+ * Returns the captured size in bytes so the caller can stash it for the
+ * AFTER_AGENT delta calculation, or null if measurement failed.
+ *
+ * @param {Object} params
+ * @param {string} params.tempDir
+ * @param {Function} [params.log] - The bound `log` from solve.mjs
+ * @returns {Promise<number|null>}
+ */
+export async function recordAfterCloneSize({ tempDir, log }) {
+  const bytes = measureDirectorySize(tempDir);
+  const marker = buildDiskMarker({
+    phase: DISK_PHASE_AFTER_CLONE,
+    bytes,
+    path: tempDir,
+  });
+  if (log) {
+    await log(`\n${marker}`);
+  } else {
+    console.log(marker);
+  }
+  return bytes;
+}
+
+/**
+ * Capture the AFTER_AGENT checkpoint and log it (with delta versus the
+ * AFTER_CLONE checkpoint when available). Returns the captured size in bytes.
+ *
+ * @param {Object} params
+ * @param {string} params.tempDir
+ * @param {number|null} params.beforeBytes - The AFTER_CLONE size captured earlier
+ * @param {Function} [params.log]
+ * @returns {Promise<number|null>}
+ */
+export async function recordAfterAgentSize({ tempDir, beforeBytes, log }) {
+  const bytes = measureDirectorySize(tempDir);
+  const deltaBytes = Number.isFinite(bytes) && Number.isFinite(beforeBytes) ? bytes - beforeBytes : null;
+  const marker = buildDiskMarker({
+    phase: DISK_PHASE_AFTER_AGENT,
+    bytes,
+    deltaBytes,
+    path: tempDir,
+  });
+  if (log) {
+    await log(`\n${marker}`);
+  } else {
+    console.log(marker);
+  }
+  return bytes;
+}
+
+export default {
+  WARNING_THRESHOLD_BYTES,
+  DISK_MARKER_PREFIX,
+  DISK_PHASE_AFTER_CLONE,
+  DISK_PHASE_AFTER_AGENT,
+  measureDirectorySize,
+  formatBytes,
+  formatBytesDelta,
+  buildDiskMarker,
+  parseDiskMarkers,
+  computeDiskWarnings,
+  formatDiskDiagnosticsBlock,
+  recordAfterCloneSize,
+  recordAfterAgentSize,
+};

package/src/solve.mjs

@@ -55,6 +55,7 @@ const { configureWorkingSession, beginWorkingSession, endWorkingSession } = awai
 const getResourceSnapshot = memoryCheck.getResourceSnapshot;
 const { handleAutoPrCreation } = await import('./solve.auto-pr.lib.mjs');
 const { setupRepositoryAndClone, verifyDefaultBranchAndStatus } = await import('./solve.repo-setup.lib.mjs');
+const { recordAfterCloneSize, recordAfterAgentSize } = await import('./solve.disk-diagnostics.lib.mjs');
 const { createOrCheckoutBranch } = await import('./solve.branch.lib.mjs');
 const { startWorkSession, endWorkSession, SESSION_TYPES } = await import('./solve.session.lib.mjs');
 // Issue #1625: centralized markers + tracked comment posting for solve.mjs's
@@ -501,6 +502,8 @@ try {
     needsClone,
   });
 
+  cleanupContext.diskDiagnostics = { beforeBytes: await recordAfterCloneSize({ tempDir, log }) };
+
   // Verify default branch and status using the new module
   // Pass argv, owner, repo, issueUrl for empty repository auto-initialization (--auto-init-repository)
   const defaultBranch = await verifyDefaultBranchAndStatus({
@@ -814,6 +817,12 @@ try {
     toolResult = claudeResult;
   }
 
+  try {
+    await recordAfterAgentSize({ tempDir, beforeBytes: cleanupContext.diskDiagnostics?.beforeBytes ?? null, log });
+  } catch (diskError) {
+    await log(`⚠️  Disk-size measurement failed: ${cleanErrorMessage(diskError)}`, { level: 'warning', verbose: true });
+  }
+
   // Issue #1823: Mark the end of the AI working session. If a graceful-shutdown interrupt arrived
   // during the session (deferred by the working-session guard), honor it now: auto-commit any
   // uncommitted changes and exit gracefully — only AFTER the AI tool has fully finished its turn.