@link-assistant/hive-mind 2.0.21 → 2.0.23

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 2.0.23
+
+### Patch Changes
+
+- 4778963: Add `--sub-agent-model` for Claude Code subagents and agent teams. The option is accepted by solve, hive, and Telegram command parsing, validates Claude aliases/full IDs plus `inherit`, and maps to `CLAUDE_CODE_SUBAGENT_MODEL` only when explicitly provided so Claude Code defaults remain unchanged.
+
+## 2.0.22
+
+### Patch Changes
+
+- 4d65c05: Make disk admission safer by default: the disk usage queue gate now waits at 80%, the absolute free-space default is 10240 MB, and isolation defaults to Docker.
+
 ## 2.0.21
 
 ### Patch Changes

package/package.json

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

package/src/agent-commander.lib.mjs

@@ -8,7 +8,7 @@
  */
 
 import { resolveCodexReasoningEffort } from './codex.options.lib.mjs';
-import { mapModelForTool } from './models/index.mjs';
+import { mapClaudeSubAgentModelToEnvValue, mapModelForTool } from './models/index.mjs';
 import { buildCodexDisable1mContextConfigArgs, buildCodexSubSessionSizeConfigArgs, parseSubSessionSize } from './sub-session-size.lib.mjs';
 import { detectUsageLimit } from './usage-limit.lib.mjs';
 import { getCacheReadTokenCount, getCumulativeContextInputTokens, getOutputTokenCount } from './context-fill.lib.mjs';
