@quecue/dev-notify 0.1.2 → 0.1.4

package/SECURITY.md

@@ -1,6 +1,8 @@
 # 安全边界（Node/npm）
 
-当前源码为 `0.1.2`，npm 包名为 `@quecue/dev-notify`；发布版本以 npm registry 为准，源码更新不等同于已发布。本项目尚未完成安全审计或双平台实机验收。
+简体中文 | [English](SECURITY.en.md)
+
+当前源码为 `0.1.3`，npm 包名为 `@quecue/dev-notify`；发布版本以 npm registry 为准，源码更新不等同于已发布。本项目尚未完成安全审计或双平台实机验收。
 
 ## 凭据与权限
 
@@ -38,7 +40,7 @@
 - 生成 `command` + `args` 的无 shell exec 形式，路径不经过 shell 展开；固定安装时使用 Node/CLI/配置的绝对路径，命令参数不含秘密。需要支持该形式与 `async` 的新版 Claude Code；切换 Node 或移动安装目录后，请重新安装 hooks。
 - 保留其他设置和 hooks，重复安装会去重更新，移除时只匹配本工具标记及参数结构。旧版、项目或插件 hooks 不会被自动删除，可能造成重复发送。`status` 只反映本地状态，不涉及全局策略或实际事件投递验收；不会解除禁用、降低权限或绕过托管限制。
 - 写入使用专用排他锁、前后快照及同目录临时文件原子替换；损坏的 JSON 会被拒绝。外部编辑器不遵守这个锁，因此不会宣称无条件消除竞态；强杀可能留下锁或临时文件，程序不会清理不属于本次创建的锁。
-- Notification 异步，Stop 与会话生命周期同步，状态登记后再发送，可能延迟本地返回。PreToolUse 只登记调用身份，不发送网络通知，也不等待答案；PermissionRequest 与普通交互终端原生窗口并行等待，最多 5 分钟，不会默认选择。新增 PostToolUse、PostToolUseFailure、PermissionDenied 处理结果，完整安装共 10 类事件。当前核对的是 Claude Code 2.1.316 实现；旧版及特殊宿主的并行路径可能不同。
+- Notification 异步，Stop 与会话生命周期同步，状态登记后再发送，可能延迟本地返回。PreToolUse 只登记调用身份，不发送网络通知，也不等待答案；PermissionRequest 与普通交互终端原生窗口并行等待，最多 10 分钟，不会默认选择。新增 PostToolUse、PostToolUseFailure、PermissionDenied 处理结果，完整安装共 10 类事件。当前核对的是 Claude Code 2.1.316 实现；旧版及特殊宿主的并行路径可能不同。
 - 没有持久通知发送队列，不会自动重发整条消息，也不提供跨进程的恰好一次保证。继续中的 Stop 和重复空闲提醒会被忽略；内部出错时只输出安全摘要并退出 0，不会使用退出码 2 让 Claude 继续。只有明确授权的结构化交互才会返回对应的官方控制 JSON。
 - 移除 hooks、清理通知凭据和卸载 npm 是三项不同操作。卸载前请先单独移除 hooks；卸载脚本不会擅自修改用户设置。
 
@@ -53,7 +55,7 @@
 - AskUserQuestion 使用原始 questions + answers，通过 PermissionRequest decision.updatedInput 回传；保留本机原生界面，单选、多选、逐题自定义都不经过终端注入。由 Claude 仲裁先到的完整答案。每个按钮带请求/题目序号，过期或旧题不会回答新题；超时或撤销时不会默认作答。
 - PreToolUse 的 tool_use_id 与输入摘要用于关联；PermissionRequest 没有该 ID，只接受唯一匹配，遇到歧义、重复同内容、缺失或已结束时会拒绝远程处理。完成事件按 tool_use_id 关联，不会依靠通知顺序猜测目标。
 - 通用 permission_prompt 去重只用于通知投递，不授予输入或批准权限：仅当前会话最后一项调用是选择题、没有其他未结束调用、结构化通知完整成功时，才会按接收人覆盖；飞书另绑定当前 webhook/签名配置的摘要。已结束题目可在原交互有效期内覆盖迟到提醒，新输入及后续工具调用不会继承。Notification 缺少精确调用身份时，以该保守会话范围判断，不会声称跨并发或跨轮次精确去重；状态异常、投递失败或关联不明确时，会保留通用提醒。
