dsh-disk-cleaner 1.0.1 → 1.2.0

package/README.md

@@ -5,7 +5,7 @@
 <!-- badges -->
 | | |
 | --- | --- |
-| **version** | `1.0.0` |
+| **version** | `1.2.0` |
 | **DSH** | `0.2.1-rc.5`（开发与实测版本；用到 `plugins.bundle.config`、`settings.section`） |
 | **license** | [MIT](LICENSE) |
 | **Node** | `>= 22`（仅运行冒烟测试需要） |
@@ -16,7 +16,7 @@
 
 **dsh-disk-cleaner** is a disk-space plugin for [DeepSeek Harness](https://github.com/deepseek-ai) (DSH). It does two different jobs, and keeps them apart on purpose:
 
-1. **Clean** — thirteen known-safe cache locations (temp folders, package manager stores, browser caches, crash dumps, the Recycle Bin). Only these are ever deleted.
+1. **Clean** — nineteen known-safe locations (temp folders, package manager stores, browser caches, crash dumps, the Recycle Bin, leftover update installers, per-app caches and logs, superseded plugin versions and applied update packages). Only these are ever deleted.
 2. **Assess** — everything the plugin will *not* delete (installed programs, the WSL virtual disk, the Windows component store, chat-app data, your own folders). Measured and listed, never removed.
 
 The assessment ends with a **plan**: the same numbers ordered by what it costs you to act, with the exact Windows command for the steps the plugin cannot perform itself.
@@ -27,16 +27,17 @@ Both the panel and the agent reach the *same* operations: the cleaning logic liv
 
 | Feature | Description |
 | --- | --- |
-| Scan | Measures all thirteen targets concurrently and shows what each occupies |
+| Scan | Measures all nineteen targets concurrently and shows what each occupies |
 | Per-drive filter | Chip row of mounted volumes; scanning or cleaning can be limited to one drive, and rows with nothing on that drive disappear |
-| Risk labels | Every target is `safe` or `caution`, with a one-line reason (`in-use` / `rebuild` / `elevation`) and a permanent legend, so "caution" never means "unspecified" |
+| Risk labels | Every target is `safe` or `caution`, with a one-line reason (`in-use` / `rebuild` / `elevation` / `pending-update` / `rollback` / `superseded`) and a permanent legend, so "caution" never means "unspecified" |
 | Aged deletion | `temp` and `windows-temp` only remove files older than one day; files a running program still holds are skipped |
-| Space assessment | Walks the disk read-only and groups the result into Windows / installed software / your own files, plus the ten largest app-data folders |
+| Space assessment | Walks the disk read-only and groups the result into Windows / installed software / your own files, plus the ten largest app-data folders. Any row opens its folder in Explorer — click, right click, or Enter |
+| Honest re-run | Re-running the assessment re-measures; a plain call still answers from the ten-minute cache |
 | Plan | Nine possible steps, ordered from zero-cost to your-decision-only; the steps the plugin can run have a button, the rest have a copyable command |
 | Entry placement | Sidebar icon, settings section, or both (default) — switched from the plugin's own config card or the panel's ⚙ button |
 | Behaviour settings | What is preselected after a scan, and whether deleting asks first |
 | Panel memory | Scan results, the selection and the assessment survive switching to another panel and back |
-| Agent tool | `disk_cleaner` exposes the same four actions to the model, in readable prose |
+| Agent tool | `disk_cleaner` exposes the same five actions to the model, in readable prose |
 | Bilingual | Follows the host locale service; zh and en dictionaries ship together |
 
 ### Cleanup targets
@@ -58,12 +59,18 @@ Every path is built from this table — a caller selects an **id**, never a path
 | `windows-update` | `C:\Windows\SoftwareDistribution\Download` | purge | caution | needs elevation |
 | `recycle-bin` | `$Recycle.Bin\S-1-5-*` on every mounted volume | purge | safe | it is the Recycle Bin |
 | `inet-cache` | `%LOCALAPPDATA%\Microsoft\Windows\INetCache` | purge | caution | rebuilt |
+| `app-updaters` | `*-updater` folders under `%LOCALAPPDATA%` and `%APPDATA%` — the installers app updaters leave behind | aged, 3 days | caution | a download from the last three days may still be a pending update |
+| `app-caches` | named cache folders inside `%APPDATA%`: the WPS CEF cache, FTNN `cef_cache`, and the `Cache` / `Code Cache` / `CachedData` / `GPUCache` of Qoder, Trae, the DSH desktop app, PersonalCenter, the WeChat devtools and QQ PC Manager | purge | caution | CEF and Chromium caches rebuild on next start |
+| `app-logs` | log folders inside `%APPDATA%`: FTNN, WeChat, Qoder, Trae, DingTalk, PersonalCenter, Clash Verge | purge | safe | nothing reads an old log back at runtime |
+| `app-temp` | scratch folders apps keep inside their own `%APPDATA%` folder instead of `%TEMP%`: `WorkDaddy\client-tmp`, `PersonalCenter\Temp` | aged, 2 days | caution | the owning app may be running and holding files |
+| `plugin-old-versions` | every version but the newest of each family in the WPS plugin pool `kingsoft\wps\addons\pool\win-i386` | purge | caution | the manager loads the newest; the rest are rollback copies |
+| `update-packages` | update packages already applied: FTNN `.spd` patches whose build number is below the newest `Program Files\FTNN\app\[version]`, and `WorkDaddy\update` installers below the installed version | purge | caution | decided by version comparison, not by age |
 
 `aged` targets skip anything modified within the retention window; `purge` targets remove every entry. Both keep the target directory itself and leave locked entries alone, counting them as skipped.
 
 ### Space assessment areas
 
-`wsl` (ext4.vhdx images), `winsxs`, `system-files` (hiberfil / pagefile / swapfile), `programs` (user scope), `program-files` (machine scope), `downloads`, `documents`, `pictures`, `videos`, `desktop`. An area that does not exist is dropped rather than reported as zero. The ten largest folders under `%LOCALAPPDATA%` and `%APPDATA%` (≥100 MB each) are listed separately, because "3.6 GB in Roaming\kingsoft" points somewhere a Settings page does not.
+`wsl` (ext4.vhdx images), `winsxs`, `system-files` (hiberfil / pagefile / swapfile), `programs` (user scope), `program-files` (machine scope), `old-versions` (builds an installer kept for rollback), `update-payloads` (setup and installer files sitting in temp and app-data), `downloads`, `documents`, `pictures`, `videos`, `desktop`. An area that does not exist is dropped rather than reported as zero. The ten largest folders under `%LOCALAPPDATA%` and `%APPDATA%` (≥100 MB each) are listed separately, because "3.6 GB in Roaming\kingsoft" points somewhere a Settings page does not.
 
 ### Plan steps
 
@@ -99,10 +106,12 @@ Panel state (drives, drive filter, scan rows, selection, notices, assessment) is
 
 | Argument | Type | Notes |
 | --- | --- | --- |
-| `action` | `overview` \| `scan` \| `clean` \| `audit` | required |
+| `action` | `overview` \| `scan` \| `clean` \| `audit` \| `reveal` | required |
 | `ids` | string[] | catalog ids; required for `clean`, max 32 |
 | `drive` | string | `C:` / `D:\` — limits the work to one volume |
 | `confirm` | boolean | without it, `clean` is a dry run |
+| `force` | boolean | `audit` re-measures instead of answering from the 10-minute cache |
+| `area` / `scope` + `name` / `index` | | `reveal` names what to open; never a path |
 
 `clean` without `confirm: true` deletes nothing and reports what it would free — that is the approval path. `audit` is read-only and returns the plan in prose, ending with "Report that plan to the user; never run those commands yourself."
 
@@ -113,11 +122,12 @@ One route, `POST /api/disk-cleaner/`, used by the panel:
 ```jsonc
 {"action":"overview"}                          // drives + target ids
 {"action":"scan","drive":"C:"}                 // measured targets
-{"action":"audit"}                             // areas + largest apps + plan
+{"action":"audit","force":true}                // areas + largest apps + plan
+{"action":"reveal","area":"downloads"}         // opens it in Explorer
 {"action":"clean","ids":["temp"],"confirm":true}
 ```
 
-POST only (405 otherwise), same-origin only (403 otherwise), body ≤4096 bytes, at most 32 ids, unknown ids or actions rejected with 400. Handlers never receive a path.
+POST only (405 otherwise), same-origin only (403 otherwise), body ≤4096 bytes, at most 32 ids, unknown ids or actions rejected with 400. Handlers never receive a path: `reveal` names an assessment area (or an app folder by scope and name), the host rebuilds the path from the same table that measured it, and hands that to `explorer.exe`.
 
 ### Safety rules
 
@@ -165,7 +175,7 @@ The bundle's own `cordis.patch.yml` inserts the plugin row; no profile patch edi
 ### Development
 
 ```bash
-node smoke.mjs                       # 61 assertions, zero dependencies
+node smoke.mjs                       # 67 assertions, zero dependencies
 node --check lib/client.js           # and lib/index.js, lib/catalog.js, lib/audit.js, lib/plan.js
 ```
 
@@ -182,7 +192,9 @@ What the smoke test deliberately does **not** cover: anything that walks a real
 | Client bundle executes, slots register and dispose | `node smoke.mjs` (real bundle in a fake DOM) |
 | Settings reach the plugin page, the settings section and the panel | `node smoke.mjs` + `cordis_inspect_query` slot occupants |
 | Route and tool registered | `node smoke.mjs` (throwaway `ctx`) |
-| `overview` / `scan` / `clean` / `audit` round-trip | Real `POST /api/disk-cleaner/` against a live host |
+| `overview` / `scan` / `clean` / `audit` / `reveal` round-trip | Real `POST /api/disk-cleaner/` against a live host |
+| Re-run bypasses the cache, a plain call still uses it | `audit` twice: `cached: false`, then `true` |
+| `reveal` refuses a path and a traversal | `name: "../.."`, and a request with neither area nor name → 400 |
 | Real deletion keeps the target directory, honours the age limit | Temp directory seeded with old and new files |
 | Dry run deletes nothing | `confirm` omitted, byte counts unchanged |
 | Drive filter rejects unmounted and malformed volumes | `C:extra`, `Z:`, `abc` → 400 |
@@ -200,7 +212,8 @@ What the smoke test deliberately does **not** cover: anything that walks a real
 ### Known ceilings
 
 - **Windows only.** Paths are built from the Windows layout; there is no POSIX branch.
-- **First assessment takes 40–60 s.** Named areas and the per-app folder list walk overlapping trees. A result is cached for 10 minutes and invalidated by a real deletion, so only the first caller pays. `ponytail:` comment in `lib/audit.js` records the shared-map alternative.
+- **First assessment takes 30–60 s.** Named areas and the per-app folder list walk overlapping trees. A result is cached for 10 minutes and invalidated by a real deletion, so only the first caller pays; the panel's re-run button passes `force` and always pays it. `ponytail:` comment in `lib/audit.js` records the shared-map alternative.
+- **Leftover installers are cleaned by age, not by knowledge.** `*-updater` folders are recognised by name; a download from the last three days is left alone because only the app knows whether it has been applied.
 - **No elevation.** The one Windows directory that refuses an unelevated write is reported, never attempted.
 - **No uninstall, no move.** Steps the plugin cannot perform carry a command instead of a button.
 - **Traversal caps** at 2,000,000 entries per walk, so an absurdly large tree is measured partially rather than hanging.
@@ -210,16 +223,16 @@ What the smoke test deliberately does **not** cover: anything that walks a real
 ```
 ├─ package.json           dsh.bundle.patch + dsh.client { platform: "web" }
 ├─ cordis.patch.yml       - insert:  id: dsh-disk-cleaner
-├─ lib/index.js    (330)  Host: HTTP route + disk_cleaner tool, same run() for both
-├─ lib/catalog.js  (413)  The 13 targets, measurePath / purgePath / resolveTargets / drives
-├─ lib/audit.js    (262)  Read-only assessment, 10-minute cache, exposes no deletion
+├─ lib/index.js    (405)  Host: HTTP route + disk_cleaner tool, same run() for both; reveal
+├─ lib/catalog.js  (688)  The 19 targets, measurePath / purgePath / resolveTargets / drives
+├─ lib/audit.js    (365)  Read-only assessment, 10-minute cache, areaPaths, exposes no deletion
 ├─ lib/plan.js     (150)  Pure: measurements → ordered steps
-├─ lib/client.js  (1234)  Client half: slots, panel, preferences, zh/en dictionaries, CSS
+├─ lib/client.js  (1355)  Client half: slots, panel, preferences, zh/en dictionaries, CSS
 ├─ locale/{en,zh}.json    Display metadata (meta.title / meta.description)
 ├─ icon.svg               Plugin icon
 ├─ README.md              This file
 ├─ LICENSE                MIT
-└─ smoke.mjs              61 assertions, zero dependencies
+└─ smoke.mjs              67 assertions, zero dependencies
 ```
 
 Client-half slots: `sidebar.panellist` (order 50, disposed in settings-only mode), `main` (keyed by the package name), `settings.section` (order 30, disposed in sidebar-only mode), `plugins.bundle.config` (keyed by the package name).
@@ -231,7 +244,7 @@ Client-half slots: `sidebar.panellist` (order 50, disposed in settings-only mode
 
 **dsh-disk-cleaner** 是 [DeepSeek Harness](https://github.com/deepseek-ai)（DSH）的磁盘空间插件。它做两件不同的事，并且刻意分开：
 
-1. **清理** —— 十三个已知安全的缓存位置（临时目录、包管理器存储、浏览器缓存、崩溃转储、回收站）。只有这些会被删除。
+1. **清理** —— 十九个已知安全的位置（临时目录、包管理器存储、浏览器缓存、崩溃转储、回收站、更新安装包残留、各应用的缓存与日志、被淘汰的插件版本与已应用的更新包）。只有这些会被删除。
 2. **评估** —— 所有本插件**不会**删的东西（已装程序、WSL 虚拟磁盘、Windows 组件库、聊天软件数据、你自己的文件夹）。只测量、只列出，绝不删除。
 
 评估的最后是一份**处理方案**：同一批数字按「你要付出多少代价」排序，本插件做不到的步骤附上确切的 Windows 命令。
@@ -242,16 +255,17 @@ Client-half slots: `sidebar.panellist` (order 50, disposed in settings-only mode
 
 | 功能 | 说明 |
 | --- | --- |
-| 扫描 | 并发测量全部十三个目标，显示各自占用 |
+| 扫描 | 并发测量全部十九个目标，显示各自占用 |
 | 按盘过滤 | 已挂载卷的胶囊按钮；扫描与清理都可限定单盘，该盘上为空的项会隐藏 |
-| 风险标注 | 每个目标都标 `安全` 或 `注意`，并给一行理由（`in-use` / `rebuild` / `elevation`），图例常驻，所以「注意」永远不是「说不清」 |
+| 风险标注 | 每个目标都标 `安全` 或 `注意`，并给一行理由（`in-use` / `rebuild` / `elevation` / `pending-update` / `rollback` / `superseded`），图例常驻，所以「注意」永远不是「说不清」 |
 | 保留期删除 | `temp` 与 `windows-temp` 只删一天前的文件；被运行中程序占住的自动跳过 |
-| 空间评估 | 只读遍历磁盘，按 Windows 自身 / 已装软件 / 你自己的文件 分组，另列占用最大的十个应用数据目录 |
+| 空间评估 | 只读遍历磁盘，按 Windows 自身 / 已装软件 / 你自己的文件 分组，另列占用最大的十个应用数据目录。每一行都能打开所在目录——单击、右键或回车 |
+| 重新评估真的重测 | 「重新评估」会重新测量；普通调用仍然走十分钟缓存 |
 | 处理方案 | 九种可能步骤，从零风险到只能你决定；本插件能执行的带按钮，其余给可复制的命令 |
 | 入口位置 | 侧边栏图标、设置页分区、或两者都要（默认）——在插件自己的配置卡或面板 ⚙ 里切换 |
 | 行为设置 | 扫描后默认勾选什么、删除前是否确认 |
 | 面板记忆 | 扫描结果、勾选、评估结果在切走再回来时都还在 |
-| Agent 工具 | `disk_cleaner` 把同样的四个动作以可读文本交给模型 |
+| Agent 工具 | `disk_cleaner` 把同样的五个动作以可读文本交给模型 |
 | 双语 | 跟随宿主语言服务，zh / en 字典一起发布 |
 
 ### 清理目标
@@ -273,12 +287,18 @@ Client-half slots: `sidebar.panellist` (order 50, disposed in settings-only mode
 | `windows-update` | `C:\Windows\SoftwareDistribution\Download` | 全清 | 注意 | 需要管理员权限 |
 | `recycle-bin` | 各已挂载卷的 `$Recycle.Bin\S-1-5-*` | 全清 | 安全 | 就是回收站 |
 | `inet-cache` | `%LOCALAPPDATA%\Microsoft\Windows\INetCache` | 全清 | 注意 | 会重建 |
+| `app-updaters` | `%LOCALAPPDATA%` 与 `%APPDATA%` 下的 `*-updater` 目录——升级程序留下的安装包 | 保留期 3 天 | 注意 | 三天内的下载可能还是待安装的更新 |
+| `app-caches` | `%APPDATA%` 里点名列出的缓存目录：WPS 的 CEF 缓存、FTNN 的 `cef_cache`，以及 Qoder、Trae、DSH 桌面端、PersonalCenter、微信开发者工具、腾讯电脑管家的 `Cache` / `Code Cache` / `CachedData` / `GPUCache` | 全清 | 注意 | CEF 与 Chromium 缓存会在下次启动时重建 |
+| `app-logs` | `%APPDATA%` 里的日志目录：FTNN、微信、Qoder、Trae、钉钉、PersonalCenter、Clash Verge | 全清 | 安全 | 旧日志运行时不会被读回 |
+| `app-temp` | 应用自己放在 `%APPDATA%` 里的临时目录（不走 `%TEMP%`）：`WorkDaddy\client-tmp`、`PersonalCenter\Temp` | 保留期 2 天 | 注意 | 应用可能正在运行并占用其中的文件 |
+| `plugin-old-versions` | WPS 插件池 `kingsoft\wps\addons\pool\win-i386` 里，每个插件族除最高版本以外的全部版本 | 全清 | 注意 | 管理器加载最高版本，其余是回滚副本 |
+| `update-packages` | 已应用的更新包：FTNN 的 `.spd` 补丁（build 号低于 `Program Files\FTNN\app\[版本]` 中最新者），以及 `WorkDaddy\update` 里低于已装版本的安装包 | 全清 | 注意 | 按版本号比较判断，不按时间 |
 
 保留期方式会跳过保留期内修改过的文件；全清方式清掉全部条目。两者都保留目标目录本身，并把锁定或无权限的条目跳过计数。
 
 ### 空间评估范围
 
-`wsl`（ext4.vhdx 映像）、`winsxs`、`system-files`（hiberfil / pagefile / swapfile）、`programs`（用户级）、`program-files`（机器级）、`downloads`、`documents`、`pictures`、`videos`、`desktop`。不存在的范围直接略去，不报成 0。`%LOCALAPPDATA%` 与 `%APPDATA%` 下超过 100 MB 的十个最大目录另外列出——因为「Roaming\kingsoft 占 3.6 GB」指向的地方，设置页里根本找不到。
+`wsl`（ext4.vhdx 映像）、`winsxs`、`system-files`（hiberfil / pagefile / swapfile）、`programs`（用户级）、`program-files`（机器级）、`old-versions`（安装器留给回滚的旧版本目录）、`update-payloads`（临时目录与应用数据里躺着的 setup / installer 文件）、`downloads`、`documents`、`pictures`、`videos`、`desktop`。不存在的范围直接略去，不报成 0。`%LOCALAPPDATA%` 与 `%APPDATA%` 下超过 100 MB 的十个最大目录另外列出——因为「Roaming\kingsoft 占 3.6 GB」指向的地方，设置页里根本找不到。
 
 ### 处理方案步骤
 
@@ -314,10 +334,12 @@ Client-half slots: `sidebar.panellist` (order 50, disposed in settings-only mode
 
 | 参数 | 类型 | 说明 |
 | --- | --- | --- |
-| `action` | `overview` \| `scan` \| `clean` \| `audit` | 必填 |
+| `action` | `overview` \| `scan` \| `clean` \| `audit` \| `reveal` | 必填 |
 | `ids` | string[] | catalog id；`clean` 必填，最多 32 个 |
 | `drive` | string | `C:` / `D:\`，把操作限定在一块盘 |
 | `confirm` | boolean | 不传时 `clean` 只做试运行 |
+| `force` | boolean | `audit` 跳过 10 分钟缓存重新测量 |
+| `area` / `scope` + `name` / `index` | | `reveal` 用它说明要打开什么，从不传路径 |
 
 不带 `confirm: true` 的 `clean` 一个字节都不删，只报告本来能释放多少——这就是审批路径。`audit` 只读，并以文本返回处理方案，结尾固定为「把方案报告给用户，不要自己执行这些命令」。
 
@@ -328,11 +350,12 @@ Client-half slots: `sidebar.panellist` (order 50, disposed in settings-only mode
 ```jsonc
 {"action":"overview"}                          // 磁盘容量 + 目标 id
 {"action":"scan","drive":"C:"}                 // 测量后的目标
-{"action":"audit"}                             // 范围 + 最大应用目录 + 方案
+{"action":"audit","force":true}                // 范围 + 最大应用目录 + 方案
+{"action":"reveal","area":"downloads"}         // 在资源管理器中打开
 {"action":"clean","ids":["temp"],"confirm":true}
 ```
 
-只接受 POST（否则 405），只接受同源（否则 403），body ≤4096 字节，id 最多 32 个，未知 id 或动作返回 400。处理器永远收不到路径。
+只接受 POST（否则 405），只接受同源（否则 403），body ≤4096 字节，id 最多 32 个，未知 id 或动作返回 400。处理器永远收不到路径：`reveal` 只报一个评估范围（或 scope + name 表示的应用目录），宿主用当初测量它的那张表重建路径，再交给 `explorer.exe`。
 
 ### 安全规则
 
@@ -384,7 +407,7 @@ git clone https://github.com/stallenlu/dsh-disk-cleaner
 ### 开发
 
 ```bash
-node smoke.mjs                       # 61 条断言，零依赖
+node smoke.mjs                       # 67 条断言，零依赖
 node --check lib/client.js           # 以及 lib/index.js、lib/catalog.js、lib/audit.js、lib/plan.js
 ```
 
@@ -401,7 +424,9 @@ node --check lib/client.js           # 以及 lib/index.js、lib/catalog.js、li
 | client bundle 能执行、slot 能注册与拆除 | `node smoke.mjs`（假 DOM 里跑真 bundle） |
 | 设置能到达插件页、设置页、面板三处 | `node smoke.mjs` + `cordis_inspect_query` 查 slot 占用 |
 | 路由与工具已注册 | `node smoke.mjs`（一次性 `ctx`） |
-| 四个动作端到端 | 对真实宿主 `POST /api/disk-cleaner/` |
+| 五个动作端到端 | 对真实宿主 `POST /api/disk-cleaner/` |
+| 「重新评估」绕过缓存、普通调用仍走缓存 | 连调两次 `audit`：`cached` 先 false 后 true |
+| `reveal` 拒绝路径与目录穿越 | `name: "../.."`，以及既无 area 又无 name → 400 |
 | 真删保留目标目录、遵守保留期 | 在 Temp 里造一旧一新两个文件验证 |
 | 试运行不删任何东西 | 不传 `confirm`，字节数不变 |
 | 盘过滤拒绝未挂载与畸形卷名 | `C:extra`、`Z:`、`abc` → 400 |
@@ -419,7 +444,8 @@ node --check lib/client.js           # 以及 lib/index.js、lib/catalog.js、li
 ### 已知上限
 
 - **仅 Windows。** 路径按 Windows 目录布局构造，没有 POSIX 分支。
-- **首次评估 40–60 秒。** 命名范围与「最大应用目录」会遍历重叠的树。结果缓存 10 分钟，并在真删后失效，所以只有第一个调用者付这笔钱。`lib/audit.js` 里有 `ponytail:` 注释记录「共享 Map」这个替代方案。
+- **首次评估 30–60 秒。** 命名范围与「最大应用目录」会遍历重叠的树。结果缓存 10 分钟，并在真删后失效，所以只有第一个调用者付这笔钱；面板的「重新评估」会传 `force`，每次都要重付。`lib/audit.js` 里有 `ponytail:` 注释记录「共享 Map」这个替代方案。
+- **更新安装包按时间清理，不靠识别版本。** `*-updater` 目录靠名字认；三天内的下载一律不动，因为只有应用自己知道它装了没有。
 - **不提权。** 那个拒绝普通权限写入的 Windows 目录只报告，不尝试删除。`C:\Windows\Temp` **不是**其中之一：默认 ACL 给 `BUILTIN\Users` 创建与删除权限，挡住删除的只是被服务占用的 EBUSY，而保留期已经处理了这一类。
 - **不卸载、不迁移。** 本插件做不到的步骤给命令，不给按钮。
 - **遍历上限**每棵树 2,000,000 条目，极端大的树会被部分测量，而不是卡死。
@@ -429,16 +455,16 @@ node --check lib/client.js           # 以及 lib/index.js、lib/catalog.js、li
 ```
 ├─ package.json           dsh.bundle.patch + dsh.client { platform: "web" }
 ├─ cordis.patch.yml       - insert:  id: dsh-disk-cleaner
-├─ lib/index.js    (330)  Host：HTTP 路由 + disk_cleaner 工具，共用同一个 run()
-├─ lib/catalog.js  (413)  13 个目标，measurePath / purgePath / resolveTargets / drives
-├─ lib/audit.js    (262)  只读评估，10 分钟缓存，不暴露任何删除
+├─ lib/index.js    (405)  Host：HTTP 路由 + disk_cleaner 工具，共用同一个 run()，含 reveal
+├─ lib/catalog.js  (688)  19 个目标，measurePath / purgePath / resolveTargets / drives
+├─ lib/audit.js    (365)  只读评估，10 分钟缓存，带 areaPaths，不暴露任何删除
 ├─ lib/plan.js     (150)  纯函数：测量结果 → 有序步骤
-├─ lib/client.js  (1234)  Client 半面：slot、面板、偏好、zh/en 字典、CSS
+├─ lib/client.js  (1355)  Client 半面：slot、面板、偏好、zh/en 字典、CSS
 ├─ locale/{en,zh}.json    展示元数据（meta.title / meta.description）
 ├─ icon.svg               插件图标
 ├─ README.md              本文件
 ├─ LICENSE                MIT
-└─ smoke.mjs              61 条断言，零依赖
+└─ smoke.mjs              67 条断言，零依赖
 ```
 
 Client 半面注册的 slot：`sidebar.panellist`（order 50，仅设置页模式下拆除）、`main`（以包名为 key）、`settings.section`（order 30，仅侧边栏模式下拆除）、`plugins.bundle.config`（以包名为 key）。

package/lib/audit.js

@@ -13,12 +13,15 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 
-import { drives, measurePath, scan } from './catalog.js';
+import { appVersionDirs, drives, measurePath, scan } from './catalog.js';
 import { buildPlan } from './plan.js';
 
 const { promises: fsp } = fs;
 
 const MB = 1024 * 1024;
+/** A downloaded installer below this is noise; the multi-hundred-MB ones are the point. */
+const PAYLOAD_FLOOR = 50 * MB;
+const PAYLOAD_NAME = /(setup|installer|-upd-|\.msix$|\.nupkg$|\.msi$)/i;
 
 const env = (name) => {
   const value = process.env[name];
@@ -90,6 +93,20 @@ const AREAS = () => {
       why: 'Machine-wide applications. Uninstall through Settings.',
       paths: () => [path.join(systemDrive + path.sep, 'Program Files'), path.join(systemDrive + path.sep, 'Program Files (x86)')],
     },
+    {
+      id: 'old-versions',
+      group: 'app',
+      label: 'Superseded app versions',
+      why: 'An installer kept the previous build beside the current one for rollback. Safe to open and delete by hand; naming a version is the only way to be sure which one is live.',
+      paths: () => appVersionDirs(),
+    },
+    {
+      id: 'update-payloads',
+      group: 'app',
+      label: 'Downloaded update packages',
+      why: 'Installer executables an updater left in Temp or its own folder after applying. The "app-updaters" cleanup target covers the ones old enough to be finished; this line shows every one still on disk.',
+      files: () => updatePayloads(),
+    },
     {
       id: 'downloads',
       group: 'personal',
@@ -128,6 +145,53 @@ const AREAS = () => {
   ];
 };
 
+/**
+ * Installer executables that updating software downloads and then leaves behind. They are
+ * found by name and size inside the handful of folders updates actually land in, so this
+ * stays a bounded directory read rather than another full-disk walk.
+ */
+const updatePayloads = () => {
+  const out = [];
+  const roots = [path.join(env('LOCALAPPDATA') ?? '', 'Temp'), env('LOCALAPPDATA'), env('APPDATA')].filter(Boolean);
+  for (const root of roots) {
+    if (!isDir(root)) continue;
+    for (const entry of listDir(root)) {
+      if (entry.isSymbolicLink()) continue;
+      const abs = path.join(root, entry.name);
+      if (entry.isFile()) {
+        if (bigPayload(entry.name, abs)) out.push(abs);
+        continue;
+      }
+      // One level down: `Temp/<app>-update-x64/Setup.exe`, `Roaming/<app>/update/x.exe`.
+      for (const inner of listDir(abs)) {
+        if (!inner.isFile() || inner.isSymbolicLink()) continue;
+        const file = path.join(abs, inner.name);
+        if (bigPayload(inner.name, file)) out.push(file);
+      }
+    }
+  }
+  return out;
+};
+
+const bigPayload = (name, abs) => {
+  if (!PAYLOAD_NAME.test(name)) return false;
+  try {
+    const stat = fs.statSync(abs);
+    return stat.isFile() && stat.size >= PAYLOAD_FLOOR;
+  } catch {
+    return false;
+  }
+};
+
+/** `readdirSync` that answers an empty list instead of throwing on a denied directory. */
+const listDir = (parent) => {
+  try {
+    return fs.readdirSync(parent, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+};
+
 /** WSL keeps one ext4.vhdx per distro, one level down under a GUID-named folder. */
 const virtualDisks = (root) => {
   if (!isDir(root)) return [];
@@ -180,9 +244,13 @@ export function invalidateAudit() {
  * on a full disk), so a result is reused for a short while: the panel and the agent ask
  * for the same picture within moments of each other, and re-walking every app folder for
  * the second caller buys nothing.
+ *
+ * `force` is what the panel's re-run button passes. Without it that button would answer
+ * from the cache and appear to do nothing, which is exactly the complaint it exists to fix.
  */
-export async function audit() {
-  if (cached !== undefined && Date.now() - cachedAt < CACHE_TTL) return { ...cached, cached: true };
+export async function audit(options = {}) {
+  const force = options.force === true;
+  if (!force && cached !== undefined && Date.now() - cachedAt < CACHE_TTL) return { ...cached, cached: true };
   const [areas, largestApps, reclaimable] = await Promise.all([
     Promise.all(AREAS().map(measureArea)),
     largestAppDirs(),
@@ -195,33 +263,67 @@ export async function audit() {
   return { ...cached, cached: false };
 }
 
-/** Measure one area, or return null when none of its locations exist. */
+/**
+ * The concrete locations behind one area id, for opening in Explorer. Recomputed from the
+ * area definition rather than sent by the caller, so a reveal request names an area, never
+ * a path.
+ */
+export function areaPaths(id) {
+  const area = AREAS().find((entry) => entry.id === id);
+  if (area === undefined) return [];
+  const out = [];
+  for (const abs of [...(area.files?.() ?? []), ...(area.paths?.() ?? [])]) {
+    try {
+      fs.statSync(abs);
+      out.push(abs);
+    } catch {
+      /* measured a moment ago, gone since, or simply not present */
+    }
+  }
+  return out;
+}
+
+/** Measure one area, or return null when none of its locations exist.
+ *
+ * `paths` is the concrete list the panel offers to open in Explorer, so a number in the
+ * assessment is one double-click away from the folder it came from. It is capped: an area
+ * like "installed programs" has hundreds of subfolders, and the panel only needs enough to
+ * get the user there.
+ */
+const AREA_PATHS = 8;
+
 async function measureArea(area) {
   let bytes = 0;
   let files = 0;
-  let present = 0;
-  let first;
+  const paths = [];
 
   for (const file of area.files?.() ?? []) {
     const size = sizeOfFile(file);
-    if (size > 0) {
-      bytes += size;
-      files += 1;
-      present += 1;
-      first ??= file;
-    }
+    if (size <= 0) continue;
+    bytes += size;
+    files += 1;
+    paths.push(file);
   }
   for (const abs of area.paths?.() ?? []) {
     const found = isDir(abs) ? await measurePath(abs) : { bytes: sizeOfFile(abs), files: 1 };
     if (found.bytes <= 0 && found.files <= 0) continue;
     bytes += found.bytes;
     files += found.files;
-    present += 1;
-    first ??= abs;
+    paths.push(abs);
   }
 
-  if (present === 0) return null;
-  return { id: area.id, group: area.group, label: area.label, why: area.why, bytes, files, first };
+  if (paths.length === 0) return null;
+  return {
+    id: area.id,
+    group: area.group,
+    label: area.label,
+    why: area.why,
+    bytes,
+    files,
+    first: paths[0],
+    paths: paths.slice(0, AREA_PATHS),
+    pathCount: paths.length,
+  };
 }
 
 /**
@@ -250,8 +352,9 @@ async function largestAppDirs() {
       entries
         .filter((entry) => entry.isDirectory() && !entry.isSymbolicLink())
         .map(async (entry) => {
-          const measured = await measurePath(path.join(root, entry.name));
-          return { scope: label, name: entry.name, bytes: measured.bytes, files: measured.files };
+          const abs = path.join(root, entry.name);
+          const measured = await measurePath(abs);
+          return { scope: label, name: entry.name, bytes: measured.bytes, files: measured.files, first: abs };
         }),
     );
     for (const item of found) {

package/lib/catalog.js

@@ -67,6 +67,79 @@ const recycleBins = () => {
   return out;
 };
 
+/** `readdirSync` that answers an empty list instead of throwing on a denied directory. */
+const listDir = (parent) => {
+  try {
+    return fs.readdirSync(parent, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+};
+
+/** Compare `0.5.2` style folder names numerically, falling back to a plain string compare. */
+const compareVersion = (a, b) => {
+  const pa = a.split(/[._-]/);
+  const pb = b.split(/[._-]/);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i += 1) {
+    const na = Number(pa[i]);
+    const nb = Number(pb[i]);
+    if (Number.isFinite(na) && Number.isFinite(nb)) {
+      if (na !== nb) return na - nb;
+      continue;
+    }
+    const cmp = String(pa[i] ?? '').localeCompare(String(pb[i] ?? ''));
+    if (cmp !== 0) return cmp;
+  }
+  return 0;
+};
+
+/**
+ * Version folders a per-user install keeps beside itself, such as Qoder's
+ * `.qoder-versions/0.5.2`. The newest child stays — it is the version the installer last
+ * put there — and the rest are rollback copies. A holder with only one child is skipped,
+ * because then nothing distinguishes a rollback copy from the install itself.
+ */
+export const appVersionDirs = () => {
+  const programs = path.join(env('LOCALAPPDATA') ?? '', 'Programs');
+  if (!isDir(programs)) return [];
+  const out = [];
+  for (const app of listDir(programs)) {
+    if (!app.isDirectory() || app.isSymbolicLink()) continue;
+    const appDir = path.join(programs, app.name);
+    for (const inner of listDir(appDir)) {
+      if (!inner.isDirectory() || inner.isSymbolicLink()) continue;
+      if (!/versions?$/i.test(inner.name) && !/_old$/i.test(inner.name)) continue;
+      const holder = path.join(appDir, inner.name);
+      const versions = listDir(holder)
+        .filter((entry) => entry.isDirectory() && !entry.isSymbolicLink())
+        .map((entry) => entry.name)
+        .sort(compareVersion);
+      if (versions.length < 2) continue;
+      for (const name of versions.slice(0, -1)) out.push(path.join(holder, name));
+    }
+  }
+  return out;
+};
+
+/**
+ * Update caches: an Electron-style updater keeps the installer it downloaded in
+ * `%LOCALAPPDATA%/<app>-updater` after applying it. The name pattern is the only signal a
+ * cleaner can use without knowing every vendor; the age limit keeps a download that has
+ * not been applied yet.
+ */
+const appUpdaters = () => {
+  const out = [];
+  for (const root of [env('LOCALAPPDATA'), env('APPDATA')]) {
+    if (root === undefined || !isDir(root)) continue;
+    for (const entry of listDir(root)) {
+      if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
+      if (!/-updater$/i.test(entry.name)) continue;
+      out.push(path.join(root, entry.name));
+    }
+  }
+  return out;
+};
+
 /** Chromium-family caches live per browser profile, so they are discovered, not spelled out. */
 const browserCaches = (userData) => {
   if (!isDir(userData)) return [];
@@ -85,6 +158,122 @@ const browserCaches = (userData) => {
   return out;
 };
 
+/**
+ * Per-app cache folders inside `%APPDATA%`. Every one is spelled out instead of discovered by
+ * a `*cache*` sweep: a folder is only safe to delete when somebody has looked at what it
+ * holds, and the same sweep that finds this WPS cache also finds WeChat's profile store and
+ * VS Code's web storage, which cost a re-login to rebuild.
+ */
+const appCaches = () => {
+  const roaming = env('APPDATA') ?? '';
+  return [
+    path.join(roaming, 'kingsoft', 'wps', 'addons', 'data', 'win-i386', 'cef', '2', 'cache'),
+    path.join(roaming, 'FTNN', '2.0', 'Common', 'cef_cache'),
+    ...subdirs(path.join(roaming, 'com.qoder.app.stable'), ['Cache', 'Code Cache']),
+    ...subdirs(path.join(roaming, 'Trae CN'), ['Cache', 'CachedData']),
+    ...subdirs(path.join(roaming, 'Trae'), ['Cache', 'CachedData']),
+    ...subdirs(path.join(roaming, '@deepseek-ai', 'dsh-desktop'), ['Cache', 'Code Cache', 'GPUCache', 'GrShaderCache']),
+    ...subdirs(path.join(roaming, 'PersonalCenter'), ['Cache']),
+    ...subdirs(path.join(roaming, '微信开发者工具'), ['Cache']),
+    ...subdirs(path.join(roaming, '腾讯电脑管家-全局搜'), ['Cache']),
+    ...subdirs(path.join(roaming, 'appGallery'), ['Crashpad']),
+  ];
+};
+
+/** Log folders that only ever hold history: nothing reads an old log back at runtime. */
+const appLogs = () => {
+  const roaming = env('APPDATA') ?? '';
+  return [
+    path.join(roaming, 'FTNN', '2.0', 'Logs'),
+    path.join(roaming, 'Tencent', 'xwechat', 'log'),
+    ...subdirs(path.join(roaming, 'com.qoder.app.stable'), ['logs']),
+    ...subdirs(path.join(roaming, 'Trae CN'), ['logs']),
+    ...subdirs(path.join(roaming, 'Trae'), ['logs']),
+    ...subdirs(path.join(roaming, 'DingTalk'), ['log']),
+    ...subdirs(path.join(roaming, 'PersonalCenter'), ['log']),
+    ...subdirs(path.join(roaming, 'io.github.clash-verge-rev.clash-verge-rev'), ['logs']),
+    ...subdirs(path.join(roaming, 'MAXHUBShare'), ['log']),
+  ];
+};
+
+/**
+ * Scratch directories an app keeps inside its own roaming folder rather than in `%TEMP%`.
+ * These belong to an app that may be running right now, so the target keeps a two-day floor
+ * instead of being purged outright.
+ */
+const appTempDirs = () => [
+  path.join(env('APPDATA') ?? '', 'WorkDaddy', 'client-tmp'),
+  path.join(env('APPDATA') ?? '', 'PersonalCenter', 'Temp'),
+];
+
+/**
+ * A plugin pool keeps every version it ever installed, because the manager picks one by name
+ * instead of replacing it in place. WPS alone had 347 folders across 131 families here. The
+ * highest version of each family stays — it is what the manager loads — and the rest are dead
+ * weight it never reads again. Families with a single member are skipped: nothing then proves
+ * which one is live.
+ */
+const pooledOldVersions = (pool, pattern) => {
+  if (!isDir(pool)) return [];
+  const families = new Map();
+  for (const entry of listDir(pool)) {
+    if (entry.isSymbolicLink()) continue;
+    const match = pattern.exec(entry.name);
+    if (match === null) continue;
+    const [, base, version] = match;
+    if (!families.has(base)) families.set(base, []);
+    families.get(base).push({ name: entry.name, version });
+  }
+  const out = [];
+  for (const list of families.values()) {
+    if (list.length < 2) continue;
+    list.sort((a, b) => compareVersion(a.version, b.version));
+    for (const older of list.slice(0, -1)) out.push(path.join(pool, older.name));
+  }
+  return out;
+};
+
+const wpsPluginOldVersions = () =>
+  pooledOldVersions(path.join(env('APPDATA') ?? '', 'kingsoft', 'wps', 'addons', 'pool', 'win-i386'), /^(.+)_([0-9][0-9._]*)$/);
+
+/** The version folders an installer left under its own `app` directory, such as FTNN's. */
+const installedAppVersions = (appRoot) => {
+  if (!isDir(appRoot)) return [];
+  return listDir(appRoot)
+    .filter((entry) => entry.isDirectory() && !entry.isSymbolicLink())
+    .map((entry) => entry.name)
+    .filter((name) => /^[0-9][0-9._]*$/.test(name));
+};
+
+/**
+ * Update packages the vendor has already applied, decided by comparison rather than by age.
+ * FTNN names a patch `Download-<from>-<to>-<hash>.spd` with bare build numbers while it keeps
+ * full `16.35.27108` folders in Program Files, so the comparison is build number against the
+ * newest installed build. A patch at or above that build may still be pending, so it stays.
+ */
+const ftnnAppliedPatches = () => {
+  const programFiles = env('ProgramFiles');
+  if (programFiles === undefined) return [];
+  const installed = installedAppVersions(path.join(programFiles, 'FTNN', 'app')).sort(compareVersion);
+  if (installed.length === 0) return [];
+  const newestBuild = Number(installed[installed.length - 1].split('.').pop());
+  if (!Number.isFinite(newestBuild)) return [];
+  const liveUpdate = path.join(env('APPDATA') ?? '', 'FTNN', '2.0', 'LiveUpdate', 'win_qtnn');
+  const out = [];
+  for (const entry of listDir(liveUpdate)) {
+    if (!entry.isFile() || entry.isSymbolicLink()) continue;
+    const match = /^Download-[0-9]+-([0-9]+)-[0-9a-f]+\.spd$/i.exec(entry.name);
+    if (match === null) continue;
+    if (Number(match[1]) < newestBuild) out.push(path.join(liveUpdate, entry.name));
+  }
+  return out;
+};
+
+const supersededUpdatePackages = () => [
+  ...ftnnAppliedPatches(),
+  ...pooledOldVersions(path.join(env('APPDATA') ?? '', 'WorkDaddy', 'update'), /^(.+)-([0-9][0-9._]*)(\.[A-Za-z0-9]+)?$/),
+];
+
 /**
  * `purge` targets drop every entry under the path. `aged` targets keep anything modified
  * within `minAgeDays`, because those files may belong to a process that is still running.
@@ -199,6 +388,55 @@ const CATALOG = [
     roots: ['LOCALAPPDATA'],
     paths: () => [path.join(env('LOCALAPPDATA') ?? '', 'Microsoft', 'Windows', 'INetCache')],
   },
+  {
+    id: 'app-updaters',
+    kind: 'aged',
+    minAgeDays: 3,
+    risk: 'caution',
+    note: 'pending-update',
+    roots: ['LOCALAPPDATA', 'APPDATA'],
+    paths: () => appUpdaters(),
+  },
+  {
+    id: 'app-caches',
+    kind: 'purge',
+    risk: 'caution',
+    note: 'rebuild',
+    roots: ['APPDATA'],
+    paths: () => appCaches(),
+  },
+  {
+    id: 'app-logs',
+    kind: 'purge',
+    risk: 'safe',
+    roots: ['APPDATA'],
+    paths: () => appLogs(),
+  },
+  {
+    id: 'app-temp',
+    kind: 'aged',
+    minAgeDays: 2,
+    risk: 'caution',
+    note: 'in-use',
+    roots: ['APPDATA'],
+    paths: () => appTempDirs(),
+  },
+  {
+    id: 'plugin-old-versions',
+    kind: 'purge',
+    risk: 'caution',
+    note: 'rollback',
+    roots: ['APPDATA'],
+    paths: () => wpsPluginOldVersions(),
+  },
+  {
+    id: 'update-packages',
+    kind: 'purge',
+    risk: 'caution',
+    note: 'superseded',
+    roots: ['APPDATA'],
+    paths: () => supersededUpdatePackages(),
+  },
 ];
 
 const byId = new Map(CATALOG.map((entry) => [entry.id, entry]));
@@ -227,6 +465,19 @@ const within = (abs, root) => {
 /** A volume such as `C:\`; anything else (including undefined) means every volume. */
 const onDrive = (abs, drive) => drive === undefined || path.parse(abs).root.toLowerCase() === drive.toLowerCase();
 
+/**
+ * Some targets are single files (an already-applied update package) rather than directories,
+ * so every step below answers both. A file target is unlinked directly and never has its
+ * parent removed.
+ */
+const isFile = (p) => {
+  try {
+    return fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+};
+
 /** Resolve catalog ids to the concrete directories that exist right now, optionally on one volume. */
 export function resolveTargets(only, drive) {
   const selected = only === undefined ? CATALOG : CATALOG.filter((entry) => only.includes(entry.id));
@@ -235,7 +486,7 @@ export function resolveTargets(only, drive) {
     for (const candidate of entry.paths()) {
       if (typeof candidate !== 'string' || candidate === '') continue;
       if (tooBroad(candidate)) continue;
-      if (!isDir(candidate)) continue;
+      if (!isDir(candidate) && !isFile(candidate)) continue;
       if (!onDrive(candidate, drive)) continue;
       const roots = entry.roots.map((name) => env(name)).filter(Boolean);
       if (roots.length > 0 && !roots.some((root) => within(candidate, root))) continue;
@@ -256,6 +507,13 @@ export function resolveTargets(only, drive) {
 }
 
 export async function measurePath(abs) {
+  if (isFile(abs)) {
+    try {
+      return { bytes: fs.statSync(abs).size, files: 1 };
+    } catch {
+      return { bytes: 0, files: 0 };
+    }
+  }
   let bytes = 0;
   let files = 0;
   let seen = 0;
@@ -385,6 +643,18 @@ export async function clean(ids, options = {}) {
         failed += 1;
         continue;
       }
+      if (isFile(abs)) {
+        try {
+          const stat = await fsp.stat(abs);
+          if (cutoff !== undefined && stat.mtimeMs > cutoff) continue;
+          await fsp.unlink(abs);
+          bytes += stat.size;
+          removed += 1;
+        } catch {
+          failed += 1;
+        }
+        continue;
+      }
       const outcome = await purgePath(abs, cutoff);
       bytes += outcome.bytes;
       removed += outcome.removed;

package/lib/client.js

@@ -38,6 +38,9 @@ window.__ModuleLoader__.load({
       'why_in-use': '只删 {n} 天前的文件，正在使用的会跳过',
       why_rebuild: '缓存会自动重建，下次打开略慢',
       why_elevation: '需要管理员权限；普通窗口下会被系统拒绝',
+      'why_pending-update': '只清 {n} 天前的下载，避免删掉还没装的更新',
+      why_rollback: '每个插件/程序只留版本号最高的一份，其余是回滚副本',
+      why_superseded: '版本号不高于已装版本的更新包，装着的那份已经生效',
       pathCount: '{n} 处',
       driveLabel: '清理范围',
       allDrives: '全部磁盘',
@@ -57,6 +60,12 @@ window.__ModuleLoader__.load({
       'target_inet-cache': '系统网络缓存',
       'target_windows-update': 'Windows 更新缓存',
       'target_recycle-bin': '回收站',
+      'target_app-updaters': '更新安装包残留',
+      'target_app-caches': '各应用缓存',
+      'target_app-logs': '各应用日志',
+      'target_app-temp': '各应用临时目录',
+      'target_plugin-old-versions': '插件旧版本',
+      'target_update-packages': '已应用的更新包',
       auditTitle: '空间评估（本插件不会删除）',
       auditHint: '统计缓存之外真正占空间的东西：已装软件、WSL 虚拟磁盘、Windows 组件库，以及你自己的文件。这些一律不由本插件删除，只列出供你判断。',
       auditRun: '开始评估',
@@ -72,6 +81,32 @@ window.__ModuleLoader__.load({
       auditScopeLocal: 'Local',
       auditScopeRoaming: 'Roaming',
       auditError: '评估失败',
+      auditOpen: '在资源管理器中打开',
+      auditOpened: '已打开',
+      area_wsl: 'WSL 虚拟磁盘',
+      area_wsl_why: 'WSL 的 ext4.vhdx 只增不减，删发行版会丢数据；回收只能压缩，见下面的处理方案。',
+      area_winsxs: 'Windows 组件库',
+      area_winsxs_why: '系统更新的旧版本备份。只能由 DISM 清理，手动删会损坏系统。',
+      'area_system-files': '休眠与页面文件',
+      'area_system-files_why': '由 Windows 管理系统文件，只能通过关闭休眠或调整虚拟内存来回收。',
+      area_programs: '用户安装的程序',
+      'area_program-files': '全机安装的程序',
+      area_programs_why: '装在你账户下的软件本体，删掉等同于卸载。',
+      'area_program-files_why': 'Program Files 里的软件本体，请走正常的卸载流程。',
+      'area_old-versions': '旧版本程序目录',
+      'area_old-versions_why': '安装器留了上一版供回滚。确认当前版本没问题后，可以自己删掉旧版。',
+      'area_update-payloads': '已下载的更新包',
+      'area_update-payloads_why': '安装完通常会留下的 setup/installer 文件。三天内的下载视为可能还没装，不动。',
+      area_downloads: '下载文件夹',
+      area_downloads_why: '你自己下载的文件，插件一律不碰。',
+      area_documents: '文档',
+      area_documents_why: '你自己的文档，插件一律不碰。',
+      area_pictures: '图片',
+      area_pictures_why: '你自己的图片，插件一律不碰。',
+      area_videos: '视频',
+      area_videos_why: '你自己的视频，插件一律不碰。',
+      area_desktop: '桌面',
+      area_desktop_why: '桌面上放着的文件，插件一律不碰。',
       planTitle: '处理方案',
       planHint: '按"收益 ÷ 代价"排序：先做零风险的部分，再做需要一次慎重操作的，最后是只能你自己决定的。',
       planNow: '现在就能回收',
@@ -147,6 +182,9 @@ window.__ModuleLoader__.load({
       'why_in-use': 'only files older than {n} day(s); files in use are skipped',
       why_rebuild: 'rebuilt automatically; the next open is slower',
       why_elevation: 'needs an elevated prompt; a normal window is refused by Windows',
+      'why_pending-update': 'only downloads older than {n} day(s), so a pending update survives',
+      why_rollback: 'only the highest version of each family stays; the rest are rollback copies',
+      why_superseded: 'the update package version is not above what is installed, so it is already applied',
       pathCount: '{n} location(s)',
       driveLabel: 'Limit to',
       allDrives: 'All drives',
@@ -166,6 +204,12 @@ window.__ModuleLoader__.load({
       'target_inet-cache': 'System internet cache',
       'target_windows-update': 'Windows update cache',
       'target_recycle-bin': 'Recycle Bin',
+      'target_app-updaters': 'Leftover update installers',
+      'target_app-caches': 'App caches',
+      'target_app-logs': 'App logs',
+      'target_app-temp': 'App scratch folders',
+      'target_plugin-old-versions': 'Old plugin versions',
+      'target_update-packages': 'Applied update packages',
       auditTitle: 'Space assessment (this plugin deletes none of it)',
       auditHint: 'What actually takes up room outside caches: installed programs, WSL disk images, the Windows component store, and your own files. None of it is removed here; it is listed so you can decide.',
       auditRun: 'Run assessment',
@@ -181,6 +225,32 @@ window.__ModuleLoader__.load({
       auditScopeLocal: 'Local',
       auditScopeRoaming: 'Roaming',
       auditError: 'Assessment failed',
+      auditOpen: 'Open in Explorer',
+      auditOpened: 'Opened',
+      area_wsl: 'WSL distros (ext4.vhdx)',
+      area_wsl_why: 'The WSL ext4.vhdx only grows. Deleting a distro loses data; compacting is the only way to reclaim it, see the plan below.',
+      area_winsxs: 'Windows component store (WinSxS)',
+      area_winsxs_why: 'Superseded copies of system updates. Only DISM may clean these; deleting by hand damages Windows.',
+      'area_system-files': 'Hibernation and page files',
+      'area_system-files_why': 'Managed by Windows. Reclaimed only by turning hibernation off or shrinking virtual memory.',
+      area_programs: 'Installed programs (user scope)',
+      area_programs_why: 'The program itself, installed under your account. Deleting it is uninstalling it.',
+      'area_program-files': 'Installed programs (machine scope)',
+      'area_program-files_why': 'Program bodies under Program Files. Remove them through the normal uninstaller.',
+      'area_old-versions': 'Superseded app versions',
+      'area_old-versions_why': 'An installer kept the previous build for rollback. Once the current version is fine, delete the old one by hand.',
+      'area_update-payloads': 'Downloaded update packages',
+      'area_update-payloads_why': 'Setup/installer files left behind after an update. Usually safe to delete; anything from the last three days may still be pending.',
+      area_downloads: 'Downloads',
+      area_downloads_why: 'Your own downloads. This plugin never touches them.',
+      area_documents: 'Documents',
+      area_documents_why: 'Your own documents. This plugin never touches them.',
+      area_pictures: 'Pictures',
+      area_pictures_why: 'Your own pictures. This plugin never touches them.',
+      area_videos: 'Videos',
+      area_videos_why: 'Your own videos. This plugin never touches them.',
+      area_desktop: 'Desktop',
+      area_desktop_why: 'Files sitting on your desktop. This plugin never touches them.',
       planTitle: 'Suggested plan',
       planHint: 'Ordered by gain against cost: the zero-risk part first, then the one deliberate operation, then what only you can decide.',
       planNow: 'Reclaimable now',
@@ -296,6 +366,9 @@ window.__ModuleLoader__.load({
       .dsc-audit-group-title { font-size: 11px; font-weight: 600; letter-spacing: .04em; text-transform: uppercase; color: var(--dsw-alias-label-secondary); margin-bottom: 4px; }
       .dsc-audit-row { display: flex; align-items: baseline; gap: 10px; padding: 6px 8px; border-radius: 7px; }
       .dsc-audit-row:hover { background: var(--dsw-alias-bg-layer-2); }
+      .dsc-openable { cursor: pointer; }
+      .dsc-openable:hover .dsc-audit-label { text-decoration: underline; text-decoration-color: var(--dsw-alias-border-l1); text-underline-offset: 3px; }
+      .dsc-openable:focus-visible { outline: 2px solid var(--dsw-alias-brand-primary); outline-offset: 1px; }
       .dsc-audit-name { flex: 1; min-width: 0; display: flex; flex-direction: column; gap: 2px; }
       .dsc-audit-label { font-weight: 600; }
       .dsc-audit-why { color: var(--dsw-alias-label-secondary); font-size: 11px; line-height: 16px; }
@@ -487,6 +560,17 @@ window.__ModuleLoader__.load({
       return text.replace('{n}', String(row.minAgeDays || 1));
     }
 
+    /**
+     * The host measures areas and sends an English label and reason; the dictionary carries
+     * a translation per area id and falls back to what the host sent when it has none, so a
+     * newly added area shows up in English instead of disappearing.
+     */
+    function areaText(t, area, suffix) {
+      const key = `area_${area.id}${suffix}`;
+      const text = t(key);
+      return text === key ? (suffix === '' ? area.label : area.why) : text;
+    }
+
     function DriveBar({ drive, t }) {
       const ratio = drive.total > 0 ? drive.used / drive.total : 0;
       const level = ratio >= 0.92 ? ' dsc-crit' : ratio >= 0.8 ? ' dsc-warn' : '';
@@ -865,12 +949,15 @@ window.__ModuleLoader__.load({
       const [data, setData] = usePersistent('audit', null);
       const [busy, setBusy] = useState(false);
       const [error, setError] = usePersistent('auditError', '');
+      // Where the last click opened: 24px of feedback beats a silent no-op on Windows,
+      // which sometimes takes a second to raise the Explorer window.
+      const [opened, setOpened] = useState('');
 
-      const run = useCallback(async () => {
+      const run = useCallback(async (force) => {
         setBusy(true);
         setError('');
         try {
-          const result = await call('audit');
+          const result = await call('audit', force === true ? { force: true } : {});
           setData(result);
         } catch (err) {
           setError(`${t('auditError')}: ${err instanceof Error ? err.message : String(err)}`);
@@ -892,6 +979,39 @@ window.__ModuleLoader__.load({
       const apps = data && Array.isArray(data.largestApps) ? data.largestApps : [];
       const total = areas.reduce((sum, area) => sum + (area.bytes || 0), 0);
 
+      /**
+       * Open one measured location in Explorer. The host rebuilds the path from the area
+       * (or scope + name) it measured, so nothing here can hand it a path of our choosing.
+       */
+      const revealAt = async (payload) => {
+        setError('');
+        try {
+          const result = await call('reveal', payload);
+          setOpened(result && result.revealed ? result.revealed : '');
+        } catch (err) {
+          setError(`${t('auditError')}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      };
+
+      /** A row that has somewhere to open gets click and right-click; one without stays plain. */
+      const openable = (payload) => {
+        const open = (event) => {
+          event.preventDefault();
+          revealAt(payload);
+        };
+        return {
+          className: 'dsc-audit-row dsc-openable',
+          role: 'button',
+          tabIndex: 0,
+          title: t('auditOpen'),
+          onClick: open,
+          onContextMenu: open,
+          onKeyDown: (event) => {
+            if (event.key === 'Enter' || event.key === ' ') open(event);
+          },
+        };
+      };
+
       /** Run a plan step the plugin is allowed to run, then re-measure so the plan is honest. */
       const runStep = async (step) => {
         if (confirmFirst.get() === 'always' && !window.confirm(t('cleanConfirm'))) return;
@@ -924,12 +1044,13 @@ window.__ModuleLoader__.load({
           data && data.cached ? h('span', { className: 'dsc-total' }, t('auditCached')) : null,
           h(
             'button',
-            { type: 'button', className: 'dsc-btn', onClick: run, disabled: busy },
+            { type: 'button', className: 'dsc-btn', onClick: () => run(true), disabled: busy },
             busy ? t('auditRunning') : data ? t('auditRescan') : t('auditRun'),
           ),
         ),
         h('p', { className: 'dsc-audit-hint' }, t('auditHint')),
         error ? h('div', { className: 'dsc-notice dsc-err' }, error) : null,
+        opened ? h('div', { className: 'dsc-audit-hint' }, `${t('auditOpened')} ${opened}`) : null,
         busy && !data ? h('div', { className: 'dsc-empty' }, t('auditCold')) : null,
         data
           ? [
@@ -948,12 +1069,12 @@ window.__ModuleLoader__.load({
                   list.map((area) =>
                     h(
                       'div',
-                      { className: 'dsc-audit-row', key: area.id },
+                      { key: area.id, ...openable({ area: area.id, index: 0 }) },
                       h(
                         'span',
                         { className: 'dsc-audit-name' },
-                        h('span', { className: 'dsc-audit-label' }, area.label),
-                        h('span', { className: 'dsc-audit-why' }, area.why),
+                        h('span', { className: 'dsc-audit-label' }, areaText(t, area, '')),
+                        h('span', { className: 'dsc-audit-why' }, areaText(t, area, '_why')),
                       ),
                       h('span', { className: 'dsc-audit-size' }, formatBytes(area.bytes)),
                     ),
@@ -968,7 +1089,7 @@ window.__ModuleLoader__.load({
                     apps.map((app) =>
                       h(
                         'div',
-                        { className: 'dsc-audit-row', key: `${app.scope}/${app.name}` },
+                        { key: `${app.scope}/${app.name}`, ...openable({ scope: app.scope, name: app.name }) },
                         h(
                           'span',
                           { className: 'dsc-audit-name' },

package/lib/index.js

@@ -5,7 +5,11 @@
  * cleaning logic exists once (in catalog.js) and is reached two ways: an HTTP route for
  * the panel and a tool for the agent.
  */
-import { audit, invalidateAudit } from './audit.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+import { areaPaths, audit, invalidateAudit } from './audit.js';
 import { clean, drives, hasTarget, resolveTargets, scan } from './catalog.js';
 
 export const name = 'dsh-disk-cleaner';
@@ -104,6 +108,46 @@ const toPublic = (target) => ({
   pathCount: target.paths.length,
 });
 
+/**
+ * Open a folder this plugin measured, in Explorer.
+ *
+ * The request never carries a path: it names an assessment area (or an app folder by
+ * scope and name) and the path is rebuilt here from the same code that measured it. A
+ * caller therefore cannot hand `explorer.exe` a string of its own choosing, which is the
+ * only thing standing between "open my Downloads folder" and "launch anything on disk".
+ */
+function revealPath(payload) {
+  if (typeof payload.area === 'string' && payload.area !== '') {
+    const index = Number.isInteger(payload.index) ? payload.index : 0;
+    const paths = areaPaths(payload.area);
+    if (index < 0 || index >= paths.length) throw new Error(`no location ${index} in area: ${payload.area}`);
+    return paths[index];
+  }
+  if (typeof payload.name === 'string' && payload.name !== '') {
+    if (/[\\/]/.test(payload.name) || payload.name === '.' || payload.name === '..') {
+      throw new Error('name must be a single folder name');
+    }
+    const root = payload.scope === 'roaming' ? process.env.APPDATA : payload.scope === 'local' ? process.env.LOCALAPPDATA : undefined;
+    if (root === undefined || root === '') throw new Error(`unknown scope: ${String(payload.scope)}`);
+    return path.join(root, payload.name);
+  }
+  throw new Error('reveal needs an area or a scope and name');
+}
+
+function reveal(payload) {
+  const abs = revealPath(payload);
+  let stat;
+  try {
+    stat = fs.statSync(abs);
+  } catch {
+    throw new Error('that folder no longer exists');
+  }
+  // `/select,` highlights the item; a bare path would open its parent for a file.
+  const args = stat.isDirectory() ? [abs] : [`/select,${abs}`];
+  spawn('explorer.exe', args, { detached: true, stdio: 'ignore' }).unref();
+  return { revealed: abs, kind: stat.isDirectory() ? 'folder' : 'file' };
+}
+
 const overview = () => ({ drives: drives(), targets: resolveTargets().map(toPublic) });
 
 async function run(action, payload) {
@@ -114,7 +158,8 @@ async function run(action, payload) {
       targets: measured.map((target) => ({ ...toPublic(target), bytes: target.bytes, files: target.files })),
     };
   }
-  if (action === 'audit') return audit();
+  if (action === 'audit') return audit({ force: payload.force === true });
+  if (action === 'reveal') return reveal(payload);
   if (action === 'clean') {
     const ids = readIds(payload.ids);
     if (ids === undefined || ids.length === 0) throw new Error('clean needs at least one target id');
@@ -150,6 +195,8 @@ const NOTE_MEANING = {
   'in-use': 'a running program may hold some of these files; only files older than the age limit go',
   rebuild: 'the owner rebuilds these, so the next start or page load is slower',
   elevation: 'Windows refuses an unelevated delete here; run the plugin elevated to reach these bytes',
+  rollback: 'an older version the app keeps for rollback; what it runs now is the newest of that family',
+  superseded: 'an update package whose version is at or below what is already installed',
 };
 
 const formatBytes = (bytes) => {
@@ -234,11 +281,13 @@ export function apply(ctx) {
           'WSL disk images, the Windows component store, chat-app data and the user\'s own folders — so the ' +
           'answer covers the whole disk rather than only caches. audit is read-only: it never removes anything, ' +
           'and it also returns a suggested plan — the same numbers ordered into steps, with the exact command ' +
-          'for the ones this plugin cannot perform. Report that plan to the user; never run those commands yourself.',
+          'for the ones this plugin cannot perform. Report that plan to the user; never run those commands yourself. ' +
+          'Action "reveal" opens one measured location in Explorer: pass an "area" id, or "scope" (local|roaming) ' +
+          'with "name" for one app folder. It takes no path.',
         parameters: {
           type: 'object',
           properties: {
-            action: { type: 'string', enum: ['overview', 'scan', 'clean', 'audit'] },
+            action: { type: 'string', enum: ['overview', 'scan', 'clean', 'audit', 'reveal'] },
             ids: {
               type: 'array',
               items: { type: 'string' },
@@ -254,6 +303,27 @@ export function apply(ctx) {
               type: 'boolean',
               description: 'Set true to actually delete. Without it, clean only reports a dry run.',
             },
+            force: {
+              type: 'boolean',
+              description: 'With audit, re-measure instead of answering from the ten-minute cache.',
+            },
+            area: {
+              type: 'string',
+              description: 'With reveal, the assessment area id to open. Rejects an id the assessment did not report.',
+            },
+            scope: {
+              type: 'string',
+              enum: ['local', 'roaming'],
+              description: 'With reveal and name, which app-data root the folder is under.',
+            },
+            name: {
+              type: 'string',
+              description: 'With reveal and scope, one folder name from the largest-app list.',
+            },
+            index: {
+              type: 'number',
+              description: 'With reveal and area, which of its locations to open (default 0).',
+            },
           },
           required: ['action'],
           additionalProperties: false,
@@ -295,8 +365,12 @@ export function apply(ctx) {
             const tail = meaning === '' ? '' : `\n\nCaution codes:\n${meaning}`;
             return `Reclaimable: ${formatBytes(total)}\n\n${lines.join('\n')}${tail}`;
           }
+          if (action === 'reveal') {
+            const value = reveal(args);
+            return `Opened ${value.revealed} (${value.kind}).`;
+          }
           if (action === 'audit') {
-            const value = await audit();
+            const value = await audit({ force: args.force === true });
             const total = value.areas.reduce((sum, area) => sum + area.bytes, 0);
             const lines = value.areas.map(
               (area) => `${area.label}: ${formatBytes(area.bytes)} in ${area.files} file(s)\n  why not automatic: ${area.why}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-disk-cleaner",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "type": "module",
   "description": "Disk Cleaner for DSH: scan known-safe cache locations, see what they occupy, and reclaim the space from a panel or from the agent.",
   "keywords": [

package/smoke.mjs

@@ -210,6 +210,10 @@ check('confirm choice persisted', storage.get('dsc.confirm') === 'never');
 check('scan honours the preselect preference', source.includes('const want = defaultPick.get();'));
 check('clean honours the confirm preference', source.includes("confirmFirst.get() === 'always'"));
 check('the settings page reuses the same rows', /function SettingsOptions\(\{ t \}\)[\s\S]{0,400}h\(ConfigRows, \{ t \}\)/.test(source));
+check('re-run asks the host to skip its cache', source.includes('onClick: () => run(true)') && source.includes("force === true ? { force: true } : {}"));
+check('an assessment row opens its folder', source.includes("call('reveal'") && source.includes('dsc-audit-row dsc-openable'));
+check('a row opens on click, right click and Enter', /const openable = \(payload\) =>[\s\S]{0,600}onClick: open[\s\S]{0,200}onContextMenu: open[\s\S]{0,300}'Enter'/.test(source));
+check('an app folder is opened by scope and name', source.includes('openable({ scope: app.scope, name: app.name })'));
 
 {
   const button = find(live('main')[0].render(), (n) => n.type === 'button' && n.props && n.props.className === 'dsc-head-btn');
@@ -250,17 +254,20 @@ apply({
 check('route registered under the documented prefix', route?.kind === 'prefix' && route?.path === '/api/disk-cleaner/');
 check('tool registered', definition?.name === 'disk_cleaner');
 check(
-  'tool accepts the four documented actions',
-  JSON.stringify(definition.parameters.properties.action.enum) === JSON.stringify(['overview', 'scan', 'clean', 'audit']),
+  'tool accepts the five documented actions',
+  JSON.stringify(definition.parameters.properties.action.enum) === JSON.stringify(['overview', 'scan', 'clean', 'audit', 'reveal']),
 );
 check('tool needs no id for overview', JSON.stringify(definition.parameters.required) === JSON.stringify(['action']));
 check('tool description warns audit is read-only', /read-only: it never removes anything/.test(definition.description));
 check('every effect is labelled', applied.every((label) => typeof label === 'string' && label.startsWith('dsh-disk-cleaner:')));
 
 const ids = [...catalog.matchAll(/^\s{4}id: '([a-z-]+)',$/gm)].map((m) => m[1]);
-check('catalog has the documented 13 targets', ids.length === 13, `got ${ids.length}`);
+check('catalog has the documented 19 targets', ids.length === 19, `got ${ids.length}`);
 check('every catalog id has a client label', ids.every((id) => zhKeys.includes(`target_${id}`) && enKeys.includes(`target_${id}`)));
-check('every note code has an explanation', ['why_safe', 'why_in-use', 'why_rebuild', 'why_elevation'].every((k) => zhKeys.includes(k)));
+check('every note code has an explanation', ['why_safe', 'why_in-use', 'why_rebuild', 'why_elevation', 'why_pending-update', 'why_rollback', 'why_superseded'].every((k) => zhKeys.includes(k) && enKeys.includes(k)));
+const areaIds = [...auditSrc.matchAll(/^\s{6}id: '([a-z-]+)',$/gm)].map((m) => m[1]);
+check('every assessment area has a translated label and reason', areaIds.length > 0 && areaIds.every((id) => zhKeys.includes(`area_${id}`) && zhKeys.includes(`area_${id}_why`) && enKeys.includes(`area_${id}`) && enKeys.includes(`area_${id}_why`)), `areas: ${areaIds.join(',')}`);
+check('a reveal request names an area, never a path', index.includes("action === 'reveal'") && auditSrc.includes('export function areaPaths') && !/revealPath[\s\S]{0,200}payload\.path/.test(index));
 check('no caller may pass a raw path', !/parameters[\s\S]{0,400}paths/.test(index) && catalog.includes('Callers select catalog ids'));
 
 const codes = [...new Set([...plan.matchAll(/code: '([a-z-]+)'/g)].map((m) => m[1]))];