@link-assistant/hive-mind 1.69.11 → 1.69.12

package/src/locales/zh.lino

@@ -80,6 +80,10 @@ zh
   limits.current_week_sonnet_only "本周（仅 Sonnet）"
   limits.disabled_by_admin "`--show-limits` 已被机器人管理员禁用。"
   limits.disk_space "磁盘空间"
+  limits.duration_day_short "天"
+  limits.duration_hour_short "小时"
+  limits.duration_minute_short "分钟"
+  limits.duration_second_short "秒"
   limits.end "结束"
   limits.five_hour_session "5 小时会话"
   limits.five_min_load_avg "5 分钟平均负载"
@@ -92,9 +96,41 @@ zh
   limits.passed "已过"
   limits.plan "方案"
   limits.ram "内存"
+  limits.reason_claude_5_hour_session "Claude 5 小时会话限额为 {{currentPercent}}%（阈值：{{thresholdPercent}}）"
+  limits.reason_claude_running "Claude 进程已在运行"
+  limits.reason_claude_weekly "Claude 每周限额为 {{currentPercent}}%（阈值：{{thresholdPercent}}）"
+  limits.reason_codex_5_hour_session "Codex 5 小时会话限额为 {{currentPercent}}%（阈值：{{thresholdPercent}}）"
+  limits.reason_codex_running "Codex 进程已在运行"
+  limits.reason_codex_weekly "Codex 每周限额为 {{currentPercent}}%（阈值：{{thresholdPercent}}）"
+  limits.reason_cpu_usage "CPU 使用率为 {{currentPercent}}%（阈值：{{thresholdPercent}}）"
+  limits.reason_disk_usage "磁盘使用率为 {{currentPercent}}%（阈值：{{thresholdPercent}}）"
+  limits.reason_gemini_running "Gemini CLI 进程已在运行"
+  limits.reason_github_api "GitHub API 使用率为 {{currentPercent}}%（阈值：{{thresholdPercent}}）"
+  limits.reason_min_interval "尚未达到命令之间的最小间隔"
+  limits.reason_qwen_running "Qwen Code 进程已在运行"
+  limits.reason_ram_usage "内存使用率为 {{currentPercent}}%（阈值：{{thresholdPercent}}）"
+  limits.reason_threshold_exceeded "{{metric}} 超过阈值"
+  limits.remaining "剩余 {{duration}}"
   limits.requests "请求"
   limits.resets_at "{{time}} 重置"
   limits.resets_in "{{duration}} 后重置"
+  limits.resource_limit_exceeded "资源限额已超出"
+  limits.solve_queue_status "Solve 队列状态"
+  limits.queue_completed "已完成"
+  limits.queue_failed "失败"
+  limits.queue_and_more "还有 {{count}} 个"
+  limits.queue_pending "等待"
+  limits.queue_processing "处理中"
+  limits.queue_processes "{{count}} 个进程"
+  limits.queue_status_cancelled "已取消"
+  limits.queue_status_failed "失败"
+  limits.queue_status_queued "已排队"
+  limits.queue_status_started "已启动"
+  limits.queue_status_starting "正在启动"
+  limits.queue_status_waiting "等待中"
+  limits.queue_waiting_current_command "等待当前命令"
+  limits.queue_waiting_in_queue "在队列中等待"
+  limits.queues "队列"
   limits.seven_day_all_models "7 天所有模型"
   limits.seven_day_sonnet_only "7 天仅 Sonnet"
   limits.session "会话"
@@ -108,9 +144,11 @@ zh
   telegram.gathering_version "🔄 正在收集版本信息……"
   telegram.usage_limits_title "📊 *使用限额*"
   telegram.version_information_title "🤖 *版本信息*"
+  telegram.formatting_fallback_warning "⚠️ 检测到格式错误。正在显示纯文本备用内容。"
   telegram.limits_only_in_groups "❌ /limits 命令仅在群聊中有效。请将本机器人加入群组并设为管理员。"
   telegram.version_only_in_groups "❌ /version 命令仅在群聊中有效。请将本机器人加入群组并设为管理员。"
   telegram.solve_only_in_groups "❌ {{commandDisplay}} 命令仅在群聊中有效。请将本机器人加入群组并设为管理员。"
+  telegram.solve_queue_only_in_groups "❌ /solve_queue 命令仅在群聊中有效。请将本机器人加入群组并设为管理员。"
   telegram.hive_only_in_groups "❌ /hive 命令仅在群聊中有效。请将本机器人加入群组并设为管理员。"
   telegram.solve_disabled "❌ 此机器人实例已禁用 solve 命令。"
   telegram.hive_disabled "❌ 此机器人实例已禁用 /hive 命令。"