-- Telegram 的「已登记」反馈只说明答案已经记录，生效情况会在后续确认。PostToolUse 返回的实际答案用于内容确认；两端同时提交相同答案时，无法证明来源。拒绝/失败、取消、缺少结果或回传后 5 分钟确认超时，无法证明实际决定时，会明确报告结果未知，不会重放答案。结果收据在发送前登记，网络失败或强杀可能导致未送达；不会无限重发，也不提供恰好一次保证。撤销授权后不再发送。旧选项会替换为已处理/过期状态；编辑失败时仍会拒绝旧请求。
+- Telegram 的「已登记」反馈只说明答案已经记录，生效情况会在后续确认。PostToolUse 返回的实际答案用于内容确认；两端同时提交相同答案时，无法证明来源。拒绝/失败、取消、缺少结果或回传后 10 分钟确认超时，无法证明实际决定时，会明确报告结果未知，不会重放答案。结果收据在发送前登记，网络失败或强杀可能导致未送达；不会无限重发，也不提供恰好一次保证。撤销授权后不再发送。旧选项会替换为已处理/已超时/已失效状态；编辑失败时仍会拒绝旧请求。
 - 问题结束后清除请求输入和答案正文，短期保留消息 ID、结果收据及输入摘要；没有收到结果时，保留到确认期限，实际清理由活跃桥接或生命周期事件触发。
 - 工具权限必须额外 opt-in；每次点击才输出 PermissionRequest 的一次 allow/deny。自定义文本只作为拒绝 message，任意文本都不会变成批准。不会持久写入 updatedPermissions，也不会更改 bypass/权限模式；Claude 的 deny 和托管策略仍然生效。permission_suggestions 不是完整的 UI 列表，因此不会伪造所有本地按钮。MCP 表单/URL 等暂不支持远程应答。
 - 问题、选项、工具参数、回复正文和答案可能包含敏感信息；启用后，问题和相应请求会发送到授权私聊及已配置飞书，无法自动脱敏。排队文本、请求输入、待回传答案及会话路径会持久写入专属本地状态；0600/0700 无法替代 Windows ACL，也无法防御同一用户的进程。逻辑 TTL 不会在断电后自动擦除文件。

package/dist/channels.js

@@ -1,5 +1,6 @@
 import { createHmac } from 'node:crypto';
 import { setTimeout as delay } from 'node:timers/promises';
+import { t } from './i18n.js';
 import { escapeHtml, feishuParts, parseMarkdown, partTitle, telegramParts } from './formatting.js';
 export class TransportError extends Error {
 }
@@ -11,7 +12,7 @@ export async function requestJson(url, payload, fetcher = fetch) {
         const response = await fetcher(url, { method: 'POST', body: JSON.stringify(payload),
             headers: { 'Content-Type': 'application/json' }, redirect: 'error', signal: AbortSignal.timeout(10000) });
         if (!response.body)
-            throw new TransportError('服务端没有返回内容。');
+            throw new TransportError(t('channels.noResponse'));
         const reader = response.body.getReader();
         const chunks = [];
         let size = 0;
@@ -23,7 +24,7 @@ export async function requestJson(url, payload, fetcher = fetch) {
                 size += value.byteLength;
                 if (size > 1024 * 1024) {
                     await reader.cancel();
-                    throw new TransportError('服务端响应过大，已停止读取。');
+                    throw new TransportError(t('channels.responseTooLarge'));
                 }
                 chunks.push(value);
             }
@@ -33,13 +34,13 @@ export async function requestJson(url, payload, fetcher = fetch) {
         }
         const result = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks)));
         if (!result || typeof result !== 'object' || Array.isArray(result))
