@quecue/dev-notify 0.1.3 → 0.1.4

package/dist/maintenance.js

@@ -3,17 +3,18 @@ import { fileURLToPath } from 'node:url';
 import path from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
 import { ConfigError } from './config.js';
+import { t } from './i18n.js';
 import { claudeCodeStatus } from './claude-code.js';
 import { bridgeStatus } from './reply-bridge.js';
 function runCli(args) {
     const cli = fileURLToPath(new URL('./cli.js', import.meta.url));
     const result = spawnSync(process.execPath, [cli, ...args], { stdio: 'inherit', timeout: 300000 });
     if (result.error)
-        throw new ConfigError('无法运行更新后的 dev-notify。请重新打开终端后运行 dev-notify --version 检查。');
+        throw new ConfigError(t('maintenance.runFailed'));
     return result.status ?? 1;
 }
 function reason(error) {
-    return error instanceof ConfigError ? error.message : '请运行 dev-notify integration claude-code status 或 dev-notify reply status 检查。';
+    return error instanceof ConfigError ? error.message : t('maintenance.reasonHint');
 }
 const normalize = (file) => process.platform === 'win32' ? path.resolve(file).toLowerCase() : path.resolve(file);
 export async function postUpdate(options) {
@@ -27,28 +28,28 @@ export async function postUpdate(options) {
         hooksStatus = await hooks();
     }
     catch (error) {
-        options.err(`无法检查 Claude Code hooks：${reason(error)}`);
+        options.err(t('maintenance.hooksCheckFailed', { reason: reason(error) }));
         failed = true;
     }
     if (hooksStatus) {
         const count = hooksStatus.stop + hooksStatus.notification + hooksStatus.lifecycle + hooksStatus.interaction;
         if (!count)
-            options.out('未检测到本工具的 Claude Code hooks，跳过。');
+            options.out(t('maintenance.noHooks'));
         else if (!hooksStatus.configs.some(file => normalize(file) === normalize(options.config))) {
-            options.out('Claude Code hooks 绑定的是其他通知配置，跳过自动更新；如需更新，请用原来的 --config 运行 integration claude-code install。');
+            options.out(t('maintenance.otherConfig'));
         }
         else {
-            options.out('更新 Claude Code hooks ...');
+            options.out(t('maintenance.updatingHooks'));
             try {
                 if (run(['integration', 'claude-code', 'install', '--yes', '--config', options.config]) === 0)
-                    options.out('Claude Code hooks 已更新。');
+                    options.out(t('maintenance.hooksUpdated'));
                 else {
-                    options.err('Claude Code hooks 更新失败。');
+                    options.err(t('maintenance.hooksFailed'));
                     failed = true;
                 }
             }
             catch (error) {
-                options.err(`Claude Code hooks 更新失败：${reason(error)}`);
+                options.err(t('maintenance.hooksFailedReason', { reason: reason(error) }));
                 failed = true;
             }
         }
@@ -58,11 +59,11 @@ export async function postUpdate(options) {
         bridgeState = await bridge();
     }
     catch (error) {
-        options.err(`无法检查回复桥接：${reason(error)}`);
+        options.err(t('maintenance.bridgeCheckFailed', { reason: reason(error) }));
         failed = true;
     }
     if (bridgeState?.running) {
-        options.out('重启回复桥接 ...');
+        options.out(t('maintenance.restartingBridge'));
         try {
             // 0 表示已停止或本来未运行；1 表示停止请求已登记，下面等待进程释放锁。
             run(['reply', 'stop', '--config', options.config]);
@@ -79,22 +80,22 @@ export async function postUpdate(options) {
                 await wait(500);
             }
             if (stillRunning) {
-                options.err('回复桥接仍在退出，请稍后运行 dev-notify reply start。');
+                options.err(t('maintenance.bridgeStillRunning'));
                 failed = true;
             }
             else if (run(['reply', 'start', '--config', options.config]) === 0)
-                options.out('回复桥接已重启。');
+                options.out(t('maintenance.bridgeRestarted'));
             else {
-                options.err('回复桥接启动失败。');
+                options.err(t('maintenance.bridgeStartFailed'));
                 failed = true;
             }
         }
         catch (error) {
-            options.err(`回复桥接重启失败：${reason(error)}`);
+            options.err(t('maintenance.bridgeRestartFailed', { reason: reason(error) }));
             failed = true;
         }
     }
     else if (bridgeState)
-        options.out('未检测到运行中的回复桥接，跳过。');
+        options.out(t('maintenance.noBridge'));
     return failed ? 1 : 0;
 }

package/dist/prompts.js

@@ -1,11 +1,12 @@
 import { emitKeypressEvents } from 'node:readline';
 import { createInterface } from 'node:readline/promises';
 import { ConfigError } from './config.js';
+import { t } from './i18n.js';
 export class Cancelled extends Error {
 }
 export function terminalPrompts() {
     if (!process.stdin.isTTY || !process.stdout.isTTY)
-        throw new ConfigError('配置向导需要在交互终端中运行。自动化场景可以改用 setup --template --yes 搭配环境变量。');
+        throw new ConfigError(t('prompts.terminalRequired'));
     return {
         out: text => console.log(text),
         text: label => readText(label),
@@ -22,7 +23,7 @@ export async function readText(label, input = process.stdin, output = process.st
         return (await terminal.question(label, { signal: controller.signal })).trim();
     }
     catch {
-        throw new Cancelled('已取消。');
+        throw new Cancelled(t('prompts.cancelled'));
     }
     finally {
         terminal.off('SIGINT', cancel);
@@ -32,7 +33,7 @@ export async function readText(label, input = process.stdin, output = process.st
 }
 export async function readHidden(label, input = process.stdin, output = process.stdout) {
     if (!input.isTTY || !output.isTTY || typeof input.setRawMode !== 'function')
-        throw new ConfigError('当前终端不支持隐藏输入。为了不暴露密钥，这里不会改用明文输入；请在支持的终端中运行，或用环境变量配置。');
+        throw new ConfigError(t('prompts.hiddenUnsupported'));
     const wasRaw = input.isRaw, wasPaused = input.isPaused();
     return new Promise((resolve, reject) => {
         let value = '';
@@ -58,8 +59,8 @@ export async function readHidden(label, input = process.stdin, output = process.
             value = '';
             error ? reject(error) : resolve(result);
         };
-        const failed = () => finish(new ConfigError('隐藏输入没有完成，凭据没有保存。'));
-        const cancelled = () => finish(new Cancelled('已取消。'));
+        const failed = () => finish(new ConfigError(t('prompts.hiddenIncomplete')));
+        const cancelled = () => finish(new Cancelled(t('prompts.cancelled')));
         const keypress = (text, key = {}) => {
             if (key.ctrl && (key.name === 'c' || key.name === 'd'))
                 return cancelled();
@@ -76,7 +77,7 @@ export async function readHidden(label, input = process.stdin, output = process.
             if (key.ctrl || key.meta || !text || /[\x00-\x1f\x7f]/.test(text))
                 return;
             if (value.length + text.length > 8192)
-                return finish(new ConfigError('凭据输入过长，没有保存。'));
+                return finish(new ConfigError(t('prompts.inputTooLong')));
             value += text;
         };
         try {

package/dist/reply-bridge.js

@@ -5,6 +5,7 @@ import path from 'node:path';
 import { randomBytes } from 'node:crypto';
 import { setTimeout as delay } from 'node:timers/promises';
 import { appPaths, ConfigError } from './config.js';
+import { t } from './i18n.js';
 import { accessReplies, atomicJson, readJson, replyDirectory, stateTransaction } from './reply-state.js';
 import { telegramApi } from './reply-telegram.js';
 import { drainReplies, processUpdate } from './reply-engine.js';
@@ -44,7 +45,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(t('reply.bridgeAuthFirst'));
     const existing = await bridgeStatus(file);
     if (existing.running)
         return existing.ready;
@@ -72,7 +73,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(t('reply.bridgeNotAuthorized'));
     const directory = replyDirectory(file);
     await mkdir(directory, { recursive: true, mode: 0o700 });
     const botDirectory = path.join(appPaths(process.platform, env).data, 'reply-bots');
@@ -83,7 +84,7 @@ export async function runBridge(file, options = {}) {
         lock = await open(lockPath, 'wx', 0o600);
     }
     catch {
-        throw new ConfigError('当前用户已经有同一个 Bot 的桥接在运行，或残留了锁文件。请确认进程退出后，再处理 reply-bots 中对应的锁。');
+        throw new ConfigError(t('reply.bridgeLocked'));
     }
     const owner = randomBytes(16).toString('hex'), lease = { pid: process.pid, owner, ready: false, updated: Date.now() };
     let stopping = false;
@@ -100,7 +101,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(t('reply.webhookConflict'));
         await api('getMe', {});
         const currentState = await stateTransaction(access, state => ({ offset: state.offset, empty: Object.keys(state.entries).length === 0 }));
         if (!currentState.offset && currentState.empty) {
@@ -137,11 +138,11 @@ export async function runBridge(file, options = {}) {
                 updates = await api('getUpdates', { offset, timeout: 2, allowed_updates: ['message', 'callback_query'] });
             }
             catch (error) {
-                if (error instanceof ConfigError && /冲突/.test(error.message))
+                if (error instanceof ConfigError && /冲突|conflict/i.test(error.message))
                     throw error;
-                log('Telegram 轮询失败；日志中没有记录密钥或服务端正文。');
+                log(t('reply.pollFailedLog'));
                 if (++failures >= 5)
-                    throw new ConfigError('Telegram 连续轮询失败 5 次，桥接已经退出。请检查网络、Token 或 API 冲突后重新启动。');
+                    throw new ConfigError(t('reply.pollFailedFatal'));
                 lease.updated = Date.now();
                 await atomicJson(leasePath(file), lease);
                 await (options.sleep ?? delay)(3000);
@@ -152,7 +153,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(t('reply.updatesInvalid'));
             for (const update of updates) {
                 if (await isStopped())
                     break;
@@ -160,7 +161,7 @@ export async function runBridge(file, options = {}) {
                     await processUpdate(access, update, context);
                 }
                 catch {
-                    log('回复处理失败。这条更新不会重放；请检查终端，或从最新通知重试。');
+                    log(t('reply.handleFailedLog'));
                 }
             }
             if (updates.length)
@@ -173,7 +174,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 : t('reply.bridgeFailed');
         await atomicJson(leasePath(file), lease).catch(() => { });
         throw error;
     }

package/dist/reply-engine.js

@@ -1,5 +1,6 @@
 import { randomBytes } from 'node:crypto';
 import { ConfigError } from './config.js';
+import { t } from './i18n.js';
 import { digest, targetEpoch, stateTransaction, TTL } from './reply-state.js';
 import { handleInteractionCallback, handleInteractionText, showInteraction } from './reply-interactions.js';
 import { injectReply, sanitizeReply, validateTarget } from './reply-platform.js';
@@ -27,7 +28,7 @@ export async function resolveEntry(access, key, context) {
 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, t('reply.sessionGoneTitle'), t('reply.sessionGoneBody'), messageId);
         return;
     }
     if (resolved.entry.request) {
@@ -36,8 +37,8 @@ async function prompt(access, chat, messageId, key, context, autoReply = 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 });
+        ? await replyHint(context.api, chat, t('reply.replyPromptTitle'), t('reply.replyPromptBody', { session }), messageId, { force_reply: true, selective: true })
+        : await replyHint(context.api, chat, t('reply.replyPromptTitle'), t('reply.replyPromptLongPress', { session }), messageId, { remove_keyboard: true });
     if (Number.isSafeInteger(sent?.message_id))
         await stateTransaction(access, state => { state.entries[`tg:${chat}:${sent.message_id}`] = resolved.entry; });
 }
@@ -53,9 +54,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: t('reply.processingFailedCallback'),
                 }).catch(() => { });
-            await replyHint(context.api, chat, '⚠️ 本次提交没有完成', '处理时出现了异常，这次提交可能已经登记，也可能没有生效。请检查终端和后续结果；不会自动重复提交。').catch(() => { });
+            await replyHint(context.api, chat, t('reply.processingFailedTitle'), t('reply.processingFailedBody')).catch(() => { });
         }
         throw error;
     }
@@ -83,8 +84,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: t('reply.interactionExpiredCallback') }).catch(() => { });
+                await replyHint(context.api, chat, t('reply.interactionExpiredTitle'), t('reply.interactionExpiredBody')).catch(() => { });
                 return;
             }
             if (await handleInteractionCallback(access, callback, chat, context.api))
@@ -92,7 +93,7 @@ async function processAuthorizedUpdate(access, update, context) {
         }
         if (typeof value !== 'string' || !/^dn:r:[a-f0-9]{32}$/.test(value) || typeof callback.id !== 'string')
             return;
-        await context.api('answerCallbackQuery', { callback_query_id: callback.id, text: '请在回复框输入内容' });
+        await context.api('answerCallbackQuery', { callback_query_id: callback.id, text: t('reply.replyBoxHint') });
         await prompt(access, chat, callback.message.message_id, 'token:' + value.slice(5), context);
         return;
     }
