@quecue/dev-notify 0.1.0-alpha.3 → 0.1.1

package/dist/reply-bridge.js

@@ -44,7 +44,7 @@ export async function stopBridge(file) {
 export async function startBridge(file, env = process.env) {
     const access = await accessReplies(file, env);
     if (!access)
-        throw new ConfigError('远程回复未授权，请先运行 reply setup');
+        throw new ConfigError('远程回复尚未授权，请先运行 reply setup。');
     const existing = await bridgeStatus(file);
     if (existing.running)
         return existing.ready;
@@ -72,7 +72,7 @@ export async function runBridge(file, options = {}) {
     const env = options.env ?? process.env;
     let access = await accessReplies(file, env);
     if (!access)
-        throw new ConfigError('远程回复未授权');
+        throw new ConfigError('远程回复尚未授权。');
     const directory = replyDirectory(file);
     await mkdir(directory, { recursive: true, mode: 0o700 });
     const botDirectory = path.join(appPaths(process.platform, env).data, 'reply-bots');
@@ -83,7 +83,7 @@ export async function runBridge(file, options = {}) {
         lock = await open(lockPath, 'wx', 0o600);
     }
     catch {
-        throw new ConfigError('本用户已有相同 Bot 桥接或残留锁；不会并发轮询。确认进程退出后再处理 reply-bots 中对应锁');
+        throw new ConfigError('当前用户已经有同一个 Bot 的桥接在运行，或残留了锁文件。请确认进程退出后，再处理 reply-bots 中对应的锁。');
     }
     const owner = randomBytes(16).toString('hex'), lease = { pid: process.pid, owner, ready: false, updated: Date.now() };
     let stopping = false;
@@ -100,7 +100,7 @@ export async function runBridge(file, options = {}) {
         let api = (options.api ?? (value => telegramApi(value.config.telegram.token)))(access);
         const webhook = await api('getWebhookInfo', {});
         if (webhook?.url)
-            throw new ConfigError('Bot 已设置 webhook，不能同时使用 getUpdates；不会自动删除 webhook');
+            throw new ConfigError('这个 Bot 已经设置了 webhook，不能同时使用 getUpdates。请先移除 webhook；本工具不会自动删除。');
         await api('getMe', {});
         const currentState = await stateTransaction(access, state => ({ offset: state.offset, empty: Object.keys(state.entries).length === 0 }));
         if (!currentState.offset && currentState.empty) {
@@ -139,9 +139,9 @@ export async function runBridge(file, options = {}) {
             catch (error) {
                 if (error instanceof ConfigError && /冲突/.test(error.message))
                     throw error;
-                log('Telegram 轮询失败；秘密和服务端正文未记录。');
+                log('Telegram 轮询失败；日志中没有记录密钥或服务端正文。');
                 if (++failures >= 5)
-                    throw new ConfigError('Telegram 连续轮询失败 5 次，桥接已退出；请检查网络、Token 或 API 冲突后重新启动');
+                    throw new ConfigError('Telegram 连续轮询失败 5 次，桥接已经退出。请检查网络、Token 或 API 冲突后重新启动。');
                 lease.updated = Date.now();
                 await atomicJson(leasePath(file), lease);
                 await (options.sleep ?? delay)(3000);
@@ -152,7 +152,7 @@ export async function runBridge(file, options = {}) {
             if (!after || after.identity !== access.identity || await isStopped())
                 break;
             if (!Array.isArray(updates))
-                throw new ConfigError('Telegram 更新格式无效');
+                throw new ConfigError('Telegram 更新格式无效。');
             for (const update of updates) {
                 if (await isStopped())
                     break;
@@ -160,7 +160,7 @@ export async function runBridge(file, options = {}) {
                     await processUpdate(access, update, context);
                 }
                 catch {
-                    log('回复处理失败；更新不重放，请检查终端或从最新通知重试。');
+                    log('回复处理失败。这条更新不会重放；请检查终端，或从最新通知重试。');
                 }
             }
             if (updates.length)
@@ -173,7 +173,7 @@ export async function runBridge(file, options = {}) {
     }
     catch (error) {
         lease.ready = false;
-        lease.error = error instanceof ConfigError ? error.message : '桥接启动或运行失败，未输出底层错误';
+        lease.error = error instanceof ConfigError ? error.message : '桥接启动或运行失败；为避免泄露密钥，没有显示底层错误。';
         await atomicJson(leasePath(file), lease).catch(() => { });
         throw error;
     }

package/dist/reply-engine.js

@@ -22,17 +22,22 @@ export async function resolveEntry(access, key, context) {
         return null;
     return resolved;
 }
-async function prompt(access, chat, messageId, key, context) {
+// autoReply：Telegram 内联按钮沿用 force_reply，点击后自动进入回复状态。
+// 飞书跳转使用普通提示 + remove_keyboard：清除客户端缓存的旧强制回复目标，但不拉起新的回复框。
+async function prompt(access, chat, messageId, key, context, autoReply = true) {
     const resolved = await resolveEntry(access, key, context);
     if (!resolved) {
-        await replyHint(context.api, chat, '⚠️ 无法回复', '该会话已关闭、切换或通知过期，请从最新通知进入。', messageId);
+        await replyHint(context.api, chat, '⚠️ 无法回复', '这个会话已经关闭、切换，或这条通知已过期。请从最新通知进入。', messageId);
         return;
     }
     if (resolved.entry.request) {
         await showInteraction(access, resolved.entry.request, chat, context.api);
         return;
     }
-    const sent = await replyHint(context.api, chat, '💬 回复 Claude', '请回复此消息输入内容。该输入将提交到对应本机会话。\n会话：' + (resolved.target.title || resolved.target.session), messageId, { force_reply: true, selective: true });
+    const session = resolved.target.title || resolved.target.session;
+    const sent = autoReply
+        ? await replyHint(context.api, chat, '💬 回复 Claude', '请回复此消息输入内容。该输入将提交到对应本机会话。\n会话：' + session, messageId, { force_reply: true, selective: true })
+        : await replyHint(context.api, chat, '💬 回复 Claude', '请长按这条消息并选择「回复」，然后输入内容。该输入将提交到对应本机会话。\n会话：' + session, messageId, { remove_keyboard: true });
     if (Number.isSafeInteger(sent?.message_id))
         await stateTransaction(access, state => { state.entries[`tg:${chat}:${sent.message_id}`] = resolved.entry; });
 }
@@ -48,9 +53,9 @@ export async function processUpdate(access, update, context) {
         if (chat && current?.identity === access.identity && current.policy.users.includes(chat)) {
             if (typeof update?.callback_query?.id === 'string')
                 await context.api('answerCallbackQuery', {
-                    callback_query_id: update.callback_query.id, text: '处理失败或结果未知，请检查终端；不会自动重复提交',
+                    callback_query_id: update.callback_query.id, text: '处理没有完成，请检查终端；不会自动重复提交。',
                 }).catch(() => { });
-            await replyHint(context.api, chat, '⚠️ 本次提交结果无法确认', '处理发生异常，无法确认是否已登记或采用。请检查终端及后续结果反馈；不会自动重复提交。').catch(() => { });
+            await replyHint(context.api, chat, '⚠️ 本次提交没有完成', '处理时出现了异常，这次提交可能已经登记，也可能没有生效。请检查终端和后续结果；不会自动重复提交。').catch(() => { });
         }
         throw error;
     }
@@ -78,8 +83,8 @@ async function processAuthorizedUpdate(access, update, context) {
         if (typeof value === 'string' && value.startsWith('dn:q:')) {
             const id = value.split(':')[2];
             if (!/^[a-f0-9]{32}$/.test(id) || !await resolveEntry(access, 'token:' + id, context)) {
-                await context.api('answerCallbackQuery', { callback_query_id: callback.id, text: '会话已关闭或交互已失效' }).catch(() => { });
-                await replyHint(context.api, chat, '⚠️ 本次提交未生效', '会话已关闭、切换或交互已失效；未回传答案。').catch(() => { });
+                await context.api('answerCallbackQuery', { callback_query_id: callback.id, text: '会话已关闭，或这次交互已经失效。' }).catch(() => { });
+                await replyHint(context.api, chat, '⚠️ 这次提交没有生效', '会话已经关闭、切换，或交互已经失效，答案没有回传。').catch(() => { });
                 return;
             }
             if (await handleInteractionCallback(access, callback, chat, context.api))
@@ -102,11 +107,12 @@ async function processAuthorizedUpdate(access, update, context) {
     if (!current.policy.users.includes(chat))
         return;
     if (typeof message.date === 'number' && Date.now() / 1000 - message.date > 300) {
-        await replyHint(context.api, chat, '⚠️ 本次提交未生效', '这条输入消息已超过有效时间，未回传；请查看最新问题或终端状态。');
+        await replyHint(context.api, chat, '⚠️ 本次提交没有生效', '这条消息已经超过有效时间，答案没有回传。请查看最新问题或终端状态。');
         return;
     }
     if (/^\/start\s+[a-f0-9]{32}$/.test(text)) {
-        await prompt(access, chat, message.message_id, 'token:' + text.split(/\s+/)[1], context);
+        // 飞书跳转：只发普通提示并清除旧键盘状态，不自动进入回复。
+        await prompt(access, chat, message.message_id, 'token:' + text.split(/\s+/)[1], context, false);
         return;
     }
     const replyTo = message.reply_to_message?.message_id;
@@ -116,7 +122,7 @@ async function processAuthorizedUpdate(access, update, context) {
     }
     const resolved = await resolveEntry(access, `tg:${chat}:${replyTo}`, context);
     if (!resolved) {
-        await replyHint(context.api, chat, '⚠️ 无法回复', '通知已过期或对应会话已关闭、切换，请从最新通知回复。', message.message_id);
+        await replyHint(context.api, chat, '⚠️ 无法回复', '通知已过期，或对应会话已经关闭、切换。请从最新通知回复。', message.message_id);
         return;
     }
     if (resolved.entry.request) {
@@ -128,14 +134,14 @@ async function processAuthorizedUpdate(access, update, context) {
         safe = sanitizeReply(message.text);
     }
     catch (error) {
-        await replyHint(context.api, chat, '❌ 未提交回复', error instanceof ConfigError ? error.message : '输入无效', message.message_id);
+        await replyHint(context.api, chat, '❌ 回复没有提交', error instanceof ConfigError ? error.message : '输入无效。', message.message_id);
         return;
     }
     const id = randomBytes(16).toString('hex');
     const queued = await stateTransaction(access, state => {
         const target = state.sessions[resolved.target.session];
         if (!target || sessionEpoch(target) !== resolved.entry.epoch)
-            throw new ConfigError('会话已变化，未提交');
+            throw new ConfigError('会话已经变化，这次回复没有提交。');
         if (state.pending[target.session] && Date.now() - state.pending[target.session].updated < 5 * 60 * 1000)
             return null;
         state.pending[target.session] = { hash: textHash(safe), text: safe, epoch: resolved.entry.epoch, id, updated: Date.now(), queued: target.working,
@@ -143,7 +149,7 @@ async function processAuthorizedUpdate(access, update, context) {
         return target.working;
     });
     if (queued === null) {
-        await replyHint(context.api, chat, '⏳ 未提交新回复', '该会话已有未确认回复，请等待收到确认或检查本机终端后再试。', message.message_id);
+        await replyHint(context.api, chat, '⏳ 新回复没有提交', '这个会话已有一条待确认的回复。请先等待确认，或检查本机终端后再试。', message.message_id);
         return;
     }
     if (queued)
@@ -164,9 +170,9 @@ export async function drainReplies(access, context) {
             if (!current || current.identity !== access.identity || !current.policy.users.includes(pending.chat))
                 return;
             if (Date.now() - pending.updated > 5 * 60 * 1000)
-                throw new ConfigError('排队回复已超过 5 分钟，未提交；请检查本机后重新回复');
+                throw new ConfigError('排队的回复已超过 5 分钟，没有提交。请检查本机后重新回复。');
             if (!target.tracked || pending.epoch !== sessionEpoch(target) || !await (context.validate ?? (value => validateTarget(value)))(target))
-                throw new ConfigError('会话已关闭或切换，未提交');
+                throw new ConfigError('会话已经关闭或切换，这次回复没有提交。');
             const text = pending.text;
             const claimed = await stateTransaction(access, state => {
                 const actual = state.pending[target.session], active = state.sessions[target.session];
@@ -183,7 +189,7 @@ export async function drainReplies(access, context) {
             if (!final || final.identity !== access.identity)
                 return;
             await (context.inject ?? ((value, content) => injectReply(value, content)))(target, text);
-            await replyHint(context.api, pending.chat, '✅ 已转发给 Claude', '终端输入已提交，等待 UserPromptSubmit 确认；这不等于 Claude 已开始处理。', pending.message);
+            await replyHint(context.api, pending.chat, '✅ 已转发给 Claude', '终端输入已提交，正在等待 UserPromptSubmit 确认。', pending.message);
         }
         catch (error) {
             await stateTransaction(access, state => {
@@ -193,7 +199,7 @@ export async function drainReplies(access, context) {
                     delete value.text;
                 }
             });
-            await replyHint(context.api, pending.chat, '⚠️ 转发未确认', error instanceof ConfigError ? error.message : '提交失败或结果未知，请检查本机终端；不会自动重复提交。', pending.message).catch(() => { });
+            await replyHint(context.api, pending.chat, '⚠️ 转发状态待确认', error instanceof ConfigError ? error.message : '提交没有完成，请检查本机终端；不会自动重复提交。', pending.message).catch(() => { });
         }
     }
 }

package/dist/reply-hooks.js

@@ -5,7 +5,7 @@ import { findSession } from './reply-platform.js';
 import { textHash } from './reply-engine.js';
 import { telegramApi, replyHint } from './reply-telegram.js';
 import { bridgeStatus, startBridge } from './reply-bridge.js';
-import { createInteraction, showInteraction, waitInteraction } from './reply-interactions.js';
+import { createInteraction, questionsContent, showInteraction, waitInteraction } from './reply-interactions.js';
 import { makePlan, deliver } from './channels.js';
 import { completeToolCall, endSessionInteractions, finishInteraction, matchingCall, registerToolCall } from './reply-outcomes.js';
 const apiFor = (access, options) => (options.api ?? (value => telegramApi(value.config.telegram.token)))(access);
@@ -27,13 +27,13 @@ export async function lifecycleHook(data, file, options = {}) {
         if (event === 'SessionEnd' || !target) {
             delete state.sessions[data.session_id];
             delete state.pending[data.session_id];
-            endSessionInteractions(state, data.session_id, '会话已结束或无法核验');
+            endSessionInteractions(state, data.session_id, '会话已经结束，或无法核验身份');
             return null;
         }
         // 同进程 / 同 TTY 已切换会话时，旧映射不再允许输入。
         for (const [id, other] of Object.entries(state.sessions)) {
             if (id !== target.session && (other.pid === target.pid || (target.tty && other.tty === target.tty))) {
-                endSessionInteractions(state, id, '会话已切换');
+                endSessionInteractions(state, id, '会话已经切换');
                 delete state.sessions[id];
                 delete state.pending[id];
             }
@@ -57,17 +57,17 @@ export async function lifecycleHook(data, file, options = {}) {
         return match ? pending : null;
     });
     if (receipt) {
-        await replyHint(apiFor(access, options), receipt.chat, '✅ Claude 已收到回复', 'UserPromptSubmit 已匹配本次远程输入；这仅确认收到，不代表任务已经完成。', receipt.message).catch(() => options.err?.('Telegram: 收到确认发送失败；不会重放输入。'));
+        await replyHint(apiFor(access, options), receipt.chat, '✅ Claude 已收到回复', 'Claude 已收到你提交的回复，任务完成后会再发通知。', receipt.message).catch(() => options.err?.('Telegram：收到确认没有发送成功；已提交的输入不会重放。'));
         if (access.config.feishu.enabled && access.config.feishu.webhook) {
             try {
                 const result = await (options.send ?? deliver)(makePlan('feishu', { title: 'Claude 已收到回复', level: 'info',
-                    content: 'UserPromptSubmit 已匹配远程输入；仅确认收到，不代表任务完成。为减少扩散，不转发回复原文。',
+                    content: 'Claude 已收到你提交的回复，任务完成后会再发通知。为减少扩散，这里不转发回复原文。',
                     footer: '会话：' + data.session_id }, access.config), access.config);
                 if (!result.ok)
-                    options.err?.('feishu: 收到确认未完整发送；不会重放输入。');
+                    options.err?.('飞书：收到确认没有完整发送；已提交的输入不会重放。');
             }
             catch {
-                options.err?.('feishu: 收到确认发送失败；不会重放输入。');
+                options.err?.('飞书：收到确认发送失败；已提交的输入不会重放。');
             }
         }
     }
@@ -111,12 +111,12 @@ export async function attachReply(message, data, file, options = {}) {
     const ready = options.bridge ? await options.bridge(file, options.env ?? process.env)
         : (await bridgeStatus(file)).ready || await startBridge(file, options.env);
     if (!ready) {
-        options.err?.('远程回复桥接未就绪，本次通知不展示回复按钮；可运行 reply status 检查。');
+        options.err?.('回复桥接还没有就绪，这条通知不会显示回复按钮。可运行 reply status 查看原因。');
         return null;
     }
     const api = apiFor(access, options), bot = await api('getMe', {});
     if (typeof bot?.username !== 'string' || !/^[A-Za-z0-9_]{5,64}$/.test(bot.username))
-        throw new ConfigError('Telegram Bot 用户名无效，未启用回复按钮');
+        throw new ConfigError('Telegram Bot 用户名无效，回复按钮没有启用。');
     const token = randomBytes(16).toString('hex');
     await stateTransaction(access, state => { state.entries['token:' + token] = { session: target.session, epoch: targetEpoch(target), updated: Date.now() }; });
     message.reply = { token, url: `https://t.me/${bot.username}?start=${token}`, users: access.policy.users };
@@ -129,7 +129,7 @@ export function mapReplies(plan, binding) {
         if (!binding.access.policy.users.includes(item.recipient))
             return;
         if (!Number.isSafeInteger(response.result?.message_id))
-            throw new ConfigError('通知未返回可映射的 Telegram 消息 ID');
+            throw new ConfigError('通知没有返回可关联的 Telegram 消息 ID。');
         await stateTransaction(binding.access, state => {
             const entry = state.entries['token:' + binding.token];
             if (entry)
@@ -157,7 +157,7 @@ export async function interactionHook(data, file, options = {}) {
     // 登记阶段复用生命周期元数据；真正开启远程交互时仍重新核验进程身份。
     const target = cached ?? await getTarget(data, options);
     if (!target) {
-        options.err?.('无法核验会话，结构化交互保留本机处理。');
+        options.err?.('没有核验到会话，结构化交互将在本机处理。');
         return;
     }
     if (data.hook_event_name === 'PreToolUse') {
@@ -169,13 +169,13 @@ export async function interactionHook(data, file, options = {}) {
         return;
     const call = await stateTransaction(access, state => matchingCall(state, target, data));
     if (!call) {
-        options.err?.('无法唯一关联工具调用，远程交互未启用；本机窗口保持正常。');
+        options.err?.('没有唯一匹配到这次工具调用，远程交互没有启用；本机窗口不受影响。');
         return;
     }
     const ready = options.bridge ? await options.bridge(file, options.env ?? process.env)
         : (await bridgeStatus(file)).ready || await startBridge(file, options.env);
     if (!ready) {
-        options.err?.('回复桥接未就绪，问题保留本机处理。');
+        options.err?.('回复桥接还没有就绪，问题将在本机处理。');
         return;
     }
     const api = apiFor(access, options);
@@ -191,7 +191,7 @@ export async function interactionHook(data, file, options = {}) {
             const bot = await api('getMe', {});
             if (typeof bot?.username === 'string' && /^[A-Za-z0-9_]{5,64}$/.test(bot.username)) {
                 const result = await (options.send ?? deliver)(makePlan('feishu', { title: 'Claude Code 需要你处理', level: 'warn', footer: '',
-                    content: kind === 'question' ? request.questions.map(q => q.question + '\n' + q.options.map(o => o.label + '：' + o.description).join('\n')).join('\n\n') : '工具权限请求：' + data.tool_name,
+                    content: kind === 'question' ? questionsContent(request.questions) : '工具权限请求：' + data.tool_name,
                     reply: { token: request.id, url: `https://t.me/${bot.username}?start=${request.id}`, users: access.policy.users } }, access.config), access.config);
                 if (result.ok)
                     await stateTransaction(access, state => {
@@ -207,13 +207,13 @@ export async function interactionHook(data, file, options = {}) {
         if (response && !controller.signal.aborted)
             options.response?.(response);
         else
-            options.err?.('远程交互已结束或未提交；不会默认作答，本机操作不受影响。');
+            options.err?.('远程交互已经结束，或答案没有提交。不会自动作答，本机操作不受影响。');
     }
     catch (error) {
         await stateTransaction(access, state => {
             const current = state.requests[request.id];
             if (current)
-                finishInteraction(current, { kind: current.claimed ? 'unknown' : 'not-applied', text: '远程交互处理失败；请检查本机，不会自动重复提交。' });
+                finishInteraction(current, { kind: current.claimed ? 'unknown' : 'not-applied', text: '远程交互处理失败，请在本机检查。' });
         }).catch(() => { });
         throw error;
     }
@@ -224,7 +224,7 @@ export async function interactionHook(data, file, options = {}) {
             await stateTransaction(access, state => {
                 const current = state.requests[request.id];
                 if (current)
-                    finishInteraction(current, { kind: current.claimed ? 'unknown' : 'not-applied', text: '交互等待已取消，远程答案未确认生效。' });
+                    finishInteraction(current, { kind: current.claimed ? 'unknown' : 'not-applied', text: '交互等待已取消，远程答案是否生效还没有确认。' });
             }).catch(() => { });
     }
 }

package/dist/reply-interactions.js

@@ -7,7 +7,7 @@ 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('问题结构无效，请在本机回答');
+        throw new ConfigError('问题结构无效，请在本机回答。');
     const questions = input.questions;
     const seen = new Set();
     for (const q of questions) {
@@ -15,7 +15,7 @@ export function questionsFrom(input) {
             || 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('问题结构无效，请在本机回答');
+            throw new ConfigError('问题结构无效，请在本机回答。');
         }
         seen.add(q.question);
     }
@@ -23,7 +23,7 @@ export function questionsFrom(input) {
 }
 export async function createInteraction(access, target, kind, input, call) {
     if (kind === 'permission' && access.policy.permissions !== true)
-        throw new ConfigError('未授权远程工具权限处理');
+        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,
@@ -31,11 +31,11 @@ export async function createInteraction(access, target, kind, input, call) {
     await stateTransaction(access, state => {
         const current = state.sessions[target.session];
         if (!current || targetEpoch(current) !== value.epoch)
-            throw new ConfigError('会话目标已变化');
+            throw new ConfigError('会话目标发生了变化。');
         if (call) {
             const bound = state.calls[call];
             if (!bound || bound.ended || bound.request || bound.epoch !== value.epoch)
-                throw new ConfigError('调用已结束或已绑定；未创建远程问题');
+                throw new ConfigError('调用已经结束或已绑定，没有创建远程问题。');
             bound.request = value.id;
         }
         // 不同 tool_use_id 可并行；无绑定的单元级调用仍只保留一个活动交互。
@@ -72,12 +72,19 @@ export function interactionMarkup(value) {
 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仅支持本次允许、拒绝或自定义拒绝说明；官方未提供完整本地按钮列表。不会创建永久权限规则。';
+            + '\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 分钟有效，不会默认选择。';
+        + '\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]);
@@ -93,7 +100,7 @@ export async function showInteraction(access, id, chat, api) {
     plan.onSent = async (item, response) => {
         const message = response.result?.message_id;
         if (!Number.isSafeInteger(message))
-            throw new ConfigError('交互通知未返回消息 ID');
+            throw new ConfigError('交互通知没有返回消息 ID。');
         await stateTransaction(access, state => {
             const current = state.requests[id];
             if (current) {
@@ -112,7 +119,7 @@ export async function showInteraction(access, id, chat, api) {
     // API 封装由测试或真实桥接注入，不另建网络连接。
     const result = await deliver(plan, config, async (_url, payload) => ({ ok: true, result: await api('sendMessage', payload) }));
     if (!result.ok)
-        throw new ConfigError('交互通知未完整发送，请回到本机处理');
+        throw new ConfigError('交互通知没有完整发送，请回到本机处理。');
     await stateTransaction(access, state => {
         const current = state.requests[id];
         if (!current)
@@ -181,17 +188,17 @@ export async function handleInteractionCallback(access, callback, chat, api) {
         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(() => { });
+        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(() => { });
+        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(() => { });
+        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 });
+        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() };
@@ -204,7 +211,7 @@ export async function handleInteractionCallback(access, callback, chat, api) {
 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);
+        await replyHint(api, chat, '❌ 答案没有提交', '请输入不超过 4000 字符的答案；内容不会被截断。', message.message_id);
         return;
     }
     const outcome = await stateTransaction(access, state => {
@@ -224,9 +231,9 @@ export async function handleInteractionText(access, id, chat, message, api) {
             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));
+    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);
 }
@@ -256,7 +263,7 @@ export async function waitInteraction(access, value, fresh, options = {}) {
     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 ? '交互等待已取消；远程答案未确认生效。' : '远程交互等待超时；未确认生效，本机仍可继续处理。' });
+            finishInteraction(request, { kind: request.claimed ? 'unknown' : 'not-applied', text: options.signal?.aborted ? '交互等待已取消，远程答案是否生效还没有确认。' : '远程交互等待超时，尚未确认生效。你仍可在本机继续处理。' });
     });
     return null;
 }

package/dist/reply-outcomes.js

@@ -35,7 +35,7 @@ export function endSessionInteractions(state, session, reason) {
         if (value.session === session && !value.result)
             finishInteraction(value, {
                 kind: value.claimed ? 'unknown' : 'not-applied',
-                text: value.claimed ? reason + '；没有收到本次答案的生效确认，请检查终端。不会重复提交。' : reason + '；本次远程答案未回传。',
+                text: value.claimed ? reason + '；还没有收到本次答案的生效确认，请检查终端。' : reason + '；这次远程答案没有回传。',
             });
 }
 export async function registerToolCall(access, target, data) {
@@ -92,24 +92,24 @@ export async function completeToolCall(access, data) {
                 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 已结束问题，但未提供可核实的答案结果。请检查终端；不会重复提交。' }
+                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 已结束问题，但没有采用你提交的答案；本机或其他应答端可能已先处理。' };
+                            ? { 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: '该工具已获准执行；本次远程决定未阻止执行。' });
+                ? { 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 = () => { }) {
@@ -122,8 +122,8 @@ export async function drainInteractionFeedback(access, api, fresh, log = () => {
             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));
@@ -151,7 +151,7 @@ export async function drainInteractionFeedback(access, api, fresh, log = () => {
             }
             catch {
                 delivery = 'unknown';
-                log('Telegram 交互结果反馈发送失败或结果未知；不自动重发，不影响已采用的答案。');
+                log('Telegram 结果反馈没有发送成功。不会自动重发，已经采用的答案不受影响。');
             }
             await stateTransaction(access, state => {
                 const actual = state.requests[value.id]?.receipts?.find(r => r.id === receipt.id);
@@ -176,7 +176,7 @@ export async function drainInteractionFeedback(access, api, fresh, log = () => {
             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 旧按钮移除失败；服务端状态仍拒绝该请求。'));
+                .catch(() => log('Telegram 旧按钮没有移除成功。服务端仍会拒绝这个请求。'));
         }
     }
 }