@goodandready/dsh-messenger-gateway 0.3.2 → 0.3.9

package/lib/gateway.js

@@ -8,7 +8,8 @@ import { SessionId } from '@deepseek-ai/dsh-session'
 import createAdapters from './adapters/index.js'
 import { transcribeVoice, speakText } from './integrations.js'
 import { attachInboundPhoto, photoOnlyHint } from './photos.js'
-import { formatInboundDocument, documentOnlyHint } from './documents.js'
+import { formatInboundDocument, documentOnlyHint, parseDocument } from './documents.js'
+import { listFiles, getFileForDownload, formatFileSize } from './file-manager.js'
 import { collectAssistantParts, buildOutboundFiles, stripImageUrls } from './outbound.js'
 import { assistantText, splitText, stripReasoningPreamble, MESSENGER_RELAY_INSTRUCTION } from './text.js'
 import { chatKey, sessionKey } from './topics.js'
@@ -16,9 +17,16 @@ import { listHomes, resolveNamedHome, upsertHome, normalizeHomeName } from './ho
 import { createVoicePrefs, shouldSpeakReply } from './voice-prefs.js'
 import { prepareTtsText, toTelegramVoiceFile } from './tts.js'
 import {
-  makeAskToken, buildInlineKeyboard, indexCallbacks, releaseCallbacks,
-  parseCallbackData, targetMatchesAsk, rejectPendingAsk, REMOVE_KEYBOARD,
+  makeAskToken, buildInlineKeyboard, buildMultiSelectKeyboard, indexCallbacks, releaseCallbacks,
+  parseCallbackData, parseAskCallback, targetMatchesAsk, rejectPendingAsk, REMOVE_KEYBOARD,
 } from './ask.js'
+import { processDiagramsAndTables } from './artifacts.js'
+import { createPersonaStore, getPersona, listPersonas, BUILTIN_PERSONAS } from './personas.js'
+import { exportSessionToMarkdown, rewindSession } from './session-ops.js'
+import { formatAlertMessage, resolveAlertTarget } from './alerts.js'
+import { createScheduler, parseRelativeTime, formatRemaining } from './scheduler.js'
+import { listModelCatalog, buildProvidersKeyboard, buildModelsKeyboard, getStoredModelSelection } from './models.js'
+import { buildQuickActionsKeyboard, REMOVE_REPLY_KEYBOARD } from './adapters/telegram.js'
 import { createPairingStore } from './pairing.js'
 import {
   extractTextDelta, extractToolName, buildStreamPreview, formatProgressLine,
@@ -64,6 +72,16 @@ export class Gateway {
     this.voicePrefs = createVoicePrefs(join(home, 'messenger-gateway', 'voice-prefs.json'))
     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.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 })
+    })
     this.stats = { sent: 0, errors: 0, startedAt: Date.now() }
   }
 
@@ -97,6 +115,20 @@ export class Gateway {
     return out
   }
 