-            throw new TransportError('服务端返回的不是 JSON 对象。');
+            throw new TransportError(t('channels.notJsonObject'));
         return result;
     }
     catch (error) {
         if (error instanceof TransportError)
             throw error;
-        throw new TransportError('网络请求失败或响应无效。为避免重复通知，不会自动重发；这条消息可能没有送达。');
+        throw new TransportError(t('channels.network'));
     }
 }
 function text(title, content, footer, icon, html) {
@@ -57,13 +58,13 @@ function card(message, title, content) {
     if (message.footer)
         elements.push({ tag: 'hr' }, { tag: 'note', elements: [{ tag: 'plain_text', content: message.footer }] });
     if (message.reply?.url)
-        elements.push({ tag: 'action', actions: [{ tag: 'button', text: { tag: 'plain_text', content: '💬 在 Telegram 回复 Claude' }, url: message.reply.url, type: 'primary' }] });
+        elements.push({ tag: 'action', actions: [{ tag: 'button', text: { tag: 'plain_text', content: t('channels.feishuReplyButton') }, url: message.reply.url, type: 'primary' }] });
     return { msg_type: 'interactive', card: { config: { wide_screen_mode: true },
             header: { template: colors[message.level], title: { tag: 'plain_text', content: title } }, elements } };
 }
 export function makePlan(channel, message, config) {
     if (!message.title.trim())
-        throw new Error('通知标题不能为空。');
+        throw new Error(t('channels.emptyTitle'));
     const blocks = parseMarkdown(message.content);
     if (channel === 'telegram') {
         const icon = icons[message.level];
@@ -76,10 +77,10 @@ export function makePlan(channel, message, config) {
                 const title = partTitle(message.title, index, chunks.length);
                 const plain = text(title, chunk.plain, message.footer, icon, false);
                 if (plain.length > 4096)
-                    throw new Error('Telegram 分段后仍然超过消息长度限制。');
+                    throw new Error(t('channels.telegramTooLong'));
                 items.push({ recipient: chatId, plain, payload: { chat_id: chatId,
                         text: text(title, chunk.html, message.footer, icon, true), parse_mode: 'HTML', disable_web_page_preview: true,
-                        ...(message.reply?.users.includes(chatId) ? { reply_markup: { inline_keyboard: [[{ text: '💬 回复 Claude', callback_data: 'dn:r:' + message.reply.token }]] } } : {}) } });
+                        ...(message.reply?.users.includes(chatId) ? { reply_markup: { inline_keyboard: [[{ text: t('channels.telegramReplyButton'), callback_data: 'dn:r:' + message.reply.token }]] } } : {}) } });
             });
         return { channel, items, recipients: config.telegram.chatIds.length };
     }
@@ -88,7 +89,7 @@ export function makePlan(channel, message, config) {
     const items = chunks.map((chunk, index) => {
         const payload = card(message, partTitle(message.title, index, chunks.length), chunk);
         if (bytes(payload) + 128 > 28000)
-            throw new Error('飞书分段后仍然超过请求大小限制。');
+            throw new Error(t('channels.feishuTooLong'));
         return { recipient: 'feishu', payload };
     });
     return { channel, items, recipients: 1 };
@@ -144,12 +145,12 @@ export async function deliver(plan, config, request = requestJson, sleep = delay
             }
             else {
                 failed.add(item.recipient);
-                error = '渠道拒绝了这次发送。请检查凭据、接收人授权、签名和频率限制。';
+                error = t('channels.rejected');
             }
         }
         catch (cause) {
             failed.add(item.recipient);
-            error = cause instanceof TransportError ? cause.message : '发送失败，这条消息可能没有送达。';
+            error = cause instanceof TransportError ? cause.message : t('channels.sendFailed');
         }
         if (!telegram && !failed.has(item.recipient) && index + 1 < plan.items.length)
             await sleep(250);

package/dist/claude-code.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { randomBytes } from 'node:crypto';
 import { ConfigError, decodeUtf8 } from './config.js';
+import { t } from './i18n.js';
 export const HOOK_MARKER = 'dev-notify:claude-code:v1';
 export const NOTIFICATION_MATCHER = 'permission_prompt|elicitation_dialog|elicitation_url_dialog|agent_needs_input';
 export const EVENTS = ['Stop', 'Notification', 'SessionStart', 'UserPromptSubmit', 'SessionEnd', 'PreToolUse', 'PermissionRequest', 'PostToolUse', 'PostToolUseFailure', 'PermissionDenied'];
