@link-assistant/hive-mind 1.69.3 → 1.69.5

package/src/telegram-bot.mjs

@@ -45,6 +45,7 @@ const { registerTerminalWatchCommand, startAutoTerminalWatchForSession } = await
 const { launchBotWithRetry } = await import('./telegram-bot-launcher.lib.mjs');
 const { trackSession, startSessionMonitoring, hasActiveSessionForUrlAsync } = await import('./session-monitor.lib.mjs');
 const { formatExecutingWorkSessionMessage, formatStartingWorkSessionMessage } = await import('./work-session-formatting.lib.mjs');
+const { buildTelegramHelpMessage, buildTelegramInfoBlock, buildSolveQueuedMessage } = await import('./telegram-ui-messages.lib.mjs');
 
 const config = yargs(hideBin(process.argv))
   .usage('Usage: hive-telegram-bot [options]')
@@ -442,12 +443,12 @@ async function getCommandUrlArg(args, createYargsConfig, positionalNames) {
 }
 
 async function validateGitHubUrl(args, options = {}) {
-  const { allowedTypes = ['issue', 'pull'], commandName = 'solve', createYargsConfig = null, positionalNames = [] } = options;
+  const { allowedTypes = ['issue', 'pull'], commandName = 'solve', createYargsConfig = null, positionalNames = [], locale = null } = options;
   const rawUrl = await getCommandUrlArg(args, createYargsConfig, positionalNames);
-  if (!rawUrl) return { valid: false, error: `Missing GitHub URL. Usage: /${commandName} <github-url> [options]` };
+  if (!rawUrl) return { valid: false, error: t('telegram.missing_github_url', { commandName }, { locale }) };
   // Issue #1102: Clean non-printable chars (Zero-Width Space, BOM, etc.) from URLs
   const url = cleanNonPrintableChars(rawUrl);
-  if (!url.includes('github.com')) return { valid: false, error: 'First argument must be a GitHub URL' };
+  if (!url.includes('github.com')) return { valid: false, error: t('telegram.first_arg_must_be_github_url', {}, { locale }) };
   const parsed = parseGitHubUrl(url);
   if (!parsed.valid) return { valid: false, error: parsed.error || 'Invalid GitHub URL', suggestion: parsed.suggestion };
   if (!allowedTypes.includes(parsed.type)) {
@@ -456,10 +457,10 @@ async function validateGitHubUrl(args, options = {}) {
     const escapedUrl = escapeMarkdown(url),
       escapedBaseUrl = escapeMarkdown(baseUrl); // Issue #1102: escape for Markdown
     let error;
-    if (parsed.type === 'issues_list') error = `URL points to the issues list page, but you need a specific issue\n\n💡 How to fix:\n1. Open the repository: ${escapedUrl}\n2. Click on a specific issue\n3. Copy the URL (it should end with /issues/NUMBER)\n\nExample: \`${escapedBaseUrl}/issues/1\``;
-    else if (parsed.type === 'pulls_list') error = `URL points to the pull requests list page, but you need a specific pull request\n\n💡 How to fix:\n1. Open the repository: ${escapedUrl}\n2. Click on a specific pull request\n3. Copy the URL (it should end with /pull/NUMBER)\n\nExample: \`${escapedBaseUrl}/pull/1\``;
-    else if (parsed.type === 'repo') error = `URL points to a repository, but you need a specific ${allowedTypesStr}\n\n💡 How to fix:\n1. Go to: ${escapedUrl}/issues\n2. Click on an issue to solve\n3. Use the full URL with the issue number\n\nExample: \`${escapedBaseUrl}/issues/1\``;
-    else error = `URL must be a GitHub ${allowedTypesStr} (not ${parsed.type.replace('_', ' ')})`;
+    if (parsed.type === 'issues_list') error = t('telegram.url_issues_list_error', { url: escapedUrl, example: `${escapedBaseUrl}/issues/1` }, { locale });
+    else if (parsed.type === 'pulls_list') error = t('telegram.url_pulls_list_error', { url: escapedUrl, example: `${escapedBaseUrl}/pull/1` }, { locale });
+    else if (parsed.type === 'repo') error = t('telegram.url_repo_error', { allowedTypes: allowedTypesStr, url: escapedUrl, example: `${escapedBaseUrl}/issues/1` }, { locale });
+    else error = t('telegram.url_must_be_type', { allowedTypes: allowedTypesStr, type: parsed.type.replace('_', ' ') }, { locale });
     return { valid: false, error };
   }
   return { valid: true, parsed, normalizedUrl: url };
@@ -486,104 +487,32 @@ bot.command('help', async ctx => {
   const chatType = ctx.chat.type;
   const chatTitle = ctx.chat.title || 'Private Chat';
   const topicId = ctx.message?.message_thread_id; // Forum topic ID (issue #1100)
-  let message = '🤖 *SwarmMindBot Help*\n\n';
-
-  // Show stopped status if chat is stopped (issue #1081)
-  if (isChatStopped(chatId)) {
-    const stopInfo = getChatStopInfo(chatId);
-    const reason = stopInfo?.reason || DEFAULT_STOP_REASON;
-    message += '🛑 *Bot Status: STOPPED*\n';
-    message += `Reason: ${reason}\n`;
-    if (stopInfo?.stoppedAt) {
-      message += `Stopped: ${stopInfo.stoppedAt.toISOString()}\n`;
-    }
-    message += 'Use /start (chat owner only) to resume.\n\n';
-  }
-
-  message += '📋 *Diagnostic Information:*\n';
-  message += `• Chat ID: \`${chatId}\`\n`;
-  if (topicId) message += `• Topic ID: \`${topicId}\`\n`;
-  message += `• Chat Type: ${chatType}\n`;
-  message += `• Chat Title: ${chatTitle}\n\n`;
-  message += '📝 *Available Commands:*\n\n';
-
-  if (solveEnabled) {
-    message += '*/solve* (aliases: */do*, */continue*, */claude*, */codex*, */opencode*, */agent*, */gemini*, */qwen*) - Solve a GitHub issue\n';
-    message += 'Usage: `/solve <github-url> [options]`\n';
-    message += 'Example: `/solve https://github.com/owner/repo/issues/123 --model sonnet`\n';
-    message += 'Tool aliases imply `--tool <tool>`: `/codex <github-url>` equals `/solve <github-url> --tool codex`\n';
-    message += 'Or reply to a message with a GitHub link: `/solve`\n';
-    if (solveOverrides.length > 0) {
-      message += `🔒 Locked options: \`${solveOverrides.join(' ')}\`\n`;
-    }
-    message += '\n';
-  } else {
-    message += '*/solve* (aliases: */do*, */continue*, */claude*, */codex*, */opencode*, */agent*, */gemini*, */qwen*) - ❌ Disabled\n\n';
-  }
-
-  if (taskEnabled) {
-    message += '*/task* - Create a GitHub issue from a repository link and issue text\n';
-    message += 'Usage: `/task <github-repository-url>` followed by issue text, or reply with `/task`\n';
-    message += 'Example: `/task https://github.com/owner/repo` then the issue text on following lines\n';
-    message += '*/split* - Split a GitHub issue into smaller issues\n';
-    message += 'Usage: `/split <github-issue-url> [options]` or `/task --split <github-issue-url>`\n';
-    message += 'Example: `/split https://github.com/owner/repo/issues/123 --split-count 2`\n\n';
-  } else {
-    message += '*/task* / */split* - ❌ Disabled\n\n';
-  }
-
-  if (hiveEnabled) {
-    message += '*/hive* - Run hive command\n';
-    message += 'Usage: `/hive <github-url> [options]`\n';
-    message += 'Example: `/hive https://github.com/owner/repo`\n';
-    if (hiveOverrides.length > 0) {
-      message += `🔒 Locked options: \`${hiveOverrides.join(' ')}\`\n`;
-    }
-    message += '\n';
-  } else {
-    message += '*/hive* - ❌ Disabled\n\n';
-  }
-
-  message += '`/solve_queue` - Show solve queue status\n';
-  message += '*/limits* - Show usage limits\n';
-  message += '*/version* - Show bot and runtime versions\n';
-  message += '*/language* `[en|ru|zh|hi]` - Set or show your preferred reply language (in-memory only, per-user)\n';
-  message += '`/accept_invites` - Accept all pending GitHub invitations\n';
-  message += '*/merge* - Merge queue (experimental)\n';
-  message += 'Usage: `/merge <github-repo-url>`\n';
-  message += "Merges all PRs with 'ready' label sequentially.\n";
-  message += '*/subscribe* / */unsubscribe* - 🔔 Get private DM forward of /solve completion (experimental, #1688)\n';
-  message += '*/help* - Show this help message\n';
-  message += '*/stop* / */start* - Stop or resume accepting new tasks (owner only)\n';
-  message += '*/stop* `<uuid>` - Send CTRL+C to an isolated solve/hive session (owner only). Also works as a reply to a message containing the UUID.\n';
-  message += '*/log* - Fetch isolation session log (owner only). Usage: `/log <uuid>` or reply with `/log`\n';
-  message += '*/terminal\\_watch* - Live-update an isolation session log (owner only). Usage: `/terminal_watch <uuid>` or reply with `/terminal_watch`\n\n';
-  message += '🔔 *Session Notifications:* Completion notifications are automatic; use /subscribe for private DM forwards.\n';
-  if (ISOLATION_BACKEND) message += `🔒 *Isolation Mode:* \`${ISOLATION_BACKEND}\` (experimental)\n`;
-  message += '\n';
-  message += '⚠️ *Note:* /solve, /do, /continue, /claude, /codex, /opencode, /agent, /gemini, /qwen, /task, /split, /hive, /solve\\_queue, /limits, /version, /accept\\_invites, /merge, /stop and /start commands only work in group chats. /terminal\\_watch, /subscribe and /unsubscribe work in private and group chats.\n\n';
-  message += '🔧 *Common Options:*\n';
-  message += `• \`--model <model>\` or \`-m\` - ${buildModelOptionDescription()}\n`;
-  message += '• `--base-branch <branch>` or `-b` - Target branch for PR (default: repo default branch)\n';
-  message += '• `--think <level>` - Thinking level (off/low/medium/high/xhigh/max) | `--thinking-budget <num>` - Token budget (0-63999)\n';
-  message += '• `--verbose` or `-v` - Verbose output | `--attach-logs` - Attach logs to PR\n';
-  if (SHOW_LIMITS_ENABLED) message += '• `--show-limits` - Experimental: embed Claude/Codex usage at start, end and delta (#594)\n';
-  message += '\n💡 *Tip:* Many more options available. See full documentation for complete list.\n';
-
-  if (allowedChats || allowedTopics) {
-    const authorized = isTopicAuthorized(ctx);
-    message += `\n🔒 *Restricted Mode:* Authorized: ${authorized ? '✅ Yes' : '❌ No'}`;
-    if (!authorized && topicId) message += `\n💡 To allow this topic: \`TELEGRAM_ALLOWED_TOPICS="(${chatId} ${topicId})"\``;
-  }
-
-  message += '\n\n🔧 *Troubleshooting:*\n';
-  message += 'If bot is not receiving messages:\n';
-  message += '1. Check privacy mode in @BotFather\n';
-  message += '   • Send `/setprivacy` to @BotFather\n';
-  message += '   • Choose "Disable" for your bot\n';
-  message += '   • Remove bot from group and re-add\n';
-  message += '2. Or make bot an admin in the group\n';
-  message += '3. Restart bot with `--verbose` flag for diagnostics';
+  const helpLocale = resolveLocaleFromTelegramCtx(ctx);
+  const stopped = isChatStopped(chatId);
+  const stopInfo = stopped ? getChatStopInfo(chatId) : null;
+  const restrictedMode = Boolean(allowedChats || allowedTopics);
+  const authorized = restrictedMode ? isTopicAuthorized(ctx) : null;
+  const message = buildTelegramHelpMessage({
+    locale: helpLocale,
+    chatId,
+    chatType,
+    chatTitle,
+    topicId,
+    isStopped: stopped,
+    stopInfo,
+    stopReason: stopInfo?.reason || DEFAULT_STOP_REASON,
+    solveEnabled,
+    taskEnabled,
+    hiveEnabled,
+    solveOverrides,
+    hiveOverrides,
+    showLimitsEnabled: SHOW_LIMITS_ENABLED,
+    isolationBackend: ISOLATION_BACKEND,
+    modelDescription: buildModelOptionDescription(),
+    restrictedMode,
+    authorized,
+    allowTopicHint: topicId ? `TELEGRAM_ALLOWED_TOPICS="(${chatId} ${topicId})"` : '',
+  });
 
   await ctx.reply(message, { parse_mode: 'Markdown' });
 });
@@ -636,8 +565,8 @@ bot.command('limits', async ctx => {
   const codexError = limits.codex.success ? null : limits.codex.error;
   const solveQueue = getSolveQueue({ verbose: VERBOSE });
   const queueStatus = await solveQueue.formatStatus();
-  const codexSection = formatCodexLimitsSection(limits.codex.success ? limits.codex : null, codexError);
-  const message = t('telegram.usage_limits_title', {}, { locale: userLocale }) + '\n\n' + formatUsageMessage(limits.claude.success ? limits.claude.usage : null, limits.disk.success ? limits.disk.diskSpace : null, limits.github.success ? limits.github.githubRateLimit : null, limits.cpu.success ? limits.cpu.cpuLoad : null, limits.memory.success ? limits.memory.memory : null, claudeError, [codexSection, queueStatus]);
+  const codexSection = formatCodexLimitsSection(limits.codex.success ? limits.codex : null, codexError, { locale: userLocale });
+  const message = t('telegram.usage_limits_title', {}, { locale: userLocale }) + '\n\n' + formatUsageMessage(limits.claude.success ? limits.claude.usage : null, limits.disk.success ? limits.disk.diskSpace : null, limits.github.success ? limits.github.githubRateLimit : null, limits.cpu.success ? limits.cpu.cpuLoad : null, limits.memory.success ? limits.memory.memory : null, claudeError, [codexSection, queueStatus], { locale: userLocale });
   await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, message, { parse_mode: 'Markdown' });
 });
 bot.command('version', async ctx => {
@@ -754,7 +683,7 @@ async function handleSolveCommand(ctx) {
   let userArgs = parseCommandArgs(ctx.message.text);
 
   // Issue #594: strip --show-limits from userArgs (hive-telegram-bot virtual option).
-  const solveSL = await handleShowLimitsFlag({ ctx, safeReply, args: userArgs, enabled: SHOW_LIMITS_ENABLED });
+  const solveSL = await handleShowLimitsFlag({ ctx, safeReply, args: userArgs, enabled: SHOW_LIMITS_ENABLED, locale: solveLocale });
   if (solveSL.handled) return;
   const solveShowLimits = solveSL.showLimits;
   userArgs = solveSL.args;
@@ -812,13 +741,13 @@ async function handleSolveCommand(ctx) {
     return;
   }
 
-  const validation = await validateGitHubUrl(userArgs, { createYargsConfig: createSolveYargsConfig, positionalNames: ['issue-url'] });
+  const validation = await validateGitHubUrl(userArgs, { createYargsConfig: createSolveYargsConfig, positionalNames: ['issue-url'], locale: solveLocale });
   if (!validation.valid) {
     let errorMsg = `❌ ${validation.error}`;
     if (validation.suggestion) {
-      errorMsg += `\n\n💡 Did you mean: \`${validation.suggestion}\``;
+      errorMsg += `\n\n${t('telegram.did_you_mean', { suggestion: validation.suggestion }, { locale: solveLocale })}`;
     }
-    errorMsg += '\n\nExample: `/solve https://github.com/owner/repo/issues/123`\n\nOr reply to a message containing a GitHub link with `/solve`';
+    errorMsg += `\n\n${t('telegram.solve_invalid_url_help', {}, { locale: solveLocale })}`;
     await safeReply(ctx, errorMsg, { reply_to_message_id: ctx.message.message_id });
     return;
   }
@@ -896,10 +825,14 @@ async function handleSolveCommand(ctx) {
   const requester = buildUserMention({ user: ctx.from, parseMode: 'Markdown' });
   // #1228: only user options; #1460: escape; #1688: 'Issue:' / 'Pull request:' label so completion can append PR link.
   const userOptionsRaw = userArgs.slice(1).join(' ');
-  const urlLabel = validation.parsed?.type === 'pull' ? 'Pull request' : 'Issue';
-  let infoBlock = `Requested by: ${requester}\n${urlLabel}: ${escapeMarkdown(normalizedUrl)}`;
-  if (userOptionsRaw) infoBlock += `\n\n🛠 Options: ${escapeMarkdown(userOptionsRaw)}`;
-  if (solveOverrides.length > 0) infoBlock += `${userOptionsRaw ? '\n' : '\n\n'}🔒 Locked options: ${escapeMarkdown(solveOverrides.join(' '))}`;
+  let infoBlock = buildTelegramInfoBlock({
+    locale: solveLocale,
+    requester,
+    urlKind: validation.parsed?.type === 'pull' ? 'pullRequest' : 'issue',
+    url: escapeMarkdown(normalizedUrl),
+    optionsRaw: userOptionsRaw ? escapeMarkdown(userOptionsRaw) : '',
+    lockedOptions: solveOverrides.length > 0 ? escapeMarkdown(solveOverrides.join(' ')) : '',
+  });
   const solveQueue = getSolveQueue({ verbose: VERBOSE });
 
   // Check for duplicate URL in queue (issue #1080)
@@ -932,15 +865,14 @@ async function handleSolveCommand(ctx) {
 
   // Issue #594: append "Limits at start" to infoBlock; thread snapshot via sessionInfo.
   let solveLimitsAtStart = null;
-  if (solveShowLimits) ({ infoBlock, limitsAtStart: solveLimitsAtStart } = await captureStartSnapshotAndAppend({ infoBlock, tool: solveTool, verbose: VERBOSE, limitsLib, commandLabel: '/solve' }));
+  if (solveShowLimits) ({ infoBlock, limitsAtStart: solveLimitsAtStart } = await captureStartSnapshotAndAppend({ infoBlock, tool: solveTool, verbose: VERBOSE, limitsLib, commandLabel: '/solve', locale: solveLocale }));
 
   if (check.canStart && toolQueuedCount === 0) {
-    const startingMessage = await safeReply(ctx, formatStartingWorkSessionMessage({ infoBlock }), { reply_to_message_id: ctx.message.message_id });
-    await executeAndUpdateMessage(ctx, startingMessage, 'solve', argsWithLocale, infoBlock, effectiveSolveIsolation, solveTool, solveUrlContext, { showLimits: solveShowLimits, limitsAtStart: solveLimitsAtStart });
+    const startingMessage = await safeReply(ctx, formatStartingWorkSessionMessage({ infoBlock, locale: solveLocale }), { reply_to_message_id: ctx.message.message_id });
+    await executeAndUpdateMessage(ctx, startingMessage, 'solve', argsWithLocale, infoBlock, effectiveSolveIsolation, solveTool, solveUrlContext, { showLimits: solveShowLimits, limitsAtStart: solveLimitsAtStart, locale: solveLocale });
   } else {
-    const queueItem = solveQueue.enqueue({ url: normalizedUrl, args: argsWithLocale, ctx, requester, infoBlock, tool: solveTool, perCommandIsolation: effectiveSolveIsolation, urlContext: solveUrlContext, showLimits: solveShowLimits, limitsAtStart: solveLimitsAtStart });
-    let queueMessage = `📋 Solve command queued (${solveTool} queue position #${toolQueuedCount + 1})\n\n${infoBlock}`; // tool-specific position (#1551)
-    if (check.reason) queueMessage += `\n\n⏳ Waiting: ${escapeMarkdown(check.reason)}`;
+    const queueItem = solveQueue.enqueue({ url: normalizedUrl, args: argsWithLocale, ctx, requester, infoBlock, tool: solveTool, perCommandIsolation: effectiveSolveIsolation, urlContext: solveUrlContext, showLimits: solveShowLimits, limitsAtStart: solveLimitsAtStart, locale: solveLocale });
+    const queueMessage = buildSolveQueuedMessage({ locale: solveLocale, tool: solveTool, position: toolQueuedCount + 1, infoBlock, reason: check.reason ? escapeMarkdown(check.reason) : '' }); // tool-specific position (#1551)
     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) {
@@ -1028,17 +960,17 @@ async function handleHiveCommand(ctx) {
   let userArgs = parseCommandArgs(ctx.message.text);
 
   // Issue #594: see /solve handler.
-  const hiveSL = await handleShowLimitsFlag({ ctx, safeReply, args: userArgs, enabled: SHOW_LIMITS_ENABLED });
+  const hiveSL = await handleShowLimitsFlag({ ctx, safeReply, args: userArgs, enabled: SHOW_LIMITS_ENABLED, locale: hiveLocale });
   if (hiveSL.handled) return;
   const hiveShowLimits = hiveSL.showLimits;
   userArgs = hiveSL.args;
 
   // Issue #1102: Allow issues_list/pulls_list URLs and normalize to repo URLs
-  const validation = await validateGitHubUrl(userArgs, { allowedTypes: ['repo', 'organization', 'user', 'issues_list', 'pulls_list'], commandName: 'hive', createYargsConfig: createHiveYargsConfig, positionalNames: ['github-url'] });
+  const validation = await validateGitHubUrl(userArgs, { allowedTypes: ['repo', 'organization', 'user', 'issues_list', 'pulls_list'], commandName: 'hive', createYargsConfig: createHiveYargsConfig, positionalNames: ['github-url'], locale: hiveLocale });
   if (!validation.valid) {
     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`';
+    if (validation.suggestion) errorMsg += `\n\n${t('telegram.did_you_mean', { suggestion: escapeMarkdown(validation.suggestion) }, { locale: hiveLocale })}`;
+    errorMsg += `\n\n${t('telegram.hive_invalid_url_help', {}, { locale: hiveLocale })}`;
     await safeReply(ctx, errorMsg, { reply_to_message_id: ctx.message.message_id });
     return;
   }
@@ -1090,31 +1022,33 @@ async function handleHiveCommand(ctx) {
   try {
     await parseArgsWithYargs(args, yargs, createHiveYargsConfig);
   } catch (error) {
-    await safeReply(ctx, `❌ Invalid options: ${escapeMarkdown(error.message || String(error))}\n\nUse /help to see available options`, {
+    await safeReply(ctx, t('telegram.invalid_options', { message: escapeMarkdown(error.message || String(error)) }, { locale: hiveLocale }), {
       reply_to_message_id: ctx.message.message_id,
     });
     return;
   }
 
   const requester = buildUserMention({ user: ctx.from, parseMode: 'Markdown' });
-  const escapedUrl = escapeMarkdown(args[0]);
   // Issue #1228: Show only user-provided options (exclude locked overrides to avoid duplication)
   // Issue #1460: Escape options text to prevent Markdown parsing errors
   const userOptionsRaw = normalizedArgs.slice(1).join(' ');
-  let infoBlock = `Requested by: ${requester}\nURL: ${escapedUrl}`;
-  if (userOptionsRaw) infoBlock += `\n\n🛠 Options: ${escapeMarkdown(userOptionsRaw)}`;
-  if (hiveOverrides.length > 0) {
-    infoBlock += `${userOptionsRaw ? '\n' : '\n\n'}🔒 Locked options: ${escapeMarkdown(hiveOverrides.join(' '))}`;
-  }
+  let infoBlock = buildTelegramInfoBlock({
+    locale: hiveLocale,
+    requester,
+    urlKind: 'url',
+    url: escapeMarkdown(args[0]),
+    optionsRaw: userOptionsRaw ? escapeMarkdown(userOptionsRaw) : '',
+    lockedOptions: hiveOverrides.length > 0 ? escapeMarkdown(hiveOverrides.join(' ')) : '',
+  });
 
   // Issue #594: see /solve handler.
   let hiveLimitsAtStart = null;
-  if (hiveShowLimits) ({ infoBlock, limitsAtStart: hiveLimitsAtStart } = await captureStartSnapshotAndAppend({ infoBlock, tool: hiveTool, verbose: VERBOSE, limitsLib, commandLabel: '/hive' }));
+  if (hiveShowLimits) ({ infoBlock, limitsAtStart: hiveLimitsAtStart } = await captureStartSnapshotAndAppend({ infoBlock, tool: hiveTool, verbose: VERBOSE, limitsLib, commandLabel: '/hive', locale: hiveLocale }));
 
-  const startingMessage = await safeReply(ctx, formatStartingWorkSessionMessage({ infoBlock }), { reply_to_message_id: ctx.message.message_id });
+  const startingMessage = await safeReply(ctx, formatStartingWorkSessionMessage({ infoBlock, locale: hiveLocale }), { reply_to_message_id: ctx.message.message_id });
   // Issue #378: propagate user's effective Telegram locale to the spawned hive session.
   const hiveArgsWithLocale = injectLanguageIfMissing(args, hiveLocale);
-  await executeAndUpdateMessage(ctx, startingMessage, 'hive', hiveArgsWithLocale, infoBlock, effectiveHiveIsolation, hiveTool, null, { showLimits: hiveShowLimits, limitsAtStart: hiveLimitsAtStart });
+  await executeAndUpdateMessage(ctx, startingMessage, 'hive', hiveArgsWithLocale, infoBlock, effectiveHiveIsolation, hiveTool, null, { showLimits: hiveShowLimits, limitsAtStart: hiveLimitsAtStart, locale: hiveLocale });
 }
 
 bot.command(/^hive$/i, handleHiveCommand);

package/src/telegram-command-execution.lib.mjs

@@ -1,6 +1,7 @@
 import { spawn } from 'child_process';
 import { promisify } from 'util';
 import { exec as execCallback } from 'child_process';
+import { t } from './i18n.lib.mjs';
 
 const exec = promisify(execCallback);
 
@@ -98,7 +99,7 @@ function executeWithCommand(startScreenCmd, command, args, verbose = false) {
  */
 export function buildExecuteAndUpdateMessage(deps) {
   const { resolveIsolation, ISOLATION_BACKEND, isolationRunner, VERBOSE, executeStartScreen, trackSession, AUTO_WATCH_MESSAGE, startAutoTerminalWatchForSession, bot, formatExecutingWorkSessionMessage } = deps;
-  return async function executeAndUpdateMessage(ctx, startingMessage, commandName, args, infoBlock, perCommandIsolation = null, tool = 'claude', urlContext = null, { showLimits = false, limitsAtStart = null } = {}) {
+  return async function executeAndUpdateMessage(ctx, startingMessage, commandName, args, infoBlock, perCommandIsolation = null, tool = 'claude', urlContext = null, { showLimits = false, limitsAtStart = null, locale = null } = {}) {
     const { chat, message_id: msgId } = startingMessage;
     const safeEdit = async text => {
       try {
@@ -108,7 +109,7 @@ export function buildExecuteAndUpdateMessage(deps) {
       }
     };
     const requesterUserId = ctx.from?.id ?? null; // Issue #1688: suppress duplicate /subscribe DM
-    const baseSessionInfo = { chatId: ctx.chat.id, messageId: msgId, startTime: new Date(), url: args[0], command: commandName, tool, infoBlock, urlContext, requesterUserId, showLimits, limitsAtStart }; // #594: showLimits/limitsAtStart
+    const baseSessionInfo = { chatId: ctx.chat.id, messageId: msgId, startTime: new Date(), url: args[0], command: commandName, tool, infoBlock, urlContext, requesterUserId, showLimits, limitsAtStart, locale }; // #594: showLimits/limitsAtStart
     const iso = await resolveIsolation(perCommandIsolation, ISOLATION_BACKEND, isolationRunner, VERBOSE);
     let result, session, sessionInfo;
     if (iso) {
@@ -131,9 +132,9 @@ export function buildExecuteAndUpdateMessage(deps) {
     }
     if (result.warning) return safeEdit(`⚠️  ${result.warning}`);
     if (result.success) {
-      await safeEdit(formatExecutingWorkSessionMessage({ sessionName: session, isolationBackend: iso?.backend || null, infoBlock }));
+      await safeEdit(formatExecutingWorkSessionMessage({ sessionName: session, isolationBackend: iso?.backend || null, infoBlock, locale }));
       if (AUTO_WATCH_MESSAGE && commandName === 'solve' && sessionInfo?.isolationBackend) await startAutoTerminalWatchForSession({ bot, ctx, sessionId: session, sessionInfo, verbose: VERBOSE });
-    } else await safeEdit(`❌ Error executing ${commandName} command:\n\n\`\`\`\n${result.error || result.output}\n\`\`\`\n\n${infoBlock}`);
+    } else await safeEdit(`${t('telegram.error_executing_command', { commandName }, { locale })}:\n\n\`\`\`\n${result.error || result.output}\n\`\`\`\n\n${infoBlock}`);
   };
 }
 

package/src/telegram-show-limits.lib.mjs

@@ -20,6 +20,8 @@
  * @see https://github.com/link-assistant/hive-mind/issues/594
  */
 
+import { lt, resolveLimitLocale } from './limits-i18n.lib.mjs';
+
 const SHOW_LIMITS_FLAG = '--show-limits';
 const NO_SHOW_LIMITS_FLAG = '--no-show-limits';
 
@@ -106,9 +108,9 @@ function pct(value) {
   return Math.floor(num);
 }
 
-function formatPercentage(value) {
+function formatPercentage(value, locale = null) {
   const p = pct(value);
-  return p === null ? 'N/A' : `${p}%`;
+  return p === null ? lt('na', {}, { locale }) : `${p}%`;
 }
 
 /**
@@ -118,26 +120,28 @@ function formatPercentage(value) {
  * @param {Object} snapshot - Result of captureLimitsSnapshot for tool=claude
  * @returns {string}
  */
-function formatClaudeSnapshotCompact(snapshot) {
-  if (!snapshot) return 'Claude limits: N/A';
-  if (!snapshot.success) return `Claude limits: ${snapshot.error || 'unavailable'}`;
+function formatClaudeSnapshotCompact(snapshot, options = {}) {
+  const locale = resolveLimitLocale(options);
+  if (!snapshot) return `${lt('claude_limits', {}, { locale })}: ${lt('na', {}, { locale })}`;
+  if (!snapshot.success) return `${lt('claude_limits', {}, { locale })}: ${snapshot.error || lt('unavailable', {}, { locale })}`;
   const usage = snapshot.usage || {};
   const lines = [];
-  lines.push(`5h session: ${formatPercentage(usage.currentSession?.percentage)}`);
-  lines.push(`7d all models: ${formatPercentage(usage.allModels?.percentage)}`);
+  lines.push(`${lt('five_hour_session', {}, { locale })}: ${formatPercentage(usage.currentSession?.percentage, locale)}`);
+  lines.push(`${lt('seven_day_all_models', {}, { locale })}: ${formatPercentage(usage.allModels?.percentage, locale)}`);
   if (usage.sonnetOnly && usage.sonnetOnly.percentage !== null && usage.sonnetOnly.percentage !== undefined) {
-    lines.push(`7d Sonnet only: ${formatPercentage(usage.sonnetOnly.percentage)}`);
+    lines.push(`${lt('seven_day_sonnet_only', {}, { locale })}: ${formatPercentage(usage.sonnetOnly.percentage, locale)}`);
   }
   return lines.join('\n');
 }
 
-function formatCodexSnapshotCompact(snapshot) {
-  if (!snapshot) return 'Codex limits: N/A';
-  if (!snapshot.success) return `Codex limits: ${snapshot.error || 'unavailable'}`;
+function formatCodexSnapshotCompact(snapshot, options = {}) {
+  const locale = resolveLimitLocale(options);
+  if (!snapshot) return `${lt('codex_limits', {}, { locale })}: ${lt('na', {}, { locale })}`;
+  if (!snapshot.success) return `${lt('codex_limits', {}, { locale })}: ${snapshot.error || lt('unavailable', {}, { locale })}`;
   const usage = snapshot.usage || {};
   const lines = [];
-  lines.push(`5h session: ${formatPercentage(usage.currentSession?.percentage)}`);
-  lines.push(`Weekly: ${formatPercentage(usage.allModels?.percentage)}`);
+  lines.push(`${lt('five_hour_session', {}, { locale })}: ${formatPercentage(usage.currentSession?.percentage, locale)}`);
+  lines.push(`${lt('weekly', {}, { locale })}: ${formatPercentage(usage.allModels?.percentage, locale)}`);
   return lines.join('\n');
 }
 
@@ -150,11 +154,12 @@ function formatCodexSnapshotCompact(snapshot) {
  * @param {string} [options.title='📊 Limits at start'] Block title
  * @returns {string}
  */
-export function formatLimitsSnapshotBlock(snapshot, { title = '📊 Limits at start' } = {}) {
+export function formatLimitsSnapshotBlock(snapshot, { title = null, locale = null } = {}) {
   if (!snapshot) return '';
   const heading = snapshot.toolKey === 'codex' ? 'Codex' : 'Claude';
-  const body = snapshot.toolKey === 'codex' ? formatCodexSnapshotCompact(snapshot) : formatClaudeSnapshotCompact(snapshot);
-  return `${title} (${heading})\n\`\`\`\n${body}\n\`\`\``;
+  const localizedTitle = title || `📊 ${lt('limits_at_start', {}, { locale })}`;
+  const body = snapshot.toolKey === 'codex' ? formatCodexSnapshotCompact(snapshot, { locale }) : formatClaudeSnapshotCompact(snapshot, { locale });
+  return `${localizedTitle} (${heading})\n\`\`\`\n${body}\n\`\`\``;
 }
 
 function deltaFor(startPct, endPct) {
@@ -164,8 +169,8 @@ function deltaFor(startPct, endPct) {
   return e - s;
 }
 
-function formatDeltaValue(delta) {
-  if (delta === null || delta === undefined) return 'N/A';
+function formatDeltaValue(delta, locale = null) {
+  if (delta === null || delta === undefined) return lt('na', {}, { locale });
   if (delta === 0) return '±0%';
   const sign = delta > 0 ? '+' : '';
   return `${sign}${delta}%`;
@@ -177,37 +182,39 @@ function formatDeltaValue(delta) {
  *
  * @param {Object|null} startSnapshot
  * @param {Object|null} endSnapshot
+ * @param {Object|string} [options]
  * @returns {string}
  */
-export function formatLimitsDeltaBlock(startSnapshot, endSnapshot) {
+export function formatLimitsDeltaBlock(startSnapshot, endSnapshot, options = {}) {
   if (!startSnapshot || !endSnapshot) return '';
   if (startSnapshot.toolKey !== endSnapshot.toolKey) return '';
+  const locale = resolveLimitLocale(options);
   const heading = startSnapshot.toolKey === 'codex' ? 'Codex' : 'Claude';
   const lines = [];
 
   if (!startSnapshot.success && !endSnapshot.success) {
-    lines.push(`Start: ${startSnapshot.error || 'unavailable'}`);
-    lines.push(`End: ${endSnapshot.error || 'unavailable'}`);
+    lines.push(`${lt('start', {}, { locale })}: ${startSnapshot.error || lt('unavailable', {}, { locale })}`);
+    lines.push(`${lt('end', {}, { locale })}: ${endSnapshot.error || lt('unavailable', {}, { locale })}`);
   } else {
     const startUsage = startSnapshot.usage || {};
     const endUsage = endSnapshot.usage || {};
 
-    const sessionLabel = '5h session';
-    lines.push(`${sessionLabel}: ${formatPercentage(startUsage.currentSession?.percentage)} → ${formatPercentage(endUsage.currentSession?.percentage)} (${formatDeltaValue(deltaFor(startUsage.currentSession?.percentage, endUsage.currentSession?.percentage))})`);
+    const sessionLabel = lt('five_hour_session', {}, { locale });
+    lines.push(`${sessionLabel}: ${formatPercentage(startUsage.currentSession?.percentage, locale)} → ${formatPercentage(endUsage.currentSession?.percentage, locale)} (${formatDeltaValue(deltaFor(startUsage.currentSession?.percentage, endUsage.currentSession?.percentage), locale)})`);
 
-    const allModelsLabel = startSnapshot.toolKey === 'codex' ? 'Weekly' : '7d all models';
-    lines.push(`${allModelsLabel}: ${formatPercentage(startUsage.allModels?.percentage)} → ${formatPercentage(endUsage.allModels?.percentage)} (${formatDeltaValue(deltaFor(startUsage.allModels?.percentage, endUsage.allModels?.percentage))})`);
+    const allModelsLabel = startSnapshot.toolKey === 'codex' ? lt('weekly', {}, { locale }) : lt('seven_day_all_models', {}, { locale });
+    lines.push(`${allModelsLabel}: ${formatPercentage(startUsage.allModels?.percentage, locale)} → ${formatPercentage(endUsage.allModels?.percentage, locale)} (${formatDeltaValue(deltaFor(startUsage.allModels?.percentage, endUsage.allModels?.percentage), locale)})`);
 
     if (startSnapshot.toolKey === 'claude' && ((startUsage.sonnetOnly && startUsage.sonnetOnly.percentage !== null && startUsage.sonnetOnly.percentage !== undefined) || (endUsage.sonnetOnly && endUsage.sonnetOnly.percentage !== null && endUsage.sonnetOnly.percentage !== undefined))) {
-      lines.push(`7d Sonnet only: ${formatPercentage(startUsage.sonnetOnly?.percentage)} → ${formatPercentage(endUsage.sonnetOnly?.percentage)} (${formatDeltaValue(deltaFor(startUsage.sonnetOnly?.percentage, endUsage.sonnetOnly?.percentage))})`);
+      lines.push(`${lt('seven_day_sonnet_only', {}, { locale })}: ${formatPercentage(startUsage.sonnetOnly?.percentage, locale)} → ${formatPercentage(endUsage.sonnetOnly?.percentage, locale)} (${formatDeltaValue(deltaFor(startUsage.sonnetOnly?.percentage, endUsage.sonnetOnly?.percentage), locale)})`);
     }
   }
 
   // Note: delta is not precise because multiple parallel tasks may consume
   // from the same Anthropic/OpenAI budget windows during the run.
-  lines.push('Note: delta is approximate (parallel sessions share the same budget).');
+  lines.push(lt('note_delta_approx', {}, { locale }));
 
-  return `📊 Limits change (${heading})\n\`\`\`\n${lines.join('\n')}\n\`\`\``;
+  return `📊 ${lt('limits_change', {}, { locale })} (${heading})\n\`\`\`\n${lines.join('\n')}\n\`\`\``;
 }
 
 /**
@@ -241,10 +248,10 @@ export function appendInfoSection(infoBlock, addition) {
  * @param {boolean} options.enabled - Master switch (config.showLimits)
  * @returns {Promise<{ handled: boolean, args: string[], showLimits: boolean }>}
  */
-export async function handleShowLimitsFlag({ ctx, safeReply, args, enabled }) {
+export async function handleShowLimitsFlag({ ctx, safeReply, args, enabled, locale = null }) {
   const { showLimits, args: stripped } = extractShowLimitsFlag(args);
   if (showLimits === true && !enabled) {
-    await safeReply(ctx, '❌ `--show-limits` is disabled by the bot administrator.', { reply_to_message_id: ctx.message.message_id });
+    await safeReply(ctx, `❌ ${lt('disabled_by_admin', {}, { locale })}`, { reply_to_message_id: ctx.message.message_id });
     return { handled: true, args: stripped, showLimits: false };
   }
   return { handled: false, args: stripped, showLimits: showLimits === true && enabled };
@@ -264,12 +271,12 @@ export async function handleShowLimitsFlag({ ctx, safeReply, args, enabled }) {
  * @param {string} [options.commandLabel='command'] - For verbose logging
  * @returns {Promise<{ infoBlock: string, limitsAtStart: Object|null }>}
  */
-export async function captureStartSnapshotAndAppend({ infoBlock, tool = 'claude', verbose = false, limitsLib, commandLabel = 'command' } = {}) {
+export async function captureStartSnapshotAndAppend({ infoBlock, tool = 'claude', verbose = false, limitsLib, commandLabel = 'command', locale = null } = {}) {
   let limitsAtStart = null;
   let nextInfoBlock = infoBlock || '';
   try {
     limitsAtStart = await captureLimitsSnapshot({ tool, verbose, limitsLib });
-    const block = formatLimitsSnapshotBlock(limitsAtStart, { title: '📊 Limits at start' });
+    const block = formatLimitsSnapshotBlock(limitsAtStart, { locale });
     if (block) nextInfoBlock = appendInfoSection(nextInfoBlock, block);
   } catch (e) {
     if (verbose) console.log(`[VERBOSE] ${commandLabel} --show-limits snapshot failed: ${e?.message || e}`);

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

@@ -21,6 +21,7 @@ import { formatDuration, formatWaitingReason, getRunningAgentProcesses, getRunni
 export { QUEUE_CONFIG, THRESHOLD_STRATEGIES } from './queue-config.lib.mjs';
 import { QUEUE_CONFIG } from './queue-config.lib.mjs';
 import { formatExecutingWorkSessionMessage, formatStartingWorkSessionMessage } from './work-session-formatting.lib.mjs';
+import { t } from './i18n.lib.mjs';
 
 export const QueueItemStatus = {
   QUEUED: 'queued',
@@ -51,6 +52,7 @@ class SolveQueueItem {
     // Issue #594: --show-limits virtual option (hive-telegram-bot only).
     this.showLimits = options.showLimits === true;
     this.limitsAtStart = options.limitsAtStart || null;
+    this.locale = options.locale || null;
     this.createdAt = new Date();
     this.startedAt = null;
     this.status = QueueItemStatus.QUEUED;
@@ -1094,7 +1096,7 @@ export class SolveQueue {
         this.stats.totalStarted++;
 
         // Update message to show Starting status
-        await this.updateItemMessage(item, formatStartingWorkSessionMessage({ infoBlock: item.infoBlock }));
+        await this.updateItemMessage(item, formatStartingWorkSessionMessage({ infoBlock: item.infoBlock, locale: item.locale }));
 
         this.log(`Starting: ${item.toString()} from ${tool} queue`);
 
@@ -1142,7 +1144,7 @@ export class SolveQueue {
 
           if (shouldUpdate) {
             const position = i + 1; // Position within this tool's queue
-            await this.updateItemMessage(item, `⏳ Waiting (${tool} queue #${position})\n\n${item.infoBlock}\n\n*Reason:*\n${item.waitingReason}`);
+            await this.updateItemMessage(item, `${t('telegram.solve_waiting', { tool, position }, { locale: item.locale })}\n\n${item.infoBlock}\n\n*${t('telegram.reason_label', {}, { locale: item.locale })}:*\n${item.waitingReason}`);
           }
         }
       }
@@ -1186,10 +1188,11 @@ export class SolveQueue {
                   sessionName,
                   isolationBackend: result.isolationBackend,
                   infoBlock: item.infoBlock,
+                  locale: item.locale,
                 });
                 await item.ctx.telegram.editMessageText(chatId, messageId, undefined, response, { parse_mode: 'Markdown' });
               } else {
-                const response = `❌ Error executing solve command:\n\n\`\`\`\n${result.error || result.output}\n\`\`\`\n\n${item.infoBlock}`;
+                const response = `${t('telegram.error_executing_command', { commandName: 'solve' }, { locale: item.locale })}:\n\n\`\`\`\n${result.error || result.output}\n\`\`\`\n\n${item.infoBlock}`;
                 await item.ctx.telegram.editMessageText(chatId, messageId, undefined, response, { parse_mode: 'Markdown' });
               }
             } catch (error) {
@@ -1415,6 +1418,7 @@ export function createQueueExecuteCallback(executeStartScreen, trackSessionFn) {
           //   handler so it can render an end-of-task delta.
           showLimits: item.showLimits === true,
           limitsAtStart: item.limitsAtStart || null,
+          locale: item.locale || null,
         });
       }
     }