@@ -107,7 +108,7 @@ 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, t('reply.staleTitle'), t('reply.staleBody'));
         return;
     }
     if (/^\/start\s+[a-f0-9]{32}$/.test(text)) {
@@ -117,12 +118,12 @@ async function processAuthorizedUpdate(access, update, context) {
     }
     const replyTo = message.reply_to_message?.message_id;
     if (!Number.isSafeInteger(replyTo)) {
-        await replyHint(context.api, chat, '💬 回复方式', '请直接回复任务完成通知，或点击通知里的「回复 Claude」按钮。', message.message_id);
+        await replyHint(context.api, chat, t('reply.howToTitle'), t('reply.howToBody'), message.message_id);
         return;
     }
     const resolved = await resolveEntry(access, `tg:${chat}:${replyTo}`, context);
     if (!resolved) {
-        await replyHint(context.api, chat, '⚠️ 无法回复', '通知已过期，或对应会话已经关闭、切换。请从最新通知回复。', message.message_id);
+        await replyHint(context.api, chat, t('reply.sessionGoneTitle'), t('reply.expiredReplyBody'), message.message_id);
         return;
     }
     if (resolved.entry.request) {
@@ -134,14 +135,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, t('reply.replyFailedTitle'), error instanceof ConfigError ? error.message : t('reply.invalidInput'), 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(t('reply.sessionChanged'));
         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,
@@ -149,11 +150,11 @@ 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, t('reply.pendingTitle'), t('reply.pendingBody'), message.message_id);
         return;
     }
     if (queued)
