@goodandready/dsh-messenger-gateway 0.3.20 → 0.3.21

package/lib/gateway.js

@@ -35,6 +35,7 @@ import {
 import { isTopicGoneError } from './telegram-errors.js'
 import { ensureContentArray } from './content-guard.js'
 import { mergeDynamicCommands } from './commands.js'
+import { t } from './locales/index.js'
 
 
 function whenIdleWithTimeout(agent, timeoutMs, signal) {
@@ -78,18 +79,74 @@ export class Gateway {
     this.chatTts = createVoicePrefs(join(home, 'messenger-gateway', 'chat-tts.json'))
     this.muted = createVoicePrefs(join(home, 'messenger-gateway', 'muted.json'))
     this.personas = createPersonaStore(join(home, 'messenger-gateway', 'personas.json'))
+    this.chatLocales = createVoicePrefs(join(home, 'messenger-gateway', 'chat-locales.json'))
     this.scheduler = createScheduler(join(home, 'messenger-gateway', 'scheduled.json'), async (task) => {
       const target = {
         platform: task.platform || 'telegram',
         chatId: task.chatId,
         threadId: task.threadId || 0,
       }
-      const text = `⏰ <b>[Напоминание]</b>\n${task.text}`
-      await this.sendToMessenger(target, { text })
+      const locale = this.resolveLocale({ chatId: task.chatId })
+      if (task.prompt || task.action === 'prompt') {
+        const promptText = task.prompt || task.text
+        try {
+          await this.dispatchAutonomousPrompt(target, promptText, locale)
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err)
+          this.ctx.logger?.warn?.(`dsh-messenger-gateway: cron prompt error: ${msg}`)
+          await this.sendToMessenger(target, {
+            text: `⚠️ <b>[Cron Error]</b>\n${msg}`,
+          }).catch(() => {})
+        }
+      } else {
+        const text = t('remind.prefix', { text: task.text }, locale)
+        await this.sendToMessenger(target, { text })
+      }
     })
     this.stats = { sent: 0, errors: 0, startedAt: Date.now() }
   }
 
+  resolveLocale(input) {
+    if (input?.locale) return input.locale
+    const chatId = input?.chatId
+    if (chatId && this.chatLocales?.get(chatId)) return this.chatLocales.get(chatId)
+    if (input?.languageCode) {
+      const code = String(input.languageCode).toLowerCase()
+      if (code.startsWith('zh')) return 'zh'
+      if (code.startsWith('en')) return 'en'
+    }
+    return this.config?.defaultLocale || 'en'
+  }
+
+  async dispatchAutonomousPrompt(target, promptText, locale = 'en') {
+    const key = this.sessionKeyFor(target)
+    const reply = async (payload) => {
+      await this.sendToMessenger(target, typeof payload === 'string' ? { text: payload } : payload)
+    }
+    const input = {
+      platform: target.platform || 'telegram',
+      chatId: target.chatId,
+      threadId: target.threadId || 0,
+      text: promptText,
+      reply,
+      locale,
+    }
+    const chat = await this.getOrCreateChat(key, input)
+    const turnInput = { ...input, attachments: [], inboundWasVoice: false }
+    chat.turnActive = true
+    try { chat.abort?.abort?.() } catch {}
+    chat.abort = new AbortController()
+    const run = chat.busy.then(() => this.runTurn(chat, turnInput, chat.abort.signal))
+    chat.busy = run.catch(() => {})
+    run.catch((err) => {
+      const msg = err instanceof Error ? err.message : String(err)
+      this.ctx.logger?.warn?.(`dsh-messenger-gateway: cron turn: ${msg}`)
+      chat.turnActive = false
+      chat.abort = undefined
+    })
+    return run
+  }
+
   isMuted(chatId) { return this.muted.get(chatId) === true }
   setMuted(chatId, on) { return this.muted.set(chatId, on) }
 
@@ -300,23 +357,24 @@ export class Gateway {
 
   async handleUnauthorized(input) {
     const { reply, userId, username } = input
+    const locale = this.resolveLocale(input)
     if (!this.tg().pairingEnabled) {
-      await reply('Доступ закрыт. Попросите владельца добавить ваш id в allowlist.')
+      await reply(t('msg.not_allowed', {}, locale))
       return
     }
     try {
       const { code } = this.pairing.requestCode(userId, { username })
-      await reply(`Нет доступа.\nВаш id: ${userId}\nКод сопряжения: ${code}\n\nВладелец должен отправить боту:\n/pair ${code}`)
+      await reply(t('msg.pairing_requested', { userId, code }, locale))
       this.sendAlert('pairing', { userId, username, code }).catch(() => {})
     } catch (err) {
-      if (err.code === 'RATE_LIMIT') await reply('Код уже выдан. Подождите или попросите владельца /pair.')
-      else await reply(`Не удалось выдать код: ${err.message}`)
+      if (err.code === 'RATE_LIMIT') await reply(t('msg.pairing_rate_limit', {}, locale))
+      else await reply(t('msg.exception', { message: err.message }, locale))
     }
   }
 
   async handleCallback(cb) {
     if (cb.userId && !this.isUserAllowed(cb.userId)) {
-      try { await cb.answer('Нет доступа.') } catch {}
+      try { await cb.answer(t('msg.not_allowed', {}, 'en')) } catch {}
       return
     }
     const indexed = this.callbackIndex.get(cb.data)
@@ -325,7 +383,7 @@ export class Gateway {
     if (askToken && this.pendingAsks.has(askToken)) {
       const pending = this.pendingAsks.get(askToken)
       if (!targetMatchesAsk(pending, cb)) {
-        await cb.answer('Кнопка для другого чата')
+        await cb.answer(t('ask.other_chat', {}, 'en'))
         return
       }
       const action = parseAskCallback(cb.data)
@@ -339,9 +397,9 @@ export class Gateway {
           indexCallbacks(this.callbackIndex, nextKb.callbackKeys, askToken)
           try {
             if (cb.editReplyMarkup) await cb.editReplyMarkup(nextKb.replyMarkup)
-            else await cb.editMessage(cb.message?.text || 'Выбор', nextKb.replyMarkup)
+            else await cb.editMessage(cb.message?.text || 'Selection', nextKb.replyMarkup)
           } catch {}
-          await cb.answer(pending.selected.has(action.id) ? 'Выбрано' : 'Снято')
+          await cb.answer(pending.selected.has(action.id) ? 'Selected' : 'Deselected')
           return
         }
         if (action.kind === 'page') {
@@ -352,7 +410,7 @@ export class Gateway {
           indexCallbacks(this.callbackIndex, nextKb.callbackKeys, askToken)
           try {
             if (cb.editReplyMarkup) await cb.editReplyMarkup(nextKb.replyMarkup)
-            else await cb.editMessage(cb.message?.text || 'Выбор', nextKb.replyMarkup)
+            else await cb.editMessage(cb.message?.text || 'Selection', nextKb.replyMarkup)
           } catch {}
           await cb.answer()
           return
@@ -362,7 +420,7 @@ export class Gateway {
           clearTimeout(pending.timer)
           releaseCallbacks(this.callbackIndex, pending.callbackKeys)
           await cb.answer('OK')
-          try { await cb.editMessage(cb.message?.text || 'Выбрано', REMOVE_KEYBOARD) } catch {}
+          try { await cb.editMessage(cb.message?.text || 'Done', REMOVE_KEYBOARD) } catch {}
           pending.resolve({ buttonId: 'done', selected: Array.from(pending.selected), data: cb.data })
           return
         }
@@ -370,8 +428,8 @@ export class Gateway {
           this.pendingAsks.delete(askToken)
           clearTimeout(pending.timer)
           releaseCallbacks(this.callbackIndex, pending.callbackKeys)
-          await cb.answer('Отменено')
-          try { await cb.editMessage(cb.message?.text || 'Отменено', REMOVE_KEYBOARD) } catch {}
+          await cb.answer('Cancelled')
+          try { await cb.editMessage(cb.message?.text || 'Cancelled', REMOVE_KEYBOARD) } catch {}
           pending.resolve({ buttonId: 'cancel', selected: [], data: cb.data })
           return
         }
@@ -380,7 +438,7 @@ export class Gateway {
       clearTimeout(pending.timer)
       releaseCallbacks(this.callbackIndex, pending.callbackKeys)
       await cb.answer('OK')
-      try { await cb.editMessage(cb.message?.text || 'Выбрано', REMOVE_KEYBOARD) } catch {}
+      try { await cb.editMessage(cb.message?.text || 'Done', REMOVE_KEYBOARD) } catch {}
       pending.resolve({ buttonId: action.id || buttonId, data: cb.data })
       return
     }
@@ -396,14 +454,14 @@ export class Gateway {
         const catalog = await listModelCatalog(this.ctx, current)
         const models = catalog.modelsByProvider.get(providerId) || []
         if (!models.length) {
-          await cb.answer('Нет доступных моделей у этого провайдера')
+          await cb.answer(t('model.no_models', {}, 'en'))
           return
         }
         const kb = buildModelsKeyboard(providerId, models, current.model, 0)
         await cb.answer()
         const text = [
-          `🤖 <b>Провайдер:</b> <code>${providerId}</code>`,
-          `Выберите модель (страница ${kb.page + 1}/${kb.totalPages}):`,
+          `🤖 <b>Provider:</b> <code>${providerId}</code>`,
+          `Select model (page ${kb.page + 1}/${kb.totalPages}):`,
         ].join('\n')
         try {
           if (cb.editMessage) await cb.editMessage(text, kb)
@@ -420,8 +478,8 @@ export class Gateway {
         const kb = buildModelsKeyboard(providerId, models, current.model, page)
         await cb.answer()
         const text = [
-          `🤖 <b>Провайдер:</b> <code>${providerId}</code>`,
-          `Выберите модель (страница ${kb.page + 1}/${kb.totalPages}):`,
+          `🤖 <b>Provider:</b> <code>${providerId}</code>`,
+          `Select model (page ${kb.page + 1}/${kb.totalPages}):`,
         ].join('\n')
         try {
           if (cb.editMessage) await cb.editMessage(text, kb)
@@ -435,8 +493,8 @@ export class Gateway {
         const kb = buildProvidersKeyboard(catalog.providers, current)
         await cb.answer()
         const text = [
-          '🤖 <b>Выберите провайдера:</b>',
-          `Текущая: <code>${current.provider}/${current.model}</code>`,
+          '🤖 <b>Choose Provider:</b>',
+          `Current: <code>${current.provider}/${current.model}</code>`,
         ].join('\n')
         try {
           if (cb.editMessage) await cb.editMessage(text, kb)
@@ -448,7 +506,7 @@ export class Gateway {
         const key = parts[2]
         const stored = getStoredModelSelection(key)
         if (!stored) {
-          await cb.answer('Сессия выбора модели истекла, вызовите /model заново')
+          await cb.answer(t('ask.expired', {}, 'en'))
           return
         }
         const { provider, model } = stored
@@ -463,12 +521,12 @@ export class Gateway {
           } catch (e) {
             this.ctx.logger?.warn?.(`persist agent model: ${e.message}`)
           }
-          await cb.answer(`Выбрана ${model}`)
+          await cb.answer(t('ask.chose', { choice: model }, 'en'))
           try {
-            if (cb.editMessage) await cb.editMessage(`✅ Модель успешно переключена на: <b>${provider}/${model}</b>`, REMOVE_KEYBOARD)
+            if (cb.editMessage) await cb.editMessage(t('model.switched', { provider, model }, 'en'), REMOVE_KEYBOARD)
           } catch {}
         } catch (err) {
-          await cb.answer(`Ошибка: ${err.message}`)
+          await cb.answer(`Error: ${err.message}`)
         }
         return
       }
@@ -512,9 +570,10 @@ export class Gateway {
       if (incomingPhotoOnly && photoOnlyMode === 'prompt') {
         chat.pendingMedia = [...(chat.pendingMedia || []), ...attachments]
         const n = chat.pendingMedia.length
+        const locale = this.resolveLocale(input)
         const msg = n === 1
-          ? 'Медиа получено. Напишите вопрос — например: «что на фото?»'
-          : `Получено ${n} вложений. Напишите вопрос.`
+          ? t('photo.received_one', {}, locale)
+          : t('photo.received_many', { count: n }, locale)
         return reply(msg)
       }
       if (chat.pendingMedia?.length) {
@@ -535,7 +594,7 @@ export class Gateway {
 
       // Hermes-like steer: while a turn is running, inject followup instead of abort+restart
       if (this.isChatBusy(chat)) {
-        const steerText = body || (hasMedia ? '(дополнение: медиа)' : '')
+        const steerText = body || (hasMedia ? '(steer: media)' : '')
         const content = await this.buildUserContent({
           ...turnInput,
           text: steerText,
@@ -546,7 +605,7 @@ export class Gateway {
           source: { kind: 'user', plugin: PLUGIN, form: 'steer', origin: 'telegram' },
         }))
         chat.lastUsed = Date.now()
-        try { await reply('↪️ Добавлено к текущему ответу') } catch {}
+        try { await reply(t('msg.steer_added', {}, this.resolveLocale(input))) } catch {}
         return
       }
 
@@ -573,103 +632,194 @@ export class Gateway {
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err)
       this.ctx.logger?.warn?.(`dsh-messenger-gateway: message: ${msg}`)
-      try { await reply(`Ошибка: ${msg}`) } catch {}
+      try { await reply(t('msg.exception', { message: msg }, this.resolveLocale(input))) } catch {}
     }
   }
 
   async handleCommand(key, text, input) {
-
     const parts = text.split(/\s+/)
     const cmd = parts[0].toLowerCase().split('@')[0]
     const { reply, userId, chatId, threadId = 0, platform } = input
-    if (cmd === '/start') return reply('Шлюз подключён. Пишите сообщение агенту. /help — команды.', { replyMarkup: REMOVE_REPLY_KEYBOARD })
+    const locale = this.resolveLocale(input)
+
+    if (cmd === '/start') {
+      return reply(t('msg.start', {}, locale), { replyMarkup: REMOVE_REPLY_KEYBOARD })
+    }
+
     if (cmd === '/help') {
       return reply([
-        '📖 <b>Команды бота:</b>',
+        '📖 <b>Messenger Gateway Help:</b>',
         '',
-        '💬 <b>Диалог:</b>',
-        '• /help — эта справка',
-        '• /new — новая сессия',
-        '• /stop — прервать текущий ответ',
-        '• /model — интерактивный выбор модели (/model list)',
-        '• /role [name] — персоны и роли агента (/role list)',
-        '• /rewind [N] — откат последних N ходов',
-        '• /fork — форк сессии в новую ветку',
-        '• /export — выгрузка истории в Markdown',
+        '💬 <b>Session & Chat:</b>',
+        '• /help — show this command reference',
+        '• /new — start fresh session',
+        '• /stop — interrupt current response',
+        '• /model — interactive model selector (/model list)',
+        '• /role [name] — switch persona or role (/role list)',
+        '• /bind [role] — bind persona to topic / chat',
+        '• /preset [name] — bind preset to topic / chat',
+        '• /lang [en|zh] — switch user language',
+        '• /rewind [N] — rewind last N turns',
+        '• /fork — fork session into new branch',
+        '• /export — export history to Markdown',
         '',
-        '🛠️ <b>Инструменты и файлы:</b>',
-        '• /skills / /tools — список активных инструментов',
-        '• /files [dir] — проводник рабочей папки',
-        '• /get <path> — скачать файл в Telegram',
-        '• /remind <время> <текст> — напоминание (/remind 10m текст)',
+        '🛠️ <b>Tools, Files & Cron:</b>',
+        '• /skills / /tools — list active tools & skills',
+        '• /files [dir] — workspace file explorer',
+        '• /get <path> — download file from workspace',
+        '• /remind <time> <text> — set reminder (/remind 10m check deploy)',
+        '• /cron <interval> <prompt> — recurring autonomous task',
         '',
-        '⚙️ <b>Настройки:</b>',
-        '• /status — статус шлюза и модели',
-        '• /top — системные ресурсы (RAM, uptime)',
-        '• /keyboard on|off — быстрые кнопки',
-        '• /voice on|off|status — голосовые ответы',
-        '• /tts on|off|status — озвучка в этом чате',
-        '• /mute / /unmute — заглушить уведомления в этот чат',
+        '⚙️ <b>Settings & Stats:</b>',
+        '• /status — gateway and active model status',
+        '• /top — system resource usage (RAM, uptime)',
+        '• /keyboard on|off — quick action keyboard',
+        '• /voice on|off|status — voice replies preference',
+        '• /tts on|off|status — speech synthesis in this chat',
+        '• /mute / /unmute — mute notifications in this chat',
         '',
-        '🔒 <b>Доступ и каналы:</b>',
-        '• /whoami — ваш Telegram id',
-        '• /pair CODE — одобрить код сопряжения',
-        '• /sethome [name] — привязать домашний чат',
-        '• /setalert — назначить канал алертов',
+        '🔒 <b>Access & Channels:</b>',
+        '• /whoami — your messenger user ID',
+        '• /pair CODE — approve pairing code',
+        '• /sethome [name] — set home notification channel',
+        '• /setalert — set alert channel',
       ].join('\n'))
     }
+
+    if (cmd === '/lang' || cmd === '/language') {
+      const sub = parts[1]?.toLowerCase()
+      if (sub === 'en' || sub === 'zh') {
+        this.chatLocales.set(chatId, sub)
+        return reply(sub === 'zh' ? '语言已切换为中文 (zh)' : 'Language switched to English (en)')
+      }
+      const cur = this.chatLocales.get(chatId) || this.config?.defaultLocale || 'en'
+      return reply(`Current language: <b>${cur}</b>\nSwitch: <code>/lang en</code> or <code>/lang zh</code>`)
+    }
+
+    if (cmd === '/bind') {
+      const targetRole = parts[1]?.toLowerCase()
+      if (!targetRole || targetRole === 'list') {
+        const cur = this.personas.getPersonaForChat(chatId, threadId)
+        return reply(`${t('persona.title', {}, locale)}\nCurrent bound role: <b>${cur}</b>\nUsage: <code>/bind &lt;role&gt;</code> (or /bind reset)`)
+      }
+      if (targetRole === 'reset' || targetRole === 'default') {
+        this.personas.set(chatId, 'default', threadId)
+        return reply(t('persona.reset', {}, locale))
+      }
+      const persona = getPersona(targetRole)
+      if (!persona) return reply(t('persona.unknown', { target: targetRole }, locale))
+      this.personas.set(chatId, targetRole, threadId)
+      return reply(t('persona.bound_topic', { kind: 'role', name: `${persona.icon} ${persona.name}` }, locale))
+    }
+
+    if (cmd === '/preset') {
+      const presetName = parts[1]
+      if (!presetName || presetName === 'list') {
+        const cur = this.personas.getPreset(chatId, threadId) || '(none)'
+        return reply(`🎭 <b>Presets:</b>\nCurrent topic preset: <code>${cur}</code>\nUsage: <code>/preset &lt;name&gt;</code> or <code>/preset reset</code>`)
+      }
+      if (presetName === 'reset' || presetName === 'clear') {
+        this.personas.setPreset(chatId, threadId, null)
+        return reply('Preset cleared for this topic.')
+      }
+      this.personas.setPreset(chatId, threadId, presetName)
+      return reply(t('persona.bound_topic', { kind: 'preset', name: presetName }, locale))
+    }
+
+    if (cmd === '/cron') {
+      const sub = parts[1]?.toLowerCase()
+      if (sub === 'list') {
+        const list = await this.scheduler.listRecurring(chatId)
+        if (!list.length) return reply(t('cron.none', {}, locale))
+        const lines = [t('cron.list_title', {}, locale)]
+        for (const task of list) {
+          const left = formatRemaining(task.dueAt - Date.now(), locale)
+          lines.push(`• <code>${task.id}</code> (every ${formatRemaining(task.intervalMs, locale)}, next in ${left}): ${task.prompt || task.text}`)
+        }
+        lines.push('\nCancel: <code>/cron cancel ID</code>')
+        return reply(lines.join('\n'))
+      }
+      if (sub === 'cancel') {
+        const targetId = parts[2]
+        if (!targetId) return reply('Specify cron task ID: <code>/cron cancel ID</code>')
+        const ok = await this.scheduler.cancel(targetId, chatId)
+        return reply(ok ? t('cron.cancelled', { id: targetId }, locale) : `Task not found: <code>${targetId}</code>`)
+      }
+      const specArg = parts[1]
+      const promptArg = parts.slice(2).join(' ')
+      const ms = parseRelativeTime(specArg)
+      if (!ms || !promptArg) {
+        return reply('⏱️ <b>Autonomous Cron Tasks:</b>\nCreate: <code>/cron &lt;interval&gt; &lt;prompt&gt;</code>\nExample: <code>/cron 1h check server logs</code>\nList: <code>/cron list</code>\nCancel: <code>/cron cancel ID</code>')
+      }
+      const task = await this.scheduler.schedule({
+        platform,
+        chatId,
+        threadId,
+        userId,
+        text: promptArg,
+        prompt: promptArg,
+        dueAt: Date.now() + ms,
+        recurring: true,
+        intervalMs: ms,
+      })
+      return reply(t('cron.scheduled', { id: task.id, schedule: specArg, prompt: promptArg }, locale))
+    }
+
     if (cmd === '/role' || cmd === '/persona') {
       const targetRole = parts[1]?.toLowerCase()
       if (!targetRole || targetRole === 'list') {
-        const currentId = this.personas.get(chatId)
+        const currentId = this.personas.getPersonaForChat(chatId, threadId)
         const lines = [
-          '🎭 <b>Доступные роли и персоны:</b>',
+          t('persona.title', {}, locale),
           '',
           ...listPersonas().map((p) => {
-            const isCurrent = p.id === currentId ? ' (активна)' : ''
+            const isCurrent = p.id === currentId ? ' (active)' : ''
             return `${p.icon} <b>${p.id}</b> — ${p.name}: ${p.description}${isCurrent}`
           }),
           '',
-          'Смена роли: <code>/role coder</code> (или /role reset)',
+          t('persona.usage', {}, locale),
         ]
         return reply(lines.join('\n'))
       }
       if (targetRole === 'reset' || targetRole === 'default') {
-        this.personas.set(chatId, 'default')
-        return reply('🎭 Роль сброшена на стандартную (Default).')
+        this.personas.set(chatId, 'default', threadId)
+        return reply(t('persona.reset', {}, locale))
       }
       const persona = getPersona(targetRole)
       if (!persona) {
-        return reply(`Неизвестная роль "${targetRole}". Список: /role list`)
+        return reply(t('persona.unknown', { target: targetRole }, locale))
       }
-      this.personas.set(chatId, persona.id)
-      return reply(`🎭 Роль изменена на: ${persona.icon} <b>${persona.name}</b>\n${persona.description}`)
+      this.personas.set(chatId, persona.id, threadId)
+      return reply(t('persona.switched', { icon: persona.icon, name: persona.name, description: persona.description }, locale))
     }
+
     if (cmd === '/skills' || cmd === '/tools') {
       const tools = this.ctx.get?.('tools') || this.ctx.tools
+      const toolsList = []
       if (tools?.tools) {
-        for (const [name, t] of tools.tools.entries()) {
-          toolsList.push(`• <b>${name}</b>: ${t.description || '(нет описания)'}`)
+        for (const [name, tDef] of tools.tools.entries()) {
+          toolsList.push(`• <b>${name}</b>: ${tDef.description || '(no description)'}`)
         }
       }
       if (!toolsList.length) {
-        return reply('🛠️ <b>Инструменты агента:</b>\n(нет зарегистрированных инструментов)')
+        return reply('🛠️ <b>Agent Tools:</b>\n(no tools registered)')
       }
       return reply([
-        '🛠️ <b>Активные инструменты и скиллы:</b>',
+        '🛠️ <b>Active Tools & Skills:</b>',
         '',
         ...toolsList,
       ].join('\n'))
     }
+
     if (cmd === '/export') {
       const chat = this.chats.get(key)
       if (!chat?.agent?.session) {
-        return reply('Нет активной сессии для экспорта.')
+        return reply(t('msg.no_active_session', {}, locale))
       }
       try {
         const { filename, buffer, messagesCount } = exportSessionToMarkdown(chat.agent.session)
         if (!messagesCount) {
-          return reply('Сессия пуста, нет сообщений для экспорта.')
+          return reply(t('export.empty', {}, locale))
         }
         const file = {
           name: filename,
@@ -677,29 +827,31 @@ export class Gateway {
           kind: 'document',
           bytes: buffer,
         }
-        return reply({ text: `📄 Экспорт диалога (${messagesCount} сообщений):`, files: [file] })
+        return reply({ text: t('export.title', { count: messagesCount }, locale), files: [file] })
       } catch (err) {
-        return reply(`Ошибка экспорта: ${err.message}`)
+        return reply(`Export error: ${err.message}`)
       }
     }
+
     if (cmd === '/rewind') {
       const chat = this.chats.get(key)
       if (!chat?.agent?.session) {
-        return reply('Нет активной сессии для отката.')
+        return reply(t('msg.no_active_session', {}, locale))
       }
       const count = Number(parts[1]) || 1
       const res = rewindSession(chat.agent.session, count)
       if (!res.removed) {
-        return reply('В истории сессии нет сообщений для отката.')
+        return reply('No turns to rewind in session history.')
       }
       const sessions = this.ctx.get?.('sessions') || this.ctx.sessions
       try { await sessions?.flush(chat.agent.session) } catch {}
-      return reply(`⏪ Откачено сообщений: ${res.removed}. Осталось в контексте: ${res.remaining}.`)
+      return reply(`⏪ Rewound ${res.removed} messages. Remaining in context: ${res.remaining}.`)
     }
+
     if (cmd === '/fork') {
       const chat = this.chats.get(key)
       if (!chat?.agent?.session) {
-        return reply('Нет активной сессии для форка.')
+        return reply(t('msg.no_active_session', {}, locale))
       }
       try {
         const oldSession = chat.agent.session
@@ -713,11 +865,12 @@ export class Gateway {
           try { await sessions?.flush(newChat.agent.session) } catch {}
         }
         this.chats.set(key, newChat)
-        return reply(`🔀 Создан форк сессии!\nСтарая сессия: ${oldSession.id}\nНовая активная сессия: ${newChat.agent.session.id}\nКонтекст сохранён (${oldMessages.length} сообщений).`)
+        return reply(`🔀 Forked session!\nOld session: ${oldSession.id}\nNew session: ${newChat.agent.session.id}\nContext preserved (${oldMessages.length} messages).`)
       } catch (err) {
-        return reply(`Ошибка форка: ${err.message}`)
+        return reply(`Fork error: ${err.message}`)
       }
     }
+
     if (cmd === '/files') {
       const subPath = parts.slice(1).join(' ').trim() || '.'
       const agentCwd = this.config.agent?.cwd || process.cwd()
@@ -725,10 +878,11 @@ export class Gateway {
       if (!res.ok) return reply(`❌ ${res.error}`)
       return reply(res.formattedText)
     }
+
     if (cmd === '/get') {
       const targetRel = parts.slice(1).join(' ').trim()
       if (!targetRel) {
-        return reply('Укажите имя файла для скачивания: <code>/get <файл></code>\nСписок: <code>/files</code>')
+        return reply('Specify file path to download: <code>/get &lt;path&gt;</code>\nBrowse: <code>/files</code>')
       }
       const agentCwd = this.config.agent?.cwd || process.cwd()
       const maxDocBytes = Number(this.config.media?.maxDocBytes) || 50 * 1024 * 1024
@@ -741,8 +895,9 @@ export class Gateway {
         bytes: res.bytes,
         dataBase64: res.bytes.toString('base64'),
       }
-      return reply({ text: `📄 Файл: <b>${res.name}</b> (${formatFileSize(res.size)})`, files: [file] })
+      return reply({ text: `📄 File: <b>${res.name}</b> (${formatFileSize(res.size)})`, files: [file] })
     }
+
     if (cmd === '/new') {
       const chat = this.chats.get(key)
       if (chat) {
@@ -751,38 +906,41 @@ export class Gateway {
         this.sessionToChat.delete(String(chat.agent.session.id))
         this.chats.delete(key)
         await chat.dispose()
-        return reply('Сессия сброшена.')
+        return reply('Session reset.')
       }
-      return reply('Активной сессии нет.')
+      return reply(t('msg.no_active_session', {}, locale))
     }
+
     if (cmd === '/whoami') {
-      const lines = [`Ваш id: ${userId}`]
+      const lines = [`User ID: ${userId}`]
       if (chatId) lines.push(`chatId: ${chatId}`)
       if (threadId) lines.push(`threadId: ${threadId}`)
       return reply(lines.join('\n'))
     }
+
     if (cmd === '/stop') {
       const chat = this.chats.get(key)
       if (chat?.turnActive || chat?.abort) {
         try { chat.abort?.abort() } catch {}
         releaseChatTurn(chat)
         chat.turnActive = false
-        return reply('Прерывание отправлено.')
+        return reply(t('msg.turn_stopped', {}, locale))
       }
-      return reply('Нечего прерывать.')
+      return reply('Nothing to stop.')
     }
+
     if (cmd === '/status') {
-      let modelLine = 'модель: (не задана)'
+      let modelLine = 'model: (not set)'
       try {
         const sel = this.resolveAgentModel()
-        modelLine = `модель: ${sel.provider}/${sel.model}`
+        modelLine = `model: ${sel.provider}/${sel.model}`
       } catch (e) {
-        modelLine = `модель: ${e.message}`
+        modelLine = `model: ${e.message}`
       }
       const home = this.resolveHomeTarget(platform || 'telegram')
       const homeLine = home
         ? `home: chat ${home.chatId}${home.threadId ? ` topic ${home.threadId}` : ''}`
-        : 'home: не задан'
+        : 'home: (not set)'
       const pending = this.pairing.listPending().length
       const up = Math.max(0, Math.round((Date.now() - this.stats.startedAt) / 1000))
       const hh = String(Math.floor(up / 3600)).padStart(2, '0')
@@ -790,22 +948,23 @@ export class Gateway {
       const ss = String(up % 60).padStart(2, '0')
       return reply([
         'Messenger gateway',
-        `адаптеры: ${[...this.adapters.keys()].join(', ') || '(нет)'}`,
-        `активных чатов: ${this.chats.size}`,
+        `adapters: ${[...this.adapters.keys()].join(', ') || '(none)'}`,
+        `active chats: ${this.chats.size}`,
         modelLine,
         homeLine,
         `pairing pending: ${pending}`,
         `transport: ${this.tg().transport || 'poll'}`,
         `sessionScope: ${this.config.agent?.sessionScope || 'user'}`,
-        `доставлено: ${this.stats.sent}`,
-        `ошибок: ${this.stats.errors}`,
-        `polling conflict: ${this.tgAdapter?.pollingConflict ? 'да' : 'нет'}`,
+        `delivered: ${this.stats.sent}`,
+        `errors: ${this.stats.errors}`,
+        `polling conflict: ${this.tgAdapter?.pollingConflict ? 'yes' : 'no'}`,
         `uptime: ${hh}:${mm}:${ss}`,
       ].join('\n'))
     }
+
     if (cmd === '/model') {
       if (parts.length >= 3) {
-        if (!this.isUserAllowed(userId)) return reply('Нет доступа.')
+        if (!this.isUserAllowed(userId)) return reply(t('msg.not_allowed', {}, locale))
         const provider = parts[1]
         const model = parts.slice(2).join(' ')
         try {
@@ -819,21 +978,21 @@ export class Gateway {
           } catch (e) {
             this.ctx.logger?.warn?.(`persist agent model: ${e.message}`)
           }
-          return reply(`Модель сохранена: ${provider}/${model}`)
+          return reply(t('model.switched', { provider, model }, locale))
         } catch (e) {
-          return reply(`Не удалось сменить модель: ${e.message}`)
+          return reply(`Failed to switch model: ${e.message}`)
         }
       }
       try {
         const current = this.resolveAgentModel()
         const catalog = await listModelCatalog(this.ctx, current)
         if (!catalog.providers.length) {
-          return reply(`Текущая модель: <code>${current.provider}/${current.model}</code>\nСмена: <code>/model &lt;provider&gt; &lt;model&gt;</code>`)
+          return reply(`Current model: <code>${current.provider}/${current.model}</code>\nSwitch: <code>/model &lt;provider&gt; &lt;model&gt;</code>`)
         }
         const kb = buildProvidersKeyboard(catalog.providers, current)
         return reply([
-          '🤖 <b>Выберите провайдера:</b>',
-          `Текущая модель: <code>${current.provider}/${current.model}</code>`,
+          t('model.title', {}, locale),
+          t('model.current', { current: `${current.provider}/${current.model}` }, locale),
         ].join('\n'), {
           replyMarkup: kb,
         })
@@ -841,38 +1000,42 @@ export class Gateway {
         return reply(e.message)
       }
     }
+
     if (cmd === '/pair') {
-      if (!this.isUserAllowed(userId)) return reply('Только пользователи из allowlist могут одобрять /pair.')
+      if (!this.isUserAllowed(userId)) return reply('Only users in allowlist can approve /pair.')
       const code = parts[1]
-      if (!code) return reply('Использование: /pair CODE')
+      if (!code) return reply('Usage: /pair CODE')
       const res = this.pairing.approveCode(code, userId)
-      if (!res.ok) return reply(`Не удалось: ${res.error}`)
+      if (!res.ok) return reply(`Failed: ${res.error}`)
       const merged = this.effectiveAllowedIds()
       for (const a of this.adapterList) a.setAllowedUserIds?.(merged)
       try { await this.hooks?.persistAllowedUserIds?.(merged) } catch (e) {
         this.ctx.logger?.warn?.(`persist allowlist: ${e.message}`)
       }
-      return reply(`Одобрен user id ${res.userId}${res.username ? ` (@${res.username})` : ''}.`)
+      return reply(`Approved user ID ${res.userId}${res.username ? ` (@${res.username})` : ''}.`)
     }
+
     if (cmd === '/sethome') {
-      if (!this.isUserAllowed(userId)) return reply('Нет доступа.')
+      if (!this.isUserAllowed(userId)) return reply(t('msg.not_allowed', {}, locale))
       const name = normalizeHomeName(parts[1] || 'default') || 'default'
       try {
         const nextTg = upsertHome(this.tg(), { name, chatId, threadId })
         await this.hooks?.persistHomes?.(nextTg)
         this.config.telegram = nextTg
-        return reply(`Home «${name}»: chat ${chatId}${threadId ? ` topic ${threadId}` : ''}`)
+        return reply(`Home "${name}": chat ${chatId}${threadId ? ` topic ${threadId}` : ''}`)
       } catch (e) {
-        return reply(`Не удалось сохранить home: ${e.message}`)
+        return reply(`Failed to save home: ${e.message}`)
       }
     }
+
     if (cmd === '/home') {
       const homes = listHomes(this.tg())
-      if (!homes.length) return reply('Home не задан. /sethome или /sethome name')
+      if (!homes.length) return reply('Home is not set. /sethome or /sethome <name>')
       return reply(['Homes:', ...homes.map((h) => `• ${h.name}: chat ${h.chatId}${h.threadId ? ` topic ${h.threadId}` : ''}`)].join('\n'))
     }
+
     if (cmd === '/setalert') {
-      if (!this.isUserAllowed(userId)) return reply('Нет доступа.')
+      if (!this.isUserAllowed(userId)) return reply(t('msg.not_allowed', {}, locale))
       const nextTg = {
         ...this.tg(),
         alerts: {
@@ -884,62 +1047,64 @@ export class Gateway {
       }
       this.config.telegram = nextTg
       try { await this.hooks?.persistHomes?.(nextTg) } catch {}
-      return reply(`🔔 Этот чат назначен каналом алертов (chat: ${chatId}${threadId ? `, topic: ${threadId}` : ''}).`)
+      return reply(`🔔 This chat assigned as alert channel (chat: ${chatId}${threadId ? `, topic: ${threadId}` : ''}).`)
     }
+
     if (cmd === '/alert') {
       const sub = parts[1]?.toLowerCase()
       if (sub === 'test') {
         const target = resolveAlertTarget(this)
-        if (!target) return reply('Канал алертов не настроен или выключен. Назначить: /setalert')
-        await this.sendAlert('status', { title: 'Тестовый алерт', details: `Отправлен пользователем id ${userId}` })
-        return reply('Тестовый алерт отправлен в канал алертов.')
+        if (!target) return reply('Alert channel not configured. Configure: /setalert')
+        await this.sendAlert('status', { title: 'Test Alert', details: `Sent by user ID ${userId}` })
+        return reply('Test alert sent to alert channel.')
       }
       const target = resolveAlertTarget(this)
       const alertsCfg = this.tg().alerts || {}
       return reply([
-        '🔔 <b>Канал алертов:</b>',
-        `Статус: ${alertsCfg.enabled ? 'включен' : 'выключен'}`,
-        `Чат: ${target ? `${target.chatId}${target.threadId ? ` (topic: ${target.threadId})` : ''}` : '(не назначен)'}`,
-        `События: ${(alertsCfg.events || ['error', 'pairing']).join(', ')}`,
+        '🔔 <b>Alert Channel:</b>',
+        `Status: ${alertsCfg.enabled ? 'enabled' : 'disabled'}`,
+        `Chat: ${target ? `${target.chatId}${target.threadId ? ` (topic: ${target.threadId})` : ''}` : '(not assigned)'}`,
+        `Events: ${(alertsCfg.events || ['error', 'pairing']).join(', ')}`,
         '',
-        'Команды:',
-        '/setalert — назначить текущий чат каналом алертов',
-        '/alert test — отправить тестовый алерт',
+        'Commands:',
+        '/setalert — assign current chat as alert channel',
+        '/alert test — send test alert',
       ].join('\n'))
     }
+
     if (cmd === '/remind') {
       const sub = parts[1]?.toLowerCase()
       if (sub === 'list') {
         const active = await this.scheduler.list(chatId)
-        if (!active.length) return reply('Нет активных напоминаний для этого чата.')
+        if (!active.length) return reply('No active reminders for this chat.')
         const lines = [
-          '⏰ <b>Активные напоминания:</b>',
+          '⏰ <b>Active Reminders:</b>',
           '',
-          ...active.map((t) => {
-            const left = formatRemaining(t.dueAt - Date.now())
-            return `• <code>${t.id}</code> (через ${left}): ${t.text}`
+          ...active.map((tItem) => {
+            const left = formatRemaining(tItem.dueAt - Date.now(), locale)
+            return `• <code>${tItem.id}</code> (in ${left}): ${tItem.text}`
           }),
           '',
-          'Отмена: <code>/remind cancel ID</code>',
+          'Cancel: <code>/remind cancel ID</code>',
         ]
         return reply(lines.join('\n'))
       }
       if (sub === 'cancel') {
         const targetId = parts[2]?.trim()
-        if (!targetId) return reply('Укажите ID напоминания: <code>/remind cancel ID</code>')
+        if (!targetId) return reply('Specify reminder ID: <code>/remind cancel ID</code>')
         const ok = await this.scheduler.cancel(targetId, chatId)
-        return reply(ok ? `✅ Напоминание <code>${targetId}</code> отменено.` : `❌ Напоминание с ID <code>${targetId}</code> не найдено.`)
+        return reply(ok ? `✅ Reminder <code>${targetId}</code> cancelled.` : `❌ Reminder <code>${targetId}</code> not found.`)
       }
       const timeArg = parts[1]
       const textArg = parts.slice(2).join(' ').trim()
       const delayMs = parseRelativeTime(timeArg)
       if (!delayMs || !textArg) {
         return reply([
-          '⏰ <b>Напоминания:</b>',
-          'Создать: <code>/remind &lt;время&gt; &lt;текст&gt;</code>',
-          'Примеры: <code>/remind 10m Позвонить</code>, <code>/remind 2h Проверить деплой</code>',
-          'Список: <code>/remind list</code>',
-          'Отмена: <code>/remind cancel ID</code>',
+          '⏰ <b>Reminders:</b>',
+          'Create: <code>/remind &lt;time&gt; &lt;text&gt;</code>',
+          'Examples: <code>/remind 10m Call colleague</code>, <code>/remind 2h Check deploy</code>',
+          'List: <code>/remind list</code>',
+          'Cancel: <code>/remind cancel ID</code>',
         ].join('\n'))
       }
       const dueAt = Date.now() + delayMs
@@ -951,9 +1116,10 @@ export class Gateway {
         text: textArg,
         dueAt,
       })
-      const left = formatRemaining(delayMs)
-      return reply(`⏰ Напоминание установлено на <b>через ${left}</b> (ID: <code>${task.id}</code>):\n«${textArg}»`)
+      const left = formatRemaining(delayMs, locale)
+      return reply(t('remind.scheduled', { time: new Date(dueAt).toLocaleTimeString(), duration: left, text: textArg }, locale))
     }
+
     if (cmd === '/voice') {
       const sub = String(parts[1] || 'status').toLowerCase()
       if (sub === 'summary') {
@@ -961,44 +1127,46 @@ export class Gateway {
         if (val === 'on' || val === 'off') {
           if (!this.config.tts) this.config.tts = {}
           this.config.tts.voiceSummary = val === 'on'
-          return reply(`Голосовое саммари (TL;DR): ${val === 'on' ? 'включено' : 'выключено'}`)
+          return reply(`Voice summary (TL;DR): ${val === 'on' ? 'enabled' : 'disabled'}`)
         }
         const state = this.config.tts?.voiceSummary ? 'on' : 'off'
-        return reply(`Голосовое саммари (TL;DR): ${state}\nПереключение: <code>/voice summary on|off</code>`)
+        return reply(`Voice summary (TL;DR): ${state}\nToggle: <code>/voice summary on|off</code>`)
       }
       if (sub === 'on' || sub === 'off') {
         this.voicePrefs.set(userId, sub === 'on')
-        return reply(sub === 'on' ? 'Голосовые ответы: on (для вас)' : 'Голосовые ответы: off (для вас)')
+        return reply(sub === 'on' ? 'Voice replies: on (for you)' : 'Voice replies: off (for you)')
       }
       const pref = this.voicePrefs.get(userId)
       const mode = this.tg().voiceMode || 'mirror'
-      const prefLine = pref === null ? 'не задан (/voice on|off)' : (pref ? 'on' : 'off')
+      const prefLine = pref === null ? 'not set (/voice on|off)' : (pref ? 'on' : 'off')
       const summaryState = this.config.tts?.voiceSummary ? 'on' : 'off'
-      return reply(`voiceMode=${mode}\nваш /voice: ${prefLine}\nglobal tts: ${this.config.tts?.enabled ? 'on' : 'off'}\nvoice summary: ${summaryState}`)
+      return reply(`voiceMode=${mode}\nyour /voice: ${prefLine}\nglobal tts: ${this.config.tts?.enabled ? 'on' : 'off'}\nvoice summary: ${summaryState}`)
     }
+
     if (cmd === '/topic') {
       const topicName = parts.slice(1).join(' ').trim()
       if (!topicName) {
-        return reply('Использование: <code>/topic &lt;название&gt;</code>\nСоздает новый топик в супергруппе и изолированную сессию под задачу.')
+        return reply('Usage: <code>/topic &lt;name&gt;</code>\nCreates a new topic in supergroup with an isolated session.')
       }
       const tgAdapter = this.getAdapter('telegram')
       if (!tgAdapter?.createForumTopic) {
-        return reply('Создание топиков доступно только в Telegram.')
+        return reply('Topic creation is available only in Telegram.')
       }
       try {
         const res = await tgAdapter.createForumTopic(chatId, topicName)
         const newThreadId = res?.message_thread_id
-        await reply(`🎯 Создан новый топик <b>«${topicName}»</b> (ID: <code>${newThreadId}</code>).\nПерейдите в созданный топик для работы над задачей!`)
+        await reply(`🎯 Created new topic <b>«${topicName}»</b> (ID: <code>${newThreadId}</code>).\nSwitch to the topic to continue working!`)
         if (newThreadId) {
           await tgAdapter.sendTo(chatId, {
-            text: `👋 Привет! Это изолированная сессия для задачи <b>«${topicName}»</b>.\nЧем могу помочь?`,
+            text: `👋 Hello! This is an isolated session for task <b>«${topicName}»</b>.\nHow can I help?`,
           }, { threadId: newThreadId })
         }
         return
       } catch (err) {
-        return reply(`Не удалось создать топик: ${err.message}\n(Убедитесь, что бот является администратором группы и включены темы/форумы)`)
+        return reply(`Failed to create topic: ${err.message}\n(Ensure the bot is group administrator with Manage Topics permission)`)
       }
     }
+
     if (cmd === '/top') {
       const mem = process.memoryUsage()
       const rssMb = (mem.rss / 1024 / 1024).toFixed(1)
@@ -1009,7 +1177,7 @@ export class Gateway {
       const ss = String(sec % 60).padStart(2, '0')
       let activeReminders = 0
       try { activeReminders = (await this.scheduler.list()).length } catch {}
-      let currentModel = 'не задана'
+      let currentModel = 'not set'
       try {
         const m = this.resolveAgentModel()
         currentModel = `${m.provider}/${m.model}`
@@ -1017,60 +1185,65 @@ export class Gateway {
 
       return reply([
         '📊 <b>DSH System & Resources:</b>',
-        `• <b>Память (RSS):</b> ${rssMb} MB`,
+        `• <b>Memory (RSS):</b> ${rssMb} MB`,
         `• <b>Heap:</b> ${heapMb} MB`,
-        `• <b>Аптайм:</b> ${hh}:${mm}:${ss}`,
-        `• <b>Активных чатов:</b> ${this.chats.size}`,
-        `• <b>Напоминаний в очереди:</b> ${activeReminders}`,
-        `• <b>Активная модель:</b> <code>${currentModel}</code>`,
-        `• <b>Сообщений отправлено:</b> ${this.stats.sent}`,
-        `• <b>Ошибок:</b> ${this.stats.errors}`,
+        `• <b>Uptime:</b> ${hh}:${mm}:${ss}`,
+        `• <b>Active chats:</b> ${this.chats.size}`,
+        `• <b>Queued reminders:</b> ${activeReminders}`,
+        `• <b>Active model:</b> <code>${currentModel}</code>`,
+        `• <b>Messages sent:</b> ${this.stats.sent}`,
+        `• <b>Errors:</b> ${this.stats.errors}`,
       ].join('\n'))
     }
+
     if (cmd === '/keyboard') {
       const sub = String(parts[1] || '').toLowerCase()
       const tgAdapter = this.getAdapter('telegram')
       if (sub === 'on') {
         if (tgAdapter) tgAdapter.quickActions = true
-        return reply('Клавиатура быстрых действий включена.', {
+        return reply('Quick action keyboard enabled.', {
           replyMarkup: buildQuickActionsKeyboard(),
         })
       }
       if (sub === 'off') {
         if (tgAdapter) tgAdapter.quickActions = false
-        return reply('Клавиатура быстрых действий выключена.', {
+        return reply('Quick action keyboard disabled.', {
           replyMarkup: REMOVE_REPLY_KEYBOARD,
         })
       }
-      const curState = tgAdapter?.quickActions ? 'включена' : 'выключена'
+      const curState = tgAdapter?.quickActions ? 'enabled' : 'disabled'
       return reply([
-        '⌨️ <b>Клавиатура быстрых действий:</b>',
-        `Текущее состояние: <b>${curState}</b>`,
+        '⌨️ <b>Quick Action Keyboard:</b>',
+        `Current state: <b>${curState}</b>`,
         '',
-        'Команды:',
-        '<code>/keyboard on</code> — показать кнопки',
-        '<code>/keyboard off</code> — скрыть кнопки',
+        'Commands:',
+        '<code>/keyboard on</code> — show buttons',
+        '<code>/keyboard off</code> — hide buttons',
       ].join('\n'))
     }
+
     if (cmd === '/tts') {
       const sub = String(parts[1] || 'status').toLowerCase()
       if (sub === 'on' || sub === 'off') {
         this.chatTts.set(chatId, sub === 'on')
-        return reply(sub === 'on' ? 'Озвучка в этом чате: on' : 'Озвучка в этом чате: off')
+        return reply(sub === 'on' ? 'Speech in this chat: on' : 'Speech in this chat: off')
       }
       const cur = this.chatTts.get(chatId)
-      const line = cur === null ? 'не задан (/tts on|off)' : (cur ? 'on' : 'off')
-      return reply(`Озвучка в этом чате: ${line}\nglobal tts: ${this.config.tts?.enabled ? 'on' : 'off'}`)
+      const line = cur === null ? 'not set (/tts on|off)' : (cur ? 'on' : 'off')
+      return reply(`Speech in this chat: ${line}\nglobal tts: ${this.config.tts?.enabled ? 'on' : 'off'}`)
     }
+
     if (cmd === '/mute') {
       this.setMuted(chatId, true)
-      return reply('Уведомления в этот чат: выключены (/unmute)')
+      return reply(t('msg.muted_on', {}, locale))
     }
+
     if (cmd === '/unmute') {
       this.setMuted(chatId, false)
-      return reply('Уведомления в этот чат: включены')
+      return reply(t('msg.muted_off', {}, locale))
     }
-    return reply(`Неизвестная команда ${cmd}. /help`)
+
+    return reply(t('msg.unknown_command', { cmd }, locale))
   }
 
   collectDynamicSkills() {
@@ -1130,7 +1303,7 @@ export class Gateway {
       this.sessionToThread.set(sessionId, { chatId: forumChatId, threadId })
       this.threadToSession.set(threadKey, sessionId)
 
-      const text = `🪞 <b>[Зеркало сессии DSH]</b>\nСессия: <code>${sessionId}</code>\nЗаголовок: <b>${title}</b>\nСообщения из этой темы будут направляться в диалог DSH.`
+      const text = t('mirror.created', { sessionId, title }, 'en')
       await tgAdapter.sendTo(forumChatId, { text }, { threadId })
       this.ctx.logger?.info?.(`Mirrored session ${sessionId} to Telegram forum topic ${threadId} in ${forumChatId}`)
     } catch (err) {
@@ -1197,7 +1370,7 @@ export class Gateway {
     if (provider && model) return { provider, model }
     const selection = this.ctx.get('agentDefaultModel')?.currentSelection?.()
     if (!selection?.provider || !selection?.model) {
-      throw new Error('Выберите модель в Settings → Models (или укажите agent.provider/model в профиле)')
+      throw new Error('Please select a model in Settings -> Models (or set agent.provider/model in profile)')
     }
     return { provider: provider || selection.provider, model: model || selection.model }
   }
@@ -1224,6 +1397,7 @@ export class Gateway {
     const chat = {
       key, agent: handle.agent, dispose: handle.dispose, busy: Promise.resolve(),
       lastUsed: Date.now(), abort: undefined, pendingMedia: [], turnActive: false,
+      sessionAllowlist: new Set(),
       target: input ? { platform: input.platform, chatId: input.chatId, threadId: input.threadId || 0 } : undefined,
     }
     this.sessionToChat.set(String(handle.agent.session.id), key)
@@ -1240,12 +1414,33 @@ export class Gateway {
       const chat = this.chats.get(chatKeyValue)
       if (!chat?.target) return next()
       const tool = req.toolName || 'tool'
-      const reason = req.reason ? `\n${req.reason}` : ''
-      const result = await this.messengerAsk(chat.target, {
-        text: `⚠️ Нужно подтверждение\nИнструмент: ${tool}${reason}`,
-        buttons: [[{ id: 'allow', text: '✅ Разрешить' }, { id: 'deny', text: '❌ Отклонить' }]],
-      }, 300_000)
-      if (result?.buttonId === 'allow') return 'allowed-once'
+      if (chat.sessionAllowlist?.has(tool)) {
+        return 'allowed-once'
+      }
+      const locale = this.resolveLocale(chat.target)
+      const reason = req.reason ? `\n<i>${req.reason}</i>` : ''
+      let detail = ''
+      if (req.input && typeof req.input === 'object') {
+        try {
+          const jsonStr = JSON.stringify(req.input, null, 2)
+          detail = `\n<pre><code>${jsonStr.slice(0, 500)}</code></pre>`
+        } catch {}
+      }
+      const text = t('ask.confirm_title', { tool, reason: reason + detail }, locale)
+      const buttons = [
+        [
+          { id: 'allow_once', text: t('ask.allow_once', {}, locale) },
+          { id: 'allow_session', text: t('ask.allow_session', {}, locale) },
+          { id: 'deny', text: t('ask.deny', {}, locale) },
+        ],
+      ]
+      const result = await this.messengerAsk(chat.target, { text, buttons }, 300_000)
+      if (result?.buttonId === 'allow_once' || result?.buttonId === 'allow') return 'allowed-once'
+      if (result?.buttonId === 'allow_session') {
+        if (!chat.sessionAllowlist) chat.sessionAllowlist = new Set()
+        chat.sessionAllowlist.add(tool)
+        return 'allowed-once'
+      }
       if (result?.buttonId === 'deny') return 'rejected'
       return next()
     } catch {
@@ -1257,13 +1452,13 @@ export class Gateway {
     const { text, attachments = [], replyText, steer, personaOverride } = input
     const parts = []
     parts.push(String(this.config.agent?.instructionPrefix || MESSENGER_RELAY_INSTRUCTION))
-    const activePersonaId = personaOverride || this.personas.get(input.chatId)
+    const activePersonaId = personaOverride || this.personas.getPersonaForChat(input.chatId, input.threadId)
     const activePersona = getPersona(activePersonaId)
     if (activePersona?.instruction) {
       parts.push(`[Persona: ${activePersona.name} (${activePersona.icon})]\n${activePersona.instruction}`)
     }
-    if (steer) parts.push('[Steer / дополнение к текущему ходу — учти вместе с предыдущим запросом, не начинай ответ заново с нуля]')
-    if (replyText?.trim()) parts.push(`[Ответ на сообщение: ${replyText.trim()}]`)
+    if (steer) parts.push('[Steer / addition to current turn: combine with previous instruction, do not restart from scratch]')
+    if (replyText?.trim()) parts.push(`[Replying to message: ${replyText.trim()}]`)
     const blocks = []
     for (const att of attachments) {
       if (att.kind === 'photo' || (att.kind === 'sticker' && att.mime?.startsWith('image/'))) {
@@ -1273,22 +1468,22 @@ export class Gateway {
             maxBytes: Number(this.config.media?.maxImageBytes) || 20 * 1024 * 1024,
           })
           blocks.push({ type: 'image', attachment: ref })
-          if (att.kind === 'sticker' && att.emoji) parts.push(`[Стикер ${att.emoji}]`)
+          if (att.kind === 'sticker' && att.emoji) parts.push(`[Sticker ${att.emoji}]`)
         } catch (err) {
           if (signal?.aborted) throw err
           const msg = err instanceof Error ? err.message : String(err)
-          parts.push(`[Не удалось приложить изображение: ${msg}]`)
+          parts.push(`[Failed to attach image: ${msg}]`)
         }
       } else if (att.kind === 'voice' || att.kind === 'audio') {
         try {
           const bytes = new Uint8Array(await readFile(att.path))
           const transcript = await transcribeVoice(this.baseUrl(), bytes, att.mime || 'audio/ogg', 'message', signal)
-          parts.push(transcript ? `[Голосовое сообщение, расшифровка: ${transcript}]` : '[Голосовое сообщение (не удалось распознать)]')
+          parts.push(transcript ? `[Voice message transcript: ${transcript}]` : '[Voice message (unrecognized)]')
         } catch (err) {
           if (signal?.aborted) throw err
           const msg = err instanceof Error ? err.message : String(err)
           this.ctx.logger?.warn?.(`voice: ${msg}`)
-          parts.push(`[Голосовое сообщение (dsh-voice недоступен: ${msg})]`)
+          parts.push(`[Voice message (dsh-voice unavailable: ${msg})]`)
         }
       } else if (att.kind === 'document' || att.kind === 'video' || att.kind === 'animation' || att.kind === 'sticker') {
         let parsed = null
@@ -1300,7 +1495,7 @@ export class Gateway {
         }
         parts.push(formatInboundDocument(att, parsed))
       } else {
-        parts.push(`[Файл: ${att.path}${att.name ? ` (${att.name})` : ''}]`)
+        parts.push(`[File: ${att.path}${att.name ? ` (${att.name})` : ''}]`)
       }
     }
     const photoHint = photoOnlyHint(attachments, text)
@@ -1310,7 +1505,7 @@ export class Gateway {
     if (text?.trim()) parts.push(text.trim())
     const textBlock = parts.filter(Boolean).join('\n\n')
     if (textBlock) blocks.unshift({ type: 'text', text: textBlock })
-    if (!blocks.length) blocks.push({ type: 'text', text: '(пустое сообщение)' })
+    if (!blocks.length) blocks.push({ type: 'text', text: '(empty message)' })
     return blocks
   }
 
@@ -1371,8 +1566,9 @@ export class Gateway {
       if (signal.aborted) {
         if (progress) try { await progress.remove() } catch {}
         if (typeof react === 'function') react('').catch?.(() => {})
-        if (stream) try { await stream.finalize('Прервано.') } catch {}
-        else return reply('Прервано.')
+        const stoppedMsg = t('msg.turn_stopped', {}, this.resolveLocale(input))
+        if (stream) try { await stream.finalize(stoppedMsg) } catch {}
+        else return reply(stoppedMsg)
         return
       }
       const sessions = this.ctx.get?.('sessions') || this.ctx.sessions
@@ -1387,7 +1583,7 @@ export class Gateway {
       const answer = processed.text
       if (collector.reason?.kind === 'error') {
         const err = collector.reason.error
-        const msg = `Ошибка агента: ${err?.code || 'error'}: ${err?.message || 'unknown'}`
+        const msg = t('msg.agent_error', { code: err?.code || 'error', message: err?.message || 'unknown' }, this.resolveLocale(input))
         this.sendAlert('error', {
           code: err?.code || 'AGENT_ERROR',
           message: err?.message || 'unknown',
@@ -1402,15 +1598,16 @@ export class Gateway {
       const files = await buildOutboundFiles(this.ctx, this.baseUrl(), collector, { signal, logger: this.ctx.logger })
       const allFiles = [...files, ...(processed.files || [])]
       if (!answer && !allFiles.length) {
-        if (stream) { await scheduler?.flush(); await stream.finalize('(нет ответа)') }
-        else await reply('(нет ответа)')
+        const noResp = t('msg.no_response', {}, this.resolveLocale(input))
+        if (stream) { await scheduler?.flush(); await stream.finalize(noResp) }
+        else await reply(noResp)
         return
       }
       const maxLen = Number(this.config.agent?.maxMessageLength) || 4000
       const chunks = answer ? splitText(answer, maxLen) : ['']
       if (stream) {
         await scheduler?.flush()
-        await stream.finalize(chunks[0] || '(нет ответа)')
+        await stream.finalize(chunks[0] || t('msg.no_response', {}, this.resolveLocale(input)))
         for (let i = 1; i < chunks.length; i++) await reply({ text: chunks[i] })
         if (allFiles.length) await reply({ files: allFiles })
       } else {
@@ -1449,8 +1646,9 @@ export class Gateway {
           threadId: input.threadId,
         }).catch(() => {})
         try {
-          if (stream) await stream.finalize(`Сбой: ${err.message}`)
-          else await reply(`Сбой: ${err.message}`)
+          const excMsg = t('msg.exception', { message: err.message }, this.resolveLocale(input))
+          if (stream) await stream.finalize(excMsg)
+          else await reply(excMsg)
         } catch {}
       }
     } finally {