@link-assistant/hive-mind 2.0.28 → 2.1.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @link-assistant/hive-mind
 
+## 2.1.0
+
+### Minor Changes
+
+- 4e21d2a: Fix Docker task disk-usage reporting so Telegram completion messages use task container writable-layer samples instead of filesystem-capacity resource markers from the parent deployment.
+- fdbf448: Add full support for Claude Sonnet 5 (`claude-sonnet-5`) and make it the default model for `--tool claude`. The bare `sonnet` alias now resolves to `claude-sonnet-5` (previously `claude-sonnet-4-6`). Sonnet 5 supports 1M context (`[1m]`), the full effort ladder including `xhigh` and `max`, 128K max output tokens, and adaptive-thinking-only environment handling. The `sonnet-4-6`/`claude-sonnet-4-6` aliases are retained for backward compatibility. (Issue #2003)
+
+## 2.0.29
+
+### Patch Changes
+
+- 0cafc64: Add solve resource diagnostics and Docker disk-usage fallback markers so Telegram completion messages can show full container filesystem usage even when the task container cannot be inspected after exit.
+
 ## 2.0.28
 
 ### Patch Changes

package/package.json

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

package/src/bot-lifecycle.lib.mjs

@@ -12,6 +12,8 @@
  * @see https://github.com/link-assistant/hive-mind/issues/1927
  */
 
+import { RESOURCE_PHASE_BOT_HEARTBEAT, captureResourceSnapshot, summarizeResourceSnapshot } from './solve.resource-diagnostics.lib.mjs';
+
 const DEFAULT_HEARTBEAT_INTERVAL_MS = 60 * 1000;
 
 /**
@@ -26,14 +28,28 @@ const DEFAULT_HEARTBEAT_INTERVAL_MS = 60 * 1000;
  *
  * @returns {{ start: () => void, stop: () => void, beat: () => void, get timer(): any }}
  */
-export function createHeartbeat({ logger, getActiveSessionCount, intervalMs = DEFAULT_HEARTBEAT_INTERVAL_MS, processImpl = process, setIntervalImpl = setInterval, clearIntervalImpl = clearInterval } = {}) {
+export function createHeartbeat({ logger, getActiveSessionCount, intervalMs = DEFAULT_HEARTBEAT_INTERVAL_MS, processImpl = process, setIntervalImpl = setInterval, clearIntervalImpl = clearInterval, captureResources = captureResourceSnapshot, resourceDiskPath = '/' } = {}) {
   let timer = null;
 
   const beat = () => {
     try {
+      let resources = null;
+      try {
+        if (typeof captureResources === 'function') {
+          resources = summarizeResourceSnapshot(
+            captureResources({
+              phase: RESOURCE_PHASE_BOT_HEARTBEAT,
+              diskPath: resourceDiskPath,
+            })
+          );
+        }
+      } catch {
+        resources = null;
+      }
       logger.heartbeat({
         activeSessions: typeof getActiveSessionCount === 'function' ? getActiveSessionCount(false) : undefined,
         uptimeSec: Math.floor(processImpl.uptime()),
+        resources,
       });
     } catch {
       /* heartbeat must never crash the bot */

package/src/config.lib.mjs

@@ -266,6 +266,22 @@ const isSonnet46OrLater = model => {
   return m === 'sonnet' || m === 'sonnet-4-6' || m.includes('sonnet-4-6') || m.includes('sonnet-5');
 };
 
+/**
+ * Check if a model is Claude Sonnet 5 (Issue #2003)
+ * Sonnet 5 (`claude-sonnet-5`) is the current default for `--tool claude` (the bare
+ * `sonnet` alias now resolves to it). Unlike Sonnet 4.6 it supports the `xhigh` effort
+ * level, up to 128k output tokens, and uses adaptive thinking only (extended/manual
+ * thinking with an explicit budget is unavailable), matching the Fable/Mythos 5 API
+ * constraints. See: https://www.anthropic.com/news/claude-sonnet-5
+ * @param {string} model - The model name or ID
+ * @returns {boolean} True if the model is Claude Sonnet 5
+ */
+export const isSonnet5 = model => {
+  if (!model) return false;
+  const m = model.toLowerCase();
+  return m === 'sonnet' || m === 'sonnet-5' || m.includes('sonnet-5');
+};
+
 const isMythosPreview = model => {
   if (!model) return false;
   return model.toLowerCase().includes('mythos');
@@ -328,11 +344,11 @@ export const supportsEffortLevel = model => {
 /**
  * Check if a model supports the xhigh effort level.
  * Official docs list xhigh for Claude Fable 5, Claude Mythos 5, Claude Opus 4.7,
- * and Opus 4.8 (Issue #1832, Issue #1875).
+ * Opus 4.8, and Sonnet 5 (Issue #1832, Issue #1875, Issue #2003).
  * @param {string} model - The model name or ID
  * @returns {boolean} True if the model supports xhigh effort
  */
-export const supportsXHighEffortLevel = model => isFable5OrMythos5(model) || isOpus47(model);
+export const supportsXHighEffortLevel = model => isFable5OrMythos5(model) || isOpus47(model) || isSonnet5(model);
 
 /**
  * Check if a model supports the max effort level.
@@ -344,14 +360,14 @@ export const supportsXHighEffortLevel = model => isFable5OrMythos5(model) || isO
 export const supportsMaxEffortLevel = model => isFable5OrMythos5(model) || isMythosPreview(model) || isOpus47OrLater(model) || isOpus46(model) || isSonnet46OrLater(model);
 
 /**
- * Get the max output tokens for a specific model (Issue #1221, Issue #1875)
- * Claude Fable 5 and Claude Mythos 5 support up to 128k output tokens, matching
- * the Opus 4.6+ ceiling.
+ * Get the max output tokens for a specific model (Issue #1221, Issue #1875, Issue #2003)
+ * Claude Fable 5, Claude Mythos 5, and Claude Sonnet 5 support up to 128k output tokens,
+ * matching the Opus 4.6+ ceiling.
  * @param {string} model - The model name or ID
  * @returns {number} The max output tokens for the model
  */
 export const getMaxOutputTokensForModel = model => {
-  if (isOpus46OrLater(model) || isFable5OrMythos5(model)) {
+  if (isOpus46OrLater(model) || isFable5OrMythos5(model) || isSonnet5(model)) {
     return claudeCode.maxOutputTokensOpus46;
   }
   return claudeCode.maxOutputTokens;
@@ -564,12 +580,12 @@ export const getClaudeEnv = (options = {}) => {
 
   // Opus 4.7+ always uses adaptive thinking — MAX_THINKING_TOKENS has no effect (Issue #1620, Issue #1832)
   // Opus 4.8 inherits this constraint: adaptive thinking is the only thinking mode.
-  // Claude Fable 5 and Claude Mythos 5 are adaptive-thinking-only too: extended/manual
-  // thinking is unavailable and `thinking: {type: "disabled"}` is rejected, so a
-  // MAX_THINKING_TOKENS=0 would be invalid for them (Issue #1875).
+  // Claude Fable 5, Claude Mythos 5, and Claude Sonnet 5 are adaptive-thinking-only too:
+  // extended/manual thinking is unavailable and `thinking: {type: "disabled"}` is rejected,
+  // so a MAX_THINKING_TOKENS=0 would be invalid for them (Issue #1875, Issue #2003).
   // For Opus 4.6 and earlier, MAX_THINKING_TOKENS controls extended thinking (Claude Code >= 2.1.12)
   // Default is 0 (thinking disabled) per Issue #1238.
-  const adaptiveThinkingOnly = options.model && (isOpus47OrLater(options.model) || isFable5OrMythos5(options.model));
+  const adaptiveThinkingOnly = options.model && (isOpus47OrLater(options.model) || isFable5OrMythos5(options.model) || isSonnet5(options.model));
   if (adaptiveThinkingOnly) {
     // Remove any inherited MAX_THINKING_TOKENS from process.env — these models ignore it
     delete env.MAX_THINKING_TOKENS;

package/src/models/index.mjs

@@ -29,10 +29,10 @@ const execFileAsync = promisify(execFile);
 // ─── MODEL DATA ──────────────────────────────────────────────────────────────
 
 // Claude models (Anthropic API)
-// Updated for Opus 4.5/4.6/4.7/4.8, Sonnet 4.6, and Fable 5 / Mythos 5 support
-// (Issue #1221, Issue #1238, Issue #1329, Issue #1433, Issue #1620, Issue #1832, Issue #1875)
+// Updated for Opus 4.5/4.6/4.7/4.8, Sonnet 4.6/5, and Fable 5 / Mythos 5 support
+// (Issue #1221, Issue #1238, Issue #1329, Issue #1433, Issue #1620, Issue #1832, Issue #1875, Issue #2003)
 export const claudeModels = {
-  sonnet: 'claude-sonnet-4-6', // Sonnet 4.6 (default, Issue #1329)
+  sonnet: 'claude-sonnet-5', // Sonnet 5 (default, Issue #2003)
   opus: 'claude-opus-4-8', // Opus 4.8 (Issue #1832)
   haiku: 'claude-haiku-4-5-20251001', // Haiku 4.5
   'haiku-3-5': 'claude-3-5-haiku-20241022', // Haiku 3.5
@@ -46,6 +46,7 @@ export const claudeModels = {
   'mythos-5': 'claude-mythos-5', // Mythos 5 short alias
   'claude-mythos-5': 'claude-mythos-5', // Mythos 5 full ID
   // Shorter version aliases (Issue #1221, Issue #1329 - PR comment feedback)
+  'sonnet-5': 'claude-sonnet-5', // Sonnet 5 short alias (Issue #2003)
   'sonnet-4-6': 'claude-sonnet-4-6', // Sonnet 4.6 short alias (Issue #1329)
   'opus-4-8': 'claude-opus-4-8', // Opus 4.8 short alias (Issue #1832)
   'opus-4-7': 'claude-opus-4-7', // Opus 4.7 short alias (backward compatibility)
@@ -56,6 +57,7 @@ export const claudeModels = {
   // Version aliases for backward compatibility (Issue #1221, Issue #1329, Issue #1620, Issue #1832)
   'claude-opus-4-8': 'claude-opus-4-8', // Opus 4.8 (Issue #1832)
   'claude-opus-4-7': 'claude-opus-4-7', // Opus 4.7 (backward compatibility)
+  'claude-sonnet-5': 'claude-sonnet-5', // Sonnet 5 (Issue #2003)
   'claude-sonnet-4-6': 'claude-sonnet-4-6', // Sonnet 4.6 (Issue #1329)
   'claude-opus-4-6': 'claude-opus-4-6', // Opus 4.6 (backward compatibility)
   'claude-opus-4-5': 'claude-opus-4-5-20251101', // Opus 4.5
@@ -207,10 +209,12 @@ export const MODELS_SUPPORTING_1M_CONTEXT = [
   'claude-opus-4-7', // Opus 4.7 (Issue #1620)
   'claude-opus-4-6',
   'claude-opus-4-5-20251101',
+  'claude-sonnet-5', // Sonnet 5 — 1M context (Issue #2003)
   'claude-sonnet-4-6', // Sonnet 4.6 (Issue #1329)
   'claude-sonnet-4-5-20250929',
   'claude-sonnet-4-5',
-  'sonnet', // Now maps to Sonnet 4.6 (Issue #1329)
+  'sonnet', // Now maps to Sonnet 5 (Issue #2003)
+  'sonnet-5', // Short alias (Issue #2003)
   'sonnet-4-6', // Short alias (Issue #1329)
   'opus', // Now maps to Opus 4.8 (Issue #1832)
   'opus-4-8', // Short alias (Issue #1832)
@@ -1148,6 +1152,8 @@ export const defaultFallbackModels = {
     'claude-mythos-5': 'fable',
     'claude-opus-4-8': 'opus-4-7',
     'claude-opus-4-7': 'opus-4-6',
+    // Claude Sonnet 5 falls back to the prior Sonnet generation (Issue #2003).
+    'claude-sonnet-5': 'sonnet-4-6',
   },
   codex: {
     'gpt-5.6-sol': 'gpt-5.5',

package/src/session-monitor.lib.mjs

@@ -193,6 +193,15 @@ function isPersistableSession(sessionInfo) {
   return Boolean(sessionInfo?.isolationBackend && sessionInfo?.sessionId);
 }
 
+function persistSessionSnapshot(sessionName, sessionInfo) {
+  if (!sessionStore || !isPersistableSession(sessionInfo)) return;
+  try {
+    sessionStore.persist(sessionName, sessionInfo);
+  } catch {
+    /* best effort — persistence must never break monitoring */
+  }
+}
+
 /**
  * Look up the in-memory record for a session id (UUID for isolation sessions
  * or the screen session name for non-isolation sessions). Returns null when no
@@ -343,7 +352,7 @@ async function resolvePullRequestUrlFromSessionLog(logPath, ctx, { verbose = fal
  * build the Telegram extraSection. Returns an empty string if there is no
  * repository or docker filesystem data to show.
  */
-async function buildDiskDiagnosticsExtraSection(logPath, { verbose = false, readFile = fs.readFile, isolationBackend = null, containerFilesystemStartBytes = null, containerFilesystemAfterBytes = null } = {}) {
+export async function buildDiskDiagnosticsExtraSection(logPath, { verbose = false, readFile = fs.readFile, isolationBackend = null, containerFilesystemStartBytes = null, containerFilesystemAfterBytes = null } = {}) {
   if (!logPath && !Number.isFinite(containerFilesystemStartBytes) && !Number.isFinite(containerFilesystemAfterBytes)) return '';
   try {
     const diskLib = await import('./solve.disk-diagnostics.lib.mjs');
@@ -392,6 +401,19 @@ async function getDockerContainerFilesystemSizeForSession(sessionName, sessionIn
   }
 }
 
+async function refreshDockerContainerFilesystemSizeForSession(sessionName, sessionInfo, { verbose = false, sizeProvider = null } = {}) {
+  const bytes = await getDockerContainerFilesystemSizeForSession(sessionName, sessionInfo, { verbose, sizeProvider });
+  if (!Number.isFinite(bytes)) return null;
+  sessionInfo.containerFilesystemLastBytes = bytes;
+  sessionInfo.containerFilesystemLastObservedAt = new Date().toISOString();
+  persistSessionSnapshot(sessionName, sessionInfo);
+  return bytes;
+}
+
+function getLastKnownDockerContainerFilesystemSize(sessionInfo) {
+  return Number.isFinite(sessionInfo?.containerFilesystemLastBytes) ? sessionInfo.containerFilesystemLastBytes : null;
+}
+
 function isSuccessfulTaskCompletion({ exitCode = null, status = null } = {}) {
   const outcome = classifySessionOutcome({ exitCode, status });
   if (outcome.failed) return false;
@@ -657,6 +679,7 @@ export async function monitorSessions(bot, verbose = false, options = {}) {
     let exitCode = null;
     let statusResult = null;
     let resolvedStatus = null;
+    let observedContainerFilesystemBytes = null;
 
     if (sessionInfo.isolationBackend && sessionInfo.sessionId) {
       // Isolation mode: use $ --status, with screen -ls only as a fallback
@@ -682,13 +705,7 @@ export async function monitorSessions(bot, verbose = false, options = {}) {
       // the log footer to learn whether it was killed.
       if (statusResult?.logPath && sessionInfo.logPath !== statusResult.logPath) {
         sessionInfo.logPath = statusResult.logPath;
-        if (sessionStore) {
-          try {
-            sessionStore.persist(sessionName, sessionInfo);
-          } catch {
-            /* best effort — persistence must never break monitoring */
-          }
-        }
+        persistSessionSnapshot(sessionName, sessionInfo);
       }
     } else {
       // Issue #1586: Non-isolation screen sessions cannot reliably detect
@@ -710,6 +727,13 @@ export async function monitorSessions(bot, verbose = false, options = {}) {
       }
     }
 
+    if (sessionInfo?.isolationBackend === 'docker') {
+      observedContainerFilesystemBytes = await refreshDockerContainerFilesystemSizeForSession(sessionName, sessionInfo, {
+        verbose,
+        sizeProvider: options.dockerContainerSizeProvider,
+      });
+    }
+
     if (!stillRunning) {
       console.log(`Session ${sessionName} has finished. Sending notification to chat ${sessionInfo.chatId}`);
 
@@ -821,10 +845,7 @@ export async function monitorSessions(bot, verbose = false, options = {}) {
         const diskExtraSections = [];
         try {
           const diskLogPath = statusResult?.logPath || sessionInfo?.logPath || null;
-          const containerFilesystemAfterBytes = await getDockerContainerFilesystemSizeForSession(sessionName, sessionInfo, {
-            verbose,
-            sizeProvider: options.dockerContainerSizeProvider,
-          });
+          const containerFilesystemAfterBytes = Number.isFinite(observedContainerFilesystemBytes) ? observedContainerFilesystemBytes : getLastKnownDockerContainerFilesystemSize(sessionInfo);
           const diskBlock = await buildDiskDiagnosticsExtraSection(diskLogPath, {
             verbose,
             readFile: options.readFile,

package/src/session-store.lib.mjs

@@ -33,7 +33,7 @@ import path from 'node:path';
 // excluded so the snapshot stays small and safe to reload.
 // `args` (#1927 review follow-up) is persisted so a killed /solve can be resumed
 // with its exact original invocation plus `--resume <lastSessionId>`.
-const PERSISTABLE_FIELDS = ['chatId', 'messageId', 'startTime', 'url', 'command', 'isolationBackend', 'sessionId', 'containerFilesystemStartBytes', 'tool', 'infoBlock', 'urlContext', 'requesterUserId', 'showLimits', 'locale', 'logPath', 'args'];
+const PERSISTABLE_FIELDS = ['chatId', 'messageId', 'startTime', 'url', 'command', 'isolationBackend', 'sessionId', 'containerFilesystemStartBytes', 'containerFilesystemLastBytes', 'containerFilesystemLastObservedAt', 'tool', 'infoBlock', 'urlContext', 'requesterUserId', 'showLimits', 'locale', 'logPath', 'args'];
 
 /**
  * Resolve the directory durable bot state is written to. Honors

package/src/solve.config.lib.mjs

@@ -299,7 +299,7 @@ export const SOLVE_OPTION_DEFINITIONS = {
   },
   think: {
     type: 'string',
-    description: 'Thinking level hint. For Claude, translated to --thinking-budget for Claude Code >= 2.1.12 (off=0, low=~8000, medium=~16000, high=~24000, xhigh/max=31999) and to CLAUDE_CODE_EFFORT_LEVEL when supported. Fable 5/Mythos 5/Opus 4.8/4.7 support xhigh and max; Opus 4.6/Sonnet 4.6/Mythos Preview support max; Opus 4.5 uses high for xhigh/max. For Codex, mapped to reasoning effort (off=none, low=low, medium=medium, high=high, xhigh/max=xhigh).',
+    description: 'Thinking level hint. For Claude, translated to --thinking-budget for Claude Code >= 2.1.12 (off=0, low=~8000, medium=~16000, high=~24000, xhigh/max=31999) and to CLAUDE_CODE_EFFORT_LEVEL when supported. Fable 5/Mythos 5/Sonnet 5/Opus 4.8/4.7 support xhigh and max; Opus 4.6/Sonnet 4.6/Mythos Preview support max; Opus 4.5 uses high for xhigh/max. For Codex, mapped to reasoning effort (off=none, low=low, medium=medium, high=high, xhigh/max=xhigh).',
     choices: ['off', 'low', 'medium', 'high', 'xhigh', 'max'],
     default: undefined,
   },

package/src/solve.escalate.lib.mjs

@@ -72,8 +72,10 @@ const TIER_ALIASES = {
   'claude-haiku-4-5': 'haiku',
   'claude-haiku-4-5-20251001': 'haiku',
   sonnet: 'sonnet',
+  'sonnet-5': 'sonnet',
   'sonnet-4-6': 'sonnet',
   'sonnet-4-5': 'sonnet',
+  'claude-sonnet-5': 'sonnet',
   'claude-sonnet-4-6': 'sonnet',
   'claude-sonnet-4-5': 'sonnet',
   opus: 'opus',

package/src/solve.mjs

@@ -49,7 +49,8 @@ const { runKeepWorkingUntilDone } = await import('./solve.keep-working.lib.mjs')
 const { runEscalation } = await import('./solve.escalate.lib.mjs');
 const { finalizeSolveProcess } = await import('./solve.finalize.lib.mjs');
 const exitHandler = await import('./exit-handler.lib.mjs');
-const { initializeExitHandler, installGlobalExitHandlers, safeExit, logActiveHandles } = exitHandler;
+const { initializeExitHandler, installGlobalExitHandlers, safeExit: baseSafeExit, logActiveHandles } = exitHandler;
+const { RESOURCE_PHASE_AFTER_AGENT, RESOURCE_PHASE_AFTER_CLONE, RESOURCE_PHASE_SOLVE_EXIT, RESOURCE_PHASE_SOLVE_START, recordResourceSnapshot } = await import('./solve.resource-diagnostics.lib.mjs');
 const { createInterruptWrapper } = await import('./solve.interrupt.lib.mjs');
 // Issue #1823: working-session guard for --do-not-shutdown-in-the-middle-of-working-session.
 const { configureWorkingSession, beginWorkingSession, endWorkingSession } = await import('./working-session.lib.mjs');
@@ -69,9 +70,7 @@ const { prepareFeedbackAndTimestamps, checkUncommittedChanges, checkForkActions
 const { validateAndExitOnInvalidClaudeSubAgentModel, validateAndExitOnInvalidModel } = await import('./models/index.mjs');
 const { autoAcceptInviteForRepo } = await import('./solve.accept-invite.lib.mjs');
 const { handleAutoForkOption, handleMaintainerForkAccess } = await import('./solve.fork-detection.lib.mjs');
-// Initialize log file early (before argument parsing) to capture all output
 const logFile = await initializeLogFile(null);
-// Log version and raw command IMMEDIATELY after log file initialization
 const versionInfo = await getVersionInfo();
 await log('');
 await log(`🚀 solve v${versionInfo}`);
@@ -80,6 +79,15 @@ await log('🔧 Raw command executed:');
 await log(`   ${rawCommand}`);
 await log('');
 
+let finalResourceSnapshotRecorded = false;
+const safeExit = async (code = 0, reason = 'Process completed', options = {}) => {
+  if (!finalResourceSnapshotRecorded) {
+    finalResourceSnapshotRecorded = true;
+    await recordResourceSnapshot({ phase: RESOURCE_PHASE_SOLVE_EXIT, log, diskPath: '/', label: `solve exit ${code}` });
+  }
+  return await baseSafeExit(code, reason, options);
+};
+
 let argv;
 try {
   argv = await parseArguments(yargs, hideBin);
@@ -98,6 +106,7 @@ configureGitHubRateLimitLogging({
   enabled: argv.githubRateLimitsLogging === true,
   log,
 });
+await recordResourceSnapshot({ phase: RESOURCE_PHASE_SOLVE_START, log, diskPath: '/', label: 'solve start', logExecutionContext: true }); // #2001: detect+report container context
 
 // Early logs go to cwd; custom log dir takes effect after argv is parsed
 // Conditionally import tool-specific functions after argv is parsed
@@ -507,6 +516,7 @@ try {
   });
 
   cleanupContext.diskDiagnostics = { beforeBytes: await recordAfterCloneSize({ tempDir, log }) };
+  await recordResourceSnapshot({ phase: RESOURCE_PHASE_AFTER_CLONE, log, diskPath: '/', label: 'after repository clone' });
 
   // Verify default branch and status using the new module
   // Pass argv, owner, repo, issueUrl for empty repository auto-initialization (--auto-init-repository)
@@ -830,6 +840,7 @@ try {
   } catch (diskError) {
     await log(`⚠️  Disk-size measurement failed: ${cleanErrorMessage(diskError)}`, { level: 'warning', verbose: true });
   }
+  await recordResourceSnapshot({ phase: RESOURCE_PHASE_AFTER_AGENT, log, diskPath: '/', label: 'after AI execution' });
 
   // 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

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

@@ -0,0 +1,435 @@
+import fs from 'node:fs';
+import os from 'node:os';
+
+export const RESOURCE_MARKER_PREFIX = '📈 [RESOURCES]';
+
+export const RESOURCE_PHASE_SOLVE_START = 'solve_start';
+export const RESOURCE_PHASE_AFTER_CLONE = 'after_clone';
+export const RESOURCE_PHASE_AFTER_AGENT = 'after_agent';
+export const RESOURCE_PHASE_SOLVE_EXIT = 'solve_exit';
+export const RESOURCE_PHASE_RESTART_BEFORE = 'restart_before';
+export const RESOURCE_PHASE_RESTART_AFTER = 'restart_after';
+export const RESOURCE_PHASE_BOT_HEARTBEAT = 'bot_heartbeat';
+
+const RESOURCE_PHASES_BY_PREFERENCE = [RESOURCE_PHASE_SOLVE_EXIT, RESOURCE_PHASE_AFTER_AGENT, RESOURCE_PHASE_RESTART_AFTER, RESOURCE_PHASE_AFTER_CLONE, RESOURCE_PHASE_SOLVE_START, RESOURCE_PHASE_RESTART_BEFORE];
+
+function finiteNumber(value) {
+  return Number.isFinite(value) ? value : null;
+}
+
+function clampPercent(value) {
+  if (!Number.isFinite(value)) return null;
+  return Math.max(0, Math.min(100, value));
+}
+
+function readLinuxMemAvailableBytes(readFileSync = fs.readFileSync, platform = process.platform) {
+  if (platform !== 'linux') return null;
+  try {
+    const text = readFileSync('/proc/meminfo', 'utf8');
+    const match = text.match(/^MemAvailable:\s+(\d+)\s+kB$/m);
+    if (!match) return null;
+    return Number.parseInt(match[1], 10) * 1024;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Detect where the current process is running so the solve command can scope
+ * per-task disk usage to the correct context (issue #2001).
+ *
+ * When solve runs inside a Docker/container isolation backend, the per-task
+ * disk measurement must come from container-scoped signals (the cloned working
+ * tree measured with `du` inside the container, plus the host-side
+ * `docker inspect --size` writable-layer size) rather than the whole-VM
+ * filesystem reported by `statfs('/')`. This helper makes that detection
+ * explicit and observable in the solve log.
+ *
+ * It is intentionally defensive: any injected `existsSync`/`readFileSync`
+ * implementation that lacks a method or throws is treated as "signal absent"
+ * rather than propagating an error, so callers never crash on detection.
+ *
+ * @returns {{ inContainer: boolean, runtime: string|null, indicators: string[] }}
+ */
+export function detectExecutionContext(options = {}) {
+  const { existsSync = fs.existsSync, readFileSync = fs.readFileSync, env = process.env, platform = process.platform } = options;
+
+  const indicators = [];
+  let runtime = null;
+
+  const safeExists = target => {
+    try {
+      return typeof existsSync === 'function' ? existsSync(target) === true : false;
+    } catch {
+      return false;
+    }
+  };
+
+  const safeRead = target => {
+    try {
+      return typeof readFileSync === 'function' ? String(readFileSync(target, 'utf8')) : '';
+    } catch {
+      return '';
+    }
+  };
+
+  if (safeExists('/.dockerenv')) {
+    indicators.push('/.dockerenv');
+    runtime = runtime || 'docker';
+  }
+  if (safeExists('/run/.containerenv')) {
+    indicators.push('/run/.containerenv');
+    runtime = runtime || 'podman';
+  }
+
+  if (platform === 'linux') {
+    const cgroup = safeRead('/proc/1/cgroup');
+    if (cgroup) {
+      if (/\bdocker\b/.test(cgroup)) {
+        indicators.push('cgroup:docker');
+        runtime = runtime || 'docker';
+      }
+      if (/kubepods/.test(cgroup)) {
+        indicators.push('cgroup:kubepods');
+        runtime = runtime || 'kubernetes';
+      }
+      if (/libpod|podman/.test(cgroup)) {
+        indicators.push('cgroup:podman');
+        runtime = runtime || 'podman';
+      }
+      if (/containerd/.test(cgroup)) {
+        indicators.push('cgroup:containerd');
+        runtime = runtime || 'containerd';
+      }
+    }
+  }
+
+  const envObj = env && typeof env === 'object' ? env : {};
+  if (envObj.HIVE_MIND_ISOLATION || envObj.HIVE_MIND_CONTAINER) {
+    indicators.push('env:hive-mind-isolation');
+    runtime = runtime || 'container';
+  }
+  if (envObj.KUBERNETES_SERVICE_HOST) {
+    indicators.push('env:kubernetes');
+    runtime = runtime || 'kubernetes';
+  }
+
+  return {
+    inContainer: indicators.length > 0,
+    runtime,
+    indicators,
+  };
+}
+
+/**
+ * Human-readable one-liner describing the detected execution context, used to
+ * make the disk-usage scope explicit in the solve log.
+ *
+ * @param {ReturnType<typeof detectExecutionContext>} context
+ * @returns {string}
+ */
+export function formatExecutionContextForLog(context) {
+  const ctx = context || detectExecutionContext();
+  if (ctx.inContainer) {
+    const runtime = ctx.runtime || 'container';
+    const detail = ctx.indicators.length ? ` (indicators: ${ctx.indicators.join(', ')})` : '';
+    return `🧭 Execution context: ${runtime} container${detail} — per-task disk usage is scoped to this container.`;
+  }
+  return '🧭 Execution context: host (no container isolation detected) — per-task disk usage is scoped to the working tree.';
+}
+
+export function captureResourceSnapshot(options = {}) {
+  const { phase = 'snapshot', diskPath = '/', now = () => new Date(), osImpl = os, fsImpl = fs, processImpl = process } = options;
+
+  const timestamp = (() => {
+    try {
+      return now().toISOString();
+    } catch {
+      return new Date().toISOString();
+    }
+  })();
+
+  const load = (() => {
+    try {
+      const values = osImpl.loadavg();
+      return {
+        load1: finiteNumber(values[0]),
+        load5: finiteNumber(values[1]),
+        load15: finiteNumber(values[2]),
+      };
+    } catch {
+      return { load1: null, load5: null, load15: null };
+    }
+  })();
+
+  const cpuCount = (() => {
+    try {
+      const cpus = osImpl.cpus();
+      return Array.isArray(cpus) ? cpus.length : null;
+    } catch {
+      return null;
+    }
+  })();
+
+  const totalMemoryBytes = (() => {
+    try {
+      return finiteNumber(osImpl.totalmem());
+    } catch {
+      return null;
+    }
+  })();
+
+  const freeMemoryBytes = (() => {
+    try {
+      return finiteNumber(osImpl.freemem());
+    } catch {
+      return null;
+    }
+  })();
+
+  const availableMemoryBytes = readLinuxMemAvailableBytes(fsImpl.readFileSync?.bind(fsImpl), processImpl.platform || process.platform) ?? freeMemoryBytes;
+  const usedMemoryBytes = totalMemoryBytes !== null && availableMemoryBytes !== null ? Math.max(0, totalMemoryBytes - availableMemoryBytes) : null;
+
+  const processMemory = (() => {
+    try {
+      const usage = processImpl.memoryUsage();
+      return {
+        rssBytes: finiteNumber(usage.rss),
+        heapUsedBytes: finiteNumber(usage.heapUsed),
+      };
+    } catch {
+      return { rssBytes: null, heapUsedBytes: null };
+    }
+  })();
+
+  const disk = (() => {
+    const path = String(diskPath || '/');
+    try {
+      if (typeof fsImpl.statfsSync !== 'function') {
+        return { path, totalBytes: null, freeBytes: null, availableBytes: null, usedBytes: null, usedPercent: null, error: 'statfs unavailable' };
+      }
+      const stat = fsImpl.statfsSync(path);
+      const blockSize = Number(stat.bsize || stat.frsize || 0);
+      const blocks = Number(stat.blocks);
+      const bfree = Number(stat.bfree);
+      const bavail = Number(stat.bavail);
+      const totalBytes = Number.isFinite(blockSize) && Number.isFinite(blocks) ? blockSize * blocks : null;
+      const freeBytes = Number.isFinite(blockSize) && Number.isFinite(bfree) ? blockSize * bfree : null;
+      const availableBytes = Number.isFinite(blockSize) && Number.isFinite(bavail) ? blockSize * bavail : freeBytes;
+      const usedBytes = totalBytes !== null && freeBytes !== null ? Math.max(0, totalBytes - freeBytes) : null;
+      const usedPercent = totalBytes && usedBytes !== null ? clampPercent((usedBytes / totalBytes) * 100) : null;
+      return { path, totalBytes, freeBytes, availableBytes, usedBytes, usedPercent, error: null };
+    } catch (error) {
+      return {
+        path,
+        totalBytes: null,
+        freeBytes: null,
+        availableBytes: null,
+        usedBytes: null,
+        usedPercent: null,
+        error: error?.message || String(error),
+      };
+    }
+  })();
+
+  return {
+    phase: String(phase || 'snapshot'),
+    timestamp,
+    cpu: { ...load, cpuCount },
+    memory: {
+      totalBytes: totalMemoryBytes,
+      freeBytes: freeMemoryBytes,
+      availableBytes: availableMemoryBytes,
+      usedBytes: usedMemoryBytes,
+      processRssBytes: processMemory.rssBytes,
+      processHeapUsedBytes: processMemory.heapUsedBytes,
+    },
+    disk,
+  };
+}
+
+export function formatBytes(bytes) {
+  if (!Number.isFinite(bytes)) return '? B';
+  const abs = Math.abs(bytes);
+  if (abs >= 1024 ** 3) return `${(bytes / 1024 ** 3).toFixed(1)} GB`;
+  if (abs >= 1024 ** 2) return `${Math.round(bytes / 1024 ** 2)} MB`;
+  if (abs >= 1024) return `${Math.round(bytes / 1024)} KB`;
+  return `${Math.round(bytes)} B`;
+}
+
+function formatNumber(value, decimals = 2) {
+  return Number.isFinite(value) ? value.toFixed(decimals) : '?';
+}
+
+function encodeValue(value) {
+  if (value === null || value === undefined) return 'null';
+  return encodeURIComponent(String(value));
+}
+
+function numberField(name, value) {
+  return Number.isFinite(value) ? `${name}=${value}` : `${name}=null`;
+}
+
+export function buildResourceMarker(snapshot) {
+  const s = snapshot || {};
+  const cpu = s.cpu || {};
+  const memory = s.memory || {};
+  const disk = s.disk || {};
+  return [
+    RESOURCE_MARKER_PREFIX,
+    `phase=${encodeValue(s.phase || 'snapshot')}`,
+    `ts=${encodeValue(s.timestamp || new Date().toISOString())}`,
+    numberField('load1', cpu.load1),
+    numberField('load5', cpu.load5),
+    numberField('load15', cpu.load15),
+    numberField('cpuCount', cpu.cpuCount),
+    numberField('memTotalBytes', memory.totalBytes),
+    numberField('memAvailableBytes', memory.availableBytes),
+    numberField('memUsedBytes', memory.usedBytes),
+    numberField('processRssBytes', memory.processRssBytes),
+    `diskPath=${encodeValue(disk.path || '/')}`,
+    numberField('diskTotalBytes', disk.totalBytes),
+    numberField('diskAvailableBytes', disk.availableBytes),
+    numberField('diskUsedBytes', disk.usedBytes),
+    numberField('diskUsedPercent', disk.usedPercent),
+    disk.error ? `error=${encodeValue(disk.error)}` : null,
+    `mem=${encodeValue(`${formatBytes(memory.availableBytes)} available / ${formatBytes(memory.totalBytes)} total`)}`,
+    `disk=${encodeValue(`${formatBytes(disk.availableBytes)} available / ${formatBytes(disk.totalBytes)} total`)}`,
+  ]
+    .filter(Boolean)
+    .join(' ');
+}
+
+function parseNumber(value) {
+  if (value === 'null' || value === undefined) return null;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+
+function parseMarkerLine(line) {
+  const idx = line.indexOf(RESOURCE_MARKER_PREFIX);
+  if (idx < 0) return null;
+  const payload = line.slice(idx + RESOURCE_MARKER_PREFIX.length).trim();
+  const parts = payload.split(/\s+/).filter(Boolean);
+  const fields = {};
+  for (const part of parts) {
+    const eq = part.indexOf('=');
+    if (eq <= 0) continue;
+    fields[part.slice(0, eq)] = part.slice(eq + 1);
+  }
+  const phase = decodeURIComponent(fields.phase || 'snapshot');
+  return {
+    phase,
+    timestamp: decodeURIComponent(fields.ts || ''),
+    cpu: {
+      load1: parseNumber(fields.load1),
+      load5: parseNumber(fields.load5),
+      load15: parseNumber(fields.load15),
+      cpuCount: parseNumber(fields.cpuCount),
+    },
+    memory: {
+      totalBytes: parseNumber(fields.memTotalBytes),
+      availableBytes: parseNumber(fields.memAvailableBytes),
+      usedBytes: parseNumber(fields.memUsedBytes),
+      processRssBytes: parseNumber(fields.processRssBytes),
+    },
+    disk: {
+      path: decodeURIComponent(fields.diskPath || '/'),
+      totalBytes: parseNumber(fields.diskTotalBytes),
+      availableBytes: parseNumber(fields.diskAvailableBytes),
+      usedBytes: parseNumber(fields.diskUsedBytes),
+      usedPercent: parseNumber(fields.diskUsedPercent),
+      error: fields.error ? decodeURIComponent(fields.error) : null,
+    },
+  };
+}
+
+export function parseResourceMarkers(logText) {
+  if (typeof logText !== 'string' || !logText) return { markers: [], byPhase: {} };
+  const markers = [];
+  const byPhase = {};
+  for (const line of logText.split(/\r?\n/)) {
+    const marker = parseMarkerLine(line);
+    if (!marker) continue;
+    markers.push(marker);
+    byPhase[marker.phase] = marker;
+  }
+  return { markers, byPhase };
+}
+
+export function selectBestDiskResourceMarker(parsed) {
+  const byPhase = parsed?.byPhase || {};
+  for (const phase of RESOURCE_PHASES_BY_PREFERENCE) {
+    const marker = byPhase[phase];
+    if (Number.isFinite(marker?.disk?.usedBytes)) return marker;
+  }
+  const markers = Array.isArray(parsed?.markers) ? parsed.markers : [];
+  for (let i = markers.length - 1; i >= 0; i--) {
+    if (Number.isFinite(markers[i]?.disk?.usedBytes)) return markers[i];
+  }
+  return null;
+}
+
+export function formatResourceSnapshotForLog(snapshot, label = null) {
+  const s = snapshot || {};
+  const phaseLabel = label || String(s.phase || 'snapshot').replace(/_/g, ' ');
+  const cpu = s.cpu || {};
+  const memory = s.memory || {};
+  const disk = s.disk || {};
+  const lines = [`📈 Resource usage (${phaseLabel}):`, `   CPU load: ${formatNumber(cpu.load1)} ${formatNumber(cpu.load5)} ${formatNumber(cpu.load15)}${Number.isFinite(cpu.cpuCount) ? ` (${cpu.cpuCount} CPUs)` : ''}`, `   Memory: ${formatBytes(memory.availableBytes)} available / ${formatBytes(memory.totalBytes)} total (${formatBytes(memory.usedBytes)} used)`, `   Process RSS: ${formatBytes(memory.processRssBytes)}${Number.isFinite(memory.processHeapUsedBytes) ? `, heap ${formatBytes(memory.processHeapUsedBytes)}` : ''}`, `   Disk (${disk.path || '/'}): ${formatBytes(disk.availableBytes)} available / ${formatBytes(disk.totalBytes)} total${Number.isFinite(disk.usedPercent) ? ` (${disk.usedPercent.toFixed(1)}% used)` : ''}`];
+  if (disk.error) lines.push(`   Disk probe error: ${disk.error}`);
+  lines.push(buildResourceMarker(snapshot));
+  return lines.join('\n');
+}
+
+export async function recordResourceSnapshot({ phase, log, diskPath = '/', label = null, capture = captureResourceSnapshot, logExecutionContext = false, detectContext = detectExecutionContext } = {}) {
+  if (typeof log !== 'function') return null;
+  try {
+    // Issue #2001: optionally report the execution context (host vs container)
+    // so it is explicit that per-task disk usage is scoped to the container.
+    if (logExecutionContext) {
+      try {
+        await log(formatExecutionContextForLog(detectContext()));
+      } catch {
+        /* context detection is best-effort and must never block the snapshot */
+      }
+    }
+    const snapshot = capture({ phase, diskPath });
+    await log(formatResourceSnapshotForLog(snapshot, label));
+    return snapshot;
+  } catch (error) {
+    await log(`⚠️  Resource usage measurement failed (${phase || 'snapshot'}): ${error?.message || error}`, { level: 'warning', verbose: true });
+    return null;
+  }
+}
+
+export function summarizeResourceSnapshot(snapshot) {
+  if (!snapshot) return null;
+  const cpu = snapshot.cpu || {};
+  const memory = snapshot.memory || {};
+  const disk = snapshot.disk || {};
+  return {
+    phase: snapshot.phase || null,
+    timestamp: snapshot.timestamp || null,
+    cpu: {
+      load1: cpu.load1,
+      load5: cpu.load5,
+      load15: cpu.load15,
+      cpuCount: cpu.cpuCount,
+    },
+    memory: {
+      totalBytes: memory.totalBytes,
+      availableBytes: memory.availableBytes,
+      usedBytes: memory.usedBytes,
+      processRssBytes: memory.processRssBytes,
+    },
+    disk: {
+      path: disk.path,
+      totalBytes: disk.totalBytes,
+      availableBytes: disk.availableBytes,
+      usedBytes: disk.usedBytes,
+      usedPercent: disk.usedPercent,
+      error: disk.error || null,
+    },
+  };
+}

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

@@ -32,6 +32,7 @@ const fs = (await use('fs')).promises;
 const lib = await import('./lib.mjs');
 const { log, formatAligned, extractToolErrorCore } = lib;
 const { ensurePullRequestBaseBranch } = await import('./solve.pr-base-guard.lib.mjs');
+const { RESOURCE_PHASE_RESTART_AFTER, RESOURCE_PHASE_RESTART_BEFORE, recordResourceSnapshot } = await import('./solve.resource-diagnostics.lib.mjs');
 
 // Import Sentry integration
 const sentryLib = await import('./sentry.lib.mjs');
@@ -177,6 +178,13 @@ export const getUncommittedChangesDetails = async tempDir => {
 export const executeToolIteration = async params => {
   const { issueUrl, owner, repo, issueNumber, prNumber, branchName, tempDir, workspaceTmpDir, mergeStateStatus, feedbackLines, argv } = params;
 
+  await recordResourceSnapshot({
+    phase: RESOURCE_PHASE_RESTART_BEFORE,
+    log,
+    diskPath: '/',
+    label: 'before AI restart iteration',
+  });
+
   // Import necessary modules for tool execution
   const memoryCheck = await import('./memory-check.mjs');
   const { getResourceSnapshot } = memoryCheck;
@@ -462,6 +470,12 @@ export const executeToolIteration = async params => {
   }
 
   await ensurePullRequestBaseBranch({ owner, repo, prNumber, argv, log, formatAligned, $ });
+  await recordResourceSnapshot({
+    phase: RESOURCE_PHASE_RESTART_AFTER,
+    log,
+    diskPath: '/',
+    label: 'after AI restart iteration',
+  });
   return toolResult;
 };