@@ -13,7 +14,7 @@ export function claudeSettingsPath(env = process.env, home = homedir(), platform
     const join = platform === 'win32' ? path.win32 : path.posix;
     const root = env.CLAUDE_CONFIG_DIR || join.join(home, '.claude');
     if (!join.isAbsolute(root))
-        throw new ConfigError('CLAUDE_CONFIG_DIR 需要是绝对路径，Claude Code 设置没有改动');
+        throw new ConfigError(t('claude.settingsAbsolute'));
     return join.join(root, 'settings.json');
 }
 function settingsFile(options) {
@@ -23,7 +24,7 @@ async function snapshot(file) {
     try {
         const bytes = await readFile(file);
         if (bytes.length > 1024 * 1024)
-            throw new ConfigError('Claude Code 设置超过 1 MiB，操作已停止，文件没有改动。');
+            throw new ConfigError(t('claude.settingsTooLarge'));
         return bytes;
     }
     catch (error) {
@@ -31,7 +32,7 @@ async function snapshot(file) {
             return null;
         if (error instanceof ConfigError)
             throw error;
-        throw new ConfigError('无法读取 Claude Code 设置，操作已停止。');
+        throw new ConfigError(t('claude.settingsReadFailed'));
     }
 }
 function parseSettings(before) {
@@ -40,17 +41,17 @@ function parseSettings(before) {
         data = before === null ? {} : JSON.parse(decodeUtf8(before));
     }
     catch {
-        throw new ConfigError('Claude Code 设置不是合法的 UTF-8 JSON，没有覆盖。');
+        throw new ConfigError(t('claude.settingsInvalidJson'));
     }
     if (!record(data) || (data.hooks !== undefined && !record(data.hooks)))
-        throw new ConfigError('Claude Code 设置或 hooks 结构无效，没有覆盖。');
+        throw new ConfigError(t('claude.settingsInvalidShape'));
     for (const event of EVENTS) {
         const groups = data.hooks?.[event];
         if (groups === undefined)
             continue;
         if (!Array.isArray(groups) || groups.some(group => !record(group) || !Array.isArray(group.hooks)
             || group.hooks.some((hook) => !record(hook))))
-            throw new ConfigError('Claude Code hook 数组结构无效，没有覆盖。');
+            throw new ConfigError(t('claude.hooksInvalidShape'));
     }
     return data;
 }
@@ -117,7 +118,7 @@ function merged(data, config, runtime) {
         if (config !== null) {
             const handler = { type: 'command', command: runtime.node,
                 args: [runtime.cli, 'integration', 'claude-code', 'hook', '--config', config],
-                ...(event === 'Notification' ? { async: true } : { timeout: event === 'PermissionRequest' ? 360 : event === 'PreToolUse' ? 10 : 120 }), statusMessage: HOOK_MARKER };
+                ...(event === 'Notification' ? { async: true } : { timeout: event === 'PermissionRequest' ? 720 : event === 'PreToolUse' ? 10 : 120 }), statusMessage: HOOK_MARKER };
             const matcher = event === 'Notification' ? NOTIFICATION_MATCHER : null;
             groups.push(matcher ? { matcher, hooks: [handler] } : { hooks: [handler] });
         }
@@ -152,14 +153,14 @@ async function commit(file, before, target, prompts, replace = rename) {
         lock = await open(lockFile, 'wx', 0o600);
     }
     catch {
-        throw new ConfigError('暂时无法获取 Claude Code 设置写入锁。请确认没有安装进程在运行，再处理残留的 .dev-notify.lock。');
+        throw new ConfigError(t('claude.lockUnavailable'));
     }
     const temporary = path.join(path.dirname(file), `.dev-notify-${randomBytes(16).toString('hex')}.tmp`);
     let created = false;
     try {
         await lock.close();
         if (!same(before, await snapshot(file)))
-            throw new ConfigError('Claude Code 设置在确认期间发生了变化，没有覆盖，请重试。');
+            throw new ConfigError(t('claude.changedDuringConfirm'));
         const stream = await open(temporary, 'wx', 0o600);
         created = true;
         try {
@@ -170,7 +171,7 @@ async function commit(file, before, target, prompts, replace = rename) {
             await stream.close();
         }
         if (!same(before, await snapshot(file)))
-            throw new ConfigError('Claude Code 设置在保存期间发生了变化，没有覆盖，请重试。');
+            throw new ConfigError(t('claude.changedDuringSave'));
         await replace(temporary, file);
     }
     finally {
@@ -179,14 +180,14 @@ async function commit(file, before, target, prompts, replace = rename) {
                 await remove(temporary);
             }
             catch {
-                prompts.out('临时文件清理失败。安装结束后请删除 .dev-notify-*.tmp。');
+                prompts.out(t('claude.tempCleanupFailed'));
             }
         }
         try {
             await remove(lockFile);
         }
         catch {
-            prompts.out('锁文件清理失败。安装结束后请删除 .dev-notify.lock。');
+            prompts.out(t('claude.lockCleanupFailed'));
         }
     }
 }
@@ -194,8 +195,8 @@ export async function configureClaudeCode(config, action, prompts, options = {})
     const file = settingsFile(options), before = await snapshot(file), data = parseSettings(before);
     const status = describe(file, data);
     if (action === 'remove' && status.stop + status.notification + status.lifecycle + status.interaction === 0) {
-        prompts.out(`Claude Code 用户级设置：${file}`);
-        prompts.out('没有找到本工具添加的 hooks，设置没有改动。');
+        prompts.out(t('claude.settingsPath', { file }));
+        prompts.out(t('claude.noHooks'));
         return true;
     }
     const runtime = options.runtime ?? { node: process.execPath, cli: fileURLToPath(new URL('./cli.js', import.meta.url)) };
@@ -203,35 +204,34 @@ export async function configureClaudeCode(config, action, prompts, options = {})
     // setup 快速路径已在汇总确认前展示路径和发送范围，避免保存后重复整段说明。
     const quiet = options.confirm === false;
     if (!quiet)
-        prompts.out(`Claude Code 用户级设置：${file}`);
+        prompts.out(t('claude.settingsPath', { file }));
     if (JSON.stringify(data) === JSON.stringify(target)) {
-        prompts.out(action === 'install' ? '本工具 hooks 已经安装，配置一致，无需重复添加。' : '没有找到本工具添加的 hooks，设置没有改动。');
+        prompts.out(action === 'install' ? t('claude.alreadyInstalled') : t('claude.noHooks'));
         return true;
     }
     if (action === 'install') {
         if (!quiet) {
-            prompts.out(`通知配置：${path.resolve(config)}`);
-            prompts.out('会为这个 Claude Code 配置目录下的所有项目启用通知：任务结束时发送最终回复，需要你确认或输入时也会提醒。');
-            prompts.out('最终回复和提醒正文可能包含敏感内容，会发送到配置实际生效的 Telegram / 飞书。环境变量仍然优先。');
-            prompts.out('同时安装会话生命周期和结构化问题 hooks。远程输入需要另行运行 reply setup 授权。');
-            prompts.out('不会读取整份会话记录。启用回复后，会读取会话的进程元数据；结构化问题或权限请求会发送对应的问题和工具信息。');
-            prompts.out('PreToolUse 只登记调用身份；PermissionRequest 会和本机终端窗口同时等待，远程回答的有效期是 5 分钟。安装完成事件只用于反馈结果，不会代替你作答。已核对 Claude Code 2.1.316；其他版本或宿主环境需要另行验证。');
+            prompts.out(t('claude.configPath', { config: path.resolve(config) }));
+            prompts.out(t('claude.installScope'));
+            prompts.out(t('claude.installSensitive'));
+            prompts.out(t('claude.installLifecycle'));
+            prompts.out(t('claude.installReads'));
+            prompts.out(t('claude.installTiming'));
         }
         if (status.others)
-            prompts.out(`当前文件里还有 ${status.others} 个其他相关处理器，可能会重复通知。`);
-        prompts.out('项目级或插件的 hooks 也可能同时生效；本工具不会自动迁移或删除旧版 hooks。');
+            prompts.out(t('claude.otherHandlers', { count: status.others }));
+        prompts.out(t('claude.projectHooks'));
         if (status.disabled)
-            prompts.out('注意：该文件启用了 disableAllHooks，安装后 hooks 也不会生效；请自行解除禁用。');
+            prompts.out(t('claude.disabledWarning'));
     }
     else if (!quiet)
-        prompts.out('只会移除本工具添加的通知、生命周期和交互处理器；其他设置、hooks、通知配置和系统凭据都会保留。如需停止回复桥接，请运行 reply disable 或 reply stop。');
+        prompts.out(t('claude.removeScope'));
     if (options.confirm !== false
-        && !yes(await prompts.text(action === 'install' ? '安装这些 Claude Code hooks？[y/N] ' : '移除本工具的 Claude Code hooks？[y/N] '))) {
-        prompts.out('已取消，Claude Code 设置没有改动。');
+        && !yes(await prompts.text(action === 'install' ? t('claude.confirmInstall') : t('claude.confirmRemove')))) {
+        prompts.out(t('claude.cancelled'));
         return false;
     }
     await commit(file, before, target, prompts, options.replace);
-    prompts.out(action === 'install' ? 'Claude Code hooks 已安装。请在 /hooks 中检查并按界面确认；如果没有生效，请重启会话。'
-        : '本工具的 Claude Code hooks 已移除。请在 /hooks 中检查，必要时重启会话。');
+    prompts.out(action === 'install' ? t('claude.installed') : t('claude.removed'));
     return true;
 }

