滚动截图，细节调整

README.md

@@ -111,7 +111,7 @@ Thing/
 - [x] 自建进程内下载引擎（多线程 HTTP/HTTPS，无需外部内核）
 - [x] 接管浏览器下载，浏览器扩展（Thing Extension）
 - [x] HTTP 下载支持
-- [ ] BT/磁力链接支持（后续支持）
+- [x] BT/磁力链接支持（后续支持）
 - [x] 下载任务管理（历史）
 - [x] 速度限制
 - [x] 断点续传
@@ -124,8 +124,8 @@ Thing/
 
 ### 第三阶段：优化与完善
 
-- [x] 性能优化（P1/P2：轮询随窗口可见性暂停、批量测速限并发、渲染 memo 化等，见 MODULE_REVIEW.md）
-- [x] 错误处理与日志完善（B5 进程级全局日志器、异常兜底）
+- [x] 性能优化（见 MODULE_REVIEW.md）
+- [x] 错误处理与日志完善（全局日志器、异常兜底）
 - [x] 用户体验优化（混合 DPI 定位、rAF 节流、UI 细节）
 - [x] 自动更新机制
 - [x] 打包发布

ThingHK/Contracts.cs

@@ -66,6 +66,8 @@ internal sealed class KernelStatus
 {
     public bool Ready { get; set; }
     public bool IsAdmin { get; set; }
+    /// <summary>PawnIO 驱动是否已安装（ring0 传感器读取依赖它或 WinRing0，缺失时温度/频率通常无法读取）</summary>
+    public bool PawnIoInstalled { get; set; }
     public double UptimeMs { get; set; }
     public int GroupCount { get; set; }
     public int SensorCount { get; set; }

ThingHK/HardwareManager.cs

@@ -277,7 +277,7 @@ internal sealed class HardwareManager : IDisposable
         _ => "",
     };
 
