@link-assistant/hive-mind 1.69.4 → 1.69.6

package/src/solve.config.lib.mjs

@@ -572,8 +572,23 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: "Working language passed to the AI tool (Claude/Codex/etc). Used as the tool's preferred language for translations and prompts. Defaults to --language.",
     choices: ['en', 'ru', 'zh', 'hi'],
   },
+  'prompt-language': {
+    type: 'string',
+    description: 'Deprecated alias for --work-language.',
+    choices: ['en', 'ru', 'zh', 'hi'],
+    hidden: true,
+  },
+  'auto-language': {
+    type: 'boolean',
+    description: 'Experimental and disabled by default. Automatically detect the target issue or pull request language and set the AI work language to English or Russian when one language has more than 51% of all words. Explicit --work-language or --prompt-language takes precedence.',
+    default: false,
+  },
 };
 
+function hasRawOption(rawArgs, optionName) {
+  return rawArgs.some(arg => arg === optionName || arg.startsWith(`${optionName}=`));
+}
+
 // Function to create yargs configuration - avoids duplication
 export const createYargsConfig = yargsInstance => {
   let config = yargsInstance
@@ -749,6 +764,12 @@ export const parseArguments = async (yargs = getLinoYargsFactory(), hideBinFn =
     if (argv.disableIssueAutoCreationOnError) {
       argv.disableReportIssue = true;
     }
+    const workLanguageExplicit = hasRawOption(rawArgs, '--work-language');
+    const promptLanguageExplicit = hasRawOption(rawArgs, '--prompt-language');
+    if (argv.promptLanguage && !workLanguageExplicit) {
+      argv.workLanguage = argv.promptLanguage;
+    }
+    argv._workLanguageExplicit = workLanguageExplicit || promptLanguageExplicit;
   }
 
   // --finalize normalization

package/src/solve.mjs

@@ -84,16 +84,6 @@ try {
 }
 global.verboseMode = argv.verbose;
 
-// Initialize i18n based on --language / --ui-language / --work-language
-// (or detected system locale). --language sets both tracks by default;
-// --ui-language and --work-language can override each track independently.
-const { initI18n } = await import('./i18n.lib.mjs');
-await initI18n({
-  language: argv.language,
-  uiLanguage: argv.uiLanguage,
-  workLanguage: argv.workLanguage,
-});
-
 setupVerboseLogInterceptor(); // Issue #1466: capture [VERBOSE] output in log files
 setupStdioLogInterceptor(); // Issue #1549: capture ALL terminal output in log file
 
@@ -180,6 +170,18 @@ if (isIssueUrl) {
 }
 cleanupContext.owner = owner;
 cleanupContext.repo = repo;
+if (argv.autoLanguage) {
+  const { applyAutoLanguageToArgv } = await import('./auto-language.lib.mjs');
+  await applyAutoLanguageToArgv({ argv, githubLib, owner, repo, number: urlNumber, isIssueUrl, isPrUrl, log });
+}
+// Initialize i18n based on --language / --ui-language / --work-language
+// (or detected system locale). --auto-language may set only the work track.
+const { initI18n } = await import('./i18n.lib.mjs');
+await initI18n({
+  language: argv.language,
+  uiLanguage: argv.uiLanguage,
+  workLanguage: argv.workLanguage,
+});
 // Setup unhandled error handlers to ensure log path is always shown
 const errorHandlerOptions = {
   log,

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}`);