@link-assistant/hive-mind 1.38.0 → 1.38.2

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @link-assistant/hive-mind
 
+## 1.38.2
+
+### Patch Changes
+
+- 290139f: fix: correct cost and token/context budget calculations (#1501)
+  - Deduplicate JSONL session entries by message ID to fix inflated token counts caused by upstream anthropics/claude-code#6805
+  - Show peak context window usage (max single-request fill) instead of cumulative sum which produced nonsensical percentages like 7516%
+  - Add "Total tokens processed" as a separate cumulative metric for session throughput visibility
+  - Add verbose logging for JSONL deduplication stats and peak context values
+
+## 1.38.1
+
+### Patch Changes
+
+- 1525ecb: fix: prevent 'Failed to send formatted message' Telegram error by adding safeReply helper and escaping unescaped Markdown in bot messages
+
 ## 1.38.0
 
 ### Minor Changes

package/package.json

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

package/src/claude.budget-stats.lib.mjs

@@ -14,6 +14,8 @@ export const createEmptySubSessionUsage = () => ({
   cacheReadTokens: 0,
   outputTokens: 0,
   messageCount: 0,
+  peakContextUsage: 0,
+  peakOutputUsage: 0,
 });
 
 /**
@@ -136,173 +138,161 @@ export const displayCostComparison = async (publicCost, anthropicCost, log) => {
 /**
  * Display token budget statistics (context window usage and ratios)
  * @param {Object} usage - Usage data for a model
+ * @param {Object} tokenUsage - Full token usage data (with subSessions)
  * @param {Function} log - Logging function
  */
-export const displayBudgetStats = async (usage, log) => {
+export const displayBudgetStats = async (usage, tokenUsage, log) => {
   const modelInfo = usage.modelInfo;
   if (!modelInfo?.limit) {
     await log('\n      ⚠️  Budget stats not available (no model limits found)');
     return;
   }
 
-  await log('\n      📊 Token Budget Statistics:');
+  await log('\n      📊 Context and tokens usage:');
 
-  // Context window usage
-  if (modelInfo.limit.context) {
-    const contextLimit = modelInfo.limit.context;
-    // Input tokens include regular input + cache creation + cache read
-    const totalInputUsed = usage.inputTokens + usage.cacheCreationTokens + usage.cacheReadTokens;
-    const contextUsageRatio = totalInputUsed / contextLimit;
-    const contextUsagePercent = (contextUsageRatio * 100).toFixed(2);
+  const contextLimit = modelInfo.limit.context;
+  const outputLimit = modelInfo.limit.output;
+  const subSessions = tokenUsage?.subSessions || [];
+  const hasMultipleSubSessions = subSessions.length > 1;
 
-    await log('        Context window:');
-    await log(`          Used: ${formatNumber(totalInputUsed)} tokens`);
-    await log(`          Limit: ${formatNumber(contextLimit)} tokens`);
-    await log(`          Ratio: ${contextUsageRatio.toFixed(4)} (${contextUsagePercent}%)`);
-  }
-
-  // Output tokens usage
-  if (modelInfo.limit.output) {
-    const outputLimit = modelInfo.limit.output;
-    const outputUsageRatio = usage.outputTokens / outputLimit;
-    const outputUsagePercent = (outputUsageRatio * 100).toFixed(2);
-
-    await log('        Output tokens:');
-    await log(`          Used: ${formatNumber(usage.outputTokens)} tokens`);
-    await log(`          Limit: ${formatNumber(outputLimit)} tokens`);
-    await log(`          Ratio: ${outputUsageRatio.toFixed(4)} (${outputUsagePercent}%)`);
-  }
-
-  // Total session tokens (input + cache_creation + output)
-  const totalSessionTokens = usage.inputTokens + usage.cacheCreationTokens + usage.outputTokens;
-  await log(`        Total session tokens: ${formatNumber(totalSessionTokens)}`);
-};
-
-/**
- * Display sub-session breakdown when compactification events occurred (Issue #1491)
- * @param {Object} tokenUsage - Token usage data with subSessions and compactifications
- * @param {Object} modelInfo - Model info with context/output limits
- * @param {Function} log - Logging function
- */
-export const displaySubSessionStats = async (tokenUsage, modelInfo, log) => {
-  if (!tokenUsage.subSessions || !tokenUsage.compactifications) return;
-
-  const contextLimit = modelInfo?.limit?.context;
-  await log(`\n      🔄 Compactification events: ${tokenUsage.compactifications.length}`);
-
-  for (let i = 0; i < tokenUsage.subSessions.length; i++) {
-    const sub = tokenUsage.subSessions[i];
-    const totalInput = sub.inputTokens + sub.cacheCreationTokens + sub.cacheReadTokens;
-    const label = i === 0 ? 'Initial session' : `After compactification #${i}`;
-
-    await log(`        Sub-session ${i + 1} (${label}):`);
-    await log(`          Messages: ${sub.messageCount}`);
-    await log(`          Context used: ${formatNumber(totalInput)} tokens`);
+  if (hasMultipleSubSessions) {
+    await log('        Sub sessions (between compact events):');
+    for (let i = 0; i < subSessions.length; i++) {
+      const sub = subSessions[i];
+      const subPeak = sub.peakContextUsage || 0;
+      let line = `          ${i + 1}. `;
+      if (contextLimit && subPeak > 0) {
+        const pct = ((subPeak / contextLimit) * 100).toFixed(0);
+        line += `${formatNumber(subPeak)} / ${formatNumber(contextLimit)} input tokens (${pct}%)`;
+      } else {
+        const subTotal = sub.inputTokens + sub.cacheCreationTokens + sub.cacheReadTokens;
+        line += `${formatNumber(subTotal)} input tokens`;
+      }
+      if (outputLimit) {
+        const outPct = ((sub.outputTokens / outputLimit) * 100).toFixed(0);
+        line += `; ${formatNumber(sub.outputTokens)} / ${formatNumber(outputLimit)} output tokens (${outPct}%)`;
+      } else {
+        line += `; ${formatNumber(sub.outputTokens)} output tokens`;
+      }
+      await log(line);
+    }
+  } else {
+    // Single sub-session: simplified format
+    const peakContext = usage.peakContextUsage || 0;
     if (contextLimit) {
-      const pct = ((totalInput / contextLimit) * 100).toFixed(2);
-      await log(`          Context usage: ${pct}% of ${formatNumber(contextLimit)}`);
+      if (peakContext > 0) {
+        const pct = ((peakContext / contextLimit) * 100).toFixed(0);
+        await log(`        Max context window: ${formatNumber(peakContext)} / ${formatNumber(contextLimit)} input tokens (${pct}%)`);
+      }
+    }
+    if (outputLimit) {
+      const outPct = ((usage.outputTokens / outputLimit) * 100).toFixed(0);
+      await log(`        Max output tokens: ${formatNumber(usage.outputTokens)} / ${formatNumber(outputLimit)} output tokens (${outPct}%)`);
     }
-    await log(`          Output: ${formatNumber(sub.outputTokens)} tokens`);
   }
 
-  // Show compactification details
-  for (let i = 0; i < tokenUsage.compactifications.length; i++) {
-    const comp = tokenUsage.compactifications[i];
-    let detail = `        Compactification #${i + 1}: trigger=${comp.trigger}`;
-    if (comp.preTokens) detail += `, pre-compaction tokens=${formatNumber(comp.preTokens)}`;
-    await log(detail);
-  }
+  // Cumulative totals
+  const totalInputNonCached = usage.inputTokens + usage.cacheCreationTokens;
+  const cachedTokens = usage.cacheReadTokens;
+  let totalLine = `        Total input tokens: ${formatNumber(totalInputNonCached)}`;
+  if (cachedTokens > 0) totalLine += ` + ${formatNumber(cachedTokens)} cached`;
+  await log(totalLine);
+  await log(`        Total output tokens: ${formatNumber(usage.outputTokens)}`);
 };
 
 /**
- * Display stream vs JSONL token comparison (Issue #1491)
- * Shows independent calculation from stream events vs JSONL session file
- * @param {Object} streamTokenUsage - Token usage accumulated from stream JSON events
- * @param {Object} jsonlTokenUsage - Token usage calculated from JSONL session file
- * @param {Function} log - Logging function
+ * Format a token count with K/M suffix for compact display
+ * @param {number} tokens - Token count
+ * @returns {string} Formatted string like "850K" or "1.5M"
  */
-export const displayTokenComparison = async (streamTokenUsage, jsonlTokenUsage, log) => {
-  if (!streamTokenUsage || !jsonlTokenUsage) return;
-
-  const streamTotal = streamTokenUsage.inputTokens + streamTokenUsage.cacheCreationTokens + streamTokenUsage.outputTokens;
-  const jsonlTotal = jsonlTokenUsage.inputTokens + jsonlTokenUsage.cacheCreationTokens + jsonlTokenUsage.outputTokens;
-
-  await log('\n      🔍 Token calculation comparison:');
-  await log(`        Stream JSON events: ${formatNumber(streamTotal)} tokens (${streamTokenUsage.eventCount} events)`);
-  await log(`        JSONL session file: ${formatNumber(jsonlTotal)} tokens`);
-
-  if (streamTotal !== jsonlTotal) {
-    const diff = jsonlTotal - streamTotal;
-    const pct = streamTotal > 0 ? ((diff / streamTotal) * 100).toFixed(2) : 'N/A';
-    await log(`        Difference: ${formatNumber(Math.abs(diff))} tokens (${diff > 0 ? '+' : ''}${pct}%)`);
-  } else {
-    await log('        Match: calculations are consistent');
-  }
+const formatTokensCompact = tokens => {
+  if (tokens >= 1000000) return `${(tokens / 1000000).toFixed(tokens % 1000000 === 0 ? 0 : 1)}M`;
+  if (tokens >= 1000) return `${(tokens / 1000).toFixed(tokens % 1000 === 0 ? 0 : 1)}K`;
+  return tokens.toLocaleString();
 };
 
 /**
- * Build budget stats string for GitHub PR comments (Issue #1491)
- * Similar to buildCostInfoString but for token budget statistics
+ * Build budget stats string for GitHub PR comments (Issue #1491, #1501)
+ * Format requested by user: sub-sessions between compactification events,
+ * per-model breakdown, cumulative totals with cached tokens shown separately.
  * @param {Object} tokenUsage - Token usage data from calculateSessionTokens
- * @param {Object|null} streamTokenUsage - Token usage from stream JSON events
+ * @param {Object|null} streamTokenUsage - Token usage from stream JSON events (used for comparison, not displayed)
  * @returns {string} Formatted markdown string for PR comment
  */
-export const buildBudgetStatsString = (tokenUsage, streamTokenUsage) => {
+export const buildBudgetStatsString = tokenUsage => {
   if (!tokenUsage) return '';
 
-  let stats = '\n\n### 📊 **Token budget statistics:**';
+  let stats = '\n\n### 📊 **Context and tokens usage:**';
 
   // Per-model breakdown
   if (tokenUsage.modelUsage) {
     const modelIds = Object.keys(tokenUsage.modelUsage);
+    const isMultiModel = modelIds.length > 1;
+
     for (const modelId of modelIds) {
       const usage = tokenUsage.modelUsage[modelId];
       const modelName = usage.modelName || modelId;
       const contextLimit = usage.modelInfo?.limit?.context;
       const outputLimit = usage.modelInfo?.limit?.output;
-      const totalInput = usage.inputTokens + usage.cacheCreationTokens + usage.cacheReadTokens;
 
-      if (modelIds.length > 1) stats += `\n- **${modelName}**:`;
+      if (isMultiModel) stats += `\n\n**${modelName}:**`;
 
-      if (contextLimit) {
-        const contextPct = ((totalInput / contextLimit) * 100).toFixed(2);
-        stats += `\n- Context window: ${totalInput.toLocaleString()} / ${contextLimit.toLocaleString()} tokens (${contextPct}%)`;
-      } else {
-        stats += `\n- Context tokens used: ${totalInput.toLocaleString()}`;
-      }
+      // Sub-session display (Issue #1501: show per sub-session stats)
+      const subSessions = tokenUsage.subSessions || [];
+      const hasMultipleSubSessions = subSessions.length > 1;
 
-      if (outputLimit) {
-        const outputPct = ((usage.outputTokens / outputLimit) * 100).toFixed(2);
-        stats += `\n- Output tokens: ${usage.outputTokens.toLocaleString()} / ${outputLimit.toLocaleString()} tokens (${outputPct}%)`;
+      if (hasMultipleSubSessions) {
+        // Multiple sub-sessions: show numbered list
+        stats += '\n\nSub sessions (between compact events):';
+        for (let i = 0; i < subSessions.length; i++) {
+          const sub = subSessions[i];
+          const subPeakContext = sub.peakContextUsage || 0;
+          const subTotalInput = sub.inputTokens + sub.cacheCreationTokens + sub.cacheReadTokens;
+          let line = `\n${i + 1}. `;
+          if (contextLimit && subPeakContext > 0) {
+            const pct = ((subPeakContext / contextLimit) * 100).toFixed(0);
+            line += `${formatTokensCompact(subPeakContext)} / ${formatTokensCompact(contextLimit)} input tokens (${pct}%)`;
+          } else {
+            line += `${formatTokensCompact(subTotalInput)} input tokens`;
+          }
+          if (outputLimit) {
+            const outPct = ((sub.outputTokens / outputLimit) * 100).toFixed(0);
+            line += `; ${formatTokensCompact(sub.outputTokens)} / ${formatTokensCompact(outputLimit)} output tokens (${outPct}%)`;
+          } else {
+            line += `; ${formatTokensCompact(sub.outputTokens)} output tokens`;
+          }
+          stats += line;
+        }
       } else {
-        stats += `\n- Output tokens: ${usage.outputTokens.toLocaleString()}`;
+        // Single sub-session (or no sub-sessions): simplified format
+        const peakContext = usage.peakContextUsage || 0;
+        if (contextLimit) {
+          if (peakContext > 0) {
+            const pct = ((peakContext / contextLimit) * 100).toFixed(0);
+            stats += `\n- Max context window: ${formatTokensCompact(peakContext)} / ${formatTokensCompact(contextLimit)} input tokens (${pct}%)`;
+          } else {
+            const totalInput = usage.inputTokens + usage.cacheCreationTokens + usage.cacheReadTokens;
+            const pct = ((totalInput / contextLimit) * 100).toFixed(0);
+            stats += `\n- Context window: ${formatTokensCompact(totalInput)} / ${formatTokensCompact(contextLimit)} tokens (${pct}%)`;
+          }
+        }
+        if (outputLimit) {
+          const outPct = ((usage.outputTokens / outputLimit) * 100).toFixed(0);
+          stats += `\n- Max output tokens: ${formatTokensCompact(usage.outputTokens)} / ${formatTokensCompact(outputLimit)} output tokens (${outPct}%)`;
+        }
       }
-    }
-  }
 
-  // Sub-session breakdown if compactification occurred
-  if (tokenUsage.subSessions && tokenUsage.compactifications) {
-    stats += `\n- Compactifications: ${tokenUsage.compactifications.length}`;
-    for (let i = 0; i < tokenUsage.subSessions.length; i++) {
-      const sub = tokenUsage.subSessions[i];
-      const totalInput = sub.inputTokens + sub.cacheCreationTokens + sub.cacheReadTokens;
-      const label = i === 0 ? 'initial' : `after compactification #${i}`;
-      stats += `\n  - Sub-session ${i + 1} (${label}): ${totalInput.toLocaleString()} context, ${sub.outputTokens.toLocaleString()} output, ${sub.messageCount} messages`;
+      // Cumulative totals: input tokens + cached shown separately
+      const totalInputNonCached = usage.inputTokens + usage.cacheCreationTokens;
+      const cachedTokens = usage.cacheReadTokens;
+      stats += `\n\nTotal input tokens: ${formatTokensCompact(totalInputNonCached)}`;
+      if (cachedTokens > 0) stats += ` + ${formatTokensCompact(cachedTokens)} cached`;
+      stats += `\nTotal output tokens: ${formatTokensCompact(usage.outputTokens)} output`;
     }
   }
 
-  // Stream vs JSONL comparison
-  if (streamTokenUsage) {
-    const streamTotal = streamTokenUsage.inputTokens + streamTokenUsage.cacheCreationTokens + streamTokenUsage.outputTokens;
-    const jsonlTotal = tokenUsage.inputTokens + tokenUsage.cacheCreationTokens + tokenUsage.outputTokens;
-    stats += `\n- Own calculation (stream): ${streamTotal.toLocaleString()} tokens (${streamTokenUsage.eventCount} events)`;
-    stats += `\n- JSONL calculation: ${jsonlTotal.toLocaleString()} tokens`;
-    if (streamTotal !== jsonlTotal) {
-      const diff = jsonlTotal - streamTotal;
-      const pct = streamTotal > 0 ? ((diff / streamTotal) * 100).toFixed(2) : 'N/A';
-      stats += ` (diff: ${diff > 0 ? '+' : ''}${pct}%)`;
-    }
-  }
+  // Stream vs JSONL comparison — kept for internal diagnostics only in verbose/debug mode
+  // Not shown to users per feedback (Issue #1501 PR comment)
 
   return stats;
 };

package/src/claude.lib.mjs

@@ -12,7 +12,7 @@ import { timeouts, retryLimits, claudeCode, getClaudeEnv, getThinkingLevelToToke
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
 import { createInteractiveHandler } from './interactive-mode.lib.mjs';
 import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
-import { displayBudgetStats, displaySubSessionStats, displayTokenComparison, createEmptySubSessionUsage, accumulateModelUsage, displayModelUsage, displayCostComparison } from './claude.budget-stats.lib.mjs';
+import { displayBudgetStats, createEmptySubSessionUsage, accumulateModelUsage, displayModelUsage, displayCostComparison } from './claude.budget-stats.lib.mjs';
 import { buildClaudeResumeCommand } from './claude.command-builder.lib.mjs';
 import { handleClaudeRuntimeSwitch } from './claude.runtime-switch.lib.mjs'; // see issue #1141
 import { CLAUDE_MODELS as availableModels } from './models/index.mjs'; // Issue #1221
@@ -497,6 +497,15 @@ export const calculateSessionTokens = async (sessionId, tempDir) => {
   }
   // Initialize per-model usage tracking
   const modelUsage = {};
+  // Issue #1501: Deduplicate JSONL entries by message ID (upstream: anthropics/claude-code#6805)
+  // Claude Code's stream-json mode splits single API responses with multiple content blocks
+  // into separate JSONL entries, each with the same message ID and identical usage stats.
+  const seenMessageIds = new Set();
+  let duplicateCount = 0;
+  // Issue #1501: Track peak context usage per request (not cumulative)
+  // The context window limit is per-request, so we track the max single-request fill.
+  const peakContextByModel = {};
+  let globalPeakContext = 0;
   // Issue #1491: Track sub-sessions between compactification events
   const subSessions = [];
   let currentSubSession = createEmptySubSessionUsage();
@@ -524,14 +533,39 @@ export const calculateSessionTokens = async (sessionId, tempDir) => {
           continue;
         }
         if (entry.message && entry.message.usage && entry.message.model) {
+          // Issue #1501: Skip duplicate JSONL entries (same message ID = same API response)
+          const msgId = entry.message.id;
+          if (msgId) {
+            if (seenMessageIds.has(msgId)) {
+              duplicateCount++;
+              continue; // Skip — already counted this message's usage
+            }
+            seenMessageIds.add(msgId);
+          }
           accumulateModelUsage(modelUsage, entry);
-          // Issue #1491: Also track per-sub-session usage
+          // Issue #1501: Track peak context usage per single API request
           const usage = entry.message.usage;
+          const requestContext = (usage.input_tokens || 0) + (usage.cache_creation_input_tokens || 0) + (usage.cache_read_input_tokens || 0);
+          const model = entry.message.model;
+          if (requestContext > (peakContextByModel[model] || 0)) {
+            peakContextByModel[model] = requestContext;
+          }
+          if (requestContext > globalPeakContext) {
+            globalPeakContext = requestContext;
+          }
+          // Issue #1491: Also track per-sub-session usage
           if (usage.input_tokens) currentSubSession.inputTokens += usage.input_tokens;
           if (usage.cache_creation_input_tokens) currentSubSession.cacheCreationTokens += usage.cache_creation_input_tokens;
           if (usage.cache_read_input_tokens) currentSubSession.cacheReadTokens += usage.cache_read_input_tokens;
           if (usage.output_tokens) currentSubSession.outputTokens += usage.output_tokens;
           currentSubSession.messageCount++;
+          // Issue #1501: Track peak context and output per sub-session
+          if (requestContext > currentSubSession.peakContextUsage) {
+            currentSubSession.peakContextUsage = requestContext;
+          }
+          if ((usage.output_tokens || 0) > currentSubSession.peakOutputUsage) {
+            currentSubSession.peakOutputUsage = usage.output_tokens || 0;
+          }
         }
       } catch {
         // Skip lines that aren't valid JSON
@@ -561,6 +595,8 @@ export const calculateSessionTokens = async (sessionId, tempDir) => {
     // Calculate cost for each model and store all characteristics
     for (const [modelId, usage] of Object.entries(modelUsage)) {
       const modelInfo = modelInfoMap[modelId];
+      // Issue #1501: Attach peak context usage per model
+      usage.peakContextUsage = peakContextByModel[modelId] || 0;
       // Calculate cost using pricing API
       if (modelInfo) {
         const costData = calculateModelCost(usage, modelInfo, true);
@@ -604,8 +640,11 @@ export const calculateSessionTokens = async (sessionId, tempDir) => {
       outputTokens: totalOutputTokens,
       totalTokens,
       totalCostUSD: hasCostData ? totalCostUSD : null,
-      // Issue #1491: Sub-session and compactification data
-      subSessions: subSessions.length > 1 ? subSessions : null, // Only include if compactification occurred
+      // Issue #1501: Peak context usage (max single-request fill) and dedup stats
+      peakContextUsage: globalPeakContext,
+      duplicateEntriesSkipped: duplicateCount,
+      // Issue #1491/#1501: Sub-session and compactification data (always include for display)
+      subSessions,
       compactifications: compactifications.length > 0 ? compactifications : null,
     };
   } catch (readError) {
@@ -1248,6 +1287,13 @@ export const executeClaudeCommand = async params => {
         try {
           const tokenUsage = await calculateSessionTokens(sessionId, tempDir);
           if (tokenUsage) {
+            // Issue #1501: Log deduplication stats in verbose mode
+            if (tokenUsage.duplicateEntriesSkipped > 0) {
+              await log(`\n⚠️  JSONL deduplication: skipped ${tokenUsage.duplicateEntriesSkipped} duplicate entries (upstream: anthropics/claude-code#6805)`, { verbose: true });
+            }
+            if (tokenUsage.peakContextUsage > 0) {
+              await log(`📊 Peak single-request context: ${formatNumber(tokenUsage.peakContextUsage)} tokens`, { verbose: true });
+            }
             await log('\n💰 Token Usage Summary:');
             // Display per-model breakdown
             if (tokenUsage.modelUsage) {
@@ -1258,18 +1304,9 @@ export const executeClaudeCommand = async params => {
                 await displayModelUsage(usage, log);
                 // Display budget stats if flag is enabled
                 if (argv.tokensBudgetStats && usage.modelInfo?.limit) {
-                  await displayBudgetStats(usage, log);
+                  await displayBudgetStats(usage, tokenUsage, log);
                 }
               }
-              // Issue #1491: Display sub-session breakdown if compactification occurred
-              if (argv.tokensBudgetStats && tokenUsage.subSessions) {
-                const primaryModelInfo = Object.values(tokenUsage.modelUsage).find(u => u.modelInfo?.limit)?.modelInfo;
-                await displaySubSessionStats(tokenUsage, primaryModelInfo, log);
-              }
-              // Issue #1491: Display stream vs JSONL token comparison
-              if (argv.tokensBudgetStats && streamTokenUsage.eventCount > 0) {
-                await displayTokenComparison(streamTokenUsage, tokenUsage, log);
-              }
               // Show totals if multiple models were used
               if (modelIds.length > 1) {
                 await log('\n   📈 Total across all models:');

package/src/github.lib.mjs

@@ -368,7 +368,7 @@ export async function attachLogToGitHub(options) {
     resultModelUsage = null, // Issue #1454
     budgetStatsData = null, // Issue #1491: budget stats for comment
   } = options;
-  const budgetStats = budgetStatsData ? buildBudgetStatsString(budgetStatsData.tokenUsage, budgetStatsData.streamTokenUsage) : '';
+  const budgetStats = budgetStatsData ? buildBudgetStatsString(budgetStatsData.tokenUsage) : '';
   const targetName = targetType === 'pr' ? 'Pull Request' : 'Issue';
   const ghCommand = targetType === 'pr' ? 'pr' : 'issue';
   try {

package/src/telegram-bot.mjs

@@ -558,25 +558,26 @@ function validateGitHubUrl(args, options = {}) {
   return { valid: true, parsed, normalizedUrl: url };
 }
 
-/**
- * Escape special characters for Telegram's legacy Markdown parser.
- * In Telegram's Markdown, these characters need escaping: _ * [ ] ( ) ~ ` > # + - = | { } . !
- * However, for plain text (not inside markup), we primarily need to escape _ and *
- * to prevent them from being interpreted as formatting.
- *
- * @param {string} text - Text to escape
- * @returns {string} Escaped text safe for Markdown parse_mode
- */
-/**
- * Execute a start-screen command and update the initial message with the result.
- * Used by both /solve and /hive commands to reduce code duplication.
- *
- * @param {Object} ctx - Telegram context
- * @param {Object} startingMessage - The initial message to update
- * @param {string} commandName - Command name (e.g., 'solve' or 'hive')
- * @param {string[]} args - Command arguments
- * @param {string} infoBlock - Info block with request details
- */
+// Issue #1460/#1497: safeReply - try Markdown first, fall back to plain text on parsing errors
+async function safeReply(ctx, text, options = {}) {
+  try {
+    return await ctx.reply(text, { parse_mode: 'Markdown', ...options });
+  } catch (error) {
+    const isParsingError = error.message && (error.message.includes("can't parse entities") || error.message.includes("Can't parse entities") || error.message.includes("can't find end of") || (error.message.includes('Bad Request') && error.message.includes('400')));
+    if (!isParsingError) throw error;
+    console.error(`[telegram-bot] safeReply: Markdown parsing failed: ${error.message}`);
+    console.error(`[telegram-bot] safeReply: Failing message (${Buffer.byteLength(text, 'utf-8')} bytes): ${text}`);
+    const plainText = text
+      .replace(/\[([^\]]+)\]\(([^)]+)\)/g, '$1 ($2)')
+      .replace(/\\_/g, '_')
+      .replace(/\\\*/g, '*')
+      .replace(/\*([^*]+)\*/g, '$1')
+      .replace(/`([^`]+)`/g, '$1');
+    return await ctx.reply(plainText, { ...options, parse_mode: undefined });
+  }
+}
+
+// Execute a start-screen command and update the initial message with the result
 async function executeAndUpdateMessage(ctx, startingMessage, commandName, args, infoBlock) {
   const result = await executeStartScreen(commandName, args);
   const { chat, message_id } = startingMessage;
@@ -914,8 +915,7 @@ async function handleSolveCommand(ctx) {
       if (VERBOSE) {
         console.log('[VERBOSE] Multiple GitHub URLs found in replied message');
       }
-      await ctx.reply(`❌ ${extraction.error}`, {
-        parse_mode: 'Markdown',
+      await safeReply(ctx, `❌ ${escapeMarkdown(extraction.error)}`, {
         reply_to_message_id: ctx.message.message_id,
       });
       return;
@@ -931,7 +931,7 @@ async function handleSolveCommand(ctx) {
       if (VERBOSE) {
         console.log('[VERBOSE] No GitHub URL found in replied message');
       }
-      await ctx.reply('❌ No GitHub issue/PR link found in the replied message.\n\nExample: Reply to a message containing a GitHub issue link with `/solve`\n\nOr with options: `/solve --model opus`', { parse_mode: 'Markdown', reply_to_message_id: ctx.message.message_id });
+      await safeReply(ctx, '❌ No GitHub issue/PR link found in the replied message.\n\nExample: Reply to a message containing a GitHub issue link with `/solve`\n\nOr with options: `/solve --model opus`', { reply_to_message_id: ctx.message.message_id });
       return;
     }
   }
@@ -943,7 +943,7 @@ async function handleSolveCommand(ctx) {
       errorMsg += `\n\n💡 Did you mean: \`${validation.suggestion}\``;
     }
     errorMsg += '\n\nExample: `/solve https://github.com/owner/repo/issues/123`\n\nOr reply to a message containing a GitHub link with `/solve`';
-    await ctx.reply(errorMsg, { parse_mode: 'Markdown', reply_to_message_id: ctx.message.message_id });
+    await safeReply(ctx, errorMsg, { reply_to_message_id: ctx.message.message_id });
     return;
   }
 
@@ -963,19 +963,19 @@ async function handleSolveCommand(ctx) {
   // Validate model name with helpful error message (before yargs validation)
   const modelError = validateModelInArgs(args, solveTool);
   if (modelError) {
-    await ctx.reply(`❌ ${modelError}`, { parse_mode: 'Markdown', reply_to_message_id: ctx.message.message_id });
+    await safeReply(ctx, `❌ ${escapeMarkdown(modelError)}`, { reply_to_message_id: ctx.message.message_id });
     return;
   }
   // Issue #1482: Validate --base-branch early to reject URLs and invalid branch names
   const branchError = validateBranchInArgs(args);
   if (branchError) {
-    await ctx.reply(`❌ ${branchError}`, { parse_mode: 'Markdown', reply_to_message_id: ctx.message.message_id });
+    await safeReply(ctx, `❌ ${escapeMarkdown(branchError)}`, { reply_to_message_id: ctx.message.message_id });
     return;
   }
   // Issue #1092: Detect malformed flag patterns like "-- model" (space after --)
   const { malformed, errors: malformedErrors } = detectMalformedFlags(args);
   if (malformed.length > 0) {
-    await ctx.reply(`❌ ${malformedErrors.join('\n')}\n\nPlease check your option syntax.`, { parse_mode: 'Markdown', reply_to_message_id: ctx.message.message_id });
+    await safeReply(ctx, `❌ ${escapeMarkdown(malformedErrors.join('\n'))}\n\nPlease check your option syntax.`, { reply_to_message_id: ctx.message.message_id });
     return;
   }
   // Validate merged arguments using solve's yargs config
@@ -994,8 +994,7 @@ async function handleSolveCommand(ctx) {
 
     testYargs.parse(args);
   } catch (error) {
-    await ctx.reply(`❌ Invalid options: ${error.message || String(error)}\n\nUse /help to see available options`, {
-      parse_mode: 'Markdown',
+    await safeReply(ctx, `❌ Invalid options: ${escapeMarkdown(error.message || String(error))}\n\nUse /help to see available options`, {
       reply_to_message_id: ctx.message.message_id,
     });
     return;
@@ -1019,7 +1018,7 @@ async function handleSolveCommand(ctx) {
   const existingItem = solveQueue.findByUrl(normalizedUrl);
   if (existingItem) {
     const statusText = existingItem.status === 'starting' || existingItem.status === 'started' ? 'being processed' : 'already in the queue';
-    await ctx.reply(`❌ This URL is ${statusText}.\n\nURL: ${escapeMarkdown(normalizedUrl)}\nStatus: ${existingItem.status}\n\n💡 Use /solve_queue to check the queue status.`, { parse_mode: 'Markdown', reply_to_message_id: ctx.message.message_id });
+    await safeReply(ctx, `❌ This URL is ${statusText}.\n\nURL: ${escapeMarkdown(normalizedUrl)}\nStatus: ${existingItem.status}\n\n💡 Use /solve\\_queue to check the queue status.`, { reply_to_message_id: ctx.message.message_id });
     return;
   }
 
@@ -1031,18 +1030,18 @@ async function handleSolveCommand(ctx) {
   // their command cannot be processed (e.g., disk full, server maintenance pending).
   // See: https://github.com/link-assistant/hive-mind/issues/1267
   if (check.rejected) {
-    await ctx.reply(`❌ Solve command rejected.\n\n${infoBlock}\n\n🚫 Reason: ${check.rejectReason}`, { parse_mode: 'Markdown', reply_to_message_id: ctx.message.message_id });
+    await safeReply(ctx, `❌ Solve command rejected.\n\n${infoBlock}\n\n🚫 Reason: ${escapeMarkdown(check.rejectReason || 'Unknown')}`, { reply_to_message_id: ctx.message.message_id });
     return;
   }
 
   if (check.canStart && queueStats.queued === 0) {
-    const startingMessage = await ctx.reply(`🚀 Starting solve command...\n\n${infoBlock}`, { parse_mode: 'Markdown', reply_to_message_id: ctx.message.message_id });
+    const startingMessage = await safeReply(ctx, `🚀 Starting solve command...\n\n${infoBlock}`, { reply_to_message_id: ctx.message.message_id });
     await executeAndUpdateMessage(ctx, startingMessage, 'solve', args, infoBlock);
   } else {
     const queueItem = solveQueue.enqueue({ url: normalizedUrl, args, ctx, requester, infoBlock, tool: solveTool });
     let queueMessage = `📋 Solve command queued (position #${queueStats.queued + 1})\n\n${infoBlock}`;
-    if (check.reason) queueMessage += `\n\n⏳ Waiting: ${check.reason}`;
-    const queuedMessage = await ctx.reply(queueMessage, { parse_mode: 'Markdown', reply_to_message_id: ctx.message.message_id });
+    if (check.reason) queueMessage += `\n\n⏳ Waiting: ${escapeMarkdown(check.reason)}`;
+    const queuedMessage = await safeReply(ctx, queueMessage, { reply_to_message_id: ctx.message.message_id });
     queueItem.messageInfo = { chatId: queuedMessage.chat.id, messageId: queuedMessage.message_id };
     if (!solveQueue.executeCallback) solveQueue.executeCallback = createQueueExecuteCallback(executeStartScreen);
   }
@@ -1122,7 +1121,7 @@ async function handleHiveCommand(ctx) {
     let errorMsg = `❌ ${validation.error}`;
     if (validation.suggestion) errorMsg += `\n\n💡 Did you mean: \`${escapeMarkdown(validation.suggestion)}\``;
     errorMsg += '\n\nExample: `/hive https://github.com/owner/repo`';
-    await ctx.reply(errorMsg, { parse_mode: 'Markdown', reply_to_message_id: ctx.message.message_id });
+    await safeReply(ctx, errorMsg, { reply_to_message_id: ctx.message.message_id });
     return;
   }
   // Normalize issues_list/pulls_list to base repo URL, or use cleaned URL
@@ -1149,13 +1148,13 @@ async function handleHiveCommand(ctx) {
   // Validate model name with helpful error message (before yargs validation)
   const hiveModelError = validateModelInArgs(args, hiveTool);
   if (hiveModelError) {
-    await ctx.reply(`❌ ${hiveModelError}`, { parse_mode: 'Markdown', reply_to_message_id: ctx.message.message_id });
+    await safeReply(ctx, `❌ ${escapeMarkdown(hiveModelError)}`, { reply_to_message_id: ctx.message.message_id });
     return;
   }
   // Issue #1482: Validate branch flags early to reject URLs and invalid branch names
   const hiveBranchError = validateBranchInArgs(args);
   if (hiveBranchError) {
-    await ctx.reply(`❌ ${hiveBranchError}`, { parse_mode: 'Markdown', reply_to_message_id: ctx.message.message_id });
+    await safeReply(ctx, `❌ ${escapeMarkdown(hiveBranchError)}`, { reply_to_message_id: ctx.message.message_id });
     return;
   }
 
@@ -1175,8 +1174,7 @@ async function handleHiveCommand(ctx) {
 
     testYargs.parse(args);
   } catch (error) {
-    await ctx.reply(`❌ Invalid options: ${error.message || String(error)}\n\nUse /help to see available options`, {
-      parse_mode: 'Markdown',
+    await safeReply(ctx, `❌ Invalid options: ${escapeMarkdown(error.message || String(error))}\n\nUse /help to see available options`, {
       reply_to_message_id: ctx.message.message_id,
     });
     return;
@@ -1193,7 +1191,7 @@ async function handleHiveCommand(ctx) {
     infoBlock += `${userOptionsRaw ? '\n' : '\n\n'}🔒 Locked options: ${escapeMarkdown(hiveOverrides.join(' '))}`;
   }
 
-  const startingMessage = await ctx.reply(`🚀 Starting hive command...\n\n${infoBlock}`, { parse_mode: 'Markdown', reply_to_message_id: ctx.message.message_id });
+  const startingMessage = await safeReply(ctx, `🚀 Starting hive command...\n\n${infoBlock}`, { reply_to_message_id: ctx.message.message_id });
   await executeAndUpdateMessage(ctx, startingMessage, 'hive', args, infoBlock);
 }