dsh-telegram-bot 0.1.1 → 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
 
@@ -17,14 +17,15 @@ The bot connects to Telegram, enforces the allowlists, and bridges DSH agent ses
 - **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. Requires **Threaded mode** in @BotFather → Bot Settings.
-- **All and System topics** — All is Telegram's default topic and the management hub; System receives bot lifecycle notifications, mirrored into All.
+- **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` 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.
+- **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.
 
@@ -68,7 +69,7 @@ The token field reports only whether a token is configured. A token supplied by
 
 1. Create a bot with [@BotFather](https://t.me/BotFather) and save its token in **Settings → Telegram**.
 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; the bot creates **System** for lifecycle notifications.
+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.

package/index.js

@@ -150,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.
@@ -398,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. */
@@ -430,7 +439,7 @@ let runtimeStatus = {
   transport: 'https-ipv4',
   version: '0.3.0',
   agentBridge: 'v1',
-  codeRevision: 'threaded-mode',
+  codeRevision: 'preview-format',
   lastPollAt: 0,
   lastMessageAt: 0,
   lastChatId: null,
@@ -483,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 }),
@@ -539,6 +548,7 @@ export function apply(ctx, config) {
         toolTimer: null,
         toolLastText: '',
         boundAgent: undefined,
+        questionAgent: undefined,
       }
       chats.set(key, chat)
     }
@@ -1121,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.
@@ -1154,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.
@@ -1235,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.
@@ -1258,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 })
+    }
   }
 
   /**
@@ -1832,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. */
@@ -2164,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)
@@ -2178,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
   }
 
@@ -2277,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 = []
@@ -2295,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)
   }
 
   /**
@@ -2333,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') {
@@ -2521,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()
@@ -2547,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` +
@@ -2613,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
     }
@@ -2673,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
@@ -2754,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)}`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-telegram-bot",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Telegram sessions, topics, model controls and approvals for DeepSeek Harness.",
   "type": "module",
   "main": "index.js",