diff --git a/apps/config/src-tauri/src/lib.rs b/apps/config/src-tauri/src/lib.rs
index 244d407..0583030 100644
--- a/apps/config/src-tauri/src/lib.rs
+++ b/apps/config/src-tauri/src/lib.rs
@@ -481,7 +481,6 @@ async fn verhub_announcements(limit: u32) -> Result<Vec<verhub::Announcement>, S
         .map_err(|e| e.to_string())
 }
 
-/// `contact` 可空——留了才好回复用户。
 #[tauri::command]
 async fn verhub_submit_feedback(
     content: String,
@@ -501,7 +500,6 @@ async fn verhub_submit_feedback(
         .map_err(|e| e.to_string())
 }
 
-/// 上报一段日志
 #[tauri::command]
 async fn verhub_upload_log(content: String) -> Result<(), String> {
     let device_info = serde_json::json!({
diff --git a/apps/config/src-tauri/src/verhub.rs b/apps/config/src-tauri/src/verhub.rs
index f9998e7..a382759 100644
--- a/apps/config/src-tauri/src/verhub.rs
+++ b/apps/config/src-tauri/src/verhub.rs
@@ -192,7 +192,7 @@ pub async fn upload_log(content: &str, device_info: serde_json::Value) -> Result
     Ok(())
 }
 
-/// 项目公开链接（主页 / 仓库 / 文档等）的缓存有效期。链接极少变动，一天刷新一次足够。
+/// 项目公开链接的缓存有效期。
 const PROJECT_CACHE_TTL_SECS: i64 = 24 * 60 * 60;
 
 /// 项目公开链接。所有字段都可能缺省（Verhub 上未填写）；前端须自备回退链接。
@@ -259,7 +259,7 @@ fn unix_now() -> i64 {
 }
 
 /// 项目公开链接：内存缓存 → 磁盘缓存（`cache_path`）→ Verhub API 逐级回退。
-/// API 拉取失败时退回过期缓存（有旧数据总比没有强），完全没有缓存才报错。
+/// API 拉取失败时退回过期缓存，完全没有缓存才报错。
 pub async fn project_links(cache_path: &Path) -> Result<ProjectLinks> {
     let now = unix_now();
     if let Some(cached) = cache_get()
diff --git a/apps/config/ui/src/App.svelte b/apps/config/ui/src/App.svelte
index e31ac53..ce3a152 100644
--- a/apps/config/ui/src/App.svelte
+++ b/apps/config/ui/src/App.svelte
@@ -59,12 +59,12 @@
   });
 
   onMount(() => {
-    // 主题：main.js 已在挂载前应用过一次（免得启动屏配色跳变），这里只负责跟随系统变化。
+    // main.js 已在挂载前应用过一次，这里只负责跟随系统变化。
     const media = matchMedia("(prefers-color-scheme: dark)");
     const onSystemTheme = () => applyTheme(loadPreference());
     media.addEventListener("change", onSystemTheme);
 
-    // 配置到手、界面有内容可看了，才把启动屏淡掉；失败时也得淡掉，否则永远卡在启动屏。
+    // 配置到手后才淡掉启动屏；失败时同样要淡掉，否则会一直卡住。
     loadAll()
       .then(() => {
         autoSaveReady = true;
diff --git a/apps/config/ui/src/components/DataNoticeModal.svelte b/apps/config/ui/src/components/DataNoticeModal.svelte
index e749c95..6bc11b6 100644
--- a/apps/config/ui/src/components/DataNoticeModal.svelte
+++ b/apps/config/ui/src/components/DataNoticeModal.svelte
@@ -1,5 +1,5 @@
 <script>
-  // 便携版写不进程序目录时的提示：说明设置存到了哪里，以及怎么改回去。
+  // 便携版写不进程序目录时的提示：设置存到了哪里、如何改回去。
   import IconAlert from "~icons/lucide/triangle-alert";
   import Modal from "./Modal.svelte";
   import { app } from "../lib/state.svelte.js";
diff --git a/apps/config/ui/src/components/Markdown.svelte b/apps/config/ui/src/components/Markdown.svelte
index 2d865d7..6494375 100644
--- a/apps/config/ui/src/components/Markdown.svelte
+++ b/apps/config/ui/src/components/Markdown.svelte
@@ -9,7 +9,7 @@
 
   const html = $derived(renderMarkdown(source));
 
-  // 链接一律交给系统浏览器：webview 里真导航走了就回不到配置界面了。
+  // 链接一律交给系统浏览器：webview 内真导航后回不到配置界面。
   function onClick(e) {
     const a = e.target.closest?.("a[href]");
     if (!a) return;
@@ -70,7 +70,6 @@
   .md :global(h6) {
     font-size: 13px;
   }
-  /* GitHub 的一二级标题带下边线 */
   .md :global(h1),
   .md :global(h2) {
     padding-bottom: 5px;
diff --git a/apps/config/ui/src/components/UpdateModal.svelte b/apps/config/ui/src/components/UpdateModal.svelte
index c9af80a..9b3e9fb 100644
--- a/apps/config/ui/src/components/UpdateModal.svelte
+++ b/apps/config/ui/src/components/UpdateModal.svelte
@@ -1,7 +1,6 @@
 <script>
-  // 更新提示。强制更新（Verhub 的 required=true）时**不能关**：没有右上角的叉、
-  // Esc 和点遮罩都不管用，只能去下载或退出程序——这正是「强制」的含义。
-  // 因此这里不用通用的 Modal 组件（那个总是可关闭的）。
+  // 更新提示。强制更新（required=true）时不可关闭：无关闭按钮，Esc 与点遮罩均无效。
+  // 故不复用总是可关闭的 Modal 组件。
   import IconDownload from "~icons/lucide/download";
   import IconTriangleAlert from "~icons/lucide/triangle-alert";
   import IconX from "~icons/lucide/x";
diff --git a/apps/config/ui/src/lib/license.js b/apps/config/ui/src/lib/license.js
index cf07c0a..30d7660 100644
--- a/apps/config/ui/src/lib/license.js
+++ b/apps/config/ui/src/lib/license.js
@@ -1,5 +1,4 @@
 // MIT 协议全文，逐字取自仓库根目录的 LICENSE 文件。
-// 关于页直接展示它——开源软件应当把协议原文摆出来，而不只是写个「MIT」。
 
 export const MIT_LICENSE = `MIT License
 
diff --git a/apps/config/ui/src/lib/pointer.js b/apps/config/ui/src/lib/pointer.js
index 407642c..a3da4f1 100644
--- a/apps/config/ui/src/lib/pointer.js
+++ b/apps/config/ui/src/lib/pointer.js
@@ -15,7 +15,7 @@ export const MAX_CLICKS = 3;
 export const MIN_MULTI_CLICK_MS = 150;
 export const MAX_MULTI_CLICK_MS = 1000;
 
-/** 把一颗键的触发条件写成人话，如「Ctrl + 三击」。 */
+/** 把一颗键的触发条件格式化为可读文本，如「Ctrl + 三击」。 */
 export function describeTrigger(button) {
   if (!button?.enabled) return t("mouse.notEnabled");
   const clicks = t(
diff --git a/apps/config/ui/src/lib/state.svelte.js b/apps/config/ui/src/lib/state.svelte.js
index 632bcb1..504c2d3 100644
--- a/apps/config/ui/src/lib/state.svelte.js
+++ b/apps/config/ui/src/lib/state.svelte.js
@@ -104,7 +104,7 @@ export function openRestoreTool() {
   app.restoreOpen = true;
 }
 
-/** 重新检测程序目录下的 pssuspend64.exe（放入文件后无需重启即可点亮增强冻结）。 */
+/** 重新检测 pssuspend64.exe；放入文件后无需重启即可启用增强冻结。 */
 export async function refreshPssuspend() {
   try {
     app.pssuspend = !!(await invoke("pssuspend_available"));
@@ -146,11 +146,11 @@ export async function loadAll() {
     invoke("pssuspend_available").then((v) => (app.pssuspend = !!v)),
     invoke("data_location").then((loc) => {
       app.dataLocation = loc;
-      // 便携版本该把设置放在程序目录里，回退了就说明那里写不进去，得让用户知道。
+      // 回退即程序目录写不进去，须提示用户。
       app.dataNoticeOpen = loc?.kind === "portable_fallback";
     }),
   ];
-  // 项目链接拉不到时静默——「关于」页有内置回退链接，不值得打扰用户。
+  // 拉取失败静默：「关于」页有内置回退链接。
   verhub
     .projectLinks()
     .then((p) => (app.project = p))
@@ -294,7 +294,7 @@ export async function loadAnnouncements({ popNew = false } = {}) {
   }
 }
 
-/** 记住这条公告已读——下次启动不再弹它。 */
+/** 记住这条公告已读，下次启动不再弹出。 */
 export function markAnnouncementSeen(id) {
   app.pendingAnnouncement = null;
   if (!app.config || !id) return;
diff --git a/crates/common/src/config.rs b/crates/common/src/config.rs
index a05454a..aa2d154 100644
--- a/crates/common/src/config.rs
+++ b/crates/common/src/config.rs
@@ -48,7 +48,7 @@ fn default_language() -> String {
 
 #[derive(Debug, thiserror::Error)]
 pub enum ConfigError {
-    /// 带上出错的路径：用户据此才能判断是装在了不可写的目录，还是被杀软拦了。
+    /// 带上出错的路径，便于区分目录不可写与被拦截。
     #[error("配置文件读写错误: {source}（路径: {path}）")]
     Io {
         path: String,
@@ -283,7 +283,7 @@ impl Default for TrayBadges {
 }
 
 impl TrayBadges {
-    /// 未知状态源一律归一为置空（不显示），避免手改配置后角标行为不可预测。幂等。
+    /// 未知状态源归一为置空，避免手改配置后角标行为不可预测。幂等。
     pub fn normalize(&mut self) {
         for v in [
             &mut self.red,
@@ -525,9 +525,7 @@ impl Config {
     }
 
     /// 同 [`Config::load`]，但额外报告「文件存在却解析失败、已回退默认值」的情况。
-    ///
-    /// 损坏文件回退默认值是刻意行为（保证核心总能启动），代价是用户的规则会「凭空消失」。
-    /// 调用方据第二个返回值把解析错误写进日志，否则这一幕无迹可循。
+    /// 回退保证核心总能启动，代价是用户的规则会凭空消失，故须由调用方记进日志。
     /// 返回 `(配置, 解析错误)`；解析成功或文件不存在时第二项为 `None`。
     pub fn load_reporting(path: &Path) -> Result<(Self, Option<String>), ConfigError> {
         match std::fs::read_to_string(path) {
@@ -557,8 +555,8 @@ impl Config {
         self.setting.normalize();
     }
 
-    /// 写入配置。先写同目录下的临时文件再原子替换：写到一半失败（磁盘满、
-    /// 杀软拦截）也不会把原文件截断成半截，用户的规则不会因此丢光。
+    /// 写入配置。先写同目录下的临时文件再原子替换，写到一半失败也不会
+    /// 把原文件截断成半截。
     pub fn save(&self, path: &Path) -> Result<(), ConfigError> {
         let json = self.to_json()?;
         if let Some(parent) = path.parent()
diff --git a/crates/common/src/paths.rs b/crates/common/src/paths.rs
index 39e9cc1..ef89909 100644
--- a/crates/common/src/paths.rs
+++ b/crates/common/src/paths.rs
@@ -4,8 +4,7 @@
 //!
 //! - **安装版**用 `%APPDATA%\BossKey`。安装包可以装进 `Program Files`，那里普通权限
 //!   进程不可写，配置程序每次保存都会得到 `os error 5`。
-//! - **便携版**用 exe 同目录，拷走整个文件夹就带走了全部设置。
-//!   目录写不进去时退回 `%APPDATA%\BossKey`，程序照常能用，界面据此提示这是权限问题。
+//! - **便携版**用 exe 同目录；写不进去时退回 `%APPDATA%\BossKey`，界面据此提示权限问题。
 //!
 //! 靠程序目录里有没有安装痕迹来分辨：安装包会放一份 [`INSTALLED_MARKER`]，
 //! 卸载程序 `unins*.exe` 也在同一目录，便携版压缩包里两者都没有。
@@ -15,9 +14,7 @@
 
 use std::path::{Path, PathBuf};
 
-/// 配置文件名。
 pub const CONFIG_FILE_NAME: &str = "config.json";
-/// 数据目录在 `%APPDATA%` 下的名字。
 pub const USER_DIR_NAME: &str = "BossKey";
 /// 安装版标记文件，由安装包放进程序目录，卸载时随之移除。
 pub const INSTALLED_MARKER: &str = "installed.marker";
@@ -59,11 +56,8 @@ pub fn user_data_dir() -> PathBuf {
     }
 }
 
-/// 程序目录里有没有安装痕迹。
-///
-/// 认两样东西：安装包放的 [`INSTALLED_MARKER`]，以及卸载程序 `unins*.exe`。
-/// 后者是兜底——标记文件被误删时仍认得出是安装版，不至于把数据写回 `Program Files`。
-/// 卸载程序的序号会随重复安装递增（`unins000` / `unins001`…），故按前缀匹配。
+/// 程序目录里有没有安装痕迹：安装包放的 [`INSTALLED_MARKER`]，或卸载程序 `unins*.exe`。
+/// 后者是标记文件被误删时的兜底；其序号随重复安装递增，故按前缀匹配。
 pub fn is_installed(program_dir: &Path) -> bool {
     if program_dir.join(INSTALLED_MARKER).exists() {
         return true;
@@ -92,9 +86,8 @@ pub fn dir_writable(dir: &Path) -> bool {
 
 /// 把程序目录里的旧配置搬到用户目录：先复制，再尽力删掉原文件。
 ///
-/// 目标已有配置就不动它——那是当前在用的一份，旧文件不得覆盖，也不去删。
-/// 删不掉（`Program Files` 下没有写权限、文件被占用）就留在原处：安装版只认用户目录，
-/// 旧文件不会再被读到。
+/// 目标已有配置就不动它，那是当前在用的一份。删不掉就留在原处：
+/// 安装版只认用户目录，旧文件不会再被读到。
 fn migrate_config(program_dir: &Path, user_dir: &Path) {
     let old = program_dir.join(CONFIG_FILE_NAME);
     let new = user_dir.join(CONFIG_FILE_NAME);
@@ -146,12 +139,10 @@ pub fn locate() -> DataDir {
     resolve_data_dir(&program_dir, &user_data_dir(), installed, portable_writable)
 }
 
-/// 本次运行使用的数据目录路径。
 pub fn data_dir() -> PathBuf {
     locate().dir
 }
 
-/// 配置文件路径。
 pub fn config_path() -> PathBuf {
     data_dir().join(CONFIG_FILE_NAME)
 }
diff --git a/crates/core/src/agent.rs b/crates/core/src/agent.rs
index 62ec127..fe40de7 100644
--- a/crates/core/src/agent.rs
+++ b/crates/core/src/agent.rs
@@ -31,8 +31,9 @@ use crate::hide::{
 };
 use crate::hotkey::{MOD_NOREPEAT, ParsedHotkey, is_disabled, parse_hotkey};
 use crate::i18n::{self, Msg};
-use crate::keyboard_hook::{self, KeyboardHook, WM_KEY_TRIGGER};
-use crate::mouse_hook::{self, MouseHook, TRIGGER_CORNER, WM_MOUSE_TRIGGER};
+use crate::input_hooks::InputHooks;
+use crate::keyboard_hook::{self, WM_KEY_TRIGGER};
+use crate::mouse_hook::{self, TRIGGER_CORNER, WM_MOUSE_TRIGGER};
 use crate::platform::win32::WindowsWindowManager;
 use crate::tray::TrayIcon;
 use crate::tray_badge::TrayIconSet;
@@ -102,14 +103,13 @@ struct AgentState {
     /// 托盘图标的角标变体缓存；未启用托盘时为 None。
     tray_icons: Option<TrayIconSet>,
     ipc_rx: Receiver<(Command, Sender<Response>)>,
-    mouse_hook: Option<MouseHook>,
+    /// 承载两个低级输入钩子的专职线程；起不来时为 None，鼠标绑定与「不传递」失效。
+    input_hooks: Option<InputHooks>,
     float_window: Option<FloatWindow>,
     /// 是否正在监听热键与鼠标（见 `Command::SetHotkeys`）。
     monitoring: bool,
     /// 热键当前是否已注册（避免重复 RegisterHotKey）。
     hotkeys_armed: bool,
-    /// 承载「不传递」热键的键盘钩子；没有热键开启「不传递」时不安装。
-    keyboard_hook: Option<KeyboardHook>,
 }
 
 impl AgentState {
@@ -175,16 +175,13 @@ impl AgentState {
     ) {
         if intercepts.is_empty() {
             keyboard_hook::set_hotkeys(&[]);
-            self.keyboard_hook = None;
+            self.set_keyboard_hook(false);
             return;
         }
         let parsed: Vec<(i32, ParsedHotkey)> =
             intercepts.iter().map(|(id, _, _, hk)| (*id, *hk)).collect();
         keyboard_hook::set_hotkeys(&parsed);
-        if self.keyboard_hook.is_none() {
-            self.keyboard_hook = KeyboardHook::install(hwnd);
-        }
-        if self.keyboard_hook.is_some() {
+        if self.set_keyboard_hook(true) {
             for (_, label, raw, _) in &intercepts {
                 logging::debug(&format!("{label}热键已由键盘钩子拦截（不传递）: {raw}"));
             }
@@ -202,6 +199,14 @@ impl AgentState {
         }
     }
 
+    /// 请求钩子线程把键盘钩子对齐 `on`，返回对齐后是否已装上。
+    /// 钩子线程起不来时恒为未装上，由调用方回退。
+    fn set_keyboard_hook(&self, on: bool) -> bool {
+        self.input_hooks
+            .as_ref()
+            .is_some_and(|hooks| hooks.set_keyboard(on))
+    }
+
     fn unregister_hotkeys(&mut self, hwnd: HWND) {
         unsafe {
             for id in [
@@ -215,7 +220,7 @@ impl AgentState {
             }
         }
         keyboard_hook::set_hotkeys(&[]);
-        self.keyboard_hook = None;
+        self.set_keyboard_hook(false);
     }
 
     /// 让热键与鼠标钩子对齐 `self.monitoring`。幂等：已是目标状态时什么都不做。
@@ -232,13 +237,16 @@ impl AgentState {
 
     fn refresh_runtime(&mut self, hwnd: HWND) {
         // 监控停用期间不装鼠标钩子。
-        if self.monitoring && mouse_hook::wants_hook(&self.config.setting) {
+        let want_mouse = self.monitoring && mouse_hook::wants_hook(&self.config.setting);
+        if want_mouse {
             mouse_hook::set_flags(&self.config.setting);
-            if self.mouse_hook.is_none() {
-                self.mouse_hook = MouseHook::install(hwnd, &self.config.setting);
-            }
-        } else {
-            self.mouse_hook = None;
+        }
+        let mouse_armed = self
+            .input_hooks
+            .as_ref()
+            .is_some_and(|hooks| hooks.set_mouse(want_mouse));
+        if want_mouse && !mouse_armed {
+            log_warn!("鼠标钩子安装失败，鼠标按键绑定与四角触发不生效");
         }
 
         unsafe {
@@ -273,7 +281,7 @@ impl AgentState {
         self.update_tray_icon();
     }
 
-    /// 让托盘图标的状态角标与悬浮提示对齐当前配置与运行状态。均未变化时开销为零。
+    /// 让托盘图标的状态角标与悬浮提示对齐当前配置与运行状态。
     fn update_tray_icon(&mut self) {
         let (Some(tray), Some(icons)) = (&mut self.tray, &mut self.tray_icons) else {
             return;
@@ -571,7 +579,7 @@ fn log_hide(config: &Config, outcomes: &[RuleOutcome], plan: &HidePlan) {
     }
 }
 
-/// 记录恢复结果；失效与找回的数量如实写出。
+/// 记录恢复结果。
 fn log_show(outcome: ShowOutcome) {
     if outcome.stale > 0 {
         logging::info(&format!(
@@ -605,10 +613,8 @@ unsafe fn register(hwnd: HWND, id: i32, hk: &ParsedHotkey) -> windows::core::Res
     }
 }
 
-/// 热键注册失败的日志文案。
-///
-/// 「已被占用」（1409）是最常见的原因，但并非唯一，故按系统错误码区分：
-/// 命中 1409 才断言被占用，其余情况如实报告错误码，不作猜测。
+/// 热键注册失败的日志文案。「已被占用」（1409）常见但非唯一原因，
+/// 故只在命中 1409 时断言被占用，其余如实报告错误码。
 fn hotkey_failure_message(label: &str, raw: &str, e: &windows::core::Error) -> String {
     if e.code() == ERROR_HOTKEY_ALREADY_REGISTERED.to_hresult() {
         format!("{label}热键注册失败，已被其他程序占用，该热键不生效: {raw}")
@@ -655,7 +661,6 @@ fn toggle_auto_hide(state: &mut AgentState, hwnd: HWND) {
     if let Err(e) = state.config.save(&state.config_path) {
         log_warn!("自动隐藏开关写入配置失败，核心重启后将丢失本次切换: {e}");
     }
-    // 重新武装/停掉空闲检测定时器，并刷新托盘角标。
     state.refresh_runtime(hwnd);
 }
 
@@ -820,6 +825,8 @@ fn quit(state: &mut AgentState, hwnd: HWND) {
     }
     state.persist_recovery();
     state.unregister_hotkeys(hwnd);
+    // 先摘钩子再收尾，退出过程中不再有输入事件进来。
+    state.input_hooks = None;
     // 排干副作用队列，确保退出前解冻 / 取消静音已生效。
     if let Some(worker) = state.effects_worker.take() {
         worker.shutdown(EFFECTS_SHUTDOWN_TIMEOUT);
@@ -906,7 +913,7 @@ unsafe extern "system" fn wndproc(hwnd: HWND, msg: u32, wparam: WPARAM, lparam:
         }
         WM_APP_FLOAT => {
             match wparam.0 {
-                // 双击悬浮窗触发老板键。
+                // 双击悬浮窗触发。
                 FLOAT_TOGGLE => {
                     if state.config.setting.click_to_hide {
                         state.apply_toggle();
@@ -960,7 +967,6 @@ unsafe extern "system" fn wndproc(hwnd: HWND, msg: u32, wparam: WPARAM, lparam:
                     }
                     quit(state, hwnd);
                 }
-                // 停用心跳超时，恢复监控。
                 SUSPEND_GUARD_TIMER_ID => {
                     unsafe {
                         let _ = KillTimer(Some(hwnd), SUSPEND_GUARD_TIMER_ID);
@@ -1037,10 +1043,8 @@ fn create_agent_window() -> windows::core::Result<HWND> {
     }
 }
 
-/// 加载配置；无论损坏还是读取失败都回退默认配置以保证核心可用，但必须留下记录。
-///
-/// 静默回退会让用户的热键与规则「凭空失效」，且日志里毫无痕迹，故此处按 error 记录，
-/// 并写出配置路径与具体原因。
+/// 加载配置；损坏或读取失败都回退默认配置以保证核心可用。
+/// 回退会让用户的热键与规则凭空失效，故按 error 记录配置路径与原因。
 fn load_config_logging_fallback(path: &Path) -> Config {
     const FALLBACK: &str = "已按默认配置启动，原有热键与规则本次不生效";
     match Config::load_reporting(path) {
@@ -1067,8 +1071,7 @@ fn should_open_settings(config_missing: bool, recorded: &str, current: &str) ->
 }
 
 pub fn run(options: AgentOptions) {
-    // 是否首次启动（尚无配置文件）/ 更新后首次启动（配置里记录的程序版本与当前不一致）。
-    // load() 在文件缺失时也返回默认值，故须先按文件是否存在判断「首次」。
+    // load() 在文件缺失时也返回默认值，故「首次启动」须先按文件是否存在判断。
     let config_missing = !options.config_path.exists();
     let mut config = load_config_logging_fallback(&options.config_path);
     i18n::set_from_pref(&config.setting.language);
@@ -1078,7 +1081,7 @@ pub fn run(options: AgentOptions) {
         bosskey_common::APP_VERSION,
     );
 
-    // 仅正常运行时（非冒烟测试）才拉起配置程序。
+    // 冒烟测试不拉起配置程序。
     if options.auto_quit_ms.is_none() && open_settings {
         let reason = if config_missing {
             "首次启动，拉起配置程序".to_string()
@@ -1165,6 +1168,12 @@ pub fn run(options: AgentOptions) {
     // 副作用由专职线程执行，消息循环不被慢操作阻塞。
     let effects_worker = EffectsWorker::spawn(WinEffects::new(exe_dir));
 
+    // 低级输入钩子挂在专职线程上：代理线程的枚举 / 落盘等重活不得拖慢全局输入。
+    let input_hooks = InputHooks::spawn(hwnd);
+    if input_hooks.is_none() {
+        log_error!("输入钩子线程启动失败，鼠标绑定与「不传递」热键本次不可用");
+    }
+
     let state = Box::new(RefCell::new(AgentState {
         config,
         config_path: options.config_path.clone(),
@@ -1176,11 +1185,10 @@ pub fn run(options: AgentOptions) {
         tray,
         tray_icons,
         ipc_rx,
-        mouse_hook: None,
+        input_hooks,
         float_window: None,
         monitoring: true,
         hotkeys_armed: false,
-        keyboard_hook: None,
     }));
 
     // 恢复文件存在即上次异常退出仍有窗口被隐藏，先找回。
diff --git a/crates/core/src/effects.rs b/crates/core/src/effects.rs
index 233d5c1..3627f4d 100644
--- a/crates/core/src/effects.rs
+++ b/crates/core/src/effects.rs
@@ -19,10 +19,8 @@ pub trait Effects {
 
 /// 冻结前的静置时长。
 ///
-/// 冻结让进程彻底停止响应消息：隐藏动作若还没在屏幕上画完就冻结，被冻结的窗口
-/// 会留下残影。发出去的媒体暂停键同样需要这段时间被目标程序处理掉，冻结早了就收不到。
-///
-/// 只在冻结前等，静音不受影响——静音走音频会话，与目标进程是否在跑无关。
+/// 冻结让进程彻底停止响应消息：隐藏动作没画完就冻结会留下残影，已发出的媒体
+/// 暂停键也需要这段时间被目标程序处理掉。静音走音频会话，不受影响，故不等。
 const FREEZE_SETTLE_DELAY: Duration = Duration::from_millis(200);
 
 pub struct WinEffects {
diff --git a/crates/core/src/freeze.rs b/crates/core/src/freeze.rs
index d2e3cb2..5f2a114 100644
--- a/crates/core/src/freeze.rs
+++ b/crates/core/src/freeze.rs
@@ -142,9 +142,8 @@ fn run_pssuspend(exe_dir: &Path, args: &[&str]) -> Result<(), FreezeError> {
     if !exe.exists() {
         return Err(FreezeError::PssuspendMissing);
     }
-    // `-accepteula` 必不可少：首次运行若未接受 EULA，pssuspend 会弹出许可
-    // 对话框并阻塞/失败（并写入 HKCU\Software\Sysinternals\PsSuspend）。
-    // 缺了它，增强冻结在没接受过 EULA 的机器上永远失败。旗标须在 PID 之前。
+    // `-accepteula` 必不可少：未接受 EULA 时 pssuspend 会弹出许可对话框并阻塞，
+    // 增强冻结在这类机器上将永远失败。旗标须排在 PID 之前。
     let output = std::process::Command::new(exe)
         .arg("-accepteula")
         .arg("-nobanner")
@@ -156,9 +155,8 @@ fn run_pssuspend(exe_dir: &Path, args: &[&str]) -> Result<(), FreezeError> {
     if output.status.success() {
         Ok(())
     } else {
-        // pssuspend 把失败原因（如「拒绝访问」「进程不存在」）打到 stdout，
-        // 而非 stderr；两路都收进来，否则日志只剩一个退出码、无从排查。
-        // 它按系统本地代码页（中文系统 GBK）输出，须按 ANSI 解码，否则中文乱码。
+        // pssuspend 把失败原因打到 stdout 而非 stderr，两路都须收进来；
+        // 它按系统本地代码页输出，须按 ANSI 解码，否则中文乱码。
         let mut detail = crate::util::from_ansi(&output.stdout).trim().to_string();
         let stderr = crate::util::from_ansi(&output.stderr);
         let stderr = stderr.trim();
diff --git a/crates/core/src/hide.rs b/crates/core/src/hide.rs
index 118171e..537a553 100644
--- a/crates/core/src/hide.rs
+++ b/crates/core/src/hide.rs
@@ -8,7 +8,7 @@ use crate::effects::Effects;
 use crate::platform::WindowManager;
 use crate::recovery::{ProcRecord, Snapshot};
 
-/// 一条隐藏记录。`process_path` / `title` 供日志与排查使用；旧恢复文件缺省为空串。
+/// 一条隐藏记录。`process_path` / `title` 仅供日志；旧恢复文件缺省为空串。
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Target {
     pub hwnd: i64,
@@ -20,7 +20,7 @@ pub struct Target {
 }
 
 impl Target {
-    /// 只有句柄与 PID 的记录（来源没有路径 / 标题信息时使用）。
+    /// 只有句柄与 PID 的记录。
     pub fn bare(hwnd: i64, pid: u32) -> Self {
         Self {
             hwnd,
@@ -52,7 +52,7 @@ impl Target {
     }
 }
 
-/// 一条窗口规则的解析结果摘要。
+/// 一条窗口规则的解析结果。
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum RuleOutcome {
     Live,
@@ -115,10 +115,8 @@ pub fn resolve_targets(
     (result, outcomes)
 }
 
-/// 前台窗口对应的隐藏目标。
-///
-/// 只接受出现在枚举结果里且当前可见的顶层窗口：工具窗口不在枚举结果内，
-/// 已被隐藏的窗口 `visible` 为假，二者都不该再次成为隐藏目标。
+/// 前台窗口对应的隐藏目标。只接受出现在枚举结果里且当前可见的顶层窗口：
+/// 工具窗口不在枚举结果内，已被隐藏的窗口 `visible` 为假。
 pub fn foreground_target(windows: &[WindowInfo], foreground: i64) -> Option<Target> {
     if foreground == 0 {
         return None;
@@ -145,21 +143,19 @@ pub fn freezable_pids(targets: &[Target], windows: &[WindowInfo]) -> Vec<u32> {
             .iter()
             .filter(|w| w.pid == *pid && w.visible)
             .peekable();
-        // 没有可见窗口时不冻结。
+        // all() 对空集恒为真，故须先确认存在可见窗口。
         visible.peek().is_some() && visible.all(|w| hidden.contains(&w.hwnd))
     });
     pids
 }
 
-/// 把一组根 PID 展开为「根 ∪ 全部后代」：按 `edges`（`(pid, 父 pid)`）建父子关系，
-/// 从每个根 BFS 收集整棵子进程树。用 visited 去重并防环 / 自指（如 pid 0 的父是 0）。
-/// 返回排序去重后的 PID 列表。
+/// 把一组根 PID 展开为「根 ∪ 全部后代」；`edges` 为 `(pid, 父 pid)`。
+/// visited 兼作防环与自指保护（pid 0 的父是 0）。返回排序去重后的列表。
 pub fn expand_descendants(roots: &[u32], edges: &[(u32, u32)]) -> Vec<u32> {
     use std::collections::VecDeque;
 
     let mut children: std::collections::HashMap<u32, Vec<u32>> = std::collections::HashMap::new();
     for &(pid, ppid) in edges {
-        // 忽略自指边，避免把自己当成自己的子进程。
         if pid != ppid {
             children.entry(ppid).or_default().push(pid);
         }
@@ -199,11 +195,11 @@ pub struct HidePlan {
     pub freeze: Vec<ProcRecord>,
     /// 是否发送媒体暂停键。
     pub send_pause: bool,
-    /// 本轮冻结方式（首轮跟随设置，之后沿用，保证解冻方式一致）。
+    /// 本轮冻结方式；首轮跟随设置，之后沿用。
     pub enhanced: bool,
 }
 
-/// [`HideController::show`] 的执行结果，供调用方如实记录日志。
+/// [`HideController::show`] 的执行结果。
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
 pub struct ShowOutcome {
     /// 实际恢复显示的窗口数。
@@ -256,12 +252,10 @@ impl<W: WindowManager, E: Effects> HideController<W, E> {
         !self.hidden.is_empty()
     }
 
-    /// 当前被隐藏的窗口数（供日志如实记录恢复了多少个窗口）。
     pub fn hidden_count(&self) -> usize {
         self.hidden.len()
     }
 
-    /// 枚举当前窗口（供上层解析目标；封装 wm 依赖）。
     pub fn enumerate(&self) -> Vec<WindowInfo> {
         self.wm.enumerate()
     }
@@ -270,26 +264,22 @@ impl<W: WindowManager, E: Effects> HideController<W, E> {
         self.wm.foreground()
     }
 
-    /// 窗口当前标题（封装 wm 依赖，供事件追踪查询）。
     pub fn window_title(&self, hwnd: i64) -> String {
         self.wm.window_title(hwnd)
     }
 
-    /// 该句柄是否在隐藏记录里。
     pub fn tracks_window(&self, hwnd: i64) -> bool {
         self.hidden.iter().any(|t| t.hwnd == hwnd)
     }
 
-    /// 移除句柄对应的隐藏记录（窗口已销毁或被外部恢复显示时由事件追踪调用）。
-    /// 返回是否有记录被移除。
+    /// 移除句柄对应的隐藏记录，返回是否有记录被移除。
     pub fn forget_window(&mut self, hwnd: i64) -> bool {
         let before = self.hidden.len();
         self.hidden.retain(|t| t.hwnd != hwnd);
         self.hidden.len() != before
     }
 
-    /// 同步隐藏记录里的窗口标题（标题变化事件）；`NO_TITLE` 不参与同步。
-    /// 返回是否有记录被更新。
+    /// 同步隐藏记录里的窗口标题；`NO_TITLE` 不参与。返回是否有记录被更新。
     pub fn update_title(&mut self, hwnd: i64, title: &str) -> bool {
         if title == NO_TITLE {
             return false;
@@ -307,13 +297,12 @@ impl<W: WindowManager, E: Effects> HideController<W, E> {
     }
 
     /// 计算一次隐藏的执行计划，不做任何窗口 / 副作用动作；顺带完成隐藏集剪枝
-    /// 与 PID 补查（仍查不到的目标剔除）。`freeze_pids` 为最终要冻结的 PID 集
-    /// （可能已含子进程树），仅在 `freeze_after_hide` 开启时生效。
+    /// 与 PID 补查（仍查不到的目标剔除）。`freeze_pids` 仅在 `freeze_after_hide`
+    /// 开启时生效。
     ///
-    /// 只有「由本程序从可见变为不可见」的窗口才进入隐藏集，恢复即逆转这次
-    /// 改变；本来就不可见的目标不入集。隐藏是累加的，`show` 时一并恢复。
-    /// 已在隐藏 / 静音 / 冻结集内的目标会被跳过——挂起是计数式的，重复施加
-    /// 会让解冻次数对不上。
+    /// 只有「由本程序从可见变为不可见」的窗口才进入隐藏集，恢复即逆转这次改变。
+    /// 隐藏是累加的，`show` 时一并恢复。已在隐藏 / 静音 / 冻结集内的目标会被
+    /// 跳过——挂起是计数式的，重复施加会让解冻次数对不上。
     pub fn plan_hide(
         &mut self,
         setting: &Setting,
@@ -325,8 +314,6 @@ impl<W: WindowManager, E: Effects> HideController<W, E> {
 
         let mut fresh: Vec<Target> = Vec::new();
         for t in targets {
-            // 只隐藏当前可见的窗口：本来就不可见的目标（如程序自行藏到托盘，
-            // Steam 的关闭按钮即是）不入集，恢复时也就不会被错误地弹出来。
             if known.contains(&t.hwnd)
                 || fresh.iter().any(|f| f.hwnd == t.hwnd)
                 || !self.wm.is_window(t.hwnd)
@@ -369,7 +356,7 @@ impl<W: WindowManager, E: Effects> HideController<W, E> {
 
         HidePlan {
             send_pause: setting.send_before_hide && !fresh.is_empty(),
-            // 解冻方式必须与冻结时一致：仅首轮冻结跟随设置，之后沿用。
+            // 解冻方式必须与冻结时一致。
             enhanced: if self.frozen.is_empty() {
                 setting.enhanced_freeze
             } else {
@@ -381,8 +368,8 @@ impl<W: WindowManager, E: Effects> HideController<W, E> {
         }
     }
 
-    /// 执行计划：同步隐藏窗口（`SW_HIDE`），静音 / 冻结 / 暂停键经 [`Effects`] 施加
-    /// （生产实现为异步队列，故入队顺序即执行顺序）。
+    /// 执行计划：同步隐藏窗口（`SW_HIDE`），静音 / 冻结 / 暂停键经 [`Effects`]
+    /// 施加。生产实现为异步队列，入队顺序即执行顺序。
     pub fn commit_hide(&mut self, plan: HidePlan) {
         // 暂停键排在最前：冻结后的进程收不到按键。
         if plan.send_pause {
@@ -400,8 +387,7 @@ impl<W: WindowManager, E: Effects> HideController<W, E> {
         self.muted.sort_unstable_by_key(|r| r.pid);
 
         self.used_enhanced = plan.enhanced;
-        // 静置排在静音之后、冻结之前：静音不必等，冻结必须等屏幕画完，
-        // 否则被冻结的窗口会留下残影。整批只等一次。
+        // 冻结前必须等屏幕画完，否则被冻结的窗口会留下残影。整批只等一次。
         if !plan.freeze.is_empty() {
             self.effects.settle_before_freeze();
         }
@@ -414,7 +400,7 @@ impl<W: WindowManager, E: Effects> HideController<W, E> {
         self.hidden.extend(plan.fresh);
     }
 
-    /// plan + commit 的便捷封装（不需要意图落盘的调用方使用）。
+    /// plan + commit 的便捷封装。
     pub fn apply_hide(&mut self, setting: &Setting, targets: &[Target], freeze_pids: &[u32]) {
         let plan = self.plan_hide(setting, targets, freeze_pids);
         self.commit_hide(plan);
@@ -441,7 +427,7 @@ impl<W: WindowManager, E: Effects> HideController<W, E> {
     fn proc_alive(&self, r: &ProcRecord) -> bool {
         let now = self.wm.process_start_time(r.pid);
         if now == 0 {
-            return false; // 进程已退出或查不到。
+            return false;
         }
         r.created_at == 0 || now == r.created_at
     }
@@ -622,7 +608,7 @@ mod tests {
         WindowInfo::new(title, hwnd, process, hwnd as u32, path)
     }
 
-    /// 与 `win` 相同，但可指定 PID（用于构造同一进程的多个窗口）。
+    /// 与 `win` 相同，但可指定 PID。
     fn win_pid(title: &str, hwnd: i64, process: &str, pid: u32, path: &str) -> WindowInfo {
         WindowInfo::new(title, hwnd, process, pid, path)
     }
@@ -860,7 +846,7 @@ mod tests {
         windows: Vec<WindowInfo>,
         foreground: i64,
         visible: RefCell<HashSet<i64>>,
-        /// 仍然存在的句柄集合（窗口销毁 = 从中移除；与 visible 是两回事）。
+        /// 仍然存在的句柄；与 visible 是两回事。
         exists: RefCell<HashSet<i64>>,
         /// 覆写某句柄当前所属的 PID（模拟句柄被别的窗口复用）。
         pid_overrides: RefCell<HashMap<i64, u32>>,
@@ -881,13 +867,12 @@ mod tests {
             }
         }
 
-        /// 模拟窗口被销毁：句柄失效且不可见。
         fn destroy(&self, hwnd: i64) {
             self.visible.borrow_mut().remove(&hwnd);
             self.exists.borrow_mut().remove(&hwnd);
         }
 
-        /// 模拟句柄被系统回收后分配给了新窗口。
+        /// 模拟句柄被回收后分配给新窗口。
         fn revive(&self, hwnd: i64) {
             self.exists.borrow_mut().insert(hwnd);
             self.visible.borrow_mut().insert(hwnd);
@@ -1233,7 +1218,7 @@ mod tests {
         controller.commit_hide(plan);
         let actual = controller.snapshot();
 
-        // 意图快照与提交后的实际状态一致——落盘发生在动作前，两者必须等价。
+        // 落盘发生在动作前，故意图快照须与提交后的状态等价。
         assert_eq!(planned.hidden, actual.hidden);
         assert_eq!(planned.frozen, actual.frozen);
         assert_eq!(planned.muted, actual.muted);
@@ -1469,7 +1454,7 @@ mod tests {
             hide_current: false,
             ..Setting::default()
         };
-        // 99 是同进程同标题的新窗口（程序重建了窗口），当前不可见。
+        // 99 是同进程同标题的新窗口，当前不可见。
         let wm = MockWm::new(
             vec![
                 win_pid("微信", 10, "WeChat.exe", 500, "C:\\WeChat.exe"),
@@ -1536,8 +1521,7 @@ mod tests {
             mute_after_hide: true,
             ..Setting::default()
         };
-        // Steam 用关闭按钮把自己藏了起来（窗口仍存在但不可见），记事本可见；
-        // 两者都被规则命中。
+        // 10 存在但已不可见，20 可见；两者都被规则命中。
         let wm = MockWm::new(
             vec![
                 win_pid("Steam", 10, "steam.exe", 500, "C:\\steam.exe"),
@@ -1592,7 +1576,7 @@ mod tests {
             ],
             0,
         );
-        // 记录外的句柄：被别的途径隐藏，核心不知情。
+        // 30 被别的途径隐藏，不在隐藏记录里。
         wm.hide(30);
         let mut controller = HideController::new(wm, MockEffects::default());
         controller.apply_hide(
@@ -1601,7 +1585,6 @@ mod tests {
             &[500],
         );
 
-        // 只点选了一个窗口 + 一个记录外句柄。
         assert_eq!(controller.release_windows(&[10, 30]), 2);
         assert!(
             controller.wm.is_visible(10) && controller.wm.is_visible(11),
diff --git a/crates/core/src/i18n.rs b/crates/core/src/i18n.rs
index f602e41..e66811c 100644
--- a/crates/core/src/i18n.rs
+++ b/crates/core/src/i18n.rs
@@ -200,7 +200,6 @@ pub fn set_from_pref(pref: &str) {
     }
 }
 
-/// 当前生效语言。
 pub fn lang() -> Lang {
     LANG.read().map(|g| *g).unwrap_or_default()
 }
diff --git a/crates/core/src/icon.rs b/crates/core/src/icon.rs
index 2447045..70b787b 100644
--- a/crates/core/src/icon.rs
+++ b/crates/core/src/icon.rs
@@ -218,7 +218,7 @@ fn zlib_stored(data: &[u8]) -> Vec<u8> {
     let mut blocks = data.chunks(MAX_BLOCK).peekable();
     loop {
         let Some(block) = blocks.next() else {
-            // data 为空时也要输出一个空的最终块
+            // data 为空时也要输出一个空的最终块。
             out.extend_from_slice(&[0x01, 0x00, 0x00, 0xFF, 0xFF]);
             break;
         };
@@ -343,7 +343,7 @@ mod tests {
         chunks
     }
 
-    /// 测试用 stored-deflate 解压（只支持我们自己产生的未压缩块）。
+    /// 测试用 stored-deflate 解压，只支持本模块产生的未压缩块。
     fn inflate_stored(zlib: &[u8]) -> Vec<u8> {
         assert_eq!(zlib[0], 0x78, "zlib CMF 头");
         let mut out = Vec::new();
diff --git a/crates/core/src/input_hooks.rs b/crates/core/src/input_hooks.rs
new file mode 100644
index 0000000..cca4860
--- /dev/null
+++ b/crates/core/src/input_hooks.rs
@@ -0,0 +1,272 @@
+//! 输入钩子专职线程：`WH_MOUSE_LL` 与 `WH_KEYBOARD_LL` 都挂在这条线程上。
+//!
+//! 低级钩子的回调由安装线程的消息泵派发，系统的输入线程要等钩子链返回才继续投递
+//! 事件。故不与代理窗口共用线程：枚举窗口、写恢复文件这类重活会卡住全局输入，
+//! 单次超过 `LowLevelHooksTimeout`（默认 300ms）时系统还会丢弃该事件。
+//! 两个钩子的回调都只做内存判定与 `PostMessageW`，互不阻塞，共用一条线程即可。
+
+use std::sync::atomic::{AtomicIsize, Ordering::Relaxed};
+use std::sync::mpsc::channel;
+use std::thread::JoinHandle;
+
+use windows::Win32::Foundation::{HWND, LPARAM, LRESULT, WPARAM};
+use windows::Win32::System::LibraryLoader::GetModuleHandleW;
+use windows::Win32::System::Threading::{
+    GetCurrentThread, SetThreadPriority, THREAD_PRIORITY_ABOVE_NORMAL,
+};
+use windows::Win32::UI::WindowsAndMessaging::{
+    CW_USEDEFAULT, CreateWindowExW, DefWindowProcW, DestroyWindow, DispatchMessageW, GetMessageW,
+    HWND_MESSAGE, MSG, PostMessageW, PostQuitMessage, RegisterClassW, SendMessageW,
+    TranslateMessage, WINDOW_EX_STYLE, WM_APP, WM_CLOSE, WM_DESTROY, WNDCLASSW, WS_OVERLAPPED,
+};
+use windows::core::{PCWSTR, w};
+
+use crate::keyboard_hook::KeyboardHook;
+use crate::logging;
+use crate::mouse_hook::MouseHook;
+
+/// 装 / 卸某个钩子；`wparam` 为钩子种类，`lparam` 非 0 表示装。
+/// 返回值非 0 表示该钩子当前已装上。
+const WM_HOOK_SET: u32 = WM_APP + 7;
+
+const HOOK_MOUSE: usize = 0;
+const HOOK_KEYBOARD: usize = 1;
+
+/// 代理窗口句柄，钩子命中后把触发投递给它。
+static AGENT_HWND: AtomicIsize = AtomicIsize::new(0);
+
+/// 钩子句柄只在钩子线程上创建与销毁，故存在该线程的 TLS 里。
+#[derive(Default)]
+struct Installed {
+    mouse: Option<MouseHook>,
+    keyboard: Option<KeyboardHook>,
+}
+
+thread_local! {
+    static INSTALLED: std::cell::RefCell<Installed> = std::cell::RefCell::new(Installed::default());
+}
+
+/// 把某个钩子对齐到目标状态，返回对齐后是否已装上。幂等。
+fn apply(kind: usize, want: bool) -> bool {
+    let agent = HWND(AGENT_HWND.load(Relaxed) as *mut std::ffi::c_void);
+    INSTALLED.with(|cell| {
+        let mut installed = cell.borrow_mut();
+        match kind {
+            HOOK_MOUSE => {
+                if !want {
+                    installed.mouse = None;
+                } else if installed.mouse.is_none() {
+                    installed.mouse = MouseHook::install(agent);
+                }
+                installed.mouse.is_some()
+            }
+            HOOK_KEYBOARD => {
+                if !want {
+                    installed.keyboard = None;
+                } else if installed.keyboard.is_none() {
+                    installed.keyboard = KeyboardHook::install(agent);
+                }
+                installed.keyboard.is_some()
+            }
+            _ => false,
+        }
+    })
+}
+
+unsafe extern "system" fn wndproc(hwnd: HWND, msg: u32, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
+    match msg {
+        WM_HOOK_SET => LRESULT(apply(wparam.0, lparam.0 != 0) as isize),
+        WM_DESTROY => {
+            INSTALLED.with(|cell| *cell.borrow_mut() = Installed::default());
+            unsafe { PostQuitMessage(0) };
+            LRESULT(0)
+        }
+        _ => unsafe { DefWindowProcW(hwnd, msg, wparam, lparam) },
+    }
+}
+
+/// 钩子线程自己的仅消息窗口，作为装卸请求的收口。
+fn create_hook_window() -> windows::core::Result<HWND> {
+    unsafe {
+        let hinstance = GetModuleHandleW(PCWSTR::null())?;
+        let class_name = w!("BossKeyInputHookWindow");
+        let wc = WNDCLASSW {
+            lpfnWndProc: Some(wndproc),
+            hInstance: hinstance.into(),
+            lpszClassName: class_name,
+            ..Default::default()
+        };
+        RegisterClassW(&wc);
+
+        CreateWindowExW(
+            WINDOW_EX_STYLE(0),
+            class_name,
+            w!("Boss Key Input Hooks"),
+            WS_OVERLAPPED,
+            CW_USEDEFAULT,
+            CW_USEDEFAULT,
+            0,
+            0,
+            Some(HWND_MESSAGE),
+            None,
+            Some(hinstance.into()),
+            None,
+        )
+    }
+}
+
+/// 钩子线程的句柄；析构时通知线程退出并等它收尾（卸钩子）。
+pub struct InputHooks {
+    hwnd: isize,
+    thread: Option<JoinHandle<()>>,
+}
+
+impl InputHooks {
+    /// 起线程并等它把仅消息窗口建好。窗口建不出来时返回 None，调用方须自行降级。
+    pub fn spawn(agent_hwnd: HWND) -> Option<InputHooks> {
+        AGENT_HWND.store(agent_hwnd.0 as isize, Relaxed);
+        let (tx, rx) = channel::<isize>();
+        let thread = std::thread::Builder::new()
+            .name("bosskey-input-hooks".into())
+            .spawn(move || {
+                unsafe {
+                    // 不上 TIME_CRITICAL，避免把调度权从前台程序手里整体抢走。
+                    let _ = SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL);
+                }
+                let hwnd = match create_hook_window() {
+                    Ok(hwnd) => hwnd,
+                    Err(e) => {
+                        crate::log_error!(
+                            "创建输入钩子窗口失败，鼠标绑定与「不传递」热键将不可用: {}",
+                            crate::util::win_err(&e)
+                        );
+                        let _ = tx.send(0);
+                        return;
+                    }
+                };
+                if tx.send(hwnd.0 as isize).is_err() {
+                    unsafe {
+                        let _ = DestroyWindow(hwnd);
+                    }
+                    return;
+                }
+                unsafe {
+                    let mut msg: MSG = std::mem::zeroed();
+                    loop {
+                        let ret = GetMessageW(&mut msg, None, 0, 0);
+                        if ret.0 <= 0 {
+                            break;
+                        }
+                        let _ = TranslateMessage(&msg);
+                        DispatchMessageW(&msg);
+                    }
+                }
+            })
+            .ok()?;
+
+        match rx.recv() {
+            Ok(hwnd) if hwnd != 0 => Some(InputHooks {
+                hwnd,
+                thread: Some(thread),
+            }),
+            _ => {
+                let _ = thread.join();
+                None
+            }
+        }
+    }
+
+    /// 让鼠标钩子对齐 `on`，返回对齐后是否已装上。
+    pub fn set_mouse(&self, on: bool) -> bool {
+        self.set(HOOK_MOUSE, on)
+    }
+
+    /// 让键盘钩子对齐 `on`，返回对齐后是否已装上。
+    pub fn set_keyboard(&self, on: bool) -> bool {
+        self.set(HOOK_KEYBOARD, on)
+    }
+
+    /// 钩子线程从不阻塞、也从不回发消息给代理线程，故 `SendMessageW` 不会死锁，
+    /// 且能直接拿到安装结果。
+    fn set(&self, kind: usize, on: bool) -> bool {
+        unsafe {
+            let hwnd = HWND(self.hwnd as *mut std::ffi::c_void);
+            SendMessageW(
+                hwnd,
+                WM_HOOK_SET,
+                Some(WPARAM(kind)),
+                Some(LPARAM(on as isize)),
+            )
+            .0 != 0
+        }
+    }
+}
+
+impl Drop for InputHooks {
+    fn drop(&mut self) {
+        unsafe {
+            let hwnd = HWND(self.hwnd as *mut std::ffi::c_void);
+            let _ = PostMessageW(Some(hwnd), WM_CLOSE, WPARAM(0), LPARAM(0));
+        }
+        if let Some(thread) = self.thread.take()
+            && thread.join().is_err()
+        {
+            logging::warn("输入钩子线程异常退出");
+        }
+        AGENT_HWND.store(0, Relaxed);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use windows::Win32::System::Threading::GetCurrentThreadId;
+    use windows::Win32::UI::WindowsAndMessaging::GetWindowThreadProcessId;
+
+    /// 代理窗口句柄传 0：钩子照常装得上，命中时的 `PostMessageW` 会被 0 句柄挡掉。
+    fn hooks() -> InputHooks {
+        InputHooks::spawn(HWND(std::ptr::null_mut())).expect("输入钩子线程应能启动")
+    }
+
+    /// 直接验证承载钩子的消息窗口属于另一条线程。
+    #[test]
+    fn hooks_live_on_their_own_thread() {
+        let hooks = hooks();
+        let owner =
+            unsafe { GetWindowThreadProcessId(HWND(hooks.hwnd as *mut std::ffi::c_void), None) };
+        assert_ne!(owner, 0, "钩子窗口应存活");
+        assert_ne!(
+            owner,
+            unsafe { GetCurrentThreadId() },
+            "钩子必须挂在专职线程上，否则调用方的重活会拖慢全局输入"
+        );
+    }
+
+    /// 本测试线程没有消息循环，而低级钩子只能装在跑消息泵的线程上，
+    /// 故能装上本身即说明请求落到了钩子线程。
+    #[test]
+    fn mouse_and_keyboard_hooks_arm_and_disarm_independently() {
+        let hooks = hooks();
+        assert!(hooks.set_mouse(true));
+        assert!(hooks.set_mouse(true), "重复请求应幂等，不重复安装");
+        assert!(!hooks.set_keyboard(false), "另一个钩子不受影响");
+
+        assert!(hooks.set_keyboard(true));
+        assert!(!hooks.set_mouse(false));
+        assert!(hooks.set_keyboard(true), "卸掉鼠标钩子不应连累键盘钩子");
+
+        assert!(!hooks.set_keyboard(false));
+    }
+
+    /// 析构须让线程退出，否则热重载会让线程越积越多。
+    #[test]
+    fn dropping_stops_the_thread_and_destroys_its_window() {
+        let hwnd = {
+            let hooks = hooks();
+            hooks.set_mouse(true);
+            hooks.hwnd
+        };
+        let owner = unsafe { GetWindowThreadProcessId(HWND(hwnd as *mut std::ffi::c_void), None) };
+        assert_eq!(owner, 0, "线程退出后钩子窗口应已销毁");
+    }
+}
diff --git a/crates/core/src/keyboard_hook.rs b/crates/core/src/keyboard_hook.rs
index ad46f79..8fe0981 100644
--- a/crates/core/src/keyboard_hook.rs
+++ b/crates/core/src/keyboard_hook.rs
@@ -118,7 +118,7 @@ unsafe extern "system" fn hook_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM)
         let data = unsafe { &*(lparam.0 as *const KBDLLHOOKSTRUCT) };
         // 注入的按键（自家的媒体键模拟等）不参与判定，避免反馈回路。
         if data.flags.0 & LLKHF_INJECTED.0 == 0 {
-            // GetKeyState 在锁外调用，锁内只剩纯内存判定。
+            // 在锁外取修饰键状态，锁内只剩纯内存判定。
             let pressed = pressed_modifiers();
             let decision = HOTKEYS
                 .lock()
@@ -142,7 +142,7 @@ pub struct KeyboardHook {
 }
 
 impl KeyboardHook {
-    /// 安装钩子；须在有消息循环的线程（代理窗口线程）上调用。
+    /// 安装钩子；须在 [`crate::input_hooks`] 的专职线程上调用。
     pub fn install(agent_hwnd: HWND) -> Option<KeyboardHook> {
         HWND_RAW.store(agent_hwnd.0 as isize, Relaxed);
         unsafe {
diff --git a/crates/core/src/lib.rs b/crates/core/src/lib.rs
index 6d4c608..5a86fad 100644
--- a/crates/core/src/lib.rs
+++ b/crates/core/src/lib.rs
@@ -12,6 +12,7 @@ pub mod i18n;
 pub mod icon;
 pub mod idle;
 pub mod input;
+pub mod input_hooks;
 pub mod ipc_server;
 pub mod keyboard_hook;
 pub mod logging;
diff --git a/crates/core/src/logging.rs b/crates/core/src/logging.rs
index 77ec632..8245cc1 100644
--- a/crates/core/src/logging.rs
+++ b/crates/core/src/logging.rs
@@ -9,9 +9,8 @@ use std::sync::{Mutex, OnceLock};
 
 use windows::Win32::System::SystemInformation::GetLocalTime;
 
-/// 日志目录名（位于 exe 同目录下）。
 pub const LOG_DIR_NAME: &str = "logs";
-/// 日志文件名前缀（面向用户，使用品牌大小写）。
+/// 日志文件名前缀；面向用户，用品牌大小写。
 const LOG_FILE_PREFIX: &str = "BossKey-";
 const LOG_FILE_SUFFIX: &str = ".log";
 
@@ -218,7 +217,7 @@ macro_rules! log_error {
     };
 }
 
-/// 格式化 panic 信息为单条日志（便于单元测试）。
+/// 格式化 panic 信息为单条日志。
 fn format_panic(message: &str, location: Option<&str>) -> String {
     match location {
         Some(loc) => format!("程序发生崩溃 (panic): {message} @ {loc}"),
diff --git a/crates/core/src/mouse_hook.rs b/crates/core/src/mouse_hook.rs
index 76b761f..421f51a 100644
--- a/crates/core/src/mouse_hook.rs
+++ b/crates/core/src/mouse_hook.rs
@@ -1,3 +1,8 @@
+//! 低级鼠标钩子：承载鼠标按键绑定与四角触发。
+//!
+//! 回调只做判定与 `PostMessageW`，重活都在代理窗口的消息处理里；
+//! 由 [`crate::input_hooks`] 的专职线程安装，鼠标移动这条最热的路径上不加锁。
+
 use std::sync::Mutex;
 use std::sync::atomic::{AtomicI32, AtomicIsize, AtomicU32, AtomicU64, Ordering::Relaxed};
 
@@ -47,8 +52,11 @@ static CORNER_FLAGS: AtomicU32 = AtomicU32::new(0);
 static SCREEN_W: AtomicI32 = AtomicI32::new(0);
 static SCREEN_H: AtomicI32 = AtomicI32::new(0);
 static LAST_CORNER: AtomicU64 = AtomicU64::new(0);
-/// 上一个鼠标位置与时刻，用来估算甩入角落的速度。
-static LAST_MOVE: Mutex<Option<MoveSample>> = Mutex::new(None);
+/// 上一个鼠标位置与时刻，用来估算甩入角落的速度；时刻为 0 表示尚无采样。
+/// 分两个原子存而不用锁：该路径每次鼠标移动都要走，且只被钩子线程读写，
+/// 故不需要跨原子的一致性。
+static LAST_MOVE_POS: AtomicU64 = AtomicU64::new(0);
+static LAST_MOVE_MS: AtomicU64 = AtomicU64::new(0);
 static BUTTONS: Mutex<Buttons> = Mutex::new(Buttons::new());
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -123,6 +131,26 @@ struct MoveSample {
     ms: u64,
 }
 
+/// 把坐标打包进一个 `u64`：高 32 位 x、低 32 位 y。
+fn pack_pos(x: i32, y: i32) -> u64 {
+    ((x as u32 as u64) << 32) | y as u32 as u64
+}
+
+fn unpack_pos(v: u64) -> (i32, i32) {
+    ((v >> 32) as u32 as i32, v as u32 as i32)
+}
+
+/// 取出上一次采样并换上这一次；无上一次采样时返回 None。
+fn swap_last_move(sample: MoveSample) -> Option<MoveSample> {
+    let ms = LAST_MOVE_MS.swap(sample.ms, Relaxed);
+    let pos = LAST_MOVE_POS.swap(pack_pos(sample.x, sample.y), Relaxed);
+    if ms == 0 {
+        return None;
+    }
+    let (x, y) = unpack_pos(pos);
+    Some(MoveSample { x, y, ms })
+}
+
 /// 这一步移动是否算「甩」：位移 / 用时超过速度门槛，且采样间隔有效。
 fn is_fast_move(from: MoveSample, to: MoveSample) -> bool {
     let dt = to.ms.saturating_sub(from.ms);
@@ -230,11 +258,8 @@ fn handle_event(msg: u32, data: &MSLLHOOKSTRUCT) {
             y: data.pt.y,
             ms: now,
         };
-        // 无论是否触发都先记下这次采样，供下次算速度。
-        let previous = LAST_MOVE
-            .lock()
-            .ok()
-            .and_then(|mut last| last.replace(sample));
+        // 须在下面的早退之前记下采样，供下次算速度。
+        let previous = swap_last_move(sample);
 
         if now.wrapping_sub(LAST_CORNER.load(Relaxed)) < CORNER_COOLDOWN_MS {
             return;
@@ -292,9 +317,12 @@ pub struct MouseHook {
 }
 
 impl MouseHook {
-    pub fn install(agent_hwnd: HWND, setting: &Setting) -> Option<MouseHook> {
-        set_flags(setting);
+    /// 安装钩子；须在 [`crate::input_hooks`] 的专职线程上调用。
+    /// 触发条件由 [`set_flags`] 单独设置，本函数不读配置。
+    pub fn install(agent_hwnd: HWND) -> Option<MouseHook> {
         HWND_RAW.store(agent_hwnd.0 as isize, Relaxed);
+        // 上一轮的采样已过时，不能拿来算速度。
+        LAST_MOVE_MS.store(0, Relaxed);
         unsafe {
             SCREEN_W.store(GetSystemMetrics(SM_CXSCREEN), Relaxed);
             SCREEN_H.store(GetSystemMetrics(SM_CYSCREEN), Relaxed);
@@ -320,7 +348,7 @@ mod tests {
     use super::*;
     use crate::hotkey::{MOD_CONTROL, MOD_SHIFT};
 
-    /// 默认配置是「中键单击隐藏」，这里要的是一张白纸，好逐项验证触发条件。
+    /// 关掉默认开启的中键，以便逐项验证触发条件。
     fn setting_with(mutate: impl FnOnce(&mut Setting)) -> Setting {
         let mut s = Setting::default();
         s.mouse.middle.enabled = false;
@@ -428,6 +456,29 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn positions_survive_the_atomic_round_trip() {
+        // 主屏左侧 / 上方的显示器坐标为负，打包不能丢符号。
+        for (x, y) in [(0, 0), (1919, 1079), (-1920, -300), (i32::MIN, i32::MAX)] {
+            assert_eq!(unpack_pos(pack_pos(x, y)), (x, y));
+        }
+    }
+
+    #[test]
+    fn swapping_yields_the_previous_sample_and_nothing_on_the_first() {
+        LAST_MOVE_MS.store(0, Relaxed);
+        assert_eq!(
+            swap_last_move(sample(-5, 1070, 1000)),
+            None,
+            "首次采样没有上一次"
+        );
+        assert_eq!(
+            swap_last_move(sample(1900, 3, 1200)),
+            Some(sample(-5, 1070, 1000))
+        );
+        LAST_MOVE_MS.store(0, Relaxed);
+    }
+
     #[test]
     fn stale_or_zero_interval_samples_are_not_trusted() {
         assert!(!is_fast_move(sample(0, 0, 1000), sample(1900, 1070, 1500)));
diff --git a/crates/core/src/shell.rs b/crates/core/src/shell.rs
index 2917fd6..f3d6a94 100644
--- a/crates/core/src/shell.rs
+++ b/crates/core/src/shell.rs
@@ -4,13 +4,11 @@ use windows::core::{PCWSTR, w};
 
 use crate::util::to_wide_null;
 
-/// 用系统默认程序打开路径或 URL（等价于在资源管理器里双击）。
+/// 用系统默认程序打开路径或 URL。
 ///
-/// 走 ShellExecute 的 "open" 动词，而不是直接 `CreateProcess` 启动
-/// explorer.exe：当本进程以管理员（高完整性令牌）运行时——例如配置程序
-/// 由已提权的核心从托盘菜单拉起——直接启动 explorer.exe 会被系统拒绝，
-/// 报「拒绝访问 / OS Error 5」。"open" 动词交由 Shell 处理，不受完整性
-/// 级别限制。
+/// 必须走 ShellExecute 的 "open" 动词：本进程以管理员运行时（如配置程序由
+/// 已提权的核心拉起），直接 `CreateProcess` 启动 explorer.exe 会被系统拒绝
+/// （OS Error 5）。"open" 交由 Shell 处理，不受完整性级别限制。
 pub fn open(target: &str) -> Result<(), String> {
     let wide = to_wide_null(target);
     let result = unsafe {
diff --git a/crates/core/src/tray_badge.rs b/crates/core/src/tray_badge.rs
index 8d1c933..25aa93a 100644
--- a/crates/core/src/tray_badge.rs
+++ b/crates/core/src/tray_badge.rs
@@ -17,7 +17,7 @@ use windows::Win32::UI::WindowsAndMessaging::{CreateIconIndirect, HICON, ICONINF
 
 use crate::icon::IconRgba;
 
-/// 角标描边：白色，用于在深浅任务栏背景上都能衬出圆点边界。
+/// 角标描边，使圆点在深浅任务栏背景上都衬得出边界。
 const BADGE_RING: [u8; 4] = [0xFF, 0xFF, 0xFF, 0xFF];
 
 /// 角标颜色，declaration 顺序即显示优先级（红最高）。
@@ -84,8 +84,7 @@ pub fn active_badge(badges: &TrayBadges, status: &TrayStatus) -> Option<BadgeCol
 }
 
 /// 在顶到底 RGBA 像素的右下角叠加一个带白色描边的实心圆点。
-///
-/// 圆点直径约为图标边长的 44%，紧贴右下角；边缘做 1px 线性过渡抗锯齿。
+/// 直径约为图标边长的 44%，边缘做 1px 线性过渡抗锯齿。
 /// `pixels` 长度必须等于 `width*height*4`，否则不做任何修改。
 fn overlay_badge(pixels: &mut [u8], width: u32, height: u32, color: [u8; 4]) {
     if width == 0 || height == 0 || pixels.len() != (width * height * 4) as usize {
@@ -189,9 +188,7 @@ fn rgba_to_hicon(icon: &IconRgba) -> Option<HICON> {
     }
 }
 
-/// 基础图标 + 各颜色角标的 HICON 缓存。
-///
-/// 颜色数量有限（4 种），生成后缓存复用；缓存的 HICON 随进程存活，不逐个销毁。
+/// 基础图标 + 各颜色角标的 HICON 缓存；缓存的 HICON 随进程存活，不逐个销毁。
 pub struct TrayIconSet {
     base: HICON,
     base_rgba: Option<IconRgba>,
diff --git a/crates/core/src/util.rs b/crates/core/src/util.rs
index 478c4dd..c47bc65 100644
--- a/crates/core/src/util.rs
+++ b/crates/core/src/util.rs
@@ -51,9 +51,8 @@ pub fn pressed_modifiers() -> u32 {
     m
 }
 
-/// 把 Win32/COM 错误格式化为「系统消息 (0x错误码)」，供日志同时记录可读原因与可检索的码值。
-///
-/// 只有消息文本时无法区分「拒绝访问」的来源，只有码值又难以直接判读，故两者都写出。
+/// 把 Win32/COM 错误格式化为「系统消息 (0x错误码)」。
+/// 只有消息文本时无法区分「拒绝访问」的来源，只有码值又难以判读，故两者都写出。
 pub fn win_err(e: &windows::core::Error) -> String {
     let message = e.message();
     let message = message.trim();
diff --git a/docs/dev/architecture.md b/docs/dev/architecture.md
index 99f9fba..dff40fa 100644
--- a/docs/dev/architecture.md
+++ b/docs/dev/architecture.md
@@ -86,6 +86,7 @@ Boss-Key/
 │           effects_worker.rs  副作用专职线程（FIFO 队列；消息循环只做 SW_HIDE）
 │           audio.rs      Core Audio 会话静音
 │           freeze.rs     NtSuspend/Resume + pssuspend64 增强冻结
+│           input_hooks.rs 输入钩子专职线程（承载两个低级钩子，优先级 above normal）
 │           mouse_hook.rs WH_MOUSE_LL（中键/侧键/四角）
 │           keyboard_hook.rs WH_KEYBOARD_LL（「不传递」热键拦截）
 │           idle.rs       GetLastInputInfo 空闲 + 自动隐藏判定
@@ -162,6 +163,14 @@ Tauri 按 `tauri.conf.json` 里的 identifier 把 WebView2 用户数据放在 `%
 
 消息循环状态由 `RefCell` 承载：托盘 / 悬浮窗菜单的模态循环（`TrackPopupMenu`）会重入 `wndproc`，重入期间的事件借用失败即被安全丢弃，避免出现两个可变引用的别名。IPC 线程创建命名管道失败时按退避（1s → 5s → 30s）重试，不会退出。
 
+### 低级输入钩子不与消息循环同线程
+
+`WH_MOUSE_LL` / `WH_KEYBOARD_LL` 的回调由**安装线程的消息泵**派发，且系统的输入线程要等钩子链返回才继续投递事件。若与 agent 同线程，枚举窗口、写恢复文件、处理全系统窗口事件这类操作会直接拖慢全局鼠标与键盘输入，单次超过 `LowLevelHooksTimeout`（默认 300ms）时系统还会丢弃该事件。
+
+故 `input_hooks.rs` 单起一条只跑消息泵的线程承载这两个钩子，线程优先级提到 above normal，回调里只做纯内存判定与 `PostMessageW`（鼠标移动这条最热的路径上不加锁，采样存在原子里）。agent 线程通过一个仅消息窗口向它同步下发装卸请求，并据返回值决定是否回退（键盘钩子装不上时「不传递」热键退化为 `RegisterHotKey`）。
+
+agent 线程本身**不**提优先级：它干的是枚举 / 冻结 / 落盘这类重活，抬高只会从前台程序手里抢 CPU。
+
 窗口事件驱动隐藏记录的实时维护：被隐藏的窗口自行销毁或被外部恢复显示时，记录即刻移除并落盘；标题变化同步进隐藏记录与精确窗口规则（仅内存，随下次正常落盘写出），使「标题 + 进程路径」的追溯与找回始终基于最新信息。恢复时若句柄已失效，还会按「进程路径 + 标题」在当前不可见窗口中尝试重新找回。
 
 当触发隐藏 / 显示时，交由 `HideController` 编排，流程为「意图先行」两段式：`plan_hide` 算出执行计划（剪掉失效记录、补齐 PID）→ 把计划后的快照写入 `recovery.json`（先落盘再动手，隐藏中途崩溃不丢记录）→ `commit_hide` 同步隐藏窗口（`SW_HIDE`），并把静音 / 冻结 / 暂停键交给副作用专职线程（`effects_worker.rs`）按 FIFO 异步执行——消息循环不被慢操作（音频枚举、pssuspend 等待）阻塞，热键与界面保持响应。
diff --git a/docs/en/dev/architecture.md b/docs/en/dev/architecture.md
index 2243582..c716517 100644
--- a/docs/en/dev/architecture.md
+++ b/docs/en/dev/architecture.md
@@ -86,6 +86,7 @@ Boss-Key/
 │           effects_worker.rs  Dedicated side-effect thread (FIFO queue; the message loop only does SW_HIDE)
 │           audio.rs      Core Audio session muting
 │           freeze.rs     NtSuspend/Resume + pssuspend64 enhanced freezing
+│           input_hooks.rs Dedicated input-hook thread (owns both low-level hooks, above-normal priority)
 │           mouse_hook.rs WH_MOUSE_LL (middle/side buttons, corners)
 │           keyboard_hook.rs WH_KEYBOARD_LL ("don't pass through" hotkey interception)
 │           idle.rs       GetLastInputInfo idle detection + auto-hide decision
@@ -162,6 +163,14 @@ The data folder actually in use, and how it was chosen, are written to the log o
 
 Message-loop state lives in a `RefCell`: the modal loops of the tray / floating-window menus (`TrackPopupMenu`) re-enter `wndproc`, and events arriving during re-entry fail the borrow and are safely dropped, so no aliased mutable references can exist. The IPC thread retries pipe creation with backoff (1s → 5s → 30s) instead of exiting.
 
+### Low-level input hooks do not share the message loop's thread
+
+`WH_MOUSE_LL` / `WH_KEYBOARD_LL` callbacks are dispatched by the **installing thread's message pump**, and the system's input thread waits for the hook chain to return before delivering the event onward. Sharing a thread with the agent means enumerating windows, writing the recovery file, or handling system-wide window events would directly slow down global mouse and keyboard input; a single callback exceeding `LowLevelHooksTimeout` (300ms by default) also makes the system drop that event.
+
+`input_hooks.rs` therefore runs a dedicated thread that does nothing but pump messages for these two hooks, at above-normal priority. The callbacks only perform in-memory checks and `PostMessageW` (the hottest path, mouse movement, takes no lock — samples live in atomics). The agent thread issues install/uninstall requests synchronously through a message-only window and uses the return value to decide whether to fall back (when the keyboard hook cannot be installed, "do not pass through" hotkeys degrade to `RegisterHotKey`).
+
+The agent thread's own priority is **not** raised: it does the heavy work — enumeration, freezing, persistence — and raising it would only steal CPU from foreground programs.
+
 Window events keep the hidden records maintained in real time: when a hidden window is destroyed or shown externally, its record is removed and persisted immediately; title changes are synced into hidden records and exact window rules (in memory only, written out with the next regular persist), so reacquisition and refinding by "title + process path" always work on fresh data. On restore, records with dead handles are additionally refound among currently invisible windows by "process path + title".
 
 When hiding or showing is triggered, `HideController` orchestrates it with a two-phase, intent-first flow: `plan_hide` computes the execution plan (pruning stale records and backfilling PIDs) → the planned snapshot is written to `recovery.json` (persist first, act second — a crash mid-hide loses no records) → `commit_hide` hides the windows synchronously (`SW_HIDE`) and hands muting / freezing / the pause key to the dedicated side-effect thread (`effects_worker.rs`), executed asynchronously in FIFO order — the message loop is never blocked by slow operations (audio enumeration, waiting on pssuspend), so hotkeys and the UI stay responsive.
diff --git a/docs/zh-tw/dev/architecture.md b/docs/zh-tw/dev/architecture.md
index c677953..80b7e80 100644
--- a/docs/zh-tw/dev/architecture.md
+++ b/docs/zh-tw/dev/architecture.md
@@ -86,6 +86,7 @@ Boss-Key/
 │           effects_worker.rs  副作用專職執行緒（FIFO 佇列；訊息迴圈只做 SW_HIDE）
 │           audio.rs      Core Audio 工作階段靜音
 │           freeze.rs     NtSuspend/Resume + pssuspend64 增強凍結
+│           input_hooks.rs 輸入掛鉤專職執行緒（承載兩個低階掛鉤，優先權 above normal）
 │           mouse_hook.rs WH_MOUSE_LL（中鍵/側鍵/四角）
 │           keyboard_hook.rs WH_KEYBOARD_LL（「不傳遞」快速鍵攔截）
 │           idle.rs       GetLastInputInfo 閒置 + 自動隱藏判定
@@ -161,6 +162,14 @@ Tauri 按 `tauri.conf.json` 裡的 identifier 把 WebView2 使用者資料放在
 
 訊息迴圈狀態由 `RefCell` 承載：通知區域／懸浮窗選單的強制回應迴圈（`TrackPopupMenu`）會重入 `wndproc`，重入期間的事件借用失敗即被安全丟棄，避免出現兩個可變參考的別名。IPC 執行緒建立具名管道失敗時按退避（1s → 5s → 30s）重試，不會結束。
 
+### 低階輸入掛鉤不與訊息迴圈同執行緒
+
+`WH_MOUSE_LL`／`WH_KEYBOARD_LL` 的回呼由**安裝執行緒的訊息幫浦**派送，且系統的輸入執行緒要等掛鉤鏈返回才繼續投遞事件。若與 agent 同執行緒，列舉視窗、寫入復原檔案、處理全系統視窗事件這類操作會直接拖慢全域滑鼠與鍵盤輸入，單次超過 `LowLevelHooksTimeout`（預設 300ms）時系統還會丟棄該事件。
+
+故 `input_hooks.rs` 單獨啟動一條只跑訊息幫浦的執行緒承載這兩個掛鉤，執行緒優先權提到 above normal，回呼裡只做純記憶體判定與 `PostMessageW`（滑鼠移動這條最熱的路徑上不加鎖，取樣存在不可分割變數裡）。agent 執行緒透過一個僅訊息視窗向它同步下達裝卸請求，並依返回值決定是否回退（鍵盤掛鉤裝不上時「不傳遞」快速鍵退化為 `RegisterHotKey`）。
+
+agent 執行緒本身**不**提優先權：它做的是列舉／凍結／寫入磁碟這類重活，抬高只會從前景程式手裡搶 CPU。
+
 視窗事件驅動隱藏紀錄的即時維護：被隱藏的視窗自行銷毀或被外部復原顯示時，紀錄即刻移除並寫入磁碟；標題變化同步進隱藏紀錄與精確視窗規則（僅記憶體，隨下次正常寫入時落盤），使「標題 + 程序路徑」的追溯與找回始終基於最新資訊。復原時若控制代碼已失效，還會按「程序路徑 + 標題」在目前不可見視窗中嘗試重新找回。
 
 當觸發隱藏／顯示時，交由 `HideController` 編排，流程為「意圖先行」兩段式：`plan_hide` 算出執行計畫（剪掉失效紀錄、補齊 PID）→ 把計畫後的快照寫入 `recovery.json`（先寫入再動手，隱藏中途當機不丟紀錄）→ `commit_hide` 同步隱藏視窗（`SW_HIDE`），並把靜音／凍結／暫停鍵交給副作用專職執行緒（`effects_worker.rs`）按 FIFO 非同步執行——訊息迴圈不被慢操作（音訊列舉、pssuspend 等待）阻塞，快速鍵與介面保持回應。