@@ -215,6 +253,20 @@ zh
   language.ru "俄语"
   language.zh "中文"
   language.hi "印地语"
+  version.ai_agents "AI 代理"
+  version.browsers "浏览器"
+  version.browser_automation "浏览器自动化"
+  version.connected "已连接"
+  version.development_tools "开发工具"
+  version.environment "环境"
+  version.architecture "架构"
+  version.kernel "内核"
+  version.not_connected "未连接"
+  version.os "操作系统"
+  version.platform "平台"
+  version.process_running_restart_needed "正在运行的进程：`{{processVersion}}`（需要重启）"
+  version.system "系统"
+  version.version "版本"
   prompt.user.issue_to_solve "要解决的问题：{{issueUrl}}"
   prompt.user.issue_linked_to_pr "要解决的问题：与 PR #{{prNumber}} 关联的问题"
   prompt.user.prepared_branch "为你准备的分支：{{branchName}}"

package/src/telegram-bot.mjs

@@ -40,7 +40,7 @@ const { applySolveToolAlias, getFirstParsedPositionalArg, getSolveCommandNameFro
 const { executeStartScreen: executeStartScreenCommand, buildExecuteAndUpdateMessage } = await import('./telegram-command-execution.lib.mjs');
 const { isChatStopped, getChatStopInfo, getStoppedChatRejectMessage, DEFAULT_STOP_REASON } = await import('./telegram-start-stop-command.lib.mjs');
 const { isOldMessage: _isOldMessage, isGroupChat: _isGroupChat, isChatAuthorized: _isChatAuthorized, isForwardedOrReply: _isForwardedOrReply, extractCommandFromText, extractGitHubUrl: _extractGitHubUrl } = await import('./telegram-message-filters.lib.mjs');
-const { safeReply } = await import('./telegram-safe-reply.lib.mjs');
+const { installTelegramFormattingFallback, safeEditMessageText, safeReply } = await import('./telegram-safe-reply.lib.mjs');
 const { registerTerminalWatchCommand, startAutoTerminalWatchForSession } = await import('./telegram-terminal-watch-command.lib.mjs');
 const { launchBotWithRetry } = await import('./telegram-bot-launcher.lib.mjs');
 const { trackSession, startSessionMonitoring, hasActiveSessionForUrlAsync } = await import('./session-monitor.lib.mjs');
@@ -315,6 +315,7 @@ const { Telegraf } = telegrafModule;
 const bot = new Telegraf(BOT_TOKEN, {
   handlerTimeout: Infinity, // Remove default 90s timeout; command handlers like /solve spawn long-running processes
 });
+installTelegramFormattingFallback(bot.telegram, { verbose: VERBOSE });
 
 // Track bot startup time (Unix seconds to match Telegram's message.date format)
 const BOT_START_TIME = Math.floor(Date.now() / 1000);
@@ -514,7 +515,7 @@ bot.command('help', async ctx => {
     allowTopicHint: topicId ? `TELEGRAM_ALLOWED_TOPICS="(${chatId} ${topicId})"` : '',
   });
 
-  await ctx.reply(message, { parse_mode: 'Markdown' });
+  await safeReply(ctx, message, { fallbackLocale: helpLocale });
 });
 
 bot.command('limits', async ctx => {
@@ -564,10 +565,10 @@ bot.command('limits', async ctx => {
   const claudeError = limits.claude.success ? null : limits.claude.error;
   const codexError = limits.codex.success ? null : limits.codex.error;
   const solveQueue = getSolveQueue({ verbose: VERBOSE });
-  const queueStatus = await solveQueue.formatStatus();
+  const queueStatus = await solveQueue.formatStatus({ locale: userLocale });
   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' });
+  await safeEditMessageText(ctx.telegram, fetchingMessage.chat.id, fetchingMessage.message_id, undefined, message, { parse_mode: 'Markdown', fallbackLocale: userLocale, verbose: VERBOSE });
 });
 bot.command('version', async ctx => {
   VERBOSE && console.log('[VERBOSE] /version command received');
@@ -585,8 +586,8 @@ bot.command('version', async ctx => {
     reply_to_message_id: ctx.message.message_id,
   });
   const result = await getVersionInfo(VERBOSE);
-  if (!result.success) return await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, `❌ ${escapeMarkdownV2(result.error, { preserveCodeBlocks: true })}`, { parse_mode: 'MarkdownV2' });
-  await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, t('telegram.version_information_title', {}, { locale: versionLocale }) + '\n\n' + formatVersionMessage(result.versions), { parse_mode: 'Markdown' });
+  if (!result.success) return await safeEditMessageText(ctx.telegram, fetchingMessage.chat.id, fetchingMessage.message_id, undefined, `❌ ${escapeMarkdownV2(result.error, { preserveCodeBlocks: true })}`, { parse_mode: 'MarkdownV2', fallbackLocale: versionLocale, verbose: VERBOSE });
+  await safeEditMessageText(ctx.telegram, fetchingMessage.chat.id, fetchingMessage.message_id, undefined, t('telegram.version_information_title', {}, { locale: versionLocale }) + '\n\n' + formatVersionMessage(result.versions, { locale: versionLocale }), { parse_mode: 'Markdown', fallbackLocale: versionLocale, verbose: VERBOSE });
 });
 
 const { registerLanguageCommand } = await import('./telegram-language-command.lib.mjs');
