@link-assistant/hive-mind 1.20.0 → 1.21.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @link-assistant/hive-mind
 
+## 1.21.0
+
+### Minor Changes
+
+- 6cf54b7: Add configurable queue threshold strategies (reject, enqueue, dequeue-one-at-a-time)
+  - Add three handling strategies for each queue threshold:
+    - `reject`: Immediately reject the command, no queueing
+    - `enqueue`: Block and wait in queue until metric drops
+    - `dequeue-one-at-a-time`: Allow one command, block subsequent
+  - Support configuration via `HIVE_MIND_QUEUE_CONFIG` environment variable (links notation format)
+  - Support individual strategy env vars (e.g., `HIVE_MIND_DISK_STRATEGY`)
+
+  **Breaking change:** Disk threshold default strategy changed from `dequeue-one-at-a-time` to `reject`
+  because the queue is lost on server restart. To restore old behavior: `HIVE_MIND_DISK_STRATEGY=dequeue-one-at-a-time`
+
+## 1.20.1
+
+### Patch Changes
+
+- 1689caf: Fix agent tool pricing display to show correct provider
+  - Add proper model mapping for free models (kimi-k2.5-free, gpt-4o-mini, etc.)
+  - Add getProviderName helper function to detect provider from model ID
+  - Prioritize provider from model ID over API response to fix issue #1250
+  - Display correct provider names: Moonshot AI, OpenAI, Anthropic instead of generic "OpenCode Zen"
+
 ## 1.20.0
 
 ### Minor Changes

package/README.md

@@ -481,9 +481,9 @@ Free Models (with --tool agent):
 /solve https://github.com/owner/repo/issues/123 --tool agent --model gpt-5-nano
 /solve https://github.com/owner/repo/issues/123 --tool agent --model glm-4.7-free
 /solve https://github.com/owner/repo/issues/123 --tool agent --model big-pickle
+```
 
 > **📖 Free Models Guide**: See [docs/FREE_MODELS.md](./docs/FREE_MODELS.md) for comprehensive information about all free models.
-```
 
 #### `/hive` - Run Hive Orchestration
 

package/package.json

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

package/src/agent.lib.mjs

@@ -79,17 +79,51 @@ export const parseAgentTokenUsage = output => {
   return usage;
 };
 