package/dist/claude-hook.js

@@ -1,20 +1,21 @@
 import { ConfigError, decodeUtf8, loadConfig, ready } from './config.js';
 import { makePlan } from './channels.js';
 import { NOTIFICATION_MATCHER } from './claude-code.js';
+import { t } from './i18n.js';
 import { findSessionName } from './reply-platform.js';
 import { lifecycleHook, interactionHook, attachReply, mapReplies, notificationCoverage } from './reply-hooks.js';
 export const MAX_HOOK_BYTES = 8 * 1024 * 1024;
 export async function readHookInput(input = process.stdin, limit = MAX_HOOK_BYTES) {
     const chunks = [];
     let size = 0;
-    const timer = setTimeout(() => input.destroy(new ConfigError('Claude Code hook 输入超时，通知没有发送。')), 15000);
+    const timer = setTimeout(() => input.destroy(new ConfigError(t('hook.timeout'))), 15000);
     timer.unref();
     try {
         for await (const chunk of input) {
             const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
             size += bytes.length;
             if (size > limit)
-                throw new ConfigError('Claude Code hook 输入超过大小限制，通知没有发送；内容不会被截断。');
+                throw new ConfigError(t('hook.tooLarge'));
             chunks.push(bytes);
         }
         return Buffer.concat(chunks);
@@ -31,44 +32,43 @@ function metadata(value, limit) {
     return chars.length > limit ? chars.slice(0, limit).join('') + '…' : clean;
 }
 function footer(data, sessionName) {
-    const project = typeof data.cwd === 'string' && data.cwd.trim() ? `项目：${metadata(data.cwd, 300)}` : '';
-    const topic = typeof sessionName === 'string' && sessionName.trim() ? `主题：${metadata(sessionName.trim(), 120)}` : '';
-    const session = typeof data.session_id === 'string' && data.session_id.trim() ? `会话：${metadata(data.session_id, 120)}` : '';
+    const project = typeof data.cwd === 'string' && data.cwd.trim() ? t('hook.footerProject', { value: metadata(data.cwd, 300) }) : '';
+    const topic = typeof sessionName === 'string' && sessionName.trim() ? t('hook.footerTopic', { value: metadata(sessionName.trim(), 120) }) : '';
+    const session = typeof data.session_id === 'string' && data.session_id.trim() ? t('hook.footerSession', { value: metadata(data.session_id, 120) }) : '';
     return [project, topic, session].filter(Boolean).join('\n');
 }
 export function claudeHookMessage(bytes, sessionName = '') {
     if (bytes.byteLength > MAX_HOOK_BYTES)
-        throw new ConfigError('Claude Code hook 输入超过大小限制，通知没有发送；内容不会被截断。');
+        throw new ConfigError(t('hook.tooLarge'));
     let data;
     try {
         data = JSON.parse(decodeUtf8(bytes));
     }
     catch {
-        throw new ConfigError('Claude Code hook 输入不是合法的 UTF-8 JSON，通知没有发送。');
+        throw new ConfigError(t('hook.invalidJson'));
     }
     if (!data || typeof data !== 'object' || Array.isArray(data))
-        throw new ConfigError('Claude Code hook 输入需要是 JSON 对象。');
+        throw new ConfigError(t('hook.notObject'));
     if (data.hook_event_name !== 'Stop' && data.hook_event_name !== 'Notification')
         return null;
     const details = footer(data, sessionName);
     if (data.hook_event_name === 'Stop') {
         if (data.stop_hook_active !== undefined && typeof data.stop_hook_active !== 'boolean')
-            throw new ConfigError('Claude Code Stop 状态字段无效。');
+            throw new ConfigError(t('hook.invalidStopState'));
         if (data.stop_hook_active === true)
             return null;
         if (data.last_assistant_message !== undefined && typeof data.last_assistant_message !== 'string')
-            throw new ConfigError('Claude Code 最终回复字段无效。');
-        return { title: 'Claude Code 回复完成', level: 'success', footer: details,
-            content: data.last_assistant_message?.trim() ? data.last_assistant_message
-                : '本轮回复已结束，Claude Code 没有提供最终正文。请回到终端查看；这里不会读取会话文件来补正文，以免显示过期内容。' };
+            throw new ConfigError(t('hook.invalidReply'));
+        return { title: t('hook.replyTitle'), level: 'success', footer: details,
+            content: data.last_assistant_message?.trim() ? data.last_assistant_message : t('hook.replyFallback') };
     }
     // 空闲提醒在 Stop 之后重复触发；只转发明确需要用户处理的通知。
     if (!NOTIFICATION_MATCHER.split('|').includes(data.notification_type))
         return null;
     if (data.message !== undefined && typeof data.message !== 'string')
-        throw new ConfigError('Claude Code 通知正文字段无效。');
-    return { title: 'Claude Code 需要你处理', level: 'warn', footer: details,
-        content: data.message?.trim() ? data.message : 'Claude Code 正在等待你的确认或输入，请回到终端处理。' };
+        throw new ConfigError(t('hook.invalidNotification'));
+    return { title: t('hook.notificationTitle'), level: 'warn', footer: details,
+        content: data.message?.trim() ? data.message : t('hook.notificationFallback') };
 }
 export async function dispatchClaudeHook(bytes, configFile, context) {
     const message = claudeHookMessage(bytes);
@@ -79,7 +79,7 @@ export async function dispatchClaudeHook(bytes, configFile, context) {
         await interactionHook(data, configFile, options);
     }
     catch {
-        context.err('Claude Code 的回复状态或交互处理失败。没有自动选择答案或批准权限，请在本机处理。');
+        context.err(t('hook.interactionFailed'));
     }
     if (!message)
         return;
@@ -88,7 +88,7 @@ export async function dispatchClaudeHook(bytes, configFile, context) {
         sessionName = await findSessionName(data.session_id, { env: context.env });
     }
     catch {
-        context.err('读取不到 Claude Code 会话名称，通知底部将省略主题。');
+        context.err(t('hook.sessionNameFailed'));
     }
     const notification = sessionName ? claudeHookMessage(bytes, sessionName) ?? message : message;
     let binding = null;
@@ -96,7 +96,7 @@ export async function dispatchClaudeHook(bytes, configFile, context) {
         binding = await attachReply(notification, data, configFile, options);
     }
     catch {
-        context.err('远程回复还没有就绪，仍会尝试发送普通通知。');
+        context.err(t('hook.replyNotReady'));
     }
     const config = await loadConfig(configFile, true, context.env);
     let covered = { telegram: [], feishu: false };
@@ -104,7 +104,7 @@ export async function dispatchClaudeHook(bytes, configFile, context) {
         covered = await notificationCoverage(data, configFile, config, options);
     }
     catch {
-        context.err('没有核验到选择题通知的覆盖情况，将保留普通权限提醒。');
+        context.err(t('hook.coverageFailed'));
     }
     let channels = 0;
     for (const channel of ['telegram', 'feishu']) {
@@ -125,12 +125,12 @@ export async function dispatchClaudeHook(bytes, configFile, context) {
                 mapReplies(plan, binding);
             const result = await context.send(plan, config);
             if (!result.ok)
-                context.err(`${channel}：Claude Code 通知没有完整发送。整条消息不会自动重发。`);
+                context.err(t('hook.sendIncomplete', { channel }));
         }
         catch {
-            context.err(`${channel}：Claude Code 通知发送失败。请检查配置、系统凭据和网络；整条消息不会自动重发。`);
+            context.err(t('hook.sendFailed', { channel }));
         }
     }
     if (!channels)
-        throw new ConfigError('Claude Code 通知没有可用渠道，请运行 dev-notify doctor 检查。');
+        throw new ConfigError(t('hook.noChannels'));
 }