dsh-disk-cleaner 1.4.0 → 1.6.0

package/README.md

@@ -5,7 +5,7 @@
 <!-- badges -->
 | | |
 | --- | --- |
-| **version** | `1.4.0` |
+| **version** | `1.6.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** — twenty-eight 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.
+1. **Clean** — thirty-two 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,15 +27,16 @@ Both the panel and the agent reach the *same* operations: the cleaning logic liv
 
 | Feature | Description |
 | --- | --- |
-| Scan | Measures all twenty-eight targets concurrently and shows what each occupies |
+| Scan | Measures all thirty-two 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` / `pending-update` / `rollback` / `superseded` / `history` / `duplicate` / `database-backup`) 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` / `history` / `duplicate` / `database-backup` / `orphan`) 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. 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 |
+| Grouped list | The thirty-two targets are filed under seven headings — system temp, developer tools, browser caches, app caches, leftover updaters, backups, orphaned data. A section whose targets all read 0 B starts folded, so the list opens with only what there is to clean |
 | Panel memory | Scan results, the selection and the assessment survive switching to another panel and back |
 | 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 |
@@ -74,6 +75,10 @@ Every path is built from this table — a caller selects an **id**, never a path
 | `agent-app-caches` | `Cache` / `Code Cache` / `GPUCache` under `%USERPROFILE%\.workbuddy\app` and `\.workbuddy-ai\app` | purge | caution | the sibling `cache` folder holds spilled conversation text and is never a target |
 | `rewind-snapshots` | `session-*` folders under `%USERPROFILE%\.dsh\rewind-snapshots` | aged, 30 days | caution | a recent session stays restorable |
 | `rotated-logs` | `*.old.log` and `*.log.N` files in the `logs` folders of the agent apps | aged, 3 days | safe | nothing reads a rotated file back |
+| `qoder-old-versions` | version folders under `%LOCALAPPDATA%\Programs\Qoder\.qoder-versions` other than the one the launcher names | purge | caution | the launcher's `state.ini` names the build it runs; an unreadable one means nothing is removed |
+| `orphan-app-data` | `%LOCALAPPDATA%\Tencent\QQGuild` - left by an app with no shortcut, no uninstall entry and nothing written for over two years | purge | caution | all four signals must agree before the folder is offered |
+| `app-data-caches` | Chromium caches under `%LOCALAPPDATA%` for Electron, DingTalk, JianyingPro and the WeChat devtools | aged, 7 days | caution | an app that still runs rewrites its cache constantly, so only a week-old tree qualifies |
+| `office-update-cache` | `%LOCALAPPDATA%\Microsoft\Office\SolutionPackages` - update packages Office already applied | purge | caution | Office stages them before applying; nothing reads them back afterwards |
 
 `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.
 
@@ -153,6 +158,8 @@ These are enforced in `lib/catalog.js` and must not be relaxed:
   that holds a single bundle all resolve to *nothing to delete*. The newest member is never returned.
 - `editor-builds` drops a build only when `bin\code.cmd` exists and names a different build that is also on disk; `old_x` goes only while `x` is still beside it.
 - `database-backups` matches `.sqlite*.bak` by name only; the live `zotero.sqlite` is never a candidate.
+- `qoder-old-versions` reads the launcher's `state.ini` for the build it runs; a missing or unparsable file, or a named build that is not on disk, removes nothing.
+- `orphan-app-data` needs four independent signals to agree: no Start-menu shortcut, no uninstall entry, no folder under either `Program Files`, and no file written for two years. Any one missing and the folder is not offered.
 - The directory Windows refuses to let an unelevated process write (`SoftwareDistribution\Download`) is labelled `elevation` and excluded from "reclaimable now". `C:\Windows\Temp` is **not** one of them on a default ACL: it grants `BUILTIN\Users` create and delete, so only EBUSY on a live file stops a delete there, which the age limit covers.
 
 ### Install
@@ -189,7 +196,7 @@ The bundle's own `cordis.patch.yml` inserts the plugin row; no profile patch edi
 ### Development
 
 ```bash
-node smoke.mjs                       # 68 assertions, zero dependencies
+node smoke.mjs                       # 82 assertions, zero dependencies
 node --check lib/client.js           # and lib/index.js, lib/catalog.js, lib/audit.js, lib/plan.js
 ```
 
@@ -216,6 +223,7 @@ What the smoke test deliberately does **not** cover: anything that walks a real
 | "Keep only the newest of a group" fails closed | Throwaway fixture tree: a same-hash duplicate collapses to the newest, a folder with no metadata is left alone, a different hash is kept, the live database survives (9/9) |
 | Old editor builds need a launcher that proves which one runs | Throwaway fixture tree: a build the launcher does not name goes, no launcher deletes nothing, a launcher naming a missing build deletes nothing, a lone build stays, `old_x` goes only while `x` exists (7/7) |
 | A dry run reports what a real run frees | The 30-day rewind window reports 263 KB not 283 MB, and scan matches the dry run |
+| Grouping and folding | The real `groupRows` runs out of the bundle against a mixed list: fixed order, per-section totals, an unknown group lands in "other", an empty section is the folded one. A click on a section head folds that section and only that one, and a folded section's rows drop out of bulk select |
 | Visual layout | Checked by hand in the running Web UI. No browser automation here, so this one is a human check, not a test. |
 
 ### Implementation notes