+  async sendAlert(type, payload = {}) {
+    try {
+      const target = resolveAlertTarget(this)
+      if (!target) return
+      const allowedEvents = this.config.telegram?.alerts?.events || ['error', 'pairing']
+      if (type !== 'status' && !allowedEvents.includes(type)) return
+
+      const text = formatAlertMessage(type, payload)
+      await this.sendToMessenger(target, { text })
+    } catch (err) {
+      this.ctx.logger?.warn?.(`sendAlert (${type}): ${err.message}`)
+    }
+  }
+
   async start() {
     this.disposeListener = this.ctx.on('session/event', (session, event) => {
       const collector = this.pending.get(session.id)
@@ -147,9 +179,11 @@ export class Gateway {
       this.idleTimer = setInterval(() => this.reapIdle(), Math.min(idleMs, 60_000))
       this.idleTimer.unref?.()
     }
+    this.scheduler.start()
   }
 
   stop() {
+    if (this.scheduler) this.scheduler.stop()
     if (this.disposeListener) this.disposeListener()
     if (this.idleTimer) clearInterval(this.idleTimer)
     for (const a of this.adapterList) { try { a.stop() } catch {} }
@@ -195,7 +229,24 @@ export class Gateway {
     const adapter = this.getAdapter(target.platform)
     if (!adapter) throw new Error(`adapter ${target.platform} unavailable`)
     const token = makeAskToken()
-    const { replyMarkup, callbackKeys } = buildInlineKeyboard(token, payload.buttons || [])
+    const isMulti = payload.mode === 'multi' || (Array.isArray(payload.options) && payload.options.length > 0)
+    let replyMarkup
+    let callbackKeys
+    let selectedSet
+    let page = 0
+    const pageSize = Number(payload.pageSize) || 6
+
+    if (isMulti) {
+      selectedSet = new Set(Array.isArray(payload.selected) ? payload.selected : [])
+      const kb = buildMultiSelectKeyboard(token, payload.options || payload.buttons, selectedSet, page, pageSize, payload)
+      replyMarkup = kb.replyMarkup
+      callbackKeys = kb.callbackKeys
+    } else {
+      const kb = buildInlineKeyboard(token, payload.buttons || [])
+      replyMarkup = kb.replyMarkup
+      callbackKeys = kb.callbackKeys
+    }
+
     indexCallbacks(this.callbackIndex, callbackKeys, token)
     try {
       await adapter.sendTo(target.chatId, { text: payload.text, replyMarkup }, { threadId: target.threadId })
@@ -215,7 +266,12 @@ export class Gateway {
         reject(new Error('messenger.ask timed out'))
       }, timeoutMs)
       timer.unref?.()
-      this.pendingAsks.set(token, { resolve, reject, timer, target, callbackKeys })
+      this.pendingAsks.set(token, {
+        resolve, reject, timer, target, callbackKeys, isMulti,
+        options: payload.options || payload.buttons,
+        selected: selectedSet,
+        page, pageSize, payload,
+      })
     })
   }
 
@@ -232,6 +288,7 @@ export class Gateway {
     try {
       const { code } = this.pairing.requestCode(userId, { username })
       await reply(`Нет доступа.\nВаш id: ${userId}\nКод сопряжения: ${code}\n\nВладелец должен отправить боту:\n/pair ${code}`)
+      this.sendAlert('pairing', { userId, username, code }).catch(() => {})
     } catch (err) {
       if (err.code === 'RATE_LIMIT') await reply('Код уже выдан. Подождите или попросите владельца /pair.')
       else await reply(`Не удалось выдать код: ${err.message}`)
@@ -248,14 +305,156 @@ export class Gateway {
         await cb.answer('Кнопка для другого чата')
         return
       }
+      const action = parseAskCallback(cb.data)
+      if (pending.isMulti) {
+        if (action.kind === 'toggle') {
+          if (pending.selected.has(action.id)) pending.selected.delete(action.id)
+          else pending.selected.add(action.id)
+          releaseCallbacks(this.callbackIndex, pending.callbackKeys)
+          const nextKb = buildMultiSelectKeyboard(askToken, pending.options, pending.selected, pending.page, pending.pageSize, pending.payload)
+          pending.callbackKeys = nextKb.callbackKeys
+          indexCallbacks(this.callbackIndex, nextKb.callbackKeys, askToken)
+          try {
+            if (cb.editReplyMarkup) await cb.editReplyMarkup(nextKb.replyMarkup)
+            else await cb.editMessage(cb.message?.text || 'Выбор', nextKb.replyMarkup)
+          } catch {}
+          await cb.answer(pending.selected.has(action.id) ? 'Выбрано' : 'Снято')
+          return
+        }
+        if (action.kind === 'page') {
+          pending.page = action.page
+          releaseCallbacks(this.callbackIndex, pending.callbackKeys)
+          const nextKb = buildMultiSelectKeyboard(askToken, pending.options, pending.selected, pending.page, pending.pageSize, pending.payload)
+          pending.callbackKeys = nextKb.callbackKeys
+          indexCallbacks(this.callbackIndex, nextKb.callbackKeys, askToken)
+          try {
+            if (cb.editReplyMarkup) await cb.editReplyMarkup(nextKb.replyMarkup)
+            else await cb.editMessage(cb.message?.text || 'Выбор', nextKb.replyMarkup)
+          } catch {}
+          await cb.answer()
+          return
+        }
+        if (action.kind === 'done') {
+          clearTimeout(pending.timer)
+          this.pendingAsks.delete(askToken)
+          releaseCallbacks(this.callbackIndex, pending.callbackKeys)
+          await cb.answer('OK')
+          try { await cb.editMessage(cb.message?.text || 'Выбрано', REMOVE_KEYBOARD) } catch {}
+          pending.resolve({ buttonId: 'done', selected: Array.from(pending.selected), data: cb.data })
+          return
+        }
+        if (action.kind === 'cancel') {
+          clearTimeout(pending.timer)
+          this.pendingAsks.delete(askToken)
+          releaseCallbacks(this.callbackIndex, pending.callbackKeys)
+          await cb.answer('Отменено')
+          try { await cb.editMessage(cb.message?.text || 'Отменено', REMOVE_KEYBOARD) } catch {}
+          pending.resolve({ buttonId: 'cancel', selected: [], data: cb.data })
+          return
+        }
+      }
       clearTimeout(pending.timer)
       this.pendingAsks.delete(askToken)
       releaseCallbacks(this.callbackIndex, pending.callbackKeys)
       await cb.answer('OK')
       try { await cb.editMessage(cb.message?.text || 'Выбрано', REMOVE_KEYBOARD) } catch {}
-      pending.resolve({ buttonId, data: cb.data })
+      pending.resolve({ buttonId: action.id || buttonId, data: cb.data })
       return
     }
+
+    // Model picker interactive flow
+    if (cb.data?.startsWith('mdl:')) {
+      const parts = cb.data.split(':')
+      const sub = parts[1]
+      // Step 2: Selected provider -> show its models (10 per page)
+      if (sub === 'p') {
+        const providerId = parts[2]
+        const current = this.resolveAgentModel()
+        const catalog = await listModelCatalog(this.ctx, current)
+        const models = catalog.modelsByProvider.get(providerId) || []
+        if (!models.length) {
+          await cb.answer('Нет доступных моделей у этого провайдера')
+          return
+        }
+        const kb = buildModelsKeyboard(providerId, models, current.model, 0)
+        await cb.answer()
+        const text = [
+          `🤖 <b>Провайдер:</b> <code>${providerId}</code>`,
+          `Выберите модель (страница ${kb.page + 1}/${kb.totalPages}):`,
+        ].join('\n')
+        try {
+          if (cb.editMessage) await cb.editMessage(text, kb)
+        } catch {}
+        return
+      }
+      // Pagination for models
+      if (sub === 'pg') {
+        const providerId = parts[2]
+        const page = parseInt(parts[3], 10) || 0
+        const current = this.resolveAgentModel()
+        const catalog = await listModelCatalog(this.ctx, current)
+        const models = catalog.modelsByProvider.get(providerId) || []
+        const kb = buildModelsKeyboard(providerId, models, current.model, page)
+        await cb.answer()
+        const text = [
+          `🤖 <b>Провайдер:</b> <code>${providerId}</code>`,
+          `Выберите модель (страница ${kb.page + 1}/${kb.totalPages}):`,
+        ].join('\n')
+        try {
+          if (cb.editMessage) await cb.editMessage(text, kb)
+        } catch {}
+        return
+      }
+      // Back to providers
+      if (sub === 'back') {
+        const current = this.resolveAgentModel()
+        const catalog = await listModelCatalog(this.ctx, current)
+        const kb = buildProvidersKeyboard(catalog.providers, current)
+        await cb.answer()
+        const text = [
+          '🤖 <b>Выберите провайдера:</b>',
+          `Текущая: <code>${current.provider}/${current.model}</code>`,
+        ].join('\n')
+        try {
+          if (cb.editMessage) await cb.editMessage(text, kb)
+        } catch {}
+        return
+      }
+      // Select model
+      if (sub === 's') {
+        const key = parts[2]
+        const stored = getStoredModelSelection(key)
+        if (!stored) {
+          await cb.answer('Сессия выбора модели истекла, вызовите /model заново')
+          return
+        }
+        const { provider, model } = stored
+        try {
+          const adm = this.ctx.get('agentDefaultModel')
+          if (adm?.saveSelection) {
+            await adm.saveSelection({ provider, model })
+          }
+          this.config.agent = { ...this.config.agent, provider, model }
+          try {
+            await this.hooks?.persistAgentModel?.({ provider, model })
+          } catch (e) {
+            this.ctx.logger?.warn?.(`persist agent model: ${e.message}`)
+          }
+          await cb.answer(`Выбрана ${model}`)
+          try {
+            if (cb.editMessage) await cb.editMessage(`✅ Модель успешно переключена на: <b>${provider}/${model}</b>`, REMOVE_KEYBOARD)
+          } catch {}
+        } catch (err) {
+          await cb.answer(`Ошибка: ${err.message}`)
+        }
+        return
+      }
+      if (sub === 'cur') {
+        await cb.answer()
+        return
+      }
+    }
+
     await cb.answer()
   }
 
@@ -300,7 +499,16 @@ export class Gateway {
         chat.pendingMedia = []
       }
       const inboundWasVoice = attachments.some((a) => a.kind === 'voice' || a.kind === 'audio')
-      const turnInput = { ...input, text: body, attachments, inboundWasVoice }
+      let personaOverride
+      for (const [pId] of Object.entries(BUILTIN_PERSONAS)) {
+        if (pId === 'default') continue
+        const tag = `@${pId}`
+        if (body.toLowerCase().includes(tag)) {
+          personaOverride = pId
+          break
+        }
+      }
+      const turnInput = { ...input, text: body, attachments, inboundWasVoice, personaOverride }
 
       // Hermes-like steer: while a turn is running, inject followup instead of abort+restart
       if (this.isChatBusy(chat)) {
@@ -328,6 +536,13 @@ export class Gateway {
       run.catch((err) => {
         const msg = err instanceof Error ? err.message : String(err)
         this.ctx.logger?.warn?.(`dsh-messenger-gateway: background turn: ${msg}`)
+        this.sendAlert('error', {
+          code: err?.code || 'BACKGROUND_ERROR',
+          message: msg,
+          sessionId: chat.agent?.session?.id,
+          chatId: input.chatId,
+          threadId: input.threadId,
+        }).catch(() => {})
         chat.turnActive = false
         chat.abort = undefined
       })
@@ -353,12 +568,157 @@ export class Gateway {
         '/stop — прервать текущий ответ',
         '/status — статус шлюза',
         '/model — текущая модель; /model provider model — сменить',
+        '/role [name] — персоны и роли агента (/role list)',
+        '/skills / /tools — список инструментов и навыков',
+        '/fork — ответвление текущей сессии',
+        '/export — выгрузка истории диалога в Markdown',
+        '/rewind [N] — откат последних N сообщений',
+        '/files [dir] — менеджер файлов в рабочей папке агента',
+        '/get <path> — скачать файл из рабочей папки в Telegram',
         '/pair CODE — одобрить пользователя',
         '/sethome [name] — этот чат = home (имя опционально)',
         '/home — список home',
+        '/setalert — назначить этот чат каналом алертов',
+        '/alert [test] — статус канала алертов и тест',
+        '/remind <время> <текст> — напоминание (/remind 10m текст, /remind list)',
         '/voice on|off|status — голосовые ответы',
+        '/tts on|off|status — озвучка в этом чате',
+        '/mute / /unmute — заглушить уведомления в этот чат',
+        '/keyboard on|off — быстрая клавиатура',
+      ].join('\n'))
+    }
+    if (cmd === '/role' || cmd === '/persona') {
+      const targetRole = parts[1]?.toLowerCase()
+      if (!targetRole || targetRole === 'list') {
+        const currentId = this.personas.get(chatId)
+        const lines = [
+          '🎭 <b>Доступные роли и персоны:</b>',
+          '',
+          ...listPersonas().map((p) => {
+            const isCurrent = p.id === currentId ? ' (активна)' : ''
+            return `${p.icon} <b>${p.id}</b> — ${p.name}: ${p.description}${isCurrent}`
+          }),
+          '',
+          'Смена роли: <code>/role coder</code> (или /role reset)',
+        ]
+        return reply(lines.join('\n'))
+      }
+      if (targetRole === 'reset' || targetRole === 'default') {
+        this.personas.set(chatId, 'default')
+        return reply('🎭 Роль сброшена на стандартную (Default).')
+      }
+      const persona = getPersona(targetRole)
+      if (!persona) {
+        return reply(`Неизвестная роль "${targetRole}". Список: /role list`)
+      }
+      this.personas.set(chatId, persona.id)
+      return reply(`🎭 Роль изменена на: ${persona.icon} <b>${persona.name}</b>\n${persona.description}`)
+    }
+    if (cmd === '/skills' || cmd === '/tools') {
+      const toolsList = []
+      if (this.ctx.tools?.tools) {
+        for (const [name, t] of this.ctx.tools.tools.entries()) {
+          toolsList.push(`• <b>${name}</b>: ${t.description || '(нет описания)'}`)
+        }
+      }
+      if (!toolsList.length) {
+        return reply('🛠️ <b>Инструменты агента:</b>\n(нет зарегистрированных инструментов)')
+      }
+      return reply([
+        '🛠️ <b>Активные инструменты и скиллы:</b>',
+        '',
+        ...toolsList,
       ].join('\n'))
     }
+    if (cmd === '/export') {
+      const chat = this.chats.get(key)
+      if (!chat?.agent?.session) {
+        return reply('Нет активной сессии для экспорта.')
+      }
+      try {
+        const { filename, buffer, messagesCount } = exportSessionToMarkdown(chat.agent.session)
+        if (!messagesCount) {
+          return reply('Сессия пуста, нет сообщений для экспорта.')
+        }
+        const file = {
+          name: filename,
+          mime: 'text/markdown',
+          kind: 'document',
+          bytes: buffer,
+          dataBase64: buffer.toString('base64'),
+        }
+        return reply({ text: `📄 Экспорт диалога (${messagesCount} сообщений):`, files: [file] })
+      } catch (err) {
+        return reply(`Ошибка экспорта: ${err.message}`)
+      }
+    }
+    if (cmd === '/rewind') {
+      const chat = this.chats.get(key)
+      if (!chat?.agent?.session) {
+        return reply('Нет активной сессии для отката.')
+      }
+      const count = Number(parts[1]) || 1
+      const res = rewindSession(chat.agent.session, count)
+      if (!res.removed) {
+        return reply('В истории сессии нет сообщений для отката.')
+      }
+      try { await this.ctx.sessions?.flush(chat.agent.session) } catch {}
+      return reply(`⏪ Откачено сообщений: ${res.removed}. Осталось в контексте: ${res.remaining}.`)
+    }
+    if (cmd === '/fork') {
+      const chat = this.chats.get(key)
+      if (!chat?.agent?.session) {
+        return reply('Нет активной сессии для форка.')
+      }
+      try {
+        const oldSession = chat.agent.session
+        const oldMessages = Array.isArray(oldSession.messages) ? [...oldSession.messages] : []
+        const newChat = await this.createChat(key, input)
+        if (newChat.agent?.session && oldMessages.length) {
+          newChat.agent.session.messages = oldMessages
+          try { await this.ctx.sessions?.flush(newChat.agent.session) } catch {}
+        }
+        this.chats.set(key, newChat)
+        return reply(`🔀 Создан форк сессии!\nСтарая сессия: ${oldSession.id}\nНовая активная сессия: ${newChat.agent.session.id}\nКонтекст сохранён (${oldMessages.length} сообщений).`)
+      } catch (err) {
+        return reply(`Ошибка форка: ${err.message}`)
+      }
+    }
+    if (cmd === '/files') {
+      const subPath = parts.slice(1).join(' ').trim() || '.'
+      const agentCwd = this.config.agent?.cwd || process.cwd()
+      const res = await listFiles(agentCwd, subPath)
+      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>')
+      }
+      const agentCwd = this.config.agent?.cwd || process.cwd()
+      const maxDocBytes = Number(this.config.media?.maxDocBytes) || 50 * 1024 * 1024
+      const res = await getFileForDownload(agentCwd, targetRel, maxDocBytes)
+      if (!res.ok) return reply(`❌ ${res.error}`)
+      const file = {
+        name: res.name,
+        mime: res.mime,
+        kind: 'document',
+        bytes: res.bytes,
+        dataBase64: res.bytes.toString('base64'),
+      }
+      return reply({ text: `📄 Файл: <b>${res.name}</b> (${formatFileSize(res.size)})`, files: [file] })
+    }
+    if (cmd === '/keyboard') {
+      const sub = String(parts[1] || 'status').toLowerCase()
+      const tgAdapter = this.getAdapter('telegram')
+      if (sub === 'on' || sub === 'off') {
+        if (tgAdapter) tgAdapter.quickActions = sub === 'on'
+        return reply(sub === 'on' ? 'Быстрая клавиатура: включена.' : 'Быстрая клавиатура: выключена.', sub === 'off' ? { replyMarkup: { remove_keyboard: true } } : undefined)
+      }
+      const cur = tgAdapter?.quickActions !== false
+      return reply(`Быстрая клавиатура: ${cur ? 'on' : 'off'}\nСмена: /keyboard on|off`)
+    }
     if (cmd === '/new') {
       const chat = this.chats.get(key)
       if (chat) {
@@ -441,8 +801,18 @@ export class Gateway {
         }
       }
       try {
-        const sel = this.resolveAgentModel()
-        return reply(`Текущая модель: ${sel.provider}/${sel.model}\nСмена: /model <provider> <model>`)
+        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>`)
+        }
+        const kb = buildProvidersKeyboard(catalog.providers, current)
+        return reply([
+          '🤖 <b>Выберите провайдера:</b>',
+          `Текущая модель: <code>${current.provider}/${current.model}</code>`,
+        ].join('\n'), {
+          replyMarkup: kb,
+        })
       } catch (e) {
         return reply(e.message)
       }
@@ -477,8 +847,101 @@ export class Gateway {
       if (!homes.length) return reply('Home не задан. /sethome или /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('Нет доступа.')
+      const nextTg = {
+        ...this.tg(),
+        alerts: {
+          ...(this.tg().alerts || {}),
+          enabled: true,
+          chatId,
+          threadId: threadId || 0,
+        },
+      }
+      this.config.telegram = nextTg
+      try { await this.hooks?.persistHomes?.(nextTg) } catch {}
+      return reply(`🔔 Этот чат назначен каналом алертов (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('Тестовый алерт отправлен в канал алертов.')
+      }
+      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(', ')}`,
+        '',
+        'Команды:',
+        '/setalert — назначить текущий чат каналом алертов',
+        '/alert test — отправить тестовый алерт',
+      ].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('Нет активных напоминаний для этого чата.')
+        const lines = [
+          '⏰ <b>Активные напоминания:</b>',
+          '',
+          ...active.map((t) => {
+            const left = formatRemaining(t.dueAt - Date.now())
+            return `• <code>${t.id}</code> (через ${left}): ${t.text}`
+          }),
+          '',
+          'Отмена: <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>')
+        const ok = await this.scheduler.cancel(targetId, chatId)
+        return reply(ok ? `✅ Напоминание <code>${targetId}</code> отменено.` : `❌ Напоминание с ID <code>${targetId}</code> не найдено.`)
+      }
+      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>',
+        ].join('\n'))
+      }
+      const dueAt = Date.now() + delayMs
+      const task = await this.scheduler.schedule({
+        platform: platform || 'telegram',
+        chatId,
+        threadId: threadId || 0,
+        userId,
+        text: textArg,
+        dueAt,
+      })
+      const left = formatRemaining(delayMs)
+      return reply(`⏰ Напоминание установлено на <b>через ${left}</b> (ID: <code>${task.id}</code>):\n«${textArg}»`)
+    }
     if (cmd === '/voice') {
       const sub = String(parts[1] || 'status').toLowerCase()
+      if (sub === 'summary') {
+        const val = parts[2]?.toLowerCase()
+        if (val === 'on' || val === 'off') {
+          if (!this.config.tts) this.config.tts = {}
+          this.config.tts.voiceSummary = val === 'on'
+          return reply(`Голосовое саммари (TL;DR): ${val === 'on' ? 'включено' : 'выключено'}`)
+        }
+        const state = this.config.tts?.voiceSummary ? 'on' : 'off'
+        return reply(`Голосовое саммари (TL;DR): ${state}\nПереключение: <code>/voice summary on|off</code>`)
+      }
       if (sub === 'on' || sub === 'off') {
         this.voicePrefs.set(userId, sub === 'on')
         return reply(sub === 'on' ? 'Голосовые ответы: on (для вас)' : 'Голосовые ответы: off (для вас)')
@@ -486,7 +949,84 @@ export class Gateway {
       const pref = this.voicePrefs.get(userId)
       const mode = this.tg().voiceMode || 'mirror'
       const prefLine = pref === null ? 'не задан (/voice on|off)' : (pref ? 'on' : 'off')
-      return reply(`voiceMode=${mode}\nваш /voice: ${prefLine}\nglobal tts: ${this.config.tts?.enabled ? '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}`)
+    }
+    if (cmd === '/topic') {
+      const topicName = parts.slice(1).join(' ').trim()
+      if (!topicName) {
+        return reply('Использование: <code>/topic &lt;название&gt;</code>\nСоздает новый топик в супергруппе и изолированную сессию под задачу.')
+      }
+      const tgAdapter = this.getAdapter('telegram')
+      if (!tgAdapter?.createForumTopic) {
+        return reply('Создание топиков доступно только в 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Перейдите в созданный топик для работы над задачей!`)
+        if (newThreadId) {
+          await tgAdapter.sendTo(chatId, {
+            text: `👋 Привет! Это изолированная сессия для задачи <b>«${topicName}»</b>.\nЧем могу помочь?`,
+          }, { threadId: newThreadId })
+        }
+        return
+      } catch (err) {
+        return reply(`Не удалось создать топик: ${err.message}\n(Убедитесь, что бот является администратором группы и включены темы/форумы)`)
+      }
+    }
+    if (cmd === '/top') {
+      const mem = process.memoryUsage()
+      const rssMb = (mem.rss / 1024 / 1024).toFixed(1)
+      const heapMb = (mem.heapUsed / 1024 / 1024).toFixed(1)
+      const sec = Math.floor((Date.now() - this.stats.startedAt) / 1000)
+      const hh = String(Math.floor(sec / 3600)).padStart(2, '0')
+      const mm = String(Math.floor((sec % 3600) / 60)).padStart(2, '0')
+      const ss = String(sec % 60).padStart(2, '0')
+      let activeReminders = 0
+      try { activeReminders = (await this.scheduler.list()).length } catch {}
+      let currentModel = 'не задана'
+      try {
+        const m = this.resolveAgentModel()
+        currentModel = `${m.provider}/${m.model}`
+      } catch {}
+
+      return reply([
+        '📊 <b>DSH System & Resources:</b>',
+        `• <b>Память (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}`,
+      ].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('Клавиатура быстрых действий включена.', {
+          replyMarkup: buildQuickActionsKeyboard(),
+        })
+      }
+      if (sub === 'off') {
+        if (tgAdapter) tgAdapter.quickActions = false
+        return reply('Клавиатура быстрых действий выключена.', {
+          replyMarkup: REMOVE_REPLY_KEYBOARD,
+        })
+      }
+      const curState = tgAdapter?.quickActions ? 'включена' : 'выключена'
+      return reply([
+        '⌨️ <b>Клавиатура быстрых действий:</b>',
+        `Текущее состояние: <b>${curState}</b>`,
+        '',
+        'Команды:',
+        '<code>/keyboard on</code> — показать кнопки',
+        '<code>/keyboard off</code> — скрыть кнопки',
+      ].join('\n'))
     }
     if (cmd === '/tts') {
       const sub = String(parts[1] || 'status').toLowerCase()
@@ -574,9 +1114,14 @@ export class Gateway {
   }
 
   async buildUserContent(input, signal) {
-    const { text, attachments = [], replyText, steer } = input
+    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 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()}]`)
     const blocks = []
@@ -606,7 +1151,14 @@ export class Gateway {
           parts.push(`[Голосовое сообщение (dsh-voice недоступен: ${msg})]`)
         }
       } else if (att.kind === 'document' || att.kind === 'video' || att.kind === 'animation' || att.kind === 'sticker') {
-        parts.push(formatInboundDocument(att))
+        let parsed = null
+        if (att.kind === 'document' && att.path) {
+          try {
+            const maxDocBytes = Number(this.config.media?.maxTextInjectBytes) || 100 * 1024
+            parsed = await parseDocument(att.path, { maxBytes: maxDocBytes })
+          } catch {}
+        }
+        parts.push(formatInboundDocument(att, parsed))
       } else {
         parts.push(`[Файл: ${att.path}${att.name ? ` (${att.name})` : ''}]`)
       }
@@ -688,16 +1240,28 @@ export class Gateway {
       if (progress) try { await progress.remove() } catch {}
       progress = null
       if (typeof react === 'function') react('').catch?.(() => {})
-      const answer = stripReasoningPreamble(stripImageUrls(collector.lastText || collector.streamText || collector.parts.join('\n\n')))
+      const rawAnswer = stripReasoningPreamble(stripImageUrls(collector.lastText || collector.streamText || collector.parts.join('\n\n')))
+      const processed = processDiagramsAndTables(rawAnswer, {
+        artifactPreviews: this.tg().artifactPreviews !== false,
+      })
+      const answer = processed.text
       if (collector.reason?.kind === 'error') {
         const err = collector.reason.error
         const msg = `Ошибка агента: ${err?.code || 'error'}: ${err?.message || 'unknown'}`
+        this.sendAlert('error', {
+          code: err?.code || 'AGENT_ERROR',
+          message: err?.message || 'unknown',
+          sessionId,
+          chatId: input.chatId,
+          threadId: input.threadId,
+        }).catch(() => {})
         if (stream) { await scheduler?.flush(); await stream.finalize(msg) }
         else await reply(msg)
         return
       }
       const files = await buildOutboundFiles(this.ctx, this.baseUrl(), collector, { signal, logger: this.ctx.logger })
-      if (!answer && !files.length) {
+      const allFiles = [...files, ...(processed.files || [])]
+      if (!answer && !allFiles.length) {
         if (stream) { await scheduler?.flush(); await stream.finalize('(нет ответа)') }
         else await reply('(нет ответа)')
         return
@@ -708,10 +1272,10 @@ export class Gateway {
         await scheduler?.flush()
         await stream.finalize(chunks[0] || '(нет ответа)')
         for (let i = 1; i < chunks.length; i++) await reply({ text: chunks[i] })
-        if (files.length) await reply({ files })
+        if (allFiles.length) await reply({ files: allFiles })
       } else {
         for (let i = 0; i < chunks.length; i++) {
-          await reply({ text: chunks[i] || undefined, files: i === 0 ? files : [] })
+          await reply({ text: chunks[i] || undefined, files: i === 0 ? allFiles : [] })
         }
       }
       const chatTtsPref = this.chatTts.get(chat.target?.chatId)
@@ -723,7 +1287,8 @@ export class Gateway {
         chatPref: chatTtsPref,
       })
       if (speak && !signal.aborted) {
-        const ttsText = prepareTtsText(answer, this.config.tts?.maxChars)
+        const isVoiceSummary = this.config.tts?.voiceSummary === true
+        const ttsText = prepareTtsText(answer, this.config.tts?.maxChars, { voiceSummary: isVoiceSummary })
         if (ttsText) {
           try {
             const spoken = await speakText(this.baseUrl(), ttsText, signal)
@@ -736,6 +1301,13 @@ export class Gateway {
       }
     } catch (err) {
       if (!signal?.aborted) {
+        this.sendAlert('error', {
+          code: err?.code || 'EXCEPTION',
+          message: err?.message || String(err),
+          sessionId,
+          chatId: input.chatId,
+          threadId: input.threadId,
+        }).catch(() => {})
         try {
           if (stream) await stream.finalize(`Сбой: ${err.message}`)
           else await reply(`Сбой: ${err.message}`)