Merge remote-tracking branch 'gitea/master'

# Conflicts:
#	lib/bridge.js
#	src/bridge.ts

lib/bridge.d.ts

@@ -43,8 +43,9 @@ export declare class TelegramBridge {
     private hookTimer;
     private readonly pendingApprovalsTG;
     private disposeApprovalHook;
-    /** sessionId → thinking indicator state (one notice per reasoning phase) */
+    /** Prototype-ask interceptor state (see installAskInterceptor). */
-    private readonly thinkingSessions;
+    private askInstalled;
+    private askRestore;
     /** callId → tool name (tool/result failure notices) */
     private readonly callNames;
     /** sessionId → latest todo snapshot (/mission) */
@@ -117,10 +118,10 @@ export declare class TelegramBridge {
     /** Retry an outbound call with capped linear backoff (500ms, 1s, 2s… max 4s). */
     private withRetry;
     /**
-     * Send a notice; a leading `> ` keeps the quote look via a plain-text `> `
+     * Send a notice; a leading `> ` marks the body for quote rendering as a real
-     * prefix. NB: NOT `<blockquote>` HTML — older Telegram clients cannot render
+     * `<blockquote>` (parse_mode HTML) — every current Telegram client draws the
-     * the blockquote entity at all and show the whole message as “not supported”.
+     * accent-colored left bar. Old-client compatibility is no longer required,
-     * Falls back to plain text when the send fails — a notice is never lost.
+     * but a failed HTML send still falls back to plain text — a notice is never lost.
      */
     private deliverNotice;
     /** Serialized per-chat notice chain — bursts can't race into Telegram 429s. */
@@ -128,18 +129,17 @@ export declare class TelegramBridge {
     private startTypingHeartbeat;
     private stopTypingHeartbeat;
     private stopAllHeartbeats;
-    private userQuestions;
+    private installAskInterceptor;
-    /**
+    private aroundUserQuestionAsk;
-     * Wrap the UI provider's ask() so Telegram gets a parallel answer path.
-     * `Promise.race` decides; the UI path is untouched. The TG promise NEVER
-     * settles when there is no bound chat — race would kill the UI's window
-     * with that early rejection.
-     */
-    private hookUserQuestions;
     private registerTgAsk;
+    /** Announce the incoming question, then one message per question (options as native inline-keyboard buttons). */
+    private deliverAskPrompt;
+    /** Resolve the pending ask once EVERY question has an answer (keyboard and/or text). */
+    private finalizeAskIfComplete;
     private settleGuiSide;
-    private formatAskPending;
     private handleTgAnswer;
+    /** Inline-keyboard tap on an ask message: toggle/record the choice, resolve when every question is answered. */
+    private handleAskCallback;
     private onApprovalRequest;
     private handleTgApproval;
     private stopBound;

lib/bridge.js

@@ -10,7 +10,7 @@ import { resolveApiProxy } from './apiproxy.js';
 import { catalogFromLiveAgents, loadCatalog, truncateButton, visibleSessionsForWorkspace, workspacesWithVisibleSessions, } from './catalog.js';
 import { TelegramClient, } from './client.js';
 import { MSG, LAST_CB, parseCommand } from './commands.js';
-import { markdownToHtml, splitMessage } from './format.js';
+import { escapeHtml, markdownToHtml, splitMessage } from './format.js';
 import { splitRichMarkdown } from './rich-format.js';
 import { formatLastTurn, loadLastTurn } from './history.js';
 import { describeAgent, displayLabel, workspaceName } from './label.js';
@@ -60,18 +60,40 @@ const MODEL_CB = 'mdl:';
 /** Use eff: (not me:) — short prefix, no collision with other callbacks. */
 const EFFORT_CB = 'eff:';
 const BACK_MODEL_CB = 'mb';
+/** ask:{questionIndex}:{optionIndex|ok} — inline-keyboard taps for ask_user_question. */
+const ASK_CB = 'ask:';
 const MAX_BUTTONS = 40;
+/** Marker stored on UserQuestionService.prototype for the ask interceptor. */
+const kTgAskWrapped = Symbol.for('dsh-telegram-channel.askWrapped');
 function lastContextKeyboard() {
     return {
         inline_keyboard: [[{ text: '查看上次对话', callback_data: LAST_CB }]],
     };
 }
 const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/** Cap a single reasoning block so a long chain of thought can't flood the phone. */
+const REASONING_QUOTE_MAX_CHARS = 800;
+/**
+ * Assistant message → markdown for delivery. Reasoning (thinking) blocks are
+ * kept, one `> ` quote line each — Telegram renders them as the accent-bar
+ * quote style the phone user expects for bash/thinking-style chatter.
+ */
 function contentToText(content) {
-    return content
+    const parts = [];
-        .filter((block) => block.type === 'text')
+    for (const block of content) {
-        .map((block) => block.text)
+        if (block.type === 'text' && typeof block.text === 'string') {
-        .join('');
+            parts.push(block.text);
+        }
+        else if (block.type === 'reasoning' && typeof block.text === 'string') {
+            let thinking = block.text.trim();
+            if (!thinking)
+                continue;
+            if (thinking.length > REASONING_QUOTE_MAX_CHARS)
+                thinking = `${thinking.slice(0, REASONING_QUOTE_MAX_CHARS)}…`;
+            parts.push(thinking.split('\n').map((line) => `> ${line}`).join('\n'));
+        }
+    }
+    return parts.join('\n\n');
 }
 function isRichUnsupportedError(err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -111,8 +133,9 @@ export class TelegramBridge {
     hookTimer;
     pendingApprovalsTG = new Map();
     disposeApprovalHook;
-    /** sessionId → thinking indicator state (one notice per reasoning phase) */
+    /** Prototype-ask interceptor state (see installAskInterceptor). */
-    thinkingSessions = new Map();
+    askInstalled = false;
+    askRestore;
     /** callId → tool name (tool/result failure notices) */
     callNames = new Map();
     /** sessionId → latest todo snapshot (/mission) */
@@ -151,7 +174,12 @@ export class TelegramBridge {
         // Restore persisted bindings (survive hot reload / restart) and install
         // the TG answering hooks (ask_user dual-path + approval dual-path).
         this.loadBindings();
-        this.hookUserQuestions();
+        // ask_user interception: see installAskInterceptor — a prototype wrap of
+        // UserQuestionService.prototype.ask. Plain ctx.on('user-questions/request')
+        // registries never see the dispatch (the waterfall fires on a different
+        // per-fiber events registry in dsh 0.1.5-rc.1), so the prototype wrap —
+        // which sees EVERY ask regardless of fiber/instance — is the reliable seam.
+        this.installAskInterceptor();
         this.disposeApprovalHook?.();
         this.disposeApprovalHook = this.ctx.on('approval/request', (req, next) => this.onApprovalRequest(req, next));
         void this.client.setMyCommands([
@@ -196,7 +224,6 @@ export class TelegramBridge {
         this.noticeQueue.clear();
         this.pendingAsks.clear();
         this.pendingApprovalsTG.clear();
-        this.thinkingSessions.clear();
         this.callNames.clear();
         this.lastTodos.clear();
         for (const controller of this.compactAborts.values())
@@ -210,6 +237,9 @@ export class TelegramBridge {
             clearTimeout(this.hookTimer);
             this.hookTimer = undefined;
         }
+        this.askRestore?.();
+        this.askRestore = undefined;
+        this.askInstalled = false;
         this.disposeApprovalHook?.();
         this.disposeApprovalHook = undefined;
         if (this.pollPromise) {
@@ -340,6 +370,10 @@ export class TelegramBridge {
         }
         const data = cq.data ?? '';
         const picker = this.pickers.get(String(chatId));
+        if (data.startsWith(ASK_CB)) {
+            await this.handleAskCallback(chatId, cq);
+            return;
+        }
         if (data === LAST_CB) {
             await this.client.answerCallbackQuery(cq.id);
             await this.sendLastTurn(chatId);
@@ -1082,6 +1116,8 @@ export class TelegramBridge {
         ]);
     }
     async onSessionEvent(session, event) {
+        if (!this.askInstalled)
+            this.installAskInterceptor();
         const id = String(session.id);
         const targets = [...this.bindings.values()].filter((b) => b.sessionId === id);
         if (targets.length === 0)
@@ -1096,7 +1132,6 @@ export class TelegramBridge {
         }
         if (event.type === 'turn/end') {
             this.busySessions.delete(id);
-            this.thinkingSessions.delete(id);
             for (const b of targets)
                 this.stopTypingHeartbeat(b.chatId);
             // Abnormal endings (API failure / abort / crash-recovery) must be
@@ -1124,7 +1159,6 @@ export class TelegramBridge {
             const name = event.data?.name ?? 'tool';
             if (name === 'ask_user_question')
                 return;
-            this.thinkingSessions.set(id, false);
             if (event.data?.callId !== undefined) {
                 if (this.callNames.size > 400) {
                     const first = this.callNames.keys().next().value;
@@ -1142,25 +1176,11 @@ export class TelegramBridge {
         }
         if (event.type === 'assistant/message') {
             const text = contentToText(event.data.message.content);
-            this.thinkingSessions.set(id, false);
             if (!text)
                 return;
             await Promise.all(targets.map((b) => this.deliver(b.chatId, text)));
             return;
         }
-        if (event.type === 'assistant/chunk') {
-            // Thinking indicator: once per reasoning phase, status only (no content).
-            const chunk = event.data?.chunk;
-            const ctype = String(chunk?.type ?? '');
-            const btype = String(chunk?.block?.type ?? '');
-            const isReasoning = ctype.includes('reasoning') || btype.includes('reasoning') || btype.includes('think');
-            if (isReasoning && this.thinkingSessions.get(id) !== true) {
-                this.thinkingSessions.set(id, true);
-                for (const b of targets)
-                    this.enqueueNotice(b.chatId, '> Thinking…');
-            }
-            return;
-        }
         if (event.type === 'tool/result') {
             // Only failures — successful results are too noisy for the phone.
             const data = event.data;
@@ -1299,18 +1319,26 @@ export class TelegramBridge {
         throw lastErr;
     }
     /**
-     * Send a notice; a leading `> ` keeps the quote look via a plain-text `> `
+     * Send a notice; a leading `> ` marks the body for quote rendering as a real
-     * prefix. NB: NOT `<blockquote>` HTML — older Telegram clients cannot render
+     * `<blockquote>` (parse_mode HTML) — every current Telegram client draws the
-     * the blockquote entity at all and show the whole message as “not supported”.
+     * accent-colored left bar. Old-client compatibility is no longer required,
-     * Falls back to plain text when the send fails — a notice is never lost.
+     * but a failed HTML send still falls back to plain text — a notice is never lost.
      */
     async deliverNotice(chatId, text) {
         const quoted = text.startsWith('> ');
         const body = quoted ? text.slice(2) : text;
+        if (quoted) {
             try {
-            await this.withRetry(() => this.client.sendMessage(chatId, quoted ? `> ${body}` : body));
+                await this.withRetry(() => this.client.sendMessage(chatId, `<blockquote>${escapeHtml(body)}</blockquote>`, 'HTML'));
                 return;
             }
+            catch (err) {
+                this.ctx.logger.warn(`dsh-telegram-channel: blockquote notice failed (${this.redact(err)}), falling back to plain text`);
+            }
+        }
+        try {
+            await this.withRetry(() => this.client.sendMessage(chatId, body));
+        }
         catch (err) {
             this.ctx.logger.error(this.redact(err));
         }
@@ -1343,87 +1371,62 @@ export class TelegramBridge {
             clearInterval(h);
         this.heartbeats.clear();
     }
-    // ── ask_user_question: TG answering via dual-path race with the UI ──
+    // ── ask_user_question: TG answering via a prototype interceptor ──
-    userQuestions() {
+    //
-        const ctx = this.ctx;
+    // dsh 0.1.5-rc.1 routes the 'user-questions/request' waterfall through a
-        if (typeof ctx.get === 'function') {
+    // per-fiber events registry: plain ctx.on listeners in other fibers (this
+    // plugin included) never see the dispatch, so the waterfall hook cannot
+    // mirror questions to TG. The class is shared across instances though, so
+    // wrapping UserQuestionService.prototype.ask intercepts EVERY ask with its
+    // agent + questions, regardless of fiber. The wrap races the TG answer
+    // against the original ask (GUI path), preserving the old dual-path
+    // semantics. Restore-on-stop keeps hot reloads from stacking wrappers.
+    installAskInterceptor() {
+        if (this.askInstalled)
+            return;
+        let svc;
         try {
-                const service = ctx.get('userQuestions');
+            svc = this.ctx.get('userQuestions');
-                if (service)
-                    return service;
         }
         catch {
-                // Continue to the plain-object fallback used by tests and simple hosts.
+            return; // service not ready yet — retried lazily from onSessionEvent
         }
+        if (!svc)
+            return;
+        const proto = svc.constructor.prototype;
+        const prev = proto[kTgAskWrapped];
+        if (prev?.bridge === this) {
+            this.askInstalled = true;
+            this.askRestore = prev.restore;
+            return;
         }
-        try {
+        prev?.restore(); // stale wrapper from a disposed bridge instance
-            return Object.prototype.hasOwnProperty.call(ctx, 'userQuestions')
+        const orig = proto.ask;
-                ? ctx.userQuestions
+        const bridge = this;
-                : undefined;
+        const wrapped = function (request) {
+            return bridge.aroundUserQuestionAsk(this, request, orig);
+        };
+        proto.ask = wrapped;
+        const restore = () => {
+            if (proto.ask === wrapped)
+                proto.ask = orig;
+        };
+        proto[kTgAskWrapped] = { restore, bridge: this };
+        this.askRestore = restore;
+        this.askInstalled = true;
     }
-        catch {
+    aroundUserQuestionAsk(service, request, orig) {
-            return undefined;
+        const tg = this.registerTgAsk(request);
-        }
-    }
-    /**
-     * Wrap the UI provider's ask() so Telegram gets a parallel answer path.
-     * `Promise.race` decides; the UI path is untouched. The TG promise NEVER
-     * settles when there is no bound chat — race would kill the UI's window
-     * with that early rejection.
-     */
-    hookUserQuestions(attempt = 0) {
-        try {
-            const provider = this.userQuestions()?.provider;
-            if (provider) {
-                if (provider.__tgHooked && provider.__tgRealAsk) {
-                    // Hot reload: re-point the wrapper at THIS bridge instance.
-                    const realAsk = provider.__tgRealAsk;
-                    const self = this;
-                    provider.ask = function (request) {
-                        const tg = self.registerTgAsk(request);
         let gui;
         try {
-                            gui = realAsk(request);
+            gui = Promise.resolve().then(() => orig.call(service, request));
         }
         catch (err) {
             tg.reject(err);
             throw err;
         }
-                        void gui.then(() => self.settleGuiSide(request), () => self.settleGuiSide(request));
+        void gui.then(() => this.settleGuiSide(request), () => this.settleGuiSide(request));
         return Promise.race([tg.promise, gui]);
-                    };
-                    return;
-                }
-                const realAsk = provider.ask.bind(provider);
-                provider.__tgRealAsk = realAsk;
-                const self = this;
-                provider.ask = function (request) {
-                    const tg = self.registerTgAsk(request);
-                    let gui;
-                    try {
-                        gui = realAsk(request);
-                    }
-                    catch (err) {
-                        tg.reject(err);
-                        throw err;
-                    }
-                    void gui.then(() => self.settleGuiSide(request), () => self.settleGuiSide(request));
-                    return Promise.race([tg.promise, gui]);
-                };
-                provider.__tgHooked = true;
-                this.ctx.logger.info('dsh-telegram-channel: ask_user TG answering hook installed');
-                return;
-            }
-        }
-        catch (err) {
-            if (attempt === 0)
-                this.ctx.logger.warn(`dsh-telegram-channel: userQuestions hook deferred: ${this.redact(err)}`);
-        }
-        if (attempt >= 30) {
-            this.ctx.logger.warn('dsh-telegram-channel: user-questions provider never appeared; TG answering disabled');
-            return;
-        }
-        this.hookTimer = setTimeout(() => this.hookUserQuestions(attempt + 1), 2000);
     }
     registerTgAsk(request) {
         let resolveFn = () => { };
@@ -1453,16 +1456,83 @@ export class TelegramBridge {
             for (const [chatId, binding] of this.bindings) {
                 if (binding.sessionId !== sessionId)
                     continue;
-                this.pendingAsks.set(String(chatId), { req: request, sessionId, questions, ask, at: Date.now() });
+                const pending = {
-                this.enqueueNotice(Number(chatId), this.formatAskPending(questions));
+                    req: request,
+                    sessionId,
+                    questions,
+                    ask,
+                    at: Date.now(),
+                    kbSel: new Map(),
+                    textAnswers: new Map(),
+                    textWanted: new Set(),
+                };
+                this.pendingAsks.set(String(chatId), pending);
+                void this.deliverAskPrompt(Number(chatId), pending);
                 asked = true;
             }
-            if (asked)
-                return { promise, reject: rejectFn };
         }
         // No bound TG chat: never settle — the UI remains the only answer path.
         return { promise, reject: rejectFn };
     }
+    /** Announce the incoming question, then one message per question (options as native inline-keyboard buttons). */
+    async deliverAskPrompt(chatId, pending) {
+        const { questions } = pending;
+        try {
+            await this.withRetry(() => this.client.sendMessage(chatId, `❓ 即将向你提问（共 ${questions.length} 题）——点按钮或回复文本作答；/cancel 关闭 TG 作答`));
+            for (let i = 0; i < questions.length; i++) {
+                const q = questions[i];
+                const opts = Array.isArray(q.options) ? q.options : [];
+                const header = questions.length > 1 ? `Q${i + 1}. ` : '';
+                if (opts.length === 0) {
+                    await this.withRetry(() => this.client.sendMessage(chatId, `${header}${q.question ?? ''}\n（开放问题，请直接回复文本）`));
+                    continue;
+                }
+                const keyboard = {
+                    inline_keyboard: [
+                        ...opts.map((o, j) => [{
+                                text: `${j + 1}. ${o.label}`.slice(0, 48),
+                                callback_data: `${ASK_CB}${i}:${j}`,
+                            }]),
+                        // Standing third choice: free-text answer, always available.
+                        [{ text: '✏️ 输入自定义答案', callback_data: `${ASK_CB}${i}:custom` }],
+                        ...(q.multiSelect ? [[{ text: '✅ 提交所选', callback_data: `${ASK_CB}${i}:ok` }]] : []),
+                    ],
+                };
+                await this.withRetry(() => this.client.sendMessage(chatId, `${header}${q.question ?? ''}`, undefined, keyboard));
+            }
+        }
+        catch (err) {
+            this.ctx.logger.error(this.redact(err));
+        }
+    }
+    /** Resolve the pending ask once EVERY question has an answer (keyboard and/or text). */
+    finalizeAskIfComplete(chatId, pending) {
+        const { questions, ask } = pending;
+        const answers = [];
+        for (let i = 0; i < questions.length; i++) {
+            const q = questions[i];
+            const opts = Array.isArray(q.options) ? q.options : [];
+            const sel = pending.kbSel.get(i);
+            if (sel && sel.size > 0) {
+                answers.push({ id: q.id, selected: [...sel].sort((a, b) => a - b).map((j) => opts[j].label) });
+                continue;
+            }
+            const text = pending.textAnswers.get(i);
+            if (text !== undefined) {
+                answers.push(text);
+                continue;
+            }
+            return false;
+        }
+        ask.answered = true;
+        for (const [cid, p] of this.pendingAsks) {
+            if (p.ask === ask)
+                this.pendingAsks.delete(cid);
+        }
+        ask.resolve({ answers });
+        this.enqueueNotice(chatId, '已提交你的回答');
+        return true;
+    }
     settleGuiSide(request) {
         for (const [chatId, p] of [...this.pendingAsks]) {
             if (p.req !== request)
@@ -1473,25 +1543,8 @@ export class TelegramBridge {
             }
         }
     }
-    formatAskPending(questions) {
-        const lines = ['待回答（回复字母选项，或直接输入自定义答案；/cancel 关闭 TG 作答）'];
-        questions.forEach((q, i) => {
-            const prefix = questions.length > 1 ? `Q${i + 1}. ` : '';
-            lines.push(`${prefix}${q.question ?? ''}`);
-            const opts = Array.isArray(q.options) ? q.options : [];
-            if (opts.length === 0) {
-                lines.push('  （开放问题，直接输入答案）');
-            }
-            else {
-                opts.forEach((o, j) => lines.push(`  [${String.fromCharCode(65 + j)}] ${o.label}${o.description ? ` — ${o.description}` : ''}`));
-                if (q.multiSelect)
-                    lines.push('  （可多选，如：A,B）');
-            }
-        });
-        return lines.join('\n');
-    }
     async handleTgAnswer(chatId, pending, text) {
-        const { questions, ask } = pending;
+        const { questions } = pending;
         let parts;
         if (questions.length === 1) {
             parts = [[0, text.trim()]];
@@ -1507,11 +1560,17 @@ export class TelegramBridge {
                     parts.push([null, line]);
             }
             if (parts.some(([idx]) => idx === null)) {
+                // ✏️ free-text route: a question awaiting text absorbs the whole message.
+                const target = [...pending.textWanted].sort((a, b) => a - b)[0];
+                if (target !== undefined) {
+                    parts = [[target, text.trim()]];
+                }
+                else {
                     await this.enqueueNotice(chatId, `共 ${questions.length} 个问题，请每行用 1:/2: 前缀分别作答`);
                     return;
                 }
             }
-        const answers = [];
+        }
         for (const [idx, raw] of parts) {
             if (idx === null || idx < 0 || idx >= questions.length) {
                 await this.enqueueNotice(chatId, `题号 ${(idx ?? 0) + 1} 不存在（共 ${questions.length} 题）`);
@@ -1534,19 +1593,73 @@ export class TelegramBridge {
                     }
                     selected.push(opts[i].label);
                 }
-                answers.push({ id: q.id, selected });
+                pending.textAnswers.set(idx, { id: q.id, selected });
             }
             else {
-                answers.push({ id: q.id, selected: [], custom: cleaned });
+                pending.textAnswers.set(idx, { id: q.id, selected: [], custom: cleaned });
+            }
+            pending.textWanted.delete(idx);
+        }
+        // Keyboard selections take precedence per question; resolve when complete.
+        if (!this.finalizeAskIfComplete(chatId, pending)) {
+            const done = questions.filter((_, i) => pending.kbSel.get(i)?.size || pending.textAnswers.has(i)).length;
+            await this.enqueueNotice(chatId, `已记录 ${done}/${questions.length} 题，请继续作答（按钮或 1:/2: 文本）`);
         }
     }
-        ask.answered = true;
+    /** Inline-keyboard tap on an ask message: toggle/record the choice, resolve when every question is answered. */
-        for (const [cid, p] of this.pendingAsks) {
+    async handleAskCallback(chatId, cq) {
-            if (p.ask === ask)
+        const pending = this.pendingAsks.get(String(chatId));
-                this.pendingAsks.delete(cid);
+        if (!pending) {
+            await this.client.answerCallbackQuery(cq.id, '该提问已失效（可能已在 Web 端作答）');
+            return;
+        }
+        const payload = (cq.data ?? '').slice(ASK_CB.length);
+        const sep = payload.indexOf(':');
+        const qi = Number(payload.slice(0, sep));
+        const action = payload.slice(sep + 1);
+        const q = pending.questions[qi];
+        if (!q) {
+            await this.client.answerCallbackQuery(cq.id, '题目已失效');
+            return;
+        }
+        const opts = Array.isArray(q.options) ? q.options : [];
+        if (action === 'custom') {
+            // Free-text path: discard button selections for this question and wait
+            // for the user's next text message (routed via textWanted).
+            pending.kbSel.delete(qi);
+            pending.textWanted.add(qi);
+            await this.client.answerCallbackQuery(cq.id, '请直接发送你的答案文本');
+            return;
+        }
+        if (action === 'ok') {
+            if (!pending.kbSel.get(qi)?.size) {
+                await this.client.answerCallbackQuery(cq.id, '请先点选选项');
+                return;
+            }
+        }
+        else {
+            const j = Number(action);
+            if (!Number.isInteger(j) || j < 0 || j >= opts.length) {
+                await this.client.answerCallbackQuery(cq.id, '选项不存在');
+                return;
+            }
+            if (q.multiSelect) {
+                const set = pending.kbSel.get(qi) ?? new Set();
+                if (set.has(j))
+                    set.delete(j);
+                else
+                    set.add(j);
+                pending.kbSel.set(qi, set);
+                await this.client.answerCallbackQuery(cq.id, set.size > 0 ? `已选 ${set.size} 项，选完点"提交所选"` : '已取消该选项');
+            }
+            else {
+                pending.kbSel.set(qi, new Set([j]));
+                await this.client.answerCallbackQuery(cq.id, `已选：${opts[j].label}`);
+            }
+        }
+        if (!this.finalizeAskIfComplete(chatId, pending) && action === 'ok') {
+            await this.client.answerCallbackQuery(cq.id, '已提交本题选择，请继续作答其他问题');
         }
-        ask.resolve({ answers });
-        this.enqueueNotice(chatId, '已提交你的回答');
     }
     // ── approval: TG answering via dual-path race on the request waterfall ──
     async onApprovalRequest(req, next) {

lib/client.js

@@ -37,12 +37,17 @@ export class TelegramClient {
     redact(message) {
         return message.split(this.token).join('***');
     }
-    async call(method, body) {
+    async call(method, body, timeoutMs = 15_000) {
         const url = `${this.baseUrl}/bot${this.token}/${method}`;
         try {
             const init = {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
+                // Without a client-side timeout a stalled proxy connection hangs the
+                // request forever — and the serialized notice queue wedges behind it,
+                // silently swallowing every later tool/ask notice. TimeoutError is
+                // caught below and surfaces as a normal (retryable) failure.
+                signal: AbortSignal.timeout(timeoutMs),
             };
             if (body !== undefined) {
                 init.body = JSON.stringify(body);
@@ -70,7 +75,8 @@ export class TelegramClient {
         if (offset !== undefined) {
             body.offset = offset;
         }
-        return this.call('getUpdates', body);
+        // Long-poll: client-side abort must outlive the server-side hold.
+        return this.call('getUpdates', body, this.pollingTimeoutSec * 1000 + 10_000);
     }
     async sendMessage(chatId, text, parseMode, replyMarkup) {
         const body = { chat_id: chatId, text };

lib/format.js

@@ -12,6 +12,30 @@ function inlineToHtml(text) {
     html = html.replace(/\*\*([^*\n]+)\*\*/g, '<b>$1</b>');
     return html;
 }
+/** Convert `> …` line groups into `<blockquote>` (Telegram renders it with the accent-colored left bar). */
+function blocksToHtml(text) {
+    const lines = text.split('\n');
+    const out = [];
+    let quote = [];
+    const flush = () => {
+        if (quote.length === 0)
+            return;
+        out.push(`<blockquote>${inlineToHtml(quote.join('\n'))}</blockquote>`);
+        quote = [];
+    };
+    for (const line of lines) {
+        if (line.startsWith('> '))
+            quote.push(line.slice(2));
+        else if (line === '>')
+            quote.push('');
+        else {
+            flush();
+            out.push(inlineToHtml(line));
+        }
+    }
+    flush();
+    return out.join('\n');
+}
 export function markdownToHtml(text) {
     const parts = text.split(/```[\w-]*/);
     if (parts.length % 2 === 0)
@@ -23,7 +47,7 @@ export function markdownToHtml(text) {
             html += `<pre>${escapeHtml(code)}</pre>`;
         }
         else {
-            html += inlineToHtml(parts[i]);
+            html += blocksToHtml(parts[i]);
         }
     }
     return html;

lib/index.d.ts

@@ -9,8 +9,8 @@ export interface TelegramChannelConfig {
     allowAllUsers?: boolean;
     maxMessageLength?: number;
     pollingTimeoutSec?: number;
-    /** 'rich' = Telegram native Rich Messages (needs a recent client);
+    /** 默认 'rich' = Telegram native Rich Messages（需较新客户端）；
-     *  anything else (default) = HTML compatibility mode that renders on all clients. */
+     *  显式 'html'/'compat' 等其它值 = 兼容模式，所有客户端可显示。 */
     rendering?: string;
 }
 export declare const Config: Schema<TelegramChannelConfig>;

lib/index.js

@@ -9,7 +9,7 @@ export const Config = Schema.object({
     allowAllUsers: Schema.boolean().default(false),
     maxMessageLength: Schema.number().default(4096),
     pollingTimeoutSec: Schema.number().default(30),
-    rendering: Schema.string().default('html'),
+    rendering: Schema.string().default('rich'),
 });
 function resolveAllowedUserIds(config) {
     if (config.allowedUserIds && config.allowedUserIds.length > 0) {

src/bridge.ts

@@ -6,7 +6,7 @@ import { dirname, join } from 'node:path'
 import type { Context } from '@deepseek-ai/cordis'
 import type { Agent } from '@deepseek-ai/dsh-agent'
 import { createUserMessage } from '@deepseek-ai/dsh-llm/message'
-import type { ContentBlock, TextBlock } from '@deepseek-ai/dsh-llm/types'
+import type { ContentBlock } from '@deepseek-ai/dsh-llm/types'
 import { SessionId, type SessionEvent } from '@deepseek-ai/dsh-session/types'
 import { isAuthorized } from './auth.js'
 import { resolveApiProxy } from './apiproxy.js'
@@ -28,7 +28,7 @@ import {
   type TelegramUpdate,
 } from './client.js'
 import { MSG, LAST_CB, parseCommand } from './commands.js'
-import { markdownToHtml, splitMessage } from './format.js'
+import { escapeHtml, markdownToHtml, splitMessage } from './format.js'
 import { splitRichMarkdown } from './rich-format.js'
 import { formatLastTurn, loadLastTurn } from './history.js'
 import { describeAgent, displayLabel, workspaceName } from './label.js'
@@ -97,6 +97,12 @@ interface TgPendingAsk {
   questions: TgQuestionItem[]
   ask: TgAnswerHandle
   at: number
+  /** question index → option indices chosen via inline-keyboard taps. */
+  kbSel: Map<number, Set<number>>
+  /** question index → answer parsed from a text reply (letters or custom). */
+  textAnswers: Map<number, { id?: string; selected: string[]; custom?: string }>
+  /** questions the user chose to answer with free text (✏️ button): the next text reply fills them. */
+  textWanted: Set<number>
 }
 
 /** chatId → pending approval request mirrored to Telegram. */
@@ -105,15 +111,6 @@ interface TgPendingApproval {
   ask: TgAnswerHandle
 }
 
-/** Structural view of the user-questions seam (types live in the host's dsh-user-questions package). */
-interface UserQuestionsServiceLike {
-  provider?: {
-    ask: (request: unknown) => Promise<unknown>
-    __tgHooked?: boolean
-    __tgRealAsk?: (request: unknown) => Promise<unknown>
-  }
-}
-
 /** Loose view of the approval request passed through the `approval/request` waterfall hook. */
 interface ApprovalRequestLike {
   agent?: Agent
@@ -194,7 +191,11 @@ const MODEL_CB = 'mdl:'
 /** Use eff: (not me:) — short prefix, no collision with other callbacks. */
 const EFFORT_CB = 'eff:'
 const BACK_MODEL_CB = 'mb'
+/** ask:{questionIndex}:{optionIndex|ok} — inline-keyboard taps for ask_user_question. */
+const ASK_CB = 'ask:'
 const MAX_BUTTONS = 40
+/** Marker stored on UserQuestionService.prototype for the ask interceptor. */
+const kTgAskWrapped = Symbol.for('dsh-telegram-channel.askWrapped')
 
 function lastContextKeyboard(): InlineKeyboardMarkup {
   return {
@@ -204,11 +205,28 @@ function lastContextKeyboard(): InlineKeyboardMarkup {
 
 const defaultSleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms))
 
+/** Cap a single reasoning block so a long chain of thought can't flood the phone. */
+const REASONING_QUOTE_MAX_CHARS = 800
+
+/**
+ * Assistant message → markdown for delivery. Reasoning (thinking) blocks are
+ * kept, one `> ` quote line each — Telegram renders them as the accent-bar
+ * quote style the phone user expects for bash/thinking-style chatter.
+ */
 function contentToText(content: readonly ContentBlock[]): string {
-  return content
+  const parts: string[] = []
-    .filter((block): block is TextBlock => block.type === 'text')
+  for (const block of content) {
-    .map((block) => block.text)
+    if (block.type === 'text' && typeof block.text === 'string') {
-    .join('')
+      parts.push(block.text)
+    } else if (block.type === 'reasoning' && typeof block.text === 'string') {
+      let thinking = block.text.trim()
+      if (!thinking) continue
+      if (thinking.length > REASONING_QUOTE_MAX_CHARS)
+        thinking = `${thinking.slice(0, REASONING_QUOTE_MAX_CHARS)}…`
+      parts.push(thinking.split('\n').map((line) => `> ${line}`).join('\n'))
+    }
+  }
+  return parts.join('\n\n')
 }
 
 function isRichUnsupportedError(err: unknown): boolean {
@@ -252,8 +270,9 @@ export class TelegramBridge {
   private hookTimer: ReturnType<typeof setTimeout> | undefined
   private readonly pendingApprovalsTG = new Map<string, TgPendingApproval>()
   private disposeApprovalHook: (() => void) | undefined
-  /** sessionId → thinking indicator state (one notice per reasoning phase) */
+  /** Prototype-ask interceptor state (see installAskInterceptor). */
-  private readonly thinkingSessions = new Map<string, boolean>()
+  private askInstalled = false
+  private askRestore: (() => void) | undefined
   /** callId → tool name (tool/result failure notices) */
   private readonly callNames = new Map<string, string>()
   /** sessionId → latest todo snapshot (/mission) */
@@ -295,7 +314,12 @@ export class TelegramBridge {
     // Restore persisted bindings (survive hot reload / restart) and install
     // the TG answering hooks (ask_user dual-path + approval dual-path).
     this.loadBindings()
-    this.hookUserQuestions()
+    // ask_user interception: see installAskInterceptor — a prototype wrap of
+    // UserQuestionService.prototype.ask. Plain ctx.on('user-questions/request')
+    // registries never see the dispatch (the waterfall fires on a different
+    // per-fiber events registry in dsh 0.1.5-rc.1), so the prototype wrap —
+    // which sees EVERY ask regardless of fiber/instance — is the reliable seam.
+    this.installAskInterceptor()
     this.disposeApprovalHook?.()
     this.disposeApprovalHook = (this.ctx as unknown as {
       on: (event: string, handler: (req: ApprovalRequestLike, next: () => Promise<string>) => Promise<string>) => () => void
@@ -343,7 +367,6 @@ export class TelegramBridge {
     this.noticeQueue.clear()
     this.pendingAsks.clear()
     this.pendingApprovalsTG.clear()
-    this.thinkingSessions.clear()
     this.callNames.clear()
     this.lastTodos.clear()
     for (const controller of this.compactAborts.values()) controller.abort()
@@ -355,6 +378,9 @@ export class TelegramBridge {
       clearTimeout(this.hookTimer)
       this.hookTimer = undefined
     }
+    this.askRestore?.()
+    this.askRestore = undefined
+    this.askInstalled = false
     this.disposeApprovalHook?.()
     this.disposeApprovalHook = undefined
     if (this.pollPromise) {
@@ -488,6 +514,10 @@ export class TelegramBridge {
     const data = cq.data ?? ''
     const picker = this.pickers.get(String(chatId))
 
+    if (data.startsWith(ASK_CB)) {
+      await this.handleAskCallback(chatId, cq)
+      return
+    }
     if (data === LAST_CB) {
       await this.client.answerCallbackQuery(cq.id)
       await this.sendLastTurn(chatId)
@@ -1255,6 +1285,7 @@ export class TelegramBridge {
   }
 
   private async onSessionEvent(session: SessionLike, event: SessionEvent): Promise<void> {
+    if (!this.askInstalled) this.installAskInterceptor()
     const id = String(session.id)
     const targets = [...this.bindings.values()].filter((b) => b.sessionId === id)
     if (targets.length === 0) return
@@ -1269,7 +1300,6 @@ export class TelegramBridge {
 
     if (event.type === 'turn/end') {
       this.busySessions.delete(id)
-      this.thinkingSessions.delete(id)
       for (const b of targets) this.stopTypingHeartbeat(b.chatId)
       // Abnormal endings (API failure / abort / crash-recovery) must be
       // visible on the phone — previously they ended in silence.
@@ -1294,7 +1324,6 @@ export class TelegramBridge {
       // Progress summary; ask_user is owned by the provider hook (avoids duplicates).
       const name = event.data?.name ?? 'tool'
       if (name === 'ask_user_question') return
-      this.thinkingSessions.set(id, false)
       if (event.data?.callId !== undefined) {
         if (this.callNames.size > 400) {
           const first = this.callNames.keys().next().value
@@ -1312,26 +1341,11 @@ export class TelegramBridge {
 
     if (event.type === 'assistant/message') {
       const text = contentToText(event.data.message.content)
-      this.thinkingSessions.set(id, false)
       if (!text) return
       await Promise.all(targets.map((b) => this.deliver(b.chatId, text)))
       return
     }
 
-    if (event.type === 'assistant/chunk') {
-      // Thinking indicator: once per reasoning phase, status only (no content).
-      const chunk = event.data?.chunk as { type?: string; block?: { type?: string } } | undefined
-      const ctype = String(chunk?.type ?? '')
-      const btype = String(chunk?.block?.type ?? '')
-      const isReasoning = ctype.includes('reasoning') || btype.includes('reasoning') || btype.includes('think')
-      if (isReasoning && this.thinkingSessions.get(id) !== true) {
-        this.thinkingSessions.set(id, true)
-        for (const b of targets)
-          this.enqueueNotice(b.chatId, '> Thinking…')
-      }
-      return
-    }
-
     if (event.type === 'tool/result') {
       // Only failures — successful results are too noisy for the phone.
       const data = event.data as { error?: { name?: string; code?: string }; message?: { tool_use_id?: string; callId?: string } }
@@ -1471,17 +1485,28 @@ export class TelegramBridge {
   }
 
   /**
-   * Send a notice; a leading `> ` keeps the quote look via a plain-text `> `
+   * Send a notice; a leading `> ` marks the body for quote rendering as a real
-   * prefix. NB: NOT `<blockquote>` HTML — older Telegram clients cannot render
+   * `<blockquote>` (parse_mode HTML) — every current Telegram client draws the
-   * the blockquote entity at all and show the whole message as “not supported”.
+   * accent-colored left bar. Old-client compatibility is no longer required,
-   * Falls back to plain text when the send fails — a notice is never lost.
+   * but a failed HTML send still falls back to plain text — a notice is never lost.
    */
   private async deliverNotice(chatId: number, text: string): Promise<void> {
     const quoted = text.startsWith('> ')
     const body = quoted ? text.slice(2) : text
+    if (quoted) {
       try {
-      await this.withRetry(() => this.client.sendMessage(chatId, quoted ? `> ${body}` : body))
+        await this.withRetry(() =>
+          this.client.sendMessage(chatId, `<blockquote>${escapeHtml(body)}</blockquote>`, 'HTML'),
+        )
         return
+      } catch (err) {
+        this.ctx.logger.warn(
+          `dsh-telegram-channel: blockquote notice failed (${this.redact(err)}), falling back to plain text`,
+        )
+      }
+    }
+    try {
+      await this.withRetry(() => this.client.sendMessage(chatId, body))
     } catch (err) {
       this.ctx.logger.error(this.redact(err))
     }
@@ -1518,87 +1543,66 @@ export class TelegramBridge {
     this.heartbeats.clear()
   }
 
-  // ── ask_user_question: TG answering via dual-path race with the UI ──
+  // ── ask_user_question: TG answering via a prototype interceptor ──
+  //
+  // dsh 0.1.5-rc.1 routes the 'user-questions/request' waterfall through a
+  // per-fiber events registry: plain ctx.on listeners in other fibers (this
+  // plugin included) never see the dispatch, so the waterfall hook cannot
+  // mirror questions to TG. The class is shared across instances though, so
+  // wrapping UserQuestionService.prototype.ask intercepts EVERY ask with its
+  // agent + questions, regardless of fiber. The wrap races the TG answer
+  // against the original ask (GUI path), preserving the old dual-path
+  // semantics. Restore-on-stop keeps hot reloads from stacking wrappers.
 
-  private userQuestions(): UserQuestionsServiceLike | undefined {
+  private installAskInterceptor(): void {
-    const ctx = this.ctx as Context & {
+    if (this.askInstalled) return
-      get?: (name: string, strict?: boolean) => unknown
+    let svc: { constructor: { prototype: Record<string | symbol, unknown> } } | undefined
-      userQuestions?: UserQuestionsServiceLike
-    }
-    if (typeof ctx.get === 'function') {
     try {
-        const service = ctx.get('userQuestions') as UserQuestionsServiceLike | undefined
+      svc = (this.ctx as unknown as { get: (name: string) => unknown }).get('userQuestions') as
-        if (service) return service
+        | { constructor: { prototype: Record<string | symbol, unknown> } }
+        | undefined
     } catch {
-        // Continue to the plain-object fallback used by tests and simple hosts.
+      return // service not ready yet — retried lazily from onSessionEvent
     }
+    if (!svc) return
+    const proto = svc.constructor.prototype
+    const prev = proto[kTgAskWrapped] as { restore: () => void; bridge: unknown } | undefined
+    if (prev?.bridge === this) {
+      this.askInstalled = true
+      this.askRestore = prev.restore
+      return
     }
-    try {
+    prev?.restore() // stale wrapper from a disposed bridge instance
-      return Object.prototype.hasOwnProperty.call(ctx, 'userQuestions')
+    const orig = proto.ask as (this: unknown, request: unknown) => Promise<unknown>
-        ? ctx.userQuestions
+    const bridge = this
-        : undefined
+    const wrapped = function (this: unknown, request: unknown): Promise<unknown> {
-    } catch {
+      return bridge.aroundUserQuestionAsk(this, request, orig)
-      return undefined
     }
+    proto.ask = wrapped
+    const restore = (): void => {
+      if (proto.ask === wrapped) proto.ask = orig
+    }
+    proto[kTgAskWrapped] = { restore, bridge: this }
+    this.askRestore = restore
+    this.askInstalled = true
   }
 
-  /**
+  private aroundUserQuestionAsk(
-   * Wrap the UI provider's ask() so Telegram gets a parallel answer path.
+    service: unknown,
-   * `Promise.race` decides; the UI path is untouched. The TG promise NEVER
+    request: unknown,
-   * settles when there is no bound chat — race would kill the UI's window
+    orig: (this: unknown, request: unknown) => Promise<unknown>,
-   * with that early rejection.
+  ): Promise<unknown> {
-   */
+    const tg = this.registerTgAsk(request)
-  private hookUserQuestions(attempt = 0): void {
-    try {
-      const provider = this.userQuestions()?.provider
-      if (provider) {
-        if (provider.__tgHooked && provider.__tgRealAsk) {
-          // Hot reload: re-point the wrapper at THIS bridge instance.
-          const realAsk = provider.__tgRealAsk
-          const self = this
-          provider.ask = function (request: unknown): Promise<unknown> {
-            const tg = self.registerTgAsk(request)
     let gui: Promise<unknown>
     try {
-              gui = realAsk(request)
+      gui = Promise.resolve().then(() => orig.call(service, request))
     } catch (err) {
       tg.reject(err as Error)
       throw err
     }
-            void gui.then(() => self.settleGuiSide(request), () => self.settleGuiSide(request))
+    void gui.then(() => this.settleGuiSide(request), () => this.settleGuiSide(request))
     return Promise.race([tg.promise, gui])
   }
-          return
-        }
-        const realAsk = provider.ask.bind(provider) as (request: unknown) => Promise<unknown>
-        provider.__tgRealAsk = realAsk
-        const self = this
-        provider.ask = function (request: unknown): Promise<unknown> {
-          const tg = self.registerTgAsk(request)
-          let gui: Promise<unknown>
-          try {
-            gui = realAsk(request)
-          } catch (err) {
-            tg.reject(err as Error)
-            throw err
-          }
-          void gui.then(() => self.settleGuiSide(request), () => self.settleGuiSide(request))
-          return Promise.race([tg.promise, gui])
-        }
-        provider.__tgHooked = true
-        this.ctx.logger.info('dsh-telegram-channel: ask_user TG answering hook installed')
-        return
-      }
-    } catch (err) {
-      if (attempt === 0)
-        this.ctx.logger.warn(`dsh-telegram-channel: userQuestions hook deferred: ${this.redact(err)}`)
-    }
-    if (attempt >= 30) {
-      this.ctx.logger.warn('dsh-telegram-channel: user-questions provider never appeared; TG answering disabled')
-      return
-    }
-    this.hookTimer = setTimeout(() => this.hookUserQuestions(attempt + 1), 2000)
-  }
 
   private registerTgAsk(request: unknown): { promise: Promise<unknown>; reject: (err: Error) => void } {
     let resolveFn: (v: unknown) => void = () => {}
@@ -1626,16 +1630,91 @@ export class TelegramBridge {
       let asked = false
       for (const [chatId, binding] of this.bindings) {
         if (binding.sessionId !== sessionId) continue
-        this.pendingAsks.set(String(chatId), { req: request, sessionId, questions, ask, at: Date.now() })
+        const pending: TgPendingAsk = {
-        this.enqueueNotice(Number(chatId), this.formatAskPending(questions))
+          req: request,
+          sessionId,
+          questions,
+          ask,
+          at: Date.now(),
+          kbSel: new Map(),
+          textAnswers: new Map(),
+          textWanted: new Set(),
+        }
+        this.pendingAsks.set(String(chatId), pending)
+        void this.deliverAskPrompt(Number(chatId), pending)
         asked = true
       }
-      if (asked) return { promise, reject: rejectFn }
     }
     // No bound TG chat: never settle — the UI remains the only answer path.
     return { promise, reject: rejectFn }
   }
 
+  /** Announce the incoming question, then one message per question (options as native inline-keyboard buttons). */
+  private async deliverAskPrompt(chatId: number, pending: TgPendingAsk): Promise<void> {
+    const { questions } = pending
+    try {
+      await this.withRetry(() =>
+        this.client.sendMessage(
+          chatId,
+          `❓ 即将向你提问（共 ${questions.length} 题）——点按钮或回复文本作答；/cancel 关闭 TG 作答`,
+        ),
+      )
+      for (let i = 0; i < questions.length; i++) {
+        const q = questions[i]!
+        const opts = Array.isArray(q.options) ? q.options : []
+        const header = questions.length > 1 ? `Q${i + 1}. ` : ''
+        if (opts.length === 0) {
+          await this.withRetry(() =>
+            this.client.sendMessage(chatId, `${header}${q.question ?? ''}\n（开放问题，请直接回复文本）`),
+          )
+          continue
+        }
+        const keyboard: InlineKeyboardMarkup = {
+          inline_keyboard: [
+            ...opts.map((o, j) => [{
+              text: `${j + 1}. ${o.label}`.slice(0, 48),
+              callback_data: `${ASK_CB}${i}:${j}`,
+            }]),
+            // Standing third choice: free-text answer, always available.
+            [{ text: '✏️ 输入自定义答案', callback_data: `${ASK_CB}${i}:custom` }],
+            ...(q.multiSelect ? [[{ text: '✅ 提交所选', callback_data: `${ASK_CB}${i}:ok` }]] : []),
+          ],
+        }
+        await this.withRetry(() => this.client.sendMessage(chatId, `${header}${q.question ?? ''}`, undefined, keyboard))
+      }
+    } catch (err) {
+      this.ctx.logger.error(this.redact(err))
+    }
+  }
+
+  /** Resolve the pending ask once EVERY question has an answer (keyboard and/or text). */
+  private finalizeAskIfComplete(chatId: number, pending: TgPendingAsk): boolean {
+    const { questions, ask } = pending
+    const answers: Array<{ id?: string; selected: string[]; custom?: string }> = []
+    for (let i = 0; i < questions.length; i++) {
+      const q = questions[i]!
+      const opts = Array.isArray(q.options) ? q.options : []
+      const sel = pending.kbSel.get(i)
+      if (sel && sel.size > 0) {
+        answers.push({ id: q.id, selected: [...sel].sort((a, b) => a - b).map((j) => opts[j]!.label) })
+        continue
+      }
+      const text = pending.textAnswers.get(i)
+      if (text !== undefined) {
+        answers.push(text)
+        continue
+      }
+      return false
+    }
+    ask.answered = true
+    for (const [cid, p] of this.pendingAsks) {
+      if (p.ask === ask) this.pendingAsks.delete(cid)
+    }
+    ask.resolve({ answers })
+    this.enqueueNotice(chatId, '已提交你的回答')
+    return true
+  }
+
   private settleGuiSide(request: unknown): void {
     for (const [chatId, p] of [...this.pendingAsks]) {
       if (p.req !== request) continue
@@ -1646,24 +1725,8 @@ export class TelegramBridge {
     }
   }
 
-  private formatAskPending(questions: TgQuestionItem[]): string {
-    const lines = ['待回答（回复字母选项，或直接输入自定义答案；/cancel 关闭 TG 作答）']
-    questions.forEach((q, i) => {
-      const prefix = questions.length > 1 ? `Q${i + 1}. ` : ''
-      lines.push(`${prefix}${q.question ?? ''}`)
-      const opts = Array.isArray(q.options) ? q.options : []
-      if (opts.length === 0) {
-        lines.push('  （开放问题，直接输入答案）')
-      } else {
-        opts.forEach((o, j) => lines.push(`  [${String.fromCharCode(65 + j)}] ${o.label}${o.description ? ` — ${o.description}` : ''}`))
-        if (q.multiSelect) lines.push('  （可多选，如：A,B）')
-      }
-    })
-    return lines.join('\n')
-  }
-
   private async handleTgAnswer(chatId: number, pending: TgPendingAsk, text: string): Promise<void> {
-    const { questions, ask } = pending
+    const { questions } = pending
     let parts: Array<[number | null, string]>
     if (questions.length === 1) {
       parts = [[0, text.trim()]]
@@ -1676,11 +1739,16 @@ export class TelegramBridge {
         else parts.push([null, line])
       }
       if (parts.some(([idx]) => idx === null)) {
+        // ✏️ free-text route: a question awaiting text absorbs the whole message.
+        const target = [...pending.textWanted].sort((a, b) => a - b)[0]
+        if (target !== undefined) {
+          parts = [[target, text.trim()]]
+        } else {
           await this.enqueueNotice(chatId, `共 ${questions.length} 个问题，请每行用 1:/2: 前缀分别作答`)
           return
         }
       }
-    const answers: Array<{ id?: string; selected: string[]; custom?: string }> = []
+    }
     for (const [idx, raw] of parts) {
       if (idx === null || idx < 0 || idx >= questions.length) {
         await this.enqueueNotice(chatId, `题号 ${(idx ?? 0) + 1} 不存在（共 ${questions.length} 题）`)
@@ -1703,17 +1771,69 @@ export class TelegramBridge {
           }
           selected.push(opts[i]!.label)
         }
-        answers.push({ id: q.id, selected })
+        pending.textAnswers.set(idx, { id: q.id, selected })
       } else {
-        answers.push({ id: q.id, selected: [], custom: cleaned })
+        pending.textAnswers.set(idx, { id: q.id, selected: [], custom: cleaned })
+      }
+      pending.textWanted.delete(idx)
+    }
+    // Keyboard selections take precedence per question; resolve when complete.
+    if (!this.finalizeAskIfComplete(chatId, pending)) {
+      const done = questions.filter((_, i) => pending.kbSel.get(i)?.size || pending.textAnswers.has(i)).length
+      await this.enqueueNotice(chatId, `已记录 ${done}/${questions.length} 题，请继续作答（按钮或 1:/2: 文本）`)
     }
   }
-    ask.answered = true
+
-    for (const [cid, p] of this.pendingAsks) {
+  /** Inline-keyboard tap on an ask message: toggle/record the choice, resolve when every question is answered. */
-      if (p.ask === ask) this.pendingAsks.delete(cid)
+  private async handleAskCallback(chatId: number, cq: { id: string; data?: string }): Promise<void> {
+    const pending = this.pendingAsks.get(String(chatId))
+    if (!pending) {
+      await this.client.answerCallbackQuery(cq.id, '该提问已失效（可能已在 Web 端作答）')
+      return
+    }
+    const payload = (cq.data ?? '').slice(ASK_CB.length)
+    const sep = payload.indexOf(':')
+    const qi = Number(payload.slice(0, sep))
+    const action = payload.slice(sep + 1)
+    const q = pending.questions[qi]
+    if (!q) {
+      await this.client.answerCallbackQuery(cq.id, '题目已失效')
+      return
+    }
+    const opts = Array.isArray(q.options) ? q.options : []
+    if (action === 'custom') {
+      // Free-text path: discard button selections for this question and wait
+      // for the user's next text message (routed via textWanted).
+      pending.kbSel.delete(qi)
+      pending.textWanted.add(qi)
+      await this.client.answerCallbackQuery(cq.id, '请直接发送你的答案文本')
+      return
+    }
+    if (action === 'ok') {
+      if (!pending.kbSel.get(qi)?.size) {
+        await this.client.answerCallbackQuery(cq.id, '请先点选选项')
+        return
+      }
+    } else {
+      const j = Number(action)
+      if (!Number.isInteger(j) || j < 0 || j >= opts.length) {
+        await this.client.answerCallbackQuery(cq.id, '选项不存在')
+        return
+      }
+      if (q.multiSelect) {
+        const set = pending.kbSel.get(qi) ?? new Set<number>()
+        if (set.has(j)) set.delete(j)
+        else set.add(j)
+        pending.kbSel.set(qi, set)
+        await this.client.answerCallbackQuery(cq.id, set.size > 0 ? `已选 ${set.size} 项，选完点"提交所选"` : '已取消该选项')
+      } else {
+        pending.kbSel.set(qi, new Set([j]))
+        await this.client.answerCallbackQuery(cq.id, `已选：${opts[j]!.label}`)
+      }
+    }
+    if (!this.finalizeAskIfComplete(chatId, pending) && action === 'ok') {
+      await this.client.answerCallbackQuery(cq.id, '已提交本题选择，请继续作答其他问题')
     }
-    ask.resolve({ answers })
-    this.enqueueNotice(chatId, '已提交你的回答')
   }
 
   // ── approval: TG answering via dual-path race on the request waterfall ──

src/client.ts

@@ -153,12 +153,17 @@ export class TelegramClient implements TelegramClientLike {
     return message.split(this.token).join('***')
   }
 
-  private async call<T>(method: string, body?: Record<string, unknown>): Promise<T> {
+  private async call<T>(method: string, body?: Record<string, unknown>, timeoutMs = 15_000): Promise<T> {
     const url = `${this.baseUrl}/bot${this.token}/${method}`
     try {
       const init: RequestInit = {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
+        // Without a client-side timeout a stalled proxy connection hangs the
+        // request forever — and the serialized notice queue wedges behind it,
+        // silently swallowing every later tool/ask notice. TimeoutError is
+        // caught below and surfaces as a normal (retryable) failure.
+        signal: AbortSignal.timeout(timeoutMs),
       }
       if (body !== undefined) {
         init.body = JSON.stringify(body)
@@ -187,7 +192,8 @@ export class TelegramClient implements TelegramClientLike {
     if (offset !== undefined) {
       body.offset = offset
     }
-    return this.call<TelegramUpdate[]>('getUpdates', body)
+    // Long-poll: client-side abort must outlive the server-side hold.
+    return this.call<TelegramUpdate[]>('getUpdates', body, this.pollingTimeoutSec * 1000 + 10_000)
   }
 
   async sendMessage(

src/format.ts

@@ -14,6 +14,28 @@ function inlineToHtml(text: string): string {
   return html
 }
 
+/** Convert `> …` line groups into `<blockquote>` (Telegram renders it with the accent-colored left bar). */
+function blocksToHtml(text: string): string {
+  const lines = text.split('\n')
+  const out: string[] = []
+  let quote: string[] = []
+  const flush = (): void => {
+    if (quote.length === 0) return
+    out.push(`<blockquote>${inlineToHtml(quote.join('\n'))}</blockquote>`)
+    quote = []
+  }
+  for (const line of lines) {
+    if (line.startsWith('> ')) quote.push(line.slice(2))
+    else if (line === '>') quote.push('')
+    else {
+      flush()
+      out.push(inlineToHtml(line))
+    }
+  }
+  flush()
+  return out.join('\n')
+}
+
 export function markdownToHtml(text: string): string {
   const parts = text.split(/```[\w-]*/)
   if (parts.length % 2 === 0) return inlineToHtml(text)
@@ -23,7 +45,7 @@ export function markdownToHtml(text: string): string {
       const code = parts[i]!.replace(/^\n/, '').replace(/\n$/, '')
       html += `<pre>${escapeHtml(code)}</pre>`
     } else {
-      html += inlineToHtml(parts[i]!)
+      html += blocksToHtml(parts[i]!)
     }
   }
   return html

src/index.ts

@@ -12,8 +12,8 @@ export interface TelegramChannelConfig {
   allowAllUsers?: boolean
   maxMessageLength?: number
   pollingTimeoutSec?: number
-  /** 'rich' = Telegram native Rich Messages (needs a recent client);
+  /** 默认 'rich' = Telegram native Rich Messages（需较新客户端）；
-   *  anything else (default) = HTML compatibility mode that renders on all clients. */
+   *  显式 'html'/'compat' 等其它值 = 兼容模式，所有客户端可显示。 */
   rendering?: string
 }
 
@@ -23,7 +23,7 @@ export const Config: Schema<TelegramChannelConfig> = Schema.object({
   allowAllUsers: Schema.boolean().default(false),
   maxMessageLength: Schema.number().default(4096),
   pollingTimeoutSec: Schema.number().default(30),
-  rendering: Schema.string().default('html'),
+  rendering: Schema.string().default('rich'),
 })
 
 function resolveAllowedUserIds(config: TelegramChannelConfig): number[] {

tests/bridge.test.ts

@@ -7,6 +7,13 @@ import { TelegramBridge } from '../src/bridge.ts'
 import type { InlineKeyboardMarkup, TelegramClientLike, TelegramUpdate } from '../src/client.ts'
 import { BIND_CB_PREFIX, LAST_CB, MSG } from '../src/commands.ts'
 
+// 防呆（2026-09-14 事故）：binding 落盘路径 = DSH_HOME/telegram-channel-bindings.json。
+// 少数用例直接构造 bridge 并 bind，未设 DSH_TELEGRAM_BINDINGS_FILE，就把 fixture
+// （chatId 10 / live-img-dl）写进了真实文件、覆盖掉用户真实绑定。
+// 这里把 DSH_HOME 指向临时目录兜底：显式 override 的用例仍走自己的临时文件，
+// 漏设的用例只会写进临时 HOME。
+process.env.DSH_HOME = '/tmp/dsh-tg-test-home'
+
 type SentMessage = {
   chatId: number
   text: string