@@ -598,7 +599,7 @@ registerAcceptInvitesCommand(bot, sharedCommandOpts);
 const { registerMergeCommand } = await import('./telegram-merge-command.lib.mjs');
 registerMergeCommand(bot, sharedCommandOpts);
 const { registerSolveQueueCommand } = await import('./telegram-solve-queue-command.lib.mjs');
-const { handleSolveQueueCommand } = registerSolveQueueCommand(bot, { ...sharedCommandOpts, getSolveQueue });
+const { handleSolveQueueCommand } = registerSolveQueueCommand(bot, { ...sharedCommandOpts, getSolveQueue, safeReply, resolveLocale: resolveLocaleFromTelegramCtx });
 const { registerSubscribeCommands } = await import('./telegram-subscribers.lib.mjs'); // #1688
 registerSubscribeCommands(bot, sharedCommandOpts);
 const { registerTaskCommands } = await import('./telegram-task-command.lib.mjs');
@@ -848,7 +849,7 @@ async function handleSolveCommand(ctx) {
     await safeReply(ctx, t('telegram.url_session_running', { url: escapeMarkdown(normalizedUrl), session: activeSession.sessionName }, { locale: solveLocale }), { reply_to_message_id: ctx.message.message_id });
     return;
   }
-  const check = await solveQueue.canStartCommand({ tool: solveTool }); // Skip Claude limits for agent (#1159)
+  const check = await solveQueue.canStartCommand({ tool: solveTool, locale: solveLocale }); // Skip Claude limits for agent (#1159)
   const queueStats = solveQueue.getStats();
   // Handle rejection: threshold strategy is 'reject' — fail immediately (issue #1267)
   if (check.rejected) {

package/src/telegram-safe-reply.lib.mjs

@@ -1,19 +1,122 @@
-// Issue #1460/#1497: safeReply - try Markdown first, fall back to plain text on parsing errors.
+import { normalizeLocale, t } from './i18n.lib.mjs';
+
+const FORMATTING_FALLBACK_INSTALLED = Symbol.for('hiveMind.telegramFormattingFallbackInstalled');
+const DEFAULT_FORMATTING_FALLBACK_WARNING = '⚠️ Formatting error detected. Showing plain text fallback.';
+const FORMATTING_FALLBACK_WARNINGS = {
+  en: DEFAULT_FORMATTING_FALLBACK_WARNING,
+  ru: '⚠️ Обнаружена ошибка форматирования. Показываю обычный текст.',
+  zh: '⚠️ 检测到格式错误。正在显示纯文本备用内容。',
+  hi: '⚠️ फ़ॉर्मैटिंग त्रुटि मिली। सादा पाठ fallback दिखाया जा रहा है।',
+};
+
+function splitOptions(options = {}) {
+  const { fallbackLocale, locale, verbose, ...telegramOptions } = options || {};
+  return {
+    telegramOptions,
+    fallbackLocale: fallbackLocale || locale || null,
+    verbose: Boolean(verbose),
+  };
+}
+
+export function isTelegramFormattingError(error) {
+  const message = error?.description || error?.message || String(error || '');
+  return /can't parse entities/i.test(message) || /can't find end of/i.test(message) || /entity.*parse/i.test(message) || (/bad request/i.test(message) && /400|parse|entity/i.test(message));
+}
+
+export function stripTelegramMarkdown(text) {
+  return String(text ?? '')
+    .replace(/\[([^\]]+)\]\(([^)]+)\)/g, '$1 ($2)')
+    .replace(/```([\s\S]*?)```/g, '$1')
+    .replace(/\\_/g, '_')
+    .replace(/\\\*/g, '*')
+    .replace(/\\`/g, '`')
+    .replace(/\\\[/g, '[')
+    .replace(/\*([^*\n]+)\*/g, '$1')
+    .replace(/_([^_\n]+)_/g, '$1')
+    .replace(/`([^`]+)`/g, '$1');
+}
+
+function getFormattingFallbackWarning(locale) {
+  const key = 'telegram.formatting_fallback_warning';
+  const normalizedLocale = normalizeLocale(locale);
+  const warning = t(key, {}, locale ? { locale } : {});
+  if (warning !== key && (normalizedLocale === 'en' || warning !== DEFAULT_FORMATTING_FALLBACK_WARNING)) return warning;
+  return FORMATTING_FALLBACK_WARNINGS[normalizedLocale] || DEFAULT_FORMATTING_FALLBACK_WARNING;
+}
+
+export function buildTelegramFormattingFallbackText(text, options = {}) {
+  const locale = options?.fallbackLocale || options?.locale || null;
+  return `${getFormattingFallbackWarning(locale)}\n\n${stripTelegramMarkdown(text)}`;
+}
+
+function logFormattingFailure(scope, error, text, verbose = false) {
+  const message = error?.description || error?.message || String(error || '');
+  console.error(`[telegram-bot] ${scope}: formatted Telegram message failed: ${message}`);
+  if (verbose) {
+    console.error(`[telegram-bot] ${scope}: Failing message (${Buffer.byteLength(String(text ?? ''), 'utf-8')} bytes): ${text}`);
+  }
+}
+
+// Issue #1460/#1497/#1788: try Markdown first, fall back to localized plain text on parsing errors.
 export async function safeReply(ctx, text, options = {}) {
+  const { telegramOptions, fallbackLocale, verbose } = splitOptions(options);
+  const firstOptions = { parse_mode: 'Markdown', ...telegramOptions };
   try {
-    return await ctx.reply(text, { parse_mode: 'Markdown', ...options });
+    return await ctx.reply(text, firstOptions);
   } catch (error) {
-    const message = error?.message || '';
-    const isParsingError = message.includes("can't parse entities") || message.includes("Can't parse entities") || message.includes("can't find end of") || (message.includes('Bad Request') && message.includes('400'));
-    if (!isParsingError) throw error;
-    console.error(`[telegram-bot] safeReply: Markdown parsing failed: ${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 });
+    if (!isTelegramFormattingError(error)) throw error;
+    logFormattingFailure('safeReply', error, text, verbose);
+    const fallbackText = buildTelegramFormattingFallbackText(text, { fallbackLocale });
+    return await ctx.reply(fallbackText, { ...telegramOptions, parse_mode: undefined });
   }
 }