-        await replyHint(context.api, chat, '⏳ 回复已排队', 'Claude 正在处理当前任务；本地队列将在本轮结束后尝试提交，不会把文本输入到正在等待权限的弹窗。', message.message_id);
+        await replyHint(context.api, chat, t('reply.queuedTitle'), t('reply.queuedBody'), message.message_id);
     else
         await drainReplies(access, context);
 }
@@ -170,9 +171,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(t('reply.queueExpired'));
             if (!target.tracked || pending.epoch !== sessionEpoch(target) || !await (context.validate ?? (value => validateTarget(value)))(target))
-                throw new ConfigError('会话已经关闭或切换，这次回复没有提交。');
+                throw new ConfigError(t('reply.sessionClosed'));
             const text = pending.text;
             const claimed = await stateTransaction(access, state => {
                 const actual = state.pending[target.session], active = state.sessions[target.session];
@@ -189,7 +190,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 确认。', pending.message);
+            await replyHint(context.api, pending.chat, t('reply.forwardedTitle'), t('reply.forwardedBody'), pending.message);
         }
         catch (error) {
             await stateTransaction(access, state => {
@@ -199,7 +200,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, t('reply.forwardUnknownTitle'), error instanceof ConfigError ? error.message : t('reply.forwardFailed'), pending.message).catch(() => { });
         }
     }
 }