@@ -241,15 +249,15 @@ 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    (411)  Host: HTTP route + disk_cleaner tool, same run() for both; reveal
-├─ lib/catalog.js  (969)  The 28 targets, measurePath / purgePath / resolveTargets / drives
+├─ lib/catalog.js  (1192)  The 32 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  (1379)  Client half: slots, panel, preferences, zh/en dictionaries, CSS
+├─ lib/client.js  (1492)  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              68 assertions, zero dependencies
+└─ smoke.mjs              82 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).
@@ -261,7 +269,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 命令。
@@ -272,15 +280,16 @@ Client-half slots: `sidebar.panellist` (order 50, disposed in settings-only mode
 
 | 功能 | 说明 |
 | --- | --- |
-| 扫描 | 并发测量全部二十八个目标，显示各自占用 |
+| 扫描 | 并发测量全部三十二个目标，显示各自占用 |
 | 按盘过滤 | 已挂载卷的胶囊按钮；扫描与清理都可限定单盘，该盘上为空的项会隐藏 |
-| 风险标注 | 每个目标都标 `安全` 或 `注意`，并给一行理由（`in-use` / `rebuild` / `elevation` / `pending-update` / `rollback` / `superseded` / `history` / `duplicate` / `database-backup`），图例常驻，所以「注意」永远不是「说不清」 |
+| 风险标注 | 每个目标都标 `安全` 或 `注意`，并给一行理由（`in-use` / `rebuild` / `elevation` / `pending-update` / `rollback` / `superseded` / `history` / `duplicate` / `database-backup` / `orphan`），图例常驻，所以「注意」永远不是「说不清」 |
 | 保留期删除 | `temp` 与 `windows-temp` 只删一天前的文件；被运行中程序占住的自动跳过 |
 | 空间评估 | 只读遍历磁盘，按 Windows 自身 / 已装软件 / 你自己的文件 分组，另列占用最大的十个应用数据目录。每一行都能打开所在目录——单击、右键或回车 |
 | 重新评估真的重测 | 「重新评估」会重新测量；普通调用仍然走十分钟缓存 |
 | 处理方案 | 九种可能步骤，从零风险到只能你决定；本插件能执行的带按钮，其余给可复制的命令 |
 | 入口位置 | 侧边栏图标、设置页分区、或两者都要（默认）——在插件自己的配置卡或面板 ⚙ 里切换 |
 | 行为设置 | 扫描后默认勾选什么、删除前是否确认 |
+| 分类折叠 | 三十二个目标归到七个标题下（系统临时、开发工具、浏览器缓存、应用缓存、升级残留、备份快照、已卸载残留）。整类都是 0 字节的默认收起来，所以打开面板先看到的只有真能清的那些 |
 | 面板记忆 | 扫描结果、勾选、评估结果在切走再回来时都还在 |
 | Agent 工具 | `disk_cleaner` 把同样的五个动作以可读文本交给模型 |
 | 双语 | 跟随宿主语言服务，zh / en 字典一起发布 |
@@ -319,6 +328,10 @@ Client-half slots: `sidebar.panellist` (order 50, disposed in settings-only mode
 | `agent-app-caches` | `%USERPROFILE%\.workbuddy\app` 与 `\.workbuddy-ai\app` 下的 `Cache` / `Code Cache` / `GPUCache` | 全清 | 注意 | 同级的 `cache` 目录存的是对话溢写内容，从不作为目标 |
 | `rewind-snapshots` | `%USERPROFILE%\.dsh\rewind-snapshots` 下的 `session-*` 目录 | 保留期 30 天 | 注意 | 最近的会话仍然可以回滚 |
 | `rotated-logs` | 各 agent 应用 `logs` 目录下的 `*.old.log` 与 `*.log.N` 文件 | 保留期 3 天 | 安全 | 轮转掉的日志不会被读回 |
+| `qoder-old-versions` | `%LOCALAPPDATA%\Programs\Qoder\.qoder-versions` 下不是启动器所指的那个版本目录 | 全清 | 注意 | 启动器 `state.ini` 写明它跑哪个版本；读不到就一个都不删 |
+| `orphan-app-data` | `%LOCALAPPDATA%\Tencent\QQGuild` —— 没有快捷方式、没有卸载项、两年多没写过文件的程序留下的数据 | 全清 | 注意 | 四条证据必须同时成立才会被列为可删 |
+| `app-data-caches` | `%LOCALAPPDATA%` 下 Electron、钉钉、剪映、微信开发者工具的 Chromium 缓存 | 保留期 7 天 | 注意 | 还在跑的程序会不停改写缓存，所以只有一周没动过的才算 |
+| `office-update-cache` | `%LOCALAPPDATA%\Microsoft\Office\SolutionPackages` —— Office 已应用的更新暂存包 | 全清 | 注意 | Office 先暂存再应用，应用后没有东西会读回 |
 
 保留期方式会跳过保留期内修改过的文件；全清方式清掉全部条目。两者都保留目标目录本身，并把锁定或无权限的条目跳过计数。
 
@@ -397,6 +410,8 @@ Client-half slots: `sidebar.panellist` (order 50, disposed in settings-only mode
   `vscode-remote-wsl\stable` 下只有一个服务包，结果都是*没有可删项*。最新那一份永远不会被返回。
 - `editor-builds` 只有在 `bin\code.cmd` 存在且指向另一份确实在磁盘上的构建时才删；`old_x` 也只有在 `x` 仍在旁边时才删。
 - `database-backups` 只按名字匹配 `.sqlite*.bak`，正在用的 `zotero.sqlite` 永不成为候选。
+- `qoder-old-versions` 从启动器的 `state.ini` 读出它实际运行哪个版本；文件缺失、解析不出、或它指的版本不在磁盘上，一律一个都不删。
+- `orphan-app-data` 要求四条独立证据同时成立：开始菜单没有快捷方式、注册表没有卸载项、两个 `Program Files` 下都没有目录、两年内没有任何文件被写过。缺一条就不会列为可删。
 - 那个拒绝普通权限写入的 Windows 目录标为 `elevation`，并排除在「现在能回收」之外。
 
 ### 安装
@@ -437,7 +452,7 @@ git clone https://github.com/stallenlu/dsh-disk-cleaner
 ### 开发
 
 ```bash
-node smoke.mjs                       # 68 条断言，零依赖
+node smoke.mjs                       # 82 条断言，零依赖
 node --check lib/client.js           # 以及 lib/index.js、lib/catalog.js、lib/audit.js、lib/plan.js
 ```
 
@@ -464,6 +479,7 @@ node --check lib/client.js           # 以及 lib/index.js、lib/catalog.js、li
 | 「只留最新一份」一律选保守一侧 | 一次性 fixture 目录：同哈希的重复项收敛到最新、无元数据的目录不动、不同哈希保留、正在用的数据库完好（9/9） |
 | 旧版编辑器构建要有启动器作证才删 | 一次性 fixture 目录：启动器未指向的构建会删、没有启动器一律不删、启动器指向的构建不在磁盘上也不删、只有一份构建时不删、`old_x` 只在 `x` 仍在时删（7/7） |
 | 预演报告的字节数等于真删能释放的字节数 | 30 天的回滚窗口报 263 KB 而不是 283 MB，且扫描结果与预演一致 |
+| 分类与折叠 | 从 bundle 里取出真正的 `groupRows` 跑一组混合数据：顺序固定、按类合计、未知类别落到「其他」、空的类别是收起来的那个。点某一类的标题只折叠这一类，折叠里的行不参与批量选择 |
 | 视觉排版 | 在运行中的 Web UI 里手工确认过。本环境没有浏览器自动化，所以这条是人眼检查，不是测试。 |
 
 ### 实现要点
@@ -489,15 +505,15 @@ 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    (411)  Host：HTTP 路由 + disk_cleaner 工具，共用同一个 run()，含 reveal
-├─ lib/catalog.js  (969)  28 个目标，measurePath / purgePath / resolveTargets / drives
+├─ lib/catalog.js  (1192)  32 个目标，measurePath / purgePath / resolveTargets / drives
 ├─ lib/audit.js    (365)  只读评估，10 分钟缓存，带 areaPaths，不暴露任何删除
 ├─ lib/plan.js     (150)  纯函数：测量结果 → 有序步骤
-├─ lib/client.js  (1379)  Client 半面：slot、面板、偏好、zh/en 字典、CSS
+├─ lib/client.js  (1492)  Client 半面：slot、面板、偏好、zh/en 字典、CSS
 ├─ locale/{en,zh}.json    展示元数据（meta.title / meta.description）
 ├─ icon.svg               插件图标
 ├─ README.md              本文件
 ├─ LICENSE                MIT
-└─ smoke.mjs              68 条断言，零依赖
+└─ smoke.mjs              82 条断言，零依赖
 ```
 
 Client 半面注册的 slot：`sidebar.panellist`（order 50，仅设置页模式下拆除）、`main`（以包名为 key）、`settings.section`（order 30，仅侧边栏模式下拆除）、`plugins.bundle.config`（以包名为 key）。

package/lib/catalog.js

@@ -465,6 +465,110 @@ const zoteroBackups = () => {
     .map((entry) => path.join(data, entry.name));
 };
 
+/**
+ * Qoder keeps one complete build per version under `.qoder-versions` and never removes the
+ * one it replaced. The launcher writes the live build into `state.ini`
+ * (`appExecutable=.qoder-versions\0.5.3\Qoder.exe`); `install.ini` next to it still names an
+ * older version, so only `state.ini` is read. No readable state file means no evidence about
+ * which build runs, and then nothing is returned at all.
+ */
+const qoderOldVersions = () => {
+  const versions = path.join(env('LOCALAPPDATA') ?? '', 'Programs', 'Qoder', '.qoder-versions');
+  if (!isDir(versions)) return [];
+  let live = '';
+  try {
+    const state = fs.readFileSync(
+      path.join(env('LOCALAPPDATA') ?? '', 'Qoder', 'Qoder Launcher', 'state.ini'),
+      'utf8',
+    );
+    const match = /appExecutable\s*=\s*(.+)/.exec(state);
+    if (match !== null) {
+      const parts = match[1].trim().split(/[\\/]/).filter(Boolean);
+      const index = parts.indexOf('.qoder-versions');
+      if (index !== -1 && parts[index + 1] !== undefined) live = parts[index + 1];
+    }
+  } catch {
+    /* no state.ini, no proof of which build is live: drop nothing */
+  }
+  if (live === '') return [];
+  const builds = listDir(versions)
+    .filter((entry) => entry.isDirectory() && !entry.isSymbolicLink())
+    .map((entry) => entry.name);
+  if (builds.length < 2 || !builds.includes(live)) return [];
+  return builds.filter((name) => name !== live).map((name) => path.join(versions, name));
+};
+
+/**
+ * The plugin packages the WeChat devtools downloads per account. They are fetched again the
+ * next time a mini program needs one, which is why this stays behind an age limit.
+ */
+const wechatDevtoolsCaches = () => {
+  const data = path.join(env('LOCALAPPDATA') ?? '', '微信开发者工具', 'User Data');
+  const out = [];
+  for (const entry of listDir(data)) {
+    if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
+    out.push(...subdirs(path.join(data, entry.name), ['WeappPlugin', 'WeappForeignPkgs', 'WeappVendor']));
+  }
+  return out;
+};
+
+/**
+ * The newest modification time anywhere under a folder, or 0 when it cannot be read. Used to
+ * tell "this app was uninstalled" from "this app is installed but its cache happens to be old":
+ * only a completely quiet tree is treated as an orphan.
+ */
+const newestMtime = (dir) => {
+  let newest = 0;
+  const stack = [dir];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    let handle;
+    try {
+      handle = fs.opendirSync(current);
+    } catch {
+      continue;
+    }
+    let entry;
+    while ((entry = handle.readSync()) !== null) {
+      const abs = path.join(current, entry.name);
+      if (entry.isSymbolicLink()) continue;
+      if (entry.isDirectory()) {
+        stack.push(abs);
+        continue;
+      }
+      try {
+        const stat = statReal(abs);
+        if (stat.mtimeMs > newest) newest = stat.mtimeMs;
+      } catch {
+        /* unreadable file contributes nothing */
+      }
+    }
+    try {
+      handle.closeSync();
+    } catch {
+      /* already closed */
+    }
+  }
+  return newest;
+};
+
+/**
+ * The Chromium caches left in `%LOCALAPPDATA%` by apps that are gone or idle. Each root is
+ * listed because the app name alone proves nothing: `JianyingPro` and `DingTalk_108` have no
+ * install and no shortcut, while `electron` and the devtools are still in use, so the age
+ * limit is what keeps a live app's cache out of the result.
+ */
+const appDataCaches = () => {
+  const local = env('LOCALAPPDATA') ?? '';
+  const out = [
+    path.join(local, 'electron', 'Cache'),
+    ...subdirs(path.join(local, 'DingTalk_108'), ['Cache', 'Code Cache', 'Service Worker']),
+    ...subdirs(path.join(local, 'JianyingPro', 'User Data'), ['Cache', 'Resources']),
+    ...wechatDevtoolsCaches(),
+  ];
+  return out.filter((candidate) => isDir(candidate));
+};
+
 /**
  * `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.
@@ -475,9 +579,49 @@ const zoteroBackups = () => {
  * refuses an unelevated delete), 'pending-update' (a download that may not be applied
  * yet), 'rollback' (an older version kept beside the live one), 'superseded' (an update
  * package the installed version already contains), 'history' (a snapshot nothing reads
- * back), 'duplicate' (a byte-identical copy of a live directory) or 'database-backup' (a
- * copy of a database file made before an upgrade). Safe targets have none.
+ * back), 'duplicate' (a byte-identical copy of a live directory), 'database-backup' (a copy of
+ * a database file made before an upgrade) or 'orphan' (the app that wrote this folder is no
+ * longer installed anywhere). Safe targets have none.
+ */
+/**
+ * Which section of the panel a target is filed under. Kept outside the entries so adding a
+ * target stays one line here plus one line in the catalog, not a block to re-read.
  */
+const GROUP_OF = {
+  temp: 'system',
+  'windows-temp': 'system',
+  'windows-update': 'system',
+  'recycle-bin': 'system',
+  'inet-cache': 'system',
+  'crash-dumps': 'system',
+  'npm-cache': 'dev',
+  'pnpm-store': 'dev',
+  'pip-cache': 'dev',
+  'uv-cache': 'dev',
+  'code-cache': 'dev',
+  'editor-builds': 'dev',
+  'editor-server-bundles': 'dev',
+  'toolchain-snapshots': 'dev',
+  'chrome-cache': 'browser',
+  'edge-cache': 'browser',
+  'app-caches': 'app',
+  'app-logs': 'app',
+  'app-temp': 'app',
+  'agent-app-caches': 'app',
+  'app-data-caches': 'app',
+  'agent-logs': 'app',
+  'rotated-logs': 'app',
+  'app-updaters': 'updates',
+  'update-packages': 'updates',
+  'plugin-old-versions': 'updates',
+  'qoder-old-versions': 'updates',
+  'office-update-cache': 'updates',
+  'session-backups': 'history',
+  'rewind-snapshots': 'history',
+  'database-backups': 'history',
+  'orphan-app-data': 'orphan',
+};
+
 const CATALOG = [
   {
     id: 'temp',
@@ -512,8 +656,15 @@ const CATALOG = [
     id: 'pnpm-store',
     kind: 'purge',
     risk: 'safe',
+    // pnpm 11 kept its content under `store`; 12 moved it to `package-manager-store` and left
+    // `store` behind as an empty shell, so both are listed. `pnpm-cache` holds only registry
+    // metadata, which pnpm downloads again on demand.
     roots: ['LOCALAPPDATA'],
-    paths: () => [path.join(env('LOCALAPPDATA') ?? '', 'pnpm', 'store')],
+    paths: () => [
+      path.join(env('LOCALAPPDATA') ?? '', 'pnpm', 'store'),
+      path.join(env('LOCALAPPDATA') ?? '', 'pnpm', 'package-manager-store'),
+      path.join(env('LOCALAPPDATA') ?? '', 'pnpm-cache'),
+    ],
   },
   {
     id: 'pip-cache',
@@ -705,6 +856,46 @@ const CATALOG = [
     roots: ['USERPROFILE'],
     paths: () => rotatedLogs(),
   },
+  {
+    id: 'qoder-old-versions',
+    kind: 'purge',
+    risk: 'caution',
+    note: 'rollback',
+    roots: ['LOCALAPPDATA'],
+    paths: () => qoderOldVersions(),
+  },
+  {
+    id: 'orphan-app-data',
+    kind: 'purge',
+    risk: 'caution',
+    note: 'orphan',
+    roots: ['LOCALAPPDATA'],
+    paths: () => {
+      const guild = path.join(env('LOCALAPPDATA') ?? '', 'Tencent', 'QQGuild');
+      // Measured: no Start-menu shortcut, no uninstall entry, no Program Files folder and no
+      // file touched for over two years. The folder also carries its own `Uninstall QQGuild.exe`,
+      // which only a real install does. Every one of those signals has to agree before it goes.
+      const recent = newestMtime(guild) > Date.now() - 30 * DAY;
+      return isDir(guild) && !recent ? [guild] : [];
+    },
+  },
+  {
+    id: 'app-data-caches',
+    kind: 'aged',
+    minAgeDays: 7,
+    risk: 'caution',
+    note: 'rebuild',
+    roots: ['LOCALAPPDATA'],
+    paths: () => appDataCaches(),
+  },
+  {
+    id: 'office-update-cache',
+    kind: 'purge',
+    risk: 'caution',
+    note: 'superseded',
+    roots: ['LOCALAPPDATA'],
+    paths: () => [path.join(env('LOCALAPPDATA') ?? '', 'Microsoft', 'Office', 'SolutionPackages')],
+  },
 ];
 
 const byId = new Map(CATALOG.map((entry) => [entry.id, entry]));
@@ -740,12 +931,30 @@ const onDrive = (abs, drive) => drive === undefined || path.parse(abs).root.toLo
  */
 const isFile = (p) => {
   try {
-    return fs.statSync(p).isFile();
+    return statReal(p).isFile();
   } catch {
     return false;
   }
 };
 
+/**
+ * `fs.statSync` with Electron's asar layer switched off for the call.
+ *
+ * The host is an Electron app, and its patched fs answers size 0 for any `*.asar` it cannot
+ * parse as an archive. A superseded editor build can hold exactly one file — a 58 MB
+ * `node_modules.asar` — so without this the target reports "0 B" and reads as nothing found.
+ * The switch is synchronous and restored immediately, so no other filesystem call sees it.
+ */
+function statReal(p) {
+  const prior = process.noAsar;
+  process.noAsar = true;
+  try {
+    return fs.statSync(p);
+  } finally {
+    process.noAsar = prior;
+  }
+}
+
 /** 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));
@@ -767,6 +976,7 @@ export function resolveTargets(only, drive) {
       kind: entry.kind,
       risk: entry.risk,
       note: entry.note ?? '',
+      group: GROUP_OF[entry.id] ?? 'other',
       minAgeDays: entry.minAgeDays ?? 0,
       paths: found,
       drives,
@@ -775,21 +985,27 @@ export function resolveTargets(only, drive) {
 }
 
 /**
- * Total the files under `abs`. With a `cutoff`, only files older than it count, so a dry run
- * reports what a real run would actually delete instead of the whole folder.
+ * Total the files under `abs`, answering two questions in one pass: how much the whole thing
+ * holds (`bytes` / `files` when no cutoff is given) and how much a clean would free right now
+ * (`bytes` / `files` restricted to the cutoff). Both are returned so a caller can say "245 MB
+ * here, 0.2 MB past the age limit" instead of quietly reporting the smaller number.
  */
 export async function measurePath(abs, cutoff) {
   if (isFile(abs)) {
     try {
-      const stat = fs.statSync(abs);
-      if (cutoff !== undefined && stat.mtimeMs > cutoff) return { bytes: 0, files: 0 };
-      return { bytes: stat.size, files: 1 };
+      const stat = statReal(abs);
+      const eligible = cutoff === undefined || stat.mtimeMs <= cutoff;
+      return eligible
+        ? { bytes: stat.size, files: 1, totalBytes: stat.size, totalFiles: 1 }
+        : { bytes: 0, files: 0, totalBytes: stat.size, totalFiles: 1 };
     } catch {
-      return { bytes: 0, files: 0 };
+      return { bytes: 0, files: 0, totalBytes: 0, totalFiles: 0 };
     }
   }
   let bytes = 0;
   let files = 0;
+  let totalBytes = 0;
+  let totalFiles = 0;
   let seen = 0;
   const stack = [abs];
   while (stack.length > 0 && seen < MAX_ENTRIES) {
@@ -810,7 +1026,9 @@ export async function measurePath(abs, cutoff) {
         }
         if (!entry.isFile()) continue;
         try {
-          const stat = await fsp.stat(path.join(dir, entry.name));
+          const stat = statReal(path.join(dir, entry.name));
+          totalBytes += stat.size;
+          totalFiles += 1;
           if (cutoff !== undefined && stat.mtimeMs > cutoff) continue;
           bytes += stat.size;
           files += 1;
@@ -822,13 +1040,14 @@ export async function measurePath(abs, cutoff) {
       /* an unreadable directory ends this branch */
     }
   }
-  return { bytes, files };
+  return { bytes, files, totalBytes, totalFiles };
 }
 
 /**
- * Measure every resolved target concurrently, keeping the host event loop free. Each target's
- * own age limit is applied, so the numbers answer "what would a clean free right now" rather
- * than "how much is in the folder" — the two differ for every `aged` target.
+ * Measure every resolved target concurrently, keeping the host event loop free. `bytes` is what
+ * a clean would free right now (the target's own age limit applied); `totalBytes` is what the
+ * folders hold. Reporting both is what tells the user "245 MB here, 0.2 MB past the limit"
+ * instead of a small number that reads as "nothing found".
  */
 export async function scan(only, drive) {
   const targets = resolveTargets(only, drive);
@@ -837,12 +1056,16 @@ export async function scan(only, drive) {
       const cutoff = target.minAgeDays > 0 ? Date.now() - target.minAgeDays * DAY : undefined;
       let bytes = 0;
       let files = 0;
+      let totalBytes = 0;
+      let totalFiles = 0;
       for (const abs of target.paths) {
         const size = await measurePath(abs, cutoff);
         bytes += size.bytes;
         files += size.files;
+        totalBytes += size.totalBytes;
+        totalFiles += size.totalFiles;
       }
-      return { ...target, bytes, files };
+      return { ...target, bytes, files, totalBytes, totalFiles };
     }),
   );
   return measured;
@@ -874,7 +1097,7 @@ async function purgePath(abs, cutoff) {
         }
         if (!entry.isFile()) continue;
         try {
-          const stat = await fsp.stat(full);
+          const stat = statReal(full);
           if (cutoff !== undefined && stat.mtimeMs > cutoff) continue;
           await fsp.unlink(full);
           bytes += stat.size;
@@ -926,7 +1149,7 @@ export async function clean(ids, options = {}) {
       }
       if (isFile(abs)) {
         try {
-          const stat = await fsp.stat(abs);
+          const stat = statReal(abs);
           if (cutoff !== undefined && stat.mtimeMs > cutoff) continue;
           await fsp.unlink(abs);
           bytes += stat.size;

package/lib/client.js

@@ -41,10 +41,12 @@ window.__ModuleLoader__.load({
       'why_pending-update': '只清 {n} 天前的下载，避免删掉还没装的更新',
       why_rollback: '每个插件/程序只留版本号最高的一份，其余是回滚副本',
       why_superseded: '版本号不高于已装版本的更新包，装着的那份已经生效',
+      why_orphan: '写这个目录的程序已经不在这台机器上了：没有快捷方式、没有卸载项，两年多没写过文件',
       why_history: '每个会话的整文件备份，删了不影响会话本身',
       why_duplicate: '内容完全相同的重复副本，保留最新那份',
       'why_database-backup': '升级前的数据库副本，正在用的数据库还在旁边',
       pathCount: '{n} 处',
+      holds: '共 {n}，够老的可清',
       driveLabel: '清理范围',
       allDrives: '全部磁盘',
       scanError: '扫描失败',
@@ -78,6 +80,20 @@ window.__ModuleLoader__.load({
       'target_agent-app-caches': 'AI 应用的浏览器缓存',
       'target_rewind-snapshots': '过期的回滚快照',
       'target_rotated-logs': '轮转掉的日志',
+      'target_qoder-old-versions': '编辑器少用的旧版本目录',
+      'target_orphan-app-data': '已卸载程序的残留数据',
+      'target_app-data-caches': '已停用应用的缓存',
+      'target_office-update-cache': 'Office 更新暂存包',
+      group_system: '系统临时与回收站',
+      group_dev: '开发工具与包管理器',
+      group_browser: '浏览器缓存',
+      group_app: '应用缓存与日志',
+      group_updates: '升级残留',
+      group_history: '历史备份与快照',
+      group_orphan: '已卸载程序残留',
+      group_other: '其他',
+      groupExpanded: '收起这一类',
+      groupFolded: '展开这一类',
       auditTitle: '空间评估（本插件不会删除）',
       auditHint: '统计缓存之外真正占空间的东西：已装软件、WSL 虚拟磁盘、Windows 组件库，以及你自己的文件。这些一律不由本插件删除，只列出供你判断。',
       auditRun: '开始评估',
@@ -197,10 +213,12 @@ window.__ModuleLoader__.load({
       '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',
+      why_orphan: 'the app that wrote this folder is gone: no shortcut, no uninstall entry, nothing written for over two years',
       why_history: 'a whole-file backup per session; removing it does not touch the session',
       why_duplicate: 'an identical copy; the newest one is kept',
       'why_database-backup': 'a copy made before an upgrade; the live database is beside it',
       pathCount: '{n} location(s)',
+      holds: 'holds {n}, of which the age limit allows',
       driveLabel: 'Limit to',
       allDrives: 'All drives',
       scanError: 'Scan failed',
@@ -234,6 +252,20 @@ window.__ModuleLoader__.load({
       'target_agent-app-caches': 'Browser caches of the AI apps',
       'target_rewind-snapshots': 'Expired rewind snapshots',
       'target_rotated-logs': 'Rotated-out log files',
+      'target_qoder-old-versions': 'Old versions the editor no longer runs',
+      'target_orphan-app-data': 'Leftover data from an uninstalled app',
+      'target_app-data-caches': 'Caches of apps that stopped writing',
+      'target_office-update-cache': 'Office update staging packages',
+      group_system: 'System temp and recycle bin',
+      group_dev: 'Developer tools and package managers',
+      group_browser: 'Browser caches',
+      group_app: 'App caches and logs',
+      group_updates: 'Leftover updaters',
+      group_history: 'Backups and snapshots',
+      group_orphan: 'Data from uninstalled apps',
+      group_other: 'Other',
+      groupExpanded: 'Collapse this group',
+      groupFolded: 'Expand this group',
       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',
@@ -357,6 +389,14 @@ window.__ModuleLoader__.load({
       .dsc-total b { color: var(--dsw-alias-label-primary); font-size: 13px; }
       .dsc-list { display: flex; flex-direction: column; gap: 2px; }
       .dsc-row { display: flex; align-items: center; gap: 10px; padding: 7px 8px; border-radius: 7px; cursor: pointer; }
+      .dsc-group { display: flex; flex-direction: column; gap: 2px; }
+      .dsc-group + .dsc-group { margin-top: 6px; }
+      .dsc-group-head { display: flex; align-items: center; gap: 8px; width: 100%; box-sizing: border-box; padding: 6px 8px; border: 0; border-radius: 7px; background: transparent; font: inherit; color: var(--dsw-alias-label-primary); cursor: pointer; text-align: left; }
+      .dsc-group-head:hover { background: var(--dsw-alias-bg-layer-2); }
+      .dsc-group-head:focus-visible { outline: 2px solid var(--dsw-alias-brand-primary); outline-offset: 1px; }
+      .dsc-caret { width: 10px; color: var(--dsw-alias-label-secondary); font-size: 10px; line-height: 1; }
+      .dsc-group-title { flex: 1; min-width: 0; font-size: 12px; font-weight: 600; letter-spacing: .01em; }
+      .dsc-group-meta { color: var(--dsw-alias-label-secondary); font-size: 11px; }
       .dsc-row:hover { background: var(--dsw-alias-bg-layer-2); }
       .dsc-row input { margin: 0; accent-color: var(--dsw-alias-brand-primary); }
       .dsc-row-name { min-width: 0; flex: 1; display: flex; flex-direction: column; gap: 2px; }
@@ -575,6 +615,30 @@ window.__ModuleLoader__.load({
       }, [locale, active]);
     }
 
+    // Fixed order so the sections do not shuffle between scans.
+    const GROUP_ORDER = ['system', 'dev', 'browser', 'app', 'updates', 'history', 'orphan', 'other'];
+
+    /**
+     * Fold a flat target list into sections. Order is fixed rather than by size so a target
+     * stays where the user last saw it; the caller decides which sections read as folded.
+     */
+    function groupRows(rows) {
+      const buckets = new Map();
+      for (const row of rows) {
+        const key = GROUP_ORDER.includes(row.group) ? row.group : 'other';
+        if (!buckets.has(key)) buckets.set(key, []);
+        buckets.get(key).push(row);
+      }
+      return GROUP_ORDER.filter((key) => buckets.has(key)).map((key) => {
+        const list = buckets.get(key);
+        return {
+          key,
+          rows: list,
+          bytes: list.reduce((sum, row) => sum + (row.bytes || 0), 0),
+        };
+      });
+    }
+
     /** Why a row is safe or needs care, in one line the user can act on. */
     function riskWhy(t, row) {
       if (row.risk !== 'caution') return t('why_safe');
@@ -691,7 +755,7 @@ window.__ModuleLoader__.load({
 
       const pickAll = (on) => {
         if (!shown) return;
-        setPicked(on ? new Set(shown.filter((row) => row.bytes > 0).map((row) => row.id)) : new Set());
+        setPicked(on ? new Set(visibleRows().filter((row) => row.bytes > 0).map((row) => row.id)) : new Set());
       };
 
       const runClean = async () => {
@@ -720,6 +784,17 @@ window.__ModuleLoader__.load({
       };
 
       const shown = rows && drive !== '' ? rows.filter((row) => row.pathCount > 0) : rows;
+
+      // Only what the user toggled is stored; every other section falls back to "folded
+      // when it totals zero", which is right for the common case where 20 of 32 rows read 0 B.
+      const [toggled, setToggled] = usePersistent('folded', {});
+      const isFolded = (section) =>
+        typeof toggled[section.key] === 'boolean' ? toggled[section.key] : section.bytes === 0;
+      const toggleGroup = (section) =>
+        setToggled((prev) => ({ ...prev, [section.key]: !isFolded(section) }));
+
+      /** What is actually on screen, so a hidden row cannot be selected by a bulk action. */
+      const visibleRows = () => (shown ? groupRows(shown).filter((section) => !isFolded(section)).flatMap((section) => section.rows) : []);
       const totalBytes = shown ? shown.reduce((sum, row) => sum + (row.bytes || 0), 0) : 0;
       const pickedBytes = shown ? shown.reduce((sum, row) => sum + (picked.has(row.id) ? row.bytes || 0 : 0), 0) : 0;
 
@@ -835,35 +910,74 @@ window.__ModuleLoader__.load({
               : h(
                   'div',
                   { className: 'dsc-list' },
-                  shown.map((row) =>
+                  groupRows(shown).map((section) =>
                     h(
-                      'label',
-                      { key: row.id, className: 'dsc-row' },
-                      h('input', {
-                        type: 'checkbox',
-                        checked: picked.has(row.id),
-                        disabled: busy !== '' || row.bytes === 0,
-                        onChange: () => toggle(row.id),
-                      }),
+                      'div',
+                      { key: section.key, className: 'dsc-group' },
+                      // A row of 32 targets is unreadable as a flat list: most of them read
+                      // 0 B most of the time. Fold each kind away, and start a group whose
+                      // total is zero folded, so only the groups holding something are open.
                       h(
-                        'span',
-                        { className: 'dsc-row-name' },
-                        h('span', { className: 'dsc-row-label' }, targetName(t, row.id)),
+                        'button',
+                        {
+                          type: 'button',
+                          className: 'dsc-group-head',
+                          'aria-expanded': !isFolded(section),
+                          title: t(isFolded(section) ? 'groupFolded' : 'groupExpanded'),
+                          onClick: () => toggleGroup(section),
+                        },
+                        h('span', { className: 'dsc-caret' }, isFolded(section) ? '▸' : '▾'),
+                        h('span', { className: 'dsc-group-title' }, t(`group_${section.key}`)),
+                        h('span', { className: 'dsc-group-meta' }, `${section.rows.length}`),
                         h(
                           'span',
-                          { className: 'dsc-row-hint' },
-                          `${t('pathCount').replace('{n}', String(row.pathCount))} · ${riskWhy(t, row)}`,
+                          { className: `dsc-size${section.bytes > 0 ? '' : ' dsc-idle'}` },
+                          formatBytes(section.bytes),
                         ),
                       ),
-                      h(
-                        'span',
-                        {
-                          className: `dsc-badge${row.risk === 'caution' ? ' dsc-badge-caution' : ''}`,
-                          title: riskWhy(t, row),
-                        },
-                        t(row.risk === 'caution' ? 'risky' : 'safe'),
-                      ),
-                      h('span', { className: `dsc-size${row.bytes > 0 ? '' : ' dsc-idle'}` }, formatBytes(row.bytes)),
+                      isFolded(section)
+                        ? null
+                        : section.rows.map((row) => {
+                            // An `aged` target reports only the bytes past its age limit, so a
+                            // folder holding 261 MB can read as "0.2 MB" and look like nothing
+                            // was found. Name the folder size too when the two disagree.
+                            const holds = row.totalBytes > row.bytes ? row.totalBytes : 0;
+                            return h(
+                              'label',
+                              { key: row.id, className: 'dsc-row' },
+                              h('input', {
+                                type: 'checkbox',
+                                checked: picked.has(row.id),
+                                disabled: busy !== '' || row.bytes === 0,
+                                onChange: () => toggle(row.id),
+                              }),
+                              h(
+                                'span',
+                                { className: 'dsc-row-name' },
+                                h('span', { className: 'dsc-row-label' }, targetName(t, row.id)),
+                                h(
+                                  'span',
+                                  { className: 'dsc-row-hint' },
+                                  `${t('pathCount').replace('{n}', String(row.pathCount))} · ${riskWhy(t, row)}${
+                                    holds > 0 ? ` · ${t('holds').replace('{n}', formatBytes(holds))}` : ''
+                                  }`,
+                                ),
+                              ),
+                              h(
+                                'span',
+                                {
+                                  className: `dsc-badge${row.risk === 'caution' ? ' dsc-badge-caution' : ''}`,
+                                  title: riskWhy(t, row),
+                                },
+                                t(row.risk === 'caution' ? 'risky' : 'safe'),
+                              ),
+                              h(
+                                'span',
+                                { className: `dsc-size${row.bytes > 0 ? '' : ' dsc-idle'}` },
+                                formatBytes(row.bytes),
+                              ),
+                            );
+                          }),
                     ),
                   ),
                 ),

package/lib/index.js

@@ -103,6 +103,7 @@ const toPublic = (target) => ({
   kind: target.kind,
   risk: target.risk,
   note: target.note,
+  group: target.group,
   minAgeDays: target.minAgeDays,
   drives: target.drives,
   pathCount: target.paths.length,
@@ -155,7 +156,15 @@ async function run(action, payload) {
   if (action === 'scan') {
     const measured = await scan(readIds(payload.ids), readDrive(payload.drive));
     return {
-      targets: measured.map((target) => ({ ...toPublic(target), bytes: target.bytes, files: target.files })),
+      targets: measured.map((target) => ({
+        ...toPublic(target),
+        bytes: target.bytes,
+        files: target.files,
+        // The folder's real size, which differs from `bytes` for every `aged` target. Without
+        // it a folder holding 261 MB reads as "0.2 MB" and looks like nothing was found.
+        totalBytes: target.totalBytes,
+        totalFiles: target.totalFiles,
+      })),
     };
   }
   if (action === 'audit') return audit({ force: payload.force === true });
@@ -201,6 +210,7 @@ const NOTE_MEANING = {
   history: 'a backup snapshot of file edits that nothing reads back; the live state sits beside it',
   duplicate: 'a byte-identical copy of a directory that is still present',
   'database-backup': 'a copy of a database file taken before an upgrade; the live database is beside it',
+  orphan: 'the app that wrote this folder is no longer installed: no shortcut, no uninstall entry, and nothing written for over two years',
 };
 
 const formatBytes = (bytes) => {
@@ -281,7 +291,9 @@ export function apply(ctx) {
           'caches, the Windows internet cache, per-app caches, logs and scratch folders under %APPDATA%, ' +
           'superseded plugin versions and applied update packages, the backup snapshots, dated logs, ' +
           'rotated-out log files, duplicate toolchain copies and database backups under the user profile, ' +
-          'editor builds their launcher no longer names, and the Chromium caches of the agent apps. ' +
+          'editor builds their launcher no longer names, superseded editor versions, data left by an app ' +
+          'that is no longer installed, applied Office update packages, and the Chromium caches of the ' +
+          'agent apps. ' +
           'Call with action "overview" to list drives and target ids, ' +
           '"scan" to measure them, and "clean" to delete. clean without confirm: true is a dry run that only ' +
           'reports what it would free, so the user can approve the amount before anything is removed. ' +
@@ -366,7 +378,12 @@ export function apply(ctx) {
           }
           if (action === 'scan') {
             const measured = await scan(readIds(args.ids), readDrive(args.drive));
-            const lines = measured.map((target) => `${target.id}: ${formatBytes(target.bytes)} in ${target.files} file(s)`);
+            const lines = measured.map((target) => {
+              const limit = target.minAgeDays > 0 ? ` (${target.minAgeDays}d age limit)` : '';
+              const holds =
+                target.totalBytes > target.bytes ? ` of ${formatBytes(target.totalBytes)} present` : '';
+              return `${target.id}: ${formatBytes(target.bytes)}${holds} in ${target.files} file(s)${limit}`;
+            });
             const total = measured.reduce((sum, target) => sum + target.bytes, 0);
             const notes = [...new Set(measured.map((target) => target.note).filter(Boolean))];
             const meaning = notes.map((note) => `${note}: ${NOTE_MEANING[note] ?? note}`).join('\n');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-disk-cleaner",
-  "version": "1.4.0",
+  "version": "1.6.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

@@ -262,9 +262,59 @@ check('tool description warns audit is read-only', /read-only: it never removes
 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 28 targets', ids.length === 28, `got ${ids.length}`);
+check('catalog has the documented 32 targets', ids.length === 32, `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', 'why_pending-update', 'why_rollback', 'why_superseded', 'why_history', 'why_duplicate', 'why_database-backup'].every((k) => zhKeys.includes(k) && enKeys.includes(k)));
+const groupMap = catalog.slice(catalog.indexOf('const GROUP_OF'), catalog.indexOf('const CATALOG = ['));
+const grouped = new Set([...groupMap.matchAll(/^\s+'?([a-z-]+)'?: '[a-z]+',$/gm)].map((m) => m[1]));
+check('every catalog id is filed under a group', ids.every((id) => grouped.has(id)), `missing: ${ids.filter((id) => !grouped.has(id)).join(',')}`);
+const groupKeys = [...new Set([...groupMap.matchAll(/: '([a-z]+)',$/gm)].map((m) => m[1]))];
+check('every group has a label in both languages', groupKeys.length > 1 && groupKeys.every((key) => zhKeys.includes(`group_${key}`) && enKeys.includes(`group_${key}`)), `groups: ${groupKeys.join(',')}`);
+{
+  // Run the real grouping function out of the bundle rather than assert on its text.
+  const start = source.indexOf('const GROUP_ORDER =');
+  const end = source.indexOf('function riskWhy', start);
+  const groupRows = new Function(`${source.slice(start, end)}; return groupRows;`)();
+  const folded = groupRows([
+    { id: 'a', group: 'dev', bytes: 10 },
+    { id: 'b', group: 'dev', bytes: 5 },
+    { id: 'c', group: 'system', bytes: 0 },
+    { id: 'd', group: 'nonsense', bytes: 1 },
+  ]);
+  check('grouping keeps a fixed order, not a size order', folded.map((g) => g.key).join(',') === 'system,dev,other');
+  check('grouping totals each section', folded.find((g) => g.key === 'dev').bytes === 15);
+  check('an unknown group falls into other', folded.find((g) => g.key === 'other').rows[0].id === 'd');
+  check('an empty section is the one that starts folded', folded.filter((g) => g.bytes === 0).map((g) => g.key).join(',') === 'system');
+}
+{
+  // Fold/unfold driven by the real helpers, on real section objects. The regression this
+  // guards against was the head handing `toggleGroup` a bare key, so nothing was stored.
+  const start = source.indexOf('const GROUP_ORDER =');
+  const end = source.indexOf('function riskWhy', start);
+  const groupRows = new Function(`${source.slice(start, end)}; return groupRows;`)();
+  const live = () => groupRows([
+    { id: 'a', group: 'system', bytes: 200 },
+    { id: 'b', group: 'dev', bytes: 0 },
+  ]);
+  const isFolded = (t, section) =>
+    typeof t[section.key] === 'boolean' ? t[section.key] : section.bytes === 0;
+  const click = (t, section) => ({ ...t, [section.key]: !isFolded(t, section) });
+
+  let toggled = {};
+  let section = live().find((g) => g.key === 'system');
+  check('a group with bytes starts open', isFolded(toggled, section) === false);
+  toggled = click(toggled, section);
+  check('one click folds the group it belongs to', isFolded(toggled, section) === true);
+  check('the fold map holds only the group that was clicked', Object.keys(toggled).join(',') === 'system');
+  toggled = click(toggled, section);
+  check('a second click unfolds it again', isFolded(toggled, section) === false);
+}
+check(
+  'a group head toggles its own section',
+  /onClick: \(\) => toggleGroup\(section\)/.test(source) && !/toggleGroup\(section\.key\)/.test(source),
+);
+check('select all skips the folded sections', /visibleRows\(\)\.filter/.test(source));
+check('the panel folds the group list', /function groupRows\(rows\)/.test(source) && /aria-expanded/.test(source) && /section\.bytes === 0/.test(source));
+check('every note code has an explanation', ['why_safe', 'why_in-use', 'why_rebuild', 'why_elevation', 'why_pending-update', 'why_rollback', 'why_superseded', 'why_history', 'why_duplicate', 'why_database-backup', 'why_orphan'].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));
@@ -275,6 +325,11 @@ check(
     (catalog.match(/await measurePath\(abs, cutoff\)/g) ?? []).length === 2,
   `${(catalog.match(/await measurePath\(abs, cutoff\)/g) ?? []).length} cutoff-aware call sites`,
 );
+check(
+  'an age-limited row also names the folder size',
+  catalog.includes('totalBytes') && index.includes('totalBytes: target.totalBytes') && source.includes('row.totalBytes'),
+  'scan must carry totalBytes through to the row, or an `aged` target reads as empty',
+);
 
 const codes = [...new Set([...plan.matchAll(/code: '([a-z-]+)'/g)].map((m) => m[1]))];
 check('plan emits the documented 9 step codes', codes.length === 9, `got ${codes.length}`);