+
+export async function safeEditMessageText(telegram, chatId, messageId, inlineMessageId, text, options = {}) {
+  const { telegramOptions, fallbackLocale, verbose } = splitOptions(options);
+  const firstOptions = { parse_mode: 'Markdown', ...telegramOptions };
+  try {
+    return await telegram.editMessageText(chatId, messageId, inlineMessageId, text, firstOptions);
+  } catch (error) {
+    if (!isTelegramFormattingError(error)) throw error;
+    logFormattingFailure('safeEditMessageText', error, text, verbose);
+    const fallbackText = buildTelegramFormattingFallbackText(text, { fallbackLocale });
+    return await telegram.editMessageText(chatId, messageId, inlineMessageId, fallbackText, { ...telegramOptions, parse_mode: undefined });
+  }
+}
+
+function wrapTelegramMethod(telegram, methodName, textIndex, optionsIndex, defaults = {}) {
+  const original = telegram?.[methodName];
+  if (typeof original !== 'function') return;
+
+  telegram[methodName] = async function wrappedTelegramMessageMethod(...args) {
+    const text = args[textIndex];
+    const originalOptions = args[optionsIndex] || {};
+    const { telegramOptions, fallbackLocale, verbose } = splitOptions(originalOptions);
+    args[optionsIndex] = telegramOptions;
+
+    try {
+      return await original.apply(this, args);
+    } catch (error) {
+      if (!isTelegramFormattingError(error) || typeof text !== 'string') throw error;
+      logFormattingFailure(methodName, error, text, verbose || defaults.verbose);
+      const retryArgs = [...args];
+      retryArgs[textIndex] = buildTelegramFormattingFallbackText(text, { fallbackLocale: fallbackLocale || defaults.fallbackLocale });
+      retryArgs[optionsIndex] = { ...telegramOptions, parse_mode: undefined };
+      return await original.apply(this, retryArgs);
+    }
+  };
+}
+
+export function installTelegramFormattingFallback(telegram, options = {}) {
+  if (!telegram || telegram[FORMATTING_FALLBACK_INSTALLED]) return telegram;
+
+  const defaults = {
+    fallbackLocale: options.fallbackLocale || options.locale || null,
+    verbose: Boolean(options.verbose),
+  };
+
+  wrapTelegramMethod(telegram, 'sendMessage', 1, 2, defaults);
+  wrapTelegramMethod(telegram, 'editMessageText', 3, 4, defaults);
+  telegram[FORMATTING_FALLBACK_INSTALLED] = true;
+  return telegram;
+}

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