package/dist/reply-hooks.js

@@ -1,5 +1,6 @@
 import { randomBytes } from 'node:crypto';
 import { ConfigError } from './config.js';
+import { t } from './i18n.js';
 import { accessReplies, botKey, digest, stateTransaction, targetEpoch } from './reply-state.js';
 import { findSession } from './reply-platform.js';
 import { textHash } from './reply-engine.js';
@@ -27,13 +28,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, t('reply.endSessionReason'));
             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, t('reply.endSwitchedReason'));
                 delete state.sessions[id];
                 delete state.pending[id];
             }
@@ -52,22 +53,22 @@ export async function lifecycleHook(data, file, options = {}) {
         if (event === 'UserPromptSubmit' && !match && pending?.phase === 'queued')
             delete state.pending[target.session];
         if (event === 'UserPromptSubmit' || event === 'SessionStart' || event === 'Stop') {
-            endSessionInteractions(state, target.session, event === 'Stop' ? '本轮已结束' : '本机已开始新任务或新会话');
+            endSessionInteractions(state, target.session, event === 'Stop' ? t('reply.endTurnReason') : t('reply.endLocalReason'));
         }
         return match ? pending : null;
     });
     if (receipt) {
-        await replyHint(apiFor(access, options), receipt.chat, '✅ Claude 已收到回复', 'Claude 已收到你提交的回复，任务完成后会再发通知。', receipt.message).catch(() => options.err?.('Telegram：收到确认没有发送成功；已提交的输入不会重放。'));
+        await replyHint(apiFor(access, options), receipt.chat, t('reply.receivedTitle'), t('reply.receivedBody'), receipt.message).catch(() => options.err?.(t('reply.receivedTelegramFailed')));
         if (access.config.feishu.enabled && access.config.feishu.webhook) {
             try {
-                const result = await (options.send ?? deliver)(makePlan('feishu', { title: 'Claude 已收到回复', level: 'info',
-                    content: 'Claude 已收到你提交的回复，任务完成后会再发通知。为减少扩散，这里不转发回复原文。',
-                    footer: '会话：' + data.session_id }, access.config), access.config);
+                const result = await (options.send ?? deliver)(makePlan('feishu', { title: t('reply.receivedTitle'), level: 'info',
+                    content: t('reply.receivedFeishuBody'),
+                    footer: t('reply.receivedFeishuFooter', { session: data.session_id }) }, access.config), access.config);
                 if (!result.ok)
-                    options.err?.('飞书：收到确认没有完整发送；已提交的输入不会重放。');
+                    options.err?.(t('reply.receivedFeishuIncomplete'));
             }
             catch {
-                options.err?.('飞书：收到确认发送失败；已提交的输入不会重放。');
+                options.err?.(t('reply.receivedFeishuFailed'));
             }
         }
     }
