@quecue/dev-notify 0.1.0-alpha.1 → 0.1.0

package/dist/reply-interactions.js

@@ -0,0 +1,269 @@
+import { randomBytes } from 'node:crypto';
+import { setTimeout as delay } from 'node:timers/promises';
+import { ConfigError } from './config.js';
+import { stateTransaction, targetEpoch } from './reply-state.js';
+import { replyHint } from './reply-telegram.js';
+import { finishInteraction } from './reply-outcomes.js';
+export const INTERACTION_MS = 5 * 60 * 1000;
+export function questionsFrom(input) {
+    if (!Array.isArray(input.questions) || input.questions.length < 1 || input.questions.length > 4)
+        throw new ConfigError('问题结构无效，请在本机回答。');
+    const questions = input.questions;
+    const seen = new Set();
+    for (const q of questions) {
+        if (!q || typeof q.question !== 'string' || !q.question.trim() || seen.has(q.question)
+            || typeof q.header !== 'string' || (q.multiSelect !== undefined && typeof q.multiSelect !== 'boolean') || !Array.isArray(q.options)
+            || q.options.length < 2 || q.options.length > 4 || q.options.some(o => !o || typeof o.label !== 'string' || !o.label.trim()
+            || typeof o.description !== 'string') || new Set(q.options.map(o => o.label)).size !== q.options.length) {
+            throw new ConfigError('问题结构无效，请在本机回答。');
+        }
+        seen.add(q.question);
+    }
+    return structuredClone(questions);
+}
+export async function createInteraction(access, target, kind, input, call) {
+    if (kind === 'permission' && access.policy.permissions !== true)
+        throw new ConfigError('未授权远程处理工具权限。');
+    const questions = kind === 'question' ? questionsFrom(input) : [];
+    const value = { id: randomBytes(16).toString('hex'), session: target.session, epoch: targetEpoch(target),
+        updated: Date.now(), expires: Date.now() + INTERACTION_MS, kind, input: structuredClone(input), questions,
+        answers: {}, selected: [], index: 0, call, receipts: [], messages: [] };
+    await stateTransaction(access, state => {
+        const current = state.sessions[target.session];
+        if (!current || targetEpoch(current) !== value.epoch)
+            throw new ConfigError('会话目标发生了变化。');
+        if (call) {
+            const bound = state.calls[call];
+            if (!bound || bound.ended || bound.request || bound.epoch !== value.epoch)
+                throw new ConfigError('调用已经结束或已绑定，没有创建远程问题。');
+            bound.request = value.id;
+        }
+        // 不同 tool_use_id 可并行；无绑定的单元级调用仍只保留一个活动交互。
+        if (!call)
+            for (const old of Object.values(state.requests))
+                if (old.session === target.session && !old.result) {
+                    finishInteraction(old, { kind: old.claimed ? 'unknown' : 'not-applied', text: '问题已切换，旧请求不再接受答案。' });
+                }
+        state.requests[value.id] = value;
+        state.entries['token:' + value.id] = { session: target.session, epoch: value.epoch, request: value.id, updated: Date.now() };
+    });
+    return value;
+}
+function active(value) {
+    return !!value && !value.result && !value.response && !value.claimed && value.expires > Date.now();
+}
+export function interactionMarkup(value) {
+    const prefix = `dn:q:${value.id}:${value.index}:`;
+    const buttons = [];
+    if (value.kind === 'permission') {
+        buttons.push([{ text: '✅ 本次允许', callback_data: prefix + 'a' }, { text: '⛔ 拒绝', callback_data: prefix + 'd' }]);
+        buttons.push([{ text: '✍️ 自定义拒绝说明', callback_data: prefix + 'c' }]);
+    }
+    else {
+        const q = value.questions[value.index];
+        q.options.forEach((option, index) => buttons.push([{ text: (value.selected.includes(index) ? '☑ ' : '') + Array.from(option.label).slice(0, 60).join(''), callback_data: prefix + 'o' + index }]));
+        if (q.multiSelect)
+            buttons.push([{ text: '提交所选项', callback_data: prefix + 's' }]);
+        buttons.push([{ text: '✍️ 自定义输入', callback_data: prefix + 'c' }]);
+    }
+    buttons.push([{ text: '关闭远程答题（本机仍可操作）', callback_data: prefix + 'l' }]);
+    return { inline_keyboard: buttons };
+}
+export function interactionContent(value) {
+    if (value.kind === 'permission')
+        return '工具：' + String(value.input.tool_name || '未知') + '\n\n' + JSON.stringify(value.input.tool_input ?? {}, null, 2)
+            + '\n\n这里处理本次的允许、拒绝或自定义拒绝说明。Claude 没有提供完整的本地按钮列表，因此这里也不会创建永久权限规则。';
+    const q = value.questions[value.index];
+    return `问题 ${value.index + 1}/${value.questions.length}：${q.question}\n\n`
+        + q.options.map((o, i) => `${i + 1}. ${o.label}\n${o.description}${o.preview ? '\n' + o.preview : ''}`).join('\n\n')
+        + (q.multiSelect ? '\n\n可多选，选好后点击「提交所选项」；也可自定义输入。' : '\n\n点击选项直接回答，或选择自定义输入。')
+        + '\n本机原生窗口也可以同时作答；Claude 先收到的完整答案生效。远程窗口有效期为 5 分钟，不会自动选择。';
+}
+// 飞书卡片没有回调按钮，只展示全部题目和跳转入口；逐题编号并空行分隔，避免题目与选项粘连。
+export function questionsContent(questions) {
+    return questions.map((q, index) => `问题 ${index + 1}/${questions.length}：${q.question}\n\n`
+        + q.options.map((o, i) => `${i + 1}. ${o.label}\n${o.description}${o.preview ? '\n' + o.preview : ''}`).join('\n\n')
+        + (q.multiSelect ? '\n\n可多选：进入 Telegram 后逐项选择，再点击「提交所选项」；也可自定义输入。'
+            : '\n\n进入 Telegram 后点击选项直接回答，或选择自定义输入。')).join('\n\n────────\n\n');
+}
+export async function showInteraction(access, id, chat, api) {
+    const value = await stateTransaction(access, state => state.requests[id]);
+    if (!active(value)) {
+        await replyHint(api, chat, '⚠️ 交互已失效', '请从最新通知进入，或回到本机处理。');
+        return;
+    }
+    // 使用通知分段器发送较长选项，所有选项正文保留，只有最后一段附选择按钮。
+    const { makePlan, deliver } = await import('./channels.js');
+    const { config } = access;
+    const plan = makePlan('telegram', { title: 'Claude Code 需要你处理', content: interactionContent(value), footer: '', level: 'warn' }, { ...config, telegram: { ...config.telegram, chatIds: [chat] } });
+    plan.items[plan.items.length - 1].payload.reply_markup = interactionMarkup(value);
+    plan.onSent = async (item, response) => {
+        const message = response.result?.message_id;
+        if (!Number.isSafeInteger(message))
+            throw new ConfigError('交互通知没有返回消息 ID。');
+        await stateTransaction(access, state => {
+            const current = state.requests[id];
+            if (current) {
+                state.entries[`tg:${chat}:${message}`] = { session: value.session, epoch: value.epoch, request: id, question: value.index, updated: Date.now() };
+                // 发送期间可能由本机先答；仍登记消息，随后移除过期按钮。
+                (current.messages ??= []).push({ chat, message });
+            }
+        });
+    };
+    // 完整分段及按钮投递成功后才覆盖通用提醒；重发失败时恢复该接收人的兜底提醒。
+    await stateTransaction(access, state => {
+        const current = state.requests[id];
+        if (current?.notified?.telegram)
+            current.notified.telegram = current.notified.telegram.filter(user => user !== chat);
+    });
+    // API 封装由测试或真实桥接注入，不另建网络连接。
+    const result = await deliver(plan, config, async (_url, payload) => ({ ok: true, result: await api('sendMessage', payload) }));
+    if (!result.ok)
+        throw new ConfigError('交互通知没有完整发送，请回到本机处理。');
+    await stateTransaction(access, state => {
+        const current = state.requests[id];
+        if (!current)
+            return;
+        current.notified ??= {};
+        const users = current.notified.telegram ??= [];
+        if (!users.includes(chat))
+            users.push(chat);
+    });
+}
+function answer(value, text) {
+    const q = value.questions[value.index];
+    Object.defineProperty(value.answers, q.question, { value: text, enumerable: true, writable: true, configurable: true });
+    value.selected = [];
+    value.index++;
+    if (value.index === value.questions.length)
+        value.response = {
+            hookSpecificOutput: { hookEventName: 'PermissionRequest', decision: { behavior: 'allow', updatedInput: { ...value.input, questions: value.input.questions, answers: { ...value.answers } } } },
+        };
+}
+export async function handleInteractionCallback(access, callback, chat, api) {
+    if (typeof callback.data !== 'string' || !callback.data.startsWith('dn:q:'))
+        return false;
+    const match = callback.data.match(/^dn:q:([a-f0-9]{32}):(\d):([adcls]|o[0-3])$/);
+    if (!match || typeof callback.id !== 'string')
+        return true;
+    const [, id, index, operation] = match;
+    const outcome = await stateTransaction(access, state => {
+        const value = state.requests[id], target = value && state.sessions[value.session];
+        if (!active(value) || value.index !== Number(index) || !target || targetEpoch(target) !== value.epoch)
+            return 'expired';
+        if (operation === 'l') {
+            finishInteraction(value, { kind: 'not-applied', text: '已关闭远程答题，本机仍可正常处理。' });
+            return 'local';
+        }
+        const question = value.questions[value.index]?.question;
+        const previousIndex = value.index;
+        if (value.kind === 'permission') {
+            if (access.policy.permissions !== true)
+                return 'expired';
+            if (operation === 'a' || operation === 'd') {
+                value.response = { hookSpecificOutput: { hookEventName: 'PermissionRequest', decision: { behavior: operation === 'a' ? 'allow' : 'deny' } } };
+            }
+            else if (operation !== 'c')
+                return 'expired';
+        }
+        else {
+            const q = value.questions[value.index];
+            if (operation.startsWith('o')) {
+                const selected = Number(operation.slice(1));
+                if (!q.options[selected])
+                    return 'expired';
+                if (q.multiSelect)
+                    value.selected = value.selected.includes(selected) ? value.selected.filter(i => i !== selected) : [...value.selected, selected].sort();
+                else
+                    answer(value, q.options[selected].label);
+            }
+            else if (operation === 's' && q.multiSelect && value.selected.length)
+                answer(value, value.selected.map(i => q.options[i].label).join(','));
+            else if (operation !== 'c')
+                return 'expired';
+        }
+        if (value.index !== previousIndex || value.response)
+            (value.receipts ??= []).push({ id: callback.id, chat,
+                message: callback.message.message_id, question, answer: value.kind === 'question' ? value.answers[question] : operation === 'a' ? 'allow' : 'deny' });
+        return operation === 'c' ? 'custom' : value.response ? 'done' : value.index !== previousIndex ? 'answered' : 'next';
+    });
+    await api('answerCallbackQuery', { callback_query_id: callback.id,
+        text: outcome === 'expired' ? '没有提交：按钮已失效，或已有答案等待确认。' : outcome === 'local' ? '已关闭远程答题，本机不受影响。' : outcome === 'done' || outcome === 'answered' ? '答案已登记，尚未确认生效。' : '已更新。' }).catch(() => { });
+    if (outcome === 'done' || outcome === 'answered')
+        await replyHint(api, chat, '⏳ 答案已登记，等待确认', (outcome === 'answered' ? '仍需完成其余问题，之后才回传整份答案。' : '已进入回传流程，Claude 是否采用会在稍后反馈。')
+            + '\n稍后会反馈结果；如果一直没有收到，请检查终端。\n请求：' + id.slice(0, 8)).catch(() => { });
+    if (outcome === 'expired')
+        await replyHint(api, chat, '⚠️ 本次提交未生效', '这次操作没有提交：问题已处理、过期、题目已切换，或已有答案等待确认。\n请求：' + id.slice(0, 8)).catch(() => { });
+    if (outcome === 'custom') {
+        const value = await stateTransaction(access, state => state.requests[id]);
+        if (!active(value))
+            return true;
+        const sent = await replyHint(api, chat, '✍️ 自定义输入', value.kind === 'permission' ? '请回复这条消息，填写拒绝说明。这段说明不会批准权限。' : '请回复这条消息，输入这个问题的完整答案。', callback.message.message_id, { force_reply: true, selective: true });
+        if (Number.isSafeInteger(sent?.message_id))
+            await stateTransaction(access, state => {
+                state.entries[`tg:${chat}:${sent.message_id}`] = { session: value.session, epoch: value.epoch, request: id, question: value.index, updated: Date.now() };
+            });
+    }
+    else if (outcome === 'next' || outcome === 'answered')
+        await showInteraction(access, id, chat, api);
+    return true;
+}
+export async function handleInteractionText(access, id, chat, message, api) {
+    const text = message.text;
+    if (!text.trim() || Array.from(text).length > 4000) {
+        await replyHint(api, chat, '❌ 答案没有提交', '请输入不超过 4000 字符的答案；内容不会被截断。', message.message_id);
+        return;
+    }
+    const outcome = await stateTransaction(access, state => {
+        const value = state.requests[id], target = value && state.sessions[value.session];
+        const entry = state.entries[`tg:${chat}:${message.reply_to_message.message_id}`];
+        if (!active(value) || !target || targetEpoch(target) !== value.epoch || entry?.question !== value.index)
+            return 'expired';
+        const question = value.questions[value.index]?.question;
+        if (value.kind === 'permission') {
+            if (access.policy.permissions !== true)
+                return 'expired';
+            value.response = { hookSpecificOutput: { hookEventName: 'PermissionRequest', decision: { behavior: 'deny', message: text } } };
+        }
+        else
+            answer(value, text);
+        (value.receipts ??= []).push({ id: `text:${chat}:${message.message_id}`, chat, message: message.message_id,
+            question, answer: value.kind === 'question' ? text : 'deny', custom: true });
+        return value.response ? 'done' : 'next';
+    });
+    await replyHint(api, chat, outcome === 'expired' ? '⚠️ 本次提交未生效' : '⏳ 答案已登记，等待确认', (outcome === 'done' ? '等待 Claude 确认，稍后会反馈最终结果；如果一直没有收到，请检查终端。'
+        : outcome === 'next' ? '仍需完成其余问题，之后才会回传整份答案；目前还没有生效。'
+            : '这次操作没有提交：对应问题已经结束、过期、切换，或已有答案等待确认。') + '\n请求：' + id.slice(0, 8));
+    if (outcome === 'next')
+        await showInteraction(access, id, chat, api);
+}
+export async function waitInteraction(access, value, fresh, options = {}) {
+    const end = Math.min(value.expires, Date.now() + (options.timeout ?? INTERACTION_MS));
+    while (Date.now() < end && !options.signal?.aborted) {
+        const current = await fresh();
+        if (!current || current.identity !== access.identity || (value.kind === 'permission' && current.policy.permissions !== true))
+            return null;
+        const response = await stateTransaction(access, state => {
+            const request = state.requests[value.id], target = state.sessions[value.session];
+            if (!request || request.result || !target || targetEpoch(target) !== value.epoch || (request.call && (!state.calls[request.call] || state.calls[request.call].ended)))
+                return { ended: true };
+            if (!request.response || request.claimed || options.signal?.aborted)
+                return null;
+            request.claimed = true;
+            // 回传后等待独立的完成事件确认；不能在这里删除请求或报告成功。
+            request.expires = Date.now() + INTERACTION_MS;
+            return { response: request.response };
+        });
+        if (response?.ended)
+            return null;
+        if (response?.response)
+            return response.response;
+        await (options.sleep ?? delay)(200);
+    }
+    await stateTransaction(access, state => {
+        const request = state.requests[value.id];
+        if (request && !request.result)
+            finishInteraction(request, { kind: request.claimed ? 'unknown' : 'not-applied', text: options.signal?.aborted ? '交互等待已取消，远程答案是否生效还没有确认。' : '远程交互等待超时，尚未确认生效。你仍可在本机继续处理。' });
+    });
+    return null;
+}