@@ -13,6 +13,15 @@
  * @see https://github.com/link-assistant/hive-mind/issues/1232
  */
 
+import { t } from './i18n.lib.mjs';
+
+const GROUP_ONLY_MESSAGE = '❌ The /solve_queue command only works in group chats. Please add this bot to a group and make it an admin.';
+
+function commandText(key, params = {}, locale = null, fallback = key) {
+  const translated = t(key, params, locale ? { locale } : {});
+  return translated === key ? fallback : translated;
+}
+
 /**
  * Registers the /solve_queue command handler with the bot
  * @param {Object} bot - The Telegraf bot instance
@@ -29,7 +38,7 @@
  * @returns {{ handleSolveQueueCommand: Function }} The command handler for use in text fallback
  */
 export function registerSolveQueueCommand(bot, options) {
-  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized, isTopicAuthorized, buildAuthErrorMessage, addBreadcrumb, getSolveQueue } = options;
+  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized, isTopicAuthorized, buildAuthErrorMessage, addBreadcrumb, getSolveQueue, safeReply, resolveLocale } = options;
 
   async function handleSolveQueueCommand(ctx) {
     VERBOSE && console.log('[VERBOSE] /solve_queue command received');
@@ -40,6 +49,8 @@ export function registerSolveQueueCommand(bot, options) {
       level: 'info',
       data: { chatId: ctx.chat?.id, chatType: ctx.chat?.type, userId: ctx.from?.id, username: ctx.from?.username },
     });