@@ -111,12 +112,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?.(t('reply.bridgeNotReadyButton'));
         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(t('reply.botUsernameInvalid'));
     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 +130,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(t('reply.noMessageId'));
         await stateTransaction(binding.access, state => {
             const entry = state.entries['token:' + binding.token];
             if (entry)
@@ -157,7 +158,7 @@ export async function interactionHook(data, file, options = {}) {
     // 登记阶段复用生命周期元数据；真正开启远程交互时仍重新核验进程身份。
     const target = cached ?? await getTarget(data, options);
     if (!target) {
-        options.err?.('没有核验到会话，结构化交互将在本机处理。');
+        options.err?.(t('reply.noSession'));
         return;
     }
     if (data.hook_event_name === 'PreToolUse') {
@@ -169,13 +170,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?.(t('reply.noMatchingCall'));
         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?.(t('reply.bridgeNotReadyQuestion'));
         return;
     }
     const api = apiFor(access, options);
@@ -190,8 +191,8 @@ export async function interactionHook(data, file, options = {}) {
         if (access.config.feishu.enabled && access.config.feishu.webhook) {
             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' ? questionsContent(request.questions) : '工具权限请求：' + data.tool_name,
+                const result = await (options.send ?? deliver)(makePlan('feishu', { title: t('hook.notificationTitle'), level: 'warn', footer: '',
+                    content: kind === 'question' ? questionsContent(request.questions) : t('reply.permissionRequest', { tool: String(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 +208,13 @@ export async function interactionHook(data, file, options = {}) {
         if (response && !controller.signal.aborted)
             options.response?.(response);
         else
-            options.err?.('远程交互已经结束，或答案没有提交。不会自动作答，本机操作不受影响。');
+            options.err?.(t('reply.interactionEnded'));
     }
     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', reason: 'failed', text: t('reply.interactionFailed') });
         }).catch(() => { });
         throw error;
     }
@@ -224,7 +225,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', reason: 'failed', text: t('reply.interactionCancelled') });
             }).catch(() => { });
     }
 }