+/**
+ * Helper function to get original provider name from provider identifier
+ * Used for calculating public pricing estimates based on original provider prices
+ * @param {string} providerId - Provider identifier (e.g., 'openai', 'anthropic', 'moonshot')
+ * @returns {string} Human-readable provider name for pricing reference
+ */
+const getOriginalProviderName = providerId => {
+  if (!providerId) return null;
+
+  const providerMap = {
+    openai: 'OpenAI',
+    anthropic: 'Anthropic',
+    moonshot: 'Moonshot AI',
+    google: 'Google',
+    opencode: 'OpenCode Zen',
+    grok: 'xAI',
+  };
+
+  return providerMap[providerId] || providerId.charAt(0).toUpperCase() + providerId.slice(1);
+};
+
 /**
  * Calculate pricing for agent tool usage using models.dev API
+ * Issue #1250: Shows actual provider (OpenCode Zen) and calculates public pricing estimate
+ * based on original provider prices (Moonshot AI, OpenAI, Anthropic, etc.)
+ *
  * @param {string} modelId - The model ID used (e.g., 'opencode/grok-code')
  * @param {Object} tokenUsage - Token usage data from parseAgentTokenUsage
- * @returns {Object} Pricing information
+ * @returns {Object} Pricing information with:
+ *   - provider: Always "OpenCode Zen" (actual provider)
+ *   - originalProvider: The original model provider for pricing reference
+ *   - totalCostUSD: Public pricing estimate based on original provider prices
+ *   - opencodeCost: Actual billed cost from OpenCode Zen (free for most models)
  */
 export const calculateAgentPricing = async (modelId, tokenUsage) => {
   // Extract the model name from provider/model format
   // e.g., 'opencode/grok-code' -> 'grok-code'
   const modelName = modelId.includes('/') ? modelId.split('/').pop() : modelId;
 
+  // Extract provider from model ID to determine original provider for pricing
+  const providerFromModel = modelId.includes('/') ? modelId.split('/')[0] : null;
+
+  // Get original provider name for pricing reference
+  const originalProvider = getOriginalProviderName(providerFromModel);
+
   try {
     // Fetch model info from models.dev API
     const modelInfo = await fetchModelInfo(modelName);
@@ -97,7 +131,7 @@ export const calculateAgentPricing = async (modelId, tokenUsage) => {
     if (modelInfo && modelInfo.cost) {
       const cost = modelInfo.cost;
 
-      // Calculate cost based on token usage
+      // Calculate public pricing estimate based on original provider prices
       // Prices are per 1M tokens, so divide by 1,000,000
       const inputCost = (tokenUsage.inputTokens * (cost.input || 0)) / 1_000_000;
       const outputCost = (tokenUsage.outputTokens * (cost.output || 0)) / 1_000_000;
@@ -106,10 +140,17 @@ export const calculateAgentPricing = async (modelId, tokenUsage) => {
 
       const totalCost = inputCost + outputCost + cacheReadCost + cacheWriteCost;
 
+      // Determine if this is a free model from OpenCode Zen
+      // Models accessed via OpenCode Zen are free, regardless of original provider pricing
+      const isOpencodeFreeModel = providerFromModel === 'opencode' || modelName.toLowerCase().includes('free') || modelName.toLowerCase().includes('grok') || providerFromModel === 'moonshot' || providerFromModel === 'openai' || providerFromModel === 'anthropic';
+
       return {
         modelId,
         modelName: modelInfo.name || modelName,
-        provider: modelInfo.provider || 'OpenCode Zen',
+        // Issue #1250: Always show OpenCode Zen as actual provider
+        provider: 'OpenCode Zen',
+        // Store original provider for reference in pricing display
+        originalProvider: originalProvider || modelInfo.provider || null,
         pricing: {
           inputPerMillion: cost.input || 0,
           outputPerMillion: cost.output || 0,
@@ -123,18 +164,26 @@ export const calculateAgentPricing = async (modelId, tokenUsage) => {
           cacheRead: cacheReadCost,
           cacheWrite: cacheWriteCost,
         },
+        // Public pricing estimate based on original provider prices
         totalCostUSD: totalCost,
+        // Actual cost from OpenCode Zen (free for supported models)
+        opencodeCost: isOpencodeFreeModel ? 0 : totalCost,
+        // Keep for backward compatibility - indicates if model has zero pricing
         isFreeModel: cost.input === 0 && cost.output === 0,
+        // New flag to indicate if OpenCode Zen provides this model for free
+        isOpencodeFreeModel,
       };
     }
-
     // Model not found in API, return what we have
     return {
       modelId,
       modelName,
-      provider: 'Unknown',
+      provider: 'OpenCode Zen',
+      originalProvider,
       tokenUsage,
       totalCostUSD: null,
+      opencodeCost: 0, // OpenCode Zen is free
+      isOpencodeFreeModel: true,
       error: 'Model not found in models.dev API',
     };
   } catch (error) {
@@ -142,8 +191,12 @@ export const calculateAgentPricing = async (modelId, tokenUsage) => {
     return {
       modelId,
       modelName,
+      provider: 'OpenCode Zen',
+      originalProvider,
       tokenUsage,
       totalCostUSD: null,
+      opencodeCost: 0, // OpenCode Zen is free
+      isOpencodeFreeModel: true,
       error: error.message,
     };
   }
@@ -163,6 +216,12 @@ export const mapModelToId = model => {
     haiku: 'anthropic/claude-3-5-haiku',
     opus: 'anthropic/claude-3-opus',
     'gemini-3-pro': 'google/gemini-3-pro',
+    // Free models mapping for issue #1250
+    'kimi-k2.5-free': 'moonshot/kimi-k2.5-free',
+    'gpt-4o-mini': 'openai/gpt-4o-mini',
+    'gpt-4o': 'openai/gpt-4o',
+    'claude-3.5-haiku': 'anthropic/claude-3.5-haiku',
+    'claude-3.5-sonnet': 'anthropic/claude-3.5-sonnet',
   };
 
   // Return mapped model ID if it's an alias, otherwise return as-is

package/src/github.lib.mjs

@@ -22,25 +22,50 @@ import { uploadLogWithGhUploadLog } from './log-upload.lib.mjs';
 
 /**
  * Build cost estimation string for log comments
+ * Issue #1250: Enhanced to show both public pricing estimate and actual provider cost
+ *
  * @param {number|null} totalCostUSD - Public pricing estimate
  * @param {number|null} anthropicTotalCostUSD - Cost calculated by Anthropic (Claude-specific)
  * @param {Object|null} pricingInfo - Pricing info from agent tool
+ *   - opencodeCost: Actual billed cost from OpenCode Zen (for agent tool)
+ *   - isOpencodeFreeModel: Whether OpenCode Zen provides this model for free
+ *   - originalProvider: Original provider for pricing reference
  * @returns {string} Formatted cost info string for markdown (empty if no data available)
  */
 const buildCostInfoString = (totalCostUSD, anthropicTotalCostUSD, pricingInfo) => {
   // Issue #1015: Don't show cost section when all values are unknown (clutters output)
   const hasPublic = totalCostUSD !== null && totalCostUSD !== undefined;
   const hasAnthropic = anthropicTotalCostUSD !== null && anthropicTotalCostUSD !== undefined;
-  const hasPricing = pricingInfo && (pricingInfo.modelName || pricingInfo.tokenUsage || pricingInfo.isFreeModel);
-  if (!hasPublic && !hasAnthropic && !hasPricing) return '';
+  const hasPricing = pricingInfo && (pricingInfo.modelName || pricingInfo.tokenUsage || pricingInfo.isFreeModel || pricingInfo.isOpencodeFreeModel);
+  // Issue #1250: Check for OpenCode Zen actual cost
+  const hasOpencodeCost = pricingInfo?.opencodeCost !== null && pricingInfo?.opencodeCost !== undefined;
+  if (!hasPublic && !hasAnthropic && !hasPricing && !hasOpencodeCost) return '';
   let costInfo = '\n\n💰 **Cost estimation:**';
   if (pricingInfo?.modelName) {
     costInfo += `\n- Model: ${pricingInfo.modelName}`;
     if (pricingInfo.provider) costInfo += `\n- Provider: ${pricingInfo.provider}`;
   }
+  // Issue #1250: Show public pricing estimate based on original provider prices
   if (hasPublic) {
-    costInfo += pricingInfo?.isFreeModel ? '\n- Public pricing estimate: $0.00 (Free model)' : `\n- Public pricing estimate: $${totalCostUSD.toFixed(6)} USD`;
-  } else if (hasPricing) costInfo += '\n- Public pricing estimate: unknown';
+    // For models with zero pricing from original provider, show as free
+    if (pricingInfo?.isFreeModel && totalCostUSD === 0) {
+      costInfo += '\n- Public pricing estimate: $0.00 (Free model)';
+    } else {
+      // Show actual public pricing estimate with original provider reference
+      const originalProviderRef = pricingInfo?.originalProvider ? ` (based on ${pricingInfo.originalProvider} prices)` : '';
+      costInfo += `\n- Public pricing estimate: $${totalCostUSD.toFixed(6)}${originalProviderRef}`;
+    }
+  } else if (hasPricing) {
+    costInfo += '\n- Public pricing estimate: unknown';
+  }
+  // Issue #1250: Show actual cost from OpenCode Zen for agent tool
+  if (hasOpencodeCost) {
+    if (pricingInfo.isOpencodeFreeModel) {
+      costInfo += '\n- Calculated by OpenCode Zen: $0.00 (Free model)';
+    } else {
+      costInfo += `\n- Calculated by OpenCode Zen: $${pricingInfo.opencodeCost.toFixed(6)}`;
+    }
+  }
   if (pricingInfo?.tokenUsage) {
     const u = pricingInfo.tokenUsage;
     let tokenInfo = `\n- Token usage: ${u.inputTokens?.toLocaleString() || 0} input, ${u.outputTokens?.toLocaleString() || 0} output`;

package/src/queue-config.lib.mjs

@@ -7,7 +7,20 @@
  * This module is used by both telegram-solve-queue.lib.mjs (queue logic)
  * and limits.lib.mjs (display formatting).
  *
+ * Supports three handling strategies per threshold:
+ * - 'reject': Immediately reject the command, no queueing
+ * - 'enqueue': Block and wait in queue until metric drops below threshold
+ * - 'dequeue-one-at-a-time': Allow exactly one command, block subsequent
+ *
+ * Configuration can be provided via:
+ * 1. HIVE_MIND_QUEUE_CONFIG environment variable (links notation format)
+ * 2. Individual environment variables (e.g., HIVE_MIND_DISK_THRESHOLD)
+ * 3. Built-in defaults
+ *
+ * Priority: HIVE_MIND_QUEUE_CONFIG > individual env vars > defaults
+ *
  * @see https://github.com/link-assistant/hive-mind/issues/1242
+ * @see https://github.com/link-assistant/hive-mind/issues/1253
  */
 
 // Use use-m to dynamically import modules
@@ -24,6 +37,137 @@ if (typeof globalThis.use === 'undefined') {
 }
 
 const getenv = await use('getenv');
+const linoModule = await use('links-notation');
+const LinoParser = linoModule.Parser || linoModule.default?.Parser;
+
+/**
+ * Valid threshold handling strategies
+ * @type {readonly ['reject', 'enqueue', 'dequeue-one-at-a-time']}
+ */
+export const THRESHOLD_STRATEGIES = Object.freeze(['reject', 'enqueue', 'dequeue-one-at-a-time']);
+
+/**
+ * Validate a threshold strategy value
+ * @param {string} strategy - The strategy to validate
+ * @param {string} defaultStrategy - Default strategy if invalid
+ * @returns {string} Valid strategy
+ */
+function validateStrategy(strategy, defaultStrategy = 'enqueue') {
+  if (!strategy || !THRESHOLD_STRATEGIES.includes(strategy)) {
+    return defaultStrategy;
+  }
+  return strategy;
+}
+
+/**
+ * Normalize metric name from links notation format to camelCase
+ * Examples: 'disk' -> 'disk', 'ram' -> 'ram', 'claude-5-hour' -> 'claude5Hour'
+ * @param {string} name - Metric name in kebab-case
+ * @returns {string} Metric name in normalized form
+ */
+function normalizeMetricName(name) {
+  if (!name) return '';
+  return name.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+
+/**
+ * Parse queue configuration from links notation
+ *
+ * Format:
+ * ```
+ * (
+ *   (disk (90% reject))
+ *   (ram (65% enqueue))
+ *   (cpu (65% enqueue))
+ *   (claude-5-hour (65% dequeue-one-at-a-time))
+ *   (claude-weekly (97% dequeue-one-at-a-time))
+ *   (github-api (75% enqueue))
+ * )
+ * ```
+ *
+ * @param {string} linoConfig - Configuration in links notation format
+ * @returns {Object} Parsed threshold configurations { [metricName]: { value: number, strategy: string } }
+ */
+export function parseQueueConfig(linoConfig) {
+  if (!linoConfig || typeof linoConfig !== 'string') return {};
+
+  try {
+    const parser = new LinoParser();
+    const parsed = parser.parse(linoConfig);
+
+    if (!parsed || !Array.isArray(parsed) || parsed.length === 0) return {};
+
+    const config = {};
+
+    // The parser returns: [{ id: null, values: [...] }]
+    // We need to drill down to find the metric configurations
+    const topLink = parsed[0];
+    if (!topLink || !topLink.values) return {};
+
+    // Helper to extract all ids from a values array recursively
+    function extractIds(values) {
+      const ids = [];
+      if (!values) return ids;
+      for (const v of values) {
+        if (v.id) ids.push(v.id);
+        if (v.values && v.values.length > 0) {
+          ids.push(...extractIds(v.values));
+        }
+      }
+      return ids;
+    }
+
+    // Process each item in top-level values
+    // Structure can be:
+    // - Nested: [{ id: null, values: [{ id: 'disk', ... }, { id: null, values: [{ id: '90%' }, { id: 'reject' }] }] }]
+    // - Flat: [{ id: 'disk', ... }, { id: '90%', ... }, { id: 'reject', ... }]
+    for (const item of topLink.values) {
+      // Check if this is a nested config item (no id at this level)
+      if (item.id === null && item.values && item.values.length > 0) {
+        // Extract all IDs from this nested structure
+        const ids = extractIds(item.values);
+
+        // Find metric name, percentage, and strategy
+        let metricName = null;
+        let thresholdValue = null;
+        let strategy = null;
+
+        for (const id of ids) {
+          // Check for percentage
+          const percentMatch = id.match(/^(\d+)%$/);
+          if (percentMatch) {
+            thresholdValue = parseInt(percentMatch[1], 10) / 100;
+            continue;
+          }
+
+          // Check for strategy
+          if (THRESHOLD_STRATEGIES.includes(id)) {
+            strategy = id;
+            continue;
+          }
+
+          // Otherwise it's likely the metric name
+          if (!metricName) {
+            metricName = id;
+          }
+        }
+
+        if (metricName && thresholdValue !== null) {
+          const normalized = normalizeMetricName(metricName);
+          config[normalized] = {
+            value: thresholdValue,
+            strategy: validateStrategy(strategy),
+          };
+        }
+      }
+    }
+
+    return config;
+  } catch (error) {
+    console.error('[queue-config] Failed to parse HIVE_MIND_QUEUE_CONFIG:', error.message);
+    return {};
+  }
+}
 
 // Helper function to safely parse floats with fallback
 const parseFloatWithDefault = (envVar, defaultValue) => {
@@ -39,6 +183,38 @@ const parseIntWithDefault = (envVar, defaultValue) => {
   return isNaN(parsed) ? defaultValue : parsed;
 };
 
+// Parse links notation config from environment variable (if provided)
+const linoConfig = parseQueueConfig(getenv('HIVE_MIND_QUEUE_CONFIG', ''));
+
+/**
+ * Get threshold configuration with priority:
+ * 1. HIVE_MIND_QUEUE_CONFIG (links notation) - highest priority
+ * 2. Individual environment variables
+ * 3. Default values
+ *
+ * @param {string} linoKey - Key in normalized format for lino config (e.g., 'disk', 'ram')
+ * @param {string} envVarThreshold - Environment variable for threshold value
+ * @param {string} envVarStrategy - Environment variable for strategy
+ * @param {number} defaultThreshold - Default threshold value (0.0 - 1.0)
+ * @param {string} defaultStrategy - Default strategy
+ * @returns {{ value: number, strategy: string }}
+ */
+function getThresholdConfig(linoKey, envVarThreshold, envVarStrategy, defaultThreshold, defaultStrategy) {
+  // Check links notation config first
+  if (linoConfig[linoKey]) {
+    return {
+      value: linoConfig[linoKey].value,
+      strategy: linoConfig[linoKey].strategy,
+    };
+  }
+
+  // Fall back to individual env vars, then defaults
+  return {
+    value: parseFloatWithDefault(envVarThreshold, defaultThreshold),
+    strategy: validateStrategy(getenv(envVarStrategy, ''), defaultStrategy),
+  };
+}
+
 /**
  * Configuration constants for queue throttling
  * All thresholds use ratios (0.0 - 1.0) representing usage percentage
@@ -46,21 +222,39 @@ const parseIntWithDefault = (envVar, defaultValue) => {
  * IMPORTANT: Running claude processes is NOT a blocking limit by itself.
  * Commands can run in parallel as long as actual limits (CPU, API, etc.) are not exceeded.
  * See: https://github.com/link-assistant/hive-mind/issues/1078
+ *
+ * NEW in issue #1253: Each threshold now has a configurable strategy:
+ * - 'reject': Immediately reject the command (no queueing)
+ * - '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
  */
 export const QUEUE_CONFIG = {
-  // Resource thresholds (usage ratios: 0.0 - 1.0)
-  // All thresholds use >= comparison (inclusive)
-  RAM_THRESHOLD: parseFloatWithDefault('HIVE_MIND_RAM_THRESHOLD', 0.65), // Enqueue if RAM usage >= 65%
-  // CPU threshold uses 5-minute load average, not instantaneous CPU usage
-  CPU_THRESHOLD: parseFloatWithDefault('HIVE_MIND_CPU_THRESHOLD', 0.65), // Enqueue if 5-minute load average >= 65% of CPU count
-  DISK_THRESHOLD: parseFloatWithDefault('HIVE_MIND_DISK_THRESHOLD', 0.9), // One-at-a-time if disk usage >= 90%, tuned for VM with 100 GB drive
-
-  // API limit thresholds (usage ratios: 0.0 - 1.0)
-  // All thresholds use >= comparison (inclusive)
-  // Fine-tuned for Claude MAX $200 subscription
-  CLAUDE_5_HOUR_SESSION_THRESHOLD: parseFloatWithDefault('HIVE_MIND_CLAUDE_5_HOUR_SESSION_THRESHOLD', 0.65), // One-at-a-time if 5-hour limit >= 65%
-  CLAUDE_WEEKLY_THRESHOLD: parseFloatWithDefault('HIVE_MIND_CLAUDE_WEEKLY_THRESHOLD', 0.97), // One-at-a-time if weekly limit >= 97%
-  GITHUB_API_THRESHOLD: parseFloatWithDefault('HIVE_MIND_GITHUB_API_THRESHOLD', 0.75), // Enqueue if GitHub >= 75% with parallel claude
+  // Threshold configurations with value and strategy
+  // Priority: HIVE_MIND_QUEUE_CONFIG > individual env vars > defaults
+  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'),
+    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'),
+    githubApi: getThresholdConfig('githubApi', 'HIVE_MIND_GITHUB_API_THRESHOLD', 'HIVE_MIND_GITHUB_API_STRATEGY', 0.75, 'enqueue'),
+  },
+
+  // Legacy flat threshold values for backward compatibility
+  // 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,
+  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,
+  GITHUB_API_THRESHOLD: getThresholdConfig('githubApi', 'HIVE_MIND_GITHUB_API_THRESHOLD', 'HIVE_MIND_GITHUB_API_STRATEGY', 0.75, 'enqueue').value,
 
   // Timing
   // MIN_START_INTERVAL_MS: Time to allow solve command to start actual claude process
@@ -89,16 +283,59 @@ export function thresholdToPercent(ratio) {
  * @see https://github.com/link-assistant/hive-mind/issues/1242
  */
 export const DISPLAY_THRESHOLDS = {
-  RAM: thresholdToPercent(QUEUE_CONFIG.RAM_THRESHOLD), // Blocks at 65%
-  CPU: thresholdToPercent(QUEUE_CONFIG.CPU_THRESHOLD), // Blocks at 65%
-  DISK: thresholdToPercent(QUEUE_CONFIG.DISK_THRESHOLD), // One-at-a-time at 90%
-  CLAUDE_5_HOUR_SESSION: thresholdToPercent(QUEUE_CONFIG.CLAUDE_5_HOUR_SESSION_THRESHOLD), // One-at-a-time at 65%
-  CLAUDE_WEEKLY: thresholdToPercent(QUEUE_CONFIG.CLAUDE_WEEKLY_THRESHOLD), // One-at-a-time at 97%
-  GITHUB_API: thresholdToPercent(QUEUE_CONFIG.GITHUB_API_THRESHOLD), // Blocks parallel claude at 75%
+  RAM: thresholdToPercent(QUEUE_CONFIG.RAM_THRESHOLD),
+  CPU: thresholdToPercent(QUEUE_CONFIG.CPU_THRESHOLD),
+  DISK: thresholdToPercent(QUEUE_CONFIG.DISK_THRESHOLD),
+  CLAUDE_5_HOUR_SESSION: thresholdToPercent(QUEUE_CONFIG.CLAUDE_5_HOUR_SESSION_THRESHOLD),
+  CLAUDE_WEEKLY: thresholdToPercent(QUEUE_CONFIG.CLAUDE_WEEKLY_THRESHOLD),
+  GITHUB_API: thresholdToPercent(QUEUE_CONFIG.GITHUB_API_THRESHOLD),
 };
 
+/**
+ * Get strategy for a specific metric
+ * @param {string} metric - Metric name (ram, cpu, disk, claude5Hour, claudeWeekly, githubApi)
+ * @returns {string} Strategy ('reject', 'enqueue', 'dequeue-one-at-a-time')
+ */
+export function getStrategy(metric) {
+  const threshold = QUEUE_CONFIG.thresholds[metric];
+  return threshold ? threshold.strategy : 'enqueue';
+}
+
+/**
+ * Check if a metric uses the reject strategy
+ * @param {string} metric - Metric name
+ * @returns {boolean}
+ */
+export function isRejectStrategy(metric) {
+  return getStrategy(metric) === 'reject';
+}
+
+/**
+ * Check if a metric uses the enqueue strategy
+ * @param {string} metric - Metric name
+ * @returns {boolean}
+ */
+export function isEnqueueStrategy(metric) {
+  return getStrategy(metric) === 'enqueue';
+}
+
+/**
+ * Check if a metric uses the dequeue-one-at-a-time strategy
+ * @param {string} metric - Metric name
+ * @returns {boolean}
+ */
+export function isOneAtATimeStrategy(metric) {
+  return getStrategy(metric) === 'dequeue-one-at-a-time';
+}
+
 export default {
   QUEUE_CONFIG,
   DISPLAY_THRESHOLDS,
+  THRESHOLD_STRATEGIES,
   thresholdToPercent,
+  parseQueueConfig,
+  getStrategy,
+  isRejectStrategy,
+  isEnqueueStrategy,
+  isOneAtATimeStrategy,
 };

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

@@ -26,7 +26,8 @@ import { getCachedClaudeLimits, getCachedGitHubLimits, getCachedMemoryInfo, getC
 // Import centralized queue configuration
 // This ensures thresholds are consistent between queue logic and display formatting
 // See: https://github.com/link-assistant/hive-mind/issues/1242
-export { QUEUE_CONFIG } from './queue-config.lib.mjs';
+// See: https://github.com/link-assistant/hive-mind/issues/1253 (configurable strategies)
+export { QUEUE_CONFIG, THRESHOLD_STRATEGIES } from './queue-config.lib.mjs';
 import { QUEUE_CONFIG } from './queue-config.lib.mjs';
 
 /**
@@ -531,14 +532,22 @@ export class SolveQueue {
    * - Processing count for Claude limits only includes Claude items, not agent items.
    * - This allows agent tasks to run in parallel when Claude limits are reached.
    *
+   * Logic per issue #1253:
+   * - All thresholds now support configurable strategies (reject, enqueue, dequeue-one-at-a-time)
+   * - 'reject' strategy immediately rejects the command without queueing
+   * - 'enqueue' blocks and waits in queue until metric drops
+   * - 'dequeue-one-at-a-time' allows one command while blocking subsequent
+   *
    * @param {Object} options - Options for the check
    * @param {string} options.tool - The tool being used ('claude', 'agent', etc.)
-   * @returns {Promise<{canStart: boolean, reason?: string, reasons?: string[], oneAtATime?: boolean}>}
+   * @returns {Promise<{canStart: boolean, rejected?: boolean, rejectReason?: string, reason?: string, reasons?: string[], oneAtATime?: boolean}>}
    */
   async canStartCommand(options = {}) {
     const tool = options.tool || 'claude';
     const reasons = [];
     let oneAtATime = false;
+    let rejected = false;
+    let rejectReason = null;
 
     // Check minimum interval since last start FOR THIS TOOL
     // Each tool queue has independent timing to prevent cross-blocking
@@ -572,23 +581,33 @@ export class SolveQueue {
       this.recordThrottle('claude_running');
     }
 
-    // Check system resources (RAM, CPU block unconditionally; disk uses one-at-a-time mode)
+    // Check system resources with strategy support
     // System resources apply to ALL tools, not just Claude
     // See: https://github.com/link-assistant/hive-mind/issues/1155
+    // See: https://github.com/link-assistant/hive-mind/issues/1253 (strategies)
     const resourceCheck = await this.checkSystemResources(totalProcessing);
-    if (!resourceCheck.ok) {
+    if (resourceCheck.rejected) {
+      rejected = true;
+      rejectReason = resourceCheck.rejectReason;
+    }
+    if (!resourceCheck.ok && !resourceCheck.rejected) {
       reasons.push(...resourceCheck.reasons);
     }
     if (resourceCheck.oneAtATime) {
       oneAtATime = true;
     }
 
-    // Check API limits (pass hasRunningClaude, claudeProcessingCount, and tool)
+    // Check API limits with strategy support (pass hasRunningClaude, claudeProcessingCount, and tool)
     // Claude limits use claudeProcessingCount (only Claude items), not totalProcessing
     // This allows agent tasks to proceed when Claude limits are reached
     // See: https://github.com/link-assistant/hive-mind/issues/1159
+    // See: https://github.com/link-assistant/hive-mind/issues/1253 (strategies)
     const limitCheck = await this.checkApiLimits(hasRunningClaude, claudeProcessingCount, tool);
-    if (!limitCheck.ok) {
+    if (limitCheck.rejected) {
+      rejected = true;
+      rejectReason = limitCheck.rejectReason;
+    }
+    if (!limitCheck.ok && !limitCheck.rejected) {
       reasons.push(...limitCheck.reasons);
     }
     if (limitCheck.oneAtATime) {
@@ -604,14 +623,20 @@ export class SolveQueue {
       reasons.push(formatWaitingReason('claude_running', claudeProcs.count, 0) + ` (${claudeProcs.count} processes)`);
     }
 
-    const canStart = reasons.length === 0;
+    const canStart = reasons.length === 0 && !rejected;
 
     if (!canStart && this.verbose) {
-      this.log(`Cannot start: ${reasons.join(', ')}`);
+      if (rejected) {
+        this.log(`Rejected: ${rejectReason}`);
+      } else {
+        this.log(`Cannot start: ${reasons.join(', ')}`);
+      }
     }
 
     return {
       canStart,
+      rejected,
+      rejectReason,
       reason: reasons.length > 0 ? reasons.join('\n') : undefined,
       reasons,
       oneAtATime,
@@ -628,33 +653,53 @@ export class SolveQueue {
    * This provides a more stable metric that isn't affected by brief spikes
    * during claude process startup.
    *
-   * Resource threshold modes:
-   * - RAM_THRESHOLD: Enqueue mode - blocks all commands unconditionally
-   * - CPU_THRESHOLD: Enqueue mode - blocks all commands unconditionally
-   * - DISK_THRESHOLD: One-at-a-time mode - allows exactly one command when nothing is processing
+   * Resource threshold modes are now configurable via HIVE_MIND_QUEUE_CONFIG:
+   * - 'reject': Immediately reject the command, no queueing
+   * - 'enqueue': Block all commands unconditionally until metric drops
+   * - 'dequeue-one-at-a-time': Allow one command when above threshold
+   *
+   * Default strategies:
+   * - RAM: enqueue
+   * - CPU: enqueue
+   * - DISK: reject (changed from dequeue-one-at-a-time - queue lost on restart)
    *
    * See: https://github.com/link-assistant/hive-mind/issues/1155
+   * See: https://github.com/link-assistant/hive-mind/issues/1253
    *
    * @param {number} totalProcessing - Total processing count (queue + external claude processes)
-   * @returns {Promise<{ok: boolean, reasons: string[], oneAtATime: boolean}>}
+   * @returns {Promise<{ok: boolean, reasons: string[], oneAtATime: boolean, rejected: boolean, rejectReason: string|null}>}
    */
   async checkSystemResources(totalProcessing = 0) {
     const reasons = [];
     let oneAtATime = false;
+    let rejected = false;
+    let rejectReason = null;
 
     // Check RAM (using cached value)
-    // Enqueue mode: blocks all commands unconditionally
     const memResult = await getCachedMemoryInfo(this.verbose);
     if (memResult.success) {
       const usedRatio = memResult.memory.usedPercentage / 100;
-      if (usedRatio >= QUEUE_CONFIG.RAM_THRESHOLD) {
-        reasons.push(formatWaitingReason('ram', memResult.memory.usedPercentage, QUEUE_CONFIG.RAM_THRESHOLD));
-        this.recordThrottle('ram_high');
+      if (usedRatio >= QUEUE_CONFIG.thresholds.ram.value) {
+        const reason = formatWaitingReason('ram', memResult.memory.usedPercentage, QUEUE_CONFIG.thresholds.ram.value);
+        const strategy = QUEUE_CONFIG.thresholds.ram.strategy;
+        this.recordThrottle(`ram_${strategy}`);
+
+        if (strategy === 'reject') {
+          rejected = true;
+          rejectReason = reason;
+        } else if (strategy === 'dequeue-one-at-a-time') {
+          oneAtATime = true;
+          if (totalProcessing > 0) {
+            reasons.push(reason + ' (waiting for current command)');
+          }
+        } else {
+          // 'enqueue' - block unconditionally
+          reasons.push(reason);
+        }
       }
     }
 
     // Check CPU using 5-minute load average (more stable than 1-minute)
-    // Enqueue mode: blocks all commands unconditionally
     // Cache TTL is 2 minutes, which is appropriate for this metric
     const cpuResult = await getCachedCpuInfo(this.verbose);
     if (cpuResult.success) {
@@ -671,33 +716,55 @@ export class SolveQueue {
         this.log(`CPU 5m load avg: ${loadAvg5.toFixed(2)}, cpus: ${cpuCount}, usage: ${usagePercent}%`);
       }
 
-      if (usageRatio >= QUEUE_CONFIG.CPU_THRESHOLD) {
-        reasons.push(formatWaitingReason('cpu', usagePercent, QUEUE_CONFIG.CPU_THRESHOLD));
-        this.recordThrottle('cpu_high');
+      if (usageRatio >= QUEUE_CONFIG.thresholds.cpu.value) {
+        const reason = formatWaitingReason('cpu', usagePercent, QUEUE_CONFIG.thresholds.cpu.value);
+        const strategy = QUEUE_CONFIG.thresholds.cpu.strategy;
+        this.recordThrottle(`cpu_${strategy}`);
+
+        if (strategy === 'reject') {
+          rejected = true;
+          rejectReason = reason;
+        } else if (strategy === 'dequeue-one-at-a-time') {
+          oneAtATime = true;
+          if (totalProcessing > 0) {
+            reasons.push(reason + ' (waiting for current command)');
+          }
+        } else {
+          // 'enqueue' - block unconditionally
+          reasons.push(reason);
+        }
       }
     }
 
     // Check disk space (using cached value)
-    // One-at-a-time mode: allows exactly one command when nothing is processing
-    // Unlike RAM and CPU which block unconditionally, disk uses one-at-a-time mode
-    // because we cannot predict how much disk space a task will use
-    // See: https://github.com/link-assistant/hive-mind/issues/1155
+    // Default strategy changed to 'reject' because queue is lost on restart anyway
+    // See: https://github.com/link-assistant/hive-mind/issues/1253
     const diskResult = await getCachedDiskInfo(this.verbose);
     if (diskResult.success) {
       // Calculate usage from free percentage
       const usedPercent = 100 - diskResult.diskSpace.freePercentage;
       const usedRatio = usedPercent / 100;
-      if (usedRatio >= QUEUE_CONFIG.DISK_THRESHOLD) {
-        oneAtATime = true;
-        this.recordThrottle('disk_high');
-        // Only block if something is already processing (one-at-a-time mode)
-        if (totalProcessing > 0) {
-          reasons.push(formatWaitingReason('disk', usedPercent, QUEUE_CONFIG.DISK_THRESHOLD) + ' (waiting for current command)');
+      if (usedRatio >= QUEUE_CONFIG.thresholds.disk.value) {
+        const reason = formatWaitingReason('disk', usedPercent, QUEUE_CONFIG.thresholds.disk.value);
+        const strategy = QUEUE_CONFIG.thresholds.disk.strategy;
+        this.recordThrottle(`disk_${strategy}`);
+
+        if (strategy === 'reject') {
+          rejected = true;
+          rejectReason = reason;
+        } else if (strategy === 'dequeue-one-at-a-time') {
+          oneAtATime = true;
+          if (totalProcessing > 0) {
+            reasons.push(reason + ' (waiting for current command)');
+          }
+        } else {
+          // 'enqueue' - block unconditionally
+          reasons.push(reason);
         }
       }
     }
 
-    return { ok: reasons.length === 0, reasons, oneAtATime };
+    return { ok: reasons.length === 0 && !rejected, reasons, oneAtATime, rejected, rejectReason };
   }
 
   /**
@@ -714,14 +781,20 @@ export class SolveQueue {
    * - For Claude limits, only count Claude-specific processing items, not agent items.
    *   This allows agent tasks to run in parallel even when Claude limits are reached.
    *
+   * Logic per issue #1253:
+   * - All thresholds now support configurable strategies (reject, enqueue, dequeue-one-at-a-time)
+   * - Configuration via HIVE_MIND_QUEUE_CONFIG or individual env vars
+   *
    * @param {boolean} hasRunningClaude - Whether claude processes are running (from pgrep)
    * @param {number} claudeProcessingCount - Count of 'claude' tool items being processed in queue
    * @param {string} tool - The tool being used ('claude', 'agent', etc.)
-   * @returns {Promise<{ok: boolean, reasons: string[], oneAtATime: boolean}>}
+   * @returns {Promise<{ok: boolean, reasons: string[], oneAtATime: boolean, rejected: boolean, rejectReason: string|null}>}
    */
   async checkApiLimits(hasRunningClaude = false, claudeProcessingCount = 0, tool = 'claude') {
     const reasons = [];
     let oneAtATime = false;
+    let rejected = false;
+    let rejectReason = null;
 
     // Apply Claude-specific limits only when tool is 'claude'
     // Other tools (like 'agent') use different rate limiting backends and are not
@@ -744,32 +817,51 @@ export class SolveQueue {
         const weeklyPercent = claudeResult.usage.allModels.percentage;
 
         // Session limit (5-hour)
-        // When above threshold: allow exactly one Claude command, block if any Claude processing
-        // Only counts Claude-specific processing, not agent items
-        // See: https://github.com/link-assistant/hive-mind/issues/1133, #1159
+        // Configurable strategy via HIVE_MIND_QUEUE_CONFIG or HIVE_MIND_CLAUDE_5_HOUR_SESSION_STRATEGY
+        // See: https://github.com/link-assistant/hive-mind/issues/1133, #1159, #1253
         if (sessionPercent !== null) {
           const sessionRatio = sessionPercent / 100;
-          if (sessionRatio >= QUEUE_CONFIG.CLAUDE_5_HOUR_SESSION_THRESHOLD) {
-            oneAtATime = true;
-            this.recordThrottle(sessionRatio >= 1.0 ? 'claude_5_hour_session_100' : 'claude_5_hour_session_high');
-            // Use totalClaudeProcessing for Claude-specific one-at-a-time checking
-            if (totalClaudeProcessing > 0) {
-              reasons.push(formatWaitingReason('claude_5_hour_session', sessionPercent, QUEUE_CONFIG.CLAUDE_5_HOUR_SESSION_THRESHOLD) + ' (waiting for current command)');
+          if (sessionRatio >= QUEUE_CONFIG.thresholds.claude5Hour.value) {
+            const reason = formatWaitingReason('claude_5_hour_session', sessionPercent, QUEUE_CONFIG.thresholds.claude5Hour.value);
+            const strategy = QUEUE_CONFIG.thresholds.claude5Hour.strategy;
+            this.recordThrottle(sessionRatio >= 1.0 ? 'claude_5_hour_session_100' : `claude_5_hour_session_${strategy}`);
+
+            if (strategy === 'reject') {
+              rejected = true;
+              rejectReason = reason;
+            } else if (strategy === 'dequeue-one-at-a-time') {
+              oneAtATime = true;
+              if (totalClaudeProcessing > 0) {
+                reasons.push(reason + ' (waiting for current command)');
+              }
+            } else {
+              // 'enqueue' - block unconditionally
+              reasons.push(reason);
             }
           }
         }
 
         // Weekly limit
-        // When above threshold: allow exactly one Claude command, block if one is in progress
+        // Configurable strategy via HIVE_MIND_QUEUE_CONFIG or HIVE_MIND_CLAUDE_WEEKLY_STRATEGY
+        // See: https://github.com/link-assistant/hive-mind/issues/1133, #1159, #1253
         if (weeklyPercent !== null) {
           const weeklyRatio = weeklyPercent / 100;
-          if (weeklyRatio >= QUEUE_CONFIG.CLAUDE_WEEKLY_THRESHOLD) {
-            oneAtATime = true;
-            this.recordThrottle(weeklyRatio >= 1.0 ? 'claude_weekly_100' : 'claude_weekly_high');
-            // Use totalClaudeProcessing for Claude-specific one-at-a-time checking
-            // See: https://github.com/link-assistant/hive-mind/issues/1133, #1159
-            if (totalClaudeProcessing > 0) {
-              reasons.push(formatWaitingReason('claude_weekly', weeklyPercent, QUEUE_CONFIG.CLAUDE_WEEKLY_THRESHOLD) + ' (waiting for current command)');
+          if (weeklyRatio >= QUEUE_CONFIG.thresholds.claudeWeekly.value) {
+            const reason = formatWaitingReason('claude_weekly', weeklyPercent, QUEUE_CONFIG.thresholds.claudeWeekly.value);
+            const strategy = QUEUE_CONFIG.thresholds.claudeWeekly.strategy;
+            this.recordThrottle(weeklyRatio >= 1.0 ? 'claude_weekly_100' : `claude_weekly_${strategy}`);
+
+            if (strategy === 'reject') {
+              rejected = true;
+              rejectReason = reason;
+            } else if (strategy === 'dequeue-one-at-a-time') {
+              oneAtATime = true;
+              if (totalClaudeProcessing > 0) {
+                reasons.push(reason + ' (waiting for current command)');
+              }
+            } else {
+              // 'enqueue' - block unconditionally
+              reasons.push(reason);
             }
           }
         }
@@ -779,19 +871,34 @@ export class SolveQueue {
     }
 
     // Check GitHub limits (only relevant if claude processes running)
+    // Configurable strategy via HIVE_MIND_QUEUE_CONFIG or HIVE_MIND_GITHUB_API_STRATEGY
     if (hasRunningClaude) {
       const githubResult = await getCachedGitHubLimits(this.verbose);
       if (githubResult.success) {
         const usedPercent = githubResult.githubRateLimit.usedPercentage;
         const usedRatio = usedPercent / 100;
-        if (usedRatio >= QUEUE_CONFIG.GITHUB_API_THRESHOLD) {
-          reasons.push(formatWaitingReason('github', usedPercent, QUEUE_CONFIG.GITHUB_API_THRESHOLD));
-          this.recordThrottle(usedRatio >= 1.0 ? 'github_100' : 'github_high');
+        if (usedRatio >= QUEUE_CONFIG.thresholds.githubApi.value) {
+          const reason = formatWaitingReason('github', usedPercent, QUEUE_CONFIG.thresholds.githubApi.value);
+          const strategy = QUEUE_CONFIG.thresholds.githubApi.strategy;
+          this.recordThrottle(usedRatio >= 1.0 ? 'github_100' : `github_${strategy}`);
+
+          if (strategy === 'reject') {
+            rejected = true;
+            rejectReason = reason;
+          } else if (strategy === 'dequeue-one-at-a-time') {
+            oneAtATime = true;
+            if (totalClaudeProcessing > 0) {
+              reasons.push(reason + ' (waiting for current command)');
+            }
+          } else {
+            // 'enqueue' - block unconditionally
+            reasons.push(reason);
+          }
         }
       }
     }
 
-    return { ok: reasons.length === 0, reasons, oneAtATime };
+    return { ok: reasons.length === 0 && !rejected, reasons, oneAtATime, rejected, rejectReason };
   }
 
   /**