dsh-telegram-bot 0.1.0 → 0.1.2

package/README.md

@@ -4,7 +4,7 @@ Telegram bot for [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harn
 
 > Found a bug or have an idea? [Open an issue](https://github.com/Boobaw/dsh-telegram-bot/issues).
 
-The bot connects to Telegram, enforces the allowlists, and bridges DSH agent sessions to Telegram **DM topics**. The **All** topic stays global; every DSH session gets its own topic. The assistant answer is the first message and streams in place as text arrives; the current reasoning block and a rolling tool-call list update after it, then both transient messages are deleted when the answer is ready. A separate **System** topic mirrors bot lifecycle notifications, which also appear in **All**.
+The bot connects to Telegram, enforces the allowlists, and bridges DSH agent sessions to Telegram **DM topics**. The **All** topic stays global; every DSH session gets its own topic. The assistant answer is the first message and streams in place as text arrives; the current reasoning block and a rolling tool-call list update after it, then both transient messages are deleted when the answer is ready. Bot lifecycle notifications go to **All**.
 
 ## Features
 
@@ -14,26 +14,27 @@ The bot connects to Telegram, enforces the allowlists, and bridges DSH agent ses
 - **Allowed chats** — Telegram chat ids or `@channelnames`; empty means private chats only.
 - **Enable bot** toggle.
 - **Restart bot** button — reapplies the saved settings and restarts long polling.
-- **Quick controls on the Plugins page** — the bundle's detail page shows token state, access counts, and the same restart button. The bundle switch itself is the on/off control; turning the plugin off unmounts it and aborts polling.
+- **Plugins page** — the bundle page is informational and points to Settings → Telegram. The bundle switch above it is the plugin on/off control; turning it off unmounts the runtime and aborts polling.
 - **Agent bridge** — an ordinary text message in a session topic starts a DSH agent turn in that session, with assistant text streamed back.
-- **DM topics** — `/sessions` in **All** is the single place for DSH sessions: choose a workspace, then create a new session in it or open an existing one. The selected session continues in its own topic.
-- **All and System topics** — All is Telegram's default topic and the management hub; System receives bot lifecycle notifications, mirrored into All.
-- **Thinking and tool calls** — reasoning deltas and tool calls are mirrored into the topic, with independent **Show model thinking** / **Show tool calls** switches.
+- **DM topics** — `/sessions` in **All** is the single place for DSH sessions: choose a workspace, then create a new session in it or open an existing one. The selected session continues in its own topic. Requires **Threaded mode** in @BotFather → Bot Settings.
+- **All topic** — Telegram's default topic and the management hub; lifecycle notifications are posted there.
+- **Thinking and tool calls** — reasoning deltas and tool calls are mirrored into the topic, with independent **Show model thinking** / **Show tool calls** switches. Thinking is a 10-line rolling window; the tool-call message shows the last ten calls.
 - **Commands** — `/start`, `/help`, `/sessions`, `/stop`, `/status`, `/current`, `/menu`, `/rename`, `/last`, `/restart`, `/id`, `/ping`.
 - **Approval prompts** — when a tool asks for approval, the session topic gets a styled prompt with **Deny** and **Allow** inline buttons; the decision resolves the exact pending request.
+- **Structured questions** — `ask_user_question` requests render in the session topic with option buttons, multi-select, a custom-answer flow, and plan-review approve/decline choices.
 - **Session controls** — an inline 2×2 panel in each session topic: **Model** (Flash/Pro), **Effort** (off/low/high/max), **Mode** (permission preset), and **Context** (window, last request usage, and cache-hit percentage). Telegram reply keyboards are chat-wide, so the controls are a per-topic inline panel rather than a bottom keyboard.
-- **Recovery** — `/last [n]` shows the latest assistant answer(s) from the bound session, useful after switching between Web and Telegram. `/rename <name>` changes the Telegram topic title; `/restart` restarts the Telegram runtime; `/menu` reposts the bottom controls.
+- **Recovery** — `/last [n]` shows the latest assistant answer(s) from the bound session, useful after switching between Web and Telegram. `/rename <name>` changes the Telegram topic title; `/restart` restarts the Telegram runtime; `/menu` opens the inline session controls.
 - **Language** — bot messages and the Telegram command menu default to English; a Settings selector switches them to Russian.
-- **Formatting** — assistant Markdown (headings, bold, lists, code, links, tables) is converted to Telegram MarkdownV2.
-- **Command hints** — the runtime publishes the list with `setMyCommands`, so Telegram shows the commands and descriptions when the user types `/`. English is the default; Russian clients get localized descriptions.
+- **Formatting** — assistant Markdown (headings, bold, lists, code, links, tables) is converted to Telegram MarkdownV2. The same formatting is used for session previews and `/last`.
+- **Command hints** — the runtime publishes the list with `setMyCommands`, so Telegram shows the commands and descriptions when the user types `/`. The descriptions follow the selected Bot language; English is the default.
 - English and Russian page copy; Russian is registered as an optional language pack.
 
 ## Install
 
-From this checkout:
+From this checkout, run in the repository root:
 
 ```sh
-npx @deepseek-ai/dsh plugin --profile web add /home/boobaw/dsh-plugin-tg-bot
+npx @deepseek-ai/dsh plugin --profile web add .
 ```
 
 After publishing to npm:
@@ -44,7 +45,7 @@ npx @deepseek-ai/dsh plugin --profile web add dsh-telegram-bot
 
 `dsh plugin add` installs the package and selects its bundle in `dsh.profile.bundles` when the package declares `dsh.bundle`. Restart `dsh web` if the running profile does not pick the new bundle up through HMR.
 
-Then open **Settings → Telegram** (or **Plugins → dsh-telegram-bot**) in the Web UI.
+Then open **Settings → Telegram** (or **Plugins → Telegram Bot**) in the Web UI.
 
 ## Configure
 
@@ -67,10 +68,11 @@ The token field reports only whether a token is configured. A token supplied by
 ### First run
 
 1. Create a bot with [@BotFather](https://t.me/BotFather) and save its token in **Settings → Telegram**.
-2. Open the bot chat, tap the bot name and enable **Topics**. **All** is Telegram's default topic; the bot creates **System** for lifecycle notifications.
-3. Send `/start` in **All**. With an empty user list the bot replies with your user id and chat id.
-4. Add your user id to **Allowed users** and press **Save** (or **Restart bot**).
-5. In **All** send `/sessions` to create a new session or pick an existing DSH session. The dialog continues in its own topic.
+2. In @BotFather open the bot's **Bot Settings → Threaded mode** and enable it. Without this, private-chat topics cannot be created.
+3. Open the bot chat, tap the bot name and enable **Topics**. **All** is Telegram's default topic.
+4. Send `/start` in **All**. With an empty user list the bot replies with your user id and chat id, plus the Threaded-mode reminder.
+5. Add your user id to **Allowed users** and press **Save** (or **Restart bot**).
+6. In **All** send `/sessions` to create a new session or pick an existing DSH session. The dialog continues in its own topic.
 
 The runtime starts only when **Enable bot** is on, a token is configured, and the profile process is running. It logs connection and polling diagnostics with the `[telegram]` prefix. Runtime state is at `$DSH_HOME/telegram/status.json`, and the topic → session mapping is at `$DSH_HOME/telegram/state.json` (neither contains the token).
 
@@ -127,15 +129,13 @@ No browser and no port are opened. `Ctrl+C` stops the process; `$DSH_HOME/telegr
 
 ## Plugins page
 
-The bundle detail page in **Plugins** renders a compact card with:
+The bundle detail page in **Plugins** is a short informational panel:
 
-- token state and the current number of allowed users/chats;
-- **Restart bot**;
-- a pointer to **Settings → Telegram** for editing the full lists.
+- it points to **Settings → Telegram** for token, access lists, language and display options;
+- it lists the manual configuration files for headless setups;
+- it does not duplicate the settings controls.
 
-There is deliberately no bot on/off switch on this page: the bundle switch above the card disables the whole plugin, and the runtime's `ctx.effect` cleanup aborts polling when it unmounts. **Settings → Telegram → Enable bot** remains a soft pause that keeps the plugin loaded.
-
-The full page remains in Settings because allowlist editing needs room for chips and validation.
+The bundle switch above the panel is the plugin on/off control. **Settings → Telegram → Enable bot** is a soft pause that keeps the plugin loaded but stops polling.
 
 ## Security
 
@@ -178,11 +178,9 @@ A Git URL or tarball also works for DSH (`dsh plugin add github:you/dsh-telegram
 
 ## Roadmap
 
-1. Approval and question answerers with inline buttons.
-2. Tool-call cards and richer streaming presentation.
-3. File attachments and voice input.
-4. Model/preset selection from the chat.
-5. Multiple chats and group/topic routing.
+1. File attachments and voice input.
+2. Multiple chats and group/topic routing.
+3. Richer tool-result summaries.
 
 ## License
 

package/client.js

@@ -10,7 +10,7 @@ window.__ModuleLoader__.load({
     const { Button, SettingsSecretField, Switch } = primitives
     const h = React.createElement
 
-    /** Loader row id / settings namespace, equal to the package name. */
+    /** Loader row id / settings namespace; the npm package name is dsh-telegram-bot. */
     const NS = 'telegram-bot'
     /** Default credential reference holding the Telegram bot token. */
     const DEFAULT_TOKEN_REF = 'TELEGRAM_BOT_TOKEN'
@@ -51,7 +51,6 @@ window.__ModuleLoader__.load({
       saving: 'Saving…',
       saved: 'Saved.',
       restart: 'Restart bot',
-      restarting: 'Restarting…',
       restartRequested: 'Restart requested. Check Telegram or the DSH log.',
       restartFailed: 'The Host did not accept the restart request.',
       bundleSummary: 'Telegram bot',
@@ -61,20 +60,6 @@ window.__ModuleLoader__.load({
       pluginConfigSettings: 'plugin settings (cordis.patch.yml)',
       pluginConfigToken: 'bot token (credential store)',
       pluginConfigEnv: 'token fallback for headless deployments',
-      running: 'Running',
-      stopped: 'Stopped',
-      runtimeMissingShort: 'Host not loaded',
-      on: 'On',
-      off: 'Off',
-      pluginRuntimeHint: 'Runtime state from this DSH process. Turning the bundle off stops polling.',
-      pluginQuickControls: 'Quick controls',
-      pluginDisplay: 'Display',
-      bundleSettingsHint: 'Full allowlists are in Settings → Telegram.',
-      tokenConfiguredShort: 'token configured',
-      tokenMissingShort: 'no token',
-      usersShort: 'users',
-      chatsShort: 'chats',
-      bundleDisableHint: 'Turning the plugin off in Plugins stops polling.',
       hostNeedsRestart: 'The Telegram runtime is not loaded in this DSH process yet. Restart dsh web once; after that this page can restart the bot.',
       discard: 'Discard',
       saveFailed: 'The Host did not accept these values.',
@@ -121,7 +106,6 @@ window.__ModuleLoader__.load({
       saving: 'Сохранение…',
       saved: 'Сохранено.',
       restart: 'Перезапустить бота',
-      restarting: 'Перезапуск…',
       restartRequested: 'Запрошен перезапуск. Проверьте Telegram или лог DSH.',
       restartFailed: 'Host не принял запрос на перезапуск.',
       bundleSummary: 'Telegram-бот',
@@ -131,20 +115,6 @@ window.__ModuleLoader__.load({
       pluginConfigToken: 'токен бота (credential store)',
       pluginConfigEnv: 'fallback токена для headless',
       pluginPageLocation: 'Открой Settings → Telegram, чтобы настроить плагин.',
-      running: 'Работает',
-      stopped: 'Остановлен',
-      runtimeMissingShort: 'Host не загружен',
-      on: 'Вкл',
-      off: 'Выкл',
-      pluginRuntimeHint: 'Состояние runtime в этом процессе DSH. Выключение bundle останавливает polling.',
-      pluginQuickControls: 'Быстрые настройки',
-      pluginDisplay: 'Отображение',
-      bundleSettingsHint: 'Полные списки доступа — в Settings → Telegram.',
-      tokenConfiguredShort: 'токен настроен',
-      tokenMissingShort: 'нет токена',
-      usersShort: 'пользователей',
-      chatsShort: 'чатов',
-      bundleDisableHint: 'Выключение плагина в Plugins останавливает polling.',
       hostNeedsRestart: 'Telegram runtime ещё не загружен в этот процесс DSH. Перезапусти dsh web один раз; после этого кнопка рестарта заработает.',
       discard: 'Отменить',
       saveFailed: 'Host не принял эти значения.',
@@ -189,22 +159,9 @@ window.__ModuleLoader__.load({
       .dtb-message{min-height:20px;font-size:12px;line-height:20px}
       .dtb-messageOk{color:var(--dsw-alias-state-success-primary)}
       .dtb-messageError{color:var(--dsw-alias-state-error-primary)}
-      .dtb-bundle{display:flex;flex-direction:column;gap:12px}
       .dtb-plugin{display:flex;flex-direction:column;gap:16px;padding-top:4px}
-      .dtb-pluginTop{display:flex;flex-direction:column;gap:8px}
-      .dtb-bundleMeta{display:flex;flex-wrap:wrap;align-items:center;gap:8px}
-      .dtb-pluginGrid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:8px}
-      .dtb-stat{display:flex;flex-direction:column;gap:2px;padding:10px 12px;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;background:var(--dsw-alias-bg-layer-1)}
-      .dtb-statLabel{color:var(--dsw-alias-label-tertiary);font-size:11px;line-height:16px}
-      .dtb-statValue{font-size:15px;line-height:22px;font-weight:600}
-      .dtb-pluginSection{display:flex;flex-direction:column;gap:10px}
-      .dtb-pluginSectionTitle{margin:0;font-size:13px;font-weight:600;line-height:20px}
-      .dtb-pluginControls{display:flex;flex-direction:column;gap:10px}
-      .dtb-pluginControl{display:flex;align-items:center;justify-content:space-between;gap:16px}
-      .dtb-pluginActions{display:flex;align-items:center;gap:10px;flex-wrap:wrap}
       .dtb-notice{margin:0;padding:10px 12px;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;background:var(--dsw-alias-bg-layer-1);color:var(--dsw-alias-label-secondary);font-size:12px;line-height:18px}
       .dtb-loading{padding:16px 0;color:var(--dsw-alias-label-tertiary);font-size:13px}
-      .dtb-note{margin:0;color:var(--dsw-alias-label-tertiary);font-size:11px;line-height:17px}
       @media (max-width:560px){.dtb-toggleRow{align-items:flex-start;flex-direction:column;gap:8px}.dtb-footer{align-items:stretch;flex-direction:column}.dtb-footerActions{justify-content:flex-end}}
     `
 
@@ -715,11 +672,11 @@ window.__ModuleLoader__.load({
 
 
     /**
-     * Compact controls on the Plugins page's bundle detail. The full allowlists
-     * stay in Settings → Telegram; this card owns the restart and token/status
-     * summary. The bundle switch itself is the plugin's on/off control.
-     * @param props - locale reader, settings form, credential operations, view.
-     * @returns the summary line or the quick controls.
+     * Informational card on the Plugins page's bundle detail. All controls live
+     * in Settings → Telegram; this card only points there and lists the manual
+     * configuration files. The bundle switch is the plugin's on/off control.
+     * @param props - locale reader and slot view.
+     * @returns the summary line or the settings pointer.
      */
     function BundleSettings(props) {
       const { t, view } = props
@@ -809,7 +766,7 @@ window.__ModuleLoader__.load({
                 name: 'plugins.bundle.config',
                 key: 'dsh-telegram-bot',
                 locale: NS,
-                inject: () => ({ t, form, token }),
+                inject: () => ({ t }),
               },
               BundleSettings,
             ),

package/index.js

@@ -1,14 +1,10 @@
 /**
  * Host half of dsh-telegram-bot.
  *
- * It owns two things:
- *  - the editable settings namespace (`enabled`, allowlists, restart request);
- *  - a deliberately small Telegram long-polling runtime, so the Restart button
- *    and the allowlists do something real before the full agent bridge lands.
- *
- * The runtime answers only a handful of diagnostic commands. Wiring Telegram
- * chats to DSH agents is the next step; keeping this layer small means a bad
- * token or a conflicting poller can never take the Host down.
+ * It owns the editable settings namespace, the Telegram long-polling runtime,
+ * the DM-topic session browser, and the bridge between Telegram topics and
+ * DSH agent sessions. Keeping the runtime isolated means a bad token or a
+ * conflicting poller cannot take the Host down.
  */
 import z from '@deepseek-ai/schemastery'
 import { mkdir, readFile, rename, writeFile } from 'node:fs/promises'
@@ -18,13 +14,11 @@ import { homedir } from 'node:os'
 import { basename, join, resolve } from 'node:path'
 import telegramifyMarkdown from 'telegramify-markdown'
 
-/** Loader row id; keep it equal to the package name and the client namespace. */
+/** Loader row id and settings namespace; the npm package name stays dsh-telegram-bot. */
 export const name = 'telegram-bot'
 
 /** Default credential reference holding the bot token. */
 const DEFAULT_TOKEN_REF = 'TELEGRAM_BOT_TOKEN'
-/** Telegram Bot API root; the token is appended per request. */
-const API_ROOT = 'https://api.telegram.org'
 /** Long-poll timeout requested from Telegram, in seconds. */
 const POLL_TIMEOUT_SECONDS = 25
 /** Pause after a failed poll before trying again, in milliseconds. */
@@ -156,6 +150,19 @@ function fitAnswerText(text, limit = ANSWER_MARKDOWN_LIMIT) {
   return prefix.length === 0 ? '' : `${prefix}…`
 }
 
+/**
+ * Trim a session preview at a line boundary so formatting is not cut mid-construct.
+ * @param text - raw assistant Markdown.
+ * @param limit - maximum characters.
+ * @returns clipped preview.
+ */
+function clipPreview(text, limit = 2500) {
+  if (text.length <= limit) return text
+  const cut = text.slice(0, limit)
+  const newline = cut.lastIndexOf('\n')
+  return newline > limit / 2 ? cut.slice(0, newline) : cut
+}
+
 /**
  * Split raw Markdown into chunks whose converted MarkdownV2 fits Telegram.
  * @param text - complete answer.
@@ -404,27 +411,23 @@ async function loadState() {
   return { version: 2, sessions: {}, threads: {} }
 }
 
-/** Durable control/system topic ids for the bot chat. */
+/** Durable control-chat id for lifecycle notifications. */
 const TOPICS_PATH = join(STATUS_DIR, 'topics.json')
 
 /**
- * Read the control/system topic mapping.
- * @returns the mapping, or empty ids when absent.
+ * Read the control chat used for lifecycle notifications.
+ * @returns the chat id, or 0 when absent.
  */
 async function loadTopics() {
   try {
     const parsed = JSON.parse(await readFile(TOPICS_PATH, 'utf8'))
-    if (parsed !== null && typeof parsed === 'object') {
-      return {
-        chatId: typeof parsed.chatId === 'number' ? parsed.chatId : 0,
-        allThreadId: typeof parsed.allThreadId === 'number' ? parsed.allThreadId : 0,
-        systemThreadId: typeof parsed.systemThreadId === 'number' ? parsed.systemThreadId : 0,
-      }
+    if (parsed !== null && typeof parsed === 'object' && typeof parsed.chatId === 'number') {
+      return { chatId: parsed.chatId }
     }
   } catch {
-    // Topics are optional until /start creates them.
+    // The control chat is learned on the first /start.
   }
-  return { chatId: 0, allThreadId: 0, systemThreadId: 0 }
+  return { chatId: 0 }
 }
 
 /** Last published runtime snapshot, mirrored to a local diagnostics file. */
@@ -436,7 +439,7 @@ let runtimeStatus = {
   transport: 'https-ipv4',
   version: '0.3.0',
   agentBridge: 'v1',
-  codeRevision: 'format-4',
+  codeRevision: 'preview-format',
   lastPollAt: 0,
   lastMessageAt: 0,
   lastChatId: null,
@@ -489,8 +492,8 @@ export function apply(ctx, config) {
   const chats = new Map()
   /** Agent API calls use this lifetime; the bot polling lifetime is separate. */
   const bridgeAbort = new AbortController()
-  /** Control/System topic ids. */
-  let topics = { chatId: 0, allThreadId: 0, systemThreadId: 0 }
+  /** Control chat id used for lifecycle notifications. */
+  let topics = { chatId: 0 }
   /** Resolves after the mapping and topic files have been read. */
   const stateReady = Promise.all([
     loadState().then((loaded) => { state = loaded }),
@@ -540,12 +543,12 @@ export function apply(ctx, config) {
         thinkingMessageId: null,
         thinkingTimer: null,
         thinkingLastText: '',
-        thinkingIsStatus: false,
         tools: [],
         toolMessageId: null,
         toolTimer: null,
         toolLastText: '',
         boundAgent: undefined,
+        questionAgent: undefined,
       }
       chats.set(key, chat)
     }
@@ -577,19 +580,6 @@ export function apply(ctx, config) {
     await persistState()
   }
 
-  /**
-   * Remove one topic's session binding without deleting the session.
-   * @param chat - chat bridge state.
-   */
-  async function unbindSession(chat) {
-    const sessionId = chat.sessionId
-    chat.sessionId = undefined
-    chat.boundAgent = undefined
-    delete state.threads[chat.key]
-    if (typeof sessionId === 'string') delete state.sessions[sessionId]
-    await persistState()
-  }
-
   /** @returns the configured session working directory. */
   function cwdOf() {
     const configured = readLive(config.cwd, process.cwd())
@@ -1004,7 +994,7 @@ export function apply(ctx, config) {
   }
 
   /**
-   * Send one HTML-safe diagnostic message.
+   * Send one HTML-formatted message.
    * @param chatId - target chat.
    * @param text - message body.
    * @param signal - runtime lifetime.
@@ -1141,6 +1131,99 @@ export function apply(ctx, config) {
     }
   }
 
+  /**
+   * Send one Markdown-formatted message with an inline keyboard.
+   * @param chatId - target chat.
+   * @param threadId - topic thread.
+   * @param text - raw Markdown body.
+   * @param keyboard - inline keyboard rows.
+   * @param signal - request lifetime.
+   * @returns the Bot API result, or undefined.
+   */
+  async function sendKeyboardMarkdown(chatId, threadId, text, keyboard, signal) {
+    const body = toTelegramMarkdown(text)
+    try {
+      return await call('sendMessage', {
+        chat_id: chatId,
+        ...(threadId === undefined || threadId === 0 ? {} : { message_thread_id: threadId }),
+        text: body,
+        parse_mode: 'MarkdownV2',
+        reply_markup: { inline_keyboard: keyboard },
+      }, signal)
+    } catch (error) {
+      const detail = messageOf(error)
+      if (!signal.aborted) {
+        warn(`MarkdownV2 keyboard send failed, falling back: ${detail}`)
+        await publishStatus({ lastFormatFallback: detail })
+      }
+      return call('sendMessage', {
+        chat_id: chatId,
+        ...(threadId === undefined || threadId === 0 ? {} : { message_thread_id: threadId }),
+        text,
+        reply_markup: { inline_keyboard: keyboard },
+      }, signal).catch(() => undefined)
+    }
+  }
+
+  /**
+   * Edit one Markdown-formatted message and replace its keyboard.
+   * @param chatId - target chat.
+   * @param threadId - topic thread.
+   * @param messageId - message to edit.
+   * @param text - raw Markdown body.
+   * @param keyboard - inline keyboard rows.
+   * @param signal - request lifetime.
+   * @returns true when the edit succeeded.
+   */
+  async function editKeyboardMarkdown(chatId, threadId, messageId, text, keyboard, signal) {
+    const body = toTelegramMarkdown(text)
+    try {
+      await call('editMessageText', {
+        chat_id: chatId,
+        message_id: messageId,
+        ...(threadId === undefined || threadId === 0 ? {} : { message_thread_id: threadId }),
+        text: body,
+        parse_mode: 'MarkdownV2',
+        reply_markup: { inline_keyboard: keyboard },
+      }, signal)
+      return true
+    } catch (error) {
+      const detail = messageOf(error)
+      if (/not modified/i.test(detail)) return true
+      if (!signal.aborted) {
+        warn(`MarkdownV2 keyboard edit failed, falling back: ${detail}`)
+        await publishStatus({ lastFormatFallback: detail })
+      }
+      try {
+        await call('editMessageText', {
+          chat_id: chatId,
+          message_id: messageId,
+          ...(threadId === undefined || threadId === 0 ? {} : { message_thread_id: threadId }),
+          text,
+          reply_markup: { inline_keyboard: keyboard },
+        }, signal)
+        return true
+      } catch {
+        return false
+      }
+    }
+  }
+
+  /**
+   * Render a Markdown main menu, editing the previous one when possible.
+   * @param chatId - target chat.
+   * @param threadId - topic thread.
+   * @param messageId - panel message to edit.
+   * @param text - raw Markdown body.
+   * @param keyboard - inline keyboard rows.
+   * @param signal - request lifetime.
+   * @returns resolves after the send/edit.
+   */
+  async function renderMenuMarkdown(chatId, threadId, messageId, text, keyboard, signal) {
+    if (messageId !== undefined && await editKeyboardMarkdown(chatId, threadId, messageId, text, keyboard, signal)) return
+    await sendKeyboardMarkdown(chatId, threadId, text, keyboard, signal)
+  }
+
   /**
    * Split text into Telegram-sized chunks.
    * @param text - full response.
@@ -1174,6 +1257,8 @@ export function apply(ctx, config) {
 
   /** Pending inline approval prompts keyed by short callback id. */
   const pendingApprovals = new Map()
+  /** Pending structured user questions keyed by short callback id. */
+  const pendingQuestions = new Map()
 
   /**
    * Resolve one pending approval and update its prompt in place.
@@ -1255,6 +1340,292 @@ export function apply(ctx, config) {
     })
   }
 
+  /**
+   * Find a pending question batch for one Telegram topic.
+   * @param chatId - Telegram chat id.
+   * @param threadId - topic thread.
+   * @returns the pending batch, if any.
+   */
+  function pendingQuestionFor(chatId, threadId) {
+    for (const pending of pendingQuestions.values()) {
+      if (pending.chatId === chatId && pending.threadId === threadId) return pending
+    }
+    return undefined
+  }
+
+  /**
+   * Render the current question prompt as raw Markdown.
+   * @param pending - in-flight question batch.
+   * @returns Markdown body.
+   */
+  function questionText(pending) {
+    const question = pending.questions[pending.index]
+    const lines = []
+    if (question.header !== undefined) lines.push(`**${question.header}**`)
+    if (question.intent?.kind === 'plan-review') lines.push(`**${tr('Plan review', 'Проверка плана')}**`)
+    lines.push(question.question)
+    if (question.detail !== undefined) {
+      const detail = question.detail.length > 3000 ? `${question.detail.slice(0, 2999)}…` : question.detail
+      lines.push('', detail)
+    }
+    lines.push('', `_${tr('Question', 'Вопрос')} ${pending.index + 1}/${pending.questions.length}_`)
+    if (pending.awaitingCustom) lines.push(`**${tr('Reply to this message with your answer.', 'Ответь на это сообщение своим вариантом.')}**`)
+    else if ((question.options ?? []).length === 0) lines.push(`**${tr('Reply to this message with your answer.', 'Ответь на это сообщение своим вариантом.')}**`)
+    return lines.join('\n')
+  }
+
+  /**
+   * Build the inline keyboard for the current question.
+   * @param pending - in-flight question batch.
+   * @returns keyboard rows.
+   */
+  function questionKeyboard(pending) {
+    const question = pending.questions[pending.index]
+    const rows = []
+    for (const [index, option] of (question.options ?? []).slice(0, 8).entries()) {
+      const mark = pending.selected.has(option.label) ? '✅ ' : ''
+      rows.push([{ text: `${mark}${shortLabel(option.label, 50)}`, callback_data: `q:${pending.id}:${index}` }])
+    }
+    if (question.multiSelect === true) {
+      rows.push([{ text: tr('✅ Done', '✅ Готово'), callback_data: `q:${pending.id}:done` }])
+    }
+    if ((question.options ?? []).length > 0) {
+      rows.push([{ text: tr('✍️ Custom answer', '✍️ Свой ответ'), callback_data: `q:${pending.id}:custom` }])
+    }
+    return rows
+  }
+
+  /**
+   * Send or update the current question prompt in its topic.
+   * @param pending - in-flight question batch.
+   * @returns true when Telegram accepted the prompt.
+   */
+  async function sendQuestionPrompt(pending) {
+    const question = pending.questions[pending.index]
+    pending.awaitingCustom = (question.options ?? []).length === 0
+    const keyboard = pending.awaitingCustom ? [] : questionKeyboard(pending)
+    const result = await sendKeyboardMarkdown(
+      pending.chatId,
+      pending.threadId,
+      questionText(pending),
+      keyboard,
+      pending.signal,
+    )
+    if (result?.message_id === undefined) return false
+    pending.messageId = result.message_id
+    return true
+  }
+
+  /**
+   * Finish a question batch and resolve the DSH request.
+   * @param pending - completed batch.
+   */
+  function finishQuestions(pending) {
+    if (!pendingQuestions.delete(pending.id)) return
+    pending.signal?.removeEventListener('abort', pending.onAbort)
+    pending.resolve({ answers: pending.answers })
+    void editKeyboardMarkdown(
+      pending.chatId,
+      pending.threadId,
+      pending.messageId,
+      `✅ **${tr('Answer recorded', 'Ответ принят')}**`,
+      [],
+      bridgeAbort.signal,
+    )
+  }
+
+  /**
+   * Record one answer and advance to the next question.
+   * @param pending - in-flight batch.
+   * @param selected - selected option labels.
+   * @param custom - optional free-text answer.
+   * @param signal - request lifetime.
+   */
+  async function completeQuestion(pending, selected, custom, signal) {
+    if (pending.busy) return
+    pending.busy = true
+    try {
+      const question = pending.questions[pending.index]
+      pending.answers.push({
+        id: question.id,
+        selected,
+        ...(custom === undefined || custom.length === 0 ? {} : { custom }),
+      })
+      const summary = [
+        `✅ **${tr('Answer recorded', 'Ответ принят')}**`,
+        '',
+        question.question,
+        ...(selected.length > 0 ? [`${tr('Selected', 'Выбрано')}: ${selected.join(', ')}`] : []),
+        ...(custom !== undefined && custom.length > 0 ? [`${tr('Custom', 'Свой ответ')}: ${custom}`] : []),
+      ].join('\n')
+      await editKeyboardMarkdown(pending.chatId, pending.threadId, pending.messageId, summary, [], signal)
+      pending.selected = new Set()
+      pending.awaitingCustom = false
+      pending.index += 1
+      if (pending.index < pending.questions.length) {
+        if (!await sendQuestionPrompt(pending)) {
+          pendingQuestions.delete(pending.id)
+          pending.signal?.removeEventListener('abort', pending.onAbort)
+          pending.reject(new Error('Telegram could not display the next question'))
+        }
+      } else {
+        finishQuestions(pending)
+      }
+    } finally {
+      pending.busy = false
+    }
+  }
+
+  /**
+   * Ask the Telegram user one structured question batch.
+   * @param agent - requesting agent.
+   * @param chat - chat bridge state.
+   * @param req - user-questions request.
+   * @param next - downstream answerer chain.
+   * @returns the structured answer.
+   */
+  async function requestUserQuestions(agent, chat, req, next) {
+    if (chat.boundAgent !== agent || typeof chat.sessionId !== 'string') return next()
+    if (pendingQuestionFor(chat.chatId, chat.threadId) !== undefined) return next()
+    const signal = req.signal ?? bridgeAbort.signal
+    if (signal.aborted) return next()
+    const id = randomUUID().replaceAll('-', '').slice(0, 10)
+    let resolvePromise
+    let rejectPromise
+    const promise = new Promise((resolve, reject) => {
+      resolvePromise = resolve
+      rejectPromise = reject
+    })
+    const pending = {
+      id,
+      chatId: chat.chatId,
+      threadId: chat.threadId,
+      signal,
+      questions: Array.isArray(req.questions) ? req.questions : [],
+      index: 0,
+      answers: [],
+      selected: new Set(),
+      awaitingCustom: false,
+      busy: false,
+      messageId: undefined,
+      resolve: resolvePromise,
+      reject: rejectPromise,
+      onAbort: undefined,
+    }
+    if (pending.questions.length === 0) return next()
+    pending.onAbort = () => {
+      if (!pendingQuestions.delete(id)) return
+      signal.removeEventListener('abort', pending.onAbort)
+      rejectPromise(signal.reason ?? new Error('User question cancelled'))
+      if (pending.messageId !== undefined) {
+        void editKeyboardMarkdown(
+          pending.chatId,
+          pending.threadId,
+          pending.messageId,
+          `⏹ **${tr('Question cancelled', 'Вопрос отменён')}**`,
+          [],
+          bridgeAbort.signal,
+        )
+      }
+    }
+    signal.addEventListener('abort', pending.onAbort, { once: true })
+    pendingQuestions.set(id, pending)
+    let sent = false
+    try {
+      sent = await sendQuestionPrompt(pending)
+    } catch (error) {
+      if (!signal.aborted) warn(`user question prompt failed: ${messageOf(error)}`)
+    }
+    if (!sent) {
+      pendingQuestions.delete(id)
+      signal.removeEventListener('abort', pending.onAbort)
+      return next()
+    }
+    return promise
+  }
+
+  /**
+   * Handle one callback belonging to a pending user question.
+   * @param ref - callback payload after `q:`.
+   * @param chatId - Telegram chat id.
+   * @param threadId - topic thread.
+   * @param signal - request lifetime.
+   * @returns true when the callback belonged to a question.
+   */
+  async function handleQuestionCallback(ref, chatId, threadId, signal) {
+    const colon = ref.indexOf(':')
+    const id = colon === -1 ? ref : ref.slice(0, colon)
+    const action = colon === -1 ? '' : ref.slice(colon + 1)
+    const pending = pendingQuestions.get(id)
+    if (pending === undefined || pending.chatId !== chatId || pending.threadId !== threadId) {
+      await send(chatId, tr('This question is already closed.', 'Этот вопрос уже закрыт.'), signal, threadId)
+      return true
+    }
+    if (pending.busy) return true
+    const question = pending.questions[pending.index]
+    if (action === 'custom') {
+      pending.awaitingCustom = true
+      await editKeyboardMarkdown(pending.chatId, pending.threadId, pending.messageId, questionText(pending), [], signal)
+      return true
+    }
+    if (action === 'done') {
+      await completeQuestion(pending, [...pending.selected], undefined, signal)
+      return true
+    }
+    const optionIndex = Number.parseInt(action, 10)
+    if (!Number.isFinite(optionIndex) || question.options?.[optionIndex] === undefined) return true
+    const label = question.options[optionIndex].label
+    if (question.multiSelect === true) {
+      if (pending.selected.has(label)) pending.selected.delete(label)
+      else pending.selected.add(label)
+      await editKeyboardMarkdown(pending.chatId, pending.threadId, pending.messageId, questionText(pending), questionKeyboard(pending), signal)
+      return true
+    }
+    await completeQuestion(pending, [label], undefined, signal)
+    return true
+  }
+
+  /**
+   * Consume a free-text answer for the active question in this topic.
+   * @param chat - chat bridge state.
+   * @param text - user message.
+   * @param signal - request lifetime.
+   * @returns true when the message was an answer.
+   */
+  async function consumeQuestionReply(chat, text, signal) {
+    const command = text.trim().split(/\s+/u)[0]?.toLowerCase()
+    if (BOT_COMMANDS.some((entry) => `/${entry.command}` === command)) return false
+    const pending = pendingQuestionFor(chat.chatId, chat.threadId)
+    if (pending === undefined || !pending.awaitingCustom) return false
+    const question = pending.questions[pending.index]
+    const selected = question.multiSelect === true ? [...pending.selected] : []
+    await completeQuestion(pending, selected, text.trim(), signal)
+    return true
+  }
+
+  /**
+   * Cancel any pending questions in one topic.
+   * @param chat - chat bridge state.
+   */
+  function cancelQuestionsForChat(chat) {
+    for (const pending of [...pendingQuestions.values()]) {
+      if (pending.chatId !== chat.chatId || pending.threadId !== chat.threadId) continue
+      pendingQuestions.delete(pending.id)
+      pending.signal?.removeEventListener('abort', pending.onAbort)
+      pending.reject(new Error('Question cancelled by /stop'))
+      if (pending.messageId !== undefined) {
+        void editKeyboardMarkdown(
+          pending.chatId,
+          pending.threadId,
+          pending.messageId,
+          `⏹ **${tr('Question cancelled', 'Вопрос отменён')}**`,
+          [],
+          bridgeAbort.signal,
+        )
+      }
+    }
+  }
+
   /**
    * Register stream/error listeners on one live agent.
    * @param agent - agent to observe.
@@ -1278,6 +1649,13 @@ export function apply(ctx, config) {
         return requestApproval(agent, chat, req, next)
       }, { prepend: true })
     }
+    if (chat.questionAgent !== agent) {
+      chat.questionAgent = agent
+      agent.ctx.on('user-questions/request', (req, next) => {
+        if (chat.boundAgent !== agent) return next()
+        return requestUserQuestions(agent, chat, req, next)
+      }, { prepend: true })
+    }
   }
 
   /**
@@ -1499,7 +1877,6 @@ export function apply(ctx, config) {
     chat.thinkingText = ''
     chat.thinkingLastText = ''
     chat.thinkingMessageId = null
-    chat.thinkingIsStatus = false
     chat.tools = []
     chat.toolLastText = ''
     chat.toolMessageId = null
@@ -1625,7 +2002,6 @@ export function apply(ctx, config) {
     }
     if (frame.type === 'chunk' && frame.chunk?.type === 'reasoning-delta') {
       if (readLive(config.showThinking, true) !== true) return
-      chat.thinkingIsStatus = false
       chat.thinkingText += frame.chunk.text
       scheduleThinking(chat)
       return
@@ -1669,7 +2045,7 @@ export function apply(ctx, config) {
   }
 
   /**
-   * Flush the final assistant text, replacing or splitting the placeholder.
+   * Flush the final assistant text into the first answer message and split it.
    * @param chat - chat bridge state.
    */
   async function finalizeChat(chat) {
@@ -1854,46 +2230,30 @@ export function apply(ctx, config) {
   }
 
   /**
-   * Ensure the All and System topics exist for this control chat.
-   * @param chatId - chat with Topics enabled.
-   * @param signal - request lifetime.
+   * Remember the chat that owns lifecycle notifications (All, thread 0).
+   * @param chatId - control chat id.
    */
-  async function ensureTopics(chatId, signal) {
-    if (topics.chatId === chatId && topics.systemThreadId !== 0) {
-      if (topics.allThreadId !== 0) {
-        topics.allThreadId = 0
-        await writeFile(TOPICS_PATH, JSON.stringify(topics, null, 2) + '\n', { mode: 0o600 })
-      }
-      return
-    }
-    try {
-      const systemThreadId = await createTopic(chatId, 'System', signal)
-      topics = { chatId, allThreadId: 0, systemThreadId: systemThreadId ?? 0 }
-      await mkdir(STATUS_DIR, { recursive: true })
-      await writeFile(TOPICS_PATH, JSON.stringify(topics, null, 2) + '\n', { mode: 0o600 })
-    } catch (error) {
-      if (!signal.aborted) warn(`ensureTopics failed: ${messageOf(error)}`)
-    }
+  async function rememberControlChat(chatId) {
+    if (topics.chatId === chatId) return
+    topics = { chatId }
+    await mkdir(STATUS_DIR, { recursive: true })
+    await writeFile(TOPICS_PATH, JSON.stringify(topics, null, 2) + '\n', { mode: 0o600 })
   }
 
   /**
-   * Publish a system notification to System and All.
+   * Publish a lifecycle notification into All.
    * @param text - HTML-safe body.
    * @param signal - request lifetime.
    */
-  async function notifySystem(text, signal) {
+  async function notifyAll(text, signal) {
     if (topics.chatId === 0) return
-    const ids = [...new Set([topics.systemThreadId, topics.allThreadId])]
-    for (const threadId of ids) {
-      await call('sendMessage', {
-        chat_id: topics.chatId,
-        ...(threadId === 0 ? {} : { message_thread_id: threadId }),
-        text,
-        parse_mode: 'HTML',
-      }, signal).catch((error) => {
-        if (!signal.aborted) warn(`system notification failed: ${messageOf(error)}`)
-      })
-    }
+    await call('sendMessage', {
+      chat_id: topics.chatId,
+      text,
+      parse_mode: 'HTML',
+    }, signal).catch((error) => {
+      if (!signal.aborted) warn(`lifecycle notification failed: ${messageOf(error)}`)
+    })
   }
 
   /** @returns the display name for a permission preset. */
@@ -1922,7 +2282,7 @@ export function apply(ctx, config) {
     return [
       [
         { text: `🤖 ${modelLabel(current.model)}`, callback_data: 'o:model' },
-        { text: `🧠 ${tr('Effort', 'Режим')}: ${effortLabel(current.reasoningEffort)}`, callback_data: 'o:effort' },
+        { text: `🧠 ${tr('Effort', 'Усилие')}: ${effortLabel(current.reasoningEffort)}`, callback_data: 'o:effort' },
       ],
       [
         { text: `🛡 ${permissionLabel(permission)}`, callback_data: 'o:mode' },
@@ -2103,7 +2463,7 @@ export function apply(ctx, config) {
         const message = messageOf(error).toLowerCase()
         if (message.includes('duplicate') || message.includes('already')) continue
         if (message.includes('forum') || message.includes('topic')) {
-          throw new Error(tr('Enable Topics in the bot chat: tap the bot name → Topics.', 'Включи Topics в чате с ботом: имя бота сверху → Topics.'))
+          throw new Error(tr('Enable Threaded mode in @BotFather → Bot Settings, then enable Topics in the bot chat (tap the bot name → Topics).', 'Включи Threaded mode в @BotFather → Bot Settings, затем включи Topics в чате с ботом (имя бота сверху → Topics).'))
         }
         throw error
       }
@@ -2186,10 +2546,30 @@ export function apply(ctx, config) {
    * @param signal - request lifetime.
    * @returns topic record, or undefined.
    */
+  async function deliverSessionTopic(record, chatId, signal) {
+    const preview = await lastAssistantText(record.sessionId)
+    const title = record.title || await sessionTitle(record.sessionId)
+    const delivered = await sendKeyboardMarkdown(
+      chatId,
+      record.threadId,
+      `📂 **${title}**\n\n${preview.length > 0 ? clipPreview(preview) : tr('No assistant messages yet.', 'Пока нет ответов ассистента.')}\n\n${tr('Send a message to continue this session.', 'Напиши сообщение, чтобы продолжить эту сессию.')}`,
+      [],
+      signal,
+    )
+    if (delivered === undefined) return false
+    await sendMenu(chatId, record.threadId, await chatFor(chatId, record.threadId), signal)
+    return true
+  }
+
   async function openTopicForSession(sessionId, chatId, signal) {
     const existing = state.sessions[sessionId]
     if (existing !== undefined && existing.chatId === chatId && typeof existing.threadId === 'number') {
-      return existing
+      // Re-open the stored topic and make it visible in Telegram. If the
+      // thread was deleted, drop the stale mapping and create a fresh one.
+      if (await deliverSessionTopic(existing, chatId, signal)) return existing
+      delete state.sessions[sessionId]
+      delete state.threads[`${chatId}:${existing.threadId}`]
+      await persistState()
     }
     const title = await sessionTitle(sessionId)
     const records = await ctx.get('sessionQuery')?.listSessions(signal)
@@ -2200,16 +2580,8 @@ export function apply(ctx, config) {
     state.sessions[sessionId] = record
     state.threads[`${chatId}:${threadId}`] = sessionId
     await persistState()
-    await notifySystem(`📂 ${tr('Session opened', 'Открыта сессия')} <code>${escapeHtml(sessionId)}</code>`, signal)
-    const preview = await lastAssistantText(sessionId)
-    await sendKeyboard(
-      chatId,
-      threadId,
-      `📂 <b>${escapeHtml(title)}</b>\n\n${preview.length > 0 ? escapeHtml(preview.slice(0, 1200)) : tr('No assistant messages yet.', 'Пока нет ответов ассистента.')}\n\n${tr('Send a message to continue this session.', 'Напиши сообщение, чтобы продолжить эту сессию.')}`,
-      [],
-      signal,
-    )
-    await sendMenu(chatId, threadId, await chatFor(chatId, threadId), signal)
+    await notifyAll(`📂 ${tr('Session opened', 'Открыта сессия')} <code>${escapeHtml(sessionId)}</code>`, signal)
+    await deliverSessionTopic(record, chatId, signal)
     return record
   }
 
@@ -2299,10 +2671,10 @@ export function apply(ctx, config) {
     const record = records?.find((entry) => entry.header.id === sessionId)
     const title = await sessionTitle(sessionId, record?.header)
     const text =
-      `<b>${escapeHtml(title)}</b>\n` +
-      `${tr('Workspace', 'Workspace')}: <code>${escapeHtml(record?.header.cwd ?? 'unknown')}</code>\n` +
+      `**${title}**\n` +
+      `${tr('Workspace', 'Workspace')}: \`${String(record?.header.cwd ?? 'unknown').replaceAll('`', '\\`')}\`\n` +
       `${tr('Status', 'Статус')}: ${record?.live ? tr('live', 'активна') : tr('persisted', 'сохранена')}\n\n` +
-      `${preview.length > 0 ? escapeHtml(preview.slice(0, 1600)) : tr('No assistant messages yet.', 'Пока нет ответов ассистента.')}`
+      `${preview.length > 0 ? clipPreview(preview) : tr('No assistant messages yet.', 'Пока нет ответов ассистента.')}`
     const workspace = ctx.get('workspaceRegistry')?.list()
       ?.find((entry) => entry.path === record?.header.cwd)
     const rows = []
@@ -2317,7 +2689,7 @@ export function apply(ctx, config) {
       text: tr('⬅️ Back', '⬅️ Назад'),
       callback_data: `w:${workspaceRef}`,
     }])
-    await renderMenu(chatId, threadId, messageId, text, rows, signal)
+    await renderMenuMarkdown(chatId, threadId, messageId, text, rows, signal)
   }
 
   /**
@@ -2355,6 +2727,10 @@ export function apply(ctx, config) {
         settleApproval(id, action === 'y' ? 'allowed-once' : 'rejected')
         return
       }
+      if (prefix === 'q') {
+        await handleQuestionCallback(ref, chat.id, threadId, signal)
+        return
+      }
       if (prefix === 'o') {
         const chatState = await chatFor(chat.id, threadId)
         if (typeof chatState.sessionId !== 'string') {
@@ -2484,8 +2860,7 @@ export function apply(ctx, config) {
   }
 
   /**
-   * Answer one authorized message. This is intentionally a diagnostic surface
-   * until the DSH Agent bridge replaces it.
+   * Handle one authorized Telegram message and dispatch its command or prompt.
    * @param message - Telegram message.
    * @param signal - runtime lifetime.
    * @param type - Telegram update key, for diagnostics.
@@ -2533,8 +2908,8 @@ export function apply(ctx, config) {
         await send(
           chat.id,
           tr(
-            `Setup mode.\nYour user id: <code>${from.id}</code>\nYour chat id: <code>${chat.id}</code>\n\nAdd the user id to <b>Settings → Telegram → Allowed users</b>, then press Restart.`,
-            `Режим настройки.\nТвой user id: <code>${from.id}</code>\nТвой chat id: <code>${chat.id}</code>\n\nДобавь user id в <b>Settings → Telegram → Allowed users</b> и нажми Restart.`,
+            `Setup mode.\nYour user id: <code>${from.id}</code>\nYour chat id: <code>${chat.id}</code>\n\nAdd the user id to <b>Settings → Telegram → Allowed users</b>, then press Restart.\n\nBefore opening sessions, enable <b>Threaded mode</b> in @BotFather → Bot Settings.`,
+            `Режим настройки.\nТвой user id: <code>${from.id}</code>\nТвой chat id: <code>${chat.id}</code>\n\nДобавь user id в <b>Settings → Telegram → Allowed users</b> и нажми Restart.\n\nПеред открытием сессий включи <b>Threaded mode</b> в @BotFather → Bot Settings.`,
           ),
           signal,
           threadId,
@@ -2544,6 +2919,7 @@ export function apply(ctx, config) {
     }
 
     const chatState = await chatFor(chat.id, threadId)
+    if (await consumeQuestionReply(chatState, text, signal)) return
     const inSession = typeof chatState.sessionId === 'string'
     const parts = text.trim().split(/\s+/u)
     const command = parts[0]?.toLowerCase()
@@ -2570,7 +2946,7 @@ export function apply(ctx, config) {
     }
 
     if (command === '/start' || command === '/help') {
-      if (!inSession) await ensureTopics(chat.id, signal)
+      await rememberControlChat(chat.id)
       await send(
         chat.id,
         `<b>DeepSeek Harness Telegram bot</b>\n\n` +
@@ -2581,6 +2957,7 @@ export function apply(ctx, config) {
           (inSession
             ? `${tr('Current session', 'Текущая сессия')}: <code>${chatState.sessionId}</code>\n`
             : `${tr('Global topic. Choose a session or create a new one.', 'Глобальный чат. Выбери сессию или создай новую.')}\n`) +
+          `\n<b>${tr('First run', 'Первый запуск')}:</b> @BotFather → Bot Settings → <b>Threaded mode</b> → ${tr('Enable', 'Включить')}.\n` +
           `${tr('Commands', 'Команды')}: /sessions, /current, /menu, /rename, /last, /stop, /restart, /status, /id, /ping.`,
         signal,
         threadId,
@@ -2635,11 +3012,11 @@ export function apply(ctx, config) {
       }
       const title = await sessionTitle(chatState.sessionId)
       const body = texts
-        .map((text, index) => `${limit === 1 ? '' : `<b>${index + 1}.</b> `}${escapeHtml(text.slice(0, 3500))}`)
+        .map((text, index) => `${limit === 1 ? '' : `**${index + 1}.** `}${text.slice(0, 3500)}`)
         .join('\n\n')
-      const header = limit === 1 ? tr('Latest assistant answer', 'Последний ответ ассистента') : `${tr('Latest', 'Последние')} ${texts.length} ${tr('answers', 'ответа')}`
-      for (const chunk of splitTelegramText(`${header} · ${escapeHtml(title)}\n\n${body}`)) {
-        await send(chat.id, chunk, signal, threadId)
+      const header = limit === 1 ? `**${tr('Latest assistant answer', 'Последний ответ ассистента')}**` : `**${tr('Latest', 'Последние')} ${texts.length} ${tr('answers', 'ответа')}**`
+      for (const chunk of splitAnswerText(`${header} · ${title}\n\n${body}`)) {
+        await sendAnswer(chat.id, chunk, signal, threadId)
       }
       return
     }
@@ -2695,6 +3072,7 @@ export function apply(ctx, config) {
       chatState.done = true
       clearEditTimer(chatState)
       clearAuxTimers(chatState)
+      cancelQuestionsForChat(chatState)
       if (chatState.thinkingMessageId !== null) {
         await deleteMessage(chat.id, threadId, chatState.thinkingMessageId)
         chatState.thinkingMessageId = null
@@ -2776,7 +3154,7 @@ export function apply(ctx, config) {
       info(`connected as @${me.username ?? me.id}`)
       await publishStatus({ state: 'running', detail: '', username: me.username ?? String(me.id) })
       await publishCommands(tokenLifetime.signal)
-      await notifySystem(`🟢 ${tr('Bot online', 'Бот онлайн')}: @${escapeHtml(me.username ?? String(me.id))}`, tokenLifetime.signal)
+      await notifyAll(`🟢 ${tr('Bot online', 'Бот онлайн')}: @${escapeHtml(me.username ?? String(me.id))}`, tokenLifetime.signal)
     } catch (error) {
       if (!tokenLifetime.signal.aborted) {
         warn(`getMe failed: ${messageOf(error)}`)
@@ -2944,5 +3322,3 @@ export function apply(ctx, config) {
     'dsh-telegram-bot: runtime',
   )
 }
-
-export { preprocessTables, toTelegramMarkdown, splitAnswerText, fitAnswerText }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-telegram-bot",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Telegram sessions, topics, model controls and approvals for DeepSeek Harness.",
   "type": "module",
   "main": "index.js",
@@ -52,10 +52,10 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/boobaw/dsh-telegram-bot.git"
+    "url": "git+https://github.com/Boobaw/dsh-telegram-bot.git"
   },
-  "homepage": "https://github.com/boobaw/dsh-telegram-bot#readme",
+  "homepage": "https://github.com/Boobaw/dsh-telegram-bot#readme",
   "bugs": {
-    "url": "https://github.com/boobaw/dsh-telegram-bot/issues"
+    "url": "https://github.com/Boobaw/dsh-telegram-bot/issues"
   }
 }