@@ -54,6 +54,7 @@ const buildClaudeToolOptions = (argv = {}) => {
   if (argv.disable1mContext) extraEnv.CLAUDE_CODE_DISABLE_1M_CONTEXT = '1';
   if (argv.showThinkingContent) extraEnv.CLAUDE_CODE_SHOW_THINKING = '1';
   if (argv.planModel) extraEnv.ANTHROPIC_DEFAULT_OPUS_MODEL = argv.planModel;
+  if (argv.subAgentModel) extraEnv.CLAUDE_CODE_SUBAGENT_MODEL = mapClaudeSubAgentModelToEnvValue(argv.subAgentModel);
   appendExtraEnv(options, extraEnv);
 
   return options;

package/src/claude.lib.mjs

@@ -21,7 +21,7 @@ import { seedCumulativeAnthropicCost, addAnthropicRunCost } from './anthropic-co
 import { buildSolveResumeCommand } from './solve.resume-command.lib.mjs'; // Issue #942
 import { SESSION_FORCE_KILLED_MARKER, postTrackedComment } from './tool-comments.lib.mjs'; // Issue #1625
 import { handleClaudeRuntimeSwitch } from './claude.runtime-switch.lib.mjs'; // see issue #1141
-import { CLAUDE_MODELS as availableModels } from './models/index.mjs'; // Issue #1221
+import { CLAUDE_MODELS as availableModels, mapClaudeSubAgentModelToEnvValue } from './models/index.mjs'; // Issue #1221, #1978
 import { buildMcpConfigWithoutPlaywright, ensureClaudePlaywrightMcpServer } from './playwright-mcp.lib.mjs';
 import { resolveClaudeSessionToolFlags } from './useless-tools.lib.mjs';
 import { ensureClaudeQuietConfig } from './claude-quiet-config.lib.mjs';
@@ -658,6 +658,7 @@ export const executeClaudeCommand = async params => {
     let execCommand;
     const mappedModel = mapModelToId(argv.model);
     const resolvedPlanModel = argv.planModel ? mapModelToId(argv.planModel) : undefined; // Issue #1223
+    const resolvedSubAgentModel = argv.subAgentModel ? mapClaudeSubAgentModelToEnvValue(argv.subAgentModel) : undefined; // Issue #1978
     const effectiveModel = resolvedPlanModel ? 'opusplan' : mappedModel;
     const resolvedExecutionModel = resolvedPlanModel ? mappedModel : undefined;
     // Issue #1949: Let Claude Code handle transient overload (529) fallback via its own
@@ -706,12 +707,13 @@ export const executeClaudeCommand = async params => {
       // Issue #1706: --sub-session-size + --disable-1m-context. Resolve here, then pass into getClaudeEnv along with the rest.
       const { parsed: parsedSubSessionSize, contextWindowTokens } = await resolveSubSessionSize({ rawValue: argv.subSessionSize, tool: 'claude', modelId: effectiveModel, fetchModelInfo, log });
       // Issue #817: streaming mode sets exitAfterStopDelayMs=60000 so the headless Claude process stays alive between NDJSON turns.
-      const claudeEnv = getClaudeEnv({ thinkingBudget: resolvedThinkingBudget, model: effectiveModel, thinkLevel, maxBudget, planModel: resolvedPlanModel, executionModel: resolvedExecutionModel, showThinkingContent: argv.showThinkingContent, exitAfterStopDelayMs: streamingInput ? 60_000 : undefined, disable1mContext: !!argv.disable1mContext, subSessionSize: parsedSubSessionSize, contextWindowTokens });
+      const claudeEnv = getClaudeEnv({ thinkingBudget: resolvedThinkingBudget, model: effectiveModel, thinkLevel, maxBudget, planModel: resolvedPlanModel, executionModel: resolvedExecutionModel, subAgentModel: resolvedSubAgentModel, showThinkingContent: argv.showThinkingContent, exitAfterStopDelayMs: streamingInput ? 60_000 : undefined, disable1mContext: !!argv.disable1mContext, subSessionSize: parsedSubSessionSize, contextWindowTokens });
       if (argv.verbose) claudeEnv.ANTHROPIC_LOG = 'debug';
       const modelMaxOutputTokens = getMaxOutputTokensForModel(effectiveModel);
       if (argv.verbose) {
         await log(`📊 CLAUDE_CODE_MAX_OUTPUT_TOKENS: ${modelMaxOutputTokens}, MCP_TIMEOUT: ${claudeCode.mcpTimeout}ms, MCP_TOOL_TIMEOUT: ${claudeCode.mcpToolTimeout}ms, ANTHROPIC_LOG: debug`, { verbose: true });
         if (resolvedPlanModel) await log(`📊 opusplan: plan=${resolvedPlanModel}, exec=${resolvedExecutionModel}`, { verbose: true });
+        if (claudeEnv.CLAUDE_CODE_SUBAGENT_MODEL) await log(`📊 CLAUDE_CODE_SUBAGENT_MODEL: ${claudeEnv.CLAUDE_CODE_SUBAGENT_MODEL}`, { verbose: true });
         if (resolvedThinkingBudget !== undefined) await log(`📊 MAX_THINKING_TOKENS: ${resolvedThinkingBudget}`, { verbose: true });
         if (claudeEnv.CLAUDE_CODE_EFFORT_LEVEL) await log(`📊 CLAUDE_CODE_EFFORT_LEVEL: ${claudeEnv.CLAUDE_CODE_EFFORT_LEVEL}`, { verbose: true });
         if (claudeEnv.CLAUDE_CODE_SHOW_THINKING) await log(`📊 CLAUDE_CODE_SHOW_THINKING: ${claudeEnv.CLAUDE_CODE_SHOW_THINKING}`, { verbose: true });

package/src/config.lib.mjs

@@ -111,7 +111,7 @@ export const githubLimits = {
 
 // Memory and disk configurations
 export const systemLimits = {
-  minDiskSpaceMb: parseIntWithDefault('HIVE_MIND_MIN_DISK_SPACE_MB', 2048),
+  minDiskSpaceMb: parseIntWithDefault('HIVE_MIND_MIN_DISK_SPACE_MB', 10240),
   defaultPageSizeKb: parseIntWithDefault('HIVE_MIND_DEFAULT_PAGE_SIZE_KB', 16),
 };
 
@@ -543,9 +543,11 @@ export const supportsThinkingBudget = (version, minVersion = '2.1.12') => {
 // Supports planModel/executionModel for opusplan mode (Issue #1223)
 // Issue #1706: supports subSessionSize (parsed) + disable1mContext to cap
 // auto-compaction sub-session size and opt out of the 1M extended context.
+// Issue #1978: supports subAgentModel for Claude Code native subagents and agent teams.
 // See: https://code.claude.com/docs/en/env-vars and https://code.claude.com/docs/en/model-config
 //   ANTHROPIC_DEFAULT_OPUS_MODEL  → model used in plan mode (and for 'opus' alias)
 //   ANTHROPIC_DEFAULT_SONNET_MODEL → model used in execution mode (and for 'sonnet' alias)
+//   CLAUDE_CODE_SUBAGENT_MODEL     → model used by all subagents and agent teams
 //   CLAUDE_CODE_DISABLE_1M_CONTEXT, CLAUDE_CODE_AUTO_COMPACT_WINDOW, CLAUDE_AUTOCOMPACT_PCT_OVERRIDE
 export const getClaudeEnv = (options = {}) => {
   // Get max output tokens based on model (Issue #1221)
@@ -619,6 +621,12 @@ export const getClaudeEnv = (options = {}) => {
     env.ANTHROPIC_DEFAULT_SONNET_MODEL = String(options.executionModel);
   }
 
+  // Issue #1978: Set Claude Code native subagent/agent-team model only when
+  // explicitly requested. Leaving this unset preserves Claude Code defaults.
+  if (options.subAgentModel) {
+    env.CLAUDE_CODE_SUBAGENT_MODEL = String(options.subAgentModel);
+  }
+
   // Issue #1706: --disable-1m-context. Sets CLAUDE_CODE_DISABLE_1M_CONTEXT=1.
   if (options.disable1mContext) {
     env.CLAUDE_CODE_DISABLE_1M_CONTEXT = '1';

package/src/hive.mjs

@@ -74,7 +74,7 @@ if (isRunningDirectly) {
     const { validateClaudeConnection } = claudeLib;
     // Import model validation library
     const modelValidation = await import('./models/index.mjs');
-    const { validateAndExitOnInvalidModel, defaultModels, resolveRuntimeDefaultModel } = modelValidation;
+    const { validateAndExitOnInvalidClaudeSubAgentModel, validateAndExitOnInvalidModel, defaultModels, resolveRuntimeDefaultModel } = modelValidation;
     const githubLib = await import('./github.lib.mjs');
     const { checkGitHubPermissions, fetchAllIssuesWithPagination, fetchProjectIssues, isRateLimitError, batchCheckPullRequestsForIssues, parseGitHubUrl, batchCheckArchivedRepositories } = githubLib;
     // Import YouTrack-related functions
@@ -473,6 +473,9 @@ if (isRunningDirectly) {
       }
       await validateAndExitOnInvalidModel(argv.planModel, tool, safeExit);
     }
+    if (argv.subAgentModel) {
+      await validateAndExitOnInvalidClaudeSubAgentModel(argv.subAgentModel, tool, safeExit);
+    }
 
     // Handle -s (--skip-issues-with-prs) and --auto-continue interaction
     const hasExplicitAutoContinue = rawArgs.includes('--auto-continue');
@@ -1444,7 +1447,7 @@ if (isRunningDirectly) {
     } else {
       const systemCheck = await checkSystem(
         {
-          minDiskSpaceMB: argv.minDiskSpace || 2048,
+          minDiskSpaceMB: argv.minDiskSpace || 10240,
           minMemoryMB: 256,
           exitOnFailure: true,
         },

package/src/memory-check.mjs

@@ -26,7 +26,7 @@ const lib = await import('./lib.mjs');
 const { log: libLog, setLogFile } = lib;
 
 // Function to check available disk space
-export const checkDiskSpace = async (minSpaceMB = 2048, options = {}) => {
+export const checkDiskSpace = async (minSpaceMB = 10240, options = {}) => {
   const log = options.log || libLog;
 
   try {
@@ -289,7 +289,7 @@ export const getResourceSnapshot = async () => {
 
 // Combined system check function
 export const checkSystem = async (requirements = {}, options = {}) => {
-  const { minMemoryMB = 256, minDiskSpaceMB = 2048, exitOnFailure = false } = requirements;
+  const { minMemoryMB = 256, minDiskSpaceMB = 10240, exitOnFailure = false } = requirements;
 
   // Note: log is passed through options to checkDiskSpace and checkRAM
   const results = {
@@ -334,7 +334,7 @@ const createMemoryCheckYargsConfig = yargsInstance =>
       alias: 'd',
       type: 'number',
       description: 'Minimum required disk space in MB',
-      default: 2048,
+      default: 10240,
     })
     .option('exit-on-failure', {
       alias: 'e',

package/src/models/index.mjs

@@ -742,6 +742,62 @@ export const validateModelName = (model, tool = 'claude') => {
   };
 };
 
+export const CLAUDE_SUB_AGENT_MODEL_INHERIT = 'inherit';
+
+export const normalizeClaudeSubAgentModelName = model => {
+  if (model === undefined || model === null) return model;
+  if (typeof model !== 'string') return model;
+
+  const trimmed = model.trim();
+  return trimmed.toLowerCase() === CLAUDE_SUB_AGENT_MODEL_INHERIT ? CLAUDE_SUB_AGENT_MODEL_INHERIT : trimmed;
+};
+
+const looksLikeClaudeProviderModelId = model => {
+  if (typeof model !== 'string') return false;
+  const normalized = model.toLowerCase();
+  return normalized.startsWith('claude-') || normalized.startsWith('anthropic/') || normalized.startsWith('anthropic.') || normalized.includes('.anthropic.');
+};
+
+/**
+ * Validate the Claude Code subagent/agent-team model override.
+ *
+ * Claude Code documents CLAUDE_CODE_SUBAGENT_MODEL as accepting full provider
+ * model IDs, normal Claude model aliases, and the special value "inherit".
+ * Keep "inherit" scoped to this option so it does not become a valid main
+ * session model.
+ *
+ * @param {string} model - The subagent model override value
+ * @returns {{ valid: boolean, message?: string, suggestions?: string[], mappedModel?: string }}
+ */
+export const validateClaudeSubAgentModelName = model => {
+  const normalized = normalizeClaudeSubAgentModelName(model);
+
+  if (normalized === CLAUDE_SUB_AGENT_MODEL_INHERIT) {
+    return {
+      valid: true,
+      mappedModel: CLAUDE_SUB_AGENT_MODEL_INHERIT,
+    };
+  }
+
+  const validation = validateModelName(normalized, 'claude');
+  if (validation.valid) return validation;
+  if (looksLikeClaudeProviderModelId(normalized)) {
+    return {
+      valid: true,
+      mappedModel: normalized,
+    };
+  }
+
+  return validation;
+};
+
+export const mapClaudeSubAgentModelToEnvValue = model => {
+  const result = validateClaudeSubAgentModelName(model);
+  if (result.valid && result.mappedModel) return result.mappedModel;
+  const normalized = normalizeClaudeSubAgentModelName(model);
+  return mapModelForTool('claude', normalized);
+};
+
 /**
  * Validate model name and exit with error if invalid
  * This is the main entry point for model validation in solve.mjs, hive.mjs, etc.
@@ -767,6 +823,46 @@ export const validateAndExitOnInvalidModel = async (model, tool = 'claude', exit
   return true;
 };
 
+/**
+ * Validate --sub-agent-model and exit with error if invalid.
+ *
+ * This option maps to Claude Code's CLAUDE_CODE_SUBAGENT_MODEL, so it is only
+ * meaningful for the Claude tool even when solve/hive supports multiple tools.
+ *
+ * @param {string} model - The subagent model override value
+ * @param {string} tool - The selected tool
+ * @param {Function} exitFn - Function to call for exiting (default: process.exit)
+ * @returns {Promise<boolean>} True if valid, exits process if invalid
+ */
+export const validateAndExitOnInvalidClaudeSubAgentModel = async (model, tool = 'claude', exitFn = null) => {
+  if (model === undefined || model === null || model === '') return true;
+
+  if (tool !== 'claude') {
+    await log(`❌ --sub-agent-model is only supported with --tool claude (current tool: ${tool})`, { level: 'error' });
+    if (exitFn) {
+      await exitFn(1, '--sub-agent-model requires --tool claude');
+    } else {
+      process.exit(1);
+    }
+    return false;
+  }
+
+  const result = validateClaudeSubAgentModelName(model);
+
+  if (!result.valid) {
+    await log(`❌ Invalid --sub-agent-model: ${result.message}`, { level: 'error' });
+
+    if (exitFn) {
+      await exitFn(1, 'Invalid sub-agent model name');
+    } else {
+      process.exit(1);
+    }
+    return false;
+  }
+
+  return true;
+};
+
 /**
  * Format the list of available models for help text
  * @param {string} tool - The tool name

package/src/queue-config.lib.mjs

@@ -22,6 +22,7 @@ import { ensureUseM } from './use-m-bootstrap.lib.mjs';
  *
  * @see https://github.com/link-assistant/hive-mind/issues/1242
  * @see https://github.com/link-assistant/hive-mind/issues/1253
+ * @see https://github.com/link-assistant/hive-mind/issues/1981
  */
 
 // Use use-m to dynamically import modules
@@ -236,9 +237,8 @@ function getThresholdConfig(linoKey, envVarThreshold, envVarStrategy, defaultThr
  * - 'enqueue': Block and wait in queue
  * - 'dequeue-one-at-a-time': Allow one command, block subsequent
  *
- * BREAKING CHANGE: Disk threshold default strategy changed from 'dequeue-one-at-a-time' to 'reject'
- * because the queue is lost on server restart anyway, so there's no point in queueing.
- * To restore old behavior: HIVE_MIND_DISK_STRATEGY=dequeue-one-at-a-time
+ * Issue #1981: disk now defaults to the normal wait/enqueue path at 80% used.
+ * Operators can still choose immediate rejection with HIVE_MIND_DISK_STRATEGY=reject.
  */
 export const QUEUE_CONFIG = {
   // Threshold configurations with value and strategy
@@ -246,10 +246,8 @@ export const QUEUE_CONFIG = {
   thresholds: {
     ram: getThresholdConfig('ram', 'HIVE_MIND_RAM_THRESHOLD', 'HIVE_MIND_RAM_STRATEGY', 0.65, 'enqueue'),
     cpu: getThresholdConfig('cpu', 'HIVE_MIND_CPU_THRESHOLD', 'HIVE_MIND_CPU_STRATEGY', 0.65, 'enqueue'),
-    // BREAKING: disk default changed from 'dequeue-one-at-a-time' to 'reject'
-    // Queue is in RAM and lost on restart - no point enlarging it when disk is full
-    // See: https://github.com/link-assistant/hive-mind/issues/1253
-    disk: getThresholdConfig('disk', 'HIVE_MIND_DISK_THRESHOLD', 'HIVE_MIND_DISK_STRATEGY', 0.9, 'reject'),
+    // Issue #1981: wait instead of immediately rejecting when disk crosses 80%.
+    disk: getThresholdConfig('disk', 'HIVE_MIND_DISK_THRESHOLD', 'HIVE_MIND_DISK_STRATEGY', 0.8, 'enqueue'),
     claude5Hour: getThresholdConfig('claude5Hour', 'HIVE_MIND_CLAUDE_5_HOUR_SESSION_THRESHOLD', 'HIVE_MIND_CLAUDE_5_HOUR_SESSION_STRATEGY', 0.65, 'dequeue-one-at-a-time'),
     claudeWeekly: getThresholdConfig('claudeWeekly', 'HIVE_MIND_CLAUDE_WEEKLY_THRESHOLD', 'HIVE_MIND_CLAUDE_WEEKLY_STRATEGY', 0.97, 'dequeue-one-at-a-time'),
     codex5Hour: getThresholdConfig('codex5Hour', 'HIVE_MIND_CODEX_5_HOUR_SESSION_THRESHOLD', 'HIVE_MIND_CODEX_5_HOUR_SESSION_STRATEGY', 0.65, 'dequeue-one-at-a-time'),
@@ -265,7 +263,7 @@ export const QUEUE_CONFIG = {
   // These are derived from thresholds.{metric}.value
   RAM_THRESHOLD: getThresholdConfig('ram', 'HIVE_MIND_RAM_THRESHOLD', 'HIVE_MIND_RAM_STRATEGY', 0.65, 'enqueue').value,
   CPU_THRESHOLD: getThresholdConfig('cpu', 'HIVE_MIND_CPU_THRESHOLD', 'HIVE_MIND_CPU_STRATEGY', 0.65, 'enqueue').value,
-  DISK_THRESHOLD: getThresholdConfig('disk', 'HIVE_MIND_DISK_THRESHOLD', 'HIVE_MIND_DISK_STRATEGY', 0.9, 'reject').value,
+  DISK_THRESHOLD: getThresholdConfig('disk', 'HIVE_MIND_DISK_THRESHOLD', 'HIVE_MIND_DISK_STRATEGY', 0.8, 'enqueue').value,
   CLAUDE_5_HOUR_SESSION_THRESHOLD: getThresholdConfig('claude5Hour', 'HIVE_MIND_CLAUDE_5_HOUR_SESSION_THRESHOLD', 'HIVE_MIND_CLAUDE_5_HOUR_SESSION_STRATEGY', 0.65, 'dequeue-one-at-a-time').value,
   CLAUDE_WEEKLY_THRESHOLD: getThresholdConfig('claudeWeekly', 'HIVE_MIND_CLAUDE_WEEKLY_THRESHOLD', 'HIVE_MIND_CLAUDE_WEEKLY_STRATEGY', 0.97, 'dequeue-one-at-a-time').value,
   CODEX_5_HOUR_SESSION_THRESHOLD: getThresholdConfig('codex5Hour', 'HIVE_MIND_CODEX_5_HOUR_SESSION_THRESHOLD', 'HIVE_MIND_CODEX_5_HOUR_SESSION_STRATEGY', 0.65, 'dequeue-one-at-a-time').value,

package/src/solve.config.lib.mjs

@@ -289,8 +289,8 @@ export const SOLVE_OPTION_DEFINITIONS = {
   },
   'min-disk-space': {
     type: 'number',
-    description: 'Minimum required disk space in MB (default: 2048)',
-    default: 2048,
+    description: 'Minimum required disk space in MB (default: 10240)',
+    default: 10240,
   },
   'log-dir': {
     type: 'string',
@@ -333,6 +333,11 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: 'Fallback model to switch to on model capacity/overload errors (and, for Fable 5, on safety-classifier refusals). When supported, retries resume the same session with this model. Defaults: claude fable/claude-fable-5 -> opus (Opus 4.8); claude mythos-5/claude-mythos-5 -> fable; claude opus/opus-4-8 -> opus-4-7; claude opus-4-7 -> opus-4-6; codex gpt-5.5 -> gpt-5.4; all others unset.',
     default: undefined,
   },
+  'sub-agent-model': {
+    type: 'string',
+    description: 'Claude Code subagent/agent-team model override. Sets CLAUDE_CODE_SUBAGENT_MODEL only when provided. Accepts Claude model aliases, full model IDs, or "inherit" to use normal Claude Code subagent model resolution. Only works with --tool claude.',
+    default: undefined,
+  },
   'show-thinking-content': {
     type: 'boolean',
     description: 'Show thinking content in Claude responses. Opus 4.7+ omits thinking content by default (applies to Opus 4.8 as well); this option opts in to receive summarized thinking blocks. Disabled by default. Only affects --tool claude.',

package/src/solve.mjs

@@ -64,7 +64,7 @@ const { attachFinalLogIfMissing } = await import('./attach-logs-guarantee.lib.mj
 // "did the AI post anything?" check in --auto-attach-solution-summary).
 const { postTrackedComment, USAGE_LIMIT_REACHED_MARKER } = await import('./tool-comments.lib.mjs');
 const { prepareFeedbackAndTimestamps, checkUncommittedChanges, checkForkActions } = await import('./solve.preparation.lib.mjs');
-const { validateAndExitOnInvalidModel } = await import('./models/index.mjs');
+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
@@ -243,12 +243,13 @@ if (argv.planModel) {
   }
   await validateAndExitOnInvalidModel(argv.planModel, tool, safeExit);
 }
+if (argv.subAgentModel) await validateAndExitOnInvalidClaudeSubAgentModel(argv.subAgentModel, tool, safeExit);
 
 // Perform all system checks (skip tool connection check in dry-run or when --skip-tool-connection-check; model validation always runs)
 const skipToolConnectionCheck = argv.dryRun || argv.skipToolConnectionCheck || argv.toolConnectionCheck === false;
 const { cascadePlaywrightMcpDisable, ensureSolvePlaywrightMcpReady } = await import('./playwright-mcp.lib.mjs');
 await cascadePlaywrightMcpDisable(argv, log);
-if (!(await performSystemChecks(argv.minDiskSpace || 2048, skipToolConnectionCheck, argv.model, argv))) {
+if (!(await performSystemChecks(argv.minDiskSpace || 10240, skipToolConnectionCheck, argv.model, argv))) {
   await safeExit(1, 'System checks failed');
 }
 // Playwright MCP preflight is local/free and stays independent from paid tool connection checks.

package/src/solve.validation.lib.mjs

@@ -54,7 +54,7 @@ const { parseResetTime: parseResetTimeToDate } = usageLimitLib;
 const { validateClaudeConnection } = claudeLib;
 
 // Wrapper function for disk space check using imported module
-const checkDiskSpace = async (minSpaceMB = 2048) => {
+const checkDiskSpace = async (minSpaceMB = 10240) => {
   const result = await memoryCheck.checkDiskSpace(minSpaceMB, { log });
   return result.success;
 };
@@ -216,7 +216,7 @@ export const validateContinueOnlyOnFeedback = async (argv, isPrUrl, isIssueUrl)
 // Perform all system checks (disk space, memory, tool connection, GitHub permissions)
 // 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 = 2048, skipToolConnection = false, model = 'sonnet', argv = {}) => {
+export const performSystemChecks = async (minDiskSpace = 10240, skipToolConnection = false, model = 'sonnet', argv = {}) => {
   // Check disk space before proceeding
   const hasEnoughSpace = await checkDiskSpace(minDiskSpace);
   if (!hasEnoughSpace) {

package/src/task.config.lib.mjs

@@ -61,7 +61,7 @@ export const createYargsConfig = yargsInstance =>
       type: 'string',
       description: 'agent-commander isolation mode',
       choices: ['screen', 'none', 'docker'],
-      default: 'screen',
+      default: 'docker',
     })
     .option('screen-name', {
       type: 'string',

package/src/task.mjs

@@ -35,7 +35,7 @@ if (earlyArgs.length === 0 || earlyArgs.includes('--help') || earlyArgs.includes
   console.log('  --split-count      Number of issues to split into [default: 2]');
   console.log('  --tool             AI tool for agent-commander read-only mode (claude, codex, opencode, agent, qwen, gemini) [default: claude]');
   console.log('  --model, -m        Model to use');
-  console.log('  --isolation        agent-commander isolation mode [default: screen]');
+  console.log('  --isolation        agent-commander isolation mode [default: docker]');
   console.log('  --dry-run          Print split output without creating GitHub issues');
   console.log('  --verbose, -v      Enable verbose logging');
   console.log('  --output-format    Output format (text or json) [default: text]');

package/src/telegram-bot.mjs

@@ -102,7 +102,7 @@ const config = yargs(hideBin(process.argv))
   .option('autoStartScreenWatchMessage', { type: 'boolean', description: 'Experimental: auto-start separate /terminal_watch messages for public /solve sessions', alias: 'auto-start-screen-watch-message', default: getenv('TELEGRAM_AUTO_START_SCREEN_WATCH_MESSAGE', getenv('TELEGRAM_AUTO_WATCH_MESSAGE', 'false')) === 'true' })
   // Issue #594: bot-owner toggle for --show-limits virtual option in /solve and /hive.
   .option('showLimits', { type: 'boolean', description: 'Experimental: allow /solve and /hive callers to use --show-limits to embed Claude/Codex usage at start, end, and delta in the completion message', alias: 'show-limits', default: getenv('TELEGRAM_SHOW_LIMITS', 'true') !== 'false' })
-  .option('isolation', { type: 'string', description: "Isolation backend (screen/tmux/docker). Defaults to 'screen' so Telegram-bot work sessions survive bot restarts; pass --isolation '' (or set TELEGRAM_ISOLATION='') to disable.", default: getenv('TELEGRAM_ISOLATION', 'screen') })
+  .option('isolation', { type: 'string', description: "Isolation backend (screen/tmux/docker). Defaults to 'docker' so Telegram-bot work sessions run in Docker isolation; pass --isolation '' (or set TELEGRAM_ISOLATION='') to disable.", default: getenv('TELEGRAM_ISOLATION', 'docker') })
   .help('h')
   .alias('h', 'help')
   .parserConfiguration({
@@ -316,7 +316,7 @@ if (config.dryRun) {
 const { buildUserMention } = await import('./buildUserMention.lib.mjs');
 const { reportError, initializeSentry, addBreadcrumb } = await import('./sentry.lib.mjs');
 const { parseGitHubUrl, validateGitHubEntityExistence } = await import('./github.lib.mjs');
-const { validateModelName, buildModelOptionDescription } = await import('./models/index.mjs');
+const { validateClaudeSubAgentModelName, validateModelName, buildModelOptionDescription } = await import('./models/index.mjs');
 const { resolveIsolation, createIsolationAwareQueueCallback } = await import('./telegram-isolation.lib.mjs');
 const limitsLib = await import('./limits.lib.mjs');
 const { formatUsageMessage, formatCodexLimitsSection, getAllCachedLimits } = limitsLib;
@@ -435,6 +435,12 @@ function validateModelInArgs(args, tool = 'claude') {
       if (!validation.valid) {
         return validation.message;
       }
+    } else if (args[i] === '--sub-agent-model' || args[i].startsWith('--sub-agent-model=')) {
+      const modelName = args[i] === '--sub-agent-model' ? args[i + 1] : args[i].substring('--sub-agent-model='.length);
+      if (!modelName) continue;
+      if (tool !== 'claude') return `--sub-agent-model is only supported with --tool claude (current tool: ${tool})`;
+      const validation = validateClaudeSubAgentModelName(modelName);
+      if (!validation.valid) return `Invalid --sub-agent-model: ${validation.message}`;
     }
   }
   return null;

package/src/telegram-solve-queue.lib.mjs

@@ -724,10 +724,11 @@ export class SolveQueue {
    * Default strategies:
    * - RAM: enqueue
    * - CPU: enqueue
-   * - DISK: reject (changed from dequeue-one-at-a-time - queue lost on restart)
+   * - DISK: enqueue (waits until disk drops below the threshold)
    *
    * See: https://github.com/link-assistant/hive-mind/issues/1155
    * See: https://github.com/link-assistant/hive-mind/issues/1253
+   * See: https://github.com/link-assistant/hive-mind/issues/1981
    *
    * @param {number} totalProcessing - Total processing count (queue + external claude processes)
    * @returns {Promise<{ok: boolean, reasons: string[], oneAtATime: boolean, rejected: boolean, rejectReason: string|null}>}

package/src/telegram-start-stop-command.lib.mjs

@@ -584,7 +584,7 @@ export function registerStartStopCommands(bot, options) {
       // immediately and was dispatched to a detached session) but the session
       // monitor still tracks a running isolated session for this URL, forward
       // CTRL+C to its start-command UUID. This is the common case for tasks
-      // that begin executing right away with `--isolation screen`.
+      // that begin executing right away with an isolation backend.
       const queueHasTask = lookup.action === 'cancel-queued' || lookup.action === 'stop-running';
       if (!queueHasTask && runningSession?.stoppable && runningSession.sessionId) {
         VERBOSE && console.log(`[VERBOSE] /stop: forwarding CTRL+C to tracked session ${runningSession.sessionId} for ${url} (queue action=${lookup.action})`);
@@ -597,7 +597,7 @@ export function registerStartStopCommands(bot, options) {
         // running-but-non-stoppable (non-isolation) session, say so; otherwise
         // fall back to the UUID hint.
         if (runningSession) {
-          await ctx.reply(`⚠️ Found a running task for ${url}, but it was not started with an isolation backend, so \`/stop\` cannot forward CTRL+C to it.\n\nNext time you can run the command with \`--isolation screen\` to make this task interruptible via \`/stop\`.`, {
+          await ctx.reply(`⚠️ Found a running task for ${url}, but it was not started with an isolation backend, so \`/stop\` cannot forward CTRL+C to it.\n\nNext time run it with the default isolation backend or pass \`--isolation docker\` to make this task interruptible via \`/stop\`.`, {
             parse_mode: 'Markdown',
             reply_to_message_id: message.message_id,
           });
@@ -615,13 +615,13 @@ export function registerStartStopCommands(bot, options) {
         // have forwarded CTRL+C above). If it tracked a non-isolation session,
         // explain why it can't be stopped; otherwise report not found.
         if (runningSession) {
-          await ctx.reply(`⚠️ Found a running task for ${url}, but it was not started with an isolation backend, so \`/stop\` cannot forward CTRL+C to it.\n\nNext time you can run the command with \`--isolation screen\` to make this task interruptible via \`/stop\`.`, {
+          await ctx.reply(`⚠️ Found a running task for ${url}, but it was not started with an isolation backend, so \`/stop\` cannot forward CTRL+C to it.\n\nNext time run it with the default isolation backend or pass \`--isolation docker\` to make this task interruptible via \`/stop\`.`, {
             parse_mode: 'Markdown',
             reply_to_message_id: message.message_id,
           });
           return;
         }
-        await ctx.reply(`ℹ️ No queued or running task found for ${url}.\n\nIf the task is running with \`--isolation screen\`, try \`/stop <UUID>\` (the UUID is shown in the bot's session-id message).`, {
+        await ctx.reply(`ℹ️ No queued or running task found for ${url}.\n\nIf the task is running with an isolation backend, try \`/stop <UUID>\` (the UUID is shown in the bot's session-id message).`, {
           parse_mode: 'Markdown',
           reply_to_message_id: message.message_id,
         });
@@ -655,7 +655,7 @@ export function registerStartStopCommands(bot, options) {
       // running-not-isolated: a started, non-isolated screen session. We
       // could shell out to `screen -X -S <name> stuff $'\003'`, but that's
       // brittle and out of scope for #1780. Tell the user how to recover.
-      await ctx.reply(`⚠️ Found a running task for ${url}, but it was not started with an isolation backend, so \`/stop\` cannot forward CTRL+C to it.\n\nNext time you can run the command with \`--isolation screen\` to make this task interruptible via \`/stop\`.`, {
+      await ctx.reply(`⚠️ Found a running task for ${url}, but it was not started with an isolation backend, so \`/stop\` cannot forward CTRL+C to it.\n\nNext time run it with the default isolation backend or pass \`--isolation docker\` to make this task interruptible via \`/stop\`.`, {
         parse_mode: 'Markdown',
         reply_to_message_id: message.message_id,
       });