@link-assistant/hive-mind 1.20.1 → 1.21.1

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @link-assistant/hive-mind
 
+## 1.21.1
+
+### Patch Changes
+
+- fbfc0c3: Fix `--tool agent` pricing display for free models (Issue #1250)
+  - Add base model pricing lookup for free model variants (e.g., `kimi-k2.5-free` → `kimi-k2.5`)
+  - Show actual market price as "Public pricing estimate" based on the underlying paid model
+  - Display base model reference in cost output: "(based on Moonshot AI kimi-k2.5 prices)"
+  - Distinguish between truly free models and free access to paid models
+  - Fix token usage showing "0 input, 0 output" by accumulating tokens during streaming
+  - Token accumulation now happens in real-time as step_finish events arrive, avoiding NDJSON concatenation issues
+
+## 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

package/package.json

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

package/src/agent.lib.mjs

@@ -100,11 +100,59 @@ const getOriginalProviderName = providerId => {
   return providerMap[providerId] || providerId.charAt(0).toUpperCase() + providerId.slice(1);
 };
 
+/**
+ * Issue #1250: Normalize model name and find base model for pricing lookup
+ * Free models like "kimi-k2.5-free" should use pricing from base model "kimi-k2.5"
+ *
+ * @param {string} modelName - The model name (e.g., 'kimi-k2.5-free')
+ * @returns {Object} Object with:
+ *   - baseModelName: The base model name for pricing lookup
+ *   - isFreeVariant: Whether this is a free variant
+ */
+const getBaseModelForPricing = modelName => {
+  // Known mappings for free models to their base paid versions
+  const freeToBaseMap = {
+    'kimi-k2.5-free': 'kimi-k2.5',
+    'glm-4.7-free': 'glm-4.7',
+    'minimax-m2.1-free': 'minimax-m2.1',
+    'trinity-large-preview-free': 'trinity-large-preview',
+    // Grok models don't have a paid equivalent with same name
+    // These are kept as-is since they're truly free
+  };
+
+  // Check if there's a direct mapping
+  if (freeToBaseMap[modelName]) {
+    return {
+      baseModelName: freeToBaseMap[modelName],
+      isFreeVariant: true,
+    };
+  }
+
+  // Try removing "-free" suffix
+  if (modelName.endsWith('-free')) {
+    return {
+      baseModelName: modelName.replace(/-free$/, ''),
+      isFreeVariant: true,
+    };
+  }
+
+  // Not a free variant
+  return {
+    baseModelName: modelName,
+    isFreeVariant: false,
+  };
+};
+
 /**
  * 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.)
  *
+ * For free models like "kimi-k2.5-free", this function:
+ * 1. First fetches the free model info to get the model name
+ * 2. Then fetches the base model (e.g., "kimi-k2.5") for actual pricing
+ * 3. Calculates public pricing estimate based on the base model's cost
+ *
  * @param {string} modelId - The model ID used (e.g., 'opencode/grok-code')
  * @param {Object} tokenUsage - Token usage data from parseAgentTokenUsage
  * @returns {Object} Pricing information with:
@@ -122,40 +170,66 @@ export const calculateAgentPricing = async (modelId, tokenUsage) => {
   const providerFromModel = modelId.includes('/') ? modelId.split('/')[0] : null;
 
   // Get original provider name for pricing reference
-  const originalProvider = getOriginalProviderName(providerFromModel);
+  let originalProvider = getOriginalProviderName(providerFromModel);
 
   try {
     // Fetch model info from models.dev API
-    const modelInfo = await fetchModelInfo(modelName);
+    let modelInfo = await fetchModelInfo(modelName);
+
+    // Issue #1250: Check if model has zero pricing (free model from OpenCode Zen)
+    // If so, look up the base model for actual public pricing estimate
+    const { baseModelName, isFreeVariant } = getBaseModelForPricing(modelName);
+    let baseModelInfo = null;
+    let pricingCost = modelInfo?.cost;
+
+    if (modelInfo && modelInfo.cost && modelInfo.cost.input === 0 && modelInfo.cost.output === 0 && baseModelName !== modelName) {
+      // This is a free model with zero pricing - look up base model for public pricing
+      baseModelInfo = await fetchModelInfo(baseModelName);
+      if (baseModelInfo && baseModelInfo.cost) {
+        // Use base model pricing for public estimate
+        pricingCost = baseModelInfo.cost;
+        // Update original provider from base model if available
+        if (baseModelInfo.provider && !originalProvider) {
+          originalProvider = baseModelInfo.provider;
+        }
+      }
+    }
 
-    if (modelInfo && modelInfo.cost) {
-      const cost = modelInfo.cost;
+    if (modelInfo || baseModelInfo) {
+      const effectiveModelInfo = modelInfo || baseModelInfo;
+      const cost = pricingCost || { input: 0, output: 0, cache_read: 0, cache_write: 0, reasoning: 0 };
 
       // Calculate public pricing estimate based on original provider prices
       // Prices are per 1M tokens, so divide by 1,000,000
+      // All priced components from models.dev: input, output, cache_read, cache_write, reasoning
       const inputCost = (tokenUsage.inputTokens * (cost.input || 0)) / 1_000_000;
       const outputCost = (tokenUsage.outputTokens * (cost.output || 0)) / 1_000_000;
       const cacheReadCost = (tokenUsage.cacheReadTokens * (cost.cache_read || 0)) / 1_000_000;
       const cacheWriteCost = (tokenUsage.cacheWriteTokens * (cost.cache_write || 0)) / 1_000_000;
+      const reasoningCost = (tokenUsage.reasoningTokens * (cost.reasoning || 0)) / 1_000_000;
 
-      const totalCost = inputCost + outputCost + cacheReadCost + cacheWriteCost;
+      const totalCost = inputCost + outputCost + cacheReadCost + cacheWriteCost + reasoningCost;
 
       // 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';
+      const isOpencodeFreeModel = providerFromModel === 'opencode' || isFreeVariant || modelName.toLowerCase().includes('free') || modelName.toLowerCase().includes('grok') || providerFromModel === 'moonshot' || providerFromModel === 'openai' || providerFromModel === 'anthropic';
+
+      // Use base model's provider for original provider reference if available
+      const effectiveOriginalProvider = baseModelInfo?.provider || originalProvider || effectiveModelInfo?.provider || null;
 
       return {
         modelId,
-        modelName: modelInfo.name || modelName,
+        modelName: effectiveModelInfo?.name || modelName,
         // 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,
+        originalProvider: effectiveOriginalProvider,
         pricing: {
           inputPerMillion: cost.input || 0,
           outputPerMillion: cost.output || 0,
           cacheReadPerMillion: cost.cache_read || 0,
           cacheWritePerMillion: cost.cache_write || 0,
+          reasoningPerMillion: cost.reasoning || 0,
         },
         tokenUsage,
         breakdown: {
@@ -163,15 +237,18 @@ export const calculateAgentPricing = async (modelId, tokenUsage) => {
           output: outputCost,
           cacheRead: cacheReadCost,
           cacheWrite: cacheWriteCost,
+          reasoning: reasoningCost,
         },
-        // Public pricing estimate based on original provider prices
+        // Public pricing estimate based on original/base model 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,
+        // Keep for backward compatibility - indicates if the accessed model has zero pricing
+        isFreeModel: modelInfo?.cost?.input === 0 && modelInfo?.cost?.output === 0,
         // New flag to indicate if OpenCode Zen provides this model for free
         isOpencodeFreeModel,
+        // Issue #1250: Include base model info for transparency
+        baseModelName: baseModelName !== modelName ? baseModelName : null,
       };
     }
     // Model not found in API, return what we have
@@ -476,11 +553,39 @@ export const executeAgentCommand = async params => {
       let limitReached = false;
       let limitResetTime = null;
       let lastMessage = '';
-      let fullOutput = ''; // Collect all output for pricing calculation and error detection
+      let fullOutput = ''; // Collect all output for error detection (kept for backward compatibility)
       // Issue #1201: Track error events detected during streaming for reliable error detection
       // Post-hoc detection on fullOutput can miss errors if NDJSON lines get concatenated without newlines
       let streamingErrorDetected = false;
       let streamingErrorMessage = null;
+      // Issue #1250: Accumulate token usage during streaming instead of parsing fullOutput later
+      // This fixes the issue where NDJSON lines get concatenated without newlines, breaking JSON.parse
+      const streamingTokenUsage = {
+        inputTokens: 0,
+        outputTokens: 0,
+        reasoningTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        totalCost: 0,
+        stepCount: 0,
+      };
+      // Helper to accumulate tokens from step_finish events during streaming
+      const accumulateTokenUsage = data => {
+        if (data.type === 'step_finish' && data.part?.tokens) {
+          const tokens = data.part.tokens;
+          streamingTokenUsage.stepCount++;
+          if (tokens.input) streamingTokenUsage.inputTokens += tokens.input;
+          if (tokens.output) streamingTokenUsage.outputTokens += tokens.output;
+          if (tokens.reasoning) streamingTokenUsage.reasoningTokens += tokens.reasoning;
+          if (tokens.cache) {
+            if (tokens.cache.read) streamingTokenUsage.cacheReadTokens += tokens.cache.read;
+            if (tokens.cache.write) streamingTokenUsage.cacheWriteTokens += tokens.cache.write;
+          }
+          if (data.part.cost !== undefined) {
+            streamingTokenUsage.totalCost += data.part.cost;
+          }
+        }
+      };
 
       for await (const chunk of execCommand.stream()) {
         if (chunk.type === 'stdout') {
@@ -500,6 +605,8 @@ export const executeAgentCommand = async params => {
                 sessionId = data.sessionID;
                 await log(`📌 Session ID: ${sessionId}`);
               }
+              // Issue #1250: Accumulate token usage during streaming
+              accumulateTokenUsage(data);
               // Issue #1201: Detect error events during streaming for reliable detection
               if (data.type === 'error' || data.type === 'step_error') {
                 streamingErrorDetected = true;
@@ -532,6 +639,8 @@ export const executeAgentCommand = async params => {
                   sessionId = stderrData.sessionID;
                   await log(`📌 Session ID: ${sessionId}`);
                 }
+                // Issue #1250: Accumulate token usage during streaming (stderr)
+                accumulateTokenUsage(stderrData);
                 // Issue #1201: Detect error events during streaming (stderr) for reliable detection
                 if (stderrData.type === 'error' || stderrData.type === 'step_error') {
                   streamingErrorDetected = true;
@@ -646,8 +755,9 @@ export const executeAgentCommand = async params => {
         await log(`   Memory: ${resourcesAfter.memory.split('\n')[1]}`, { verbose: true });
         await log(`   Load: ${resourcesAfter.load}`, { verbose: true });
 
-        // Parse token usage even on failure (partial work may have been done)
-        const tokenUsage = parseAgentTokenUsage(fullOutput);
+        // Issue #1250: Use streaming-accumulated token usage instead of re-parsing fullOutput
+        // This fixes the issue where NDJSON lines get concatenated without newlines, breaking JSON.parse
+        const tokenUsage = streamingTokenUsage;
         const pricingInfo = await calculateAgentPricing(mappedModel, tokenUsage);
 
         return {
@@ -664,29 +774,47 @@ export const executeAgentCommand = async params => {
 
       await log('\n\n✅ Agent command completed');
 
-      // Parse token usage from collected output
-      const tokenUsage = parseAgentTokenUsage(fullOutput);
+      // Issue #1250: Use streaming-accumulated token usage instead of re-parsing fullOutput
+      // This fixes the issue where NDJSON lines get concatenated without newlines, breaking JSON.parse
+      const tokenUsage = streamingTokenUsage;
       const pricingInfo = await calculateAgentPricing(mappedModel, tokenUsage);
 
-      // Log pricing information
+      // Log pricing information (similar to --tool claude breakdown)
       if (tokenUsage.stepCount > 0) {
         await log('\n💰 Token Usage Summary:');
-        await log(`   📊 ${pricingInfo.modelName || mappedModel}:`);
-        await log(`      Input tokens: ${tokenUsage.inputTokens.toLocaleString()}`);
-        await log(`      Output tokens: ${tokenUsage.outputTokens.toLocaleString()}`);
+        await log(`   📊 ${pricingInfo.modelName || mappedModel} (${tokenUsage.stepCount} steps):`);
+        await log(`      Input tokens:     ${tokenUsage.inputTokens.toLocaleString()}`);
+        await log(`      Output tokens:    ${tokenUsage.outputTokens.toLocaleString()}`);
         if (tokenUsage.reasoningTokens > 0) {
           await log(`      Reasoning tokens: ${tokenUsage.reasoningTokens.toLocaleString()}`);
         }
         if (tokenUsage.cacheReadTokens > 0 || tokenUsage.cacheWriteTokens > 0) {
-          await log(`      Cache read: ${tokenUsage.cacheReadTokens.toLocaleString()}`);
-          await log(`      Cache write: ${tokenUsage.cacheWriteTokens.toLocaleString()}`);
+          await log(`      Cache read:       ${tokenUsage.cacheReadTokens.toLocaleString()}`);
+          await log(`      Cache write:      ${tokenUsage.cacheWriteTokens.toLocaleString()}`);
         }
 
-        if (pricingInfo.totalCostUSD !== null) {
-          if (pricingInfo.isFreeModel) {
-            await log('      Cost: $0.00 (Free model)');
-          } else {
-            await log(`      Cost: $${pricingInfo.totalCostUSD.toFixed(6)}`);
+        if (pricingInfo.totalCostUSD !== null && pricingInfo.breakdown) {
+          // Show per-component cost breakdown (similar to --tool claude)
+          await log('      Cost breakdown:');
+          await log(`        Input:      $${pricingInfo.breakdown.input.toFixed(6)} (${(pricingInfo.pricing?.inputPerMillion || 0).toFixed(2)}/M tokens)`);
+          await log(`        Output:     $${pricingInfo.breakdown.output.toFixed(6)} (${(pricingInfo.pricing?.outputPerMillion || 0).toFixed(2)}/M tokens)`);
+          if (tokenUsage.cacheReadTokens > 0) {
+            await log(`        Cache read: $${pricingInfo.breakdown.cacheRead.toFixed(6)} (${(pricingInfo.pricing?.cacheReadPerMillion || 0).toFixed(2)}/M tokens)`);
+          }
+          if (tokenUsage.cacheWriteTokens > 0) {
+            await log(`        Cache write: $${pricingInfo.breakdown.cacheWrite.toFixed(6)} (${(pricingInfo.pricing?.cacheWritePerMillion || 0).toFixed(2)}/M tokens)`);
+          }
+          if (tokenUsage.reasoningTokens > 0 && pricingInfo.breakdown.reasoning > 0) {
+            await log(`        Reasoning:  $${pricingInfo.breakdown.reasoning.toFixed(6)} (${(pricingInfo.pricing?.reasoningPerMillion || 0).toFixed(2)}/M tokens)`);
+          }
+          // Show public pricing estimate
+          const pricingRef = pricingInfo.baseModelName && pricingInfo.originalProvider ? ` (based on ${pricingInfo.originalProvider} ${pricingInfo.baseModelName} prices)` : pricingInfo.originalProvider ? ` (based on ${pricingInfo.originalProvider} prices)` : '';
+          await log(`      Public pricing estimate: $${pricingInfo.totalCostUSD.toFixed(6)}${pricingRef}`);
+          // Show actual OpenCode Zen cost
+          if (pricingInfo.isOpencodeFreeModel) {
+            await log('      Calculated by OpenCode Zen: $0.00 (Free model)');
+          } else if (pricingInfo.opencodeCost !== undefined) {
+            await log(`      Calculated by OpenCode Zen: $${pricingInfo.opencodeCost.toFixed(6)}`);
           }
           await log(`      Provider: ${pricingInfo.provider || 'OpenCode Zen'}`);
         } else {

package/src/github.lib.mjs

@@ -30,6 +30,7 @@ import { uploadLogWithGhUploadLog } from './log-upload.lib.mjs';
  *   - 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
+ *   - baseModelName: Base model name if pricing was derived from base model (Issue #1250)
  * @returns {string} Formatted cost info string for markdown (empty if no data available)
  */
 const buildCostInfoString = (totalCostUSD, anthropicTotalCostUSD, pricingInfo) => {
@@ -47,13 +48,20 @@ const buildCostInfoString = (totalCostUSD, anthropicTotalCostUSD, pricingInfo) =
   }
   // Issue #1250: Show public pricing estimate based on original provider prices
   if (hasPublic) {
-    // For models with zero pricing from original provider, show as free
-    if (pricingInfo?.isFreeModel && totalCostUSD === 0) {
+    // Issue #1250: For free models accessed via OpenCode Zen, show pricing based on base model
+    // Only show as completely free if the base model also has no pricing
+    if (pricingInfo?.isFreeModel && totalCostUSD === 0 && !pricingInfo?.baseModelName) {
       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}`;
+      // Issue #1250: Include base model reference when pricing comes from base model
+      let pricingRef = '';
+      if (pricingInfo?.baseModelName && pricingInfo?.originalProvider) {
+        pricingRef = ` (based on ${pricingInfo.originalProvider} ${pricingInfo.baseModelName} prices)`;
+      } else if (pricingInfo?.originalProvider) {
+        pricingRef = ` (based on ${pricingInfo.originalProvider} prices)`;
+      }
+      costInfo += `\n- Public pricing estimate: $${totalCostUSD.toFixed(6)}${pricingRef}`;
     }
   } else if (hasPricing) {
     costInfo += '\n- Public pricing estimate: unknown';

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 };
   }
 
   /**