-    private static bool IsRunningAsAdmin()
+    internal static bool IsRunningAsAdmin()
     {
         try
         {

ThingHK/HttpEndpoints.cs

@@ -44,6 +44,7 @@ internal static class HttpEndpoints
             {
                 Ready = hw?.Ready ?? false,
                 IsAdmin = hw?.IsAdmin ?? false,
+                PawnIoInstalled = PawnIoSupport.IsServiceInstalled(),
                 UptimeMs = kernel.Uptime.Elapsed.TotalMilliseconds,
                 GroupCount = snap?.Groups.Count ?? 0,
                 SensorCount = kernel.Scheduler.Cache.SensorCount,

ThingHK/PawnIoSupport.cs

@@ -0,0 +1,101 @@
+using System.Diagnostics;
+using Microsoft.Win32;
+
+namespace ThingHK;
+
+/// <summary>
+/// PawnIO 驱动支持：检测 + 静默安装。
+///
+/// 背景：LHM 读取 CPU 温度/频率等 ring0 数据依赖内核驱动，回退用的 WinRing0 被
+/// 微软"易受攻击的驱动程序阻止列表"和部分杀软（如火绒）拦截，导致传感器缺失。
+/// PawnIO 是正规签名的替代驱动（不在阻止列表、兼容 HVCI/安全启动），
+/// LHM 0.9.5+ 检测到已安装时优先使用，无需任何代码开关。
+///
+/// 安装器约定：PawnIO_setup.exe 与 ThingHK.exe 同目录
+/// （由 Tauri 侧 prepare_kernel 从资源目录随内核一起复制到 {app_data}/monitor/cores/）。
+///
+/// 静默参数：-install -silent（官方 CLI 参数，见 namazso/PawnIO.Setup）。
+/// 退出码：0=成功；3010=成功但需重启（ERROR_SUCCESS_REBOOT_REQUIRED）。
+///
+/// 策略：仅在内核已提权时安装。两种提权模式（Thing 提权继承 / 仅提权 ThingHK）
+/// 都只有一次 UAC，内核拿到权限后自行静默安装，避免二次弹窗。
+/// serve 模式调用；scan 诊断模式不安装，保持被动。
+/// </summary>
+internal static class PawnIoSupport
+{
+    /// <summary>驱动服务注册表键：存在即认为已安装</summary>
+    private const string ServiceKeyName = @"SYSTEM\CurrentControlSet\Services\PawnIO";
+
+    private const string SetupFileName = "PawnIO_setup.exe";
+
+    /// <summary>3010 = ERROR_SUCCESS_REBOOT_REQUIRED（安装成功但需重启生效）</summary>
+    private const int ExitCodeRebootRequired = 3010;
+
+    /// <summary>驱动安装通常数秒内完成，留足余量防止卡死启动流程</summary>
+    private const int InstallTimeoutMs = 90_000;
+
+    /// <summary>检测 PawnIO 驱动服务是否已注册</summary>
+    public static bool IsServiceInstalled()
+    {
+        try
+        {
+            using var key = Registry.LocalMachine.OpenSubKey(ServiceKeyName);
+            return key != null;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// 确保 PawnIO 就绪：已安装直接返回；未安装且当前已提权时静默安装。
+    /// 返回描述性结果（写入 stderr 日志 + /status 诊断）。
+    /// </summary>
+    public static string EnsureInstalled()
+    {
+        if (IsServiceInstalled())
+            return "already-installed";
+
+        if (!HardwareManager.IsRunningAsAdmin())
+            return "skipped: not elevated (温度/频率等传感器需要提权运行)";
+
+        string setupPath = Path.Combine(AppContext.BaseDirectory, SetupFileName);
+        if (!File.Exists(setupPath))
+            return $"skipped: {SetupFileName} 未找到（应随内核一起部署，见 prepare_kernel）";
+
+        try
+        {
+            using var process = Process.Start(new ProcessStartInfo
+            {
+                FileName = setupPath,
+                Arguments = "-install -silent",
+                UseShellExecute = false,
+                CreateNoWindow = true,
+            });
+            if (process == null)
+                return "failed: Process.Start 返回 null";
+
+            if (!process.WaitForExit(InstallTimeoutMs))
+            {
+                try { process.Kill(); } catch { /* 超时后进程可能已自行退出 */ }
+                return "failed: 安装超时";
+            }
+
+            int code = process.ExitCode;
+            if (code == ExitCodeRebootRequired)
+                return "installed: 需重启后生效";
+
+            if (code != 0)
+                return $"failed: 安装器退出码 {code}";
+
+            return IsServiceInstalled()
+                ? "installed"
+                : "failed: 安装器返回 0 但服务未注册";
+        }
+        catch (Exception ex)
+        {
+            return $"failed: {ex.Message}";
+        }
+    }
+}

ThingHK/Program.cs

@@ -87,6 +87,11 @@ internal static class Program
 
         Console.Error.WriteLine($"[ThingHK] serve 模式: port={port} config={configPath ?? "(默认)"} fast={fastMs}ms slow={slowMs}ms");
 
+        // PawnIO：ring0 传感器读取的首选驱动（未安装且已提权时静默安装，
+        // 避开 WinRing0 被系统阻止列表/杀软拦截导致的温度/频率缺失）
+        string pawnIoResult = PawnIoSupport.EnsureInstalled();
+        Console.Error.WriteLine($"[ThingHK] PawnIO: {pawnIoResult}");
+
         using var kernel = new KernelHost();
         await kernel.StartAsync(configPath, fastMs, slowMs);
 

ThingHK/ThingHK.csproj

@@ -25,7 +25,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="LibreHardwareMonitorLib" Version="0.9.7-pre716" />
+    <PackageReference Include="LibreHardwareMonitorLib" Version="0.9.7-pre729" />
     <PackageReference Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
   </ItemGroup>
 

package.json

@@ -1,7 +1,7 @@
 {
   "name": "thing",
   "private": true,
-  "version": "26.8.4",
+  "version": "26.8.5",
   "type": "module",
   "scripts": {
     "dev": "vite",

src-tauri/Cargo.lock

@@ -5951,7 +5951,7 @@ dependencies = [
 
 [[package]]
 name = "thing"
-version = "26.8.4"
+version = "26.8.5"
 dependencies = [
  "axum 0.7.9",
  "base64 0.22.1",
@@ -5985,6 +5985,7 @@ dependencies = [
  "url",
  "walkdir",
  "windows 0.52.0",
+ "windows-capture",
  "windows-sys 0.52.0",
  "winreg 0.52.0",
  "zip",
@@ -6908,6 +6909,19 @@ dependencies = [
  "windows-numerics 0.3.1",
 ]
 
+[[package]]
+name = "windows-capture"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09046acbe9b6d039cde50e8c8178d95bb0f9b33ed7feccc4465dadc5404b31b4"
+dependencies = [
+ "parking_lot",
+ "rayon",
+ "thiserror 2.0.18",
+ "windows 0.62.2",
+ "windows-future 0.3.2",
+]
+
 [[package]]
 name = "windows-collections"
 version = "0.2.0"

src-tauri/capabilities/screenshot.json

@@ -1,8 +1,8 @@
 {
   "$schema": "../gen/schemas/desktop-schema.json",
   "identifier": "screenshot",
-  "description": "Capability for screenshot overlay, editor and pin windows",
-  "windows": ["screenshot-overlay*", "screenshot-editor-*", "screenshot-pin"],
+  "description": "Capability for screenshot overlay, editor, pin and scroll-control windows",
+  "windows": ["screenshot-overlay*", "screenshot-editor*", "screenshot-pin", "screenshot-scroll-*"],
   "permissions": [
     "core:default",
     "core:window:allow-hide",
@@ -18,6 +18,7 @@
     "core:window:allow-close",
     "core:event:allow-emit",
     "core:event:allow-listen",
+    "core:webview:allow-create-webview-window",
     "dialog:default",
     "snap-layout:default"
   ]

src-tauri/src/constants.rs

@@ -12,6 +12,8 @@ pub mod windows {
     pub const SCREENSHOT_OVERLAY: &str = "screenshot-overlay";
     #[allow(dead_code)]
     pub const SCREENSHOT_PIN: &str = "screenshot-pin";
+    #[allow(dead_code)]
+    pub const SCREENSHOT_SCROLL: &str = "screenshot-scroll";
 }
 
 /// Tauri 事件名（与前端 constants::EVENTS 对应）
@@ -44,11 +46,21 @@ pub mod events {
     // OSD 窗口
     pub const OSD_SYSTEM_UI_ACTIVE: &str = "osd-system-ui-active";
     pub const OSD_SYSTEM_UI_INACTIVE: &str = "osd-system-ui-inactive";
+    pub const OSD_GAME_ACTIVE: &str = "osd-game-active";
+    pub const OSD_GAME_INACTIVE: &str = "osd-game-inactive";
     pub const OSD_START_DRAG: &str = "osd-start-drag";
     pub const OSD_END_DRAG: &str = "osd-end-drag";
     // 截图
     pub const SCREENSHOT_SHORTCUT: &str = "screenshot-shortcut";
     pub const SCREENSHOT_PIN_SHORTCUT: &str = "screenshot-pin-shortcut";
+    /// 截图结果导出（含覆盖层/编辑器/滚动截图会话）
+    pub const SCREENSHOT_EXPORTED: &str = "screenshot-exported";
+    /// 滚动截图会话：实时进度 { width, height, auto }
+    pub const SCROLL_PROGRESS: &str = "screenshot-scroll-progress";
+    /// 滚动截图会话：完成并导出（负载与 SCREENSHOT_EXPORTED 相同）
+    pub const SCROLL_COMPLETE: &str = "screenshot-scroll-complete";
+    /// 滚动截图会话：已取消（无负载）
+    pub const SCROLL_CANCELLED: &str = "screenshot-scroll-cancelled";
     // 内核安装进度
     pub const KERNEL_INSTALL_PROGRESS: &str = "kernel-install-progress";
     // 后端自动切换节点完成（前端据以刷新节点列表并提示）

src-tauri/src/download_engine/engine.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::path::PathBuf;
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::{Arc, Mutex};
@@ -115,8 +115,8 @@ struct EngineInner {
     http: HttpDownloader,
     /// BitTorrent 下载器（封装 librqbit 全局会话）
     torrent: TorrentDownloader,
-    /// 下载是否使用代理（true=尊重系统代理，false=强制直连）
-    /// 独立于 settings 存储，避免下载过程中反复锁 settings；save_settings 时同步更新
+    /// 下载是否使用代理（true=尝试走本地 mihomo 代理（mihomo 运行时才走），false=强制直连）。
+    /// 不再依赖系统代理。独立于 settings 存储，避免下载过程中反复锁 settings；save_settings 时同步更新
     use_proxy: AtomicBool,
     /// Tauri 应用句柄（用于发事件）
     app_handle: AppHandle,
@@ -126,6 +126,11 @@ struct EngineInner {
     next_gen: AtomicU64,
     /// 持久化节流：上次保存时间
     last_save: Mutex<Instant>,
+    /// mihomo 代理地址解析缓存（含解析时刻），避免每个任务反复探测控制端
+    mihomo_proxy_cache: Mutex<Option<(Instant, Option<String>)>>,
+    /// HTTP 任务元数据后台探测中（占位任务已建但尚未完成探测/分段）：
+    /// 期间 schedule 跳过此类任务，防止用"未知大小/单段"提前启动；探测完成后移除并重新调度
+    http_pending: Mutex<HashSet<String>>,
 }
 
 impl DownloadEngine {
@@ -161,7 +166,7 @@ impl DownloadEngine {
         let use_proxy = settings.use_proxy;
         // BT 会话默认目录（下载目录，每个任务用 output_folder 覆盖）
         // 解析 BT 代理地址（若开启且代理模块可用）
-        let bt_socks = bt_proxy_addr(&app_handle, settings.bt_use_proxy);
+        let bt_socks = bt_proxy_addr(&app_handle, settings.use_proxy);
         let torrent = TorrentDownloader::new(PathBuf::from(&settings.download_dir));
         // 同步 BT 专属设置（上传限速 / 监听端口 / 代理）
         torrent.set_settings(settings.bt_upload_limit_kb, settings.bt_listen_port, bt_socks);
@@ -180,6 +185,8 @@ impl DownloadEngine {
                 started: AtomicBool::new(false),
                 next_gen: AtomicU64::new(0),
                 last_save: Mutex::new(Instant::now()),
+                mihomo_proxy_cache: Mutex::new(None),
+                http_pending: Mutex::new(HashSet::new()),
             }),
         };
 
@@ -227,6 +234,7 @@ impl DownloadEngine {
         }
 
         let use_proxy = self.inner.use_proxy.load(Ordering::SeqCst);
+        self.ensure_mihomo_proxy().await;
         let probe = self.inner.http.probe(url, headers, use_proxy).await;
         let settings = self.inner.settings.lock().unwrap_or_else(|e| e.into_inner()).clone();
         let task_dir = dir.map(|d| d.to_string()).unwrap_or_else(|| settings.download_dir.clone());
@@ -439,50 +447,50 @@ impl DownloadEngine {
             return self.add_bt_task(url, dir, only_files).await;
         }
 
-        // 探测资源信息
-        let use_proxy = self.inner.use_proxy.load(Ordering::SeqCst);
-        let probe = self.inner.http.probe(&url, &headers, use_proxy).await;
-
+        // HTTP 任务采用"立即占位 + 后台探测"：
+        // 点击添加后立即返回 id 并让任务出现在列表，探测/分段/调度全部放后台，
+        // 避免添加操作阻塞在慢速探测（如 mihomo 未就绪/网络不通）上，也防止用户因"没反应"多次点击。
         let settings = self.inner.settings.lock().unwrap_or_else(|e| e.into_inner()).clone();
-        let task_dir = dir.unwrap_or_else(|| settings.download_dir.clone());
+        let task_dir = dir.clone().unwrap_or_else(|| settings.download_dir.clone());
 
-        // 确定文件名
-        let mut task_filename = filename
-            .or_else(|| probe.as_ref().ok().and_then(|p| p.filename.clone()))
-            .unwrap_or_else(|| {
-                url.split('?')
-                    .next()
-                    .and_then(|u| u.rsplit('/').next())
-                    .filter(|n| !n.is_empty())
-                    .map(|n| n.to_string())
-                    .unwrap_or_else(|| format!("download_{}", chrono::Utc::now().timestamp()))
-            });
-
-        // 自动重命名：若磁盘已存在同名文件，追加 (1)、(2)...
-        if auto_rename {
-            task_filename = self.generate_unique_filename(&task_dir, &task_filename);
+        // 1) 后端 URL 去重：同 URL 且非终态任务已存在 → 直接复用既有 id，不重复创建。
+        //    接住多次点击/重复转发造成的重复添加。
+        if settings.check_duplicate {
+            let dup_id = {
+                let tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
+                tasks
+                    .values()
+                    .find(|t| {
+                        t.protocol == TaskProtocol::Http
+                            && t.url == url
+                            && matches!(
+                                t.status,
+                                TaskStatus::Queued | TaskStatus::Active | TaskStatus::Paused
+                            )
+                    })
+                    .map(|t| t.id.clone())
+            };
+            if let Some(id) = dup_id {
+                return Ok(id);
+            }
         }
 
         let id = self.inner.storage.next_task_id();
 
-        // 创建分段（受 continue_download 设置控制：关闭时强制单线程、不支持续传）
-        let resume_enabled = settings.continue_download;
-        let segments = match &probe {
-            Ok(p) if resume_enabled && p.supports_resume && p.total_size.map(|s| s > 0).unwrap_or(false) => {
-                split_segments(p.total_size.unwrap(), settings.max_connections)
-            }
-            _ => vec![Segment {
-                index: 0,
-                start: 0,
-                end: 0,
-                completed: 0,
-            }],
-        };
-
-        let total_size = probe.as_ref().ok().and_then(|p| p.total_size).unwrap_or(0);
-        let supports_resume = resume_enabled
-            && probe.as_ref().ok().map(|p| p.supports_resume).unwrap_or(false);
+        // 2) 占位文件名：优先用调用方指定，否则先用 URL 推导，探测完成后用 Content-Disposition 修正
+        let mut task_filename = filename.clone().unwrap_or_else(|| {
+            url.split('?')
+                .next()
+                .and_then(|u| u.rsplit('/').next())
+                .filter(|n| !n.is_empty())
+                .map(|n| n.to_string())
+                .unwrap_or_else(|| format!("download_{}", chrono::Utc::now().timestamp()))
+        });
+        if auto_rename {
+            task_filename = self.generate_unique_filename(&task_dir, &task_filename);
+        }
 
+        // 3) 立即插入占位任务：Queued（未探测完成前 schedule 会跳过），未知大小单段
         let task = DownloadTask {
             id: id.clone(),
             url: url.clone(),
@@ -493,47 +501,128 @@ impl DownloadEngine {
             bt_files: Vec::new(),
             bt_metadata_ready: false,
             status: TaskStatus::Queued,
-            total_size,
+            total_size: 0,
             completed_size: 0,
             speed: 0,
-            supports_resume,
-            segments: segments.clone(),
+            supports_resume: false,
+            segments: vec![Segment {
+                index: 0,
+                start: 0,
+                end: 0,
+                completed: 0,
+            }],
             error: None,
             created_at: chrono::Utc::now().timestamp_millis(),
-            headers,
+            headers: headers.clone(),
         };
-
-        // 如果探测失败，标记为 Error
-        let task = match probe {
-            Ok(_) => task,
-            Err(e) => DownloadTask {
-                status: TaskStatus::Error,
-                error: Some(e),
-                ..task
-            },
-        };
-
         {
             let mut tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
             tasks.insert(id.clone(), task);
         }
+        // 标记该任务元数据探测中，避免被并发调度提前启动
+        self.inner
+            .http_pending
+            .lock()
+            .unwrap_or_else(|e| e.into_inner())
+            .insert(id.clone());
         self.persist_now();
+        self.emit_task_added(&id);
 
-        // 如果探测成功，尝试调度
-        let should_schedule = {
-            let tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
-            tasks.get(&id).map(|t| t.status == TaskStatus::Queued).unwrap_or(false)
-        };
-        if should_schedule {
-            self.schedule();
-        }
+        // 4) 后台探测/分段/调度：不阻塞本函数，点击添加后立即返回
+        let engine = self.clone();
+        let rid = id.clone();
+        let raw_url = url.clone();
+        let raw_headers = headers.clone();
+        let use_proxy = self.inner.use_proxy.load(Ordering::SeqCst);
+        tauri::async_runtime::spawn(async move {
+            engine.ensure_mihomo_proxy().await;
+            let probe = engine.inner.http.probe(&raw_url, &raw_headers, use_proxy).await;
 
-        // 通知前端有新任务加入（扩展通过 HTTP API 添加时，前端需要刷新）
-        let _ = self.inner.app_handle.emit(crate::constants::events::DOWNLOAD_ADDED, serde_json::json!({ "id": id }));
+            // 探测结束，解除 pending 门控
+            engine
+                .inner
+                .http_pending
+                .lock()
+                .unwrap_or_else(|e| e.into_inner())
+                .remove(&rid);
+
+            let mut should_schedule = false;
+            // 先在锁内应用非文件名字段，并取出目录/探测文件名（释放锁后再做唯一化命名，
+            // 因为 generate_unique_filename 内部会再锁 tasks，持锁调用会死锁）
+            let rename_from: Option<(String, Option<String>)> = {
+                let mut tasks = engine.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
+                match tasks.get_mut(&rid) {
+                    Some(t) => match &probe {
+                        Ok(p) => {
+                            t.total_size = p.total_size.unwrap_or(0);
+                            let resume = settings.continue_download
+                                && p.supports_resume
+                                && p.total_size.map(|s| s > 0).unwrap_or(false);
+                            t.supports_resume = resume;
+                            t.segments = if resume {
+                                split_segments(p.total_size.unwrap(), settings.max_connections)
+                            } else {
+                                vec![Segment {
+                                    index: 0,
+                                    start: 0,
+                                    end: p.total_size.map(|s| s.saturating_sub(1)).unwrap_or(0),
+                                    completed: 0,
+                                }]
+                            };
+                            if t.status == TaskStatus::Queued {
+                                should_schedule = true;
+                            }
+                            // 调用方未指定文件名时，才后续用 Content-Disposition 修正
+                            if filename.is_none() {
+                                Some((t.dir.clone(), p.filename.clone()))
+                            } else {
+                                None
+                            }
+                        }
+                        Err(e) => {
+                            if t.status == TaskStatus::Queued {
+                                t.status = TaskStatus::Error;
+                                t.error = Some(e.clone());
+                            }
+                            None
+                        }
+                    },
+                    None => None,
+                }
+            };
+
+            // 释放 tasks 锁后，若探测返回了真实文件名，重新做唯一化并写回
+            if let Some((dir_owned, Some(real_name))) = rename_from {
+                let final_name = if auto_rename {
+                    engine.generate_unique_filename(&dir_owned, &real_name)
+                } else {
+                    real_name
+                };
+                let mut tasks = engine.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
+                if let Some(t) = tasks.get_mut(&rid) {
+                    t.filename = final_name;
+                }
+            }
+
+            engine.persist_now();
+            // 探测完成：刷新大小/文件名/分段/错误态到前端
+            engine.emit_task_added(&rid);
+            if should_schedule {
+                engine.schedule();
+            }
+        });
 
         Ok(id)
     }
 
+    /// 通知前端任务已新增/元数据已更新（用于刷新任务列表）
+    fn emit_task_added(&self, id: &str) {
+        let _ = self.inner.app_handle.emit(
+            crate::constants::events::DOWNLOAD_ADDED,
+            serde_json::json!({ "id": id }),
+        );
+    }
+
     /// 添加 BitTorrent 任务（磁力链 / 本地 .torrent）— 全异步添加。
     /// 立即创建占位任务并**立即返回** id（不阻塞）；加入会话与元数据解析全在后台进行。
     /// 注意：librqbit 的 add_torrent 对磁力会在元数据就绪前阻塞返回，因此绝不能在此 await。
@@ -663,6 +752,67 @@ impl DownloadEngine {
         }
     }
 
+    /// BT 任务重新入会：句柄缺失（元数据未解析完/句柄被移除）时，重新加入会话以取回句柄。
+    /// librqbit 对已加入的种子返回 AlreadyManaged（复用现有句柄，已下载片段保留），
+    /// 因此对暂停→继续、错误→继续等场景都幂等、安全。
+    async fn reenter_bt(&self, id: &str, url: &str, dir: &str) -> Result<(), String> {
+        let added = tokio::time::timeout(
+            std::time::Duration::from_secs(crate::download_engine::torrent::INSPECT_TIMEOUT_SECS),
+            self.inner.torrent.add_async(url, dir),
+        ).await;
+        let (_, handle) = match added {
+            Ok(Ok(v)) => v,
+            Ok(Err(e)) => return Err(e),
+            Err(_) => return Err("解析磁力元数据超时：未能从 DHT/Tracker 获取种子信息".to_string()),
+        };
+
+        // 存回句柄（句柄存在则更新，缺失则新建）
+        {
+            let mut handles = self.inner.handles.lock().unwrap_or_else(|e| e.into_inner());
+            match handles.get_mut(id) {
+                Some(h) => h.bt = Some(handle.clone()),
+                None => {
+                    handles.insert(
+                        id.to_string(),
+                        TaskHandle {
+                            gen: self.inner.next_gen.fetch_add(1, Ordering::SeqCst) + 1,
+                            cancel: Arc::new(AtomicBool::new(false)),
+                            progress: Vec::new(),
+                            join: Mutex::new(None),
+                            bt: Some(handle.clone()),
+                        },
+                    );
+                }
+            }
+        }
+
+        // 等待元数据就绪（本地 .torrent 秒回；磁力依赖网络，带超时）
+        if let Err(e) = self.inner.torrent.wait_initialized(&handle).await {
+            return Err(e);
+        }
+        // 刷新结构化任务元数据（filename / infohash / 文件列表 / 大小）
+        match self.inner.torrent.inspect(url).await {
+            Ok(info) => {
+                let mut tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
+                if let Some(t) = tasks.get_mut(id) {
+                    t.filename = info.name.clone();
+                    t.info_hash = Some(info.info_hash.clone());
+                    t.bt_files = info.files.clone();
+                    t.total_size = info.total_size;
+                    t.bt_metadata_ready = true;
+                    t.error = None;
+                    // 复位为 Queued：start_download 只在 Queued 下继续推进（首调时已置 Active）
+                    if matches!(t.status, TaskStatus::Active | TaskStatus::Error) {
+                        t.status = TaskStatus::Queued;
+                    }
+                }
+            }
+            Err(e) => return Err(e),
+        }
+        self.persist_now();
+        Ok(())
+    }
+
     /// BT 元数据解析失败：任务置为 Error 并通知前端刷新
     fn fail_bt_resolve(engine: &DownloadEngine, id: &str, error: String) {
         {
@@ -1096,8 +1246,9 @@ impl DownloadEngine {
             .use_proxy
             .store(settings.use_proxy, Ordering::SeqCst);
 
-        // 同步 BT 专属设置（上传限速 / 监听端口 / 代理；监听端口、代理首次创建会话时生效）
-        let bt_socks = bt_proxy_addr(&self.inner.app_handle, settings.bt_use_proxy);
+        // 同步 BT 专属设置（上传限速 / 监听端口 / 代理；监听端口、代理首次创建会话时生效）。
+        // BT 是否走代理跟随下载设置 use_proxy（bt_use_proxy 不再独立控制）
+        let bt_socks = bt_proxy_addr(&self.inner.app_handle, settings.use_proxy);
         self.inner
             .torrent
             .set_settings(settings.bt_upload_limit_kb, settings.bt_listen_port, bt_socks);
@@ -1114,6 +1265,68 @@ impl DownloadEngine {
         self.inner.started.load(Ordering::SeqCst)
     }
 
+    /// 读取代理模块(mihomo)配置：mixed_port 与 external_controller（settings.json）。
+    /// 无配置/端口非法返回 None。
+    fn mihomo_proxy_config(&self) -> Option<(u16, String)> {
+        let dir = self.inner.app_handle.path().app_data_dir().ok()?;
+        let p = dir.join("proxy").join("settings.json");
+        let s = std::fs::read_to_string(p).ok()?;
+        let v: serde_json::Value = serde_json::from_str(&s).ok()?;
+        let port = v.get("mixedPort").and_then(|x| x.as_u64())?;
+        if port == 0 || port > 65535 {
+            return None;
+        }
+        let controller = v
+            .get("externalController")
+            .and_then(|x| x.as_str())
+            .unwrap_or("127.0.0.1:9090")
+            .to_string();
+        Some((port as u16, controller))
+    }
+
+    /// 解析当前 mihomo 显式代理地址（带 TTL 缓存）：
+    /// 代理开关开启 & mihomo 控制端在线 → `http://127.0.0.1:{mixed_port}`；
+    /// 否则 → None（直连）。不再依赖系统代理。
+    async fn mihomo_proxy(&self) -> Option<String> {
+        // 先查缓存（短锁，不跨 await 持有）
+        {
+            let cache = self
+                .inner
+                .mihomo_proxy_cache
+                .lock()
+                .unwrap_or_else(|e| e.into_inner());
+            if let Some((at, addr)) = cache.as_ref() {
+                if at.elapsed() < Duration::from_secs(5) {
+                    return addr.clone();
+                }
+            }
+        }
+
+        // 重新解析：读配置端口 + 探测控制端确认 mihomo 运行
+        let addr = match self.mihomo_proxy_config() {
+            Some((port, controller)) => {
+                if self.inner.http.probe_controller(&controller).await {
+                    Some(format!("http://127.0.0.1:{}", port))
+                } else {
+                    None
+                }
+            }
+            None => None,
+        };
+        if let Ok(mut cache) = self.inner.mihomo_proxy_cache.lock() {
+            *cache = Some((Instant::now(), addr.clone()));
+        }
+        addr
+    }
+
+    /// 下载/探测前，把解析出的 mihomo 代理地址应用到 HTTP 下载器。
+    /// 代理开关关闭时强制直连。
+    async fn ensure_mihomo_proxy(&self) {
+        let use_proxy = self.inner.use_proxy.load(Ordering::SeqCst);
+        let proxy = if use_proxy { self.mihomo_proxy().await } else { None };
+        self.inner.http.configure_mihomo_proxy(proxy);
+    }
+
     /// 退出时清理：停止所有下载、保存状态
     pub fn cleanup_on_exit(&self) {
         // 取消所有活跃下载（HTTP 设 cancel 标志；BT 中止等待 future）
@@ -1158,13 +1371,20 @@ impl DownloadEngine {
 
         let (active_count, queued_ids) = {
             let tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
+            let pending = self.inner.http_pending.lock().unwrap_or_else(|e| e.into_inner());
             let active = tasks.values().filter(|t| t.status == TaskStatus::Active).count();
             let mut queued: Vec<_> = tasks
                 .values()
                 // 跳过元数据未就绪的 BT 任务（异步添加后台解析中，等待用户勾选文件）
+                // 及 HTTP 占位任务（后台探测未完成，未得到大小/分段前不得提前启动）
                 .filter(|t| {
-                    t.status == TaskStatus::Queued
-                        && (t.protocol != TaskProtocol::BitTorrent || t.bt_metadata_ready)
+                    if t.status != TaskStatus::Queued {
+                        return false;
+                    }
+                    if t.protocol == TaskProtocol::BitTorrent {
+                        return t.bt_metadata_ready;
+                    }
+                    !pending.contains(&t.id)
                 })
                 .collect();
             queued.sort_by_key(|t| t.created_at);
@@ -1245,15 +1465,28 @@ impl DownloadEngine {
         // ===== BitTorrent 下载分支 =====
         if is_bt {
             let Some(bt) = existing_bt else {
-                // 无 BT 句柄（异常）：标记 Error
-                {
-                    let mut tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
-                    if let Some(task) = tasks.get_mut(&id) {
-                        task.status = TaskStatus::Error;
-                        task.error = Some("BitTorrent 句柄缺失".to_string());
+                // 无 BT 句柄：常见于元数据尚未解析完就点了"暂停/继续"，或句柄已被移除。
+                // 不能直接报"句柄缺失"（否则此类任务点"继续"会立即失败），改为后台重新加入
+                // 会话（如已加入则复用已有句柄，已下载片段保留），元数据就绪后再进入下载。
+                let engine2 = self.clone();
+                let id2 = id.clone();
+                let url2 = task.url.clone();
+                let dir2 = task.dir.clone();
+                tauri::async_runtime::spawn(async move {
+                    if let Err(e) = engine2.reenter_bt(&id2, &url2, &dir2).await {
+                        crate::logger::log_error("download", &format!("BT 任务重入会话失败: {}", e));
+                        let mut tasks = engine2.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
+                        if let Some(t) = tasks.get_mut(&id2) {
+                            if t.status == TaskStatus::Active || t.status == TaskStatus::Queued {
+                                t.status = TaskStatus::Error;
+                                t.error = Some(e);
+                            }
+                        }
+                        engine2.persist_now();
+                        return;
                     }
-                }
-                self.persist_now();
+                    engine2.start_download(id2);
+                });
                 return;
             };
 
@@ -1399,6 +1632,8 @@ impl DownloadEngine {
 
         let join = tauri::async_runtime::spawn(async move {
             let my_gen = gen;
+            // 下载前应用当前 mihomo 代理（engine 与 http 共享同一 mihomo 客户端状态）
+            engine.ensure_mihomo_proxy().await;
             let result = http
                 .download(&url, &headers, &segments, &temp_file_path, cancel_clone, &progress_clone, limiter, use_proxy)
                 .await;

src-tauri/src/download_engine/http_dl.rs

@@ -1,11 +1,12 @@
 use futures_util::StreamExt;
+use reqwest::Proxy;
 use reqwest::Client;
 use std::collections::HashMap;
 use std::fs::OpenOptions;
 use std::io::SeekFrom;
 use std::path::Path;
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 use tokio::io::{AsyncSeekExt, AsyncWriteExt};
 use tokio::task::JoinSet;
 
@@ -21,34 +22,76 @@ const READ_STALL_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(3
 /// HTTP/HTTPS 下载器
 #[derive(Clone)]
 pub struct HttpDownloader {
-    /// 默认客户端：尊重系统代理（reqwest 默认行为，mihomo 开启系统代理时经其转发）
-    system_client: Client,
-    /// 直连客户端：强制禁用系统代理（no_proxy）
+    /// 直连客户端：强制禁用代理（no_proxy），用于降级重试与控制端探测
     direct_client: Client,
+    /// mihomo 显式代理客户端缓存（与代理地址一一对应）：走 http://127.0.0.1:{mixed_port}。
+    /// 地址未配置（mihomo 未运行）时为 no_proxy 直连。Arc 共享同一状态，任意 clone 统一生效。
+    mihomo: Arc<Mutex<(Option<String>, Client)>>,
 }
 
 impl HttpDownloader {
     pub fn new() -> Self {
-        let system_client = Client::builder()
-            .build()
-            .unwrap_or_else(|_| Client::new());
         let direct_client = Client::builder()
-            // 强制直连：即使系统代理已开启，下载也不经过代理
+            // 强制直连：即使系统代理已开启，下载也不经过系统代理
             .no_proxy()
             .build()
             .unwrap_or_else(|_| Client::new());
         Self {
-            system_client,
-            direct_client,
+            direct_client: direct_client.clone(),
+            mihomo: Arc::new(Mutex::new((None, direct_client))),
         }
     }
 
-    /// 根据 use_proxy 选择客户端
-    fn client(&self, use_proxy: bool) -> &Client {
+    /// 配置 mihomo 显式代理客户端。
+    /// - `Some("http://127.0.0.1:{port}")`：走本地 mihomo 的 mixed 端口；
+    /// - `None`：回退直连（不走系统代理）。
+    /// 地址未变化时复用缓存，不重复重建，避免丢失连接复用。
+    pub fn configure_mihomo_proxy(&self, proxy_url: Option<String>) {
+        let mut guard = self.mihomo.lock().unwrap_or_else(|e| e.into_inner());
+        if guard.0 == proxy_url {
+            return;
+        }
+        let client = match &proxy_url {
+            Some(url) => {
+                let mut cb = Client::builder();
+                if let Ok(p) = Proxy::all(url.clone()) {
+                    cb = cb.proxy(p);
+                }
+                cb.build().unwrap_or_else(|_| Client::new())
+            }
+            None => Client::builder()
+                .no_proxy()
+                .build()
+                .unwrap_or_else(|_| Client::new()),
+        };
+        *guard = (proxy_url, client);
+    }
+
+    /// 探测 mihomo 外部控制端是否在线（用于判断代理模块是否真正运行）。
+    /// 走直连客户端，避免探测本身依赖代理。
+    pub async fn probe_controller(&self, controller: &str) -> bool {
+        let url = format!("http://{}/version", controller);
+        match tokio::time::timeout(
+            std::time::Duration::from_secs(3),
+            self.direct_client.get(&url).send(),
+        )
+        .await
+        {
+            Ok(Ok(r)) => r.status().is_success(),
+            _ => false,
+        }
+    }
+
+    /// 根据 use_proxy 选择客户端（克隆句柄，Client 内部共享连接池）
+    fn client(&self, use_proxy: bool) -> Client {
         if use_proxy {
-            &self.system_client
+            self.mihomo
+                .lock()
+                .unwrap_or_else(|e| e.into_inner())
+                .1
+                .clone()
         } else {
-            &self.direct_client
+            self.direct_client.clone()
         }
     }
 
@@ -62,11 +105,11 @@ impl HttpDownloader {
         use_proxy: bool,
     ) -> Result<ProbeResult, String> {
         let first = self.client(use_proxy);
-        match self.probe_with_client(first, url, headers).await {
+        match self.probe_with_client(&first, url, headers).await {
             Ok(r) => return Ok(r),
             Err(e) if use_proxy => {
                 let direct = self.client(false);
-                self.probe_with_client(direct, url, headers)
+                self.probe_with_client(&direct, url, headers)
                     .await
                     .map_err(|e2| format!("代理探测失败（{}），直连重试也失败（{}）", e, e2))
             }
@@ -190,12 +233,12 @@ impl HttpDownloader {
         // 注意：用户主动暂停/取消（返回"已取消"）必须原样透传，不能触发代理回退，
         // 否则会把"已取消"包装成"代理失败"，导致引擎将其误判为错误而非暂停。
         let first = self.client(use_proxy);
-        match self.download_with_client(first, url, headers, segments, file_path, cancel.clone(), progress, &limiter).await {
+        match self.download_with_client(&first, url, headers, segments, file_path, cancel.clone(), progress, &limiter).await {
             Ok(()) => return Ok(()),
             Err(e) if use_proxy && e != "已取消" => {
                 // 回退直连重试（不继承 use_proxy，保证用 no_proxy 客户端）
                 let direct = self.client(false);
-                self.download_with_client(direct, url, headers, segments, file_path, cancel, progress, &limiter)
+                self.download_with_client(&direct, url, headers, segments, file_path, cancel, progress, &limiter)
                     .await
                     .map_err(|e2| format!("代理下载失败（{}），直连重试也失败（{}）", e, e2))
             }

src-tauri/src/download_engine/server.rs

@@ -1,5 +1,7 @@
 use std::collections::HashMap;
 use std::net::SocketAddr;
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant};
 
 use axum::{
     extract::{Path, State},
@@ -17,6 +19,17 @@ use super::task::{DownloadTask, TaskStatus};
 /// 扩展 HTTP API 服务器
 pub struct ExtensionServer;
 
+/// 最近处理过的下载 URL（短窗口去重）：记录对应任务 id 与创建时刻，
+/// 用于拦截"探测期间并发 POST"与"任务已结束但扩展重试"造成的重复创建
+#[derive(Clone)]
+struct RecentEntry {
+    id: String,
+    at: Instant,
+}
+
+/// 同 URL 去重窗口：窗口内重复 POST 复用既有任务 id
+const DEDUP_WINDOW: Duration = Duration::from_secs(30);
+
 #[derive(Serialize)]
 struct HealthResponse {
     ok: bool,
@@ -57,6 +70,7 @@ impl ExtensionServer {
                 engine,
                 secret,
                 app_handle,
+                recent: Arc::new(Mutex::new(HashMap::new())),
             });
 
         let listener = match tokio::net::TcpListener::bind(&addr).await {
@@ -80,6 +94,8 @@ struct AppState {
     engine: DownloadEngine,
     secret: String,
     app_handle: AppHandle,
+    /// 最近创建的 URL→任务 id（短窗口去重）
+    recent: Arc<Mutex<HashMap<String, RecentEntry>>>,
 }
 
 /// 鉴权检查：如果配置了 secret，校验 Bearer token
@@ -114,16 +130,40 @@ async fn create_download(
         return Err((StatusCode::UNAUTHORIZED, Json(ErrorResponse { error: "未授权".into() })));
     }
 
-    // 去重：同 URL 已有非终态任务（活跃/排队/暂停）时直接返回既有任务，
+    // 1. 检查短窗口缓存：同 URL 30s 内已有创建记录，直接返回（拦截浏览器/扩展重试和并发 POST）
+    {
+        let mut recent = state.recent.lock().unwrap_or_else(|e| e.into_inner());
+        if let Some(entry) = recent.get(&req.url) {
+            if entry.at.elapsed() < DEDUP_WINDOW {
+                // 30 秒内重复请求 → 返回已创建任务 id，不重复新建
+                return Ok(Json(CreateDownloadResponse { id: entry.id.clone() }));
+            } else {
+                // 窗口过期 → 删除旧记录继续检查引擎层去重
+                recent.remove(&req.url);
+            }
+        }
+    }
+
+    // 2. 引擎层去重：同 URL 已有非终态任务（活跃/排队/暂停）时直接返回既有任务，
     // 避免浏览器重复转发同一下载造成重复下载
     if let Some(existing) = state.engine.get_tasks().into_iter().find(|t| {
         matches!(t.status, TaskStatus::Active | TaskStatus::Queued | TaskStatus::Paused) && t.url == req.url
     }) {
+        // 添加到短窗口缓存以便拦截重试
+        let mut recent = state.recent.lock().unwrap_or_else(|e| e.into_inner());
+        recent.insert(req.url.clone(), RecentEntry { id: existing.id.clone(), at: Instant::now() });
         return Ok(Json(CreateDownloadResponse { id: existing.id }));
     }
 
+    // add_task 会 move 掉 req 的字段，先取出 url 供去重缓存使用
+    let task_url = req.url.clone();
     match state.engine.add_task(req.url, req.filename, req.dir, req.headers, true, None).await {
         Ok(id) => {
+            // 记录到短窗口缓存：拦截后续同一 URL 的重复转发/重试
+            let url = task_url.clone();
+            let mut recent = state.recent.lock().unwrap_or_else(|e| e.into_inner());
+            recent.insert(url, RecentEntry { id: id.clone(), at: Instant::now() });
+            drop(recent);
             // 浏览器扩展发起下载：不再置前主窗口，改为带 task id 通知前端，
             // 由前端为该任务创建一个专属的一次性下载窗口（不打断主界面）
             let _ = state.app_handle.emit(

src-tauri/src/download_engine/torrent.rs

@@ -414,13 +414,21 @@ impl TorrentDownloader {
             .map_err(|e| format!("暂停种子失败: {}", e))
     }
 
-    /// 继续种子
+    /// 继续种子（幂等）：恢复已暂停的种子。
+    /// 若种子本已处于 Live（例如 select_bt_files 的 set_only_files 内部已恢复过、
+    /// 或暂停期间被其他逻辑恢复），直接视为成功，避免 librqbit 报 "torrent is already live"
+    /// 而导致 pause→resume 链路被误判为失败。
     pub async fn unpause(&self, handle: &Arc<ManagedTorrent>) -> Result<(), String> {
         let session = self.get_session().await?;
-        session
-            .unpause(handle)
-            .await
-            .map_err(|e| format!("继续种子失败: {}", e))
+        match handle.stats().state {
+            librqbit::TorrentStatsState::Live => Ok(()),
+            librqbit::TorrentStatsState::Error => Err("种子处于错误状态，无法继续".to_string()),
+            librqbit::TorrentStatsState::Paused
+            | librqbit::TorrentStatsState::Initializing { .. } => session
+                .unpause(handle)
+                .await
+                .map_err(|e| format!("继续种子失败: {}", e)),
+        }
     }
 
     /// 删除种子（info_hash 为 hex 字符串；delete_files 是否同时删除已下载文件）

src-tauri/src/lib.rs

@@ -37,13 +37,15 @@ use mihomo_manager::{
 use monitor_kernel::{
     monitor_elevate_self, monitor_get_auto_start, monitor_get_elevate_on_launch,
     monitor_get_hardware_config, monitor_get_snapshot, monitor_get_status, monitor_kernel_info,
-    monitor_set_auto_start, monitor_set_elevate_on_launch, monitor_set_hardware_config,
-    monitor_start, monitor_start_elevated, monitor_status, monitor_stop, MonitorKernel,
+    monitor_repair_pawnio, monitor_set_auto_start, monitor_set_elevate_on_launch,
+    monitor_set_hardware_config, monitor_start, monitor_start_elevated, monitor_status, monitor_stop,
+    MonitorKernel,
 };
 use network_monitor::network_status;
 use osd_window::{
     osd_apply_overlay_style, osd_begin_drag, osd_set_bounds, osd_set_click_through,
-    osd_set_topmost, osd_start_drag_watch, osd_start_topmost_watch, osd_stop_watch,
+    osd_set_topmost, osd_start_drag_watch, osd_start_game_watch, osd_start_topmost_watch,
+    osd_stop_watch,
 };
 use process_manager::{
     process_all_status, process_start, process_status,
@@ -51,15 +53,16 @@ use process_manager::{
 };
 use screenshot::commands::{
     screenshot_capture_fullscreen, screenshot_capture_window, screenshot_clear_fullscreen,
-    screenshot_compose_copy, screenshot_copy_image, screenshot_crop_copy_stored,
-    screenshot_crop_stored, screenshot_cursor_pos, screenshot_delete_cache,
-    screenshot_disable_transitions, screenshot_enum_windows, screenshot_fullscreen_png,
-    screenshot_get_editor_image, screenshot_get_fullscreen_bmp, screenshot_load_cache,
+    screenshot_compose_copy, screenshot_compose_png, screenshot_copy_image,
+    screenshot_crop_copy_stored, screenshot_crop_stored, screenshot_cursor_pos,
+    screenshot_delete_cache, screenshot_disable_transitions, screenshot_enum_windows,
+    screenshot_fullscreen_png, screenshot_get_fullscreen_bmp, screenshot_load_cache,
     screenshot_load_cache_raw, screenshot_pick_list, screenshot_register_pin_shortcut,
     screenshot_register_shortcut,
-    screenshot_save_cache, screenshot_save_png, screenshot_set_editor_image,
-    screenshot_show_overlay, screenshot_unregister_pin_shortcut,
-    screenshot_unregister_shortcut,
+    screenshot_save_cache, screenshot_save_png, screenshot_scroll_capture,
+    screenshot_scroll_cancel, screenshot_scroll_finish, screenshot_scroll_start,
+    screenshot_show_overlay, screenshot_take_editor_image_raw,
+    screenshot_unregister_pin_shortcut, screenshot_unregister_shortcut,
 };
 use clipboard::{
     ClipboardManager,
@@ -84,7 +87,10 @@ use quickpanel::{
     quickpanel_show_window, quickpanel_unregister_shortcut, quickpanel_focus_main_window,
 };
 use tray_menu::{tray_menu_action, tray_menu_hide, tray_menu_ready};
-use updater::{app_version, update_check, update_install, update_thinghk};
+use updater::{
+    app_version, update_check, update_install, update_thinghk_apply, update_thinghk_cancel,
+    update_thinghk_confirm, ThinghkUpdateState,
+};
 
 #[tauri::command]
 fn quit_app(app: tauri::AppHandle) {
@@ -109,8 +115,9 @@ fn export_bindings() {
         // 生成命令失败时直接 throw，与原生 invoke 一致，前端无需解包 helper
         .error_handling(ErrorHandlingMode::Throw)
         .commands(collect_commands![
-            // 应用更新（4）
-            app_version, update_check, update_install, update_thinghk,
+            // 应用更新（6）
+            app_version, update_check, update_install, update_thinghk_apply,
+            update_thinghk_confirm, update_thinghk_cancel,
             // proxy（20）
             proxy_activate_profile, proxy_apply_kernel_update, proxy_cancel_kernel_install, proxy_check_kernel_update, proxy_clear_system_proxy,
             proxy_close_connection, proxy_confirm_install, proxy_delete_profile, proxy_get_settings,
@@ -142,14 +149,16 @@ fn export_bindings() {
             downloader_get_tasks, downloader_check_url, downloader_add_task, downloader_pause_task,
             downloader_resume_task, downloader_cancel_task, downloader_redownload, downloader_remove_task, downloader_get_settings,
             downloader_save_settings, downloader_open_dir, downloader_open_url, downloader_focus_window, downloader_inspect, downloader_select_bt_files,
-            // screenshot（22，豁免 3：get_fullscreen_bmp / load_cache_raw 返回 ipc::Response、compose_copy 接收 ipc::Request）
+            // screenshot（22，豁免 3：get_fullscreen_bmp / take_editor_image_raw 返回 ipc::Response、
+            // compose_copy / compose_png 接收 ipc::Request）
             screenshot_disable_transitions, screenshot_show_overlay, screenshot_register_shortcut,
             screenshot_unregister_shortcut, screenshot_register_pin_shortcut,
             screenshot_unregister_pin_shortcut, screenshot_capture_fullscreen,
             screenshot_fullscreen_png, screenshot_clear_fullscreen, screenshot_crop_stored,
             screenshot_crop_copy_stored, screenshot_pick_list, screenshot_cursor_pos,
-            screenshot_enum_windows, screenshot_capture_window, screenshot_set_editor_image,
-            screenshot_get_editor_image, screenshot_copy_image, screenshot_save_png,
+            screenshot_enum_windows, screenshot_capture_window, screenshot_scroll_capture,
+            screenshot_scroll_cancel, screenshot_scroll_finish, screenshot_scroll_start,
+            screenshot_copy_image, screenshot_save_png,
             screenshot_save_cache, screenshot_load_cache, screenshot_delete_cache,
         ])
         .export(Typescript::default(), "../src/lib/bindings.ts")
@@ -175,12 +184,15 @@ pub fn run() {
                 .build()
         )
         .manage(ProcessManager::new())
+        .manage(ThinghkUpdateState::new())
         .invoke_handler(tauri::generate_handler![
             quit_app,
             app_version,
             update_check,
             update_install,
-            update_thinghk,
+            update_thinghk_apply,
+            update_thinghk_confirm,
+            update_thinghk_cancel,
             process_start,
             process_stop,
             process_status,
@@ -223,6 +235,7 @@ pub fn run() {
             monitor_elevate_self,
             monitor_stop,
             monitor_get_status,
+            monitor_repair_pawnio,
             monitor_get_snapshot,
             monitor_get_elevate_on_launch,
             monitor_set_elevate_on_launch,
@@ -238,6 +251,7 @@ pub fn run() {
             osd_set_topmost,
             osd_start_drag_watch,
             osd_start_topmost_watch,
+            osd_start_game_watch,
             osd_stop_watch,
             downloader_get_tasks,
             downloader_add_task,
@@ -326,8 +340,11 @@ pub fn run() {
             screenshot_cursor_pos,
             screenshot_enum_windows,
             screenshot_capture_window,
-            screenshot_set_editor_image,
-            screenshot_get_editor_image,
+            screenshot_scroll_capture,
+            screenshot_scroll_cancel,
+            screenshot_scroll_finish,
+            screenshot_scroll_start,
+            screenshot_take_editor_image_raw,
             screenshot_copy_image,
             screenshot_save_png,
             screenshot_save_cache,
@@ -339,7 +356,8 @@ pub fn run() {
             screenshot_register_pin_shortcut,
             screenshot_unregister_pin_shortcut,
             screenshot_disable_transitions,
-            screenshot_compose_copy
+            screenshot_compose_copy,
+            screenshot_compose_png
         ])
         .setup(setup::init)
         .on_window_event(|window, event| {

src-tauri/src/monitor_kernel.rs

@@ -228,6 +228,8 @@ pub fn check_and_relaunch_if_needed(app_data_dir: &std::path::Path) -> bool {
 pub struct KernelStatus {
     pub ready: bool,
     pub is_admin: bool,
+    /// PawnIO 驱动是否已安装；旧版内核无此字段，Option 兼容
+    pub pawn_io_installed: Option<bool>,
     pub uptime_ms: f64,
     pub group_count: u32,
     pub sensor_count: u32,
@@ -370,7 +372,9 @@ impl MonitorKernel {
         self.root.join("hardware-config.json")
     }
 
-    /// 确保内核就位：若 cores/ 无内核或版本过期（源文件较新），从资源目录复制
+    /// 确保内核就位：若 cores/ 无内核或版本过期（源文件较新），从资源目录复制。
+    /// 同时把 PawnIO_setup.exe（可选资源）复制过去——内核提权启动时会静默安装它，
+    /// 作为 WinRing0 被系统/杀软拦截时读取温度/频率的替代驱动。
     pub fn prepare_kernel(&self, app: &AppHandle) -> Result<MonitorKernelInfo, String> {
         let kernel = self.kernel_path();
         if let Ok(src) = app.path().resolve("binaries/ThingHK.exe", BaseDirectory::Resource) {
@@ -385,6 +389,24 @@ impl MonitorKernel {
                 }
             }
         }
+
+        // PawnIO 安装器：可选资源，缺失时仅影响自动安装能力（不影响内核运行）
+        if let Ok(setup_src) = app.path().resolve("binaries/PawnIO_setup.exe", BaseDirectory::Resource) {
+            if setup_src.exists() {
+                let setup_dest = self.cores_dir().join("PawnIO_setup.exe");
+                let need_copy = !setup_dest.exists()
+                    || fs::metadata(&setup_src)
+                        .and_then(|s| fs::metadata(&setup_dest).map(|d| s.len() != d.len()))
+                        .unwrap_or(true);
+                if need_copy {
+                    fs::create_dir_all(self.cores_dir()).ok();
+                    if let Err(e) = fs::copy(&setup_src, &setup_dest) {
+                        crate::logger::log_warn("monitor", &format!("复制 PawnIO_setup.exe 失败: {}", e));
+                    }
+                }
+            }
+        }
+
         Ok(MonitorKernelInfo {
             path: kernel.to_string_lossy().to_string(),
             exists: kernel.exists(),
@@ -489,12 +511,20 @@ impl MonitorKernel {
                 Ok(resp) if resp.status().is_success() => {
                     match resp.json::<KernelStatus>().await {
                         Ok(s) if s.ready => {
+                            // PawnIO 诊断：已提权但驱动缺失时，温度/频率等 ring0 传感器大概率无法读取
+                            if s.is_admin && s.pawn_io_installed == Some(false) {
+                                crate::logger::log_warn(
+                                    "monitor",
+                                    "Kernel 已提权但 PawnIO 驱动未安装，CPU 温度/频率可能无法读取（检查 cores/PawnIO_setup.exe 是否随包部署）",
+                                );
+                            }
                             let _ = app.emit(
                                 crate::constants::events::MONITOR_READY,
                                 serde_json::json!({
                                     "isAdmin": s.is_admin,
                                     "sensorCount": s.sensor_count,
                                     "providers": s.providers,
+                                    "pawnIoInstalled": s.pawn_io_installed,
                                 }),
                             );
                             return Ok(());
@@ -988,6 +1018,52 @@ pub async fn monitor_get_status(state: tauri::State<'_, MonitorKernel>) -> Resul
     state.get_status().await
 }
 
+/// 检测并修复 PawnIO 驱动：确保安装器随内核部署 → 静默安装 → 重启监控内核
+/// （LHM 打开一次后不会重新发现驱动，装完必须重启才能恢复 CPU 温度/功耗读取）。
+/// 返回 { installed, needReboot }；installed=false 说明未提权或安装失败，交由内核启动自装。
+#[tauri::command]
+pub async fn monitor_repair_pawnio(
+    state: tauri::State<'_, MonitorKernel>,
+    pm: tauri::State<'_, ProcessManager>,
+    app: AppHandle,
+) -> Result<serde_json::Value, String> {
+    // 1. 确保 PawnIO_setup.exe 随内核部署
+    state.prepare_kernel(&app)?;
+    let setup = state.cores_dir().join("PawnIO_setup.exe");
+    if !setup.exists() {
+        return Err("未找到 PawnIO_setup.exe 安装器（binaries 资源未随包部署），请重新部署监控内核".into());
+    }
+
+    // 2. 静默安装驱动（继承当前进程权限；Thing 已提权则直接成功）
+    let mut cmd = std::process::Command::new(&setup);
+    cmd.args(["-install", "-silent"]);
+    crate::process_manager::setup_creation_flags(&mut cmd);
+    let (installed, need_reboot) = match cmd.status() {
+        Ok(status) => {
+            let code = status.code().unwrap_or(-1);
+            match code {
+                3010 => (true, true), // ERROR_SUCCESS_REBOOT_REQUIRED
+                0 => (true, false),
+                _ => (false, false),
+            }
+        }
+        Err(e) => return Err(format!("运行 PawnIO 安装器失败: {}", e)),
+    };
+
+    // 3. 重启监控内核，使 LHM 以 PawnIO 重新打开传感器
+    state.stop_subscription(&app).await;
+    if state.is_elevated() && !is_thing_elevated() {
+        state.shutdown_kernel().await?;
+        state.elevated.store(false, Ordering::SeqCst);
+        state.start_elevated(&app).await?;
+    } else {
+        pm.stop(PROCESS_ID)?;
+        state.start_with_subscription(&app).await?;
+    }
+
+    Ok(serde_json::json!({ "installed": installed, "needReboot": need_reboot }))
+}
+
 #[tauri::command]
 pub async fn monitor_get_snapshot(state: tauri::State<'_, MonitorKernel>) -> Result<SensorSnapshot, String> {
     state.get_snapshot().await

src-tauri/src/osd_window.rs

@@ -15,9 +15,12 @@ use tauri::{AppHandle, Emitter};
 static DRAG_STOP: OnceLock<Arc<AtomicBool>> = OnceLock::new();
 /// 任务栏覆盖监视线程停止标志
 static TOPMOST_STOP: OnceLock<Arc<AtomicBool>> = OnceLock::new();
+/// 游戏全屏监视线程停止标志
+static GAME_STOP: OnceLock<Arc<AtomicBool>> = OnceLock::new();
 /// 监视线程句柄（用于停止时 join，避免 sleep 猜测式等待 + 线程泄漏）
 static DRAG_HANDLE: Mutex<Option<JoinHandle<()>>> = Mutex::new(None);
 static TOPMOST_HANDLE: Mutex<Option<JoinHandle<()>>> = Mutex::new(None);
+static GAME_HANDLE: Mutex<Option<JoinHandle<()>>> = Mutex::new(None);
 
 fn drag_stop() -> &'static Arc<AtomicBool> {
     DRAG_STOP.get_or_init(|| Arc::new(AtomicBool::new(true)))
@@ -27,6 +30,10 @@ fn topmost_stop() -> &'static Arc<AtomicBool> {
     TOPMOST_STOP.get_or_init(|| Arc::new(AtomicBool::new(true)))
 }
 
+fn game_stop() -> &'static Arc<AtomicBool> {
+    GAME_STOP.get_or_init(|| Arc::new(AtomicBool::new(true)))
+}
+
 /// 停止右键拖动监视线程并等待其退出（标志置位后线程最迟一个轮询周期退出）
 fn stop_drag_thread() {
     drag_stop().store(true, Ordering::SeqCst);
@@ -51,18 +58,35 @@ fn stop_topmost_thread() {
     }
 }
 
+/// 停止游戏全屏监视线程并等待其退出
+fn stop_game_thread() {
+    game_stop().store(true, Ordering::SeqCst);
+    if let Some(h) = GAME_HANDLE
+        .lock()
+        .unwrap_or_else(|e| e.into_inner())
+        .take()
+    {
+        let _ = h.join();
+    }
+}
+
 #[cfg(windows)]
 mod win_api {
     use tauri::{AppHandle, Manager};
     use windows_sys::Win32::Foundation::{POINT, RECT};
+    use windows_sys::Win32::Graphics::Gdi::{
+        GetMonitorInfoW, MonitorFromWindow, MONITORINFO, MONITOR_DEFAULTTONEAREST,
+    };
     use windows_sys::Win32::UI::Input::KeyboardAndMouse::{GetAsyncKeyState, VK_RBUTTON};
     use windows_sys::Win32::UI::WindowsAndMessaging::{
-        GetClassNameW, GetCursorPos, GetForegroundWindow, GetWindowLongPtrW,
-        GetWindowRect, SendMessageW, SetWindowLongPtrW, SetWindowPos,
-        GWL_EXSTYLE, HTCAPTION, HWND_NOTOPMOST, HWND_TOPMOST, SWP_NOACTIVATE, SWP_NOMOVE,
-        SWP_NOSIZE, SWP_NOZORDER, WM_NCLBUTTONDOWN, WS_EX_NOACTIVATE,
+        GetClassNameW, GetCursorPos, GetForegroundWindow, GetWindowLongPtrW, GetWindowLongW,
+        GetWindowRect, GetWindowThreadProcessId, SendMessageW, SetWindowLongPtrW, SetWindowPos,
+        GWL_EXSTYLE, GWL_STYLE, HTCAPTION, HWND_NOTOPMOST, HWND_TOPMOST, SWP_NOACTIVATE,
+        SWP_NOMOVE, SWP_NOSIZE, SWP_NOZORDER, WM_NCLBUTTONDOWN, WS_EX_NOACTIVATE,
         WS_EX_TOOLWINDOW, WS_EX_TRANSPARENT,
     };
+    /// 供模块外全屏判定使用的窗口样式常量（pub re-export）
+    pub use windows_sys::Win32::UI::WindowsAndMessaging::WS_CAPTION;
 
     /// windows-sys 的 HWND 类型别名（isize）
     pub type Hwnd = isize;
@@ -225,6 +249,41 @@ mod win_api {
             | "Windows.UI.Shell.ShellFlyoutWindow" // Win11 Shell 弹出
         )
     }
+
+    /// 获取窗口样式（GWL_STYLE）
+    pub fn get_window_style(hwnd: Hwnd) -> isize {
+        unsafe { GetWindowLongW(hwnd, GWL_STYLE) as isize }
+    }
+
+    /// 判断窗口是否属于本进程（Thing 自身窗口不参与全屏判定）
+    pub fn is_own_process(hwnd: Hwnd) -> bool {
+        let mut pid: u32 = 0;
+        unsafe {
+            GetWindowThreadProcessId(hwnd, &mut pid);
+        }
+        pid != 0 && pid == std::process::id()
+    }
+
+    /// 获取窗口所在显示器（最近匹配）的矩形（物理像素）
+    pub fn get_monitor_rect(hwnd: Hwnd) -> Option<RECT> {
+        let monitor = unsafe { MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST) };
+        if monitor == 0 {
+            return None;
+        }
+        let mut info = MONITORINFO {
+            cbSize: std::mem::size_of::<MONITORINFO>() as u32,
+            rcMonitor: RECT { left: 0, top: 0, right: 0, bottom: 0 },
+            rcWork: RECT { left: 0, top: 0, right: 0, bottom: 0 },
+            dwFlags: 0,
+        };
+        unsafe {
+            if GetMonitorInfoW(monitor, &mut info) != 0 {
+                Some(info.rcMonitor)
+            } else {
+                None
+            }
+        }
+    }
 }
 
 /// 应用 OSD 悬浮窗的原生样式（NoActivate + ToolWindow）
@@ -369,11 +428,98 @@ pub fn osd_start_topmost_watch(app: AppHandle) -> Result<(), String> {
     Ok(())
 }
 
+/// 判断窗口是否为全屏应用（无边框/独占全屏游戏）
+///
+/// 判定条件（全部满足）：
+/// 1. 无 WS_CAPTION 样式 —— 排除普通应用的"最大化"（即使系统任务栏设为自动隐藏，
+///    最大化窗口覆盖率也接近 100%，但它们带标题栏，靠样式即可区分）
+/// 2. 非本进程窗口（Thing 主窗口/悬浮窗自身）
+/// 3. 窗口矩形与所在显示器矩形的交集覆盖率 ≥ 95%（兼容缩放/1px 误差）
+#[cfg(windows)]
+fn is_fullscreen_game_window(hwnd: isize) -> bool {
+    if win_api::get_window_style(hwnd) & (win_api::WS_CAPTION as isize) != 0 {
+        return false;
+    }
+    if win_api::is_own_process(hwnd) {
+        return false;
+    }
+    let (Some(win_rect), Some(mon_rect)) = (
+        win_api::get_window_rect(hwnd),
+        win_api::get_monitor_rect(hwnd),
+    ) else {
+        return false;
+    };
+    let iw = (win_rect.right.min(mon_rect.right) - win_rect.left.max(mon_rect.left)).max(0) as i64;
+    let ih = (win_rect.bottom.min(mon_rect.bottom) - win_rect.top.max(mon_rect.top)).max(0) as i64;
+    let mw = (mon_rect.right - mon_rect.left).max(0) as i64;
+    let mh = (mon_rect.bottom - mon_rect.top).max(0) as i64;
+    let mon_area = (mw * mh).max(1);
+    iw * ih * 100 >= mon_area * 95
+}
+
+/// 启动游戏全屏监视
+///
+/// 轮询检测前景窗口是否为全屏应用（无边框/独占全屏游戏），
+/// 状态变化时发出 `osd-game-active` / `osd-game-inactive` 事件。
+/// 前端据此隐藏/恢复 OSD：透明置顶 WebView 悬浮窗会占用 DWM 合成路径，
+/// 禁用游戏的独立翻转（MPO），是游戏中掉帧的根源；隐藏悬浮窗即可排除影响。
+#[tauri::command]
+pub fn osd_start_game_watch(app: AppHandle) -> Result<(), String> {
+    // 停止旧线程，等待其退出后再启动新线程
+    stop_game_thread();
+    let stop_flag = game_stop().clone();
+    stop_flag.store(false, Ordering::SeqCst);
+
+    let app_handle = app.clone();
+
+    let handle = thread::spawn(move || {
+        let mut fullscreen_active = false;
+
+        loop {
+            if stop_flag.load(Ordering::SeqCst) {
+                break;
+            }
+
+            #[cfg(windows)]
+            {
+                let fg = win_api::get_foreground_window();
+                let fullscreen = fg != 0
+                    && win_api::get_class_name(fg)
+                        .map_or(false, |c| !win_api::is_system_ui_class(&c))
+                    && is_fullscreen_game_window(fg);
+
+                if fullscreen != fullscreen_active {
+                    fullscreen_active = fullscreen;
+                    let event = if fullscreen {
+                        crate::constants::events::OSD_GAME_ACTIVE
+                    } else {
+                        crate::constants::events::OSD_GAME_INACTIVE
+                    };
+                    let _ = app_handle.emit(event, ());
+                    crate::logger::log_info(
+                        "osd",
+                        &format!("全屏应用前台: {}", if fullscreen { "是 → 隐藏 OSD" } else { "否 → 恢复 OSD" }),
+                    );
+                }
+            }
+
+            thread::sleep(Duration::from_millis(1000));
+        }
+    });
+
+    if let Ok(mut guard) = GAME_HANDLE.lock() {
+        *guard = Some(handle);
+    }
+
+    Ok(())
+}
+
 /// 停止所有 OSD 监视线程
 #[tauri::command]
 pub fn osd_stop_watch() {
     stop_drag_thread();
     stop_topmost_thread();
+    stop_game_thread();
 }
 
 /// 设置点击穿透（Rust 侧原生 WS_EX_TRANSPARENT，比 JS setIgnoreCursorEvents 更可靠）

src-tauri/src/process_manager.rs

@@ -11,6 +11,11 @@ use tauri::{AppHandle, Emitter, Manager};
 // CREATE_NO_WINDOW = 0x08000000，阻止子进程创建新的控制台窗口
 #[cfg(windows)]
 pub const CREATE_NO_WINDOW: u32 = 0x08000000;
+// CREATE_NEW_CONSOLE = 0x00000010，强制为控制台类子进程新开一个可见控制台窗口。
+// 从 GUI 宿主（无控制台）直接 spawn cmd/powershell 等控制台程序时若不设置，
+// 子进程会挂到隐藏控制台/不显示窗口，表现为"点击没反应"。
+#[cfg(windows)]
+pub const CREATE_NEW_CONSOLE: u32 = 0x00000010;
 
 // Windows Job Object 相关常量，用于异常退出时自动清理子进程
 #[cfg(windows)]

src-tauri/src/quickpanel/commands.rs

@@ -505,11 +505,35 @@ pub fn quickpanel_run_custom_command(command: String, args: Vec<String>) -> Resu
 
 /// 运行系统命令（不设置 CREATE_NO_WINDOW，使 cmd/powershell/regedit 等显示自身窗口）
 /// 适用于内置系统工具：regedit、shutdown、cmd、powershell、taskmgr 等。
+/// - 控制台类交互程序（cmd/powershell/pwsh）额外设置 CREATE_NEW_CONSOLE，
+///   否则从 GUI 宿主启动时无可见控制台窗口（表现为"点击没反应"）。
+/// - .msc 控制台文件（如 devmgmt.msc）不可被 CreateProcess 直接执行，
+///   改由 mmc 打开（路径解析到 System32，不受当前工作目录影响）。
 #[tauri::command]
 #[specta::specta]
 pub fn quickpanel_run_system_command(command: String, args: Vec<String>) -> Result<(), String> {
+    let lower = command.to_lowercase();
+    if lower.ends_with(".msc") {
+        // 控制台文件：通过 mmc 打开（GUI 程序，无需新控制台）
+        let system_root = std::env::var("SystemRoot").unwrap_or_else(|_| "C:\\Windows".into());
+        let path = format!("{}\\System32\\{}", system_root, command);
+        let mut c = std::process::Command::new("mmc");
+        c.arg(&path);
+        return c
+            .spawn()
+            .map(|_| ())
+            .map_err(|e| format!("运行系统命令失败: {}", e));
+    }
     let mut cmd = std::process::Command::new(&command);
     cmd.args(&args);
+    #[cfg(windows)]
+    {
+        use std::os::windows::process::CommandExt;
+        let c = lower;
+        if c == "cmd" || c == "powershell" || c == "pwsh" {
+            cmd.creation_flags(crate::process_manager::CREATE_NEW_CONSOLE);
+        }
+    }
     cmd.spawn().map_err(|e| format!("运行系统命令失败: {}", e))?;
     Ok(())
 }

src-tauri/src/screenshot/capture.rs

@@ -111,7 +111,7 @@ fn bgra_to_bmp(bgra: &[u8], width: i32, height: i32) -> Result<Vec<u8>, String>
 ///
 /// 使用 Fast 压缩 + 无过滤：历史缩略图/自动保存不需要最优压缩比，
 /// 大幅降低"点击完成 → 关闭窗口"的编码延迟。
-fn bgra_to_png(bgra: &[u8], width: i32, height: i32) -> Result<Vec<u8>, String> {
+pub(crate) fn bgra_to_png(bgra: &[u8], width: i32, height: i32) -> Result<Vec<u8>, String> {
     use image::codecs::png::{CompressionType, FilterType, PngEncoder};
     use image::ImageEncoder;
     if width <= 0 || height <= 0 {
@@ -138,7 +138,7 @@ fn bgra_to_png(bgra: &[u8], width: i32, height: i32) -> Result<Vec<u8>, String>
 }
 
 /// 从 HBITMAP 提取 32bpp BGRA top-down 像素
-unsafe fn extract_pixels(
+pub(crate) unsafe fn extract_pixels(
     hdc_mem: isize,
     hbm: isize,
     width: i32,
@@ -182,7 +182,16 @@ unsafe fn extract_pixels(
 }
 
 /// 捕获整个虚拟屏（所有显示器拼接为一张图）
+///
+/// 优先走 BitBlt（SDR 全屏一次捕获、低延迟）；检测到任一显示器为 HDR 时改用 WGC
+/// （RGBA16F + HDR→sRGB 色调映射，避免 BitBlt 把 scRGB 线性像素当 sRGB 直出导致过曝）。
+/// WGC 失败时回退到 BitBlt。
 pub fn capture_virtual_screen() -> Result<CapturedImage, String> {
+    if super::wgc_capture::is_hdr_enabled() {
+        if let Ok(img) = super::wgc_capture::capture_virtual_screen_wgc() {
+            return Ok(img);
+        }
+    }
     unsafe {
         let x = GetSystemMetrics(SM_XVIRTUALSCREEN);
         let y = GetSystemMetrics(SM_YVIRTUALSCREEN);
@@ -232,6 +241,19 @@ pub fn capture_virtual_screen() -> Result<CapturedImage, String> {
 
 /// 捕获指定窗口（PrintWindow + PW_RENDERFULLCONTENT，覆盖硬件加速窗口）
 pub fn capture_window(hwnd: isize) -> Result<CapturedImage, String> {
+    let img = capture_window_bgra(hwnd)?;
+    let png = bgra_to_png(&img.bgra, img.width, img.height)?;
+    Ok(CapturedImage {
+        width: img.width,
+        height: img.height,
+        png,
+        bgra: img.bgra,
+    })
+}
+
+/// 捕获指定窗口的原始 BGRA（不做 PNG 编码）。
+/// 滚动截图每帧只需像素数据做匹配拼接，跳过编码可显著降低单帧耗时。
+pub fn capture_window_bgra(hwnd: isize) -> Result<CapturedImage, String> {
     unsafe {
         let mut rect: RECT = std::mem::zeroed();
         if GetWindowRect(hwnd, &mut rect) == 0 {
@@ -259,13 +281,11 @@ pub fn capture_window(hwnd: isize) -> Result<CapturedImage, String> {
         let result = if ok == 0 {
             Err("PrintWindow 失败（可能窗口无响应或权限不足）".into())
         } else {
-            extract_pixels(hdc_mem, hbm, w, h).and_then(|bgra| {
-                bgra_to_png(&bgra, w, h).map(|png| CapturedImage {
-                    width: w,
-                    height: h,
-                    png,
-                    bgra,
-                })
+            extract_pixels(hdc_mem, hbm, w, h).map(|bgra| CapturedImage {
+                width: w,
+                height: h,
+                png: Vec::new(),
+                bgra,
             })
         };
 
@@ -523,7 +543,7 @@ fn bgra_to_dib(bgra: &[u8], width: i32, height: i32) -> Vec<u8> {
     dib
 }
 
-fn crop_bgra(
+pub(crate) fn crop_bgra(
     src: &[u8],
     src_width: usize,
     x: i32,
@@ -667,6 +687,20 @@ pub fn compose_copy_rgba(rgba: &[u8], width: i32, height: i32) -> Result<Capture
     }
     let dib = rgba_raw_to_dib(rgba, width, height);
     write_dib_to_clipboard(&dib)?;
+    rgba_raw_to_png_checked(rgba, width, height)
+}
+
+/// 有标注导出：raw RGBA → PNG base64（仅编码，不写剪贴板；编辑器「保存到文件」用）
+pub fn compose_png_rgba(rgba: &[u8], width: i32, height: i32) -> Result<CaptureData, String> {
+    let expected = (width as usize) * (height as usize) * 4;
+    if rgba.len() < expected {
+        return Err(format!("像素数据不足: {} < {}", rgba.len(), expected));
+    }
+    rgba_raw_to_png_checked(rgba, width, height)
+}
+
+/// raw RGBA → PNG base64（带长度校验的封装，供 compose_copy/compose_png 共用）
+fn rgba_raw_to_png_checked(rgba: &[u8], width: i32, height: i32) -> Result<CaptureData, String> {
     let png = rgba_raw_to_png(rgba, width, height)?;
     Ok(CaptureData {
         png_base64: base64_encode(&png),

src-tauri/src/screenshot/commands.rs

@@ -10,13 +10,14 @@
 //! - screenshot_show_overlay：一次 IPC 完成覆盖层 show + focus（关键路径减少往返）
 //! - screenshot_enum_windows：枚举可见顶层窗口
 //! - screenshot_capture_window：按 hwnd 捕获指定窗口
-//! - screenshot_set_editor_image / screenshot_get_editor_image：编辑器图片传递
+//! - screenshot_take_editor_image_raw：取出编辑器图片（raw IPC，滚动截图会话直接写入）
+//! - screenshot_compose_png / screenshot_compose_copy：raw RGBA → PNG（仅编码 / 剪贴板+编码）
 //! - screenshot_copy_image：写入剪贴板（CF_DIB）
 //! - screenshot_save_png：写入文件
 //! - screenshot_disable_transitions：禁用窗口显示/隐藏过渡动画（消除覆盖层缩放动画）
 
 use super::{CaptureData, CaptureStart, WindowInfo};
-use tauri::{Emitter, Manager};
+use tauri::{AppHandle, Emitter, Manager};
 
 /// 禁用指定窗口（按 label 查找）的显示/隐藏过渡动画，消除覆盖层出现/消失时的缩放动画
 #[tauri::command]
@@ -297,19 +298,90 @@ pub async fn screenshot_capture_window(hwnd: isize) -> Result<CaptureData, Strin
     }
 }
 
-/// 存入编辑器图片（base64 PNG）
+/// 滚动截图：从窗口当前滚动位置向下拼接到底部，返回超长 PNG。
+/// `region` 为 Some 时仅在框选区域（屏幕物理坐标）内捕捉，宽 = 选区宽；
+/// 为 None 时捕捉整个客户区。结束后会把窗口滚回起始位置，不打扰用户。
 #[tauri::command]
 #[specta::specta]
-pub async fn screenshot_set_editor_image(png_base64: String) -> Result<(), String> {
-    super::set_editor_image(png_base64);
-    Ok(())
+pub async fn screenshot_scroll_capture(
+    hwnd: isize,
+    region: Option<super::ScrollRegion>,
+) -> Result<CaptureData, String> {
+    #[cfg(windows)]
+    {
+        tauri::async_runtime::spawn_blocking(move || {
+            super::scroll_capture::scroll_capture(hwnd, region)
+        })
+        .await
+        .map_err(|e| format!("滚动截图任务失败: {}", e))?
+    }
+    #[cfg(not(windows))]
+    {
+        let _ = hwnd;
+        let _ = region;
+        Err("截图仅支持 Windows".into())
+    }
 }
 
-/// 取出编辑器图片（编辑器窗口加载时调用，取出即清除）
+/// 启动滚动截图会话（后台线程持续捕捉拼接，实时推进度事件）。
+/// `auto = true` 为自动滚动（线程主动下滚拼到底部）；`false` 为手动（等用户滚动窗口）。
 #[tauri::command]
 #[specta::specta]
-pub async fn screenshot_get_editor_image() -> Result<Option<String>, String> {
-    Ok(super::take_editor_image())
+pub fn screenshot_scroll_start(
+    app: AppHandle,
+    hwnd: isize,
+    region: Option<super::ScrollRegion>,
+    auto: bool,
+) -> Result<(), String> {
+    #[cfg(windows)]
+    {
+        super::scroll_session::start(app, hwnd, region, auto)
+    }
+    #[cfg(not(windows))]
+    {
+        let _ = (app, hwnd, region, auto);
+        Err("截图仅支持 Windows".into())
+    }
+}
+
+/// 结束滚动截图会话并导出结果。
+#[tauri::command]
+#[specta::specta]
+pub fn screenshot_scroll_finish() -> Result<(), String> {
+    #[cfg(windows)]
+    {
+        super::scroll_session::finish()
+    }
+    #[cfg(not(windows))]
+    {
+        Err("截图仅支持 Windows".into())
+    }
+}
+
+/// 取消滚动截图会话（不导出）。
+#[tauri::command]
+#[specta::specta]
+pub fn screenshot_scroll_cancel() -> Result<(), String> {
+    #[cfg(windows)]
+    {
+        super::scroll_session::cancel_now()
+    }
+    #[cfg(not(windows))]
+    {
+        Err("截图仅支持 Windows".into())
+    }
+}
+
+/// 取出编辑器图片（原始 PNG 字节，raw IPC → 前端 ArrayBuffer → Blob URL，取出即清除）
+///
+/// 长图（滚动截图）可达数十 MB：raw IPC 相比 base64 JSON 事件传输省 ~33% 体积，
+/// 且避免 JSON 序列化/多次广播。注：返回 ipc::Response，specta 无法生成，豁免标注。
+#[tauri::command]
+pub async fn screenshot_take_editor_image_raw() -> Result<tauri::ipc::Response, String> {
+    match super::take_editor_image_raw() {
+        Some(bytes) => Ok(tauri::ipc::Response::new(bytes)),
+        None => Err("无待编辑的截图".into()),
+    }
 }
 
 /// 将 PNG base64 写入系统剪贴板（转 CF_DIB）
@@ -339,6 +411,39 @@ pub async fn screenshot_copy_image(png_base64: String) -> Result<(), String> {
 #[tauri::command]
 pub async fn screenshot_compose_copy(
     request: tauri::ipc::Request<'_>,
+) -> Result<super::CaptureData, String> {
+    #[cfg(windows)]
+    {
+        let body = match request.body() {
+            tauri::ipc::InvokeBody::Raw(data) => data.clone(),
+            _ => return Err("需要 raw body（ArrayBuffer）".into()),
+        };
+        if body.len() < 8 {
+            return Err("数据不足：缺少尺寸头".into());
+        }
+        let width = i32::from_le_bytes([body[0], body[1], body[2], body[3]]);
+    let height = i32::from_le_bytes([body[4], body[5], body[6], body[7]]);
+    let rgba = body[8..].to_vec();
+    tauri::async_runtime::spawn_blocking(move || {
+        super::capture::compose_copy_rgba(&rgba, width, height)
+    })
+    .await
+    .map_err(|e| format!("合成复制任务失败: {}", e))?
+    }
+    #[cfg(not(windows))]
+    {
+        let _ = request;
+        Err("截图仅支持 Windows".into())
+    }
+}
+
+/// 有标注导出（仅编码）：接收 raw RGBA（前端 canvas.getImageData 直传），一次完成 PNG 编码。
+/// 与 screenshot_compose_copy 的区别：不写剪贴板（编辑器「保存到文件」用）。
+/// body 格式：前 8 字节 = width(i32 LE) + height(i32 LE)，之后为 raw RGBA 像素。
+/// 注：参数为 tauri::ipc::Request（原始 body），specta 无法生成，豁免标注。
+#[tauri::command]
+pub async fn screenshot_compose_png(
+    request: tauri::ipc::Request<'_>,
 ) -> Result<super::CaptureData, String> {
     #[cfg(windows)]
     {
@@ -353,10 +458,10 @@ pub async fn screenshot_compose_copy(
         let height = i32::from_le_bytes([body[4], body[5], body[6], body[7]]);
         let rgba = body[8..].to_vec();
         tauri::async_runtime::spawn_blocking(move || {
-            super::capture::compose_copy_rgba(&rgba, width, height)
+            super::capture::compose_png_rgba(&rgba, width, height)
         })
         .await
-        .map_err(|e| format!("合成复制任务失败: {}", e))?
+        .map_err(|e| format!("合成编码任务失败: {}", e))?
     }
     #[cfg(not(windows))]
     {

src-tauri/src/screenshot/mod.rs

@@ -9,6 +9,12 @@ use specta::Type;
 
 #[cfg(windows)]
 pub mod capture;
+#[cfg(windows)]
+pub mod wgc_capture;
+#[cfg(windows)]
+pub mod scroll_capture;
+#[cfg(windows)]
+pub mod scroll_session;
 pub mod commands;
 
 /// 前端可见的捕获数据
@@ -48,17 +54,28 @@ pub struct ScreenRect {
     pub height: i32,
 }
 
-/// 编辑器图片静态存储（覆盖层裁剪后存入 → 编辑器窗口加载取出）
-static EDITOR_IMAGE: Mutex<Option<String>> = Mutex::new(None);
+/// 滚动截图区域（屏幕物理像素坐标，通常为覆盖层框选区平移到屏幕）
+#[derive(serde::Serialize, serde::Deserialize, Clone, Copy, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct ScrollRegion {
+    pub x: i32,
+    pub y: i32,
+    pub width: i32,
+    pub height: i32,
+}
 
-/// 存储编辑器图片（base64 PNG）
-pub fn set_editor_image(png_base64: String) {
-    if let Ok(mut g) = EDITOR_IMAGE.lock() {
-        *g = Some(png_base64);
+/// 编辑器图片静态存储：原始 PNG 字节（滚动截图会话完成后直接写入，
+/// 编辑器窗口通过 raw IPC 取出 → Blob URL 显示，全程不经 base64/JSON 事件传输）
+static EDITOR_IMAGE_RAW: Mutex<Option<Vec<u8>>> = Mutex::new(None);
+
+/// 存储编辑器图片（原始 PNG 字节）
+pub fn set_editor_image_raw(png: Vec<u8>) {
+    if let Ok(mut g) = EDITOR_IMAGE_RAW.lock() {
+        *g = Some(png);
     }
 }
 
-/// 取出并清除编辑器图片
-pub fn take_editor_image() -> Option<String> {
-    EDITOR_IMAGE.lock().ok()?.take()
+/// 取出并清除编辑器图片（原始 PNG 字节）
+pub fn take_editor_image_raw() -> Option<Vec<u8>> {
+    EDITOR_IMAGE_RAW.lock().ok()?.take()
 }

src-tauri/src/screenshot/scroll_capture.rs

@@ -0,0 +1,469 @@
+//! 滚动截图（垂直长图拼接）底层设施（仅 Windows）
+//!
+//! ## 原理
+//! 目标窗口的**客户区**内容往往是可分页垂直滚动的。算法：
+//! 1. 用 PrintWindow（PW_RENDERFULLCONTENT）抓客户区为 BGRA（不做 PNG 编码）；
+//! 2. 向窗口发送 `WM_MOUSEWHEEL` 使其向下滚动；
+//! 3. 再抓一帧，用**框选带内多列采样行信号**做一维模板匹配，求出两帧间的垂直
+//!    滚动像素偏移 `d`：`cur[y] ≈ prev[y+d]`，故把 `cur` 底部新出现的 `d` 行拼到画布末尾；
+//! 4. 重复直到内容不再变化（滚到底部），把各帧拼成一张超高纵轴图像。
+//!
+//! 固定表头/粘性头部由拼接语义天然处理——只追加 `cur` 底部的 `d` 行，
+//! 表头保留在第一帧中，不会重复。
+//!
+//! ## 滚轮投递
+//! `WM_MOUSEWHEEL` 优先发给**框选带中心处的最深子窗口**（如 Chromium 的
+//! RenderWidgetHostHWND）：很多程序的顶层窗口过程不转发滚轮消息，
+//! 直接发顶层会导致"完全不滚动"。坐标一律用屏幕物理坐标（lParam 语义）。
+
+use std::thread::sleep;
+use std::time::Duration;
+
+use windows_sys::Win32::Foundation::{HWND, POINT, RECT};
+use windows_sys::Win32::Graphics::Gdi::{ClientToScreen, ScreenToClient};
+use windows_sys::Win32::UI::WindowsAndMessaging::{
+    ChildWindowFromPointEx, GetClientRect, GetWindowRect, PostMessageW, SendMessageTimeoutW,
+    WM_MOUSEWHEEL, WHEEL_DELTA, CWP_SKIPDISABLED, CWP_SKIPINVISIBLE, CWP_SKIPTRANSPARENT,
+    SMTO_ABORTIFHUNG,
+};
+
+use super::{CaptureData, ScrollRegion};
+use super::capture::{base64_encode, bgra_to_png, capture_window_bgra, crop_bgra};
+
+/// 窗口客户区上下文：客户区尺寸 + 客户区在窗口位图内的偏移。
+pub(crate) struct BandCtx {
+    pub cw: i32,
+    pub ch: i32,
+    pub ox: i32,
+    pub oy: i32,
+}
+
+/// 解析框选带：把可选区域（屏幕物理坐标）换算成客户区内的裁剪带。
+/// 区域未命中客户区时返回错误；`None` 表示整客户区。
+/// 返回 (ctx, band_x, band_y, band_w, band_h)，band_* 为客户区内坐标。
+pub(crate) fn resolve_band(
+    hwnd: isize,
+    region: Option<ScrollRegion>,
+) -> Result<(BandCtx, i32, i32, i32, i32), String> {
+    let (cw, ch, ox, oy) = client_info(hwnd)
+        .ok_or_else(|| "无法获取窗口客户区（窗口可能被最小化或已销毁）".to_string())?;
+    if cw <= 0 || ch <= 0 {
+        return Err("窗口客户区尺寸无效".into());
+    }
+    let (wr_x, wr_y) = window_rect_origin(hwnd).ok_or_else(|| "无法获取窗口矩形".to_string())?;
+    let band = match region {
+        Some(r) => {
+            let wbx = r.x - wr_x;
+            let wby = r.y - wr_y;
+            let bx0 = wbx.max(ox);
+            let by0 = wby.max(oy);
+            let bx1 = (wbx + r.width).min(ox + cw);
+            let by1 = (wby + r.height).min(oy + ch);
+            if bx1 <= bx0 || by1 <= by0 {
+                return Err("选区未命中窗口客户区".into());
+            }
+            (bx0 - ox, by0 - oy, bx1 - bx0, by1 - by0)
+        }
+        None => (0, 0, cw, ch),
+    };
+    Ok((
+        BandCtx { cw, ch, ox, oy },
+        band.0,
+        band.1,
+        band.2,
+        band.3,
+    ))
+}
+
+/// 客户区内坐标 → 屏幕物理坐标。
+pub(crate) fn client_pt_to_screen(hwnd: isize, cx: i32, cy: i32) -> Option<(i32, i32)> {
+    unsafe {
+        let mut pt = POINT { x: cx, y: cy };
+        if ClientToScreen(hwnd as HWND, &mut pt) == 0 {
+            return None;
+        }
+        Some((pt.x, pt.y))
+    }
+}
+
+/// 递归下钻：找到客户区坐标 (cx, cy) 处最深的子窗口（跳过不可见/禁用/透明子窗口）。
+/// WM_MOUSEWHEEL 优先发给真正处理滚轮的子窗口——顶层窗口过程往往不转发滚轮，
+/// 这是"自动滚动一开始就不动"的主因之一。
+pub(crate) fn deep_child_at_point(top: isize, mut cx: i32, mut cy: i32) -> isize {
+    let mut cur = top;
+    for _ in 0..16 {
+        let child = unsafe {
+            ChildWindowFromPointEx(
+                cur as HWND,
+                POINT { x: cx, y: cy },
+                CWP_SKIPINVISIBLE | CWP_SKIPDISABLED | CWP_SKIPTRANSPARENT,
+            )
+        };
+        if child == 0 || child == cur as HWND {
+            break;
+        }
+        // 坐标换算到子窗口客户区
+        let mut pt = POINT { x: cx, y: cy };
+        unsafe {
+            if ClientToScreen(cur as HWND, &mut pt) == 0 {
+                break;
+            }
+            if ScreenToClient(child, &mut pt) == 0 {
+                break;
+            }
+        }
+        cx = pt.x;
+        cy = pt.y;
+        cur = child as isize;
+    }
+    cur
+}
+
+/// 构造 WM_MOUSEWHEEL 的 wParam/lParam（lParam 为屏幕坐标）。
+fn wheel_params(sx: i32, sy: i32, delta: i32) -> (usize, isize) {
+    // wParam 高位字 = 有符号 delta，低位字 = 按键 0
+    let wparam = ((delta as u16) as usize) << 16;
+    // lParam 低 16 位 = x（屏幕），高 16 位 = y（屏幕）
+    let lparam = ((((sy as u32) & 0xFFFF) << 16) | ((sx as u32) & 0xFFFF)) as isize;
+    (wparam, lparam)
+}
+
+/// 发送滚轮消息（SendMessageTimeout：目标线程短暂忙/挂起时不至于卡死调用线程）。
+/// delta > 0 向上滚，delta < 0 向下滚。
+pub(crate) fn send_wheel(hwnd: isize, sx: i32, sy: i32, delta: i32) {
+    let (wparam, lparam) = wheel_params(sx, sy, delta);
+    let mut result = 0usize;
+    unsafe {
+        let _ = SendMessageTimeoutW(
+            hwnd as HWND,
+            WM_MOUSEWHEEL,
+            wparam,
+            lparam,
+            SMTO_ABORTIFHUNG,
+            80,
+            &mut result,
+        );
+    }
+}
+
+/// 异步投递滚轮消息（部分程序只处理经消息泵排队的事件）。
+pub(crate) fn post_wheel(hwnd: isize, sx: i32, sy: i32, delta: i32) {
+    let (wparam, lparam) = wheel_params(sx, sy, delta);
+    unsafe {
+        let _ = PostMessageW(hwnd as HWND, WM_MOUSEWHEEL, wparam, lparam);
+    }
+}
+
+// ===== 单次同步滚动截图（一次调用拼到底）=====
+
+/// 每次向下滚动的「格数」（WHEEL_DELTA=120/格）。
+const WHEEL_STROKE: i32 = 2;
+/// 滚动后等待窗口重绘的时间。
+const SETTLE_MS: u64 = 70;
+/// 保护上限：最大迭代轮数。
+const MAX_ITERS: usize = 140;
+/// 保护上限：最大拼接段数。
+const MAX_STITCHES: usize = 90;
+/// 保护上限：拼接后总高（像素）。
+const MAX_TOTAL_H: u32 = 30000;
+/// 连续多少次滚动无位移判定为「已到底部」。
+const NO_CHANGE_STOP: u32 = 2;
+
+/// 执行滚动截图：把窗口当前滚动位置向下拼接到底部，返回超长 PNG（同步，一次调用）。
+///
+/// - `region` 为 `Some` 时，只在**框选区域**内捕捉（列带 + 该区域的纵向视口），
+///   输出宽度 = 选区宽度；为 `None` 时捕捉整个客户区。
+///   偏移检测始终优先使用带内信号，保证滚动量在窄带下也能稳健匹配。
+/// - 结束时把窗口滚回起始位置，不打扰用户。
+pub fn scroll_capture(hwnd: isize, region: Option<ScrollRegion>) -> Result<CaptureData, String> {
+    let (ctx, band_x, band_y, band_w, band_h) = resolve_band(hwnd, region)?;
+    let (cw, ch) = (ctx.cw, ctx.ch);
+    let (client_ox, client_oy) = (ctx.ox, ctx.oy);
+
+    // 滚轮目标：带中心的最深子窗口 + 屏幕坐标
+    let bcx = band_x + band_w / 2;
+    let bcy = band_y + band_h / 2;
+    let wheel_hwnd = deep_child_at_point(hwnd, bcx, bcy);
+    let (sx, sy) = client_pt_to_screen(hwnd, bcx, bcy)
+        .ok_or_else(|| "无法换算屏幕坐标".to_string())?;
+
+    // 第一帧（全客户区）→ 画布（裁剪到框选带）
+    let first = capture_client_bgra(hwnd, client_ox, client_oy, cw, ch)?;
+    let mut canvas = crop_bgra(&first, cw as usize, band_x, band_y, band_w, band_h)?;
+    let mut prev = first;
+    let mut total_h = band_h as u32;
+    let mut total_stitches = 0usize;
+    let mut no_change = 0u32;
+    let mut moved: u32 = 0;
+    let mut iters = 0usize;
+
+    while iters < MAX_ITERS && total_stitches < MAX_STITCHES && total_h < MAX_TOTAL_H {
+        iters += 1;
+
+        send_wheel(wheel_hwnd, sx, sy, -(WHEEL_DELTA as i32) * WHEEL_STROKE);
+        sleep(Duration::from_millis(SETTLE_MS));
+
+        let cur = match capture_client_bgra(hwnd, client_ox, client_oy, cw, ch) {
+            Ok(f) => f,
+            Err(_) => break, // 窗口中途被关闭/失去客户区
+        };
+
+        match detect_vscroll_offset(
+            &prev,
+            &cur,
+            cw as usize,
+            ch as usize,
+            band_x as usize,
+            band_y as usize,
+            band_w as usize,
+            band_h as usize,
+        ) {
+            Some(0) => {
+                no_change += 1;
+                if no_change >= NO_CHANGE_STOP {
+                    break; // 已到底部
+                }
+                prev = cur;
+            }
+            Some(d) => {
+                no_change = 0;
+                total_stitches += 1;
+                moved += 1;
+                // 追加框选带底部新出现的 d 行（在客户区帧内的带区间 [band_y, band_y+band_h)）
+                let new_rows = (d as i32).min(band_h) as usize;
+                let new_y = band_y + band_h - new_rows as i32;
+                let rows = crop_bgra(&cur, cw as usize, band_x, new_y, band_w, new_rows as i32)?;
+                canvas.extend_from_slice(&rows);
+                total_h += new_rows as u32;
+                prev = cur;
+            }
+            None => {
+                // 匹配失败（内容大幅变化/动画等）：不拼接、不累计 no_change，下一轮继续
+                prev = cur;
+            }
+        }
+    }
+
+    // 结束回滚：上滚与下滚相同数量的手势
+    for _ in 0..moved {
+        send_wheel(wheel_hwnd, sx, sy, WHEEL_DELTA as i32 * WHEEL_STROKE);
+        sleep(Duration::from_millis(20));
+    }
+
+    if total_h <= band_h as u32 {
+        return Err("区域内容未能滚动（可能不支持鼠标滚轮或已到底部）".into());
+    }
+
+    let png = bgra_to_png(&canvas, band_w as i32, total_h as i32)?;
+    Ok(CaptureData {
+        png_base64: base64_encode(&png),
+        width: band_w as i32,
+        height: total_h as i32,
+    })
+}
+
+/// 窗口矩形左上角的屏幕坐标（用于把屏幕区域换算成窗口位图内的裁剪坐标）。
+fn window_rect_origin(hwnd: isize) -> Option<(i32, i32)> {
+    unsafe {
+        let mut wr: RECT = std::mem::zeroed();
+        if GetWindowRect(hwnd as HWND, &mut wr) == 0 {
+            return None;
+        }
+        Some((wr.left, wr.top))
+    }
+}
+
+/// 获取窗口客户区尺寸与客户区左上角屏幕坐标。
+fn client_info(hwnd: isize) -> Option<(i32, i32, i32, i32)> {
+    unsafe {
+        let h = hwnd as HWND;
+        let mut cr: RECT = std::mem::zeroed();
+        if GetClientRect(h, &mut cr) == 0 {
+            return None;
+        }
+        let (cw, ch) = (cr.right - cr.left, cr.bottom - cr.top);
+        let mut pt: POINT = std::mem::zeroed();
+        if ClientToScreen(h, &mut pt) == 0 {
+            return None;
+        }
+        let mut wr: RECT = std::mem::zeroed();
+        if GetWindowRect(h, &mut wr) == 0 {
+            return None;
+        }
+        Some((cw, ch, pt.x - wr.left, pt.y - wr.top))
+    }
+}
+
+/// 抓取窗口客户区内容（PrintWindow + 裁剪，不做 PNG 编码）。
+pub(crate) fn capture_client_bgra(
+    hwnd: isize,
+    client_ox: i32,
+    client_oy: i32,
+    cw: i32,
+    ch: i32,
+) -> Result<Vec<u8>, String> {
+    let img = capture_window_bgra(hwnd)?;
+    // 客户区在窗口位图内的偏移（PrintWindow 从窗口左上角绘制）
+    crop_bgra(
+        &img.bgra,
+        img.width as usize,
+        client_ox,
+        client_oy,
+        cw.min(img.width),
+        ch.min(img.height),
+    )
+}
+
+// ===== 帧间垂直偏移检测 =====
+
+/// 行信号采样列数：每行采 16 列亮度（B+G+R），保留横向细节（文字边缘、分隔线）。
+/// 相比旧的"整行平均"，多列采样大幅降低重复纹理/大面积纯色区的误匹配率。
+const SIG_COLS: usize = 16;
+/// 单周期可检测的最大偏移（像素）。超过即匹配失败（调用方自适应降速）。
+const MAX_OFFSET: usize = 512;
+
+/// 检测两帧之间的垂直滚动像素偏移 `d`，使 `cur[y] ≈ prev[y+d]`。
+///
+/// 匹配范围优先限定在**框选带**（行=带内行、列=带内列）：带外内容（工具栏、
+/// 状态栏、不随滚动的区域）不参与匹配，避免污染信号。带太小/带内匹配失败时
+/// 逐级回退（全行+带列 → 全行+全列）。
+///
+/// 返回：
+/// - `Some(0)`：两帧实质相同（未滚动 / 已到底部）
+/// - `Some(d)` d>0：检测到向下滚动了 d 像素
+/// - `None`：无法可靠匹配（内容动画 / 位移超上限等），调用方跳过本轮
+pub(crate) fn detect_vscroll_offset(
+    prev: &[u8],
+    cur: &[u8],
+    w: usize,
+    h: usize,
+    band_l: usize,
+    band_t: usize,
+    band_w: usize,
+    band_h: usize,
+) -> Option<usize> {
+    if w < 4 || h < 16 {
+        return None;
+    }
+    let band_ok = band_w >= 8 && band_h >= 24 && band_t + band_h <= h && band_l + band_w <= w;
+    if band_ok {
+        // 主匹配：行、列都限定在带内（带外内容不随滚动变化，会污染匹配信号）
+        let ps = row_signals(prev, w, band_t, band_h, band_l, band_w);
+        let cs = row_signals(cur, w, band_t, band_h, band_l, band_w);
+        if let Some(r) = match_signals(&ps, &cs) {
+            return Some(r);
+        }
+        // 回退（带内匹配失败：快速滚动位移超上限 / 带内大面积动画）：
+        // 全客户区行只用于**找位移**，不判"无变化"——带外静止内容会把误差拉低，
+        // 误报 Some(0) 造成假"到底"
+        if band_l + band_w <= w {
+            let ps = row_signals(prev, w, 0, h, band_l, band_w);
+            let cs = row_signals(cur, w, 0, h, band_l, band_w);
+            if let Some(d) = match_signals(&ps, &cs).filter(|d| *d > 0) {
+                return Some(d);
+            }
+        }
+        let ps = row_signals(prev, w, 0, h, 0, w);
+        let cs = row_signals(cur, w, 0, h, 0, w);
+        return match_signals(&ps, &cs).filter(|d| *d > 0);
+    }
+    // 带太小：全客户区回退（此时允许 Some(0)，否则永远判不了"到底"）
+    if band_w >= 8 && band_l + band_w <= w {
+        let ps = row_signals(prev, w, 0, h, band_l, band_w);
+        let cs = row_signals(cur, w, 0, h, band_l, band_w);
+        if let Some(r) = match_signals(&ps, &cs) {
+            return Some(r);
+        }
+    }
+    let ps = row_signals(prev, w, 0, h, 0, w);
+    let cs = row_signals(cur, w, 0, h, 0, w);
+    match_signals(&ps, &cs)
+}
+
+/// 每行采样 SIG_COLS 列的亮度（B+G+R，0..765），返回 rows × SIG_COLS 的信号矩阵。
+fn row_signals(bgra: &[u8], w: usize, y0: usize, rows: usize, l: usize, bw: usize) -> Vec<i32> {
+    // 均匀采样列（含两端）
+    let mut cols = [0usize; SIG_COLS];
+    for i in 0..SIG_COLS {
+        cols[i] = l + (i * (bw - 1)) / (SIG_COLS - 1).max(1);
+    }
+    let mut out = Vec::with_capacity(rows * SIG_COLS);
+    for y in y0..y0 + rows {
+        let base = y * w * 4;
+        for &c in &cols {
+            let i = base + c * 4;
+            // bgra: B,G,R（alpha 通常为 0，不计入亮度）
+            out.push(bgra[i] as i32 + bgra[i + 1] as i32 + bgra[i + 2] as i32);
+        }
+    }
+    out
+}
+
+/// 信号模板匹配：求 d 使 `cs[y] ≈ ps[y+d]`，取平均绝对误差最小者。
+fn match_signals(ps: &[i32], cs: &[i32]) -> Option<usize> {
+    let n = ps.len() / SIG_COLS;
+    if n < 16 {
+        return None;
+    }
+    let step = 2; // 隔行采样加速
+    let max_d = MAX_OFFSET.min(n * 3 / 4);
+    if max_d < 1 {
+        return None;
+    }
+
+    // d=0 基准误差：两帧几乎一致 → 未滚动（到底部）
+    let err0 = {
+        let (mut e, mut c) = (0i64, 0i64);
+        let mut y = 0;
+        while y < n {
+            for k in 0..SIG_COLS {
+                e += (cs[y * SIG_COLS + k] - ps[y * SIG_COLS + k]).abs() as i64;
+            }
+            c += SIG_COLS as i64;
+            y += step;
+        }
+        if c == 0 {
+            return None;
+        }
+        e as f64 / c as f64
+    };
+    if err0 < 4.0 {
+        return Some(0);
+    }
+
+    // 找最小平均误差的 d
+    let mut best_d = 0usize;
+    let mut best_err = f64::MAX;
+    for d in 1..=max_d {
+        let (mut e, mut c) = (0i64, 0i64);
+        let mut y = 0;
+        while y + d < n {
+            for k in 0..SIG_COLS {
+                e += (cs[y * SIG_COLS + k] - ps[(y + d) * SIG_COLS + k]).abs() as i64;
+            }
+            c += SIG_COLS as i64;
+            y += step;
+            // 早停：明显劣于当前最优则放弃该候选
+            if c >= 64 && e as f64 / c as f64 > best_err * 1.8 + 24.0 {
+                break;
+            }
+        }
+        if c >= 64 {
+            let ae = e as f64 / c as f64;
+            if ae < best_err {
+                best_err = ae;
+                best_d = d;
+            }
+        }
+    }
+
+    if best_d == 0 {
+        return None;
+    }
+    // 阈值按 3 通道和（0..765）标定：亚像素滚动会有轻微重采样模糊，阈值不宜过紧
+    if best_err < 30.0 && best_err * 2.0 < err0 {
+        Some(best_d)
+    } else {
+        None
+    }
+}

src-tauri/src/screenshot/scroll_session.rs

@@ -0,0 +1,647 @@
+//! 滚动截图会话（仅 Windows）：后台线程捕捉拼接 + 独立滚轮线程平滑滚动。
+//!
+//! 与 [super::scroll_capture::scroll_capture]（同步一次调用）不同，本模块把捕获循环
+//! 放进后台线程，通过事件把**实时进度**推给前端。
+//!
+//! ## 自动模式架构
+//! - **run_loop（会话线程）**：按节奏捕获客户区帧，与上一帧做带内偏移匹配，拼接新行；
+//! - **ticker（滚轮线程）**：以 ~16ms 间隔发送小步长 `WM_MOUSEWHEEL`，由目标程序自身的
+//!   平滑滚动动画呈现连续滚动（替代旧版"每 70ms 一整格"的跳变式滚动）；
+//! - **目标策略升级**：带中心最深子窗口（小步长 Send）→ 子窗口整格 → 顶层整格 Send →
+//!   顶层整格 Post。解决"一开始就不滚动"（顶层不转发滚轮 / 程序忽略非整格消息）；
+//! - **自适应速度**：按每周期实测位移调滚轮步长 / 捕获周期，逼近"带高 1/4"的理想重叠；
+//! - **停止补帧（settle）**：用户停止后等目标窗口滚动动画静止再补拼最后一帧，
+//!   保证最终图片结尾 = 用户停止时窗口实际停留的位置；
+//! - **精准回滚**：先按累计像素粗估上滚，再用帧匹配对初始帧校准回到起始位置。
+//!
+//! 事件（广播到所有窗口）：
+//! - `SCROLL_PROGRESS`：`{ width, height, auto }` 当前已拼接高度
+//! - `SCROLL_COMPLETE`：`{ width, height }` 完成导出（PNG 原始字节已存入编辑器图片槽，
+//!   由前端常驻编辑器窗口通过 raw IPC 取出，事件本身不携带图片数据）
+//! - `SCROLL_CANCELLED`：`{}` 取消（丢弃画布）
+
+use std::sync::atomic::{AtomicBool, AtomicI32, AtomicIsize, Ordering};
+use std::sync::Mutex;
+use std::thread::sleep;
+use std::time::{Duration, Instant};
+
+use tauri::{AppHandle, Emitter};
+use windows_sys::Win32::UI::WindowsAndMessaging::WHEEL_DELTA;
+
+use crate::constants::events as evts;
+use crate::logger::{log_error, log_info};
+use super::capture::{bgra_to_png, crop_bgra};
+use super::scroll_capture::{
+    capture_client_bgra, client_pt_to_screen, deep_child_at_point, detect_vscroll_offset,
+    post_wheel, resolve_band, send_wheel,
+};
+use super::ScrollRegion;
+
+// ===== 可调参数 =====
+
+/// 滚轮线程发送间隔（毫秒）。小步长 + 高频 → 目标程序的平滑滚动动画连贯不断帧。
+const TICK_MS: u64 = 16;
+/// 捕获周期基准（毫秒）。与滚轮解耦：滚动不因捕获/匹配而停顿。
+const CYCLE_MS: u64 = 130;
+/// 捕获周期上限（整格模式下按实测位移自适应放大）。
+const CYCLE_MS_MAX: u64 = 360;
+/// 每周期理想位移 = clamp(band_h / 4, TARGET_D_MIN, TARGET_D_MAX)。
+/// 太小 → 慢；太大 → 带内重叠不足、匹配易失败。
+const TARGET_D_MIN: usize = 32;
+const TARGET_D_MAX: usize = 180;
+/// 小步长模式：起始 / 上下限步长（WHEEL_DELTA=120 为一整格）。
+const DELTA_START: i32 = 20;
+const DELTA_MIN: i32 = 4;
+const DELTA_MAX: i32 = 72;
+/// 整格模式步长（部分程序忽略非整格滚轮消息，累不进小步长）。
+const DELTA_NOTCH: i32 = 120;
+/// 策略未锁定时：连续多少周期无位移 → 升级投递策略。
+const ESCALATE_CYCLES: u32 = 3;
+/// 策略已锁定时：连续多少周期无位移 → 判定到底。
+const NO_CHANGE_STOP: u32 = 3;
+/// 上限：拼接后总高（像素），超出即自动结束。
+const MAX_TOTAL_H: u32 = 30000;
+/// 进度事件节流。
+const PROGRESS_THROTTLE_MS: u64 = 120;
+/// 停止后等待滚动动画静止的超时（毫秒）。
+const SETTLE_TIMEOUT_MS: u64 = 900;
+/// 回滚粗估：每整格对应的滚动像素。
+const ROLLBACK_PX_PER_NOTCH: f64 = 55.0;
+
+// ===== 会话状态 =====
+
+/// 活动会话（会话线程独占读写；命令只改 STOP/CANCEL 原子标志）
+struct Session {
+    hwnd: isize,
+    /// 客户区尺寸与客户区在窗口位图内偏移
+    cw: i32,
+    ch: i32,
+    ox: i32,
+    oy: i32,
+    band_x: i32,
+    band_y: i32,
+    band_w: i32,
+    band_h: i32,
+    /// 已拼接像素（带宽 × total_h）
+    canvas: Vec<u8>,
+    total_h: u32,
+    /// 累计检测到的滚动像素
+    ttl_px: u32,
+    /// 上一帧（全客户区，匹配基准）
+    prev: Vec<u8>,
+    /// 初始帧（回滚校准用）
+    first: Vec<u8>,
+    auto_scroll: bool,
+    active: bool,
+}
+
+static SESSION: Mutex<Option<Session>> = Mutex::new(None);
+/// 请求线程结束（完成/取消共用）
+static STOP: AtomicBool = AtomicBool::new(false);
+/// 结束方式：true = 取消（不导出），false = 完成（导出）
+static CANCEL: AtomicBool = AtomicBool::new(false);
+
+// ===== 滚轮线程共享控制 =====
+
+static TICKER_STOP: AtomicBool = AtomicBool::new(false);
+static WHEEL_TARGET: AtomicIsize = AtomicIsize::new(0);
+/// 滚轮步长（有符号 delta，正值；发送时取负 = 向下滚）
+static WHEEL_STEP: AtomicI32 = AtomicI32::new(0);
+static WHEEL_POST: AtomicBool = AtomicBool::new(false);
+static WHEEL_SX: AtomicI32 = AtomicI32::new(0);
+static WHEEL_SY: AtomicI32 = AtomicI32::new(0);
+
+/// 会话线程每轮用的只读参数（启动时一次性读出）。
+struct Params {
+    hwnd: isize,
+    cw: i32,
+    ch: i32,
+    ox: i32,
+    oy: i32,
+    band_x: i32,
+    band_y: i32,
+    band_w: i32,
+    band_h: i32,
+    auto_scroll: bool,
+}
+
+fn read_params() -> Option<Params> {
+    let g = SESSION.lock().ok()?;
+    let s = g.as_ref().filter(|s| s.active)?;
+    Some(Params {
+        hwnd: s.hwnd,
+        cw: s.cw,
+        ch: s.ch,
+        ox: s.ox,
+        oy: s.oy,
+        band_x: s.band_x,
+        band_y: s.band_y,
+        band_w: s.band_w,
+        band_h: s.band_h,
+        auto_scroll: s.auto_scroll,
+    })
+}
+
+/// 会话是否仍活动（run_loop 每周期自检，异常路径提前退出）
+fn is_active() -> bool {
+    SESSION
+        .lock()
+        .map(|g| g.as_ref().map(|s| s.active).unwrap_or(false))
+        .unwrap_or(false)
+}
+
+/// 启动滚动截图会话。`auto = true` 时线程自动下滚拼到底部；否则等用户手动滚动。
+pub fn start(app: AppHandle, hwnd: isize, region: Option<ScrollRegion>, auto: bool) -> Result<(), String> {
+    {
+        let g = SESSION.lock().map_err(|e| e.to_string())?;
+        if g.as_ref().map(|s| s.active).unwrap_or(false) {
+            return Err("已有滚动截图进行中".into());
+        }
+    }
+    let (ctx, bx, by, bw, bh) = resolve_band(hwnd, region)?;
+    let first = capture_client_bgra(hwnd, ctx.ox, ctx.oy, ctx.cw, ctx.ch)?;
+    let canvas = crop_bgra(&first, ctx.cw as usize, bx, by, bw, bh)?;
+
+    {
+        let mut g = SESSION.lock().map_err(|e| e.to_string())?;
+        *g = Some(Session {
+            hwnd,
+            cw: ctx.cw,
+            ch: ctx.ch,
+            ox: ctx.ox,
+            oy: ctx.oy,
+            band_x: bx,
+            band_y: by,
+            band_w: bw,
+            band_h: bh,
+            canvas,
+            total_h: bh as u32,
+            ttl_px: 0,
+            first: first.clone(),
+            prev: first,
+            auto_scroll: auto,
+            active: true,
+        });
+    }
+    STOP.store(false, Ordering::Release);
+    CANCEL.store(false, Ordering::Release);
+
+    log_info("scroll-session", &format!(
+        "启动滚动截图 hwnd={} band={}x{} auto={}",
+        hwnd, bw, bh, auto
+    ));
+    std::thread::spawn(move || run_loop(app));
+    Ok(())
+}
+
+/// 请求结束会话并导出（完成）。立即返回，线程在下一轮感知并完成。
+pub fn finish() -> Result<(), String> {
+    if !running() {
+        return Err("没有进行中的滚动截图".into());
+    }
+    STOP.store(true, Ordering::Release);
+    CANCEL.store(false, Ordering::Release);
+    Ok(())
+}
+
+/// 请求取消会话（不导出）。立即返回，线程在下一轮感知并回滚终止。
+pub fn cancel_now() -> Result<(), String> {
+    if !running() {
+        return Err("没有进行中的滚动截图".into());
+    }
+    STOP.store(true, Ordering::Release);
+    CANCEL.store(true, Ordering::Release);
+    Ok(())
+}
+
+fn running() -> bool {
+    SESSION.lock().map(|g| g.as_ref().map(|s| s.active).unwrap_or(false)).unwrap_or(false)
+}
+
+/// 滚轮线程：高频小步长发送，滚动手感交给目标程序的平滑滚动动画。
+fn ticker_loop() {
+    loop {
+        if TICKER_STOP.load(Ordering::Acquire) {
+            break;
+        }
+        let target = WHEEL_TARGET.load(Ordering::Acquire);
+        let delta = WHEEL_STEP.load(Ordering::Acquire);
+        let sx = WHEEL_SX.load(Ordering::Acquire);
+        let sy = WHEEL_SY.load(Ordering::Acquire);
+        if target != 0 && delta != 0 {
+            if WHEEL_POST.load(Ordering::Acquire) {
+                post_wheel(target, sx, sy, -delta);
+            } else {
+                send_wheel(target, sx, sy, -delta);
+            }
+        }
+        sleep(Duration::from_millis(TICK_MS));
+    }
+}
+
+/// 应用滚轮投递策略（未检测到位移时逐级升级，直到找到能滚动的通道）。
+fn apply_strategy(strategy: u8, p: &Params, bcx: i32, bcy: i32) {
+    match strategy {
+        0 => {
+            // 子窗口 + 小步长（Chromium/WinUI 等会累加小步长并平滑滚动）
+            WHEEL_TARGET.store(deep_child_at_point(p.hwnd, bcx, bcy), Ordering::Release);
+            WHEEL_STEP.store(DELTA_START, Ordering::Release);
+            WHEEL_POST.store(false, Ordering::Release);
+        }
+        1 => {
+            // 子窗口 + 整格（经典 Win32 控件只认整格消息）
+            WHEEL_TARGET.store(deep_child_at_point(p.hwnd, bcx, bcy), Ordering::Release);
+            WHEEL_STEP.store(DELTA_NOTCH, Ordering::Release);
+            WHEEL_POST.store(false, Ordering::Release);
+        }
+        2 => {
+            // 顶层 + 整格 Send（部分程序由顶层统一处理滚轮）
+            WHEEL_TARGET.store(p.hwnd, Ordering::Release);
+            WHEEL_STEP.store(DELTA_NOTCH, Ordering::Release);
+            WHEEL_POST.store(false, Ordering::Release);
+        }
+        _ => {
+            // 顶层 + 整格 Post（只处理消息泵排队事件的程序）
+            WHEEL_TARGET.store(p.hwnd, Ordering::Release);
+            WHEEL_STEP.store(DELTA_NOTCH, Ordering::Release);
+            WHEEL_POST.store(true, Ordering::Release);
+        }
+    }
+    log_info("scroll-session", &format!("滚轮策略升级为 {}", strategy));
+}
+
+/// 单周期匹配结果
+enum CycleResult {
+    /// 两帧一致（未滚动）
+    NoChange,
+    /// 向下滚了 d 像素（已拼接）
+    Moved(usize),
+    /// 匹配失败（动画 / 位移超上限）
+    MatchFail,
+}
+
+/// 一轮捕获-匹配-拼接。返回 (band_w, total_h, CycleResult)。
+fn stitch_cycle(p: &Params, cur: &[u8]) -> (i32, u32, CycleResult) {
+    let mut g = match SESSION.lock() {
+        Ok(g) => g,
+        Err(e) => {
+            log_error("scroll-session", &format!("会话锁异常: {}", e));
+            return (p.band_w, 0, CycleResult::MatchFail);
+        }
+    };
+    let s = match g.as_mut() {
+        Some(s) => s,
+        None => return (p.band_w, 0, CycleResult::MatchFail),
+    };
+    let prev = std::mem::take(&mut s.prev);
+    let (bx, by, bw, bh) = (s.band_x, s.band_y, s.band_w, s.band_h);
+    let off = detect_vscroll_offset(
+        &prev,
+        cur,
+        p.cw as usize,
+        p.ch as usize,
+        bx as usize,
+        by as usize,
+        bw as usize,
+        bh as usize,
+    );
+    match off {
+        Some(0) => {
+            s.prev = cur.to_vec();
+            (bw, s.total_h, CycleResult::NoChange)
+        }
+        Some(d) => {
+            // 一次最多拼接带的整高：单步滚动量超过带高时无法恢复中间内容，
+            // 以整带兜底（自适应速度会把位移压回安全区间）
+            let new_rows = (d as i32).min(bh) as usize;
+            let new_y = bh - new_rows as i32; // 带在客户区内的底对齐
+            match crop_bgra(cur, p.cw as usize, bx, s.band_y + new_y, bw, new_rows as i32) {
+                Ok(rows) => {
+                    s.canvas.extend_from_slice(&rows);
+                    s.total_h += new_rows as u32;
+                    s.ttl_px += d as u32;
+                    s.prev = cur.to_vec();
+                    (bw, s.total_h, CycleResult::Moved(d))
+                }
+                Err(_) => {
+                    s.prev = cur.to_vec();
+                    (bw, s.total_h, CycleResult::MatchFail)
+                }
+            }
+        }
+        None => {
+            // 匹配失败：保留旧基准帧（下一帧与更早的稳定帧比对，累积位移仍能对上）
+            s.prev = prev;
+            (bw, s.total_h, CycleResult::MatchFail)
+        }
+    }
+}
+
+fn run_loop(app: AppHandle) {
+    let p = match read_params() {
+        Some(p) => p,
+        None => return,
+    };
+
+    // 滚轮目标初始参数：带中心（客户区坐标）→ 屏幕坐标
+    let bcx = p.band_x + p.band_w / 2;
+    let bcy = p.band_y + p.band_h / 2;
+    let (bsx, bsy) = client_pt_to_screen(p.hwnd, bcx, bcy).unwrap_or((0, 0));
+    WHEEL_SX.store(bsx, Ordering::Release);
+    WHEEL_SY.store(bsy, Ordering::Release);
+
+    // 自动模式：启动滚轮线程（策略 0 起步）
+    let mut strategy: u8 = 0;
+    let mut ticker = None;
+    if p.auto_scroll {
+        apply_strategy(0, &p, bcx, bcy);
+        TICKER_STOP.store(false, Ordering::Release);
+        ticker = Some(std::thread::spawn(ticker_loop));
+    }
+
+    let mut no_change: u32 = 0; // 锁定后：连续无位移（到底判定）
+    let mut no_move: u32 = 0; // 未锁定：连续无位移（策略升级判定）
+    let mut locked = false; // 是否已确认当前策略能滚动
+    let mut gave_up = false; // 所有策略都滚不动
+    let mut cycle_ms = CYCLE_MS;
+    let mut capture_errors: u32 = 0;
+    let mut last_emit = Instant::now();
+
+    loop {
+        if STOP.load(Ordering::Acquire) || !is_active() {
+            break;
+        }
+        // 周期节拍：捕获+匹配耗时计入周期
+        let t0 = Instant::now();
+
+        let cur = match capture_client_bgra(p.hwnd, p.ox, p.oy, p.cw, p.ch) {
+            Ok(f) => {
+                capture_errors = 0;
+                f
+            }
+            Err(e) => {
+                // 瞬时失败先重试，连续多次失败才视为窗口关闭/失去客户区
+                capture_errors += 1;
+                log_error("scroll-session", &format!("捕获失败({}/3): {}", capture_errors, e));
+                if capture_errors >= 3 {
+                    break;
+                }
+                sleep(Duration::from_millis(100));
+                continue;
+            }
+        };
+
+        let (band_w, total_h, result) = stitch_cycle(&p, &cur);
+
+        // 目标位移：带高 1/4，夹在安全区间
+        let target_d = (p.band_h as usize / 4).clamp(TARGET_D_MIN, TARGET_D_MAX);
+
+        match result {
+            CycleResult::Moved(d) => {
+                if !locked {
+                    locked = true;
+                    log_info("scroll-session", &format!("策略 {} 生效，锁定", strategy));
+                }
+                no_change = 0;
+                no_move = 0;
+                if p.auto_scroll {
+                    if strategy == 0 {
+                        // 小步长模式：按实测位移调步长（sqrt 阻尼防过冲）
+                        let delta = WHEEL_STEP.load(Ordering::Acquire) as f64;
+                        let factor = target_d as f64 / d.max(6) as f64;
+                        let nd = (delta * factor.sqrt()).clamp(DELTA_MIN as f64, DELTA_MAX as f64);
+                        WHEEL_STEP.store(nd as i32, Ordering::Release);
+                    } else {
+                        // 整格模式：步长固定，按实测位移调捕获周期
+                        if d as f64 > p.band_h as f64 * 0.55 {
+                            cycle_ms = ((cycle_ms as f64) * 1.25).min(CYCLE_MS_MAX as f64) as u64;
+                        } else if d < target_d / 2 && cycle_ms > CYCLE_MS {
+                            cycle_ms = ((cycle_ms as f64) * 0.8).max(CYCLE_MS as f64) as u64;
+                        }
+                    }
+                }
+            }
+            CycleResult::NoChange => {
+                if locked {
+                    no_change += 1;
+                    if no_change >= NO_CHANGE_STOP && p.auto_scroll {
+                        break; // 已到底部
+                    }
+                    // 手动模式由用户控制，不自动结束
+                } else if p.auto_scroll {
+                    no_move += 1;
+                    if no_move >= ESCALATE_CYCLES {
+                        no_move = 0;
+                        strategy += 1;
+                        if strategy > 3 {
+                            gave_up = true; // 所有通道都滚不动 → 结束（前端提示）
+                            break;
+                        }
+                        apply_strategy(strategy, &p, bcx, bcy);
+                    }
+                }
+            }
+            CycleResult::MatchFail => {
+                // 内容大幅变化/动画/位移超上限：若持续失败则降速，
+                // 避免越滚越快导致匹配一直失败（表现即"滚动中断"）
+                if p.auto_scroll {
+                    if locked && strategy == 0 {
+                        let delta = WHEEL_STEP.load(Ordering::Acquire) as f64;
+                        let nd = (delta * 0.75).max(DELTA_MIN as f64);
+                        WHEEL_STEP.store(nd as i32, Ordering::Release);
+                    } else if !locked {
+                        // 未锁定：匹配失败也算"无位移"参与策略升级，
+                        // 防止动画页面导致升级判定永不触发
+                        no_move += 1;
+                        if no_move >= ESCALATE_CYCLES {
+                            no_move = 0;
+                            strategy += 1;
+                            if strategy > 3 {
+                                gave_up = true;
+                                break;
+                            }
+                            apply_strategy(strategy, &p, bcx, bcy);
+                        }
+                    }
+                }
+            }
+        }
+
+        // 进度事件（节流）
+        if matches!(result, CycleResult::Moved(_))
+            && last_emit.elapsed().as_millis() as u64 >= PROGRESS_THROTTLE_MS
+        {
+            last_emit = Instant::now();
+            emit_progress(&app, band_w, total_h, p.auto_scroll);
+        }
+        if total_h >= MAX_TOTAL_H {
+            break;
+        }
+
+        // 补足周期剩余时间
+        let el = t0.elapsed().as_millis() as u64;
+        if el < cycle_ms {
+            sleep(Duration::from_millis(cycle_ms - el));
+        }
+    }
+
+    // 停滚轮线程（join 等它退出，最多再发一拍）
+    if let Some(t) = ticker.take() {
+        TICKER_STOP.store(true, Ordering::Release);
+        let _ = t.join();
+    }
+
+    let cancel = CANCEL.load(Ordering::Acquire);
+    // 完成（非取消、非放弃）时：等滚动动画静止后补拼最后一帧，
+    // 保证图片结尾 = 用户停止时窗口实际停留的位置
+    if !cancel && !gave_up {
+        settle_and_stitch(&p);
+    }
+
+    // 取出会话数据
+    let mut s = match SESSION.lock().ok().and_then(|mut g| g.take()) {
+        Some(s) => s,
+        None => {
+            log_info("scroll-session", "会话已不存在（未导出）");
+            let _ = app.emit(evts::SCROLL_CANCELLED, serde_json::json!({}));
+            return;
+        }
+    };
+
+    // 编码与回滚并行：PNG 编码只依赖画布（已定格），回滚不依赖画布，
+    // 两者无数据依赖，并行可显著缩短「停止 → 打开编辑器」的等待
+    let (band_w, total_h) = (s.band_w, s.total_h);
+    let encode = if cancel {
+        None
+    } else {
+        let canvas = std::mem::take(&mut s.canvas);
+        Some(std::thread::spawn(move || {
+            bgra_to_png(&canvas, band_w, total_h as i32)
+        }))
+    };
+
+    // 回滚到起始位置（与编码并行）：先按累计像素粗估上滚，再帧匹配校准
+    if s.ttl_px > 0 {
+        rollback(&s);
+    }
+
+    STOP.store(false, Ordering::Release);
+    CANCEL.store(false, Ordering::Release);
+
+    // 等编码完成：PNG 原始字节直接存入编辑器图片槽（不经 base64 / JSON 事件传输）
+    let png = encode.and_then(|h| h.join().ok()).and_then(|r| r.ok());
+    match png {
+        Some(png) => {
+            log_info("scroll-session", &format!(
+                "完成导出 width={} height={}",
+                band_w, total_h
+            ));
+            super::set_editor_image_raw(png);
+            let _ = app.emit(
+                evts::SCROLL_COMPLETE,
+                serde_json::json!({ "width": band_w, "height": total_h }),
+            );
+        }
+        None => {
+            log_info("scroll-session", "会话已取消（未导出）");
+            let _ = app.emit(evts::SCROLL_CANCELLED, serde_json::json!({}));
+        }
+    }
+}
+
+/// 停止后等待目标窗口滚动动画静止，并把静止帧补拼进画布（结尾对齐停止位置）。
+fn settle_and_stitch(p: &Params) {
+    let deadline = Instant::now() + Duration::from_millis(SETTLE_TIMEOUT_MS);
+    loop {
+        sleep(Duration::from_millis(70));
+        if Instant::now() >= deadline || !is_active() {
+            return;
+        }
+        let cur = match capture_client_bgra(p.hwnd, p.ox, p.oy, p.cw, p.ch) {
+            Ok(f) => f,
+            Err(_) => return,
+        };
+        match stitch_cycle(p, &cur).2 {
+            CycleResult::NoChange => return, // 已静止且无新内容
+            CycleResult::Moved(_) | CycleResult::MatchFail => {
+                // 动画仍在进行（Moved 已拼接；MatchFail 继续等）
+                if Instant::now() >= deadline {
+                    return;
+                }
+            }
+        }
+    }
+}
+
+/// 回滚：粗估整格数上滚 → 与初始帧逐次比对校准，直到回到起始位置。
+/// 帧匹配校准消除"每格滚动像素因程序而异"带来的累计误差。
+fn rollback(s: &Session) {
+    let target = {
+        let t = WHEEL_TARGET.load(Ordering::Acquire);
+        if t != 0 { t } else { s.hwnd }
+    };
+    let mut sx = WHEEL_SX.load(Ordering::Acquire);
+    let mut sy = WHEEL_SY.load(Ordering::Acquire);
+    if sx == 0 && sy == 0 {
+        if let Some((x, y)) = client_pt_to_screen(
+            s.hwnd,
+            s.band_x + s.band_w / 2,
+            s.band_y + s.band_h / 2,
+        ) {
+            sx = x;
+            sy = y;
+        }
+    }
+
+    // 粗估上滚（宁可略少，剩余交给校准补齐）。
+    // 上限按累计像素推算：长图捕获（累计数万 px）也要能回滚到位，
+    // 固定小上限会导致超长捕获结束后窗口停在半途。
+    let notches = (((s.ttl_px as f64) / ROLLBACK_PX_PER_NOTCH).floor() as i32).clamp(1, 800);
+    for _ in 0..notches {
+        send_wheel(target, sx, sy, WHEEL_DELTA as i32);
+        sleep(Duration::from_millis(3));
+    }
+    sleep(Duration::from_millis(80));
+
+    // 帧匹配校准：d = 当前仍相对起始位置向下滚动的像素
+    let mut last_d = usize::MAX;
+    for _ in 0..12 {
+        let cur = match capture_client_bgra(s.hwnd, s.ox, s.oy, s.cw, s.ch) {
+            Ok(f) => f,
+            Err(_) => return,
+        };
+        let d = detect_vscroll_offset(
+            &s.first,
+            &cur,
+            s.cw as usize,
+            s.ch as usize,
+            s.band_x as usize,
+            s.band_y as usize,
+            s.band_w as usize,
+            s.band_h as usize,
+        );
+        match d {
+            Some(0) | None => return, // 已回到起始位置 / 无法匹配（视为完成）
+            Some(d) if d < 10 => return, // 误差 10px 内视为到位
+            Some(d) => {
+                if d >= last_d {
+                    return; // 不再下降：窗口可能不支持向上滚（虚拟化列表），放弃
+                }
+                last_d = d;
+                let more = (((d as f64) / ROLLBACK_PX_PER_NOTCH).ceil() as i32).clamp(1, 60);
+                for _ in 0..more {
+                    send_wheel(target, sx, sy, WHEEL_DELTA as i32);
+                    sleep(Duration::from_millis(3));
+                }
+                sleep(Duration::from_millis(60));
+            }
+        }
+    }
+}
+
+fn emit_progress(app: &AppHandle, width: i32, height: u32, auto: bool) {
+    let _ = app.emit(
+        evts::SCROLL_PROGRESS,
+        serde_json::json!({ "width": width, "height": height, "auto": auto }),
+    );
+}

src-tauri/src/screenshot/wgc_capture.rs

@@ -0,0 +1,363 @@
+//! HDR 全屏捕获实现（Windows Graphics Capture + HDR→sRGB 色调映射）
+//!
+//! ## 为什么需要它
+//! Windows 高级色彩（HDR）开启时，桌面由 DWM 用**线性 scRGB（RGBA16F）**合成。
+//! [crate::screenshot::capture] 的 `BitBlt` 从屏幕 DC 直接取出 8bit 像素，
+//! 把这些线性/scRGB 高亮值当 sRGB 编码，会导致亮部越界被裁、局部过曝失真。
+//!
+//! ## 方案
+//! 检测到任意显示器为 HDR 输出时，改用 WGC：
+//! 1. 以 `RGBA16F`（scRGB 线性）捕获每个显示器；
+//! 2. 按 SDR 参考白缩放（`÷ (sdr_white_nits / 80)`）后钳制到 [0,1]；
+//! 3. 做 sRGB 伽马编码，得到与屏幕观感一致的 BGRA8；
+//! 4. 按各显示器在虚拟屏上的偏移拼接到一整张虚拟屏图像（与 BitBlt 输出同构）。
+//!
+//! 仅当 HDR 时才走此路径；SDR 显示器仍用快速的 BitBlt。
+
+use std::ffi::c_void;
+use std::sync::mpsc;
+use std::time::Duration;
+
+use windows_capture::capture::{Context, GraphicsCaptureApiHandler};
+use windows_capture::frame::Frame;
+use windows_capture::graphics_capture_api::InternalCaptureControl;
+use windows_capture::monitor::Monitor;
+use windows_capture::settings::{
+    ColorFormat, CursorCaptureSettings, DirtyRegionSettings, DrawBorderSettings,
+    MinimumUpdateIntervalSettings, SecondaryWindowSettings, Settings,
+};
+
+use super::capture::CapturedImage;
+
+// ===== 虚拟屏尺寸（与 capture.rs 一致）=====
+const SM_XVIRTUALSCREEN: i32 = 76;
+const SM_YVIRTUALSCREEN: i32 = 77;
+const SM_CXVIRTUALSCREEN: i32 = 78;
+const SM_CYVIRTUALSCREEN: i32 = 79;
+
+/// Windows「SDR 内容亮度」的默认参考白（nits）。未自定义时为 203。
+/// 严格值可用 DISPLAYCONFIG_SDR_WHITE_LEVEL 查询；此处取系统默认，覆盖绝大多数情况。
+const DEFAULT_SDR_WHITE_NITS: f32 = 203.0;
+
+/// 单帧捕获参数（作为 WGC handler 的 Flags 传入，把抓到的帧回传给调用线程）
+#[derive(Clone)]
+struct CaptureFlags {
+    tx: mpsc::SyncSender<Result<FramePixels, String>>,
+}
+
+/// 一帧 Rgba16F 像素（已去掉行尾 padding，top-down）
+struct FramePixels {
+    width: u32,
+    height: u32,
+    raw: Vec<u8>,
+}
+
+/// 一次性截图 handler：拿到第一帧即回传并停止捕获
+struct OneShot {
+    flags: CaptureFlags,
+}
+
+impl GraphicsCaptureApiHandler for OneShot {
+    type Flags = CaptureFlags;
+    type Error = String;
+
+    fn new(ctx: Context<Self::Flags>) -> Result<Self, Self::Error> {
+        Ok(Self { flags: ctx.flags })
+    }
+
+    fn on_frame_arrived(
+        &mut self,
+        frame: &mut Frame,
+        capture_control: InternalCaptureControl,
+    ) -> Result<(), Self::Error> {
+        let mut buffer = frame.buffer().map_err(|e| e.to_string())?;
+        let width = buffer.width();
+        let height = buffer.height();
+        let row_pitch = buffer.row_pitch() as usize;
+        let raw = buffer.as_raw_buffer();
+        // 拷贝并去掉行 padding（Rgba16F = 每像素 8 字节）
+        let row_bytes = (width as usize) * 8;
+        let mut packed = vec![0u8; row_bytes * (height as usize)];
+        for y in 0..(height as usize) {
+            let src = y * row_pitch;
+            let dst = y * row_bytes;
+            packed[dst..dst + row_bytes].copy_from_slice(&raw[src..src + row_bytes]);
+        }
+        let _ = self.flags.tx.send(Ok(FramePixels {
+            width,
+            height,
+            raw: packed,
+        }));
+        // 单帧足够，立即结束捕获（internal stop → 捕获线程退出）
+        capture_control.stop();
+        Ok(())
+    }
+}
+
+/// 捕获单个显示器（按 hmonitor），返回 tonemap 后的 BGRA8（top-down）
+fn capture_monitor_bgra(
+    hmonitor: *mut c_void,
+    sdr_white: f32,
+) -> Result<(Vec<u8>, u32, u32), String> {
+    let monitor = Monitor::from_raw_hmonitor(hmonitor);
+    let (tx, rx) = mpsc::sync_channel::<Result<FramePixels, String>>(1);
+    let flags = CaptureFlags { tx };
+    let settings = Settings::new(
+        monitor,
+        CursorCaptureSettings::WithCursor,
+        DrawBorderSettings::WithoutBorder,
+        SecondaryWindowSettings::Default,
+        MinimumUpdateIntervalSettings::Custom(Duration::from_millis(32)),
+        DirtyRegionSettings::Default,
+        ColorFormat::Rgba16F,
+        flags,
+    );
+
+    let control = OneShot::start_free_threaded(settings)
+        .map_err(|e| format!("WGC 捕获启动失败: {}", e))?;
+
+    let frame = match rx.recv_timeout(Duration::from_secs(10)) {
+        Ok(Ok(f)) => f,
+        Ok(Err(e)) => {
+            let _ = control.stop();
+            return Err(e);
+        }
+        Err(e) => {
+            let _ = control.stop();
+            return Err(format!("等待 WGC 帧超时: {}", e));
+        }
+    };
+    let _ = control.stop();
+
+    let bgra = tonemap_rgba16f_to_bgra(&frame.raw, frame.width, frame.height, sdr_white);
+    Ok((bgra, frame.width, frame.height))
+}
+
+/// 捕获整个虚拟屏（多显示器拼接），返回与 BitBlt 同构的 `CapturedImage`（BGRA top-down）。
+/// 仅当检测到 HDR 时由 [capture] 调用。
+pub fn capture_virtual_screen_wgc() -> Result<CapturedImage, String> {
+    // 用 QueryDisplayConfig 读系统实际 SDR 白电平（nits），取不到才回退系统默认 203
+    let sdr_white = query_sdr_white_level().unwrap_or(DEFAULT_SDR_WHITE_NITS);
+    let monitors = enum_monitors();
+    if monitors.is_empty() {
+        return Err("未检测到显示器".into());
+    }
+    use windows_sys::Win32::UI::WindowsAndMessaging::GetSystemMetrics as gsm;
+    let vx = unsafe { gsm(SM_XVIRTUALSCREEN) };
+    let vy = unsafe { gsm(SM_YVIRTUALSCREEN) };
+    let vw = unsafe { gsm(SM_CXVIRTUALSCREEN) };
+    let vh = unsafe { gsm(SM_CYVIRTUALSCREEN) };
+    if vw <= 0 || vh <= 0 {
+        return Err("无法获取虚拟屏尺寸".into());
+    }
+    let mut canvas = vec![0u8; (vw as usize) * (vh as usize) * 4]; // 透明区以黑填充
+    for m in &monitors {
+        let (bgra, mw, mh) = capture_monitor_bgra(m.handle as *mut c_void, sdr_white)?;
+        let ow = m.x - vx;
+        let oh = m.y - vy;
+        if mw as i32 != m.w || mh as i32 != m.h {
+            // 尺寸失配（极少见，如缩放中途）— 中止避免错位拼接
+            return Err(format!(
+                "显示器捕获尺寸不符: 枚举 {}x{} vs WGC {}x{}",
+                m.w, m.h, mw, mh
+            ));
+        }
+        let mw = mw as usize;
+        for row in 0..mh {
+            let src = (row as usize) * mw * 4;
+            let dst = ((oh + row as i32) as usize) * (vw as usize) * 4 + (ow as usize) * 4;
+            let len = mw * 4;
+            canvas[dst..dst + len].copy_from_slice(&bgra[src..src + len]);
+        }
+    }
+    Ok(CapturedImage {
+        width: vw,
+        height: vh,
+        png: Vec::new(),
+        bgra: canvas,
+    })
+}
+
+// ===== 显示器枚举与 HDR 检测 =====
+
+struct MonInfo {
+    handle: usize,
+    x: i32,
+    y: i32,
+    w: i32,
+    h: i32,
+}
+
+fn enum_monitors() -> Vec<MonInfo> {
+    let mut out: Vec<MonInfo> = Vec::new();
+    unsafe extern "system" fn cb(
+        hmon: isize,
+        _hdc: isize,
+        rect: *mut windows_sys::Win32::Foundation::RECT,
+        lparam: isize,
+    ) -> windows_sys::Win32::Foundation::BOOL {
+        let v = &mut *(lparam as *mut Vec<MonInfo>);
+        let r = *rect;
+        v.push(MonInfo {
+            handle: hmon as usize,
+            x: r.left,
+            y: r.top,
+            w: r.right - r.left,
+            h: r.bottom - r.top,
+        });
+        1
+    }
+    unsafe {
+        windows_sys::Win32::Graphics::Gdi::EnumDisplayMonitors(
+            0,
+            std::ptr::null(),
+            Some(cb),
+            &mut out as *mut _ as isize,
+        );
+    }
+    out
+}
+
+/// 枚举 DXGI 输出，任一显示器为 HDR（advanced color / PQ / HLG）输出则返回 true。
+/// 任何错误一律视为非 HDR（回退 BitBlt），保证普通 SDR 环境不受影响。
+pub fn is_hdr_enabled() -> bool {
+    #[allow(unused_imports)]
+    use windows::Win32::Graphics::Dxgi::Common::{
+        DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709, DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020,
+        DXGI_COLOR_SPACE_TYPE,
+    };
+
+    fn is_hdr_space(space: DXGI_COLOR_SPACE_TYPE) -> bool {
+        // HDR10（PQ，BT.2020 主色）与 scRGB 高级色彩工作空间即视为 HDR
+        matches!(
+            space,
+            DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020 | DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709
+        )
+    }
+
+    use windows::Win32::Graphics::Dxgi::IDXGIFactory1;
+    let Ok(factory) = (unsafe {
+        windows::Win32::Graphics::Dxgi::CreateDXGIFactory1::<IDXGIFactory1>()
+    }) else {
+        return false;
+    };
+    use windows::core::ComInterface;
+    unsafe {
+        let mut ai = 0u32;
+        while let Ok(adapter) = factory.EnumAdapters1(ai) {
+            ai += 1;
+            let mut oi = 0u32;
+            while let Ok(output) = adapter.EnumOutputs(oi) {
+                oi += 1;
+                if let Ok(out6) =
+                    output.cast::<windows::Win32::Graphics::Dxgi::IDXGIOutput6>()
+                {
+                    let mut desc: windows::Win32::Graphics::Dxgi::DXGI_OUTPUT_DESC1 =
+                        std::mem::zeroed();
+                    if out6.GetDesc1(&mut desc).is_ok() && is_hdr_space(desc.ColorSpace) {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+    false
+}
+
+/// 通过 QueryDisplayConfig 读取 Windows 实际的 SDR 参考白电平（nits）。
+///
+/// SDR 白电平并非 union 的声明成员，而是系统/驱动写入在 DISPLAYCONFIG_MODE_INFO
+/// 的 union 尾部（desktopImageInfo 之后）的 4 字节（DISPLAYCONFIG_SDR_WHITE_LEVEL）。
+/// 取不到（非 HDR / 查询失败）时返回 None，由调用方回退系统默认 203。
+fn query_sdr_white_level() -> Option<f32> {
+    use windows_sys::Win32::Devices::Display::{
+        GetDisplayConfigBufferSizes, QueryDisplayConfig, DISPLAYCONFIG_MODE_INFO,
+        DISPLAYCONFIG_MODE_INFO_TYPE_DESKTOP_IMAGE, DISPLAYCONFIG_PATH_INFO,
+        DISPLAYCONFIG_SDR_WHITE_LEVEL, QDC_ONLY_ACTIVE_PATHS,
+    };
+    unsafe {
+        let mut num_paths = 0u32;
+        let mut num_modes = 0u32;
+        if GetDisplayConfigBufferSizes(QDC_ONLY_ACTIVE_PATHS, &mut num_paths, &mut num_modes) != 0
+        {
+            return None;
+        }
+        let mut paths = vec![std::mem::zeroed::<DISPLAYCONFIG_PATH_INFO>(); num_paths as usize];
+        let mut modes = vec![std::mem::zeroed::<DISPLAYCONFIG_MODE_INFO>(); num_modes as usize];
+        if QueryDisplayConfig(
+            QDC_ONLY_ACTIVE_PATHS,
+            &mut num_paths,
+            paths.as_mut_ptr(),
+            &mut num_modes,
+            modes.as_mut_ptr(),
+            std::ptr::null_mut(),
+        ) != 0
+        {
+            return None;
+        }
+        for mode in modes.iter().take(num_modes as usize) {
+            if mode.infoType == DISPLAYCONFIG_MODE_INFO_TYPE_DESKTOP_IMAGE {
+                let base = mode as *const DISPLAYCONFIG_MODE_INFO as *const u8;
+                let off = std::mem::size_of::<DISPLAYCONFIG_MODE_INFO>()
+                    - std::mem::size_of::<DISPLAYCONFIG_SDR_WHITE_LEVEL>();
+                let white = std::ptr::read_unaligned::<u32>(base.add(off) as *const u32);
+                if white > 0 {
+                    return Some(white as f32);
+                }
+            }
+        }
+    }
+    None
+}
+
+// ===== HDR→sRGB 色调映射 =====
+
+/// IEEE754 半精度 float → f32
+fn half_to_f32(h: u16) -> f32 {
+    let sign = (h & 0x8000) != 0;
+    let exp = (h >> 10) & 0x1f;
+    let man = (h & 0x3ff) as f32;
+    let v = match exp {
+        0 => man / 1024.0 * 2.0f32.powi(-14), // 次正规
+        0x1f => f32::NAN,                      // Inf/NaN，按 NaN 处理（后续 clamp 为 0~255 安全）
+        _ => (1.0 + man / 1024.0) * 2.0f32.powi(exp as i32 - 15),
+    };
+    if sign {
+        -v
+    } else {
+        v
+    }
+}
+
+/// 线性 scRGB 值 → sRGB 8bit（标准 sRGB OETF）
+fn srgb_encode(linear: f32) -> u8 {
+    let l = linear.clamp(0.0, 1.0);
+    let e = if l <= 0.003_130_8 {
+        12.92 * l
+    } else {
+        1.055 * l.powf(1.0 / 2.4) - 0.055
+    };
+    (e * 255.0 + 0.5) as u8
+}
+
+/// Rgba16F（scRGB 线性，top-down）→ BGRA8（sRGB），按 SDR 参考白缩放。
+fn tonemap_rgba16f_to_bgra(raw: &[u8], width: u32, height: u32, sdr_white: f32) -> Vec<u8> {
+    let inv_scale = 80.0 / sdr_white.max(1.0);
+    let n = (width as usize) * (height as usize);
+    let mut out = vec![0u8; n * 4];
+    for i in 0..n {
+        let pi = i * 8;
+        let r16 = u16::from_le_bytes([raw[pi], raw[pi + 1]]);
+        let g16 = u16::from_le_bytes([raw[pi + 2], raw[pi + 3]]);
+        let b16 = u16::from_le_bytes([raw[pi + 4], raw[pi + 5]]);
+        let b = srgb_encode(half_to_f32(b16) * inv_scale);
+        let g = srgb_encode(half_to_f32(g16) * inv_scale);
+        let r = srgb_encode(half_to_f32(r16) * inv_scale);
+        let oi = i * 4;
+        out[oi] = b;
+        out[oi + 1] = g;
+        out[oi + 2] = r;
+        out[oi + 3] = 255; // 强制不透明（与 BitBlt 路径一致）
+    }
+    out
+}

src-tauri/src/updater/mod.rs

@@ -2,18 +2,65 @@
 //! 更新源为自建 Gitea：`https://gitea.atie.fun/LFeng/Thing` 的 release 资产。
 //! - 便携版（无 unins000.exe 且不在 Program Files）：下载新 thing.exe → update.bat 覆盖重启
 //! - 安装版（NSIS）：下载新 setup.exe → 提权静默安装 /S
-//! - ThingHK 内核：下载 thing-hk_{v}.zip → 停止监控内核 → 覆盖 {app_data}/monitor/cores/ThingHK.exe
-//! mihomo 内核更新继续复用代理模块已有的 GitHub 下载机制，不在此模块处理。
-use futures_util::StreamExt;
+//! - ThingHK 内核：下载由前端下载模块完成 → apply 命令 need_stop 等待确认 → 解压覆盖
+//!   {app_data}/monitor/cores/ThingHK.exe（与代理模块 mihomo 内核更新同模式）
 use serde::Serialize;
 use specta::Type;
 use std::fs;
 use std::io::{Read, Write};
 use std::path::{Path, PathBuf};
+use std::sync::{atomic::{AtomicBool, Ordering}, Mutex};
 use tauri::{AppHandle, Emitter, Manager};
+use tokio::sync::{oneshot, watch};
 
 use crate::constants::events::UPDATE_PROGRESS;
 
+/// 用户主动取消 ThingHK 更新的标记错误信息（前端据此静默处理，不弹错误 toast）
+const THINGHK_UPDATE_CANCELLED: &str = "更新已取消";
+
+/// ThingHK 内核更新的跨命令状态：apply 过程中 need_stop 阶段等待前端确认。
+/// 与 MihomoManager 的 install_confirm/kernel_cancel 同构。
+pub struct ThinghkUpdateState {
+    /// need_stop 等待阶段的确认通道（前端调 confirm 命令时唤醒 apply 继续）
+    confirm_tx: Mutex<Option<oneshot::Sender<()>>>,
+    /// 取消标志 + 唤醒通道（前端调 cancel 命令时置位，apply 等待循环立即返回）
+    cancel_flag: AtomicBool,
+    cancel_tx: watch::Sender<bool>,
+    cancel_rx: watch::Receiver<bool>,
+}
+
+impl ThinghkUpdateState {
+    pub fn new() -> Self {
+        let (tx, rx) = watch::channel(false);
+        Self {
+            confirm_tx: Mutex::new(None),
+            cancel_flag: AtomicBool::new(false),
+            cancel_tx: tx,
+            cancel_rx: rx,
+        }
+    }
+
+    /// 前端已停止监控内核，唤醒 apply 继续解压替换
+    fn confirm(&self) {
+        if let Some(tx) = self.confirm_tx.lock().unwrap_or_else(|e| e.into_inner()).take() {
+            let _ = tx.send(());
+        }
+    }
+
+    /// 取消更新：置位取消标志并唤醒 apply 等待循环
+    fn cancel(&self) {
+        self.cancel_flag.store(true, Ordering::SeqCst);
+        let _ = self.cancel_tx.send(true);
+    }
+
+    /// 进入新的 apply 流程前复位取消标志
+    fn reset(&self) {
+        self.cancel_flag.store(false, Ordering::SeqCst);
+        let _ = self.cancel_tx.send(false);
+        *self.confirm_tx.lock().unwrap_or_else(|e| e.into_inner()) = None;
+    }
+}
+
 /// 发布仓库（Gitea）
 const GITEA_REPO: &str = "LFeng/Thing";
 const GITEA_BASE: &str = "https://gitea.atie.fun";
@@ -125,72 +172,8 @@ async fn fetch_latest_release() -> Result<LatestRelease, String> {
     })
 }
 
-// ---------- 下载 / 解压 ----------
-
-/// 下载文件到 dest，期间通过 UPDATE_PROGRESS 事件上报进度
-async fn download_with_progress(app: &AppHandle, url: &str, dest: &Path) -> Result<(), String> {
-    // 注意：reqwest 的 timeout 是"从连接到响应体读完"的总超时。大文件（如
-    // thing.exe 10+MB）在慢速网络下 30s 内读不完会被掐断流导致下载到一半失败
-    // （此前 bug：更新包总在 ~50% 处中断）。这里只限制连接建立 15s，
-    // 总超时放宽到 10 分钟兜底防止永久悬挂。
-    let client = reqwest::Client::builder()
-        .connect_timeout(std::time::Duration::from_secs(15))
-        .timeout(std::time::Duration::from_secs(600))
-        .build()
-        .map_err(|e| format!("创建 HTTP 客户端失败: {}", e))?;
-    let resp = client
-        .get(url)
-        .header("User-Agent", "thing-app")
-        .send()
-        .await
-        .map_err(|e| format!("下载请求失败: {}", e))?;
-    if !resp.status().is_success() {
-        return Err(format!("下载失败: HTTP {}", resp.status()));
-    }
-    let total = resp.content_length();
-    let mut stream = resp.bytes_stream();
-    let mut file = fs::File::create(dest).map_err(|e| format!("创建文件失败: {}", e))?;
-    let mut downloaded: u64 = 0;
-    let mut last_percent: u8 = 0;
-    while let Some(chunk) = stream.next().await {
-        let chunk = chunk.map_err(|e| format!("读取下载流失败: {}", e))?;
-        file.write_all(&chunk).map_err(|e| format!("写入文件失败: {}", e))?;
-        downloaded += chunk.len() as u64;
-        let percent = match total {
-            Some(t) if t > 0 => ((downloaded as f64 / t as f64) * 100.0) as u8,
-            _ => 0,
-        };
-        if percent >= last_percent + 1 {
-            last_percent = percent;
-            let _ = app.emit(
-                UPDATE_PROGRESS,
-                UpdateProgress {
-                    stage: "downloading".into(),
-                    percent,
-                    downloaded_bytes: downloaded,
-                    total_bytes: total,
-                    message: format!(
-                        "已下载 {:.2} MB / {:.2} MB",
-                        downloaded as f64 / 1024.0 / 1024.0,
-                        total.unwrap_or(0) as f64 / 1024.0 / 1024.0
-                    ),
-                },
-            );
-        }
-    }
-    file.flush().map_err(|e| format!("flush 失败: {}", e))?;
-    let _ = app.emit(
-        UPDATE_PROGRESS,
-        UpdateProgress {
-            stage: "downloaded".into(),
-            percent: 100,
-            downloaded_bytes: downloaded,
-            total_bytes: total,
-            message: "下载完成".into(),
-        },
-    );
-    Ok(())
-}
+// ---------- 解压 ----------
+// ThingHK 内核更新包由前端下载模块负责下载（同 mihomo），此处仅解压替换。
 
 /// 用 zip crate 解压（纯 Rust，避免 PowerShell 执行策略问题）
 fn extract_zip(zip_path: &Path, dest: &Path) -> Result<(), String> {
@@ -377,47 +360,72 @@ pub async fn update_install(app: AppHandle, downloaded_path: String) -> Result<(
     Ok(())
 }
 
-/// 更新 ThingHK 内核：下载 thing-hk_{v}.zip → 停止监控内核 → 覆盖内核文件
+/// 应用 ThingHK 内核更新：下载阶段已由下载模块完成，本命令仅做
+/// need_stop（等待前端停止监控内核并确认）→ 解压 → 替换。
+/// 进度通过 UPDATE_PROGRESS 事件上报，前端据 need_stop 弹出确认对话框。
 #[tauri::command]
 #[specta::specta]
-pub async fn update_thinghk(app: AppHandle) -> Result<(), String> {
-    let result = update_thinghk_inner(&app).await;
+pub async fn update_thinghk_apply(
+    app: AppHandle,
+    state: tauri::State<'_, ThinghkUpdateState>,
+    zip_path: String,
+) -> Result<(), String> {
+    state.reset();
+    let result = update_thinghk_apply_inner(&app, &state, PathBuf::from(&zip_path)).await;
     if let Err(ref e) = result {
-        // 失败时 emit error 阶段，避免前端进度卡在最后状态无提示
-        let _ = app.emit(
-            UPDATE_PROGRESS,
-            UpdateProgress {
-                stage: "error".into(),
-                percent: 0,
-                downloaded_bytes: 0,
-                total_bytes: None,
-                message: e.clone(),
-            },
-        );
+        // 取消是用户主动行为，静默返回即可；其余失败 emit error 阶段避免前端进度卡死
+        if e != THINGHK_UPDATE_CANCELLED {
+            let _ = app.emit(
+                UPDATE_PROGRESS,
+                UpdateProgress {
+                    stage: "error".into(),
+                    percent: 0,
+                    downloaded_bytes: 0,
+                    total_bytes: None,
+                    message: e.clone(),
+                },
+            );
+        }
     }
     result
 }
 
-async fn update_thinghk_inner(app: &AppHandle) -> Result<(), String> {
-    let latest = fetch_latest_release().await?;
-    let asset = latest
-        .assets
-        .iter()
-        .find(|a| a.name.starts_with("thing-hk_") && a.name.ends_with(".zip"))
-        .ok_or("未在 release 中找到 ThingHK 内核包".to_string())?;
-    // 停止监控内核（含提权模式的 /shutdown 兜底由前端先停模块），避免 exe 被占用
-    if let Some(monitor) = app.try_state::<crate::monitor_kernel::MonitorKernel>() {
-        monitor.stop_subscription(app).await;
+async fn update_thinghk_apply_inner(
+    app: &AppHandle,
+    state: &ThinghkUpdateState,
+    zip_path: PathBuf,
+) -> Result<(), String> {
+    if !zip_path.exists() {
+        return Err(format!("下载文件不存在: {}", zip_path.display()));
     }
-    if let Some(pm) = app.try_state::<crate::process_manager::ProcessManager>() {
-        let _ = pm.stop("monitor");
+
+    // need_stop：等待前端停止监控内核并确认（exe 被占用会导致覆盖失败）。
+    // 确认/取消由 confirm/cancel 命令跨命令唤醒（与 mihomo need_stop 同构）。
+    let _ = app.emit(
+        UPDATE_PROGRESS,
+        UpdateProgress {
+            stage: "need_stop".into(),
+            percent: 90,
+            downloaded_bytes: 0,
+            total_bytes: None,
+            message: "需要停止监控内核才能继续安装".into(),
+        },
+    );
+    let (tx, mut rx) = oneshot::channel::<()>();
+    *state.confirm_tx.lock().unwrap_or_else(|e| e.into_inner()) = Some(tx);
+    let mut cancel_rx = state.cancel_rx.clone();
+    loop {
+        if state.cancel_flag.load(Ordering::SeqCst) {
+            *state.confirm_tx.lock().unwrap_or_else(|e| e.into_inner()) = None;
+            return Err(THINGHK_UPDATE_CANCELLED.to_string());
+        }
+        tokio::select! {
+            _ = &mut rx => break,
+            _ = cancel_rx.changed() => {}
+        }
     }
-    // 等待进程退出释放文件句柄
-    tokio::time::sleep(std::time::Duration::from_millis(600)).await;
-    let temp_dir = std::env::temp_dir().join("thing-update");
-    fs::create_dir_all(&temp_dir).map_err(|e| format!("创建临时目录失败: {}", e))?;
-    let zip_path = temp_dir.join(&asset.name);
-    download_with_progress(app, &asset.browser_download_url, &zip_path).await?;
+
+    // 解压阶段
     let _ = app.emit(
         UPDATE_PROGRESS,
         UpdateProgress {
@@ -428,9 +436,11 @@ async fn update_thinghk_inner(app: &AppHandle) -> Result<(), String> {
             message: "正在解压内核...".into(),
         },
     );
+    let temp_dir = std::env::temp_dir().join("thing-update");
     let extract_dir = temp_dir.join("thinghk_extract");
     let _ = fs::remove_dir_all(&extract_dir);
     extract_zip(&zip_path, &extract_dir)?;
+
     // 在解压目录中查找 ThingHK.exe
     let exe_path = find_thinghk_exe(&extract_dir).ok_or("内核包中未找到 ThingHK.exe".to_string())?;
     let app_data = app
@@ -441,6 +451,7 @@ async fn update_thinghk_inner(app: &AppHandle) -> Result<(), String> {
     fs::create_dir_all(&cores_dir).map_err(|e| format!("创建内核目录失败: {}", e))?;
     fs::copy(&exe_path, cores_dir.join("ThingHK.exe"))
         .map_err(|e| format!("覆盖内核文件失败（请确认监控模块已停止）: {}", e))?;
+
     // 清理临时文件
     let _ = fs::remove_file(&zip_path);
     let _ = fs::remove_dir_all(&extract_dir);
@@ -457,6 +468,22 @@ async fn update_thinghk_inner(app: &AppHandle) -> Result<(), String> {
     Ok(())
 }
 
+/// 前端已停止监控内核，确认继续解压替换（唤醒 need_stop 等待）
+#[tauri::command]
+#[specta::specta]
+pub fn update_thinghk_confirm(state: tauri::State<'_, ThinghkUpdateState>) -> Result<(), String> {
+    state.confirm();
+    Ok(())
+}
+
+/// 取消 ThingHK 内核更新（need_stop 等待阶段有效：唤醒 apply 以「已取消」返回，zip 保留便于重试）
+#[tauri::command]
+#[specta::specta]
+pub fn update_thinghk_cancel(state: tauri::State<'_, ThinghkUpdateState>) -> Result<(), String> {
+    state.cancel();
+    Ok(())
+}
+
 fn find_thinghk_exe(dir: &Path) -> Option<PathBuf> {
     if let Ok(entries) = fs::read_dir(dir) {
         for entry in entries.flatten() {

src-tauri/tauri.conf.json

@@ -1,11 +1,11 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "thing",
-  "version": "26.8.4",
+  "version": "26.8.5",
   "identifier": "thing.lfeng.me",
   "build": {
     "beforeDevCommand": "bun run dev",
-    "devUrl": "http://localhost:1420",
+    "devUrl": "http://localhost:14210",
     "beforeBuildCommand": "bun run build",
     "frontendDist": "../dist"
   },

src/App.vue

@@ -263,6 +263,8 @@ onMounted(async () => {
   )
   // 截图导出监听（应用级常驻，确保任何来源的截图都记录到历史）
   screenshotStore.initExportListener().catch(e => console.error('[screenshot] 导出监听初始化失败:', e))
+  // 滚动截图完成 → 进编辑器（应用级常驻）
+  screenshotStore.initScrollEditorListener().catch(e => console.error('[screenshot] 滚动进编辑器监听初始化失败:', e))
 })
 
 const trayUnlisteners: UnlistenFn[] = []

src/lib/bindings.ts

@@ -16,8 +16,16 @@ export const commands = {
 	 *  调用返回前会触发应用退出。
 	 */
 	updateInstall: (downloadedPath: string) => __TAURI_INVOKE<null>("update_install", { downloadedPath }),
-	/**  更新 ThingHK 内核：下载 thing-hk_{v}.zip → 停止监控内核 → 覆盖内核文件 */
-	updateThinghk: () => __TAURI_INVOKE<null>("update_thinghk"),
+	/**
+	 *  应用 ThingHK 内核更新：下载阶段已由下载模块完成，本命令仅做
+	 *  need_stop（等待前端停止监控内核并确认）→ 解压 → 替换。
+	 *  进度通过 UPDATE_PROGRESS 事件上报，前端据 need_stop 弹出确认对话框。
+	 */
+	updateThinghkApply: (zipPath: string) => __TAURI_INVOKE<null>("update_thinghk_apply", { zipPath }),
+	/**  前端已停止监控内核，确认继续解压替换（唤醒 need_stop 等待） */
+	updateThinghkConfirm: () => __TAURI_INVOKE<null>("update_thinghk_confirm"),
+	/**  取消 ThingHK 内核更新（need_stop 等待阶段有效：唤醒 apply 以「已取消」返回，zip 保留便于重试） */
+	updateThinghkCancel: () => __TAURI_INVOKE<null>("update_thinghk_cancel"),
 	proxyActivateProfile: (id: string) => __TAURI_INVOKE<null>("proxy_activate_profile", { id }),
 	/**  应用内核更新：下载阶段已由下载模块完成，本方法仅做 need_stop → 解压 → 替换。 */
 	proxyApplyKernelUpdate: (zipPath: string) => __TAURI_INVOKE<KernelInfo>("proxy_apply_kernel_update", { zipPath }),
@@ -110,6 +118,10 @@ export const commands = {
 	/**
 	 *  运行系统命令（不设置 CREATE_NO_WINDOW，使 cmd/powershell/regedit 等显示自身窗口）
 	 *  适用于内置系统工具：regedit、shutdown、cmd、powershell、taskmgr 等。
+	 *  - 控制台类交互程序（cmd/powershell/pwsh）额外设置 CREATE_NEW_CONSOLE，
+	 *    否则从 GUI 宿主启动时无可见控制台窗口（表现为"点击没反应"）。
+	 *  - .msc 控制台文件（如 devmgmt.msc）不可被 CreateProcess 直接执行，
+	 *    改由 mmc 打开（路径解析到 System32，不受当前工作目录影响）。
 	 */
 	quickpanelRunSystemCommand: (command: string, args: string[]) => __TAURI_INVOKE<null>("quickpanel_run_system_command", { command, args }),
 	/**  列出目录下的压缩包文件（供批量解压面板使用）。 */
@@ -268,10 +280,31 @@ export const commands = {
 	screenshotEnumWindows: () => __TAURI_INVOKE<WindowInfo[]>("screenshot_enum_windows"),
 	/**  按 hwnd 捕获指定窗口 */
 	screenshotCaptureWindow: (hwnd: number) => __TAURI_INVOKE<CaptureData>("screenshot_capture_window", { hwnd }),
-	/**  存入编辑器图片（base64 PNG） */
-	screenshotSetEditorImage: (pngBase64: string) => __TAURI_INVOKE<null>("screenshot_set_editor_image", { pngBase64 }),
-	/**  取出编辑器图片（编辑器窗口加载时调用，取出即清除） */
-	screenshotGetEditorImage: () => __TAURI_INVOKE<string | null>("screenshot_get_editor_image"),
+	/**
+	 *  滚动截图：从窗口当前滚动位置向下拼接到底部，返回超长 PNG。
+	 *  `region` 为 Some 时仅在框选区域（屏幕物理坐标）内捕捉，宽 = 选区宽；
+	 *  为 None 时捕捉整个客户区。结束后会把窗口滚回起始位置，不打扰用户。
+	 */
+	screenshotScrollCapture: (hwnd: number, region: {
+	x: number,
+	y: number,
+	width: number,
+	height: number,
+} | null) => __TAURI_INVOKE<CaptureData>("screenshot_scroll_capture", { hwnd, region }),
+	/**  取消滚动截图会话（不导出）。 */
+	screenshotScrollCancel: () => __TAURI_INVOKE<null>("screenshot_scroll_cancel"),
+	/**  结束滚动截图会话并导出结果。 */
+	screenshotScrollFinish: () => __TAURI_INVOKE<null>("screenshot_scroll_finish"),
+	/**
+	 *  启动滚动截图会话（后台线程持续捕捉拼接，实时推进度事件）。
+	 *  `auto = true` 为自动滚动（线程主动下滚拼到底部）；`false` 为手动（等用户滚动窗口）。
+	 */
+	screenshotScrollStart: (hwnd: number, region: {
+	x: number,
+	y: number,
+	width: number,
+	height: number,
+} | null, auto: boolean) => __TAURI_INVOKE<null>("screenshot_scroll_start", { hwnd, region, auto }),
 	/**  将 PNG base64 写入系统剪贴板（转 CF_DIB） */
 	screenshotCopyImage: (pngBase64: string) => __TAURI_INVOKE<null>("screenshot_copy_image", { pngBase64 }),
 	/**  将 PNG base64 写入文件 */
@@ -622,6 +655,14 @@ export type ScreenRect = {
 	height: number,
 };
 
+/**  滚动截图区域（屏幕物理像素坐标，通常为覆盖层框选区平移到屏幕） */
+export type ScrollRegion = {
+	x: number,
+	y: number,
+	width: number,
+	height: number,
+};
+
 /**  下载分段（多线程 Range 下载 / 断点续传用） */
 export type Segment = {
 	/**  分段索引 */

src/lib/constants.ts

@@ -10,6 +10,10 @@ export const WINDOWS = {
   osdOverlay: 'osd-overlay',
   screenshotOverlay: 'screenshot-overlay',
   screenshotPin: 'screenshot-pin',
+  /** 常驻截图编辑器窗口（隐藏复用，打开只 show 不重建 WebView） */
+  screenshotEditor: 'screenshot-editor',
+  /** 滚动截图控制窗 */
+  screenshotScroll: 'screenshot-scroll',
   /** 单文件一次性下载窗口前缀，实际 label = `${downloadWindow}-<taskId>` */
   downloadWindow: 'download-window',
 } as const
@@ -46,6 +50,18 @@ export const EVENTS = {
   screenshotPinReady: 'screenshot-pin-ready',
   screenshotPinShow: 'screenshot-pin-show',
   screenshotExported: 'screenshot-exported',
+  /** 滚动截图会话：实时进度 { width, height, auto } */
+  scrollProgress: 'screenshot-scroll-progress',
+  /** 滚动截图会话：完成并导出（Rust 已把 PNG 原始字节写入编辑器图片槽，事件只带 { width, height }） */
+  scrollComplete: 'screenshot-scroll-complete',
+  /** 滚动截图会话：已取消 */
+  scrollCancelled: 'screenshot-scroll-cancelled',
+  /** 滚动截图完成：打开截图编辑器（编辑/裁剪后保存才进历史） */
+  scrollToEditor: 'screenshot-scroll-to-editor',
+  /** 常驻编辑器窗口挂载完成（store 等待后下发加载事件） */
+  screenshotEditorReady: 'screenshot-editor-ready',
+  /** 通知常驻编辑器窗口加载编辑器图片槽中的新图（raw IPC 取出） */
+  screenshotEditorLoad: 'screenshot-editor-load',
   // 内核安装进度
   kernelInstallProgress: 'kernel-install-progress',
   // 后端自动切换节点完成（后台执行，刷新节点列表并提示）
@@ -61,6 +77,10 @@ export const EVENTS = {
   osdContentSize: 'osd-content-size',
   osdSystemUiActive: 'osd-system-ui-active',
   osdSystemUiInactive: 'osd-system-ui-inactive',
+  /** 前台出现全屏应用（游戏）：OSD 应隐藏以避免游戏掉帧 */
+  osdGameActive: 'osd-game-active',
+  /** 全屏应用退出前台：OSD 可恢复显示 */
+  osdGameInactive: 'osd-game-inactive',
   osdStartDrag: 'osd-start-drag',
   osdEndDrag: 'osd-end-drag',
   monitorReady: 'monitor-ready',

src/main.ts

@@ -9,8 +9,14 @@ const logger = createLogger('main')
 // 禁用 WebView 默认右键菜单（桌面应用体验，主窗口与独立窗口共用）
 document.addEventListener('contextmenu', (e) => e.preventDefault())
 
+// 良性通知过滤：ResizeObserver 回调引发的布局变化在同一帧内级联时，
+// 浏览器会派发此 ErrorEvent（规范定义为"通知"而非异常，无可操作信息）。
+// 监控数据每秒刷新、reka-ui 组件挂载时高发，直接忽略避免污染日志。
+const BENIGN_RESIZE_OBSERVER_RE = /^ResizeObserver loop (completed with undelivered notifications|limit exceeded)/i
+
 // 全局未捕获异常日志
 window.addEventListener('error', (event) => {
+  if (event.message && BENIGN_RESIZE_OBSERVER_RE.test(event.message)) return
   logger.error(`全局JS错误: ${event.message} @ ${event.filename}:${event.lineno}`)
 })
 
@@ -31,6 +37,7 @@ const standaloneWindowApps: Array<[hash: string, label: string, loader: () => Pr
   ['#screenshot-overlay', '截图覆盖层', () => import('./modules/screenshot/ScreenshotOverlay.vue')],
   ['#screenshot-editor', '截图编辑器', () => import('./modules/screenshot/ScreenshotEditor.vue')],
   ['#screenshot-pin', '贴图窗口', () => import('./modules/screenshot/ScreenshotPin.vue')],
+  ['#screenshot-scroll', '滚动截图', () => import('./modules/screenshot/ScrollControl.vue')],
   ['#download-window', '下载窗口', () => import('./modules/downloader/DownloadWindow.vue')],
 ]
 
@@ -38,7 +45,12 @@ const winHash = window.location.hash
 
 // #screenshot-overlay 带窗口号参数（多屏）、#download-window 带 ?task= 参数，按前缀匹配；其余精确匹配
 const matched = standaloneWindowApps.find(([hash]) => {
-  if (hash === '#screenshot-overlay' || hash === '#download-window') return winHash.startsWith(hash)
+  if (
+    hash === '#screenshot-overlay' ||
+    hash === '#screenshot-scroll' ||
+    hash === '#download-window'
+  )
+    return winHash.startsWith(hash)
   return winHash === hash
 })
 

src/modules/clipboard/ClipboardModule.vue

@@ -7,7 +7,6 @@ import {
 import { toast } from 'vue-sonner'
 import { useClipboardStore, type ClipboardItem, type ClipboardKind, type ClipboardItemDetail } from '@/stores/clipboardStore'
 import { useModuleTabs } from '@/lib/use-module-tabs'
-import { useModuleTabsStore } from '@/stores/moduleTabsStore'
 import { Tabs, TabsList, TabsTrigger, TabsContent } from '@/components/ui/tabs'
 import { ScrollArea } from '@/components/ui/scroll-area'
 import { Card, CardContent } from '@/components/ui/card'
@@ -34,7 +33,6 @@ import {
 const store = useClipboardStore()
 
 const activeTab = ref('history')
-const tabsStore = useModuleTabsStore()
 const tabsListRef = useModuleTabs('clipboard', activeTab, [
   { value: 'history', label: '历史' },
   { value: 'pinned', label: '固定' },
@@ -115,29 +113,35 @@ const handleEnabledToggle = async (val: boolean) => {
   form.value.enabled = val
   try {
     await store.saveSettings({ ...form.value })
-    toast.success(val ? '已开启剪贴板监听' : '已停止剪贴板监听')
   } catch {
     toast.error('切换监听失败')
   }
 }
 
-const handleSaveSettings = async () => {
+// 即改即生效：其余设置改动防抖自动保存（成功不提示，失败才提示）。
+// 用值与生效值是否相同来短路，避免 store round-trip 触发同步 watch 造成无限循环。
+let saveFormTimer = 0
+const persistSettingsForm = async () => {
+  if (JSON.stringify(form.value) === JSON.stringify(store.settings)) return
   try {
     await store.saveSettings({ ...form.value })
-    toast.success('设置已保存')
   } catch {
     toast.error('保存设置失败')
   }
 }
-
-// 注册保存处理函数到标签栏 store（TitleBar 保存按钮调用）
-tabsStore.registerSave(handleSaveSettings)
+watch(
+  form,
+  () => {
+    window.clearTimeout(saveFormTimer)
+    saveFormTimer = window.setTimeout(persistSettingsForm, 400)
+  },
+  { deep: true }
+)
 
 const handleShortcutChange = async () => {
-  // 快捷键变化立即保存并注册（不等点击"保存设置"）
+  // 快捷键变化立即保存并注册（快捷键显示本身已反映新值）
   try {
     await store.saveSettings({ ...form.value })
-    toast.success(`快捷键已更新为 ${form.value.shortcut || '（已禁用）'}`)
   } catch {
     toast.error('快捷键注册失败，可能被其他程序占用')
   }

src/modules/downloader/DownloaderModule.vue

@@ -14,7 +14,6 @@ import { open as openDialog } from '@tauri-apps/plugin-dialog'
 import { commands } from '@/lib/bindings'
 import { useDownloaderStore, type DownloadTask, type DownloaderSettings, type TaskStatus, type CheckUrlResult } from '@/stores/downloaderStore'
 import { useModuleTabs } from '@/lib/use-module-tabs'
-import { useModuleTabsStore } from '@/stores/moduleTabsStore'
 import { createLogger } from '@/lib/logger'
 import { pendingNewDownload, pendingShowDownloadTasks } from '@/lib/trayEvents'
 import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
@@ -44,7 +43,7 @@ const logger = createLogger('downloader')
 
 // ===== 主 Tab 状态 =====
 const activeTab = ref('tasks')
-const tabsStore = useModuleTabsStore()
+
 const tabsListRef = useModuleTabs('downloader', activeTab, [
   { value: 'tasks', label: '下载任务' },
   { value: 'settings', label: '设置' },
@@ -175,9 +174,9 @@ const showSecret = ref(false)
 // 下载设置快捷弹窗（任务页工具栏入口）
 const downloadSettingsOpen = ref(false)
 
-// ===== 设置草案 =====
-// 设置页/快捷弹窗编辑的是本地草案，点击"保存"才写入 store.settings（生效值）并持久化；
-// 避免未保存的编辑污染全应用读取的生效值（主页代理开关、添加任务默认值等）
+// ===== 设置草案（即改即生效） =====
+// 设置页/快捷弹窗编辑的是本地草案，任一处改动后防抖自动保存，无需手动"保存"；
+// store.settings 为全应用读取的生效值（主页代理开关、添加任务默认值等）
 const settingsDraft = ref<DownloaderSettings | null>(null)
 watch(
   () => store.settings,
@@ -187,6 +186,27 @@ watch(
   { immediate: true, deep: true }
 )
 
+// 防抖自动保存：改动后延迟写入 store 并持久化；成功不提示，失败才 toast。
+// 用值与生效值是否相同来短路，避免 store round-trip 触发上面的同步 watch 造成无限循环。
+let saveDraftTimer = 0
+const persistSettingsDraft = async () => {
+  if (!settingsDraft.value || !store.settings) return
+  if (JSON.stringify(settingsDraft.value) === JSON.stringify(store.settings)) return
+  try {
+    await store.saveSettings({ ...settingsDraft.value })
+  } catch (e) {
+    toast.error('保存设置失败', { description: String(e) })
+  }
+}
+watch(
+  settingsDraft,
+  () => {
+    window.clearTimeout(saveDraftTimer)
+    saveDraftTimer = window.setTimeout(persistSettingsDraft, 400)
+  },
+  { deep: true }
+)
+
 // ===== 任务列表：筛选 / 排序 / 搜索 / 分页 =====
 type StatusFilter = 'all' | TaskStatus
 type SortField = 'id' | 'name' | 'size'
@@ -486,24 +506,19 @@ const handleAddDownload = async () => {
   const dir = addDir.value.trim()
   addingTask.value = true
   try {
-    // HTTP 链接走原流程（含重复检查）
+    // HTTP 链接：立即添加（后端先建占位任务返回，探测/分段/调度在后台进行，
+    // 不会卡在慢速探测上；重复 URL 由后端去重，多次点击也不会堆积重复任务）
     if (httpUris.length > 0) {
-      const checkEnabled = store.settings?.checkDuplicate ?? true
-      if (checkEnabled) {
-        duplicateSuccessCount.value = 0
-        processUrlsWithCheck(httpUris, dir || undefined)
-      } else {
-        let successCount = 0
-        for (const uri of httpUris) {
-          try {
-            await store.addTask(uri, undefined, dir || undefined, undefined, true)
-            successCount++
-          } catch (e) {
-            logger.error(`添加 ${uri} 失败: ` + e)
-          }
+      let successCount = 0
+      for (const uri of httpUris) {
+        try {
+          await store.addTask(uri, undefined, dir || undefined, undefined, true)
+          successCount++
+        } catch (e) {
+          logger.error(`添加 ${uri} 失败: ` + e)
         }
-        if (successCount > 0) finishAdd(successCount)
       }
+      if (successCount > 0) finishAdd(successCount)
     }
 
     // BT 链接：异步添加（立即返回，不卡在元数据解析）。后台解析，成功后弹文件勾选。
@@ -711,48 +726,26 @@ const handleSelectSettingsDir = async () => {
   try {
     const selected = await openDialog({ directory: true, multiple: false })
     if (typeof selected === 'string' && settingsDraft.value) {
-      await store.saveSettings({ ...settingsDraft.value, downloadDir: selected })
-      toast.success('下载目录已更新')
+      settingsDraft.value.downloadDir = selected
     }
   } catch (e) {
     toast.error('选择目录失败: ' + e)
   }
 }
 
-// ===== 设置保存 =====
-const handleSaveSettings = async (): Promise<boolean> => {
-  if (!settingsDraft.value) return false
-  try {
-    await store.saveSettings({ ...settingsDraft.value })
-    toast.success('设置已保存')
-    return true
-  } catch (e) {
-    toast.error('保存失败: ' + e)
-    return false
-  }
-}
-
 /** 切换代理开关并立即保存（新任务/探测立即生效，正在下载的任务不受影响） */
 const toggleProxy = async () => {
   if (!store.settings) return
   const next = !store.settings.useProxy
   try {
     await store.saveSettings({ ...store.settings, useProxy: next })
-    toast.success(next ? '已启用系统代理下载' : '已切换为直连下载')
+    // 同步草稿，使工具栏与设置页开关状态一致
+    if (settingsDraft.value) settingsDraft.value.useProxy = next
   } catch (e) {
     toast.error('切换失败: ' + e)
   }
 }
 
-// 注册保存处理函数到标签栏 store（TitleBar 保存按钮调用）
-tabsStore.registerSave(handleSaveSettings)
-
-// Dialog 保存：成功后关闭弹窗
-const handleDialogSave = async () => {
-  const ok = await handleSaveSettings()
-  if (ok) downloadSettingsOpen.value = false
-}
-
 // ===== 扩展 =====
 // Thing Extension 已发布到 Microsoft Edge 加载项商店，暂定优先 Edge；后续如需支持 Chrome 商店再补充入口
 const EXTENSION_STORE_URL = 'https://microsoftedge.microsoft.com/addons/detail/thing-extension/fpcffdkeemoibkhldghjbkgbgbdpofbo'
@@ -1045,7 +1038,7 @@ const toggleSortOrder = () => {
                 </Button>
               </TooltipTrigger>
               <TooltipContent>
-                {{ store.settings?.useProxy ? '使用系统代理（mihomo 开启系统代理时经其转发）' : '直连模式' }}
+                {{ store.settings?.useProxy ? '使用 mihomo 代理（本地端口）' : '直连模式' }}
               </TooltipContent>
             </Tooltip>
 
@@ -1392,13 +1385,13 @@ const toggleSortOrder = () => {
                 </div>
                 <div class="flex items-center justify-between">
                   <div class="flex flex-col gap-0.5">
-                    <Label for="dl-use-proxy" class="cursor-pointer">使用系统代理</Label>
-                    <span class="text-xs text-muted-foreground">下载时尊重系统代理设置（mihomo 开启系统代理时经其转发），关闭则强制直连</span>
+                    <Label for="dl-use-proxy" class="cursor-pointer">使用 mihomo 代理</Label>
+                    <span class="text-xs text-muted-foreground">下载时经本地 mihomo 代理（127.0.0.1:端口）转发，mihomo 未运行时自动直连；关闭则强制直连</span>
                   </div>
                   <Switch
                     id="dl-use-proxy"
-                    :model-value="settingsDraft?.useProxy ?? true"
-                    @update:model-value="(v: boolean) => settingsDraft && (settingsDraft.useProxy = v)"
+                    :model-value="store.settings?.useProxy ?? true"
+                    @update:model-value="() => toggleProxy()"
                   />
                 </div>
               </CardContent>
@@ -1435,14 +1428,9 @@ const toggleSortOrder = () => {
                 </div>
                 <div class="flex items-center justify-between">
                   <div class="flex flex-col gap-0.5">
-                    <Label for="bt-proxy" class="cursor-pointer">使用代理下载</Label>
-                    <span class="text-xs text-muted-foreground">开启后自动使用代理模块（mihomo）的 SOCKS5 端口；代理不可用时自动降级为直连</span>
+                    <Label class="cursor-pointer">使用代理下载</Label>
+                    <span class="text-xs text-muted-foreground">BT 下载是否走代理跟随上方"使用 mihomo 代理"开关：开启时自动使用 mihomo 的 SOCKS5 端口，代理不可用时自动降级为直连</span>
                   </div>
-                  <Switch
-                    id="bt-proxy"
-                    :model-value="settingsDraft?.btUseProxy ?? false"
-                    @update:model-value="(v: boolean) => settingsDraft && (settingsDraft.btUseProxy = v)"
-                  />
                 </div>
                 <div class="flex items-center justify-between">
                   <div class="flex flex-col gap-0.5">
@@ -1718,16 +1706,16 @@ const toggleSortOrder = () => {
             />
           </div>
 
-          <!-- 使用系统代理 -->
+          <!-- 使用 mihomo 代理 -->
           <div class="flex items-center justify-between">
             <div class="flex flex-col gap-0.5">
-              <Label for="dl-dialog-use-proxy" class="cursor-pointer">使用系统代理</Label>
+              <Label for="dl-dialog-use-proxy" class="cursor-pointer">使用 mihomo 代理</Label>
               <span class="text-xs text-muted-foreground">关闭则强制直连</span>
             </div>
             <Switch
               id="dl-dialog-use-proxy"
-              :model-value="settingsDraft.useProxy"
-              @update:model-value="(v: boolean) => settingsDraft && (settingsDraft.useProxy = v)"
+              :model-value="store.settings?.useProxy ?? true"
+              @update:model-value="() => toggleProxy()"
             />
           </div>
 
@@ -1747,12 +1735,8 @@ const toggleSortOrder = () => {
 
         <DialogFooter>
           <DialogClose as-child>
-            <Button variant="outline">取消</Button>
+            <Button variant="outline">关闭</Button>
           </DialogClose>
-          <Button @click="handleDialogSave">
-            <Check class="size-4" />
-            保存
-          </Button>
         </DialogFooter>
       </DialogContent>
     </Dialog>

src/modules/monitor/MonitorModule.vue

@@ -6,7 +6,7 @@ import {
   ArrowDown, ArrowUp, Wifi, FolderOpen, Copy, ListChecks,
   Monitor as MonitorIcon, GripVertical, SlidersHorizontal,
   Eye, EyeOff, MousePointerClick, Plus, PencilLine,
-  CircuitBoard, BatteryFull,
+  CircuitBoard, BatteryFull, Gamepad2,
 } from '@lucide/vue'
 import type { LucideIcon } from '@lucide/vue'
 import { computed, onMounted, onUnmounted, ref, watch } from 'vue'
@@ -14,6 +14,7 @@ import { toast } from 'vue-sonner'
 import { VueDraggable } from 'vue-draggable-plus'
 import { appDataDir } from '@tauri-apps/api/path'
 import { revealItemInDir } from '@tauri-apps/plugin-opener'
+import { invoke } from '@tauri-apps/api/core'
 import {
   useMonitorStore,
   type SensorEntry,
@@ -436,6 +437,31 @@ async function handleRefresh() {
   }
 }
 
+/** 检测并修复 PawnIO 驱动：安装缺失驱动并重启监控内核 */
+const repairingPawnio = ref(false)
+async function handleRepairPawnio() {
+  repairingPawnio.value = true
+  try {
+    const r = await invoke<{ installed: boolean; needReboot: boolean }>('monitor_repair_pawnio')
+    if (r.needReboot) {
+      toast.info('PawnIO 驱动已安装，需重启电脑后生效')
+    } else if (r.installed) {
+      toast.success('PawnIO 驱动已修复，监控内核已重启')
+    } else {
+      toast.error('PawnIO 驱动安装未完成', {
+        description: '请以管理员/提权方式运行 Thing 后重试',
+      })
+    }
+    store.pawnIoMissing = false
+    await store.refreshStatus()
+    await store.fetchSnapshot()
+  } catch (e) {
+    toast.error('修复 PawnIO 失败', { description: String(e) })
+  } finally {
+    repairingPawnio.value = false
+  }
+}
+
 /** 提权：以管理员权限重启 Thing 自身，并持久化标志使后续启动自动提权。
  *  Thing 以管理员权限运行时，ThingHK 子进程继承权限，ProcessManager 可直接管控，
  *  ThingHK 崩溃会自动重启，避免数据停止后 Thing 不感知。
@@ -535,8 +561,6 @@ async function handleSaveConfig() {
             description: '主板/存储等硬件需提权才能读取完整数据，建议提权',
             duration: 6000,
           })
-        } else {
-          toast.success('配置已保存', { description: '正在重启 Kernel...' })
         }
 
         // 自动重启 Kernel 以应用硬件开关变更
@@ -554,7 +578,6 @@ async function handleSaveConfig() {
           }
         }
       } else {
-        toast.success('配置已保存', { description: '传感器类型过滤已热生效' })
         configDialogOpen.value = false
         // 热更新后立即拉取新快照以反映传感器类型过滤变化
         await store.fetchSnapshot()
@@ -1091,7 +1114,6 @@ function confirmOsdPick() {
   osdConfig.value.overlayItems = newItems
   saveOsdConfig(osdConfig.value)
   osdPickDialogOpen.value = false
-  toast.success('悬浮窗显示项已更新')
 }
 
 /** 拖动排序结束回调 */
@@ -1230,7 +1252,6 @@ function saveColorTheme() {
   osdConfig.value.colorTheme = editingColorTheme.value
   saveOsdConfig(osdConfig.value)
   colorThemeDialogOpen.value = false
-  toast.success('颜色主题已保存')
 }
 
 function resetColorTheme() {
@@ -1432,6 +1453,19 @@ watch(() => store.status?.ready, (ready, prev) => {
               </CardContent>
             </Card>
 
+            <!-- PawnIO 驱动缺失提示（提权但驱动未装 → CPU 温度/功耗无法读取） -->
+            <Card v-if="store.pawnIoMissing" class="py-0 gap-0 mb-2.5 !border-amber-500/40 bg-amber-500/10">
+              <CardContent class="px-3.5 py-2 flex flex-wrap items-center gap-2 text-xs text-amber-600 dark:text-amber-400">
+                <AlertTriangle class="size-4 shrink-0" />
+                <span class="flex-1 min-w-[200px]">检测到 PawnIO 驱动未安装，CPU 温度/功耗可能无法读取（误卸载过 PawnIO 等情况会触发）。点击下方按钮自动安装并重启监控内核。</span>
+                <Button size="xs" variant="outline" class="shrink-0 text-amber-600 dark:text-amber-400 border-amber-500/40 hover:bg-amber-500/10" :disabled="store.starting || store.stopping || repairingPawnio" @click="handleRepairPawnio">
+                  <Loader2 v-if="repairingPawnio" class="size-3 mr-1 animate-spin" />
+                  <RefreshCw v-else class="size-3 mr-1" />
+                  {{ repairingPawnio ? '修复中...' : '检测并修复' }}
+                </Button>
+              </CardContent>
+            </Card>
+
             <!-- ===== 硬件信息卡片网格（模板化，可编辑：拖拽排序 / 删除 / 添加） ===== -->
             <VueDraggable
               v-model="overviewCards"
@@ -2156,6 +2190,20 @@ watch(() => store.status?.ready, (ready, prev) => {
                       @update:model-value="updateOsdConfig('clickThrough', Boolean($event))"
                     />
                   </div>
+                  <!-- 游戏全屏自动隐藏 -->
+                  <div class="flex items-center justify-between">
+                    <div class="flex flex-col gap-0.5">
+                      <Label class="text-sm flex items-center gap-1.5 cursor-pointer">
+                        <Gamepad2 class="size-3.5 text-muted-foreground" />
+                        游戏全屏时自动隐藏
+                      </Label>
+                      <span class="text-[11px] text-muted-foreground">检测到全屏应用（游戏）前台时隐藏悬浮窗，退出后自动恢复，避免游戏掉帧</span>
+                    </div>
+                    <Switch
+                      :model-value="osdConfig.gameAutoHide"
+                      @update:model-value="updateOsdConfig('gameAutoHide', Boolean($event))"
+                    />
+                  </div>
                 </div>
 
                 <Separator />

src/modules/monitor/OsdWindow.vue

@@ -512,6 +512,13 @@ onMounted(async () => {
     console.error('[OSD] 启动置顶监视失败:', e)
   }
 
+  // 启动游戏全屏监视（前台全屏应用时通知主窗口隐藏 OSD，避免游戏掉帧）
+  try {
+    await invoke('osd_start_game_watch')
+  } catch (e) {
+    console.error('[OSD] 启动游戏全屏监视失败:', e)
+  }
+
   // 监听主窗口推送的 OSD 配置（低频通道）
   unlistenFns.push(await listen<OsdStatePayload>(EVENTS.osdStateUpdate, (e) => {
     config.value = e.payload.config

src/modules/proxy/ProxyModule.vue

@@ -13,7 +13,6 @@ import { appDataDir } from '@tauri-apps/api/path'
 import { revealItemInDir } from '@tauri-apps/plugin-opener'
 import { useProxyStore, type ProxyNode, type ProxyConnection } from '@/stores/proxyStore'
 import { useModuleTabs } from '@/lib/use-module-tabs'
-import { useModuleTabsStore } from '@/stores/moduleTabsStore'
 import { createLogger } from '@/lib/logger'
 import { EVENTS } from '@/lib/constants'
 import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
@@ -82,7 +81,6 @@ const onConfirmOpenChange = (open: boolean) => {
 
 const activeTab = ref('overview')
 // 浮动标签切换器：注册到 TitleBar，滚动遮挡时自动显示
-const tabsStore = useModuleTabsStore()
 const tabsListRef = useModuleTabs('proxy', activeTab, [
   { value: 'overview', label: '概览' },
   { value: 'connections', label: '连接' },
@@ -593,7 +591,6 @@ const handleStart = async () => {
       toast.error('mihomo 启动超时，API 无响应')
       return
     }
-    toast.success('mihomo 已启动')
     await store.refreshVersion()
     await loadProxiesWithError()
   } catch (e) {
@@ -607,7 +604,6 @@ const handleStop = async () => {
   stopping.value = true
   try {
     await store.stop()
-    toast.success('mihomo 已停止')
   } catch (e) {
     toast.error('停止失败', { description: String(e) })
   } finally {
@@ -624,7 +620,6 @@ const handleRestart = async () => {
       toast.error('mihomo 重启超时，API 无响应')
       return
     }
-    toast.success('mihomo 已重启')
     await store.refreshVersion()
     await loadProxiesWithError()
   } catch (e) {
@@ -645,7 +640,6 @@ const onToggleSystemProxy = async (on: boolean) => {
   sysProxyLoading.value = true
   try {
     await store.toggleSystemProxy(on)
-    toast.success(on ? '系统代理已开启' : '系统代理已关闭')
   } catch (e) {
     toast.error('操作失败', { description: String(e) })
   } finally {
@@ -666,7 +660,6 @@ const changeMode = async (mode: string) => {
     if (running.value) {
       await invokePatchConfigs({ mode })
     }
-    toast.success(`已切换为${modeOptions.find(m => m.value === mode)?.label}模式`)
   } catch (e) {
     if (store.settings) store.settings.mode = prev
     toast.error('模式切换失败', { description: String(e) })
@@ -678,7 +671,6 @@ const quickSwitchNode = async (name: string) => {
   if (!mainGroupName.value) return
   try {
     await store.selectProxy(mainGroupName.value, name)
-    toast.success('节点已切换', { description: name })
     // 测速新节点：用 testDelayBatch 以更新 history，保证节点 Badge 显示与结果一致
     store.testDelayBatch([name]).then(() => {
       const delay = store.proxies[name]?.history?.[0]?.delay
@@ -694,13 +686,6 @@ const quickSwitchNode = async (name: string) => {
 // ===== 自动切换节点（执行由后端调度，前端仅负责维护设置并刷新/提示） =====
 const onToggleAutoSwitch = (on: boolean) => {
   autoSwitchEnabled.value = on
-  if (on) {
-    toast.success('自动切换已开启', {
-      description: `每 ${autoSwitchInterval.value} 分钟测试并切换至最优节点`
-    })
-  } else {
-    toast.info('自动切换已关闭')
-  }
   saveAutoSwitchSettings()
 }
 
@@ -1117,8 +1102,6 @@ const saveSettingsForm = async () => {
       localSettings.value.secret !== prev.secret
     if (networkChanged && running.value) {
       toast.warning('端口/接口/密钥已保存，重启 mihomo 后生效（期间代理 API 使用新地址可能暂时不可用）')
-    } else {
-      toast.success('设置已保存')
     }
 
     // 纯模式变更（网络字段未变）在运行中即时生效，与概览页行为一致，
@@ -1136,8 +1119,32 @@ const saveSettingsForm = async () => {
   }
 }
 
-// 注册保存处理函数到标签栏 store（TitleBar 保存按钮调用）
-tabsStore.registerSave(saveSettingsForm)
+// 即改即生效：设置改动防抖自动保存（成功不提示，失败才提示）。
+// 用局部字段投影对比，避免 store round-trip 触发 syncLocalSettings 造成循环保存。
+const localMatchesStore = () => {
+  const s = store.settings
+  if (!s) return false
+  return JSON.stringify(localSettings.value) === JSON.stringify({
+    mixedPort: s.mixedPort,
+    externalController: s.externalController,
+    secret: s.secret,
+    mode: s.mode,
+    logLevel: s.logLevel,
+    allowLan: s.allowLan,
+    autoStart: s.autoStart,
+    autoSystemProxy: s.autoSystemProxy,
+  })
+}
+let saveLocalTimer = 0
+watch(
+  localSettings,
+  () => {
+    if (localMatchesStore()) return
+    window.clearTimeout(saveLocalTimer)
+    saveLocalTimer = window.setTimeout(() => void saveSettingsForm(), 400)
+  },
+  { deep: true }
+)
 </script>
 
 <template>

src/modules/quickpanel/QuickPanel.vue

@@ -5,11 +5,10 @@ import { getCurrentWindow, LogicalSize, Effect, EffectState } from '@tauri-apps/
 // Rust 端通过 tauri-specta 生成的命令绑定（bindings.ts）
 import { commands } from '@/lib/bindings'
 import type { ArchiveInfo, DeleteResult, ExtractResult, FileEntry, RenamePreview, RenameResult } from '@/lib/bindings'
-import { Search, Command, Loader2, CornerDownLeft, Calculator, Globe, Lock, ChevronRight, ChevronLeft, History, FolderOpen, Ruler, Trash2, Terminal, Archive as ArchiveIcon, Regex, FileText, Settings } from '@lucide/vue'
-import { Accordion, AccordionItem, AccordionTrigger, AccordionContent } from '@/components/ui/accordion'
+import { Search, Command, Loader2, CornerDownLeft, Calculator, Globe, Lock, ChevronRight, ChevronLeft, ChevronDown, History, FolderOpen, Ruler, Trash2, Terminal, Archive as ArchiveIcon, Regex, FileText, Settings } from '@lucide/vue'
 import { TooltipProvider, Tooltip, TooltipTrigger, TooltipContent } from '@/components/ui/tooltip'
 import { Switch } from '@/components/ui/switch'
-import { aggregateSearch, loadAppIconsForResults, recordHistoryItem, getMoreHistoryItems, getMoreHistoryCount, setFileIndexReady, type QPItem, type QPSubAction } from './providers'
+import { aggregateSearch, loadAppIconsForResults, recordHistoryItem, getAllHistoryItems, setFileIndexReady, type QPItem, type QPSubAction } from './providers'
 import { EVENTS, STORAGE_KEYS } from '@/lib/constants'
 import HistoryPicker from './HistoryPicker.vue'
 
@@ -143,14 +142,32 @@ const renameResults = ref<RenameResult[] | null>(null)
 const renameOkCount = ref(0)
 let renameTimer: ReturnType<typeof setTimeout> | null = null
 
-// ===== 历史分区（从 results 中分离历史项与其他结果） =====
-// 展示顺序：目录操作（批量解压/重命名/删除）> 历史 > 更多历史 > 其他
-const dirActionItems = computed(() => results.value.filter(r => r.group === '目录操作'))
-const historyItems = computed(() => results.value.filter(r => r.group === '历史'))
-const otherItems = computed(() => results.value.filter(r => r.group !== '历史' && r.group !== '目录操作'))
-// Accordion 中的更多历史项（不参与键盘上下导航，仅鼠标点击）
-const moreHistoryItems = ref<QPItem[]>([])
-const moreHistoryCount = ref(0)
+// ===== 结果分区（从 results 中分离历史项与其他结果） =====
+// 展示顺序：目录操作（批量解压/重命名/删除）> 历史（折叠分组）> 其他
+// 目录操作为置顶行为项；历史在空查询时置顶但默认折叠，按 Tab 展开
+const dirActionItems = ref<QPItem[]>([])
+const otherItems = computed(() => results.value)
+// 历史项单独从 localStorage 加载（不再混入 results），默认折叠
+const historyItems = ref<QPItem[]>([])
+const historyExpanded = ref(false)
+
+// 键盘导航扁平化序号：目录操作 + 历史（展开时）+ 其他
+const dirCount = computed(() => dirActionItems.value.length)
+const historyCount = computed(() => historyItems.value.length)
+const otherCount = computed(() => otherItems.value.length)
+const otherNavStart = computed(() => dirCount.value + (historyExpanded.value ? historyCount.value : 0))
+const navTotal = computed(() => otherNavStart.value + otherCount.value)
+// 键盘导航项（selectedIndex 指向该扁平数组）：目录操作 + 历史（展开时）+ 其他
+const navItems = computed<QPItem[]>(() => [
+  ...dirActionItems.value,
+  ...(historyExpanded.value ? historyItems.value : []),
+  ...otherItems.value,
+])
+
+function toggleHistory() {
+  collapseSubActions()
+  historyExpanded.value = !historyExpanded.value
+}
 
 // ===== 历史频率（localStorage 持久化，用于排序加权） =====
 const HISTORY_KEY = STORAGE_KEYS.quickpanelHistory
@@ -192,24 +209,25 @@ async function doSearch() {
   const seq = ++searchSeq
   const q = query.value.trim()
   if (!q) {
-    // 空查询：当前目录文件操作（若检测到 Explorer 目录）+ 历史置顶 + 系统相关条目
+    // 空查询：目录操作（若检测到 Explorer 目录）+ 历史置顶（默认折叠）+ 系统相关条目
     // （程序相关设置不参与默认展示；所有 Provider 空查询零 IPC，首屏即时）
     const items = await aggregateSearch('')
     if (seq !== searchSeq) return // 过期请求丢弃
-    const dirItems = getExplorerActions()
-    results.value = applyHistoryBoost([...dirItems, ...items])
+    dirActionItems.value = getExplorerActions()
+    results.value = applyHistoryBoost(items)
+    // 历史置顶但默认折叠，按 Tab 展开（每次显示重置为折叠态）
+    historyItems.value = getAllHistoryItems()
+    historyExpanded.value = false
     selectedIndex.value = 0
-    // 加载更多历史（Accordion 折叠区，不参与键盘导航）
-    moreHistoryItems.value = getMoreHistoryItems()
-    moreHistoryCount.value = getMoreHistoryCount()
     // 后台加载应用图标（含历史中的图标）
     void loadAppIconsForResults(results.value)
-    void loadAppIconsForResults(moreHistoryItems.value)
+    void loadAppIconsForResults(historyItems.value)
     return
   }
-  // 非空查询：清空历史分区
-  moreHistoryItems.value = []
-  moreHistoryCount.value = 0
+  // 非空查询：清空历史分区与目录操作
+  dirActionItems.value = []
+  historyItems.value = []
+  historyExpanded.value = false
   loading.value = true
   try {
     const items = await aggregateSearch(q)
@@ -680,7 +698,7 @@ async function confirmDelete() {
 
 // 子动作展开/收起
 function toggleSubActions(idx: number) {
-  const item = results.value[idx]
+  const item = navItems.value[idx]
   if (!item?.subActions?.length) return
   if (subActionExpanded.value === idx) {
     subActionExpanded.value = null
@@ -697,7 +715,7 @@ function collapseSubActions() {
 // 当前展开的子动作列表
 function currentSubActions(): QPSubAction[] {
   if (subActionExpanded.value === null) return []
-  return results.value[subActionExpanded.value]?.subActions || []
+  return navItems.value[subActionExpanded.value]?.subActions || []
 }
 
 // ===== 键盘导航 =====
@@ -725,7 +743,7 @@ function onKeydown(e: KeyboardEvent) {
 
   const expanded = subActionExpanded.value !== null
   const subs = currentSubActions()
-  const expandedItem = expanded ? results.value[subActionExpanded.value!] : undefined
+  const expandedItem = expanded ? navItems.value[subActionExpanded.value!] : undefined
 
   if (expanded) {
     // 子动作导航模式
@@ -760,7 +778,7 @@ function onKeydown(e: KeyboardEvent) {
   // 结果列表导航模式
   if (e.key === 'ArrowDown') {
     e.preventDefault()
-    selectedIndex.value = Math.min(selectedIndex.value + 1, results.value.length - 1)
+    selectedIndex.value = Math.min(selectedIndex.value + 1, navTotal.value - 1)
     scrollSelectedIntoView()
   } else if (e.key === 'ArrowUp') {
     e.preventDefault()
@@ -768,17 +786,23 @@ function onKeydown(e: KeyboardEvent) {
     scrollSelectedIntoView()
   } else if (e.key === 'Enter') {
     e.preventDefault()
-    const item = results.value[selectedIndex.value]
+    const item = navItems.value[selectedIndex.value]
     if (item) executeItem(item)
   } else if (e.key === 'Escape') {
     e.preventDefault()
     hideWindow()
   } else if (e.key === 'Tab') {
-    // Tab 展开子动作
-    const item = results.value[selectedIndex.value]
-    if (item?.subActions?.length) {
+    if (!query.value.trim()) {
+      // 默认视图：Tab 展开/收起历史分组
       e.preventDefault()
-      toggleSubActions(selectedIndex.value)
+      toggleHistory()
+    } else {
+      // 搜索视图：Tab 展开子动作
+      const item = navItems.value[selectedIndex.value]
+      if (item?.subActions?.length) {
+        e.preventDefault()
+        toggleSubActions(selectedIndex.value)
+      }
     }
   }
 }
@@ -1393,58 +1417,35 @@ onUnmounted(() => {
           </div>
         </template>
 
-        <!-- 历史置顶项（可键盘导航，索引偏移 dirActionItems.length） -->
-        <template v-for="(item, idx) in historyItems" :key="item.id">
+        <!-- 历史分组：置顶、默认折叠，按 Tab 展开 -->
+        <div v-if="historyCount > 0" class="qp-history-section">
           <div
-            class="qp-item"
-            :class="{ 'qp-item-selected': (idx + dirActionItems.length) === selectedIndex }"
-            @click="executeItem(item)"
-            @mouseenter="onItemHover(idx + dirActionItems.length)"
+            class="qp-item qp-history-trigger"
+            @click="toggleHistory"
           >
-            <img
-              v-if="item.iconUrl"
-              :src="item.iconUrl"
-              class="qp-app-icon shrink-0"
-              alt=""
-            />
-            <component
-              v-else
-              :is="groupIcon(item.group)"
-              class="size-4 text-muted-foreground shrink-0"
-              :class="isAppLike(item) ? '' : 'mt-0.5'"
-            />
-            <div class="flex-1 min-w-0 flex" :class="isAppLike(item) ? 'items-center' : 'flex-col'">
-              <p class="text-sm truncate">{{ item.title }}</p>
-              <p v-if="!isAppLike(item) && item.subtitle" class="text-xs text-muted-foreground truncate">{{ item.subtitle }}</p>
+            <History class="size-4 text-muted-foreground shrink-0" />
+            <div class="flex-1 min-w-0">
+              <p class="text-sm">历史</p>
+              <p class="text-xs text-muted-foreground">{{ historyCount }} 条最近记录</p>
             </div>
-            <span class="qp-group-badge" :class="groupBadgeClass(item.group)">{{ item.group }}</span>
-            <CornerDownLeft
-              v-if="(idx + dirActionItems.length) === selectedIndex"
-              class="h-3.5 w-3.5 text-primary shrink-0"
+            <kbd class="qp-kbd shrink-0" @click.stop="toggleHistory">Tab</kbd>
+            <ChevronDown
+              v-if="historyExpanded"
+              class="h-3.5 w-3.5 text-muted-foreground shrink-0"
+            />
+            <ChevronRight
+              v-else
+              class="h-3.5 w-3.5 text-muted-foreground shrink-0"
             />
           </div>
-        </template>
-
-        <!-- 更多历史 Accordion（固定在历史下方，不参与键盘导航） -->
-        <Accordion
-          v-if="moreHistoryCount > 0"
-          type="single"
-          collapsible
-          class="qp-more-history"
-        >
-          <AccordionItem value="more" class="border-0">
-            <AccordionTrigger class="qp-more-trigger">
-              <span class="flex items-center gap-2">
-                <History class="h-3.5 w-3.5 text-muted-foreground" />
-                更多历史（{{ moreHistoryCount }} 条）
-              </span>
-            </AccordionTrigger>
-            <AccordionContent class="qp-more-content">
+          <!-- 展开后的历史项（索引偏移 dirCount，可键盘导航） -->
+          <template v-if="historyExpanded">
+            <template v-for="(item, idx) in historyItems" :key="item.id">
               <div
-                v-for="item in moreHistoryItems"
-                :key="item.id"
-                class="qp-item qp-more-item"
+                class="qp-item"
+                :class="{ 'qp-item-selected': (dirCount + idx) === selectedIndex }"
                 @click="executeItem(item)"
+                @mouseenter="onItemHover(dirCount + idx)"
               >
                 <img
                   v-if="item.iconUrl"
@@ -1463,18 +1464,22 @@ onUnmounted(() => {
                   <p v-if="!isAppLike(item) && item.subtitle" class="text-xs text-muted-foreground truncate">{{ item.subtitle }}</p>
                 </div>
                 <span class="qp-group-badge" :class="groupBadgeClass(item.group)">{{ item.group }}</span>
+                <CornerDownLeft
+                  v-if="(dirCount + idx) === selectedIndex"
+                  class="h-3.5 w-3.5 text-primary shrink-0"
+                />
               </div>
-            </AccordionContent>
-          </AccordionItem>
-        </Accordion>
+            </template>
+          </template>
+        </div>
 
-        <!-- 其他结果（设置/应用/系统等，可键盘导航，索引偏移 dirActionItems.length + historyItems.length） -->
+        <!-- 其他结果（设置/应用/系统等，可键盘导航，索引偏移 otherNavStart） -->
         <template v-for="(item, idx) in otherItems" :key="item.id">
           <div
             class="qp-item"
-            :class="{ 'qp-item-selected': (idx + dirActionItems.length + historyItems.length) === selectedIndex }"
+            :class="{ 'qp-item-selected': (otherNavStart + idx) === selectedIndex }"
             @click="executeItem(item)"
-            @mouseenter="onItemHover(idx + dirActionItems.length + historyItems.length)"
+            @mouseenter="onItemHover(otherNavStart + idx)"
           >
             <img
               v-if="item.iconUrl"
@@ -1494,21 +1499,21 @@ onUnmounted(() => {
             </div>
             <span class="qp-group-badge" :class="groupBadgeClass(item.group)">{{ item.group }}</span>
             <ChevronRight
-              v-if="item.subActions?.length && (idx + dirActionItems.length + historyItems.length) !== selectedIndex"
+              v-if="item.subActions?.length && (otherNavStart + idx) !== selectedIndex"
               class="h-3.5 w-3.5 text-muted-foreground shrink-0"
             />
             <kbd
-              v-else-if="item.subActions?.length && (idx + dirActionItems.length + historyItems.length) === selectedIndex"
+              v-else-if="item.subActions?.length && (otherNavStart + idx) === selectedIndex"
               class="qp-kbd shrink-0"
-              @click.stop="toggleSubActions(idx + dirActionItems.length + historyItems.length)"
+              @click.stop="toggleSubActions(otherNavStart + idx)"
             >Tab</kbd>
             <CornerDownLeft
-              v-else-if="(idx + dirActionItems.length + historyItems.length) === selectedIndex"
+              v-else-if="(otherNavStart + idx) === selectedIndex"
               class="h-3.5 w-3.5 text-primary shrink-0"
             />
           </div>
           <!-- 子动作展开面板 -->
-          <div v-if="subActionExpanded === (idx + dirActionItems.length + historyItems.length) && item.subActions?.length" class="qp-sub-panel">
+          <div v-if="subActionExpanded === (otherNavStart + idx) && item.subActions?.length" class="qp-sub-panel">
             <div
               v-for="(sub, sIdx) in item.subActions"
               :key="sub.id"
@@ -1529,7 +1534,8 @@ onUnmounted(() => {
     <!-- 底部提示 -->
     <div class="qp-footer">
       <span><kbd>↑</kbd><kbd>↓</kbd> 导航</span>
-      <span v-if="subActionExpanded === null"><kbd>Tab</kbd> 子动作</span>
+      <span v-if="!query.trim()"><kbd>Tab</kbd> 历史</span>
+      <span v-else-if="subActionExpanded === null"><kbd>Tab</kbd> 子动作</span>
       <span v-else><kbd>1-9</kbd> 快捷执行</span>
       <span><kbd>Enter</kbd> 执行</span>
       <span><kbd>Esc</kbd> {{ subActionExpanded !== null ? '收起' : '关闭' }}</span>
@@ -1995,35 +2001,15 @@ onUnmounted(() => {
   background: var(--accent);
 }
 
-/* 更多历史 Accordion */
-.qp-more-history {
+/* 历史折叠分组 */
+.qp-history-section {
   margin: 0 6px 4px;
 }
 
-.qp-more-trigger {
-  padding: 6px 12px;
-  font-size: 12px;
-  font-weight: 500;
-  color: var(--muted-foreground);
-  min-height: 28px;
-  border-radius: var(--radius);
-  /* 覆盖 reka-ui 默认 py-4 */
-  padding-top: 6px;
-  padding-bottom: 6px;
-}
-
-.qp-more-trigger:hover {
-  background: var(--muted);
-}
-
-.qp-more-content {
-  /* 覆盖 AccordionContent 默认 pb-4 */
-  padding-top: 0;
-  padding-bottom: 2px;
-}
-
-.qp-more-item {
+.qp-history-trigger {
+  min-height: 36px;
   padding: 6px 12px;
+  font-size: 13px;
 }
 
 .qp-item-selected:hover {

src/modules/quickpanel/QuickPanelModule.vue

@@ -98,6 +98,7 @@ onMounted(async () => {
   } catch (e) {
     console.error('[quickpanel] 读取设置失败:', e)
   }
+  formLoaded.value = true
   await refreshStats()
   // 监听索引构建完成事件（闲时自动建立/重建）：刷新统计，无需手动刷新
   indexUpdatedUnlisten = await listen<number>(EVENTS.quickpanelIndexUpdated, () => {
@@ -105,7 +106,10 @@ onMounted(async () => {
   })
 })
 
-// ===== 保存 =====
+// 初始加载完成后才允许自动保存（避免启动时把刚读到的配置再写回一次）
+const formLoaded = ref(false)
+
+// ===== 保存（即改即生效） =====
 async function saveSettings() {
   try {
     await commands.quickpanelSaveSettings({ ...form })
@@ -113,13 +117,24 @@ async function saveSettings() {
     localStorage.setItem(STORAGE_KEYS.quickpanelSettings, JSON.stringify({ ...form }))
     // 清除自定义命令缓存，使下次搜索重新加载
     invalidateCustomCommandsCache()
-    toast.success('设置已保存')
   } catch (e) {
     console.error('[quickpanel] 保存设置失败:', e)
     toast.error('保存设置失败')
   }
 }
 
+// 防抖自动保存：设置任意改动后自动持久化（成功不提示，失败才提示）
+let saveQueueTimer = 0
+watch(
+  form,
+  () => {
+    if (!formLoaded.value) return
+    window.clearTimeout(saveQueueTimer)
+    saveQueueTimer = window.setTimeout(() => void saveSettings(), 400)
+  },
+  { deep: true }
+)
+
 // ===== 自定义命令管理 =====
 const editingCmd = reactive<CustomCommand>({ id: '', title: '', command: '', args: [] })
 const editingIdx = ref(-1) // -1 表示新增，>=0 表示编辑现有
@@ -163,7 +178,6 @@ function removeCustomCommand(idx: number) {
 }
 
 const tabsStore = useModuleTabsStore()
-tabsStore.registerSave(saveSettings)
 
 // ===== 快捷键录入器（与 ClipboardModule 同模式） =====
 const recording = ref(false)

src/modules/quickpanel/providers/aggregate.ts

@@ -4,7 +4,6 @@
  */
 import type { QPItem, QPProvider } from './types'
 import { appRankFromPath } from './utils'
-import { HistoryProvider } from './history'
 import { CommandProvider } from './command'
 import { CustomCommandProvider } from './customCommand'
 import { AppProvider } from './app'
@@ -21,7 +20,6 @@ let providers: QPProvider[] | null = null
 export function getProviders(): QPProvider[] {
   if (!providers) {
     providers = [
-      new HistoryProvider(),
       new CommandProvider(),
       new CustomCommandProvider(),
       new AppProvider(),

src/modules/quickpanel/providers/history.ts

@@ -1,18 +1,15 @@
 /**
  * history Provider：最近交互记录。
- * 记录持久化到 localStorage，空查询时置顶展示最近几条；点击历史项时
+ * 记录持久化到 localStorage，供 QuickPanel 顶部折叠分组加载；点击历史项时
  * 重新聚合搜索恢复原 action。
  */
 import { STORAGE_KEYS } from '@/lib/constants'
-import type { HistoryEntry, QPItem, QPProvider } from './types'
+import type { HistoryEntry, QPItem } from './types'
 import { aggregateSearch } from './aggregate'
 
 const HISTORY_ITEMS_KEY = STORAGE_KEYS.quickpanelHistoryItems
 const HISTORY_MAX = 50
 
-/** 空查询时默认展示的历史条数（置顶部分） */
-export const HISTORY_PREVIEW_COUNT = 3
-
 function loadHistoryEntries(): HistoryEntry[] {
   try {
     const raw = localStorage.getItem(HISTORY_ITEMS_KEY)
@@ -76,32 +73,8 @@ export function clearHistory() {
   localStorage.removeItem(HISTORY_ITEMS_KEY)
 }
 
-/** 获取置顶的历史项（最近 N 条），用于空查询时在结果列表顶部显示 */
-export function getTopHistoryItems(): QPItem[] {
+/** 获取全部历史项（最近优先），供顶部可折叠的历史分组使用 */
+export function getAllHistoryItems(): QPItem[] {
   const entries = loadHistoryEntries()
-  return entries.slice(0, HISTORY_PREVIEW_COUNT).map(buildHistoryItem)
-}
-
-/** 获取置顶历史之后的剩余历史项，用于 Accordion 折叠显示 */
-export function getMoreHistoryItems(): QPItem[] {
-  const entries = loadHistoryEntries()
-  return entries.slice(HISTORY_PREVIEW_COUNT).map(buildHistoryItem)
-}
-
-/** 获取剩余历史数量（用于 Accordion 标题显示） */
-export function getMoreHistoryCount(): number {
-  const entries = loadHistoryEntries()
-  return Math.max(0, entries.length - HISTORY_PREVIEW_COUNT)
-}
-
-export class HistoryProvider implements QPProvider {
-  id = 'history'
-  label = '历史'
-  priority = 99 // 最高优先级，空查询时显示在最前
-
-  async search(query: string): Promise<QPItem[]> {
-    if (query.trim()) return [] // 历史只在空查询时显示
-    // 只返回置顶3条，剩余由 Accordion 承载
-    return getTopHistoryItems()
-  }
+  return entries.map(buildHistoryItem)
 }

src/modules/quickpanel/providers/index.ts

@@ -14,10 +14,7 @@ export { loadAppIconsForResults, invalidateAppIconCache } from './app'
 export { setFileIndexReady } from './file'
 export { invalidateCustomCommandsCache } from './customCommand'
 export {
-  HISTORY_PREVIEW_COUNT,
   recordHistoryItem,
   clearHistory,
-  getTopHistoryItems,
-  getMoreHistoryItems,
-  getMoreHistoryCount,
+  getAllHistoryItems,
 } from './history'

src/modules/quickpanel/providers/system.ts

@@ -54,6 +54,14 @@ const SYSTEM_COMMANDS: SystemCommandDef[] = [
     command: 'taskmgr',
     args: [],
   },
+  {
+    id: 'sys-devmgmt',
+    title: '设备管理器',
+    subtitle: 'devmgmt.msc',
+    keywords: ['devmgmt', '设备管理', '硬件', '驱动', 'sheb'],
+    command: 'devmgmt.msc',
+    args: [],
+  },
   {
     id: 'sys-explorer',
     title: '资源管理器',

src/modules/screenshot/ScreenshotOverlay.vue

@@ -7,13 +7,13 @@ import { EVENTS, STORAGE_KEYS, WINDOWS } from '@/lib/constants'
 // Rust 端通过 tauri-specta 生成的命令绑定（bindings.ts）
 import { commands } from '@/lib/bindings'
 import {
-  Undo2, Redo2, Eraser, Copy, Save,
+  Undo2, Redo2, Eraser, Copy, Save, ChevronsDown,
 } from '@lucide/vue'
 import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover'
 import { Slider } from '@/components/ui/slider'
 import { TooltipProvider, Tooltip, TooltipTrigger, TooltipContent } from '@/components/ui/tooltip'
 import {
-  TOOLS, COLORS, BLOCK_SIZES, ALPHAS, HANDLES, HANDLE_HIT, DRAG_THRESHOLD,
+  TOOLS, TOOL_KEYS, COLORS, BLOCK_SIZES, ALPHAS, HANDLES, HANDLE_HIT, DRAG_THRESHOLD,
   type Phase, type ToolType, type Annotation, type DrawableAnnotation,
   type Point, type Sel, type CaptureData, type WindowInfo, type HandleDir,
   type RectAnno, type EllipseAnno, type ArrowAnno, type PenAnno, type TextAnno,
@@ -60,6 +60,15 @@ const sel = ref<Sel>({ x: 0, y: 0, w: 0, h: 0 })
 const dragStart = ref<Point>({ x: 0, y: 0 })
 const dragTracking = ref(false)
 
+/** 滚动截图失败提示（气泡定位在选区附近，避免全屏居中落在多屏接缝处） */
+const scrollToast = ref('')
+let scrollToastTimer: ReturnType<typeof setTimeout> | null = null
+
+/** 界面内滚动模式（方案 B）：选区透明透出真实屏幕、遮罩保留，自动滚动拼接 */
+const scrollMode = ref(false)
+/** 会话实时拼接进度 */
+const scrollProgress = ref<{ width: number; height: number } | null>(null)
+
 // 窗口识别
 const winHighlight = ref<{ x: number; y: number; w: number; h: number; title: string } | null>(null)
 const currentHwnd = ref(0)
@@ -154,6 +163,10 @@ let magGridCanvas: HTMLCanvasElement | null = null
 // 常驻窗口：'screenshot-begin' 事件监听（store 捕获并定位窗口后触发）
 let beginUnlisten: UnlistenFn | null = null
 const beginUnlistenCleanups: Array<() => void> = []
+/** 界面内滚动会话事件监听（scrollProgress / scrollComplete / scrollCancelled） */
+let scrollProgressUnlisten: UnlistenFn | null = null
+let scrollCompleteUnlisten: UnlistenFn | null = null
+let scrollCancelledUnlisten: UnlistenFn | null = null
 
 // 底图解码完成信号：新一轮底图 decode 完成后再显示窗口（避免"旧图→loading→新图"割裂）
 let imgReadyResolve: (() => void) | null = null
@@ -355,8 +368,8 @@ const toolbarPos = computed(() => {
   return { left: left + 'px', top: top + 'px' }
 })
 
-// 工具栏显示/尺寸变化后重新测量定位（两行折叠、马赛克/高亮参数按钮增减等）
-watch([showToolbar, currentTool, phase], async () => {
+// 工具栏显示/尺寸变化后重新测量定位（两行折叠、马赛克/高亮参数按钮增减、滚动模式切换等）
+watch([showToolbar, currentTool, phase, scrollMode], async () => {
   await nextTick()
   toolbarTick.value++
 })
@@ -413,6 +426,10 @@ function ensurePixelCanvas() {
 
 /** 调度放大镜更新（rAF 节流，每帧最多一次） */
 function scheduleMagnifier(e: MouseEvent) {
+  if (scrollMode.value) {
+    magVisible.value = false
+    return
+  }
   if (loading.value || errorMsg.value) {
     magVisible.value = false
     return
@@ -764,6 +781,7 @@ function selectWindow(w: { x: number; y: number; w: number; h: number }) {
 
 // ===== 鼠标交互 =====
 function onMouseDown(e: MouseEvent) {
+  if (scrollMode.value) return
   if (e.button !== 0 || loading.value || errorMsg.value) return
   if (phase.value === 'pick') {
     dragTracking.value = true
@@ -781,7 +799,7 @@ function onMouseDown(e: MouseEvent) {
 }
 
 function onRegionMouseDown(e: MouseEvent) {
-  if (e.button !== 0) return
+  if (e.button !== 0 || scrollMode.value) return
   if (phase.value === 'selected') {
     if (!hasAnnotations.value) {
       const dir = hitHandle(e)
@@ -836,6 +854,7 @@ function onMouseMove(e: MouseEvent) {
   // 追踪鼠标物理坐标（ESC 等回到 pick 阶段时按当前位置恢复窗口高亮）
   lastMousePhys.x = Math.round(winOuterX + e.clientX * dpr)
   lastMousePhys.y = Math.round(winOuterY + e.clientY * dpr)
+  if (scrollMode.value) return
   // 取色器放大镜更新（rAF 节流）
   scheduleMagnifier(e)
 
@@ -913,7 +932,7 @@ function onMouseMove(e: MouseEvent) {
 }
 
 function onMouseUp(e: MouseEvent) {
-  if (e.button !== 0) return
+  if (e.button !== 0 || scrollMode.value) return
   if (phase.value === 'pick') {
     if (dragTracking.value) {
       dragTracking.value = false
@@ -948,6 +967,17 @@ function onMouseUp(e: MouseEvent) {
 }
 
 function onKeyDown(e: KeyboardEvent) {
+  // 界面内滚动模式：Enter 停止并导出，Esc 取消，其余按键不响应
+  if (scrollMode.value) {
+    if (e.key === 'Escape') {
+      e.preventDefault()
+      void cancelScroll()
+    } else if (e.key === 'Enter') {
+      e.preventDefault()
+      void stopScroll()
+    }
+    return
+  }
   if (textInputPos.value) {
     // Ctrl+Enter → 提交文字；普通 Enter → 换行（textarea 默认行为）
     if (e.key === 'Enter' && e.ctrlKey) {
@@ -959,6 +989,44 @@ function onKeyDown(e: KeyboardEvent) {
     }
     return
   }
+  // 编辑栏快捷键（selected/editing 阶段）：单字母切工具 / S 滚动截图 / Ctrl 组合操作
+  if (showToolbar.value) {
+    const k = e.key.toLowerCase()
+    const mod = e.ctrlKey || e.metaKey
+    if (!mod && !e.altKey) {
+      const tool = TOOL_KEYS[k]
+      if (tool) {
+        e.preventDefault()
+        onSelectTool(tool)
+        return
+      }
+      if (k === 's') {
+        e.preventDefault()
+        void startScroll()
+        return
+      }
+    }
+    if (mod && !e.shiftKey && k === 'z') {
+      e.preventDefault()
+      undo()
+      return
+    }
+    if (mod && (k === 'y' || (e.shiftKey && k === 'z'))) {
+      e.preventDefault()
+      redo()
+      return
+    }
+    if (mod && k === 'd') {
+      e.preventDefault()
+      clearAnnotations()
+      return
+    }
+    if (mod && k === 's') {
+      e.preventDefault()
+      void doSave()
+      return
+    }
+  }
   // Shift 切换颜色格式（hex → rgb → hsl → hex）
   if (e.key === 'Shift' && !e.repeat) {
     const formats: ColorFormat[] = ['hex', 'rgb', 'hsl']
@@ -1007,7 +1075,7 @@ function onKeyDown(e: KeyboardEvent) {
 }
 
 function onRegionDblClick() {
-  if (textInputPos.value) return
+  if (textInputPos.value || scrollMode.value) return
   void finish()
 }
 
@@ -1852,6 +1920,76 @@ function cancel() {
   void win.hide().catch(() => {})
 }
 
+/** 在选区附近显示滚动截图失败提示，数秒后自动消失 */
+function showScrollToast(msg: string) {
+  scrollToast.value = msg
+  if (scrollToastTimer) clearTimeout(scrollToastTimer)
+  scrollToastTimer = setTimeout(() => {
+    scrollToast.value = ''
+    scrollToastTimer = null
+  }, 3200)
+}
+
+/** 界面内滚动截图：启动自动滚动会话，覆盖层保持可见，选区透明透出真实屏幕 */
+async function startScroll() {
+  if (exporting.value || scrollMode.value) return
+  const sp = selPhys.value
+  // 目标窗口：优先窗口拾取结果；自由选区时按选区中心在拾取列表中命中（列表为截图开始时刻快照）
+  let hwnd = currentHwnd.value
+  if (!hwnd) {
+    const cx = Math.round(winOuterX + sp.x + sp.w / 2)
+    const cy = Math.round(winOuterY + sp.y + sp.h / 2)
+    hwnd = hitTestWindow(cx, cy)?.hwnd ?? 0
+  }
+  if (!hwnd) {
+    showScrollToast('选区中心处未找到可滚动窗口，请点击选中窗口后重试')
+    return
+  }
+  // 框选区平移到屏幕物理坐标：selPhys 已是物理像素，叠加覆盖层物理原点即绝对屏幕坐标
+  const region = {
+    x: Math.round(winOuterX + sp.x),
+    y: Math.round(winOuterY + sp.y),
+    width: Math.round(sp.w),
+    height: Math.round(sp.h),
+  }
+  try {
+    await commands.screenshotScrollStart(hwnd, region, true)
+  } catch (e) {
+    console.error('[screenshot] 滚动截图启动失败', e)
+    showScrollToast(String(e))
+    return
+  }
+  // 进入界面内滚动模式：隐藏冻结底图 → 选区透明透出真实屏幕，遮罩/蓝框保留。
+  // 会话用 PrintWindow 抓目标窗口客户区，覆盖层/遮罩不会出现在结果图中。
+  scrollMode.value = true
+  scrollProgress.value = null
+  magVisible.value = false
+}
+
+/** 退出界面内滚动模式（会话已结束/取消后恢复普通选区界面） */
+function exitScrollMode() {
+  scrollMode.value = false
+  scrollProgress.value = null
+}
+
+/** 取消滚动会话并退出滚动模式（会话线程回滚窗口、丢弃画布） */
+async function cancelScroll() {
+  try {
+    await commands.screenshotScrollCancel()
+  } catch { /* 会话可能已结束 */ }
+  exitScrollMode()
+}
+
+/** 手动停止：请求会话结束并导出当前已拼接内容（随后进入编辑器） */
+async function stopScroll() {
+  try {
+    await commands.screenshotScrollFinish()
+  } catch {
+    // 会话可能已提前结束（自动到底/窗口关闭等），退出滚动模式即可，无需报错
+    exitScrollMode()
+  }
+}
+
 // ===== 生命周期 =====
 function onImgLoad() {
   if (imgEl.value) {
@@ -1923,6 +2061,29 @@ onMounted(async () => {
   beginUnlisten = await listen<ScreenshotBeginPayload>(EVENTS.screenshotBegin, (e) => {
     void beginCapture(e.payload)
   })
+  // 界面内滚动会话事件（仅滚动模式下有意义；会话由主窗口触发、覆盖层常驻监听）
+  scrollProgressUnlisten = await listen<{ width: number; height: number }>(EVENTS.scrollProgress, (e) => {
+    if (!scrollMode.value) return
+    scrollProgress.value = { width: e.payload.width, height: e.payload.height }
+  })
+  scrollCompleteUnlisten = await listen<{ width: number; height: number }>(EVENTS.scrollComplete, (e) => {
+    if (!scrollMode.value) return
+    const regionH = selPhys.value.h
+    const got = e.payload.height > regionH
+    exitScrollMode()
+    if (!got) {
+      // 没有滚动内容（窗口未响应自动滚动 / 选区在固定区域）：保留选区并提示
+      showScrollToast('未检测到滚动内容，窗口可能不支持自动滚动，或选区不含可滚动内容')
+      return
+    }
+    void win.hide().catch(() => {})
+    // 通知主窗口打开常驻编辑器（PNG 原始字节已由 Rust 写入编辑器图片槽，raw IPC 取出）
+    void emit(EVENTS.scrollToEditor, {}).catch(() => {})
+  })
+  scrollCancelledUnlisten = await listen(EVENTS.scrollCancelled, () => {
+    if (!scrollMode.value) return
+    exitScrollMode()
+  })
   await emit(EVENTS.screenshotOverlayReady)
 })
 
@@ -1934,7 +2095,13 @@ async function beginCapture(payload?: ScreenshotBeginPayload) {
     // 每次截图开始时同步主界面主题（覆盖层是常驻窗口，主界面可能已切换主题）
     applyTheme()
     // 重置到"拾取"初始状态
+    const wasScrolling = scrollMode.value
     phase.value = 'pick'
+    // 若上一轮滚动会话状态残留（异常路径），一并复位
+    scrollMode.value = false
+    scrollProgress.value = null
+    // 新截图打断进行中的滚动会话 → 取消后台会话（避免残留占用）
+    if (wasScrolling) void commands.screenshotScrollCancel().catch(() => {})
     winHighlight.value = null
     currentHwnd.value = 0
     sel.value = { x: 0, y: 0, w: 0, h: 0 }
@@ -2017,12 +2184,19 @@ onUnmounted(() => {
   window.removeEventListener('storage', onStorageChange)
   beginUnlisten?.()
   beginUnlisten = null
+  scrollProgressUnlisten?.()
+  scrollProgressUnlisten = null
+  scrollCompleteUnlisten?.()
+  scrollCompleteUnlisten = null
+  scrollCancelledUnlisten?.()
+  scrollCancelledUnlisten = null
   beginUnlistenCleanups.forEach(fn => fn())
   beginUnlistenCleanups.length = 0
   if (pickRaf) cancelAnimationFrame(pickRaf)
   if (magRaf) cancelAnimationFrame(magRaf)
   if (redrawRaf) cancelAnimationFrame(redrawRaf)
   if (enterTimer !== null) clearTimeout(enterTimer)
+  if (scrollToastTimer !== null) clearTimeout(scrollToastTimer)
   staticCanvas = null
   magGridCanvas = null
   if (objectUrl) URL.revokeObjectURL(objectUrl)
@@ -2040,9 +2214,9 @@ onUnmounted(() => {
     @mouseup="onMouseUp"
   >
     <TooltipProvider>
-    <!-- 冻结的屏幕底图 -->
+    <!-- 冻结的屏幕底图（滚动模式下隐藏，选区透明透出真实屏幕） -->
     <img
-      v-if="imgSrc"
+      v-if="imgSrc && !scrollMode"
       ref="imgEl"
       :src="imgSrc"
       class="bg-img"
@@ -2057,6 +2231,16 @@ onUnmounted(() => {
       <button class="btn" @click="cancel">关闭</button>
     </div>
 
+    <!-- 滚动截图失败气泡：定位在选区上方，多屏时也不会落在屏幕接缝 -->
+    <div
+      v-if="scrollToast"
+      class="scroll-toast"
+      :style="{
+        left: sel.x + sel.w / 2 + 'px',
+        top: Math.max(8, sel.y - 10) + 'px',
+      }"
+    >{{ scrollToast }}</div>
+
     <!-- pick 阶段全屏淡遮罩（无悬停窗口时；有悬停窗口时由窗口框 box-shadow 暗化框外） -->
     <div v-if="phase === 'pick' && !winHighlight" class="pick-mask" />
 
@@ -2103,8 +2287,12 @@ onUnmounted(() => {
       @mousedown.stop="onRegionMouseDown"
       @dblclick.stop="onRegionDblClick"
     >
-      <div class="region-bg" :style="regionBgStyle" />
-      <canvas ref="canvasRef" class="anno-canvas" :width="physW" :height="physH" />
+      <div v-if="!scrollMode" class="region-bg" :style="regionBgStyle" />
+      <canvas v-if="!scrollMode" ref="canvasRef" class="anno-canvas" :width="physW" :height="physH" />
+      <!-- 滚动模式：左上角实时显示已拼接分辨率（与框选过程的尺寸标签同风格） -->
+      <span v-if="scrollMode" class="size-tag scroll-size-tag">
+        {{ scrollProgress ? `${scrollProgress.width} × ${scrollProgress.height}` : `${selPhys.w} × ${selPhys.h}` }}
+      </span>
       <div class="region-border" />
       <!-- 文字输入：textarea 支持多行，Enter 换行，Ctrl+Enter 提交 -->
       <textarea
@@ -2133,8 +2321,8 @@ onUnmounted(() => {
       </template>
     </div>
 
-    <!-- 缩放手柄（已有标注时禁用缩放，仅可移动） -->
-    <template v-if="phase === 'selected' && !hasAnnotations">
+    <!-- 缩放手柄（已有标注时禁用缩放，仅可移动；滚动模式下隐藏） -->
+    <template v-if="phase === 'selected' && !hasAnnotations && !scrollMode">
       <div
         v-for="dir in HANDLES"
         :key="dir"
@@ -2145,8 +2333,8 @@ onUnmounted(() => {
       />
     </template>
 
-    <!-- 编辑栏：单行布局，工具栏右边框与选区右边框对齐。复制/保存置于末尾 -->
-    <div v-if="showToolbar" ref="toolbarRef" class="toolbar" :style="toolbarPos" @mousedown.stop>
+    <!-- 编辑栏：单行布局，工具栏右边框与选区右边框对齐。复制/保存置于末尾（滚动模式下替换为滚动控制条） -->
+    <div v-if="showToolbar && !scrollMode" ref="toolbarRef" class="toolbar" :style="toolbarPos" @mousedown.stop>
       <!-- 标注工具 -->
       <div class="tb-group">
         <Tooltip v-for="t in TOOLS" :key="t.value">
@@ -2159,27 +2347,24 @@ onUnmounted(() => {
               <component :is="t.icon" class="tb-svg" />
             </button>
           </TooltipTrigger>
-          <TooltipContent>{{ t.label }}</TooltipContent>
+          <TooltipContent>{{ t.label }} ({{ t.key }})</TooltipContent>
         </Tooltip>
       </div>
 
       <div class="tb-sep" />
 
-      <!-- 颜色色卡：显示当前颜色，点击打开选色板 -->
+      <!-- 颜色色卡：显示当前颜色，点击打开选色板
+           注意：Popover 触发器不能套在 <Tooltip as-child> 里——两层 as-child 组合触发器会把
+           click 的 onOpenToggle 合成掉，导致点击无反应。这里直接让 PopoverTrigger 绑按钮。 -->
       <Popover v-model:open="colorPickerOpen">
-        <Tooltip>
-          <TooltipTrigger as-child>
-            <PopoverTrigger as-child>
-              <button
-                class="color-badge"
-                :class="{ disabled: !colorEnabled }"
-                :style="{ '--swatch-color': effectiveColor }"
-                :disabled="!colorEnabled"
-              />
-            </PopoverTrigger>
-          </TooltipTrigger>
-          <TooltipContent>颜色</TooltipContent>
-        </Tooltip>
+        <PopoverTrigger as-child>
+          <button
+            class="color-badge"
+            :class="{ disabled: !colorEnabled }"
+            :style="{ '--swatch-color': effectiveColor }"
+            :disabled="!colorEnabled"
+          />
+        </PopoverTrigger>
         <PopoverContent class="w-auto p-3" align="start">
           <div class="color-popover">
             <input
@@ -2205,20 +2390,15 @@ onUnmounted(() => {
         </PopoverContent>
       </Popover>
 
-      <!-- 粗细 badge：点击打开 Slider -->
+      <!-- 粗细 badge：点击打开 Slider（同样去掉 Tooltip 嵌套，避免合成掉 onOpenToggle） -->
       <Popover v-model:open="lineWidthPickerOpen">
-        <Tooltip>
-          <TooltipTrigger as-child>
-            <PopoverTrigger as-child>
-              <button
-                class="width-badge"
-                :class="{ disabled: !lineWidthEnabled }"
-                :disabled="!lineWidthEnabled"
-              >{{ effectiveLineWidth }}</button>
-            </PopoverTrigger>
-          </TooltipTrigger>
-          <TooltipContent>粗细</TooltipContent>
-        </Tooltip>
+        <PopoverTrigger as-child>
+          <button
+            class="width-badge"
+            :class="{ disabled: !lineWidthEnabled }"
+            :disabled="!lineWidthEnabled"
+          >{{ effectiveLineWidth }}</button>
+        </PopoverTrigger>
         <PopoverContent class="w-auto p-3" align="start">
           <div class="width-popover">
             <div class="width-popover-header">
@@ -2279,7 +2459,7 @@ onUnmounted(() => {
               <Undo2 class="tb-svg" />
             </button>
           </TooltipTrigger>
-          <TooltipContent>撤销</TooltipContent>
+          <TooltipContent>撤销 (Ctrl+Z)</TooltipContent>
         </Tooltip>
         <Tooltip>
           <TooltipTrigger as-child>
@@ -2287,7 +2467,7 @@ onUnmounted(() => {
               <Redo2 class="tb-svg" />
             </button>
           </TooltipTrigger>
-          <TooltipContent>重做</TooltipContent>
+          <TooltipContent>重做 (Ctrl+Y)</TooltipContent>
         </Tooltip>
         <Tooltip>
           <TooltipTrigger as-child>
@@ -2295,7 +2475,7 @@ onUnmounted(() => {
               <Eraser class="tb-svg" />
             </button>
           </TooltipTrigger>
-          <TooltipContent>清空标注</TooltipContent>
+          <TooltipContent>清空标注 (Ctrl+D)</TooltipContent>
         </Tooltip>
       </div>
 
@@ -2305,6 +2485,23 @@ onUnmounted(() => {
 
       <div class="tb-sep" />
 
+      <!-- 滚动截图：自动滚动（自动向下拼接到底部） -->
+      <div class="tb-group">
+        <Tooltip>
+          <TooltipTrigger as-child>
+            <button
+              class="tb-icon"
+              @click="startScroll"
+            >
+              <ChevronsDown class="tb-svg" />
+            </button>
+          </TooltipTrigger>
+          <TooltipContent>滚动截图 (S)</TooltipContent>
+        </Tooltip>
+      </div>
+
+      <div class="tb-sep" />
+
       <!-- 复制 / 保存（置末） -->
       <div class="tb-group">
         <Tooltip>
@@ -2313,7 +2510,7 @@ onUnmounted(() => {
               <Save class="tb-svg" />
             </button>
           </TooltipTrigger>
-          <TooltipContent>保存到文件</TooltipContent>
+          <TooltipContent>保存到文件 (Ctrl+S)</TooltipContent>
         </Tooltip>
         <Tooltip>
           <TooltipTrigger as-child>
@@ -2326,6 +2523,15 @@ onUnmounted(() => {
       </div>
     </div>
 
+    <!-- 界面内滚动控制条：选区下方，显示模式与操作提示（实时分辨率在选区左上角），可停止（保留已拼）或取消（丢弃） -->
+    <div v-if="scrollMode" ref="toolbarRef" class="scroll-bar" :style="toolbarPos" @mousedown.stop>
+      <span class="sm-mode auto">自动</span>
+      <span class="sm-dot" />
+      <span class="sm-hint">平滑滚动拼接中 · Enter 停止 · Esc 取消</span>
+      <button class="sm-btn primary" @click="stopScroll">停止</button>
+      <button class="sm-btn ghost" @click="cancelScroll">取消</button>
+    </div>
+
     <!-- 取色器放大镜：放大像素 + 中心色块 + 坐标 + 颜色值 + 提示 -->
     <div v-show="magVisible" class="magnifier" :style="{ left: magX + 'px', top: magY + 'px' }">
       <canvas ref="magCanvasRef" :width="MAG_W" :height="MAG_H" class="mag-canvas" />
@@ -2396,6 +2602,24 @@ onUnmounted(() => {
   z-index: 20;
 }
 .hint.error { flex-direction: column; }
+/* 滚动截图失败气泡：不占满全屏，定位在选区上方避免落在多屏接缝 */
+.scroll-toast {
+  position: absolute;
+  transform: translate(-50%, -100%);
+  max-width: 70vw;
+  padding: 8px 14px;
+  background: rgba(15, 23, 42, 0.92);
+  border: 1px solid rgba(239, 68, 68, 0.6);
+  color: #fecaca;
+  font-size: 13px;
+  line-height: 1.4;
+  border-radius: 6px;
+  box-shadow: 0 4px 14px rgba(0, 0, 0, 0.35);
+  z-index: 30;
+  pointer-events: none;
+  white-space: normal;
+  word-break: break-word;
+}
 .btn {
   padding: 4px 12px;
   background: var(--primary);
@@ -2642,6 +2866,60 @@ onUnmounted(() => {
   white-space: nowrap;
 }
 
+/* 界面内滚动控制条（方案 B）：与工具栏同锚点，位于选区下方 */
+.scroll-bar {
+  position: absolute;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 5px 6px;
+  background: var(--card);
+  color: var(--card-foreground);
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  box-shadow: 0 4px 16px rgba(0, 0, 0, 0.28);
+  z-index: 30;
+}
+.sm-mode {
+  padding: 1px 8px;
+  border-radius: 999px;
+  font-size: 12px;
+  color: #fff;
+  white-space: nowrap;
+}
+.sm-mode.auto { background: #2563eb; }
+.sm-mode.manual { background: #059669; }
+/* 拼接进行中的呼吸点 */
+.sm-dot {
+  width: 7px;
+  height: 7px;
+  border-radius: 999px;
+  background: #22c55e;
+  animation: sm-pulse 1.1s ease-in-out infinite;
+  flex-shrink: 0;
+}
+@keyframes sm-pulse {
+  0%, 100% { opacity: 0.35; transform: scale(0.8); }
+  50% { opacity: 1; transform: scale(1.15); }
+}
+.sm-hint {
+  font-size: 12px;
+  color: var(--muted-foreground);
+  white-space: nowrap;
+}
+.sm-btn {
+  padding: 4px 14px;
+  border: none;
+  border-radius: 6px;
+  font-size: 13px;
+  cursor: pointer;
+  white-space: nowrap;
+}
+.sm-btn.primary { background: var(--primary); color: var(--primary-foreground); }
+.sm-btn.primary:hover { filter: brightness(0.95); }
+.sm-btn.ghost { background: var(--accent); color: var(--accent-foreground); }
+.sm-btn.ghost:hover { filter: brightness(0.97); }
+
 /* 文字输入：textarea 支持多行，Enter 换行 */
 .text-input {
   position: absolute;
@@ -2732,4 +3010,10 @@ onUnmounted(() => {
   white-space: pre-line;
   word-break: keep-all;
 }
+/* 滚动模式左上角实时分辨率标签（.region-view overflow:hidden 会裁掉负偏移，故置于内部左上角） */
+.scroll-size-tag {
+  top: 4px;
+  left: 4px;
+  z-index: 8;
+}
 </style>

src/modules/screenshot/ScrollControl.vue

@@ -0,0 +1,180 @@
+<script setup lang="ts">
+/** 滚动截图控制窗：覆盖层隐藏后弹出，实时展示拼接进度，完成/取消滚动截图。 */
+import { onMounted, onUnmounted, ref } from 'vue'
+import { getCurrentWindow } from '@tauri-apps/api/window'
+import { listen, type UnlistenFn } from '@tauri-apps/api/event'
+import { commands } from '@/lib/bindings'
+import { EVENTS } from '@/lib/constants'
+
+const win = getCurrentWindow()
+
+// 模式来自 URL hash 参数（覆盖层创建窗口时携带）：#screenshot-scroll?auto=1 自动，否则手动
+const auto = ref(readAutoMode())
+function readAutoMode(): boolean {
+  const qs = location.hash.split('?')[1] ?? ''
+  return new URLSearchParams(qs).get('auto') === '1'
+}
+
+const width = ref(0)
+const height = ref(0)
+const status = ref('')
+/** 是否已收到最终事件（完成/取消），此后关闭窗口不再触发取消 */
+let ended = false
+let unlisten: UnlistenFn[] = []
+
+onMounted(async () => {
+  status.value = auto.value ? '自动向下拼接中…' : '请滚动目标窗口，完成后点「完成」'
+  void win.show().catch(() => {})
+  // 不抢焦点：手动模式下用户需滚目标窗口，焦点应留在目标窗口
+
+  unlisten.push(
+    await listen<{ width: number; height: number }>(EVENTS.scrollProgress, (e) => {
+      width.value = e.payload.width
+      height.value = e.payload.height
+    }),
+  )
+  unlisten.push(
+    await listen(EVENTS.scrollComplete, () => {
+      ended = true
+      status.value = '已在历史中添加'
+      setTimeout(() => void win.close().catch(() => {}), 400)
+    }),
+  )
+  unlisten.push(
+    await listen(EVENTS.scrollCancelled, () => {
+      ended = true
+      void win.close().catch(() => {})
+    }),
+  )
+})
+
+onUnmounted(() => {
+  unlisten.forEach((fn) => fn())
+  // 用户直接关窗（未走完成/取消）→ 通知取消会话
+  if (!ended) {
+    commands.screenshotScrollCancel().catch(() => {})
+  }
+})
+
+function finish() {
+  status.value = '正在处理…'
+  void commands.screenshotScrollFinish().catch((e) => {
+    status.value = String(e)
+  })
+}
+
+function cancel() {
+  ended = true
+  void commands.screenshotScrollCancel().catch(() => {})
+  void win.close().catch(() => {})
+}
+</script>
+
+<template>
+  <div class="scroll-panel">
+    <div class="scroll-header" data-tauri-drag-region>
+      <span class="title">滚动截图</span>
+      <span class="mode" :class="auto ? 'auto' : 'manual'">{{ auto ? '自动' : '手动' }}</span>
+    </div>
+
+    <div class="scroll-body">
+      <div class="size" v-if="height > 0">
+        <b>{{ width }}</b> × <b>{{ height }}</b>
+      </div>
+      <div class="size empty" v-else>等待内容…</div>
+      <div class="status">{{ status }}</div>
+      <div class="hint" v-if="!auto">用鼠标滚轮向下滚动目标窗口</div>
+    </div>
+
+    <div class="scroll-actions">
+      <button class="btn ghost" @click="cancel">取消</button>
+      <button class="btn primary" @click="finish">完成</button>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.scroll-panel {
+  width: 260px;
+  border-radius: 10px;
+  overflow: hidden;
+  background: var(--popover, #1e293b);
+  border: 1px solid rgba(255, 255, 255, 0.12);
+  box-shadow: 0 12px 32px rgba(0, 0, 0, 0.4);
+  color: #e2e8f0;
+  font-size: 13px;
+  user-select: none;
+}
+.scroll-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 8px 12px;
+  background: rgba(255, 255, 255, 0.06);
+  cursor: move;
+}
+.title {
+  font-weight: 600;
+}
+.mode {
+  padding: 1px 8px;
+  border-radius: 8px;
+  font-size: 11px;
+}
+.mode.auto {
+  background: #2563eb;
+  color: #fff;
+}
+.mode.manual {
+  background: #059669;
+  color: #fff;
+}
+.scroll-body {
+  padding: 14px 14px 6px;
+}
+.size {
+  font-size: 16px;
+  color: #fff;
+}
+.size.empty {
+  color: #94a3b8;
+}
+.status {
+  margin-top: 6px;
+  color: #cbd5e1;
+  line-height: 1.4;
+  min-height: 18px;
+}
+.hint {
+  margin-top: 4px;
+  color: #94a3b8;
+  font-size: 12px;
+}
+.scroll-actions {
+  display: flex;
+  gap: 8px;
+  padding: 10px 12px 12px;
+}
+.btn {
+  flex: 1;
+  padding: 7px 0;
+  border: none;
+  border-radius: 7px;
+  font-size: 13px;
+  cursor: pointer;
+}
+.btn.ghost {
+  background: rgba(255, 255, 255, 0.08);
+  color: #e2e8f0;
+}
+.btn.ghost:hover {
+  background: rgba(255, 255, 255, 0.14);
+}
+.btn.primary {
+  background: #2563eb;
+  color: #fff;
+}
+.btn.primary:hover {
+  background: #1d4ed8;
+}
+</style>

src/modules/screenshot/types.ts

@@ -47,16 +47,21 @@ export interface ScreenshotBeginPayload {
 }
 
 // ===== 工具与选项 =====
-export const TOOLS: { value: ToolType; icon: Component; label: string }[] = [
-  { value: 'rect', icon: Square, label: '矩形' },
-  { value: 'ellipse', icon: Circle, label: '椭圆' },
-  { value: 'arrow', icon: MoveUpRight, label: '箭头' },
-  { value: 'number', icon: ListOrdered, label: '序号' },
-  { value: 'pen', icon: Pencil, label: '画笔' },
-  { value: 'text', icon: Type, label: '文字' },
-  { value: 'mosaic', icon: Grid3x3, label: '马赛克' },
-  { value: 'highlight', icon: Highlighter, label: '高亮' },
+/** key = 工具快捷键（单字母，不区分大小写响应） */
+export const TOOLS: { value: ToolType; icon: Component; label: string; key: string }[] = [
+  { value: 'rect', icon: Square, label: '矩形', key: 'R' },
+  { value: 'ellipse', icon: Circle, label: '椭圆', key: 'O' },
+  { value: 'arrow', icon: MoveUpRight, label: '箭头', key: 'A' },
+  { value: 'number', icon: ListOrdered, label: '序号', key: 'N' },
+  { value: 'pen', icon: Pencil, label: '画笔', key: 'P' },
+  { value: 'text', icon: Type, label: '文字', key: 'T' },
+  { value: 'mosaic', icon: Grid3x3, label: '马赛克', key: 'M' },
+  { value: 'highlight', icon: Highlighter, label: '高亮', key: 'H' },
 ]
+/** 快捷键（小写字母）→ 工具，覆盖层与编辑器共用 */
+export const TOOL_KEYS: Partial<Record<string, ToolType>> = Object.fromEntries(
+  TOOLS.map((t) => [t.key.toLowerCase(), t.value]),
+)
 export const COLORS = ['#ef4444', '#f97316', '#eab308', '#22c55e', '#3b82f6', '#a855f7', '#000000', '#ffffff']
 export const BLOCK_SIZES = [8, 10, 14]
 export const ALPHAS = [0.2, 0.4, 0.6]

src/modules/settings/GeneralSettings.vue

@@ -10,42 +10,32 @@ import { useAppStore, type Theme, type EffectType, type ModuleInfo } from '@/sto
 import { useSearchStore } from '@/stores/searchStore'
 import { useProcessStore } from '@/stores/processStore'
 import { useDownloaderStore } from '@/stores/downloaderStore'
+import { AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogTitle } from '@/components/ui/alert-dialog'
 import { getModuleIcon } from '@/modules/icons'
 import { commands, type UpdateCheckResult } from '@/lib/bindings'
-import { EVENTS } from '@/lib/constants'
 import { listen, type UnlistenFn } from '@tauri-apps/api/event'
 import { invoke } from '@tauri-apps/api/core'
-import { computed, onMounted, onUnmounted, ref, watch } from 'vue'
+import { computed, onMounted, ref, watch } from 'vue'
 import { VueDraggable } from 'vue-draggable-plus'
 import { toast } from 'vue-sonner'
+import { storeToRefs } from 'pinia'
+import { useUpdaterStore } from '@/stores/updaterStore'
 
 const appStore = useAppStore()
 const searchStore = useSearchStore()
 const processStore = useProcessStore()
 
-// ===== 关于 / 更新 =====
+/** 更新编排状态/进度提升到全局 store，切模块后下载进度与 need_stop 等待不丢失 */
+const updater = useUpdaterStore()
+const { appUpdating, kernelUpdating, progress, downloadCancellable, kernelDownloadCancellable, thinghkConfirmState } = storeToRefs(updater)
 
-/** 更新进度事件载荷（与 Rust UpdateProgress 对应） */
-interface UpdateProgress {
-  stage: string
-  percent: number
-  downloadedBytes: number
-  totalBytes: number | null
-  message: string
-}
+// ===== 关于 / 更新 =====
 
 /** 当前应用版本（启动时读取） */
 const currentVersion = ref('')
 /** 检查更新的结果 */
 const updateResult = ref<UpdateCheckResult | null>(null)
 const checking = ref(false)
-/** 应用本体更新中 */
-const appUpdating = ref(false)
-/** ThingHK 内核更新中 */
-const kernelUpdating = ref(false)
-const progress = ref<UpdateProgress | null>(null)
-const thinghkExists = ref(false)
-let progressUnlisten: UnlistenFn | null = null
 
 const installTypeText = computed(() =>
   updateResult.value?.installType === 'installed' ? '安装版' : '便携版',
@@ -80,8 +70,6 @@ const checkUpdate = async () => {
 
 const downloaderStore = useDownloaderStore()
 
-/** 下载中显示取消按钮（下载完成进入 applying 阶段后不可取消） */
-const downloadCancellable = ref(false)
 /** 取消下载的唤醒回调（由等待 Promise 设置） */
 let cancelAppDownload: (() => void) | null = null
 
@@ -215,19 +203,162 @@ const cancelUpdateDownload = async () => {
   cancelAppDownload?.()
 }
 
-/** 更新 ThingHK 内核：后端先停止监控内核再覆盖文件 */
+/** 更新 ThingHK 内核：下载模块下载 → apply 命令 need_stop 等待确认 → 停止内核 → 解压替换。
+ *  与代理模块 mihomo 内核更新同模式。 */
+const thinghkExists = ref(false)
+/** 取消 ThingHK 内核包下载的唤醒回调 */
+let cancelKernelDownload: (() => void) | null = null
+
+/** 确认停止内核并唤醒后端 apply 继续解压替换（委托给全局 updater store） */
+const onThinghkNeedStopConfirm = () => {
+  void updater.confirmNeedStop()
+}
+
+/** 取消 ThingHK 内核更新（中止后端等待中的 apply 流程，zip 保留便于重试） */
+const onThinghkNeedStopCancel = () => {
+  updater.cancelNeedStop()
+}
+
+/** AlertDialog 关闭事件的兜底判定：cancel/action 点击会先 update:open(false) 再 click，
+ *  仅在此前未被 click 处理器 resolve 时才当作取消（遮罩/Esc 关闭），否则会误判确认/取消。 */
+const onThinghkNeedStopOpenChange = (open: boolean) => {
+  const s = thinghkConfirmState.value
+  if (!open && !s.resolved) {
+    setTimeout(() => {
+      if (!thinghkConfirmState.value.resolved) updater.cancelNeedStop()
+    }, 0)
+  }
+  thinghkConfirmState.value.open = open
+}
+
+/** 取消 ThingHK 内核包下载（仅下载阶段） */
+const cancelKernelUpdateDownload = () => {
+  if (!kernelDownloadCancellable.value) return
+  cancelKernelDownload?.()
+}
+
+/** 更新 ThingHK 内核 */
 const updateThinghkKernel = async () => {
   if (kernelUpdating.value) return
+  // 未先"检查更新"时自动检查一次，避免点击"更新内核"无反应
+  let result = updateResult.value
+  if (!result) {
+    await checkUpdate()
+    result = updateResult.value
+  }
+  if (!result) return
+  // 从 release assets 中定位 ThingHK 内核包（zip）；找不到则提示手动下载
+  const asset = result.assets.find(a => {
+    const n = a.name.toLowerCase()
+    return (n.includes('thing-hk') || n.includes('thinghk')) && n.endsWith('.zip')
+  })
+  if (!asset) {
+    toast.error('未找到 ThingHK 内核更新包', {
+      description: '请确认 release 资产中已上传 ThingHK 内核 zip 包',
+    })
+    return
+  }
+
   kernelUpdating.value = true
+  progress.value = {
+    stage: 'downloading',
+    percent: 0,
+    downloadedBytes: 0,
+    totalBytes: asset.size || null,
+    message: '准备开始下载...',
+  }
+
+  let taskId: string | null = null
+  let downloadProgressFn: UnlistenFn | null = null
+  // 用对象持有完成事件解绑函数，避免闭包内赋值导致的 TS 类型收窄问题（同 proxyStore）
+  const completeHolder: { fn: UnlistenFn | null } = { fn: null }
+  let downloadOk = false
   try {
-    await commands.updateThinghk()
+    // 确保下载模块事件监听已注册（下载器 UI 与这里共用事件流）
+    try { await downloaderStore.startEventListeners() } catch { /* 忽略 */ }
+    taskId = await downloaderStore.addTask(asset.browserDownloadUrl, asset.name, undefined, {}, false)
+
+    // 下载进度 → 更新进度条
+    downloadProgressFn = await listen<{
+      id: string; completedSize: number; totalSize: number; speed: number; status: string
+    }>('download-progress', (e) => {
+      if (e.payload.id !== taskId || !kernelUpdating.value) return
+      const pct = e.payload.totalSize > 0
+        ? Math.round((e.payload.completedSize / e.payload.totalSize) * 100)
+        : 0
+      progress.value = {
+        stage: 'downloading',
+        percent: pct,
+        downloadedBytes: e.payload.completedSize,
+        totalBytes: e.payload.totalSize,
+        message: e.payload.speed > 0
+          ? `正在下载... ${fmtSpeed(e.payload.speed)}`
+          : '正在下载...',
+      }
+    })
+
+    // 等待下载完成 / 失败 / 取消
+    kernelDownloadCancellable.value = true
+    const dlResult = await new Promise<{ ok: boolean; error?: string }>((resolve) => {
+      let settled = false
+      const finish = (r: { ok: boolean; error?: string }) => {
+        if (settled) return
+        settled = true
+        cancelKernelDownload = null
+        resolve(r)
+      }
+      // 任务添加后瞬间进入终态（如探测即失败）
+      const initial = downloaderStore.tasks.find(t => t.id === taskId)
+      if (initial) {
+        if (initial.status === 'complete') { finish({ ok: true }); return }
+        if (initial.status === 'error') { finish({ ok: false, error: initial.error || '下载失败' }); return }
+      }
+      cancelKernelDownload = () => finish({ ok: false, error: '已取消下载' })
+      listen<{ id: string; status: string; error: string | null }>('download-complete', (e) => {
+        if (e.payload.id === taskId) {
+          if (e.payload.status === 'complete') finish({ ok: true })
+          else finish({ ok: false, error: e.payload.error || '下载失败' })
+        }
+      }).then(fn => { completeHolder.fn = fn })
+    })
+    kernelDownloadCancellable.value = false
+    if (!dlResult.ok) throw new Error(dlResult.error || '下载失败')
+    downloadOk = true
+
+    // 取下载文件路径 → 移除任务记录（保留文件，apply 命令内部会解压并清理）
+    const dlTask = downloaderStore.tasks.find(t => t.id === taskId)
+    if (!dlTask) throw new Error('下载任务未找到')
+    const zipPath = dlTask.dir + '/' + dlTask.filename
+    try {
+      await downloaderStore.removeTask(taskId, false)
+      taskId = null
+    } catch { /* 任务清理失败不阻断更新 */ }
+
+    // 应用阶段：apply 内部 need_stop 等待前端停止内核并确认 → 解压替换 → 完成
+    await invoke('update_thinghk_apply', { zipPath })
     await loadAppInfo()
     toast.success('ThingHK 内核更新完成')
   } catch (e) {
     console.error('[updater] ThingHK 更新失败', e)
-    toast.error('ThingHK 内核更新失败', { description: String(e) })
+    const msg = String(e)
+    if (msg.includes('已取消下载')) {
+      toast.info('已取消更新下载')
+    } else if (msg.includes('更新已取消')) {
+      toast.info('已取消内核更新')
+    } else {
+      toast.error('ThingHK 内核更新失败', { description: msg })
+    }
+    // 清理下载任务：下载失败/取消时删除半成品文件；apply 失败保留 zip 便于重试
+    if (taskId) {
+      try { await downloaderStore.removeTask(taskId, !downloadOk) } catch { /* 忽略 */ }
+    }
   } finally {
     kernelUpdating.value = false
+    progress.value = null
+    kernelDownloadCancellable.value = false
+    cancelKernelDownload = null
+    if (downloadProgressFn) downloadProgressFn()
+    if (completeHolder.fn) completeHolder.fn()
   }
 }
 
@@ -237,19 +368,8 @@ const systemDark = computed(() => appStore.systemDark)
 
 onMounted(() => {
   loadAppInfo()
-  // 监听更新进度事件（应用更新与 ThingHK 内核更新共用）
-  listen<UpdateProgress>(EVENTS.updateProgress, (e) => {
-    progress.value = e.payload
-    if (e.payload.stage === 'done') {
-      kernelUpdating.value = false
-      progress.value = null
-    } else if (e.payload.stage === 'error') {
-      // ThingHK 内核更新失败（后端 emit）；应用更新失败走命令 reject 路径
-      kernelUpdating.value = false
-    }
-  }).then((fn) => {
-    progressUnlisten = fn
-  })
+  // 更新进度事件由全局 updater store 订阅（切换模块仍持续），组件只负责展示
+  void updater.subscribe()
   searchStore.registerAction('settings', 0, () => appStore.setTheme('light'))
   searchStore.registerAction('settings', 1, () => appStore.setTheme('dark'))
   searchStore.registerAction('settings', 2, () => appStore.setTheme('system'))
@@ -267,11 +387,6 @@ onMounted(() => {
   processStore.refreshAll().catch(() => { /* 忽略：后端可能未就绪 */ })
 })
 
-onUnmounted(() => {
-  progressUnlisten?.()
-  progressUnlisten = null
-})
-
 const themes: Array<{ id: Theme; name: string; color: string; icon: typeof Sun }> = [
   { id: 'light', name: '浅色模式', color: '#f8fafc', icon: Sun },
   { id: 'dark', name: '深色模式', color: '#1e293b', icon: Moon },
@@ -407,6 +522,16 @@ const onDragEnd = () => {
               @update:model-value="(checked: boolean) => appStore.toggleAutoStart(checked)"
             />
           </div>
+          <div class="flex items-center justify-between py-2 border-t border-border/60 mt-2">
+            <div class="space-y-1">
+              <Label class="text-base font-medium">静默启动</Label>
+              <p class="text-sm text-muted-foreground">启动后不打开主界面，静默驻留托盘（托盘左键可呼出）</p>
+            </div>
+            <Switch
+              :model-value="appStore.silentAutoStart"
+              @update:model-value="(checked: boolean) => appStore.toggleSilentAutoStart(checked)"
+            />
+          </div>
         </CardContent>
       </Card>
 
@@ -675,8 +800,42 @@ const onDragEnd = () => {
               <span>{{ progress.message }}</span>
               <span class="font-mono">{{ progress.percent }}%</span>
             </div>
-            <Progress :model-value="progress.percent" />
+            <div class="flex items-center gap-2">
+              <Progress :model-value="progress.percent" class="flex-1" />
+              <Button
+                v-if="kernelDownloadCancellable"
+                variant="ghost"
+                size="sm"
+                class="h-5 px-1.5 text-xs"
+                @click="cancelKernelUpdateDownload"
+              >
+                <X class="size-3 mr-0.5" />
+                取消
+              </Button>
+            </div>
           </div>
+
+          <!-- 停止监控内核确认（need_stop 阶段：与 mihomo 同模式） -->
+          <AlertDialog :open="thinghkConfirmState.open" @update:open="onThinghkNeedStopOpenChange">
+            <AlertDialogContent>
+              <AlertDialogHeader>
+                <AlertDialogTitle>停止监控内核后继续</AlertDialogTitle>
+                <AlertDialogDescription>
+                  {{
+                    thinghkConfirmState.wasRunning
+                      ? '内核更新包已下载。安装新内核前需要停止监控内核，点击「停止并继续」将自动停止监控并完成安装。'
+                      : '内核更新包已下载。即将安装新内核，点击「继续」完成安装。'
+                  }}
+                </AlertDialogDescription>
+              </AlertDialogHeader>
+              <AlertDialogFooter>
+                <AlertDialogCancel @click="onThinghkNeedStopCancel">取消</AlertDialogCancel>
+                <AlertDialogAction :disabled="thinghkConfirmState.busy" @click="onThinghkNeedStopConfirm">
+                  {{ thinghkConfirmState.busy ? '正在停止...' : (thinghkConfirmState.wasRunning ? '停止并继续' : '继续') }}
+                </AlertDialogAction>
+              </AlertDialogFooter>
+            </AlertDialogContent>
+          </AlertDialog>
         </CardContent>
       </Card>
 

src/stores/appStore.ts

@@ -57,6 +57,7 @@ export const useAppStore = defineStore('app', () => {
   const theme = ref<Theme>('system')
   const effect = ref<EffectType>('mica')
   const isAutoStart = ref(false)
+  const silentAutoStart = ref(false)
   const isInitialized = ref(false)
   const modules = ref<ModuleInfo[]>(initModulesFromRegistry())
   const moduleOrder = ref<string[]>(initModuleOrder())
@@ -88,6 +89,8 @@ export const useAppStore = defineStore('app', () => {
 
         if (settings.theme) theme.value = settings.theme
         if (settings.effect) effect.value = settings.effect
+        if (typeof settings.isAutoStart === 'boolean') isAutoStart.value = settings.isAutoStart
+        if (typeof settings.silentAutoStart === 'boolean') silentAutoStart.value = settings.silentAutoStart
         if (settings.modules) {
           const savedModules = settings.modules as Array<{ id: string; enabled: boolean }>
           savedModules.forEach(sm => {
@@ -127,6 +130,7 @@ export const useAppStore = defineStore('app', () => {
         theme: theme.value,
         effect: effect.value,
         isAutoStart: isAutoStart.value,
+        silentAutoStart: silentAutoStart.value,
         modules: modulesData,
         moduleOrder: moduleOrder.value
       }))
@@ -323,6 +327,11 @@ export const useAppStore = defineStore('app', () => {
     }
   }
 
+  const toggleSilentAutoStart = (checked?: boolean) => {
+    silentAutoStart.value = checked !== undefined ? checked : !silentAutoStart.value
+    saveSettings()
+  }
+
   const applyTheme = async () => {
     const root = document.documentElement
     root.classList.remove('dark')
@@ -472,6 +481,8 @@ export const useAppStore = defineStore('app', () => {
 
       isInitialized.value = true
     } finally {
+      // 静默启动：仅当未开启时才显示主窗口（开启后启动静默驻留托盘，托盘左键可呼出）
+      if (silentAutoStart.value) return
       try {
         const tauriWindow = getCurrentWindow()
         await tauriWindow.show()
@@ -486,6 +497,7 @@ export const useAppStore = defineStore('app', () => {
     effect,
     systemDark,
     isAutoStart,
+    silentAutoStart,
     isInitialized,
     modules,
     moduleOrder,
@@ -497,6 +509,7 @@ export const useAppStore = defineStore('app', () => {
     setTheme,
     setEffect,
     toggleAutoStart,
+    toggleSilentAutoStart,
     applyTheme,
     applyEffect,
     init,

src/stores/monitorStore.ts

@@ -185,6 +185,8 @@ export interface OsdConfig {
   /** 悬浮窗窗口保存位置（null=使用百分比计算默认位置） */
   overlayX?: number | null
   overlayY?: number | null
+  /** 游戏全屏时自动隐藏悬浮窗（前台全屏应用会因置顶透明窗口掉帧，默认开启） */
+  gameAutoHide: boolean
 }
 
 /** OSD 悬浮窗窗口 label（与 Tauri 窗口创建对应，见 constants::WINDOWS） */
@@ -274,6 +276,7 @@ function defaultOsdConfig(): OsdConfig {
     alert: { ...DEFAULT_ALERT_CONFIG, maxValues: { ...DEFAULT_ALERT_CONFIG.maxValues } },
     overlayX: null,
     overlayY: null,
+    gameAutoHide: true,
   }
 }
 
@@ -308,6 +311,8 @@ export const useMonitorStore = defineStore('monitor', () => {
   const snapshot = ref<SensorSnapshot | null>(null)
   const kernelInfo = ref<MonitorKernelInfo | null>(null)
   const errorMsg = ref<string | null>(null)
+  /** 提权运行但 PawnIO 驱动缺失（CPU 温度/功耗大概率无法读取） */
+  const pawnIoMissing = ref(false)
   /** 累计收到的 monitor-data 事件数，用于诊断与"已连接"判定 */
   const eventCount = ref(0)
   /** 最近一次收到 monitor-data 的时间戳（ms） */
@@ -340,6 +345,10 @@ export const useMonitorStore = defineStore('monitor', () => {
    */
   const osdConfig = ref<OsdConfig>(loadOsdConfig())
 
+  /** 前台是否为全屏应用（游戏）。由 Rust 侧 osd-game-active/inactive 事件驱动，
+   *  用于游戏时隐藏 OSD（透明置顶窗口会占用 DWM 合成路径导致游戏掉帧） */
+  const gameFullscreen = ref(false)
+
   /** OSD 配置防抖保存：滑块/输入连续变化时合并为一次 localStorage 写入（避免每帧全量序列化） */
   let osdSaveTimer: ReturnType<typeof setTimeout> | null = null
   /** OSD 配置防抖推送定时器（initOsd 内注册的 deep watch 使用，dispose 时需清理） */
@@ -367,6 +376,8 @@ export const useMonitorStore = defineStore('monitor', () => {
   /** 推送 OSD 数据到所有 OSD 窗口（高频通道：仅显示项 key→value 映射 + 网速，每秒一次） */
   async function pushOsdState() {
     if (!osdConfig.value.overlayEnabled) return
+    // 游戏全屏自动隐藏期间停止推送：OSD 窗口已隐藏，推送只会白白消耗 IPC 和 WebView JS 时间片
+    if (gameFullscreen.value && osdConfig.value.gameAutoHide) return
     try {
       const map = sensorKeyMap.value
       const data: Record<string, number | null> = {}
@@ -681,10 +692,12 @@ export const useMonitorStore = defineStore('monitor', () => {
       // OSD 开启时同步推送（合并到每帧一次，避免与网速事件重复推送）
       if (osdConfig.value.overlayEnabled) scheduleOsdPush()
     }))
-    unlistenFns.push(await listen(EVENTS.monitorReady, () => {
+    unlistenFns.push(await listen<{ isAdmin?: boolean; pawnIoInstalled?: boolean }>(EVENTS.monitorReady, (e) => {
       refreshStatus()
       // Kernel 就绪后主动拉取一次快照，避免等待 SSE 首事件导致 UI 空白
       fetchSnapshot()
+      // PawnIO 驱动缺失检测：提权运行但仍缺驱动 → CPU 温度/功耗大概率无法读取
+      pawnIoMissing.value = e.payload?.isAdmin === true && e.payload?.pawnIoInstalled === false
     }))
     unlistenFns.push(await listen(EVENTS.monitorLoading, () => {
       // 后端正在等待 Kernel ready，刷新状态以反映 running=true
@@ -1145,6 +1158,22 @@ export const useMonitorStore = defineStore('monitor', () => {
       void pushOsdState()
     })
     osdEventUnlisteners.push(unlistenReq)
+    // 监听游戏全屏事件：前台出现全屏应用（游戏）时隐藏 OSD，
+    // 避免透明置顶悬浮窗占用 DWM 合成路径导致游戏掉帧；退出全屏后恢复。
+    const unlistenGameActive = await listen(EVENTS.osdGameActive, async () => {
+      gameFullscreen.value = true
+      if (osdConfig.value.overlayEnabled && osdConfig.value.gameAutoHide) {
+        await hideOverlayWindow()
+      }
+    })
+    osdEventUnlisteners.push(unlistenGameActive)
+    const unlistenGameInactive = await listen(EVENTS.osdGameInactive, async () => {
+      gameFullscreen.value = false
+      if (osdConfig.value.overlayEnabled && osdConfig.value.gameAutoHide) {
+        await ensureOverlayWindow()
+      }
+    })
+    osdEventUnlisteners.push(unlistenGameInactive)
   }
 
   /** initOsd 幂等守卫：监听/配置 watcher 只注册一次（App 启动 + 模块挂载均会调用） */
@@ -1190,12 +1219,24 @@ export const useMonitorStore = defineStore('monitor', () => {
       if (enabled) {
         // 开启时若显示项为空则不创建窗口
         if (osdConfig.value.overlayItems.length === 0) return
+        // 游戏全屏自动隐藏期间不创建窗口（退出全屏时由 osd-game-inactive 统一恢复）
+        if (gameFullscreen.value && osdConfig.value.gameAutoHide) return
         ensureOverlayWindow().catch(e => logger.error('[OSD] 创建悬浮窗失败: ' + e))
       } else {
         hideOverlayWindow().catch(e => logger.error('[OSD] 隐藏悬浮窗失败: ' + e))
       }
     }))
 
+    // 游戏中切换"自动隐藏"开关：立即生效（关闭时恢复显示，开启时立即隐藏）
+    osdWatchStops.push(watch(() => osdConfig.value.gameAutoHide, (enabled) => {
+      if (!osdConfig.value.overlayEnabled || !gameFullscreen.value) return
+      if (enabled) {
+        hideOverlayWindow().catch(e => logger.error('[OSD] 游戏全屏隐藏悬浮窗失败: ' + e))
+      } else {
+        ensureOverlayWindow().catch(e => logger.error('[OSD] 恢复悬浮窗失败: ' + e))
+      }
+    }))
+
     // 显示项变化时：无项则隐藏窗口，有项且开关开则确保窗口存在
     osdWatchStops.push(watch(() => osdConfig.value.overlayItems.length, (len) => {
       if (!osdConfig.value.overlayEnabled) return
@@ -1256,6 +1297,7 @@ export const useMonitorStore = defineStore('monitor', () => {
     snapshot,
     kernelInfo,
     errorMsg,
+    pawnIoMissing,
     eventCount,
     lastEventTime,
     starting,

src/stores/screenshotStore.ts

@@ -253,8 +253,48 @@ export const useScreenshotStore = defineStore('screenshot', () => {
     await ensureOverlay()
   }
 
-  async function openEditor() {
-    new WebviewWindow(`screenshot-editor-${Date.now()}`, {
+  // ===== 常驻截图编辑器窗口 =====
+  const EDITOR_LABEL = WINDOWS.screenshotEditor
+  let editorWin: WebviewWindow | null = null
+  let editorReadyUnlisten: UnlistenFn | null = null
+  let editorReadyListenerInit = false
+  let editorReadyResolve: (() => void) | null = null
+  let editorReadyPromise: Promise<void> | null = null
+
+  function resetEditorReady() {
+    editorReadyPromise = new Promise<void>((resolve) => {
+      editorReadyResolve = resolve
+    })
+  }
+
+  async function waitEditorReady() {
+    await Promise.race([
+      editorReadyPromise,
+      new Promise<void>((r) => setTimeout(r, 5000)),
+    ])
+  }
+
+  async function ensureEditorListener() {
+    if (editorReadyListenerInit) return
+    editorReadyListenerInit = true
+    resetEditorReady()
+    editorReadyUnlisten = await listen(EVENTS.screenshotEditorReady, () => {
+      editorReadyResolve?.()
+    })
+  }
+
+  /** 创建常驻编辑器窗口（隐藏，首次打开时创建一次，之后 show 复用不重建 WebView） */
+  async function ensureEditorWindow() {
+    if (editorWin) {
+      const existing = await WebviewWindow.getByLabel(EDITOR_LABEL).catch(() => null)
+      if (existing) {
+        editorWin = existing
+        return
+      }
+      editorWin = null
+    }
+    resetEditorReady()
+    editorWin = new WebviewWindow(EDITOR_LABEL, {
       url: 'index.html#screenshot-editor',
       title: '截图编辑器',
       width: 960,
@@ -268,10 +308,18 @@ export const useScreenshotStore = defineStore('screenshot', () => {
       resizable: true,
       shadow: true,
       focus: true,
-      visible: true,
+      visible: false,
     })
   }
 
+  /** 打开编辑器：确保常驻窗口就绪后通知其加载编辑器图片槽中的新图（图由 Rust 侧直接写入） */
+  async function openEditor() {
+    await ensureEditorListener()
+    await ensureEditorWindow()
+    await waitEditorReady()
+    await emit(EVENTS.screenshotEditorLoad)
+  }
+
   // ===== 历史 / 导出 =====
   /** 由完整 PNG base64 生成缩略图 data URL（canvas 缩放至 ~256px 宽，JPEG 压缩） */
   function makeThumb(pngBase64: string, width: number, height: number): Promise<string> {
@@ -468,6 +516,17 @@ export const useScreenshotStore = defineStore('screenshot', () => {
     })
   }
 
+  // ===== 滚动截图完成 → 进编辑器 =====
+  /** 滚动截图完成的监听（覆盖层通知 → 打开常驻编辑器；PNG 原始字节已由 Rust 写入编辑器图片槽） */
+  let scrollEditorUnlisten: UnlistenFn | null = null
+
+  async function initScrollEditorListener() {
+    if (scrollEditorUnlisten) return
+    scrollEditorUnlisten = await listen(EVENTS.scrollToEditor, () => {
+      void openEditor()
+    })
+  }
+
   // ===== 全局快捷键 =====
   /** 监听 Rust 侧 emit 的 'screenshot-shortcut' 事件（快捷键按下时触发） */
   async function initShortcutListener() {
@@ -627,6 +686,14 @@ export const useScreenshotStore = defineStore('screenshot', () => {
       pinReadyUnlisten()
       pinReadyUnlisten = null
     }
+    if (editorReadyUnlisten) {
+      editorReadyUnlisten()
+      editorReadyUnlisten = null
+    }
+    if (scrollEditorUnlisten) {
+      scrollEditorUnlisten()
+      scrollEditorUnlisten = null
+    }
   }
 
   function destroyShortcutListener() {
@@ -662,6 +729,7 @@ export const useScreenshotStore = defineStore('screenshot', () => {
     setPinShortcut,
     initExportListener,
     destroyExportListener,
+    initScrollEditorListener,
     initShortcutListener,
     initShortcutRegistration,
     destroyShortcutListener,

src/stores/updaterStore.ts

@@ -0,0 +1,163 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import { listen, type UnlistenFn } from '@tauri-apps/api/event'
+import { invoke } from '@tauri-apps/api/core'
+import { EVENTS } from '@/lib/constants'
+import { useMonitorStore } from '@/stores/monitorStore'
+import { createLogger } from '@/lib/logger'
+
+const logger = createLogger('updater')
+
+/** 更新进度事件载荷（与 Rust UpdateProgress 对应） */
+export interface UpdateProgress {
+  stage: string
+  percent: number
+  downloadedBytes: number
+  totalBytes: number | null
+  message: string
+}
+
+/**
+ * 应用 / ThingHK 内核更新的全局编排状态。
+ *
+ * 把更新进度与"need_stop 确认"从集团件作用域提升到全局 store：
+ * 切换模块导致 GeneralSettings 卸载后，进行中的下载进度、need_stop 等待、
+ * done 后的内核重启都能跨组件存活并正确完成，避免"切回来进度丢失 / 更新卡死 / 不重启内核"。
+ */
+export const useUpdaterStore = defineStore('updater', () => {
+  /** 应用本体更新中 */
+  const appUpdating = ref(false)
+  /** ThingHK 内核更新中 */
+  const kernelUpdating = ref(false)
+  /** 更新进度（下载/解压/need_stop/done 共用一条进度展示） */
+  const progress = ref<UpdateProgress | null>(null)
+  /** 应用更新下载中可取消（下载完成进入 applying 后不可取消） */
+  const downloadCancellable = ref(false)
+  /** ThingHK 内核包下载中可取消 */
+  const kernelDownloadCancellable = ref(false)
+  /** 停止监控内核的确认弹窗状态（need_stop 阶段由后端 event 触发） */
+  const thinghkConfirmState = ref<{
+    open: boolean
+    wasRunning: boolean
+    busy: boolean
+    resolved: boolean
+  }>({
+    open: false,
+    wasRunning: false,
+    busy: false,
+    resolved: false,
+  })
+
+  let subscribed = false
+  const unlisteners: UnlistenFn[] = []
+  let handlingNeedStop = false
+
+  /** 若应用被最小化/隐藏到后台，先弹到前台再显示确认框 */
+  const focusMain = () => {
+    invoke('quickpanel_focus_main_window').catch(() => { /* 忽略 */ })
+  }
+
+  /** need_stop：记录内核是否在运行，弹出确认框等待用户停止并继续 */
+  function handleNeedStop() {
+    if (handlingNeedStop) return
+    handlingNeedStop = true
+    try {
+      focusMain()
+      const monitor = useMonitorStore()
+      const wasRunning = monitor.status?.running ?? false
+      thinghkConfirmState.value = { open: true, wasRunning, busy: false, resolved: false }
+    } finally {
+      handlingNeedStop = false
+    }
+  }
+
+  /** 全局订阅 UPDATE_PROGRESS：need_stop / done / error 与组件挂载无关，切换标签不中断更新 */
+  async function subscribe() {
+    if (subscribed) return
+    subscribed = true
+    try {
+      unlisteners.push(
+        await listen<UpdateProgress>(EVENTS.updateProgress, (e) => {
+          progress.value = e.payload
+          const p = e.payload
+          if (p.stage === 'need_stop') {
+            handleNeedStop()
+          } else if (p.stage === 'done') {
+            const wasRunning = thinghkConfirmState.value.wasRunning
+            kernelUpdating.value = false
+            progress.value = null
+            // 更新前内核在运行 → 替换完成后恢复（重启内核），保持内核状态
+            if (wasRunning) {
+              const monitor = useMonitorStore()
+              void monitor.start()
+            }
+          } else if (p.stage === 'error') {
+            kernelUpdating.value = false
+            progress.value = null
+          }
+        }),
+      )
+    } catch (e) {
+      logger.error('[updater] 订阅更新进度失败: ' + e)
+    }
+  }
+
+  /** 确认停止内核并唤醒后端 apply 继续解压替换 */
+  async function confirmNeedStop() {
+    const s = thinghkConfirmState.value
+    if (s.resolved) return
+    s.resolved = true
+    s.busy = true
+    try {
+      if (s.wasRunning) {
+        const monitor = useMonitorStore()
+        await monitor.stop()
+      }
+      await invoke('update_thinghk_confirm')
+    } catch (e) {
+      logger.error('[updater] 停止监控内核失败: ' + e)
+      // 停止失败则中止更新，避免替换阶段因 exe 占用而报错
+      try {
+        await invoke('update_thinghk_cancel')
+      } catch { /* 忽略 */ }
+    } finally {
+      s.busy = false
+      s.open = false
+    }
+  }
+
+  /** 取消 ThingHK 内核更新（中止后端等待中的 apply 流程） */
+  function cancelNeedStop() {
+    const s = thinghkConfirmState.value
+    if (s.resolved) return
+    s.resolved = true
+    s.open = false
+    invoke('update_thinghk_cancel').catch(() => { /* 忽略 */ })
+  }
+
+  /** 复位全局更新状态（订阅与状态一并清理，供测试/异常恢复用） */
+  function reset() {
+    appUpdating.value = false
+    kernelUpdating.value = false
+    progress.value = null
+    downloadCancellable.value = false
+    kernelDownloadCancellable.value = false
+    thinghkConfirmState.value = { open: false, wasRunning: false, busy: false, resolved: false }
+    subscribed = false
+    unlisteners.forEach((fn) => fn())
+    unlisteners.length = 0
+  }
+
+  return {
+    appUpdating,
+    kernelUpdating,
+    progress,
+    downloadCancellable,
+    kernelDownloadCancellable,
+    thinghkConfirmState,
+    subscribe,
+    confirmNeedStop,
+    cancelNeedStop,
+    reset,
+  }
+})

vite.config.ts

@@ -54,14 +54,16 @@ export default defineConfig(async () => ({
   clearScreen: false,
   // 2. tauri expects a fixed port, fail if that port is not available
   server: {
-    port: 1420,
+    // 1420/1421 落在 Windows 保留端口段 1333-1432 内（Hyper-V/WinNAT 动态保留），
+    // 绑定时报 EACCES，故改用 14210/14211（netsh excludedportrange 确认可用）
+    port: 14210,
     strictPort: true,
     host: host || false,
     hmr: host
       ? {
         protocol: "ws",
         host,
-        port: 1421,
+        port: 14211,
       }
       : undefined,
     watch: {