+    const locale = resolveLocale ? resolveLocale(ctx) : null;
+    const replyWithFallback = (text, replyOptions = {}) => (safeReply ? safeReply(ctx, text, replyOptions) : ctx.reply(text, { parse_mode: 'Markdown', ...replyOptions }));
 
     // Ignore messages sent before bot started
     if (isOldMessage(ctx)) {
@@ -55,8 +66,9 @@ export function registerSolveQueueCommand(bot, options) {
 
     if (!isGroupChat(ctx)) {
       VERBOSE && console.log('[VERBOSE] /solve_queue ignored: not a group chat');
-      await ctx.reply('❌ The /solve_queue command only works in group chats. Please add this bot to a group and make it an admin.', {
+      await replyWithFallback(commandText('telegram.solve_queue_only_in_groups', {}, locale, GROUP_ONLY_MESSAGE), {
         reply_to_message_id: ctx.message.message_id,
+        fallbackLocale: locale,
       });
       return;
     }
@@ -65,7 +77,7 @@ export function registerSolveQueueCommand(bot, options) {
     if (!authorize(ctx)) {
       VERBOSE && console.log('[VERBOSE] /solve_queue ignored: not authorized');
       const errMsg = buildAuthErrorMessage ? buildAuthErrorMessage(ctx) : `❌ This chat (ID: ${ctx.chat.id}) is not authorized.`;
-      await ctx.reply(errMsg, { reply_to_message_id: ctx.message.message_id });
+      await replyWithFallback(errMsg, { reply_to_message_id: ctx.message.message_id, fallbackLocale: locale });
       return;
     }
 
@@ -77,11 +89,11 @@ export function registerSolveQueueCommand(bot, options) {
     // Shows per-queue breakdown with first 5 items per queue and human-readable times
     // Processing counts are actual running system processes (via pgrep)
     // See: https://github.com/link-assistant/hive-mind/issues/1267
-    const message = await solveQueue.formatDetailedStatus();
+    const message = await solveQueue.formatDetailedStatus({ locale });
 
-    await ctx.reply(message, {
-      parse_mode: 'Markdown',
+    await replyWithFallback(message, {
       reply_to_message_id: ctx.message.message_id,
+      fallbackLocale: locale,
     });
   }
 

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

@@ -2,6 +2,7 @@
 
 import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
+import { lt } from './limits-i18n.lib.mjs';
 
 const execAsync = promisify(exec);
 
@@ -111,8 +112,9 @@ export function formatThresholdPercent(ratio) {
  * @returns {string} Human-readable duration
  * @see https://github.com/link-assistant/hive-mind/issues/1267
  */
-export function formatDuration(ms) {
+export function formatDuration(ms, options = {}) {
   if (ms < 0) ms = 0;
+  const locale = typeof options === 'string' ? options : options?.locale || null;
 
   const totalSeconds = Math.floor(ms / 1000);
   const days = Math.floor(totalSeconds / 86400);
@@ -120,11 +122,26 @@ export function formatDuration(ms) {
   const minutes = Math.floor((totalSeconds % 3600) / 60);
   const seconds = totalSeconds % 60;
 
+  const labels =
+    locale && locale !== 'en'
+      ? {
+          day: lt('duration_day_short', {}, { locale }),
+          hour: lt('duration_hour_short', {}, { locale }),
+          minute: lt('duration_minute_short', {}, { locale }),
+          second: lt('duration_second_short', {}, { locale }),
+        }
+      : {
+          day: 'd',
+          hour: 'h',
+          minute: 'm',
+          second: 's',
+        };
+
   const parts = [];
-  if (days > 0) parts.push(`${days}d`);
-  if (hours > 0) parts.push(`${hours}h`);
-  if (minutes > 0) parts.push(`${minutes}m`);
-  if (seconds > 0 || parts.length === 0) parts.push(`${seconds}s`);
+  if (days > 0) parts.push(`${days}${locale && locale !== 'en' ? ' ' : ''}${labels.day}`);
+  if (hours > 0) parts.push(`${hours}${locale && locale !== 'en' ? ' ' : ''}${labels.hour}`);
+  if (minutes > 0) parts.push(`${minutes}${locale && locale !== 'en' ? ' ' : ''}${labels.minute}`);
+  if (seconds > 0 || parts.length === 0) parts.push(`${seconds}${locale && locale !== 'en' ? ' ' : ''}${labels.second}`);
 
   return parts.join(' ');
 }
@@ -136,9 +153,44 @@ export function formatDuration(ms) {
  * @param {number} threshold - Threshold ratio (0.0 - 1.0)
  * @returns {string} Human-readable reason
  */
-export function formatWaitingReason(metric, currentValue, threshold) {
+export function formatWaitingReason(metric, currentValue, threshold, options = {}) {
+  const locale = typeof options === 'string' ? options : options?.locale || null;
   const thresholdPercent = formatThresholdPercent(threshold);
   const currentPercent = Math.round(currentValue);
+  const params = { currentPercent, thresholdPercent, metric };
+
+  if (locale && locale !== 'en') {
+    switch (metric) {
+      case 'ram':
+        return lt('reason_ram_usage', params, { locale });
+      case 'cpu':
+        return lt('reason_cpu_usage', params, { locale });
+      case 'disk':
+        return lt('reason_disk_usage', params, { locale });
+      case 'claude_5_hour_session':
+        return lt('reason_claude_5_hour_session', params, { locale });
+      case 'claude_weekly':
+        return lt('reason_claude_weekly', params, { locale });
+      case 'codex_5_hour_session':
+        return lt('reason_codex_5_hour_session', params, { locale });
+      case 'codex_weekly':
+        return lt('reason_codex_weekly', params, { locale });
+      case 'github':
+        return lt('reason_github_api', params, { locale });
+      case 'min_interval':
+        return lt('reason_min_interval', params, { locale });
+      case 'claude_running':
+        return lt('reason_claude_running', params, { locale });
+      case 'codex_running':
+        return lt('reason_codex_running', params, { locale });
+      case 'qwen_running':
+        return lt('reason_qwen_running', params, { locale });
+      case 'gemini_running':
+        return lt('reason_gemini_running', params, { locale });
+      default:
+        return lt('reason_threshold_exceeded', params, { locale });
+    }
+  }
 
   switch (metric) {
     case 'ram':