@goodandready/dsh-messenger-gateway 0.2.0 → 0.3.1

package/lib/adapters/index.js

@@ -15,6 +15,9 @@ export default function createAdapters(deps) {
       groupsEnabled: tg.groupsEnabled,
       groupRequireMention: tg.groupRequireMention,
       reactionsEnabled: tg.reactionsEnabled,
+      statusIndicator: tg.statusIndicator,
+      statusOnline: tg.statusOnline,
+      statusOffline: tg.statusOffline,
       transport: tg.transport,
       webhookUrl: tg.webhookUrl,
       webhookSecret: tg.webhookSecret,

package/lib/adapters/telegram.js

@@ -11,6 +11,7 @@ import { normalizeThreadId, telegramThreadParams } from '../topics.js'
 import {
   shouldProcessTelegramMessage, stripBotCommandSuffix,
 } from '../groups.js'
+import { isResendSafeNetworkError, isPollingConflict } from '../telegram-errors.js'
 
 const API = 'https://api.telegram.org'
 const TELEGRAM_MAX = 4096
@@ -34,6 +35,12 @@ export class TelegramAdapter {
     this.groupRequireMention = opts.groupRequireMention !== false
     this.reactionsEnabled = opts.reactionsEnabled !== false
     this.transport = opts.transport === 'webhook' ? 'webhook' : 'poll'
+    this.statusIndicator = opts.statusIndicator === true
+    this.statusOnline = String(opts.statusOnline || 'Online')
+    this.statusOffline = String(opts.statusOffline || 'Offline')
+    this.sendRetryMax = 2
+    this.sendRetryBaseMs = 400
+    this.pollingConflict = false
     this.webhookUrl = String(opts.webhookUrl || '').trim()
     this.webhookSecret = String(opts.webhookSecret || '').trim()
     this.offset = 0
@@ -63,6 +70,24 @@ export class TelegramAdapter {
     return json.result
   }
 
+  // Retry a send only on resend-safe network errors (request never reached Telegram).
+  // Permanent errors (4xx/5xx) and ambiguous timeouts are not retried to avoid duplicates.
+  async sendWithRetry(method, params, { multipart = false } = {}) {
+    const fn = () => (multipart ? this.callMultipart(method, params) : this.call(method, params))
+    let lastErr
+    for (let attempt = 0; attempt <= this.sendRetryMax; attempt++) {
+      try {
+        return await fn()
+      } catch (err) {
+        lastErr = err
+        if (!isResendSafeNetworkError(err) || attempt >= this.sendRetryMax) throw err
+        this.logger?.warn?.(`telegram ${method} resend-safe network error (attempt ${attempt + 1}/${this.sendRetryMax}), retrying: ${err.message}`)
+        await new Promise((r) => setTimeout(r, this.sendRetryBaseMs * (attempt + 1)))
+      }
+    }
+    throw lastErr
+  }
+
   async getFile(fileId) { return this.call('getFile', { file_id: fileId }) }
 
   async downloadFile(filePath) {
@@ -76,6 +101,17 @@ export class TelegramAdapter {
     await this.call('setMyCommands', { commands: this.commands })
   }
 
+  // Bots have no presence dot; the short description is the closest surface.
+  // Opt-in only — it mutates the bot's global profile visible to all users.
+  async setStatusIndicator(text) {
+    if (!this.statusIndicator) return
+    try {
+      await this.call('setMyShortDescription', { short_description: String(text || '').slice(0, 120) })
+    } catch (err) {
+      this.logger?.warn?.(`telegram setMyShortDescription: ${err.message}`)
+    }
+  }
+
   async start() {
     if (!this.token) throw new Error('telegram bot token is empty')
     this.stopped = false
@@ -87,6 +123,7 @@ export class TelegramAdapter {
     } catch (err) {
       this.logger?.warn?.(`dsh-messenger-gateway: telegram getMe: ${err.message}`)
     }
+    if (this.statusIndicator) await this.setStatusIndicator(this.statusOnline)
     try {
       await this.registerCommands()
       this.logger?.info?.(`dsh-messenger-gateway: telegram commands registered (${this.commands.length})`)
@@ -115,6 +152,7 @@ export class TelegramAdapter {
   stop() {
     this.stopped = true
     if (this.pollTimer) clearTimeout(this.pollTimer)
+    if (this.statusIndicator) this.setStatusIndicator(this.statusOffline).catch(() => {})
   }
 
   schedulePoll() {
@@ -131,12 +169,20 @@ export class TelegramAdapter {
         offset: this.offset,
         allowed_updates: ['message', 'callback_query'],
       })
+      this.pollingConflict = false
       for (const update of updates || []) {
         this.offset = Math.max(this.offset, update.update_id + 1)
         await this.dispatchUpdate(update)
       }
     } catch (e) {
-      if (!this.stopped) this.logger?.warn?.(`poll: ${e.message}`)
+      if (!this.stopped) {
+        if (isPollingConflict(e)) {
+          this.pollingConflict = true
+          this.logger?.error?.(`poll: TELEGRAM CONFLICT — another bot instance is polling the same token. Stop the duplicate instance. (${e.message})`)
+        } else {
+          this.logger?.warn?.(`poll: ${e.message}`)
+        }
+      }
     }
     this.schedulePoll()
   }
@@ -422,12 +468,12 @@ export class TelegramAdapter {
     if (thread.message_thread_id) form.append('message_thread_id', String(thread.message_thread_id))
     const blob = new Blob([file.bytes])
     const name = safeName(file.name || 'file')
-    if (file.kind === 'photo') { form.append('photo', blob, name); return this.callMultipart('sendPhoto', form) }
-    if (file.kind === 'voice') { form.append('voice', blob, name); return this.callMultipart('sendVoice', form) }
-    if (file.kind === 'audio') { form.append('audio', blob, name); return this.callMultipart('sendAudio', form) }
-    if (file.kind === 'video') { form.append('video', blob, name); return this.callMultipart('sendVideo', form) }
+    if (file.kind === 'photo') { form.append('photo', blob, name); return this.sendWithRetry('sendPhoto', form, { multipart: true }) }
+    if (file.kind === 'voice') { form.append('voice', blob, name); return this.sendWithRetry('sendVoice', form, { multipart: true }) }
+    if (file.kind === 'audio') { form.append('audio', blob, name); return this.sendWithRetry('sendAudio', form, { multipart: true }) }
+    if (file.kind === 'video') { form.append('video', blob, name); return this.sendWithRetry('sendVideo', form, { multipart: true }) }
     form.append('document', blob, name)
-    return this.callMultipart('sendDocument', form)
+    return this.sendWithRetry('sendDocument', form, { multipart: true })
   }
 
   formatOutgoingText(text, payload = {}) {
@@ -451,7 +497,7 @@ export class TelegramAdapter {
       }
       if (parseMode) params.parse_mode = parseMode
       try {
-        await this.call('sendMessage', params)
+        await this.sendWithRetry('sendMessage', params)
       } catch (err) {
         if (!parseMode) throw err
         this.logger?.warn?.(`telegram HTML send failed, fallback plain: ${err.message}`)

package/lib/client.js

@@ -98,6 +98,8 @@ const css =
       groupMention: 'Groups require @mention / reply / command',
       reactionsEnable: 'React while processing (👀)',
       progressEnable: 'Progress message (thinking → delete → final)',
+      statusIndicator: 'Status indicator (Online/Offline)',
+      statusIndicatorHint: 'Sets the bot short description; bots have no presence dot. Opt-in, visible to all users.',
       transport: 'Transport',
       transportPoll: 'Long poll (getUpdates)',
       transportWebhook: 'Webhook',
@@ -167,6 +169,8 @@ const css =
       groupMention: 'В группах только @mention / reply / команда',
       reactionsEnable: 'Реакция 👀 пока думает',
       progressEnable: 'Прогресс: думаю → удалить → финальный ответ',
+      statusIndicator: 'Индикатор статуса (Online/Offline)',
+      statusIndicatorHint: 'Меняет short description бота (у ботов нет точки присутствия). Опцionalно, видно всем.',
       transport: 'Транспорт',
       transportPoll: 'Long poll (getUpdates)',
       transportWebhook: 'Webhook',
@@ -410,6 +414,11 @@ const css =
             React.createElement('input', { type: 'checkbox', checked: cfg.telegram?.progressEnabled !== false, onChange: (e) => setCfg({ ...cfg, telegram: { ...cfg.telegram, progressEnabled: e.target.checked } }) }),
             t('progressEnable'),
           ),
+          React.createElement('label', { className: 'msgw-check' },
+            React.createElement('input', { type: 'checkbox', checked: cfg.telegram?.statusIndicator === true, onChange: (e) => setCfg({ ...cfg, telegram: { ...cfg.telegram, statusIndicator: e.target.checked } }) }),
+            t('statusIndicator'),
+          ),
+          React.createElement('div', { className: 'msgw-hint' }, t('statusIndicatorHint')),
           React.createElement(Field, { label: t('voiceMode') },
             React.createElement('select', { className: 'msgw-select', value: cfg.telegram?.voiceMode || 'mirror', onChange: (e) => setCfg({ ...cfg, telegram: { ...cfg.telegram, voiceMode: e.target.value } }) },
               React.createElement('option', { value: 'mirror' }, t('voiceModeMirror')),

package/lib/commands.js

@@ -10,6 +10,9 @@ export const DEFAULT_TELEGRAM_COMMANDS = [
   { command: 'model', description: 'Показать или сменить модель' },
   { command: 'status', description: 'Статус шлюза' },
   { command: 'voice', description: 'Голосовые ответы: /voice on|off|status' },
+  { command: 'tts', description: 'Озвучка в этом чате: /tts on|off|status' },
+  { command: 'mute', description: 'Не присылать уведомления в этот чат' },
+  { command: 'unmute', description: 'Вернуть уведомления в этот чат' },
 ]
 
 export function normalizeTelegramCommands(commands) {

package/lib/config.js

@@ -31,6 +31,9 @@ export const PluginConfig = z.object({
     groupsEnabled: z.boolean().default(true).description('Process group/supergroup messages'),
     groupRequireMention: z.boolean().default(true).description('In groups, only respond to @mention, reply-to-bot, or /commands'),
     reactionsEnabled: z.boolean().default(true).description('React with 👀 while processing a turn'),
+    statusIndicator: z.boolean().default(false).description('Opt-in: set bot short description to Online/Offline (bots have no presence)'),
+    statusOnline: z.string().default('Online'),
+    statusOffline: z.string().default('Offline'),
     transport: z.union([z.const('poll'), z.const('webhook')]).default('poll'),
     webhookUrl: z.string().default(''),
     webhookSecret: z.string().role('secret').default(''),

package/lib/gateway.js

@@ -24,6 +24,7 @@ import {
   extractTextDelta, extractToolName, buildStreamPreview, formatProgressLine,
   createEditScheduler, startTypingHeartbeat,
 } from './stream.js'
+import { isTopicGoneError } from './telegram-errors.js'
 
 function whenIdleWithTimeout(agent, timeoutMs, signal) {
   const idle = agent.whenIdle()
@@ -61,8 +62,14 @@ export class Gateway {
     const home = process.env.DSH_HOME || join(homedir(), '.dsh')
     this.pairing = createPairingStore(join(home, 'messenger-gateway', 'pairing.json'))
     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.stats = { sent: 0, errors: 0, startedAt: Date.now() }
   }
 
+  isMuted(chatId) { return this.muted.get(chatId) === true }
+  setMuted(chatId, on) { return this.muted.set(chatId, on) }
+
   baseUrl() {
     const raw = String(this.config.internalBaseURL || '').trim()
     return raw || 'http://127.0.0.1:3080'
@@ -129,6 +136,7 @@ export class Gateway {
         await adapter.start()
         this.adapterList.push(adapter)
         this.adapters.set(adapter.name, adapter)
+        if (adapter.name === 'telegram') this.tgAdapter = adapter
         this.ctx.logger?.info?.(`dsh-messenger-gateway: ${adapter.name} started`)
       } catch (err) {
         this.ctx.logger?.warn?.(`dsh-messenger-gateway: ${adapter.name}: ${err.message}`)
@@ -170,7 +178,17 @@ export class Gateway {
     }
     const adapter = this.getAdapter(resolved.platform)
     if (!adapter?.sendTo) throw new Error(`adapter ${resolved.platform} unavailable`)
-    await adapter.sendTo(resolved.chatId, payload, { threadId: resolved.threadId })
+    try {
+      await adapter.sendTo(resolved.chatId, payload, { threadId: resolved.threadId })
+      this.stats.sent++
+    } catch (err) {
+      this.stats.errors++
+      if (isTopicGoneError(err)) {
+        this.logger?.warn?.(`messengerSend: topic gone for ${resolved.platform}:${resolved.chatId}:${resolved.threadId} — the chat/topic was deleted; skipping delivery`)
+        return
+      }
+      throw err
+    }
   }
 
   async messengerAsk(target, payload, timeoutMs = 300_000) {
@@ -179,7 +197,17 @@ export class Gateway {
     const token = makeAskToken()
     const { replyMarkup, callbackKeys } = buildInlineKeyboard(token, payload.buttons || [])
     indexCallbacks(this.callbackIndex, callbackKeys, token)
-    await adapter.sendTo(target.chatId, { text: payload.text, replyMarkup }, { threadId: target.threadId })
+    try {
+      await adapter.sendTo(target.chatId, { text: payload.text, replyMarkup }, { threadId: target.threadId })
+    } catch (err) {
+      // Never leave stale callback keys pointing at an unresolvable ask.
+      releaseCallbacks(this.callbackIndex, callbackKeys)
+      if (isTopicGoneError(err)) {
+        this.logger?.warn?.(`messengerAsk: topic gone for ${target.platform}:${target.chatId}:${target.threadId} — ask aborted (chat/topic deleted)`)
+        throw new Error('messenger.ask: chat or topic was deleted')
+      }
+      throw err
+    }
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pendingAsks.delete(token)
@@ -343,7 +371,12 @@ export class Gateway {
       }
       return reply('Активной сессии нет.')
     }
-    if (cmd === '/whoami') return reply(`Ваш id: ${userId}`)
+    if (cmd === '/whoami') {
+      const lines = [`Ваш 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) {
@@ -367,6 +400,10 @@ export class Gateway {
         ? `home: chat ${home.chatId}${home.threadId ? ` topic ${home.threadId}` : ''}`
         : 'home: не задан'
       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')
+      const mm = String(Math.floor((up % 3600) / 60)).padStart(2, '0')
+      const ss = String(up % 60).padStart(2, '0')
       return reply([
         'Messenger gateway',
         `адаптеры: ${[...this.adapters.keys()].join(', ') || '(нет)'}`,
@@ -376,6 +413,10 @@ export class Gateway {
         `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 ? 'да' : 'нет'}`,
+        `uptime: ${hh}:${mm}:${ss}`,
       ].join('\n'))
     }
     if (cmd === '/model') {
@@ -447,6 +488,24 @@ export class Gateway {
       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'}`)
     }
+    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')
+      }
+      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'}`)
+    }
+    if (cmd === '/mute') {
+      this.setMuted(chatId, true)
+      return reply('Уведомления в этот чат: выключены (/unmute)')
+    }
+    if (cmd === '/unmute') {
+      this.setMuted(chatId, false)
+      return reply('Уведомления в этот чат: включены')
+    }
     return reply(`Неизвестная команда ${cmd}. /help`)
   }
 
@@ -655,11 +714,13 @@ export class Gateway {
           await reply({ text: chunks[i] || undefined, files: i === 0 ? files : [] })
         }
       }
+      const chatTtsPref = this.chatTts.get(chat.target?.chatId)
       const speak = shouldSpeakReply({
         globalTts: Boolean(this.config.tts?.enabled),
         voiceMode: this.tg().voiceMode || 'mirror',
         inboundWasVoice: Boolean(inboundWasVoice),
         userPref: this.voicePrefs.get(userId),
+        chatPref: chatTtsPref,
       })
       if (speak && !signal.aborted) {
         const ttsText = prepareTtsText(answer, this.config.tts?.maxChars)

package/lib/index.js

@@ -244,6 +244,8 @@ export function apply(ctx, config) {
       lines.push(`error: ${reason.error?.message || reason.error?.code || 'unknown'}`)
     }
     const homeName = cfg.home || 'default'
+    const home = gw.messenger.home?.() || null
+    if (home && gw.isMuted?.(home.chatId)) return
     gw.messengerSend({ platform: 'telegram', home: homeName }, { text: lines.join('\n') })
       .catch((e) => ctx.logger?.warn?.(`notify bridge: ${e.message}`))
   }), 'dsh-messenger-gateway: notify bridge')

package/lib/telegram-errors.js

@@ -0,0 +1,41 @@
+// Network error classification for Telegram sends (mirrors Hermes adapter policy).
+//
+// The key distinction: some network failures mean the request NEVER left the
+// process (connect/pool timeout, ECONNRESET before send) → resending is safe.
+// Others (a generic timeout after the request may have reached Telegram) could
+// duplicate a message if we resend → do NOT retry.
+
+function rootCause(err) {
+  let e = err
+  let depth = 0
+  while (e && e.cause && e.cause !== e && depth < 10) {
+    e = e.cause
+    depth++
+  }
+  return e || err
+}
+
+// True when a resend cannot duplicate a message: the request did not reach Telegram.
+export function isResendSafeNetworkError(err) {
+  const c = rootCause(err)
+  const msg = String(c?.message || err?.message || '').toLowerCase()
+  if (/not sent to telegram|connect timeout|und_err_connect|econnreset|enotfound|econnrefused|ECONNRESET|ENOTFOUND|ECONNREFUSED/i.test(msg)) {
+    return true
+  }
+  // undici PoolTimeout message: "Request was *not* sent to Telegram."
+  if (/pool timeout|request was \*?not\*? sent/i.test(msg)) return true
+  return false
+}
+
+// True for a 409 from getUpdates: a second bot instance polls the same token.
+export function isPollingConflict(err) {
+  const msg = String(err?.message || '').toLowerCase()
+  return /terminated by other getupdates request|another bot instance is running|getupdates.*conflict|conflict.*getupdates/i.test(msg)
+}
+
+// True when the target chat/topic no longer exists (deleted/closed/upgraded).
+// Such sends should not be retried and any pending ask binding must be pruned.
+export function isTopicGoneError(err) {
+  const msg = String(err?.message || '').toLowerCase()
+  return /thread not found|message thread not found|topic[_ ]?(not found|closed|deleted)|chat (not found|was (upgraded|deleted))|group chat was (upgraded|deleted)/i.test(msg)
+}

package/lib/telegram-format.js

@@ -7,6 +7,105 @@ export function escapeHtml(text) {
 
 const PH = '\uE000'
 
+// Render inline markdown (bold/italic/code/links) inside already-HTML-escaped text.
+function renderInline(t) {
+  let s = escapeHtml(t)
+  s = s.replace(/\*\*([^*\n]+)\*\*/g, '<b>$1</b>')
+  s = s.replace(/`([^`\n]+)`/g, '<code>$1</code>')
+  s = s.replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (_, label, url) => `<a href="${escapeHtml(url)}">${label}</a>`)
+  s = s.replace(/(^|[^*])\*([^*\n]+)\*(?!\*)/g, '$1<i>$2</i>')
+  return s
+}
+
+function splitRow(line) {
+  let s = line.trim()
+  if (s.startsWith('|')) s = s.slice(1)
+  if (s.endsWith('|')) s = s.slice(0, -1)
+  return s.split('|').map((c) => c.trim())
+}
+
+function isTableDelimiter(line) {
+  const s = line.trim()
+  if (!s.startsWith('|') || !s.endsWith('|')) return false
+  const cells = s.split('|').slice(1, -1)
+  return cells.length > 0 && cells.every((c) => /^:?-+:?$/.test(c.trim()))
+}
+
+// GFM pipe tables → bold heading + bullet rows (Telegram HTML has no table syntax).
+function convertTables(text, stash) {
+  const lines = text.split('\n')
+  const out = []
+  let i = 0
+  while (i < lines.length) {
+    const line = lines[i]
+    if (line.includes('|') && i + 1 < lines.length && isTableDelimiter(lines[i + 1])) {
+      const headers = splitRow(line)
+      const rows = []
+      let j = i + 2
+      while (j < lines.length && lines[j].includes('|') && !isTableDelimiter(lines[j])) {
+        rows.push(splitRow(lines[j]))
+        j++
+      }
+      let blocks
+      if (headers.length === 2) {
+        // key/value table → bullet list, no separate heading row
+        blocks = rows.map((row) => `• <b>${renderInline(row[0] || '')}</b>: ${renderInline(row[1] || '')}`)
+      } else {
+        blocks = rows.map((row) => {
+          const heading = renderInline(row[0] || '')
+          const bullets = headers
+            .slice(1)
+            .map((h, idx) => {
+              const val = (row[idx + 1] || '').trim()
+              if (!val) return null
+              return `• ${renderInline(h)}: ${renderInline(val)}`
+            })
+            .filter(Boolean)
+          return bullets.length ? `<b>${heading}</b>\n${bullets.join('\n')}` : `<b>${heading}</b>`
+        })
+      }
+      out.push(stash(blocks.join('\n\n')))
+      i = j
+      continue
+    }
+    out.push(line)
+    i++
+  }
+  return out.join('\n')
+}
+
+// GFM task lists → checkbox glyphs.
+function convertTaskLists(text, stash) {
+  const lines = text.split('\n')
+  const out = []
+  let buf = []
+  const flush = () => {
+    if (buf.length) {
+      out.push(stash(buf.join('\n')))
+      buf = []
+    }
+  }
+  for (const line of lines) {
+    const m = line.match(/^(\s*)[-*]\s+\[([ xX])\]\s+(.*)$/)
+    if (m) {
+      buf.push(`${m[1]}${m[2].toLowerCase() === 'x' ? '☑' : '☐'} ${renderInline(m[3])}`)
+    } else {
+      flush()
+      out.push(line)
+    }
+  }
+  flush()
+  return out.join('\n')
+}
+
+// <details><summary>..</summary>..</details> → bold summary + body (no native collapse in HTML).
+function convertDetails(text, stash) {
+  return text.replace(
+    /<details\b[^>]*>\s*<summary>([\s\S]*?)<\/summary>([\s\S]*?)<\/details>/gi,
+    (_, summary, body) => stash(`<b>${renderInline(summary.trim())}</b>\n${renderInline(body.trim())}`),
+  )
+}
+
 /** Convert common Markdown from LLM replies to Telegram HTML parse_mode. */
 export function markdownToTelegramHtml(markdown) {
   let text = String(markdown ?? '')
@@ -20,6 +119,9 @@ export function markdownToTelegramHtml(markdown) {
 
   text = text.replace(/```([\s\S]*?)```/g, (_, code) => stash(`<pre><code>${escapeHtml(code.replace(/^\n/, '').replace(/\n$/, ''))}</code></pre>`))
   text = text.replace(/`([^`\n]+)`/g, (_, code) => stash(`<code>${escapeHtml(code)}</code>`))
+  text = convertTables(text, stash)
+  text = convertDetails(text, stash)
+  text = convertTaskLists(text, stash)
   text = escapeHtml(text)
   text = text.replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (_, label, url) => `<a href="${escapeHtml(url)}">${label}</a>`)
   text = text.replace(/\*\*([^*\n]+)\*\*/g, '<b>$1</b>')

package/lib/voice-prefs.js

@@ -33,7 +33,9 @@ export function createVoicePrefs(filePath) {
 }
 
 /** Decide whether to speak the reply. */
-export function shouldSpeakReply({ globalTts, voiceMode, inboundWasVoice, userPref }) {
+export function shouldSpeakReply({ globalTts, voiceMode, inboundWasVoice, userPref, chatPref }) {
+  if (chatPref === false) return false
+  if (chatPref === true) return true
   if (globalTts) return true
   if (userPref === true) return true
   if (userPref === false) return false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-messenger-gateway",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Telegram messenger bridge for DeepSeek Harness: sessions, steer, homes, inline asks, notify bridge, and optional TTS voice notes.",
   "license": "MIT",
   "type": "module",
@@ -52,14 +52,14 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-agent": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-agent-loop": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-host-webserver": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-session": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-settings": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-agent": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-agent-loop": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-llm": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-session": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-settings": "^0.1.1-rc.2",
     "@deepseek-ai/schemastery": "^3.18.1",
-    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6"
+    "@deepseek-ai/dsh-tools": "^0.1.1-rc.2"
   },
   "publishConfig": {
     "access": "public"