package/dist/reply-outcomes.js

@@ -0,0 +1,182 @@
+import { digest, stateTransaction, targetEpoch } from './reply-state.js';
+import { replyHint } from './reply-telegram.js';
+// PermissionRequest 没有 tool_use_id：只接受唯一且尚未结束的同输入调用，歧义时保留本机处理。
+function canonical(value) {
+    if (Array.isArray(value))
+        return value.map(canonical);
+    if (value && typeof value === 'object')
+        return Object.fromEntries(Object.keys(value).sort().map(key => [key, canonical(value[key])]));
+    return value;
+}
+export const inputFingerprint = (value) => digest(JSON.stringify(canonical(value)) ?? 'null');
+export const callKey = (session, id) => digest(JSON.stringify([session, id]));
+export function finishInteraction(value, result) {
+    if (value.result)
+        return;
+    value.result = result;
+    for (const receipt of value.receipts ?? [])
+        receipt.result ??= result;
+    // 留下短期结果和消息 ID，用于反馈及旧按钮；不保留已结束的问题、参数和答案正文。
+    value.input = {};
+    value.questions = [];
+    value.answers = {};
+    value.selected = [];
+    delete value.response;
+    for (const receipt of value.receipts ?? []) {
+        receipt.answer = '';
+        delete receipt.question;
+    }
+}
+export function endSessionInteractions(state, session, reason) {
+    for (const call of Object.values(state.calls))
+        if (call.session === session)
+            call.ended = true;
+    for (const value of Object.values(state.requests))
+        if (value.session === session && !value.result)
+            finishInteraction(value, {
+                kind: value.claimed ? 'unknown' : 'not-applied',
+                text: value.claimed ? reason + '；还没有收到本次答案的生效确认，请检查终端。' : reason + '；这次远程答案没有回传。',
+            });
+}
+export async function registerToolCall(access, target, data) {
+    if (typeof data.tool_use_id !== 'string' || !data.tool_use_id || typeof data.tool_name !== 'string' || !data.tool_input)
+        return;
+    const key = callKey(target.session, data.tool_use_id);
+    await stateTransaction(access, state => {
+        if (state.calls[key])
+            return;
+        const previous = state.sessions[target.session];
+        state.sessions[target.session] = { ...target, working: true, latestCall: key, tracked: previous?.tracked === true && targetEpoch(previous) === targetEpoch(target) };
+        state.calls[key] = { id: data.tool_use_id, session: target.session, epoch: targetEpoch(target), tool: data.tool_name,
+            fingerprint: inputFingerprint(data.tool_input), prompt: typeof data.prompt_id === 'string' ? data.prompt_id : undefined, updated: Date.now() };
+        // 正常工具不一定有权限请求，限制关联索引大小。丢失索引只会回到本机，不会猜目标。
+        const old = Object.entries(state.calls).filter(([, call]) => !call.request).sort((a, b) => a[1].updated - b[1].updated);
+        for (const [id] of old.slice(0, Math.max(0, old.length - 256)))
+            delete state.calls[id];
+    });
+}
+export function matchingCall(state, target, data) {
+    const fingerprint = inputFingerprint(data.tool_input);
+    const matches = Object.entries(state.calls).filter(([, call]) => call.session === target.session && call.epoch === targetEpoch(target)
+        && call.tool === data.tool_name && call.fingerprint === fingerprint
+        && (typeof data.prompt_id !== 'string' || call.prompt === data.prompt_id));
+    // 包括已结束的同内容记录，防止迟到的 PermissionRequest 误绑到重复的新题。
+    if (matches.length !== 1 || matches[0][1].ended || matches[0][1].request || Date.now() - matches[0][1].updated > 300000)
+        return;
+    return matches[0][0];
+}
+function sameAnswer(actual, expected, multi) {
+    if (!multi)
+        return actual === expected;
+    const parts = (value) => [...(Array.isArray(value) ? value : value.split(',')).map(s => s.trim())].sort();
+    return (typeof actual === 'string' || Array.isArray(actual) && actual.every(s => typeof s === 'string'))
+        && JSON.stringify(parts(actual)) === JSON.stringify(parts(expected));
+}
+export async function completeToolCall(access, data) {
+    if (typeof data.session_id !== 'string' || typeof data.tool_use_id !== 'string')
+        return;
+    await stateTransaction(access, state => {
+        const call = state.calls[callKey(data.session_id, data.tool_use_id)];
+        if (!call || call.tool !== data.tool_name)
+            return;
+        call.ended = true;
+        const value = call.request && state.requests[call.request];
+        if (!value || value.result)
+            return;
+        if (data.hook_event_name === 'PostToolUse' && value.kind === 'question') {
+            const output = data.tool_response;
+            const answers = output?.answers;
+            const valid = answers && typeof answers === 'object' && !Array.isArray(answers);
+            const answered = !output?.afkTimeoutMs && output?.followUp !== true && !(typeof output?.response === 'string' && output.response.trim());
+            for (const receipt of value.receipts ?? []) {
+                const q = value.questions.find(q => q.question === receipt.question);
+                const exists = valid && answered && receipt.question !== undefined && Object.hasOwn(answers, receipt.question)
+                    && !output.annotations?.[receipt.question]?.unanswered;
+                receipt.result = !value.claimed ? { kind: 'not-applied', text: '本机或其他端已经先处理了，这次 Telegram 答案没有提交。' }
+                    : !valid ? { kind: 'unknown', text: 'Claude 已经结束了这个问题，但没有返回可核实的结果。请检查终端。' }
+                        : exists && sameAnswer(answers[receipt.question], receipt.answer, q?.multiSelect === true && receipt.custom !== true && q.options.every(o => !o.label.includes(',')))
+                            ? { kind: 'applied', text: 'Claude 已确认采用了与你提交内容一致的答案。如果本机也提交了相同内容，这次结果无法说明是哪一方生效。' }
+                            : { kind: 'not-applied', text: 'Claude 已经结束问题，但没有采用你提交的答案；本机或其他端可能已经先处理。' };
+            }
+            finishInteraction(value, { kind: 'not-applied', text: '问题已处理，旧按钮已失效。' });
+        }
+        else if (data.hook_event_name === 'PostToolUse' && value.kind === 'permission') {
+            const allow = value.claimed && value.receipts?.some(r => r.answer === 'allow');
+            finishInteraction(value, allow
+                ? { kind: 'applied', text: '工具已获准并执行完成。如果本机同时也批准了，完成事件本身无法说明是哪一方放行。' }
+                : { kind: 'not-applied', text: '工具已经获准执行，这次远程决定没有阻止执行。' });
+        }
+        else
+            finishInteraction(value, { kind: value.claimed ? 'unknown' : 'not-applied', text: value.claimed
+                    ? '工具执行失败、被拒绝或取消。这个事件无法说明远程决定是否生效，请检查终端。'
+                    : '请求失败、被拒绝或取消，这次远程决定没有回传。' });
+    });
+}
+export async function drainInteractionFeedback(access, api, fresh, log = () => { }) {
+    const current = await fresh();
+    if (!current || current.identity !== access.identity)
+        return;
+    const work = await stateTransaction(access, state => {
+        for (const value of Object.values(state.requests)) {
+            const target = state.sessions[value.session];
+            if (!value.result && (!target || targetEpoch(target) !== value.epoch || value.expires <= Date.now()))
+                finishInteraction(value, {
+                    kind: value.claimed ? 'unknown' : 'not-applied', text: value.claimed
+                        ? '等待生效确认超时，或会话已经切换。结果暂时未知，请检查终端。'
+                        : '交互已过期或会话已结束；远程答案没有回传，你仍可在本机界面继续处理。',
+                });
+        }
+        return Object.values(state.requests).filter(value => value.result || value.receipts?.some(r => r.result));
+    });
+    for (const value of work) {
+        for (const receipt of value.receipts ?? []) {
+            if (!receipt.result || receipt.delivery)
+                continue;
+            const authorized = await fresh();
+            if (!authorized || authorized.identity !== access.identity || !authorized.policy.users.includes(receipt.chat))
+                return;
+            const claimed = await stateTransaction(access, state => {
+                const actual = state.requests[value.id]?.receipts?.find(r => r.id === receipt.id);
+                if (!actual?.result || actual.delivery)
+                    return false;
+                actual.delivery = 'sending';
+                return true;
+            });
+            if (!claimed)
+                continue;
+            let delivery = 'sent';
+            try {
+                const title = receipt.result.kind === 'applied' ? '✅ 答案内容已生效' : receipt.result.kind === 'not-applied' ? '⚠️ 本次提交未生效' : '⚠️ 提交结果暂时无法确认';
+                await replyHint(api, receipt.chat, title, receipt.result.text + '\n请求：' + value.id.slice(0, 8));
+            }
+            catch {
+                delivery = 'unknown';
+                log('Telegram 结果反馈没有发送成功。不会自动重发，已经采用的答案不受影响。');
+            }
+            await stateTransaction(access, state => {
+                const actual = state.requests[value.id]?.receipts?.find(r => r.id === receipt.id);
+                if (actual)
+                    actual.delivery = delivery;
+            });
+        }
+        if (!value.result)
+            continue;
+        for (const message of value.messages ?? []) {
+            if (message.cleared)
+                continue;
+            const authorized = await fresh();
+            if (!authorized || authorized.identity !== access.identity || !authorized.policy.users.includes(message.chat))
+                return;
+            // 最多尝试一次移除按钮；编辑失败时旧回调仍由服务端状态拒绝。
+            await stateTransaction(access, state => {
+                const actual = state.requests[value.id]?.messages?.find(m => m.chat === message.chat && m.message === message.message);
+                if (actual)
+                    actual.cleared = true;
+            });
+            const label = value.result.kind === 'unknown' ? '已关闭 · 结果待核实' : value.result.text.includes('过期') ? '已过期 · 不再接受答案' : '已处理 · 不再接受答案';
+            await api('editMessageReplyMarkup', { chat_id: message.chat, message_id: message.message,
+                reply_markup: { inline_keyboard: [[{ text: label, callback_data: `dn:q:${value.id}:0:l` }]] } })
+                .catch(() => log('Telegram 旧按钮没有移除成功。服务端仍会拒绝这个请求。'));
+        }
+    }
+}