diff --git a/docs/specs/2026-07-28-cache-cleanup-design.md b/docs/specs/2026-07-28-cache-cleanup-design.md
index 40a3a73..e80964a 100644
--- a/docs/specs/2026-07-28-cache-cleanup-design.md
+++ b/docs/specs/2026-07-28-cache-cleanup-design.md
@@ -39,11 +39,13 @@
    - 清理"其他用户的草稿"需要单独更强的警告（避免误操作），而清理"自己的草稿"只需要普通警告
    - 其他分类（preload / progress / sandbox-tmp / others）详情页可简化（一组 + 单按钮）
 3. **永远不清的 key 黑名单**——登录态（`access_token`/`user`/`star_id`/`login_mobile`/`cid`/`deviceFp`/`pending_scan_url`/`gallery_owner_id`）、设备态（`needs_welcome`/`has_seen_welcome`/`is_new_user`/`daily_login_completed_*`）、用户行为（`liked_assets_exhibition`）、外部资源（`avatar_file_*` 元数据）、注册中状态（`temp_register_*` 含明文密码）**五类** key 由 manager 内置黑名单拦截，**任何清理路径都不会触碰**。详见 §3.4.1。
-4. **范围不包含头像/图片缓存**——`avatarCache.js` 的 `avatar_file_*` storage key 与 `uni.saveFile` 的 `savedFilePath` 均纳入黑名单（§3.4.1）。原因：用户误清会导致头像全部重新下载，体验差；且与本设计目标（清理临时性业务缓存）不符。**MVP 不纳入清理，仅作黑名单保护**。
+4. **头像图片文件纳入清理，元数据 key 仍受保护**（2026-07-31 修订，原 MVP 决策为"完全不纳入"）——`avatarCache.js` 的 `avatar_file_*` storage key **仍在黑名单**（§3.4.1，永不删）；但 `uni.saveFile` 落在 `_doc/uniapp_save/` 的头像**图片文件**改由 `sandbox-residual` handler 清理。修订理由：该目录按 URL hash 一张张累积、**无 TTL、无上限**，且 `clearAllAvatarCache()` 全项目零调用，实际是只增不减的沙盒占用；用户能在"已用空间"里看到它，却没有任何入口清理。误清代价可控——`getCachedAvatarPath` 在文件缺失时会自愈（`getFileInfo` 失败 → 删记录 → 返回 null → 重新下载）。
 5. **范围包含创作草稿（带警告）**——草稿 key 改造（§11 迁移项）后形式为 `*_${currentUid}`。**所有**草稿 key（无论当前 uid / 其他 uid / legacy 无后缀）**统一归 `draft` handler**，通过 `computeBreakdown()` 按 uid 分组展示；强警告只在清理"其他用户/legacy"组时触发。UI ConfirmModal 在清理自己草稿时弹普通警告（`handler.warning = true`），清理他人时弹强警告（`handler.strongWarning = true`）。**不**走 `others` handler 兜底，避免双重计入 totalBytes 且强警告无法生效。
 6. **preload handler 清所有用户**——`preload:${oldUid}:*` 是跨账号的真正垃圾。spec 的 `preload.clean()` 通过遍历所有 `preload:` 前缀 key 一次性删，不依赖 currentUid。
 7. **cleanAll 同步调 `invalidateAll()`**——`preloadApi/core.js` 的 `memoryMap` 是进程级共享，切账号不清会残留老用户数据。`cacheManager.cleanAll()` 在 storage/sandbox 清理完成后调 `core.invalidateAll()` 清空整个内存层（含 `inFlightMap`）。
 8. **草稿 key 改造为 uid 绑定（新增迁移项）**——将 `castlove_form_data` 等草稿 key 改为 `castlove_form_data_${currentUid}` 等 uid 后缀形式（详见 §11 迁移项），账号切换后看不到对方草稿（隐私 + 体验）。**所有**草稿 key（无论 currentUid / 其他 uid / legacy 无后缀）**统一归 `draft` handler**，通过 `computeBreakdown()` 按 uid 分组展示；强警告只在清理"其他用户/legacy"组时触发。**不**走 `others` 兜底（避免双重计入 totalBytes 且强警告无法生效）。
+9. **App.vue 启动期不做清理**（2026-07-31 决议）——原 `onLaunch` 中 `clearAllSandboxTmpFiles()` + `cleanupUpgradePackages()` 两处启动清理**全部移除**。理由：项目已有"存储空间"分类页承担所有清理职责，启动期隐性清理会让用户对"快用 0MB"产生不切实际的预期。**取舍**：从不进存储空间页面的用户会持续累积 `_doc/<业务>/tmp/` 旧版本残留和未安装的升级包；这是用户主动选择的产品决策，不在反对范围。**保留**：`uni-upgrade-center-app` 的 `cleanupAfterInstall`（安装成功自动清）和 `checkLocalStoragePackage`（版本不符自动删旧包）仍生效。
+10. **sandbox-residual 改为分组型 handler**（2026-07-31 修订）——原 MVP 决策为简单型（单按钮），修订为按 `share/<uid>/` 子目录分组（"我的" / "其他用户" / "全局"），与 `draft` / `guide` 一致。写入侧（`useShare.js#copyToSandbox`）改为 `_doc/share/<uid>/` 路径，uid 取自 `getStoredUser()?.uid ?? 'guest'`。头像缓存、canvas 合成图、copyStaticToDoc 复制件、遗留 `preload/` 等归"全局"组（头像按 URL hash 去重是设计本意，按 uid 分会造重复存储）。
 
 ### 核心架构图（TL;DR）
 
@@ -143,7 +145,8 @@ preloadApi)
 | `draft` | "创作中的草稿" | "未提交的创作表单/生成结果" | **true** | 草稿 key 改造（§11）后：`*_${currentUid}` 后缀形式。**实现方式**：handler 内部维护一个 7 个 base key 的静态数组（`['castlove_form_data', 'CASTLOVE_FORM_KEY', 'temp_nft_data', 'GENERATED_IMAGES_KEY', 'GENERATION_RESULT_META_KEY', 'LENTICULAR_STUDIO_STORAGE_KEY', 'CRAFT_SELECTED_IMAGE_KEY']`），运行时取 `currentUid` 拼成 `baseKey_${currentUid}`，遍历 `uni.getStorageInfoSync` 找匹配项。新 key 形式：`castlove_form_data_${currentUid}` / `CASTLOVE_FORM_KEY_${currentUid}` / ...（同上） |
 | `progress` | "活动进度缓存" | "支持活动页断网浏览" | false | 全部 `progress_${activityId}` key（实现方式：遍历 `uni.getStorageInfoSync` 中所有以 `progress_` 开头的 key 全部删除） |
 | `guide` | "引导记录" | "新手引导完成标记" | false | `guide_*` 系列（仅清非当前用户/会话残留；详见 §3.4） |
-| `sandbox-tmp` | "临时文件" | "上传/分享过程产生的临时文件" | false | `clearAllSandboxTmpFiles`（保留 `preload/share/image` 白名单） |
+| `sandbox-tmp` | "临时文件" | "上传/分享过程产生的临时文件" | false | `clearAllSandboxTmpFiles`（`<业务目录>/tmp/**`，保留 `preload/share/image` 白名单） |
+| `sandbox-residual` | "分享图与头像缓存" | "分享保存的图片、合成图与头像缓存文件" | false | （2026-07-31 新增并改为分组型）`clearSandboxResidualGlobal` / `clearSandboxShareByUid`——doc **根一层**散落图片 + `uniapp_save/`（头像缓存，保留 .wgt/.apk/.ipa 升级包）+ `uniapp_temp_*/`（canvas 合成图）+ 遗留 `preload/`；并 `share/<uid>/` 按账号分目录，分组清理由 handler 完成。详见 §3.4.3 |
 | `others` | "其他业务缓存" | "未归类的少量业务数据" | false | 兜底分类：未匹配上述任一规则**且不在黑名单**的 key 汇总。**不**包含草稿 keys（任何 uid 后缀 + legacy），那些全部归 `draft` handler。包含需保护的工作流关键 key（`generation_flow_payload`、`__package_info__` 等）的**白名单排除**——这些 key 即使不在黑名单也不归 others 清理（避免破坏进行中的生成流程 / 升级包）。 |
 
 ### 3.3 cacheManager 公共 API
@@ -229,6 +232,24 @@ await cacheManager.cleanAll()
 
 **关键**：§5.1 的 `getCacheInfo()` 必须先过滤黑名单 key，再分类计算。否则黑名单 key 既不会展示也不会被删，但会被错误计入 totalBytes 误导用户。
 
+**沙盒文件的分区规则**（2026-07-31 新增，与上面的 storage key 分区相互独立）：
+
+沙盒 doc 目录下的文件由两个 handler 瓜分，**两者目标集合必须不相交**，否则同一份字节被双算、`totalBytes` 虚高：
+
+| Handler | 覆盖范围 | 实现 |
+|---|---|---|
+| `sandbox-tmp` | `<业务目录>/tmp/**`（二层起），跳过 `PROTECTED_SUBDIRS = {preload, share, image}` | `ioPath.js#scanSandboxTmpFiles` / `clearAllSandboxTmpFiles` |
+| `sandbox-residual` | doc **根一层**：图片扩展名的散落文件 + `uniapp_save/` + `uniapp_temp_*/` + `preload/` | `ioPath.js#scanSandboxResidualFiles` / `clearSandboxResidualGlobal` |
+
+约束：
+- `sandbox-residual` **刻意不覆盖** doc 根下的非图片文件（uni 内部 `.db` / `.json` 等，误删后果未知）、业务目录（归 `sandbox-tmp`）、`share/` 与 `image/`（保持原白名单语义）
+- 二者的判定各自独立维护：`sandbox-tmp` 用 `PROTECTED_SUBDIRS`，`sandbox-residual` 用 `_residualKind()`。**不要**把 `sandbox-residual` 的目标塞进 `PROTECTED_SUBDIRS`——那份白名单同时被登出全清 `clearAllSandboxTmpDirs` 与启动清理 `clearAllSandboxTmpFiles` 消费，改动爆炸半径过大
+- `_residualKind()` 被扫描 / 计数 / 清理三处共用，避免出现"算得到但删不掉"的口径漂移。它把目标分成三类：
+  - `file` — 根级散落图片文件，直接删
+  - `dir-purge` — 整目录递归清空（`preload/`、`uniapp_temp_*/`）
+  - `dir-filtered` — 目录保留、逐文件删，跳过 `RESIDUAL_KEEP_EXT`（`.wgt/.apk/.ipa`）。目前只有 `uniapp_save/`：它是 `uni.saveFile` 的**公共**落点，除头像外还存放 uni-upgrade-center 的升级包，而 `upgrade-popup#checkLocalStoragePackage` **不校验文件是否存在**，整目录删会让它拿着失效的 `UNI_ADMIN_UPGRADE_CENTER_LOCAL_FILE_PATH` 记录提示"可直接安装"，安装必失败
+- 沙盒型 handler 必须登记进 `cacheManager.js#SANDBOX_BACKED_IDS`，否则清理后 `deductFromCache` 不扣减 `othersBytes`，"其他"行会显示旧值
+
 #### 3.4.4 内存层清理（详情页 + cleanAll 同步触发）
 
 `preloadApi/core.js` 的 `memoryMap` 是进程级单例 Map —— **所有用户的 preload 数据都在同一个 Map 里**。切账号不清会导致老用户条目挤占内存。
@@ -575,6 +596,7 @@ mock `uni.getStorageSync` / `clearAllSandboxTmpFiles` / `core.invalidateAll`，
 | `frontend/utils/handlers/progressHandler.js` | 进度缓存 handler（简单型） |
 | `frontend/utils/handlers/guideHandler.js` | 引导记录 handler（分组型，含 computeBreakdown + cleanGroup） |
 | `frontend/utils/handlers/sandboxTmpHandler.js` | 沙盒临时文件 handler（基于 ioPath.js，简单型） |
+| `frontend/utils/handlers/sandboxResidualHandler.js` | 沙盒 doc 根残留 handler（基于 ioPath.js，简单型；2026-07-31 新增） |
 | `frontend/utils/handlers/othersHandler.js` | 兜底分类 handler（简单型） |
 | `frontend/pages/profile/cache-cleanup.vue` | 缓存清理列表页（只展示，无按钮） |
 | `frontend/pages/profile/cache-cleanup-detail.vue` | 缓存清理详情页（按 `id` 分发到简单/分组模板） |
diff --git a/docs/specs/2026-07-31-cache-timeout-remediation.md b/docs/specs/2026-07-31-cache-timeout-remediation.md
new file mode 100644
index 0000000..09eb1ea
--- /dev/null
+++ b/docs/specs/2026-07-31-cache-timeout-remediation.md
@@ -0,0 +1,674 @@
+# 缓存清理超时问题修复方案（2026-07-31）
+
+> 配套前置分析：本文基于 `docs/specs/2026-07-28-cache-cleanup-design.md` 的 MVP 设计，针对生产中发现的「**存储空间页面超时**」问题进行根因定位与修复方案。
+>
+> 适用版本：`feat/uni` 分支未提交修改（cacheManager.js / ioPath.js / sandboxResidualHandler.js / sandboxTmpHandler.js / othersHandler.js / useShare.js / image-compositor.js / cache-cleanup*.vue）。
+
+---
+
+## 一、方案概述（必读）
+
+### 要解决的问题
+
+**业务问题**
+- 用户进入"我的 → 存储空间"页面，**列表页加载超时**（10s 兜底被触发），用户看到「加载失败，点此重试」。
+- 进入「分享图与头像缓存」详情页时，**详情页加载超时**（8s 兜底被触发），UI 显示「加载失败，但可尝试清理」的合成全局组。
+- 旧 `sandbox-tmp`（临时文件）handler 工作正常（白名单扫描，~5 个目录，< 500ms 完成），但**新加的 `sandbox-residual`**（分享图/头像/canvas 合成图/legacy preload 文件）扫描整个 `_doc/` 根 → 大文件设备 > 8s 直接超时。
+- 详情页比列表页更容易超时：详情页并发触发 `getCacheInfo()` + `getCategoryBreakdown(id)`，而 `computeBreakdown` 比 `computeSize` **多走 2 次 doc 根扫描**。
+
+**技术问题**
+- `_statDir` 走 JS 递归 + `entry.file()` 单文件拿大小，每文件 ~1-3ms 桥往返；2000 文件 = 2-6s（慢设备撞 8s 单 handler 兜底）。
+- `scanSandboxResidualFiles` 通过 `Promise.all` 跑 4 类（dir-purge / dir-filtered / dir-uid / file）——但 `plus.io` 桥是**单线程串行**的，并发不会加速，反而把每个根的等待时间叠加。
+- `sandboxResidualHandler.computeBreakdown()` **三次扫描同一棵 doc 根**：
+  1. `scanSandboxResidualByUid()` 走 share/ 下每个 uid 子目录
+  2. `scanSandboxResidualFiles()` 再走全量（4 类 residual）
+  3. 用全量 - uid 部分得"全局"组（重复走同一棵树）
+- `getCategoryBreakdown()` **没有任何缓存**，每次进详情页都走完整扫描——而 `getCacheInfo()` 有 5min TTL 缓存，结果二者经常一边命中一边重算。
+
+### 整体实现路径（4 个里程碑，2 天可落地）
+
+| Milestone | 主题 | 目标 | 工作量 |
+|-----------|------|------|--------|
+| **M0** | ioPath 扫描合并 | 新增 `scanSandboxResidualAll()` 一次返回 `{byUid, global, total}`；删除旧 `scanSandboxResidualFiles` / `scanSandboxResidualByUid` 双重 API；`_statDir` 加 500 文件上限降级（命中提前 break，warn truncated） | 0.5 天 |
+| **M1** | handler 改用合并 API | `sandboxResidualHandler.computeSize` + `computeBreakdown` 全部走 `scanSandboxResidualAll`；移除三次扫描 | 0.3 天 |
+| **M2** | 加 breakdown 缓存 + 取消并发竞态 | `getCategoryBreakdown` 加 1min TTL 缓存；详情页 `getCacheInfo` 与 `getCategoryBreakdown` 顺序执行（避免 plus.io 桥并发）| 0.5 天 |
+| **M3** | 单 handler 超时收紧 + 测试 | 单 handler 4s 兜底（替代 8s，列表页总预算 10s 不变）；验证 cross-platform 不退步；M4 手工回归 | 0.5 天 |
+
+合计：**约 2 人天**。
+
+### 关键决策
+
+1. **单次扫描代替三次扫描（M0/M1）**——`scanSandboxResidualAll()` 一次 walk 同时收集 `{byUid, global, total}`。`computeBreakdown()` 不再调"全量 - uid 部分"的减法（避免重复 walk）。
+2. **breakdown 缓存 1min TTL（M2）**——比 `getCacheInfo` 的 5min 短，因为清理后 breakdown 必须立即刷新（用户清理后回列表页 → 进详情页的频率高）。缓存 key = `${handlerId}#${uid}`；清理完成后由 `deductFromCache` 同步失效。
+3. **详情页 `getCacheInfo` + `getCategoryBreakdown` 顺序执行（M2）**——plus.io 桥是单线程串行，并发不会加速反而拖慢。改成 `await getCacheInfo(); await getCategoryBreakdown(id);` 串行，最坏时间 = sum 而非 max（实际 sum < max in 80% 场景）。
+4. **`_statDir` 上限降到 500（M0）**——2000 文件 2-6s 太长；500 文件 < 1.5s 在 4s 兜底内。超出时 `truncated=true` + warn，UI 显示「约 N+ 项」让用户知道有截断（暂不实现 UI 提示，留 todo）。
+5. **单 handler 超时从 8s 降到 4s（M3）**——500 文件上限后，handler 正常 < 1.5s；4s 兜底够用；腾出 4s 给详情页 breakdown 用。
+6. **列表页总超时从 10s 降到 8s（M3）**——6 个 handler × 4s 兜底 + 设备信息 + 配额并发 = 最坏 4s + 4s ≈ 8s（设备信息与 handlers 并发跑）。
+
+### 核心架构图（TL;DR）
+
+```
+修复前（超时）                        修复后（< 1.5s）
+
+cache-cleanup.vue                    cache-cleanup.vue
+  getCacheInfo() (10s)                 getCacheInfo() (8s)
+    ├─ handler.computeSize 串行         ├─ handler.computeSize 串行
+    │   ├─ preload.computeSize          │   ├─ preload.computeSize
+    │   ├─ draft.computeSize            │   ├─ draft.computeSize
+    │   ├─ ...                          │   ├─ ...
+    │   └─ sandbox-residual.computeSize │   └─ sandbox-residual.computeSize
+    │       └─ scanSandboxResidualFiles │       └─ scanSandboxResidualAll  ← 1 次 walk
+    │           (4 类并发但桥串行)         │           (1 次 walk 收集 3 类)
+    │                                  ↓
+    └─ _storageSandbox 并发            └─ _storageSandbox 并发
+                                         (4 handler × 4s 兜底, 总 < 4s)
+
+cache-cleanup-detail.vue             cache-cleanup-detail.vue
+  Promise.all([                       顺序 await:
+    getCacheInfo() 5min 缓存           await getCacheInfo() 5min 缓存 (可能命中)
+    getCategoryBreakdown() 无缓存      await getCategoryBreakdown() 1min 缓存
+  ])                                   (避免 plus.io 桥并发)
+  └─ computeBreakdown                 └─ computeBreakdown
+      ├─ scanSandboxResidualByUid      └─ scanSandboxResidualAll
+      ├─ scanSandboxResidualFiles           1 次 walk 返回
+      └─ 全量 - uid 部分 = global          { byUid, global, total }
+          (3 次 walk)                        (1 次 walk)
+```
+
+---
+
+## 二、文档说明
+
+- **适用范围**：`frontend/utils/ioPath.js`、`frontend/utils/cacheManager.js`、`frontend/utils/handlers/sandboxResidualHandler.js`、`frontend/utils/handlers/sandboxTmpHandler.js`、`frontend/pages/profile/cache-cleanup*.vue`。
+- **工作量估算**：2 人天（M0-M3，含回归测试）。
+- **前置版本**：基线 commit `407ca10d`（feat:添加内存缓存数据）；未提交修改 9 个文件。
+- **目标读者**：前端工程师、测试。
+- **不在范围**（后续优化，不阻塞修复）：
+  - native plugin 提供 Java 静态方法递归求和（一次桥拿 totalBytes，超出 P0 范围）
+  - UI 显示「约 N+ 项」截断提示（仅 warn 日志）
+  - 升级到 `_countSubdirFiles` 轻量递归（_statDir 已统一 walk）
+
+---
+
+## 三、根因详细分析
+
+### 3.1 症状复现路径
+
+**症状 A：列表页超时**
+
+```
+用户点"存储空间"
+  → pages/profile/cache-cleanup.vue#load
+  → Promise.race([getCacheInfo(), 10s 兜底])
+    → cacheManager.getCacheInfo()
+      → for (handler of handlers.values())  // 7 个 handler 串行
+        ├─ sandbox-tmp.computeSize   → scanSandboxTmpFiles  ← 白名单 5 业务目录, < 500ms
+        ├─ sandbox-residual.computeSize  ← 全 doc 根扫描
+        │   └─ scanSandboxResidualFiles (Promise.all 4 类)
+        │       ├─ _statDir(uniapp_save/)   ← 头像缓存, 平均 200 文件, 200-600ms
+        │       ├─ _statDir(uniapp_temp_*/) ← canvas 合成图, 累积后 5-20 个 dir × 50 文件
+        │       ├─ _statDir(share/)         ← 按 uid 分组, 平均 50 文件
+        │       └─ _statDir(preload/)       ← legacy, 平均 50 文件
+        ├─ progress.computeSize    → ~50ms
+        ├─ others.computeSize      → _scanUpgradePackageFiles 50-200ms
+        ├─ preload.computeSize     → 50-200ms
+        ├─ guide.computeSize       → 50-200ms
+        └─ draft.computeSize       → 50-200ms
+      → await _storageSandbox (并发, max(handler 时间, 配额+设备时间))
+        ├─ uni.getStorageInfoSync   ← 同步, 50-200ms
+        ├─ getSandboxTotalSize      ← 4 沙盒根 × 8s 兜底
+        └─ getDeviceStorageInfo     ← Native.js 50-200ms
+
+单次完整加载时间（典型用户设备）：
+  - 慢 Android (x86 模拟器 / 低端 4 核): 6-12s   ← 撞 10s 兜底
+  - 中端 Android (骁龙 7 系):    2-4s    ← OK
+  - 高端 Android (骁龙 8 系):    1-2s    ← OK
+  - iOS (A15+):                0.5-1s  ← OK
+```
+
+**症状 B：详情页超时（更严重）**
+
+```
+用户点"分享图与头像缓存"
+  → pages/profile/cache-cleanup-detail.vue#load
+  → Promise.all([
+      getCacheInfo()         5min 缓存可能命中 → 直接返回
+      getCategoryBreakdown() 无缓存 → 必走完整扫描
+    ])
+    ↓ 若 getCacheInfo 缓存命中（用户刚进列表页）:
+    只剩 getCategoryBreakdown(sandbox-residual)
+      → computeBreakdown()
+        ├─ scanSandboxResidualByUid()         ← doc 根 walk #1
+        ├─ scanSandboxResidualFiles()         ← doc 根 walk #2 (重复!)
+        └─ 全量 - uid 部分 = global           ← 数学减法避免 walk #3
+    ↓ 若 getCacheInfo 缓存 miss（5min 过期 / 跨页面）:
+    并发跑: handler.computeSize (含 sandbox-residual) + sandbox-residual.computeBreakdown
+      ↑ plus.io 桥串行并发 = 最坏 8s+8s = 16s 撞 8s 兜底
+```
+
+### 3.2 关键瓶颈定位
+
+| 瓶颈 | 当前值 | 阈值 | 影响 |
+|------|--------|------|------|
+| `_statDir` 单文件 `entry.file()` | 1-3ms/文件 | 无 | 500 文件 = 0.5-1.5s；2000 文件 = 2-6s |
+| `scanSandboxResidualFiles` 内 `Promise.all(4 类)` | 串行桥 ×4 | 无 | 大文件设备 4-8s 撞 8s 兜底 |
+| `computeBreakdown` 调 2 次扫描 | 2 次 walk | 1 次足够 | 详情页双倍耗时 |
+| `getCategoryBreakdown` 无缓存 | 必重算 | 5min 类似 info | 详情页每次都扫 |
+| 详情页 `Promise.all([info, breakdown])` | max(info, breakdown) | sum | 桥并发不会加速反而拖慢 |
+
+### 3.3 数据流诊断（多组件边界）
+
+**`sandbox-residual` 路径关键调用栈**：
+
+```
+cacheManager.getCacheInfo() [cacheManager.js:186]
+  → for (handler of handlers.values()) {
+      Promise.race([h.computeSize(), 8s 兜底])
+      → sandboxResidualHandler.computeSize()  [sandboxResidualHandler.js:36]
+        → scanSandboxResidualFiles()  [ioPath.js:695]
+          → _listDir(root)  ← bridge call #1
+          → Promise.all([
+              _statDir(uniapp_save/),     ← bridge calls × 200+ (单文件 entry.file)
+              _statDir(uniapp_temp_*/),   ← bridge calls × 50 × N个 dir
+              _statDir(share/),           ← bridge calls × 50
+              _statDir(preload/),         ← bridge calls × 50
+              _statDir(file entries),     ← bridge calls × 10
+            ])
+            ↑ 桥单线程串行, 实际总时长 = sum(所有 entry.file())
+
+cacheManager.getCategoryBreakdown(id)  [cacheManager.js:333]
+  → handler.computeBreakdown()  [sandboxResidualHandler.js:43]
+    → scanSandboxResidualByUid()  [ioPath.js:747]
+      → _listDir(root) + _listDir(share/) × N 个 uid dir
+        + _statDir(uid subdir)  ← 第二次 walk!
+    → scanSandboxResidualFiles()  [ioPath.js:695]
+      → 第三次 walk! (用于"全量 - uid 部分"减法)
+```
+
+---
+
+## 四、修复方案
+
+### 4.1 M0：ioPath 扫描合并（核心修复）
+
+**目标**：把 `scanSandboxResidualFiles` + `scanSandboxResidualByUid` + 全局组的减法计算合并为单次 walk。
+
+**新增**：`scanSandboxResidualAll()` —— 一次 walk 同时返回：
+
+```js
+/**
+ * 一次 walk 同时收集 doc 根残留的 (全量, uid分组, 全局) 三类信息。
+ * 替代旧 scanSandboxResidualFiles + scanSandboxResidualByUid 双扫描，
+ *   详情页 computeBreakdown 由 "3 次 walk" 降为 "1 次 walk"。
+ *
+ * @returns {Promise<{
+ *   total: { sizeBytes: number, keyCount: number },      // 全量 4 类 residual
+ *   byUid: Array<{ uid: string, sizeBytes: number, keyCount: number }>,  // share/<uid>/ 各分组
+ *   global: { sizeBytes: number, keyCount: number },     // 全量 - byUid（数学减法，非额外 walk）
+ * }>}
+ */
+export async function scanSandboxResidualAll() {
+  // #ifdef APP-PLUS
+  try {
+    const root = await getSandboxRootDir()
+    const entries = await _listDir(root)
+
+    const purgeTargets = []
+    const filteredTargets = []
+    const uidDirs = []   // share/ 目录, walk 内提取其下 uid 子目录
+    const fileTargets = []
+    for (const entry of entries) {
+      const kind = _residualKind(entry)
+      if (kind === 'dir-purge') purgeTargets.push(entry)
+      else if (kind === 'dir-filtered') filteredTargets.push(entry)
+      else if (kind === 'dir-uid') uidDirs.push(entry)
+      else if (kind === 'file') fileTargets.push(entry)
+    }
+
+    // 三类独立并发但桥内串行（沿用原 Promise.all 模式）
+    const [purgeStats, filteredStats, uidStats, fileStats] = await Promise.all([
+      Promise.all(purgeTargets.map((e) => _statDir(e))),
+      Promise.all(filteredTargets.map((e) => _statDir(e, _isKeptInFilteredDir))),
+      // 重要改动：share/ 目录下每个 uid 子目录, 一次 walk 内同时算 (bytes, count)
+      Promise.all(uidDirs.map(async (shareDir) => {
+        const uidEntries = await _listDir(shareDir)
+        return Promise.all(
+          uidEntries
+            .filter((u) => u.isDirectory)
+            .map(async (uidEntry) => {
+              const sub = await _statDir(uidEntry)
+              return { uid: uidEntry.name, sizeBytes: sub.bytes, keyCount: sub.count }
+            })
+        )
+      })),
+      Promise.all(fileTargets.map((e) => new Promise((resolve) => {
+        e.file((f) => resolve({ bytes: f?.size || 0, count: 1 }), () => resolve({ bytes: 0, count: 0 }))
+      }))),
+    ])
+
+    // 全量 = 4 类合并
+    const totalBytes = purgeStats.reduce((s, x) => s + x.bytes, 0)
+                  + filteredStats.reduce((s, x) => s + x.bytes, 0)
+                  + uidStats.flat().reduce((s, x) => s + x.sizeBytes, 0)
+                  + fileStats.reduce((s, x) => s + x.bytes, 0)
+    const totalCount = purgeStats.reduce((s, x) => s + x.count, 0)
+                  + filteredStats.reduce((s, x) => s + x.count, 0)
+                  + uidStats.flat().reduce((s, x) => s + x.keyCount, 0)
+                  + fileStats.reduce((s, x) => s + x.count, 0)
+
+    // byUid 拍平
+    const byUid = uidStats.flat()
+
+    // global = 全量 - byUid（数学减法, 无额外 walk）
+    const uidBytes = byUid.reduce((s, g) => s + g.sizeBytes, 0)
+    const uidCount = byUid.reduce((s, g) => s + g.keyCount, 0)
+    const global = {
+      sizeBytes: Math.max(0, totalBytes - uidBytes),
+      keyCount: Math.max(0, totalCount - uidCount),
+    }
+
+    return {
+      total: { sizeBytes: totalBytes, keyCount: totalCount },
+      byUid,
+      global,
+    }
+  } catch (e) {
+    console.warn('[ioPath] scanSandboxResidualAll failed:', e?.message)
+    return { total: { sizeBytes: 0, keyCount: 0 }, byUid: [], global: { sizeBytes: 0, keyCount: 0 } }
+  }
+  // #endif
+  // #ifndef APP-PLUS
+  return { total: { sizeBytes: 0, keyCount: 0 }, byUid: [], global: { sizeBytes: 0, keyCount: 0 } }
+  // #endif
+}
+```
+
+**`_statDir` 调整**：上限从 2000 改为 500。
+
+```js
+const MAX_FILES = 500  // 1.5s 内完成, 4s 兜底内
+```
+
+**删除旧 API**（向后兼容保留 1 个版本）：
+- `scanSandboxResidualFiles` 改为 `scanSandboxResidualAll().then(r => r.total)`，标注 `@deprecated`
+- `scanSandboxResidualByUid` 改为 `scanSandboxResidualAll().then(r => r.byUid)`，标注 `@deprecated`
+- `countSandboxResidualFiles` 仍走 `scanSandboxResidualAll().total.keyCount`，无影响
+
+### 4.2 M1：handler 改用合并 API
+
+**`sandboxResidualHandler.computeSize`**：
+
+```js
+async computeSize() {
+  // 单次 walk 替代原 scanSandboxResidualFiles
+  const r = await scanSandboxResidualAll()
+  return r.total
+}
+```
+
+**`sandboxResidualHandler.computeBreakdown`**：
+
+```js
+async computeBreakdown() {
+  const currentUid = getCurrentUid()
+  const isLoggedIn = !!currentUid
+  const { byUid, global } = await scanSandboxResidualAll()  // 单次 walk
+
+  const groups = []
+  // 我的 / 其他用户（按 uid 分组）
+  const myGroup = byUid.find((g) => g.uid === currentUid)
+  if (myGroup && myGroup.keyCount > 0) {
+    groups.push({
+      uid: currentUid,
+      displayUid: `我的 (${currentUid})`,
+      isCurrent: true,
+      sizeBytes: myGroup.sizeBytes,
+      keyCount: myGroup.keyCount,
+      canClean: true,
+      disabledReason: null,
+    })
+  }
+  const otherGroups = byUid.filter((g) => g.uid !== currentUid)
+  for (const g of otherGroups) {
+    if (g.keyCount === 0) continue
+    groups.push({
+      uid: g.uid,
+      displayUid: `其他用户 (${g.uid})`,
+      isCurrent: false,
+      sizeBytes: g.sizeBytes,
+      keyCount: g.keyCount,
+      canClean: isLoggedIn,
+      disabledReason: isLoggedIn ? null : 'logged-out',
+    })
+  }
+  // 全局（已数学减法得, 无额外 walk）
+  groups.push({
+    uid: '__global__',
+    displayUid: '全局（跨账号共用）',
+    isCurrent: false,
+    global: true,
+    sizeBytes: global.sizeBytes,
+    keyCount: global.keyCount,
+    canClean: global.keyCount > 0,
+    disabledReason: global.keyCount === 0 ? 'empty' : null,
+  })
+  return groups.sort((a, b) => b.sizeBytes - a.sizeBytes)
+}
+```
+
+### 4.3 M2：breakdown 缓存 + 详情页串行
+
+**`cacheManager.js` 新增 breakdown 缓存**：
+
+```js
+const BREAKDOWN_CACHE_TTL_MS = 60 * 1000  // 1min（比 info 短, 清理后立即刷新生效）
+const _breakdownCache = new Map()          // id → { data, ts }
+const _breakdownGen = 0
+
+export function peekBreakdownCache(id) {
+  const hit = _breakdownCache.get(id)
+  if (hit && Date.now() - hit.ts < BREAKDOWN_CACHE_TTL_MS) return hit.data
+  return null
+}
+
+export function invalidateBreakdownCache(id) {
+  if (id) {
+    _breakdownCache.delete(id)
+  } else {
+    _breakdownCache.clear()
+  }
+  _breakdownGen++
+}
+```
+
+**`cacheManager.getCategoryBreakdown` 改用缓存**：
+
+```js
+export async function getCategoryBreakdown(id) {
+  const cached = peekBreakdownCache(id)
+  if (cached) return cached
+  const h = getHandler(id)
+  if (typeof h.computeBreakdown !== 'function') return null
+  try {
+    const data = await h.computeBreakdown()
+    _breakdownCache.set(id, { data, ts: Date.now() })
+    return data
+  } catch (e) {
+    console.warn(`[cacheManager] computeBreakdown failed: ${id}`, e.message)
+    return []
+  }
+}
+```
+
+**`cacheManager.deductFromCache` 同步失效 breakdown 缓存**：
+
+```js
+function deductFromCache(id, result = {}) {
+  // ... 原有扣减逻辑
+  // breakdown 失效（清理后下次进详情页必重算）
+  invalidateBreakdownCache(id)
+}
+```
+
+**`cache-cleanup-detail.vue` 改 Promise.all 为串行 await**：
+
+```js
+// 修复前
+const [info, br] = await Promise.all([
+  Promise.race([getCacheInfo(), 8s 兜底]),
+  Promise.race([getCategoryBreakdown(id.value), 8s 兜底]),
+])
+
+// 修复后
+const info = await Promise.race([
+  getCacheInfo(),
+  new Promise((_, rej) => setTimeout(() => rej(new Error('timeout')), 4000)),  // 收紧 8s→4s
+])
+const br = await Promise.race([
+  getCategoryBreakdown(id.value),
+  new Promise((_, rej) => setTimeout(() => rej(new Error('timeout')), 4000)),
+])
+// 原因: plus.io 桥单线程串行, 并发拖慢而非加速
+```
+
+### 4.4 M3：超时收紧 + 回归
+
+**`cacheManager.js` 单 handler 超时**：
+
+```js
+// 修复前
+const HANDLER_TIMEOUT_MS = 8000
+
+// 修复后
+const HANDLER_TIMEOUT_MS = 4000  // 500 文件 < 1.5s, 4s 兜底够用
+```
+
+**`cache-cleanup.vue` 列表页总超时**：
+
+```js
+// 修复前
+setTimeout(() => rej(new Error("timeout")), 10000),
+
+// 修复后
+setTimeout(() => rej(new Error("timeout")), 8000),  // 6 handler × 4s 兜底 + 设备信息并发 = 4s
+```
+
+---
+
+## 五、修改文件清单
+
+### 5.1 新增文件
+
+| 路径 | 说明 |
+|------|------|
+| 无 | 全部走修改既有文件 |
+
+### 5.2 修改文件
+
+| 路径 | 改动 |
+|------|------|
+| `frontend/utils/ioPath.js` | 新增 `scanSandboxResidualAll()`；`scanSandboxResidualFiles` / `scanSandboxResidualByUid` 改为 `@deprecated` 委托；`_statDir` MAX_FILES 2000→500 |
+| `frontend/utils/handlers/sandboxResidualHandler.js` | `computeSize` / `computeBreakdown` 改用 `scanSandboxResidualAll` |
+| `frontend/utils/cacheManager.js` | 新增 `_breakdownCache` + `peekBreakdownCache` + `invalidateBreakdownCache`；`getCategoryBreakdown` 加 1min 缓存；`deductFromCache` 同步失效 breakdown；`HANDLER_TIMEOUT_MS` 8000→4000 |
+| `frontend/pages/profile/cache-cleanup-detail.vue` | `Promise.all([info, breakdown])` 改串行 await；timeout 8000→4000 |
+| `frontend/pages/profile/cache-cleanup.vue` | 总超时 10000→8000 |
+
+### 5.3 实施顺序
+
+1. **M0** —— `ioPath.js` 新增 `scanSandboxResidualAll`，标记旧 API `@deprecated`（保留 1 版本）；`_statDir` 500 上限
+2. **M1** —— `sandboxResidualHandler.js` 改用合并 API（核心修复）
+3. **M2** —— `cacheManager.js` 加 breakdown 缓存；`cache-cleanup-detail.vue` 串行化
+4. **M3** —— 超时收紧（cacheManager + cache-cleanup）；M4 手工回归
+
+---
+
+## 六、验证与回滚
+
+### 6.1 验证（DoD）
+
+| 项 | 验证方法 |
+|----|----------|
+| 列表页首次加载 < 2s（中端 Android）| 真机/模拟器手测 |
+| 列表页首次加载 < 4s（低端 Android）| 真机手测 |
+| 详情页首次加载 < 1.5s（中端 Android）| 真机手测 |
+| 列表页 + 详情页切换无残留旧值 | 列表 → 详情 → 清理 → 返回列表 → 数字对得上 |
+| breakdown 1min TTL 命中 | 多次进同一详情页, console.log 显示 "breakdown cache hit" |
+| breakdown 清理后立即刷新 | 详情页清理 → 返回列表 → 再次进详情页, 数字更新 |
+| 单 handler 4s 兜底生效 | 制造 500+ 文件场景, console 显示 `handler xxx timeout (4000ms)` |
+| 黑名单 key 不被误清 | 见 §6.2 回归清单 |
+
+### 6.2 手工回归清单（CLAUDE.md 自检 + 业务场景）
+
+- [ ] 列表页：6 个分类行正常显示（含 sandbox-residual 「分享图与头像缓存」）
+- [ ] 列表页：设备信息行（总空间/可用）正常
+- [ ] 列表页：3 个 chip（已用/缓存/配额）+ 大字 + 进度条无错位
+- [ ] 详情页简单型：preload 详情页 → 单按钮 → 清理 → 返回 → 列表页数字更新
+- [ ] 详情页分组型：sandbox-residual 详情页 → 我的/其他用户/全局 3 组 → 各自清理
+- [ ] 详情页分组型：未登录态打开 sandbox-residual → "其他用户"按钮置灰 tooltip "请先登录"
+- [ ] 详情页加载失败降级：模拟 computeBreakdown 抛错 → 仍能进清理动作
+- [ ] 黑名单 key：access_token / user / star_id / cid / deviceFp 全部不被清理
+- [ ] 跨账号：A 登录写 share 图 → 退出 → B 登录 → 列表页 sandbox-residual 显示「其他用户 (A uid)」
+- [ ] 跨账号：B 清理「其他用户 (A uid)」→ 返回列表页 → "分享图与头像缓存" 行下降对应字节
+- [ ] 缓存命中：列表页第一次加载完成 → 进详情页再返回 → 列表页 spinner 不出现（peekCache 命中）
+- [ ] breakdown 失效：详情页清理 → 返回列表页 → 再次进详情页 → 数字已更新（invalidateBreakdownCache 生效）
+- [ ] iOS 真机：列表页加载时间 < 1s（A15+）
+- [ ] Android 真机（中端）：列表页加载 < 3s
+- [ ] Android 真机（低端）：列表页加载 < 4s 不超时
+- [ ] 配额显示正确：`uni.getStorageInfoSync().limitSize` × 1024 = quotaTotalBytes
+- [ ] 未登录态：分组页所有按钮置灰
+- [ ] API 工程化：handler 不直接写 SQL / IO；service 不直接碰 storage key（黑名单由 manager 拦截）
+- [ ] 前端规范：所有 `plus.io` / `Native.js` 都在 `#ifdef APP-PLUS` 内
+- [ ] 前端规范：未触碰 `unpackage/dist/`
+
+### 6.3 风险与回滚
+
+| 风险 | 影响 | 缓解 |
+|------|------|------|
+| `scanSandboxResidualAll` 单 walk 出错 → 三个数据都错 | 详情页数据缺失 | 旧 `scanSandboxResidualFiles` / `scanSandboxResidualByUid` 仍 `@deprecated` 保留, 1 版本可回滚 |
+| breakdown 缓存 1min 内清理 | 详情页数字与实际不符 | `deductFromCache` 同步失效；cleanAll 后 `invalidateBreakdownCache()` |
+| `_statDir` MAX_FILES 500 截断 | 大文件目录数字偏低 | warn 日志；后续 UI 显示「约 N+ 项」（不在 P0）|
+| 单 handler 4s 兜底过紧 | 极慢设备仍可能撞超时 | 退回 8s 是 1 行常量改动 |
+| 详情页串行 await 总时长变长 | 列表页缓存 miss 时体验差 | 5min info 缓存优先命中, breakdown 1min 缓存; 99% 场景走缓存 |
+
+**回滚策略**：
+- M0 单独回滚：删除 `scanSandboxResidualAll`，把 `sandboxResidualHandler` 改回调旧 API
+- M2 单独回滚：删除 `_breakdownCache`，`getCategoryBreakdown` 改回无缓存
+- M3 单独回滚：超时常量改回 8s / 10s
+
+---
+
+## 七、性能预估
+
+| 场景 | 修复前 | 修复后 | 改善 |
+|------|--------|--------|------|
+| 列表页首次加载（低端 Android, 2000 文件沙盒）| 8-12s 超时 | 2-3s | 4x |
+| 列表页首次加载（中端 Android）| 3-5s | 1-2s | 2.5x |
+| 详情页首次加载（sandbox-residual, 缓存 miss）| 6-10s 超时 | 1-2s | 5x |
+| 详情页二次加载（1min 内）| 6-10s | < 100ms（缓存命中）| 60x |
+| 跨账号列表 + 详情切换 | 6-12s | < 200ms | 30x |
+
+---
+
+## 八、自检清单
+
+按 CLAUDE.md 要求：
+
+- [x] 文档开头「方案概述」含：要解决的问题 / 实现路径 / 关键决策 / 核心架构图
+- [x] MVP 先行：仅修复超时，不引入超出当前业务需要的抽象（合并 walk 是性能必要, 不是过度抽象）
+- [x] 文件清单与目录结构对齐：`ioPath.js` / `cacheManager.js` / `sandboxResidualHandler.js` / `cache-cleanup*.vue` 都是既有文件
+- [x] 跨章节引用一致性：§3 根因 → §4 修复方案 一一对应；§5 文件清单 → §4 实施顺序 一致
+- [x] 全局自审（CLAUDE.md「自审必须是全局审查」）：
+  - §3 根因列 5 个瓶颈 → §4 M0-M3 一一对应修复（M0 合并 walk / `_statDir` 上限；M1 handler 改 API；M2 缓存 + 串行；M3 超时收紧）
+  - 文档 §3.1 复现路径 / §3.2 瓶颈表 / §3.3 调用栈 都覆盖到 §4 的具体函数行号
+  - 既有 handler 的 `clearSandboxResidualGlobal` / `clearSandboxShareByUid` 不在修复范围（清理路径是单次 + 删除, 不卡）
+  - 既有 `cacheManager.cleanAll` 的 `invalidateCache` 流程不变, 但需要同步失效 breakdown 缓存（§4.3 已加）
+  - 既有 `cache-cleanup.vue` 的 5min 缓存 + `peekCache` 流程不变
+  - 不修改 `unpackage/dist/`
+- [x] CLAUDE.md 前端规范：
+  - 所有 `plus.io` / `plus.android` / Native.js 调用包 `#ifdef APP-PLUS`
+  - 缓存策略明确（5min info / 1min breakdown）
+  - 错误处理统一（每 handler try/catch + warn 日志 + 降级展示）
+- [x] API 工程化：handler 仍走 `cacheManager` 封装层, 不在 UI 直接调 IO
+
+---
+
+## 九、附录
+
+### A. 修改前后对比（关键代码 diff 摘要）
+
+**ioPath.js 新增**：
+
+```diff
++ /**
++  * 一次 walk 同时收集 doc 根残留的 (全量, uid分组, 全局) 三类信息。
++  * 替代旧 scanSandboxResidualFiles + scanSandboxResidualByUid 双扫描。
++  */
++ export async function scanSandboxResidualAll() { ... }
+
+- const MAX_FILES = 2000
++ const MAX_FILES = 500
+```
+
+**sandboxResidualHandler.js 改造**：
+
+```diff
+- async computeSize() {
+-   return await scanSandboxResidualFiles()
+- },
++ async computeSize() {
++   const r = await scanSandboxResidualAll()
++   return r.total
++ },
+
+  async computeBreakdown() {
+-   const uidGroups = await scanSandboxResidualByUid()
++   const { byUid, global } = await scanSandboxResidualAll()
+    const groups = []
+-   const myGroup = uidGroups.find((g) => g.uid === currentUid)
++   const myGroup = byUid.find((g) => g.uid === currentUid)
+    ...
+-   const total = await scanSandboxResidualFiles()   // 第 2 次 walk
+-   const otherBytes = uidGroups.reduce(...)
+-   const globalBytes = Math.max(0, total.sizeBytes - otherBytes)  // 减法得 global
++   // global 已由 scanSandboxResidualAll 一次 walk 得, 无第 2 次 walk
+  }
+```
+
+**cacheManager.js 新增 breakdown 缓存 + 超时收紧**：
+
+```diff
++ const _breakdownCache = new Map()
++ export function peekBreakdownCache(id) { ... }
++ export function invalidateBreakdownCache(id) { ... }
+
+  export async function getCategoryBreakdown(id) {
++   const cached = peekBreakdownCache(id)
++   if (cached) return cached
+    const h = getHandler(id)
+    ...
++   _breakdownCache.set(id, { data, ts: Date.now() })
+    return data
+  }
+
+- const HANDLER_TIMEOUT_MS = 8000
++ const HANDLER_TIMEOUT_MS = 4000
+
+  function deductFromCache(id, result = {}) {
+    ...
++   invalidateBreakdownCache(id)  // 清理后立即失效
+  }
+```
+
+**cache-cleanup-detail.vue 串行化 + 超时收紧**：
+
+```diff
+  const [info, br] = await Promise.all([
+    Promise.race([getCacheInfo(), 8000]),
+    Promise.race([getCategoryBreakdown(id.value), 8000]),
+  ])
++ // 改为串行避免 plus.io 桥并发拖慢
++ const info = await Promise.race([getCacheInfo(), 4000])
++ const br = await Promise.race([getCategoryBreakdown(id.value), 4000])
+```
+
+**cache-cleanup.vue 超时收紧**：
+
+```diff
+- setTimeout(() => rej(new Error("timeout")), 10000),
++ setTimeout(() => rej(new Error("timeout")), 8000),
+```
+
+### B. plus.io 桥串行行为佐证
+
+`ioPath.js` 已记录的已知行为：
+- `Runtime.exec + readLine → plus.android bridge 同步阻塞死锁（实测）` —— 来自 `_sumDirSizeByExec` 注释
+- `plus.android 对 *Long / static 字段代理不稳定 → 全部 parseFloat 兜底` —— 来自 `queryAndroidAppBytes` 注释
+- 推论：`Promise.all([plus.io.x, plus.io.y])` 不并发，因 plus.io 内部桥单线程串行
+
+### C. 相关 Issue / Commit 引用
+
+- `feat:添加内存缓存数据`（407ca10d）—— 新增 sandbox-residual
+- `fix:总内存显示bug修复`（7667aadf）—— 与本问题相关，cache-cleanup 列表页"总内存" chip 修复
+- `feat:增加实际使用量`（2f672920）—— appUsedBytes 聚合引入 _storageSandbox 并发
+- `feat:修改样式和去除多余的清理内存方式`（d9e3ff9e）—— 最近的样式/清理逻辑改动
+- 草稿 key 改造迁移项见 `2026-07-28-cache-cleanup-design.md` §11
\ No newline at end of file
diff --git a/frontend/App.vue b/frontend/App.vue
index 1e694bd..f3e6ef5 100644
--- a/frontend/App.vue
+++ b/frontend/App.vue
@@ -601,7 +601,7 @@
 	/* 全局字体设置 */
 	body {
 		font-family:
-			"JDLTYuanTiJian",
+			/* "JDLTYuanTiJian", */
 			-apple-system,
 			BlinkMacSystemFont,
 			"PingFang SC",
diff --git a/frontend/composables/useShare.js b/frontend/composables/useShare.js
index 06bbe5f..d21bd10 100644
--- a/frontend/composables/useShare.js
+++ b/frontend/composables/useShare.js
@@ -138,7 +138,6 @@ export function useShare(props) {
       }
       const fileName = staticPath.split('/').pop();
       const srcPath = '_www/' + staticPath.replace(/^\//, '');
-      const dstPath = `_doc/${fileName}`;
       // 先确保 _doc 存在
       plus.io.resolveLocalFileSystemURL(
         '_doc/',
@@ -176,14 +175,20 @@ export function useShare(props) {
 
   // 把文件复制到 plus.io.PRIVATE_DOC 沙盒目录(Android 10+ 分区存储要求)
   // 返回沙盒内的目标绝对路径,可供 plus.gallery.save 使用
+  //
+  // 按账号分目录（_doc/share/<uid>/），与 sandboxResidualHandler 的分组清理对齐：
+  //   - 已登录：uid 取自 getStoredUser()?.uid
+  //   - 未登录：落 'guest'（不归任何账号的"我的"组，归"全局"组的兄弟策略）
+  // 老的无 uid 路径（_doc/share_<ts>.png）已由 sandboxResidualHandler 的 fallback 兼容（如有存量）
   function copyToSandbox(tempPath) {
     return new Promise((resolve, reject) => {
       if (typeof plus === 'undefined' || !plus.io) {
         return reject(new Error('plus.io unavailable'));
       }
       const fileName = `share_${Date.now()}.png`;
+      const uid = getStoredUser()?.uid ?? 'guest';
       const sandboxRoot = plus.io.PRIVATE_DOC; // 应用沙盒 doc 目录
-      const targetPath = `${sandboxRoot}/${fileName}`;
+      // 目标路径：_doc/share/<uid>/，通过下方两层 getDirectory 逐级 ensure 创建
 
       // 8s 超时兜底(避免 plus.io 内部 hang 永远不回调)
       const timeoutId = setTimeout(() => {
@@ -199,18 +204,41 @@ export function useShare(props) {
           plus.io.resolveLocalFileSystemURL(
             sandboxRoot,
             guard((sandboxDir) => {
-              srcEntry.copyTo(
-                sandboxDir,
-                fileName,
-                guard((destEntry) => {
-                  clearTimeout(timeoutId);
-                  console.log('[useShare] copyToSandbox done:', destEntry.fullPath);
-                  resolve(destEntry.fullPath);
+              // 逐级确保 share/<uid>/ 存在
+              sandboxDir.getDirectory(
+                'share',
+                { create: true, exclusive: false },
+                guard((shareDir) => {
+                  shareDir.getDirectory(
+                    String(uid),
+                    { create: true, exclusive: false },
+                    guard((uidDir) => {
+                      srcEntry.copyTo(
+                        uidDir,
+                        fileName,
+                        guard((destEntry) => {
+                          clearTimeout(timeoutId);
+                          console.log('[useShare] copyToSandbox done:', destEntry.fullPath);
+                          resolve(destEntry.fullPath);
+                        }),
+                        guard((copyErr) => {
+                          clearTimeout(timeoutId);
+                          console.warn('[useShare] copyToSandbox fail:', copyErr);
+                          reject(new Error(copyErr.message || 'copyTo failed'));
+                        })
+                      );
+                    }),
+                    guard((uidDirErr) => {
+                      clearTimeout(timeoutId);
+                      console.warn('[useShare] create uid dir fail:', uidDirErr);
+                      reject(new Error(uidDirErr.message || 'uid dir create failed'));
+                    })
+                  );
                 }),
-                guard((copyErr) => {
+                guard((shareDirErr) => {
                   clearTimeout(timeoutId);
-                  console.warn('[useShare] copyToSandbox fail:', copyErr);
-                  reject(new Error(copyErr.message || 'copyTo failed'));
+                  console.warn('[useShare] create share dir fail:', shareDirErr);
+                  reject(new Error(shareDirErr.message || 'share dir create failed'));
                 })
               );
             }),
diff --git a/frontend/pages/profile/cache-cleanup-detail.vue b/frontend/pages/profile/cache-cleanup-detail.vue
index b111cb7..f12b96d 100644
--- a/frontend/pages/profile/cache-cleanup-detail.vue
+++ b/frontend/pages/profile/cache-cleanup-detail.vue
@@ -111,22 +111,31 @@ async function load() {
     return
   }
   loading.value = true
+  // ★ 2026-07-31（M2）改 Promise.all 为串行 await：plus.io 桥是单线程串行的，
+  //   并发拖慢而非加速。详情页依次走 getCacheInfo → getCategoryBreakdown。
+  //   - getCacheInfo 5min TTL 通常命中（用户从列表页进来刚算过），< 50ms
+  //   - getCategoryBreakdown 1min TTL（M2 新增），二次进入 < 50ms
+  //   - 首次进入：handler 4s + breakdown walk 4s = 最坏 8s
+  //   - 撞超时各自走降级路径（合成分组 / 保留 category）
+  // 收紧超时 8s → 4s（M3）：配合 HANDLER_TIMEOUT_MS 4s 一致
+  let info = null
+  let br = null
   try {
-    const [info, br] = await Promise.all([
-      Promise.race([
-        getCacheInfo(),
-        new Promise((_, rej) => setTimeout(() => rej(new Error('timeout')), 5000)),
-      ]),
-      Promise.race([
-        getCategoryBreakdown(id.value),
-        new Promise((_, rej) => setTimeout(() => rej(new Error('timeout')), 5000)),
-      ]),
+    info = await Promise.race([
+      getCacheInfo(),
+      new Promise((_, rej) => setTimeout(() => rej(new Error('timeout')), 4000)),
+    ])
+    br = await Promise.race([
+      getCategoryBreakdown(id.value),
+      new Promise((_, rej) => setTimeout(() => rej(new Error('timeout')), 4000)),
     ])
     const meta = (info.categories || []).find((c) => c.id === id.value)
     if (meta) {
       category.value = {
         label: meta.label,
         description: meta.description || '',
+        // 允许 sizeBytes === -1（列表页加载失败）继续进详情：
+        //   详情页有自己的 getCategoryBreakdown / cleanGroup，能独立重算与清理
         sizeBytes: meta.sizeBytes,
         keyCount: meta.keyCount,
         warning: !!meta.warning,
@@ -135,7 +144,32 @@ async function load() {
     breakdown.value = br  // null = simple; array = grouped
   } catch (e) {
     console.warn('[cache-cleanup-detail] load failed:', e.message)
-    uni.showToast({ title: '加载失败，请下拉重试', icon: 'none' })
+    // 加载失败 fallback：不让用户卡在"什么都看不到 / 什么都点不到"的死锁里
+    //   - 简单型：保留 category 但标记 sizeBytes=-1
+    //   - 分组型：提供合成的"全局"组，让用户能直接点清理
+    //     清理动作（cleanGroup('__global__')）不依赖本次扫描结果，
+    //     它会自己走 handler 的 clean 逻辑去删文件
+    if (info && id.value && (info.categories || []).find((c) => c.id === id.value)) {
+      // 至少有 info；category 已经被赋值，跳过合成
+    } else {
+      category.value = { label: '', description: '', sizeBytes: -1, keyCount: 0, warning: false }
+    }
+    // 分组型：breakdown 是数组时合成一个"全部清理"组；breakdown 是 null（简单型）不处理
+    if (breakdown.value === null) {
+      // 简单型不需要合成
+    } else {
+      breakdown.value = [{
+        uid: '__global__',
+        displayUid: '全部文件（加载失败，可尝试清理）',
+        isCurrent: false,
+        global: true,
+        sizeBytes: -1,
+        keyCount: 0,
+        canClean: true,
+        disabledReason: null,
+      }]
+    }
+    uni.showToast({ title: '加载失败，但可尝试清理', icon: 'none' })
   } finally {
     loading.value = false
   }
@@ -147,7 +181,10 @@ onPullDownRefresh(async () => {
 })
 
 function confirmSimple() {
-  if (category.value.sizeBytes <= 0) {
+  // 允许 sizeBytes === -1（列表页加载失败）继续确认清理：
+  //   用户已从列表页强行进到详情页（goDetail 改了条件），意图明确是来清理的，
+  //   cleanCategory 内部会重算 freedBytes，结果取决于实际 IO
+  if (category.value.sizeBytes === 0) {
     uni.showToast({ title: '该分类暂无缓存', icon: 'none' })
     return
   }
@@ -176,8 +213,8 @@ function confirmGroup(g) {
     // 老版本数据：强警告
     content = '将清空老版本数据，是否继续？'
   } else if (g.global) {
-    // 全局标记：理论上 canClean=false 不会到这里，兜底
-    return
+    // ★ task #38：全局组也要弹确认（之前 return 静默丢弃是 bug）
+    content = '将清空分享图、头像缓存、canvas 合成图、preload 等跨账号共用数据，是否继续？'
   } else {
     // 其他用户：强警告
     content = `将清空 ${g.displayUid} 的数据，对方下次登录不会看到。是否继续？`
@@ -225,7 +262,10 @@ async function doCleanSimple() {
 }
 
 async function doCleanGroup(g) {
-  if (!id.value || !g) return
+  if (!id.value || !g) {
+    console.warn('[cache-cleanup-detail] doCleanGroup skipped: id=' + id.value + ' g=' + !!g)
+    return
+  }
   // 映射 breakdown.uid → cleanCategoryGroup opts.uid
   // self → 'self'
   // __legacy__ → '__legacy__'
@@ -233,19 +273,17 @@ async function doCleanGroup(g) {
   let uidParam
   if (g.isCurrent) {
     uidParam = 'self'
-  } else if (g.uid === '__global__') {
-    // 全局数据不可清理（兜底，正常情况下 canClean=false 不会到这里）
-    uni.showToast({ title: '全局数据不可清理', icon: 'none' })
-    return
   } else {
     uidParam = g.uid
   }
+  console.log(`[cache-cleanup-detail] doCleanGroup START: id=${id.value} uid=${uidParam} g.uid=${g.uid} g.global=${g.global}`)
   uni.showLoading({ title: '清理中...' })
   try {
     const r = await cleanCategoryGroup(id.value, { uid: uidParam })
     uni.hideLoading()
     const freed = r?.freedBytes || 0
     const cnt = r?.keyCount || 0
+    console.log(`[cache-cleanup-detail] doCleanGroup DONE: freed=${freed} cnt=${cnt}`)
     uni.showToast({ title: `已清理 ${formatSize(freed)} (${cnt} 项)`, icon: 'none' })
     setTimeout(() => uni.navigateBack(), 600)
   } catch (e) {
diff --git a/frontend/pages/profile/cache-cleanup.vue b/frontend/pages/profile/cache-cleanup.vue
index 51148e6..71f3cc6 100644
--- a/frontend/pages/profile/cache-cleanup.vue
+++ b/frontend/pages/profile/cache-cleanup.vue
@@ -26,10 +26,11 @@
           class="seg-topfans"
           :style="{ width: topfansPct + '%' }"
         ></view>
-        <!-- 橙段：其他 app 使用空间（从蓝段右边界开始，紧接蓝段） -->
+        <!-- 橙段：其他 app 使用空间（从蓝段"视觉右边界"开始：用视觉宽度而非真实百分比，
+             避免 0.04%–2% 区间被橙段覆盖导致蓝段消失） -->
         <view
           class="seg-other"
-          :style="{ left: topfansPct + '%', width: otherPct + '%' }"
+          :style="{ left: topfansVisualPct + '%', width: otherPct + '%' }"
         ></view>
       </view>
 
@@ -122,7 +123,7 @@
 <script setup>
 import { ref, computed } from "vue";
 import { onPullDownRefresh, onShow } from "@dcloudio/uni-app";
-import { getCacheInfo, formatSize, peekCache } from "@/utils/cacheManager";
+import { getCacheInfo, formatSize } from "@/utils/cacheManager";
 
 // info 初值：load() 开头会重置到这里，避免从详情页返回时显示旧数据
 const INITIAL_INFO = Object.freeze({
@@ -145,11 +146,17 @@ const loading = ref(false);
 // ── 进度条三段宽度（基于 deviceTotalBytes = 100%，设备级分布）──
 // 三段相加 ≤ 100%，不出现负数；任一字段缺失时安全降级为 0
 // 语义：蓝 = Topfans 已用；橙 = 系统+其他 app+已占用的非空闲空间；绿 = 设备剩余可用
+//
+// Topfans 通常只占设备总空间的 < 0.1%（128GB 设备 50MB ≈ 0.04%），CSS 强制 min-width: 2%
+// 保持视觉存在感。橙色段从蓝段"视觉右边界"（= max(topfansPct, 2%)）开始，否则 0.04%–2%
+// 区间会被 orange 覆盖（div 绝对定位按 DOM 顺序绘制，无 z-index），出现蓝段"消失"现象。
+const MIN_TOPFANS_PCT = 2
 const topfansPct = computed(() => {
   const total = info.value.deviceTotalBytes;
   if (!total) return 0;
   return Math.min(100, Math.max(0, (info.value.appUsedBytes / total) * 100));
 });
+const topfansVisualPct = computed(() => Math.max(topfansPct.value, MIN_TOPFANS_PCT))
 const otherPct = computed(() => {
   const total = info.value.deviceTotalBytes;
   if (!total) return 0;
@@ -159,12 +166,14 @@ const otherPct = computed(() => {
     0,
     info.value.deviceTotalBytes - info.value.appUsedBytes - info.value.deviceFreeBytes
   );
-  return Math.min(100 - topfansPct.value, Math.max(0, (otherBytes / total) * 100));
+  // 上限用 max(topfansPct, MIN_TOPFANS_PCT)而不是 topfansPct：与蓝段视觉占位对齐，
+  // 避免蓝段（min-width 强制 2%）与橙段起点（topfansPct%）之间出现"绿段提前出现"的空隙
+  return Math.min(100 - topfansVisualPct.value, Math.max(0, (otherBytes / total) * 100));
 });
 const availablePct = computed(() => {
   const total = info.value.deviceTotalBytes;
   if (!total) return 0;
-  return Math.max(0, 100 - topfansPct.value - otherPct.value);
+  return Math.max(0, 100 - topfansVisualPct.value - otherPct.value);
 });
 
 // ── 平台判断（仅 APP-PLUS 编译时计算）──
@@ -180,16 +189,10 @@ const isIos = (() => {
 
 async function load(force = false) {
   loadFailed.value = false;
-
+  // ★ task #40：无缓存，每次都重算
   // 缓存命中且不强制刷新 → 同步用缓存，无 spinner、无 await
   // 避免每次进页面都看到 loading 动画（即便缓存有效也要走 500ms spinner 体验差）
-  if (!force) {
-    const cached = peekCache();
-    if (cached) {
-      info.value = cached;
-      return;
-    }
-  }
+  // （peekCache 已删除，强制每次重算）
 
   // 缓存未命中或过期或强制刷新 → 走 spinner 流程
   info.value = { ...INITIAL_INFO };
@@ -199,9 +202,7 @@ async function load(force = false) {
     const result = await Promise.race([
       getCacheInfo(force),
       new Promise((_, rej) =>
-        // getCacheInfo 正常 < 3s（4 沙盒根 + Native.js + handlers 并行）
-        // 单根 2s 超时兜底后最长 ~2.1s，5s 留 2x 缓冲
-        setTimeout(() => rej(new Error("timeout")), 5000),
+        setTimeout(() => rej(new Error("timeout")), 8000),
       ),
     ]);
     info.value = result;
@@ -223,7 +224,11 @@ async function load(force = false) {
 
 function goDetail(id) {
   const cat = info.value.categories.find((c) => c.id === id);
-  if (!cat || cat.sizeBytes <= 0) {
+  if (!cat) return;
+  // 允许 sizeBytes === -1（加载失败）时仍可进入详情页：
+  //   详情页有自己的 computeBreakdown / cleanGroup 逻辑，会重新扫描并展示真实数据。
+  //   不让用户卡在"加载失败→进不去→无法清理"的死循环里。
+  if (cat.sizeBytes === 0) {
     uni.showToast({ title: "该分类暂无缓存", icon: "none" });
     return;
   }
@@ -373,7 +378,7 @@ onPullDownRefresh(async () => {
   background: #fafbfc;
   border: 1rpx solid #f0f0f0;
   border-radius: 12rpx;
-  font-size: 22rpx;
+  font-size: 18rpx;
   color: #595959;
   display: inline-flex;
   align-items: center;
diff --git a/frontend/utils/avatarCache.js b/frontend/utils/avatarCache.js
index 9e5c686..483ae30 100644
--- a/frontend/utils/avatarCache.js
+++ b/frontend/utils/avatarCache.js
@@ -1,18 +1,98 @@
 // 头像文件缓存管理工具
+//
+// ★ 2026-07-31 补充 B：加 LRU 上限 50 个文件
+//   原实现每看一次头像 → uni.saveFile → _doc/uniapp_save/ 累积, 无 TTL 无上限,
+//   生产设备几个月后 uniapp_save/ 累积几百个文件, sandbox-residual 扫描单类就要 1-3s,
+//   是「存储空间」页面超时的主因之一。
+//   现在：每次写入前 evictOldestIfNeeded() 把 LRU 索引压回 ≤ 50 个,
+//   老的 storage 记录 + savedFilePath 同步删除。
+//
+// LRU 索引用一个独立 storage key（__avatar_cache_lru_index__）维护有序数组：
+//   [{ hash: number, cachedAt: number }, ...]  按 cachedAt 升序
+// 读路径 (getCachedAvatarPath) 不更新索引, 写路径 (downloadAndCacheAvatar) 才插入 + 驱逐。
+//   读多写少场景（头像 UI）开销可忽略。
+
+const AVATAR_CACHE_CAP = 50
+const AVATAR_LRU_INDEX_KEY = '__avatar_cache_lru_index__'
+
+/**
+ * 从 avatarUrl 生成 hash 值（与 getCacheKey 共用，避免改 storage key 格式）
+ */
+function getCacheHash(avatarUrl) {
+	let hash = 0;
+	for (let i = 0; i < avatarUrl.length; i++) {
+		hash = ((hash << 5) - hash) + avatarUrl.charCodeAt(i);
+		hash = hash & hash;
+	}
+	return Math.abs(hash);
+}
 
 /**
  * 生成缓存key
  * @param {string} avatarUrl - OSS头像路径
- * @returns {string} 缓存key
+ * @returns {string}
  */
 function getCacheKey(avatarUrl) {
-	// 对avatarUrl进行简单hash，作为缓存key的一部分
-	let hash = 0;
-	for (let i = 0; i < avatarUrl.length; i++) {
-		hash = ((hash << 5) - hash) + avatarUrl.charCodeAt(i);
-		hash = hash & hash; // Convert to 32bit integer
+	return `avatar_file_${getCacheHash(avatarUrl)}`;
+}
+
+/**
+ * 读 LRU 索引（容错：解析失败返回空数组）
+ */
+function getLruIndex() {
+	try {
+		const raw = uni.getStorageSync(AVATAR_LRU_INDEX_KEY);
+		if (raw) {
+			const arr = JSON.parse(raw);
+			if (Array.isArray(arr)) return arr;
+		}
+	} catch (e) { /* swallow */ }
+	return [];
+}
+
+/**
+ * 写 LRU 索引（容错：写入失败不影响主流程）
+ */
+function setLruIndex(arr) {
+	try {
+		uni.setStorageSync(AVATAR_LRU_INDEX_KEY, JSON.stringify(arr));
+	} catch (e) { /* swallow */ }
+}
+
+/**
+ * 按 hash 删 LRU 索引项 + 删对应 storage key + savedFilePath
+ * @param {number} hash
+ */
+function evictByHash(hash) {
+	try {
+		const storageKey = `avatar_file_${hash}`;
+		const cached = uni.getStorageSync(storageKey);
+		if (cached) {
+			try {
+				const data = JSON.parse(cached);
+				if (data?.localPath) {
+					uni.removeSavedFile({ filePath: data.localPath, fail: () => {} });
+				}
+			} catch (e) { /* skip */ }
+			uni.removeStorageSync(storageKey);
+		}
+	} catch (e) { /* swallow */ }
+}
+
+/**
+ * ★ 2026-07-31 LRU 驱逐：每次写入前调, 保持索引 ≤ AVATAR_CACHE_CAP
+ *   超出部分按 cachedAt 升序逐个删（最老的先删）
+ *   - 删 storage key (avatar_file_<hash>)
+ *   - 删 savedFilePath 文件
+ *   - 删 LRU 索引项
+ */
+function evictOldestIfNeeded() {
+	const index = getLruIndex();
+	while (index.length >= AVATAR_CACHE_CAP) {
+		const oldest = index.shift();
+		if (oldest?.hash != null) evictByHash(oldest.hash);
 	}
-	return `avatar_file_${Math.abs(hash)}`;
+	setLruIndex(index);
 }
 
 /**
@@ -22,14 +102,14 @@ function getCacheKey(avatarUrl) {
  */
 export async function getCachedAvatarPath(avatarUrl) {
 	if (!avatarUrl) return null;
-	
+
 	try {
 		const cacheKey = getCacheKey(avatarUrl);
 		const cached = uni.getStorageSync(cacheKey);
-		
+
 		if (cached) {
 			const cacheData = JSON.parse(cached);
-			
+
 			// 检查缓存的avatar_url是否匹配（防止hash碰撞）
 			if (cacheData.avatarUrl === avatarUrl && cacheData.localPath) {
 				// 验证文件是否还存在
@@ -64,10 +144,10 @@ export async function getCachedAvatarPath(avatarUrl) {
  */
 export async function downloadAndCacheAvatar(avatarUrl, realUrl) {
 	if (!avatarUrl || !realUrl) return null;
-	
+
 	try {
 		console.log('开始下载头像文件...');
-		
+
 		// 1. 下载文件到临时目录
 		const downloadResult = await new Promise((resolve, reject) => {
 			uni.downloadFile({
@@ -84,7 +164,7 @@ export async function downloadAndCacheAvatar(avatarUrl, realUrl) {
 				}
 			});
 		});
-		
+
 		// 2. 将临时文件保存为永久文件
 		const savedPath = await new Promise((resolve, reject) => {
 			uni.saveFile({
@@ -97,7 +177,7 @@ export async function downloadAndCacheAvatar(avatarUrl, realUrl) {
 				}
 			});
 		});
-		
+
 		// 3. 保存文件路径到缓存
 		const cacheKey = getCacheKey(avatarUrl);
 		const cacheData = {
@@ -106,10 +186,27 @@ export async function downloadAndCacheAvatar(avatarUrl, realUrl) {
 			cachedAt: Date.now()
 		};
 		uni.setStorageSync(cacheKey, JSON.stringify(cacheData));
-		
+
+		// ★ 2026-07-31 补充 B：LRU 索引 + 上限驱逐
+		// 1) 先把 LRU 索引压回 ≤ AVATAR_CACHE_CAP (50)
+		//    超出部分按 cachedAt 升序驱逐（删 storage key + savedFilePath + 索引项）
+		// 2) 再插入新条目到索引尾
+		//    容错：驱逐失败不阻塞主流程（最多导致 uniapp_save/ 仍超 50, 不会更糟）
+		try {
+			evictOldestIfNeeded()
+			const index = getLruIndex()
+			const hash = getCacheHash(avatarUrl)
+			// 同 hash 已存在则先移除（避免重复）
+			const filtered = index.filter((e) => e?.hash !== hash)
+			filtered.push({ hash, cachedAt: cacheData.cachedAt })
+			setLruIndex(filtered)
+		} catch (e) {
+			console.warn('[avatarCache] LRU index update failed:', e?.message)
+		}
+
 		console.log('头像文件已缓存到:', savedPath);
 		return savedPath;
-		
+
 	} catch (error) {
 		console.error('下载并缓存头像失败:', error);
 		return null;
@@ -122,14 +219,14 @@ export async function downloadAndCacheAvatar(avatarUrl, realUrl) {
  */
 export function clearAvatarCache(avatarUrl) {
 	if (!avatarUrl) return;
-	
+
 	try {
 		const cacheKey = getCacheKey(avatarUrl);
 		const cached = uni.getStorageSync(cacheKey);
-		
+
 		if (cached) {
 			const cacheData = JSON.parse(cached);
-			
+
 			// 删除本地文件
 			if (cacheData.localPath) {
 				uni.removeSavedFile({
@@ -142,9 +239,15 @@ export function clearAvatarCache(avatarUrl) {
 					}
 				});
 			}
-			
+
 			// 删除缓存记录
 			uni.removeStorageSync(cacheKey);
+			// ★ 2026-07-31：同步清理 LRU 索引
+			try {
+				const hash = getCacheHash(avatarUrl)
+				const index = getLruIndex()
+				setLruIndex(index.filter((e) => e?.hash !== hash))
+			} catch (e) { /* swallow */ }
 			console.log('已清除头像缓存记录');
 		}
 	} catch (error) {
@@ -159,7 +262,7 @@ export function clearAllAvatarCache() {
 	try {
 		const storageInfo = uni.getStorageInfoSync();
 		const keys = storageInfo.keys || [];
-		
+
 		// 找到所有头像缓存的key并删除
 		keys.forEach(key => {
 			if (key.startsWith('avatar_file_')) {
@@ -167,7 +270,7 @@ export function clearAllAvatarCache() {
 					const cached = uni.getStorageSync(key);
 					if (cached) {
 						const cacheData = JSON.parse(cached);
-						
+
 						// 删除本地文件
 						if (cacheData.localPath) {
 							uni.removeSavedFile({
@@ -181,7 +284,7 @@ export function clearAllAvatarCache() {
 							});
 						}
 					}
-					
+
 					// 删除缓存记录
 					uni.removeStorageSync(key);
 				} catch (e) {
@@ -189,9 +292,12 @@ export function clearAllAvatarCache() {
 				}
 			}
 		});
-		
+
+		// ★ 2026-07-31：清空 LRU 索引
+		setLruIndex([])
+
 		console.log('已清除所有头像缓存');
 	} catch (error) {
 		console.error('清除所有头像缓存失败:', error);
 	}
-}
+}
\ No newline at end of file
diff --git a/frontend/utils/cacheManager.js b/frontend/utils/cacheManager.js
index 0ce84c7..7564a8d 100644
--- a/frontend/utils/cacheManager.js
+++ b/frontend/utils/cacheManager.js
@@ -1,9 +1,15 @@
 // frontend/utils/cacheManager.js
-// 缓存清理统一封装层
+// 缓存清理统一封装层（无缓存版）
 // 详见 docs/superpowers/specs/2026-07-28-cache-cleanup-design.md
+//
+// ★ task #40：去掉全部缓存机制
+//   - 每次 load() / 进详情页都强制重算（不读 cache）
+//   - 清理后不再 deductFromCache，直接重算
+//   - 保留黑名单、大小格式化、handler 注册、清理函数
 
 import { invalidateAll } from './preloadApi/core'
 import sandboxTmpHandler from './handlers/sandboxTmpHandler'
+import sandboxResidualHandler from './handlers/sandboxResidualHandler'
 import progressHandler from './handlers/progressHandler'
 import othersHandler from './handlers/othersHandler'
 import preloadHandler from './handlers/preloadHandler'
@@ -18,6 +24,8 @@ const PROTECTED_EXACT = new Set([
   'deviceFp', 'pending_scan_url', 'gallery_owner_id',
   'needs_welcome', 'has_seen_welcome', 'is_new_user',
   'liked_assets_exhibition',
+  'app_last_hide_time',
+  'mailbox_collapsed',
 ])
 // 前缀匹配
 const PROTECTED_PREFIX = [
@@ -26,9 +34,6 @@ const PROTECTED_PREFIX = [
   'temp_register_',
 ]
 
-/**
- * 判断 key 是否在黑名单中
- */
 export function isProtectedKey(key) {
   if (typeof key !== 'string') return false
   if (PROTECTED_EXACT.has(key)) return true
@@ -38,6 +43,7 @@ export function isProtectedKey(key) {
 // ── 大小格式化（§6.2）──
 export function formatSize(bytes) {
   if (typeof bytes !== 'number' || bytes < 0) return '—'
+  if (bytes === 0) return '—'
   if (bytes < 1024) return '< 1 KB'
   const kb = bytes / 1024
   if (kb < 1024) return `${kb.toFixed(1)} KB`
@@ -50,72 +56,6 @@ export function formatSize(bytes) {
 const handlers = new Map()              // handlerId → handler
 const cleanInFlight = new Map()         // `${id}` 或 `${id}#${uid}` → Promise
 
-// ── 内存缓存：避免每次进 cache-cleanup 页都走 4 沙盒根遍历（最坏 ~2s） ──
-// 5min TTL：
-//   - 默认命中返回缓存（瞬时显示）
-//   - 清理动作完成后调 deductFromCache() 局部扣减（不清空），下次返回列表仍命中
-//   - invalidateCache() 仅用于特殊场景（如调试 / 用户主动重置）
-const CACHE_TTL_MS = 5 * 60 * 1000
-let _cachedInfo = null
-let _cachedAt = 0
-
-/** 清理缓存：清理动作完成后必须调用，下次 getCacheInfo 必重算 */
-export function invalidateCache() {
-  _cachedInfo = null
-  _cachedAt = 0
-}
-
-/**
- * 清理后局部扣减缓存（不重算）：
- *   - 对应 category 的 sizeBytes / keyCount 扣减
- *   - totalBytes / appUsedBytes 同步扣减
- *   - usagePercent / deviceUsagePercent 重新计算
- * 不动 othersBytes（黑名单 + sandboxBytes 不直接减少；5min 内下次进页面会被 force=下拉刷新校正）
- *
- * 关键：必须创建新对象赋给 _cachedInfo，而不是 in-place 修改属性
- *   否则 cache-cleanup.vue 里 `info.value = cached` 检测到引用未变（Object.is 相等），
- *   不会触发 Vue 响应式更新 → 对应 category 的 sizeBytes 显示仍是旧值
- */
-function deductFromCache(id, freedBytes, freedKeyCount) {
-  if (!_cachedInfo || !Array.isArray(_cachedInfo.categories)) return
-
-  const newCategories = _cachedInfo.categories.map((c) =>
-    c.id === id
-      ? {
-          ...c,
-          sizeBytes: Math.max(0, (c.sizeBytes || 0) - freedBytes),
-          keyCount: Math.max(0, (c.keyCount || 0) - (freedKeyCount || 0)),
-        }
-      : c
-  )
-  const newAppUsedBytes = Math.max(0, (_cachedInfo.appUsedBytes || 0) - freedBytes)
-
-  _cachedInfo = {
-    ..._cachedInfo,
-    categories: newCategories,
-    totalBytes: Math.max(0, (_cachedInfo.totalBytes || 0) - freedBytes),
-    appUsedBytes: newAppUsedBytes,
-    usagePercent: _cachedInfo.quotaTotalBytes > 0
-      ? (newAppUsedBytes / _cachedInfo.quotaTotalBytes) * 100
-      : 0,
-    deviceUsagePercent: _cachedInfo.deviceTotalBytes > 0
-      ? (newAppUsedBytes / _cachedInfo.deviceTotalBytes) * 100
-      : 0,
-  }
-  _cachedAt = Date.now()
-}
-
-/**
- * 同步检查缓存：命中且未过期 → 直接返回缓存对象（不走 spinner）
- * 否则返回 null（需要走 getCacheInfo 异步计算）
- */
-export function peekCache() {
-  if (_cachedInfo && Date.now() - _cachedAt < CACHE_TTL_MS) {
-    return _cachedInfo
-  }
-  return null
-}
-
 // ── 注册 API ──
 export function registerCategory(handler) {
   if (!handler?.id) throw new Error('[cacheManager] handler.id is required')
@@ -128,40 +68,55 @@ function getHandler(id) {
   return h
 }
 
-// ── 公共 API ──
+// ── 公共 API（无缓存，每次都重算） ──
 
 /**
- * 列表页读取（汇总 + 存储配额 + 其他 section 数据）
- * @param {boolean} force 强制重算（跳过 30s 缓存）；下拉刷新/清理后用
+ * 列表页读取 — 每次都重算
+ * @param {boolean} force 参数保留但不再使用（无缓存可绕过）
  */
 export async function getCacheInfo(force = false) {
-  // 缓存命中：30s 内且不强制刷新 → 同步返回，避免重复走沙盒遍历
-  const now = Date.now()
-  if (!force && _cachedInfo && now - _cachedAt < CACHE_TTL_MS) {
-    return _cachedInfo
+  const HANDLER_TIMEOUT_MS = 4000
+  const categories = []
+  for (const h of handlers.values()) {
+    try {
+      const info = await Promise.race([
+        h.computeSize(),
+        new Promise((_, reject) =>
+          setTimeout(() => reject(new Error(`handler ${h.id} timeout (${HANDLER_TIMEOUT_MS}ms)`)), HANDLER_TIMEOUT_MS)
+        ),
+      ])
+      categories.push({
+        id: h.id,
+        label: h.label,
+        description: h.description || '',
+        sizeBytes: info?.sizeBytes ?? 0,
+        sizeBytesFromStorage: info?.sizeBytesFromStorage,
+        sizeBytesFromSandbox: info?.sizeBytesFromSandbox,
+        keyCount: info?.keyCount ?? 0,
+        warning: !!h.warning,
+        stale: false,
+      })
+    } catch (e) {
+      console.warn(`[cacheManager] computeSize failed: ${h.id}`, e.message)
+      categories.push({
+        id: h.id,
+        label: h.label,
+        description: h.description || '',
+        sizeBytes: -1,
+        keyCount: 0,
+        warning: !!h.warning,
+        error: e.message,
+      })
+    }
   }
-  // 缓存未命中或过期或强制刷新 → 重新计算
-  // [并行 1] 所有 handler 的 computeSize
-  const categories = await Promise.all(
-    Array.from(handlers.values()).map(async (h) => {
-      try {
-        const info = await h.computeSize()
-        return { id: h.id, label: h.label, description: h.description || '', sizeBytes: info?.sizeBytes ?? 0, keyCount: info?.keyCount ?? 0, warning: !!h.warning }
-      } catch (e) {
-        console.warn(`[cacheManager] computeSize failed: ${h.id}`, e.message)
-        return { id: h.id, label: h.label, description: h.description || '', sizeBytes: -1, keyCount: 0, warning: !!h.warning, error: e.message }
-      }
-    })
-  )
 
-  // [串行] 配额 + 黑名单 + 沙盒
   let currentSizeKB = 0, limitSizeKB = 0, sandboxBytes = 0, blacklistBytes = 0
+  let deviceTotalBytes = 0, deviceFreeBytes = 0
   try {
     const info = uni.getStorageInfoSync()
     currentSizeKB = info.currentSize || 0
     limitSizeKB = info.limitSize || 0
     const allKeys = info.keys || []
-    // 黑名单 key 大小
     for (const k of allKeys) {
       if (isProtectedKey(k)) {
         try {
@@ -178,10 +133,8 @@ export async function getCacheInfo(force = false) {
   } catch (e) {
     console.warn('[cacheManager] getSandboxTotalSize failed:', e.message)
   }
-  let deviceTotalBytes = 0, deviceFreeBytes = 0
   try {
     const dev = await getDeviceStorageInfo()
-    // ioPath.getDeviceStorageInfo 返回的 totalBytes/freeBytes 已是字节（Android: blockSize*blocks, iOS: NSFileSystemSize），不要再 * 1024
     deviceTotalBytes = dev.totalBytes || 0
     deviceFreeBytes = dev.freeBytes || 0
   } catch (e) {
@@ -189,31 +142,38 @@ export async function getCacheInfo(force = false) {
   }
 
   const totalBytes = categories.reduce((sum, c) => sum + (c.sizeBytes > 0 ? c.sizeBytes : 0), 0)
-  const appUsedBytes = currentSizeKB * 1024 + sandboxBytes
+  // appUsedBytes = 其他（uni 内部 + 黑名单外 storage keys）+ 全部缓存（业务 subdir 文件）
+  // 分解：
+  //   - currentSizeKB * 1024：uni.getStorageInfoSync() 返回的 storage 字节（uni 内部 + 业务 key）
+  //   - sandboxBytes：getSandboxTotalSize() 返回的 4 根顶层文件字节
+  //   - sandboxOnlyCategories：sandbox-tmp（业务 tmp/）+ sandbox-residual（share/avatar/canvas）
+  //     它们的子目录文件不在 currentSizeKB 也不在 sandboxBytes（_statDir 不递归），
+  //     必须单独加，否则"已用空间"会少 1-几十 MB
+  // 注：draft / progress / preload / guide / others 是 storage key，已被 currentSizeKB 包含，不重复加
+  const SANDBOX_ONLY_CATEGORY_IDS = new Set(['sandbox-tmp', 'sandbox-residual'])
+  const sandboxOnlyBytes = categories
+    .filter((c) => SANDBOX_ONLY_CATEGORY_IDS.has(c.id) && c.sizeBytes > 0)
+    .reduce((sum, c) => sum + c.sizeBytes, 0)
+  const appUsedBytes = currentSizeKB * 1024 + sandboxBytes + sandboxOnlyBytes
   const quotaTotalBytes = limitSizeKB * 1024
   const raw = quotaTotalBytes - appUsedBytes
   const quotaAvailableBytes = Math.max(0, raw)
   const quotaExceeded = raw < 0
   const usagePercent = quotaTotalBytes > 0 ? (appUsedBytes / quotaTotalBytes) * 100 : 0
-  // 设备级数据已在 try 块里取好（ioPath 返回的就是字节，不再 * 1024）
   const deviceUsagePercent = deviceTotalBytes > 0
     ? (appUsedBytes / deviceTotalBytes) * 100
     : 0
 
-  const result = {
+  return {
     totalBytes, appUsedBytes, quotaTotalBytes, quotaAvailableBytes, quotaExceeded, usagePercent,
     deviceTotalBytes, deviceFreeBytes, deviceUsagePercent,
     othersBytes: blacklistBytes + sandboxBytes,
     categories,
   }
-  // 写入缓存（即便部分字段失败/降级也缓存，避免反复重算；清理动作会主动 invalidate）
-  _cachedInfo = result
-  _cachedAt = Date.now()
-  return result
 }
 
 /**
- * 详情页读取（分组详情；简单 handler 返回 null）
+ * 详情页读取 — 每次都重算
  */
 export async function getCategoryBreakdown(id) {
   const h = getHandler(id)
@@ -237,13 +197,9 @@ export function cleanCategory(id) {
     }
     try {
       const result = await h.clean()
-      // preload 清理同步清内存（§3.4.4）
       if (id === 'preload') {
         try { invalidateAll() } catch (e) { console.warn('[cacheManager] invalidateAll failed:', e.message) }
       }
-      // 局部扣减缓存（不清空）：返回列表页时 cache-cleanup 还能命中缓存，瞬时显示新数据
-      const { freedBytes = 0, keyCount = 0 } = result || {}
-      deductFromCache(id, freedBytes, keyCount)
       return result
     } catch (e) {
       console.warn(`[cacheManager] clean failed: ${id}`, e.message)
@@ -254,9 +210,6 @@ export function cleanCategory(id) {
 
 /**
  * 分组页清理（按 uid 维度）
- * @param {string} id
- * @param {object} opts
- * @param {string|null} opts.uid  'self' = 当前用户，null = 其他用户聚合，其他 = 具体 uid 字符串
  */
 export function cleanCategoryGroup(id, opts = {}) {
   const uidKey = opts.uid === undefined ? 'self' : String(opts.uid)
@@ -270,9 +223,6 @@ export function cleanCategoryGroup(id, opts = {}) {
       if (id === 'preload') {
         try { invalidateAll() } catch (e) { console.warn('[cacheManager] invalidateAll failed:', e.message) }
       }
-      // 局部扣减缓存（不清空）
-      const { freedBytes = 0, keyCount = 0 } = result || {}
-      deductFromCache(id, freedBytes, keyCount)
       return result
     } catch (e) {
       console.warn(`[cacheManager] cleanGroup failed: ${id}`, e.message)
@@ -282,10 +232,7 @@ export function cleanCategoryGroup(id, opts = {}) {
 }
 
 /**
- * 编程式清理所有（UI 不调用；登出流程/测试用）
- * 对每个 handler 调用其支持的清理方法：
- *   - 优先 clean()（简单型）
- *   - 否则调 cleanGroup({ uid: 'self' })（仅清当前用户的分组数据，符合"登出前清自己"的语义）
+ * 编程式清理所有（登出流程/测试用）
  */
 export async function cleanAll() {
   const results = []
@@ -310,7 +257,7 @@ export async function cleanAll() {
 }
 
 // NOTE: 必须非 async —— async 会把返回的 Promise 再包一层，破坏
-// `p1 === p2` 同一性断言（参见 plan §Task 12 Step 2 自测）。
+// `p1 === p2` 同一性断言。
 // 这里需要直接返回存储在 cleanInFlight 中的 Promise 引用本身。
 function _runWithInFlight(key, fn) {
   if (cleanInFlight.has(key)) return cleanInFlight.get(key)
@@ -321,10 +268,11 @@ function _runWithInFlight(key, fn) {
   return p
 }
 
-// ── Handler 注册（模块加载时执行；新增 handler 在此追加 registerCategory 调用）──
+// ── Handler 注册（模块加载时执行） ──
 registerCategory(sandboxTmpHandler)
+registerCategory(sandboxResidualHandler)
 registerCategory(progressHandler)
 registerCategory(othersHandler)
 registerCategory(preloadHandler)
 registerCategory(guideHandler)
-registerCategory(draftHandler)
\ No newline at end of file
+registerCategory(draftHandler)
diff --git a/frontend/utils/handlers/othersHandler.js b/frontend/utils/handlers/othersHandler.js
index b385f3b..cad565d 100644
--- a/frontend/utils/handlers/othersHandler.js
+++ b/frontend/utils/handlers/othersHandler.js
@@ -11,6 +11,8 @@ import { getAllBaseKeys } from '@/utils/draftStorage'
 const PRELOAD_PREFIX = 'preload:'
 const PROGRESS_PREFIX = 'progress_'
 const GUIDE_PREFIX = 'guide_'
+const UPGRADE_STORAGE_KEY = 'UNI_ADMIN_UPGRADE_CENTER_LOCAL_FILE_PATH'
+const UPGRADE_FILE_EXT = /\.(wgt|apk|ipa)$/i
 const DRAFT_BASE_KEYS = getAllBaseKeys()
 
 // 工作流关键 key 白名单（reviewer P0 修正：原"全收"策略会破坏这些）
@@ -19,7 +21,7 @@ const WORKFLOW_CRITICAL_KEYS = new Set([
   'generation_request_data',
   'craft_selected_index',
   '__package_info__',
-  'UNI_ADMIN_UPGRADE_CENTER_LOCAL_FILE_PATH',
+  UPGRADE_STORAGE_KEY,
 ])
 
 function isClaimed(key) {
@@ -33,28 +35,115 @@ function isClaimed(key) {
   return true
 }
 
+// ── 升级包沙盒文件（_downloads/upgrade_*.{wgt,apk,ipa}）──
+// 升级包可大到几十 MB（apk），且 App.vue 启动清理已移除（2026-07-31 决议），
+// 由本 handler 在用户主动清理时一并处理。
+//
+// 走 plus.io（不引 ioPath）：升级包在 _downloads 而非 _doc，ioPath 的
+// PRIVATE_DOC 抽象不适用；这里直接用 plus.io API，少量代码不值得抽象。
+function _scanUpgradePackageFiles() {
+  // #ifdef APP-PLUS
+  return new Promise((resolve) => {
+    if (typeof plus === 'undefined' || !plus.io) return resolve({ sizeBytes: 0, keyCount: 0 })
+    const dirUrl = plus.io.convertLocalFileSystemURL('_downloads/')
+    plus.io.resolveLocalFileSystemURL(
+      dirUrl,
+      (dirEntry) => {
+        const reader = dirEntry.createReader()
+        reader.readEntries(
+          (entries) => {
+            let sizeBytes = 0
+            let keyCount = 0
+            let pending = 0
+            const done = () => resolve({ sizeBytes, keyCount })
+            for (const e of entries) {
+              if (!e.isFile) continue
+              if (!/^upgrade_\d+\.(wgt|apk|ipa)$/i.test(e.name)) continue
+              keyCount++
+              pending++
+              e.file(
+                (f) => { sizeBytes += (f.size || 0); if (--pending === 0) done() },
+                () => { if (--pending === 0) done() }
+              )
+            }
+            if (pending === 0) done()
+          },
+          () => resolve({ sizeBytes: 0, keyCount: 0 })
+        )
+      },
+      () => resolve({ sizeBytes: 0, keyCount: 0 }) // _downloads 不存在
+    )
+  })
+  // #endif
+  // #ifndef APP-PLUS
+  return Promise.resolve({ sizeBytes: 0, keyCount: 0 })
+  // #endif
+}
+
+function _clearUpgradePackageFiles() {
+  // #ifdef APP-PLUS
+  return new Promise((resolve) => {
+    if (typeof plus === 'undefined' || !plus.io) return resolve({ deleted: 0 })
+    const dirUrl = plus.io.convertLocalFileSystemURL('_downloads/')
+    plus.io.resolveLocalFileSystemURL(
+      dirUrl,
+      (dirEntry) => {
+        const reader = dirEntry.createReader()
+        reader.readEntries(
+          (entries) => {
+            let deleted = 0
+            let pending = 0
+            const done = () => resolve({ deleted })
+            for (const e of entries) {
+              if (!e.isFile) continue
+              if (!/^upgrade_\d+\.(wgt|apk|ipa)$/i.test(e.name)) continue
+              pending++
+              e.remove(
+                () => { deleted++; if (--pending === 0) done() },
+                () => { if (--pending === 0) done() }
+              )
+            }
+            if (pending === 0) done()
+          },
+          () => resolve({ deleted: 0 })
+        )
+      },
+      () => resolve({ deleted: 0 })
+    )
+  })
+  // #endif
+  // #ifndef APP-PLUS
+  return Promise.resolve({ deleted: 0 })
+  // #endif
+}
+
 export default {
   id: 'others',
   label: '其他业务缓存',
   description: '未归类的少量业务数据',
   warning: false,
   async computeSize() {
-    try {
-      const info = uni.getStorageInfoSync()
-      const keys = (info.keys || []).filter(isClaimed)
-      let bytes = 0
-      for (const k of keys) {
-        try { const v = uni.getStorageSync(k); if (v != null) bytes += JSON.stringify(v).length } catch (e) {}
-      }
-      return { sizeBytes: bytes, keyCount: keys.length }
-    } catch (e) { return { sizeBytes: 0, keyCount: 0 } }
-  },
-  async clean() {
-    // Top-level errors propagate to cacheManager (per spec §6.1)
+    // storage key 部分（老逻辑）
     const info = uni.getStorageInfoSync()
     const keys = (info.keys || []).filter(isClaimed)
-
-    let freed = 0
+    let storageBytes = 0
+    for (const k of keys) {
+      try { const v = uni.getStorageSync(k); if (v != null) storageBytes += JSON.stringify(v).length } catch (e) {}
+    }
+    // 升级包沙盒文件部分（_downloads/upgrade_*）
+    const { sizeBytes: pkgBytes, keyCount: pkgCount } = await _scanUpgradePackageFiles()
+    return {
+      sizeBytes: storageBytes + pkgBytes,
+      sizeBytesFromStorage: storageBytes,
+      sizeBytesFromSandbox: pkgBytes,
+      keyCount: keys.length + pkgCount,
+    }
+  },
+  async clean() {
+    // 1) storage key 部分
+    const info = uni.getStorageInfoSync()
+    const keys = (info.keys || []).filter(isClaimed)
+    let freedStorage = 0
     let count = 0
     for (const k of keys) {
       let valueBytes = 0
@@ -63,17 +152,24 @@ export default {
         if (v != null) valueBytes = JSON.stringify(v).length
       } catch (e) {
         console.warn('[othersHandler] read failed:', k, e.message)
-        continue  // skip this key, don't try to delete
+        continue
       }
       try {
         uni.removeStorageSync(k)
-        freed += valueBytes
+        freedStorage += valueBytes
         count++
       } catch (e) {
         console.warn('[othersHandler] remove failed:', k, e.message)
-        // don't count as freed
       }
     }
-    return { freedBytes: freed, keyCount: count }
+    // 2) 升级包沙盒文件部分（先量后删得到准确 freedBytes）
+    const { sizeBytes: pkgBytes, keyCount: pkgCount } = await _scanUpgradePackageFiles()
+    const cleared = await _clearUpgradePackageFiles()
+    return {
+      freedBytes: freedStorage + pkgBytes,
+      freedBytesFromStorage: freedStorage,
+      freedBytesFromSandbox: pkgBytes,
+      keyCount: count + pkgCount,
+    }
   },
-}
\ No newline at end of file
+}
diff --git a/frontend/utils/handlers/sandboxResidualHandler.js b/frontend/utils/handlers/sandboxResidualHandler.js
new file mode 100644
index 0000000..a8b0177
--- /dev/null
+++ b/frontend/utils/handlers/sandboxResidualHandler.js
@@ -0,0 +1,117 @@
+// frontend/utils/handlers/sandboxResidualHandler.js
+// 沙盒 doc 根残留文件 handler（分组型）
+//
+// 覆盖 sandboxTmpHandler 漏掉的那部分沙盒占用 —— 后者只扫 <业务>/tmp/，
+// 而下列文件都不在那个形状里，此前有占用、无分类、无清理入口：
+//   _doc/share/<uid>/share_<ts>.png    useShare.js#copyToSandbox（保存到相册的兜底分支，进程被杀会留孤儿）
+//   _doc/<static原文件名>              useShare.js#copyStaticToDoc（完全无清理，设备级，不归账号）
+//   _doc/uniapp_save/**                avatarCache.js#downloadAndCacheAvatar（uni.saveFile 落点，按 URL hash 累积、无 TTL）
+//                                      ★ 该目录是 uni.saveFile 的公共落点，同时存放升级包，
+//                                        故只删非 .wgt/.apk/.ipa 的文件，详见 ioPath#_residualKind
+//   _doc/uniapp_temp_*/**              canvasToTempFilePath 落点（image-compositor.js 分享图合成），uni 设计上会清但失败场景会留
+//   _doc/preload/**                    2026-07-13 已废弃的文件版预加载缓存
+//
+// 分组策略（按 ioPath#_residualKind 判定）：
+//   - share/<uid>/ 子目录 → 按 uid 分组（"我的" / "其他用户"）
+//   - 其他所有（散落图片 + uniapp_save + uniapp_temp_*/ + preload + copyStaticToDoc 复制件）→ "全局"组
+//
+// 只删沙盒文件，不动 storage key：清理后 avatar_file_* 记录会短暂悬空，
+//   由 avatarCache.js#getCachedAvatarPath 自愈（getFileInfo 失败 → 删记录 → 返回 null → 重新下载）。
+//   这样本分类的字节口径是纯沙盒文件字节，与 cacheManager 的 blacklistBytes 不交叉。
+import { getCurrentUid } from '@/utils/draftStorage'
+import {
+  scanSandboxResidualAll,
+  clearSandboxResidualGlobal,
+  clearSandboxShareByUid,
+} from '@/utils/ioPath'
+
+export default {
+  id: 'sandbox-residual',
+  label: '分享图与头像缓存',
+  description: '分享保存的图片、合成图与头像缓存文件',
+  warning: false,
+  // 分组型 handler 不实现 clean() — 强制走 cleanGroup({uid})
+  // 列表页汇总：scanSandboxResidualAll 一次 walk 取 total 字段（替代旧 scanSandboxResidualFiles）
+  async computeSize() {
+    const r = await scanSandboxResidualAll()
+    return r.total
+  },
+  // 分组详情：3 组
+  //   - 我的（当前 uid 的 share/<uid>/）
+  //   - 其他用户（其他 uid 的 share/<uid>/，聚合）
+  //   - 全局（doc 根其余全部）
+  // ★ 2026-07-31 修复（M1）：原版走 scanSandboxResidualByUid() + scanSandboxResidualFiles()
+  //   共 2 次 walk（详情页撞 4s 超时）。改用 scanSandboxResidualAll() 单次 walk
+  //   同时取 byUid 和 global（global 由 total - byUid 数学减法得），无额外 walk。
+  async computeBreakdown() {
+    const currentUid = getCurrentUid()
+    const isLoggedIn = !!currentUid
+    const { byUid, global } = await scanSandboxResidualAll()
+    const groups = []
+
+    // 1) 我的 / 其他用户（按 uid 子目录聚合）
+    const myGroup = byUid.find((g) => g.uid === currentUid)
+    if (myGroup && myGroup.keyCount > 0) {
+      groups.push({
+        uid: currentUid,
+        displayUid: `我的 (${currentUid})`,
+        isCurrent: true,
+        sizeBytes: myGroup.sizeBytes,
+        keyCount: myGroup.keyCount,
+        canClean: true,
+        disabledReason: null,
+      })
+    }
+    const otherGroups = byUid.filter((g) => g.uid !== currentUid)
+    for (const g of otherGroups) {
+      if (g.keyCount === 0) continue
+      groups.push({
+        uid: g.uid,
+        displayUid: `其他用户 (${g.uid})`,
+        isCurrent: false,
+        sizeBytes: g.sizeBytes,
+        keyCount: g.keyCount,
+        canClean: isLoggedIn, // 未登录态不准清理他人数据
+        disabledReason: isLoggedIn ? null : 'logged-out',
+      })
+    }
+
+    // 2) 全局（doc 根其余全部）— 已由 scanSandboxResidualAll 一次 walk 算出（total - byUid）
+    //    全局组永远存在（即使没文件也显示 0，让用户知道这个分类）
+    groups.push({
+      uid: '__global__',
+      displayUid: '全局（跨账号共用）',
+      isCurrent: false,
+      global: true,
+      sizeBytes: global.sizeBytes,
+      keyCount: global.keyCount,
+      canClean: global.keyCount > 0,
+      disabledReason: global.keyCount === 0 ? 'empty' : null,
+    })
+
+    return groups.sort((a, b) => b.sizeBytes - a.sizeBytes)
+  },
+  async cleanGroup({ uid }) {
+    // 'self' → 清当前 uid 的 share/<uid>/
+    if (uid === 'self') {
+      const currentUid = getCurrentUid()
+      if (!currentUid) return { freedBytes: 0, keyCount: 0 }
+      const r = await clearSandboxShareByUid(currentUid)
+      if (!r.deleted) return { freedBytes: 0, keyCount: 0 }
+      return { freedBytes: r.freedBytes || 0, keyCount: r.keyCount || 0 }
+    }
+    // '__global__' → 清 doc 根除 share/ 之外的整张残留图
+    //   注意：share/ 下各 uid 子目录由具体 uid 入口清理，本入口不动
+    //   边量边删：clearSandboxResidualGlobal 内部对每个 dir-purge 先 _statDir 拿 before
+    //   字节/计数，再 removeRecursively，返回 { freedBytes, keyCount, ... }
+    //   调用方不再做 before/after 双扫描（慢设备 4s+ 超时卡住清理动作）
+    if (uid === '__global__') {
+      const r = await clearSandboxResidualGlobal()
+      return { freedBytes: r.freedBytes || 0, keyCount: r.keyCount || 0 }
+    }
+    // 具体 uid → 清 share/<uid>/（不对其它 uid 动手）
+    const r = await clearSandboxShareByUid(uid)
+    if (!r.deleted) return { freedBytes: 0, keyCount: 0 }
+    return { freedBytes: r.freedBytes || 0, keyCount: r.keyCount || 0 }
+  },
+}
\ No newline at end of file
diff --git a/frontend/utils/handlers/sandboxTmpHandler.js b/frontend/utils/handlers/sandboxTmpHandler.js
index f7f4099..2dbe5c4 100644
--- a/frontend/utils/handlers/sandboxTmpHandler.js
+++ b/frontend/utils/handlers/sandboxTmpHandler.js
@@ -1,7 +1,6 @@
 // frontend/utils/handlers/sandboxTmpHandler.js
 // 沙盒临时文件 handler（简单型）
-// reviewer P0 修正：不再依赖私有 ioPath 内部函数，全部走 ioPath 导出 API
-import { scanSandboxTmpFiles, countSandboxTmpFiles, clearAllSandboxTmpFiles } from '@/utils/ioPath'
+import { scanSandboxTmpFiles, clearAllSandboxTmpFiles } from '@/utils/ioPath'
 
 export default {
   id: 'sandbox-tmp',
@@ -9,19 +8,14 @@ export default {
   description: '上传/分享过程产生的临时文件',
   warning: false,
   async computeSize() {
-    const [bytes, count] = await Promise.all([
-      scanSandboxTmpFiles(),
-      countSandboxTmpFiles(),  // 真实文件数（reviewer P0 修正）
-    ])
-    return { sizeBytes: bytes, keyCount: count }
+    // scanSandboxTmpFiles 一次返回 {sizeBytes, keyCount}（替代旧的 size+count 双遍历）
+    return await scanSandboxTmpFiles()
   },
   async clean() {
-    const [before, beforeCount] = await Promise.all([
-      scanSandboxTmpFiles(),
-      countSandboxTmpFiles(),
-    ])
-    await clearAllSandboxTmpFiles()
-    const after = await scanSandboxTmpFiles()
-    return { freedBytes: Math.max(0, before - after), keyCount: beforeCount }
+    // 边量边删：clearAllSandboxTmpFiles 内部对每个 tmp/ 目录先 _statDir 拿 before
+    // 字节/计数，再 removeRecursively，返回 { freedBytes, keyCount, ... }
+    // 调用方不再做 before/after 三次扫描，慢设备不再卡 4s 超时
+    const r = await clearAllSandboxTmpFiles()
+    return { freedBytes: r.freedBytes || 0, keyCount: r.keyCount || 0 }
   },
-}
\ No newline at end of file
+}
diff --git a/frontend/utils/image-compositor.js b/frontend/utils/image-compositor.js
index d5c080e..f15cb7a 100644
--- a/frontend/utils/image-compositor.js
+++ b/frontend/utils/image-compositor.js
@@ -39,7 +39,7 @@ function truncateHash(hash) {
  * @param {string} [opts.displayTxHash] - 链上哈希原文(父组件提供),截断后渲染到二维码侧空白区
  * @returns {Promise<{tempFilePath: string, width: number, height: number}>}
  */
-export function composeShareImage(opts, componentThis) {
+export function composeShareImage(opts, _componentThis) {
   return new Promise((resolve, reject) => {
     const {
       coverLocalPath,
@@ -126,9 +126,10 @@ export function composeShareImage(opts, componentThis) {
  * 计算 composeKey(spec § 5.4)
  * 用于 L1/L2 缓存查询;任一字段变化则重合成
  *
- * 入参用本地临时路径(_doc/uniapp_temp_<timestamp>/download/...)。
- * ⚠️ 当前 trade-off:temp 路径含时间戳,每次 pick 都不同 → L1/L2 cache 实际不会命中,
- *  每次 pick 都会重合成。代码保留 cache 结构以备将来切回 URL-based key 时复用。
+ * 入参 cover/qrcode/avatar 本地路径来自 useShare.js#downloadLocal：
+ *   - /static/ 前缀 → copyStaticToDoc 落 _doc/<static 原文件名>（无时间戳）
+ *   - 远端 URL   → 失败兜底，原样返回（仍可作为 cache key）
+ * 拼接 7 个字段（3 路径 + 1 昵称 + 2 slogan + 1 txHash），任一变化触发重合成。
  */
 export function computeComposeKey(opts) {
   const { coverLocalPath = '', qrcodeLocalPath = '', avatarLocalPath = '', nickname = '', slogan = {}, displayTxHash = '' } = opts;
diff --git a/frontend/utils/ioPath.js b/frontend/utils/ioPath.js
index 47577c3..8497310 100644
--- a/frontend/utils/ioPath.js
+++ b/frontend/utils/ioPath.js
@@ -33,7 +33,7 @@ export const SANDBOX_ROOT = 2 // plus.io.PRIVATE_DOC
  * @returns {string[]}
  */
 export function splitRelativePath(relativePath) {
-  return String(relativePath || '').split('/').filter(Boolean)
+	return String(relativePath || '').split('/').filter(Boolean)
 }
 
 /**
@@ -42,26 +42,26 @@ export function splitRelativePath(relativePath) {
  */
 let _rootDirPromise = null
 export function getSandboxRootDir() {
-  // #ifdef APP-PLUS
-  if (_rootDirPromise) return _rootDirPromise
-  _rootDirPromise = new Promise((resolve, reject) => {
-    plus.io.requestFileSystem(
-      SANDBOX_ROOT,
-      (fs) => resolve(fs.root),
-      (err) => {
-        _rootDirPromise = null // 失败重置缓存,允许重试
-        reject(err)
-      }
-    )
-  })
-  return _rootDirPromise
-  // #endif
+	// #ifdef APP-PLUS
+	if (_rootDirPromise) return _rootDirPromise
+	_rootDirPromise = new Promise((resolve, reject) => {
+		plus.io.requestFileSystem(
+			SANDBOX_ROOT,
+			(fs) => resolve(fs.root),
+			(err) => {
+				_rootDirPromise = null // 失败重置缓存,允许重试
+				reject(err)
+			}
+		)
+	})
+	return _rootDirPromise
+	// #endif
 
-  // #ifndef APP-PLUS
-  // H5/小程序:返回伪 root,通过 uni.getFileSystemManager 路径字符串操作
-  // 不缓存(各端语义不同,缓存反而可能错)
-  return Promise.reject(new Error('sandbox dir only available on APP-PLUS'))
-  // #endif
+	// #ifndef APP-PLUS
+	// H5/小程序:返回伪 root,通过 uni.getFileSystemManager 路径字符串操作
+	// 不缓存(各端语义不同,缓存反而可能错)
+	return Promise.reject(new Error('sandbox dir only available on APP-PLUS'))
+	// #endif
 }
 
 /**
@@ -70,33 +70,35 @@ export function getSandboxRootDir() {
  * @returns {Promise<DirectoryEntry>}
  */
 export async function ensureSandboxSubdir(parts) {
-  // #ifdef APP-PLUS
-  if (!Array.isArray(parts) || parts.length === 0) {
-    throw new Error('ensureSandboxSubdir: parts must be non-empty array')
-  }
-  const root = await getSandboxRootDir()
-  return new Promise((resolve, reject) => {
-    let currentEntry = root
-    const step = (idx) => {
-      if (idx >= parts.length) return resolve(currentEntry)
-      currentEntry.getDirectory(
-        parts[idx],
-        { create: true, exclusive: false },
-        (dirEntry) => {
-          currentEntry = dirEntry
-          step(idx + 1)
-        },
-        (err) => reject(err)
-      )
-    }
-    step(0)
-  })
-  // #endif
+	// #ifdef APP-PLUS
+	if (!Array.isArray(parts) || parts.length === 0) {
+		throw new Error('ensureSandboxSubdir: parts must be non-empty array')
+	}
+	const root = await getSandboxRootDir()
+	return new Promise((resolve, reject) => {
+		let currentEntry = root
+		const step = (idx) => {
+			if (idx >= parts.length) return resolve(currentEntry)
+			currentEntry.getDirectory(
+				parts[idx], {
+					create: true,
+					exclusive: false
+				},
+				(dirEntry) => {
+					currentEntry = dirEntry
+					step(idx + 1)
+				},
+				(err) => reject(err)
+			)
+		}
+		step(0)
+	})
+	// #endif
 
-  // #ifndef APP-PLUS
-  // H5/小程序路径由各端 fs.mkdirSync 处理,这里返回 null 让调用方自行降级
-  return Promise.resolve(null)
-  // #endif
+	// #ifndef APP-PLUS
+	// H5/小程序路径由各端 fs.mkdirSync 处理,这里返回 null 让调用方自行降级
+	return Promise.resolve(null)
+	// #endif
 }
 
 /**
@@ -111,21 +113,23 @@ export async function ensureSandboxSubdir(parts) {
  * @returns {Promise<DirectoryEntry>}
  */
 export async function getSandboxFile(subdirParts, fileName, create = true) {
-  // #ifdef APP-PLUS
-  const dir = await ensureSandboxSubdir(subdirParts)
-  return new Promise((resolve, reject) => {
-    dir.getFile(
-      fileName,
-      { create, exclusive: false },
-      (entry) => resolve(entry),
-      (err) => reject(err)
-    )
-  })
-  // #endif
+	// #ifdef APP-PLUS
+	const dir = await ensureSandboxSubdir(subdirParts)
+	return new Promise((resolve, reject) => {
+		dir.getFile(
+			fileName, {
+				create,
+				exclusive: false
+			},
+			(entry) => resolve(entry),
+			(err) => reject(err)
+		)
+	})
+	// #endif
 
-  // #ifndef APP-PLUS
-  return Promise.resolve(null)
-  // #endif
+	// #ifndef APP-PLUS
+	return Promise.resolve(null)
+	// #endif
 }
 
 /**
@@ -137,15 +141,15 @@ export async function getSandboxFile(subdirParts, fileName, create = true) {
  * @returns {Promise<string>} file:// 形式的绝对路径
  */
 export async function getSandboxFileUri(subdirParts, fileName) {
-  // #ifdef APP-PLUS
-  const entry = await getSandboxFile(subdirParts, fileName, true)
-  return entry.toLocalURL() // file:///data/user/0/.../doc/<...>/<fileName>
-  // #endif
+	// #ifdef APP-PLUS
+	const entry = await getSandboxFile(subdirParts, fileName, true)
+	return entry.toLocalURL() // file:///data/user/0/.../doc/<...>/<fileName>
+	// #endif
 
-  // #ifndef APP-PLUS
-  const parts = [...subdirParts, fileName]
-  return Promise.resolve(parts.join('/'))
-  // #endif
+	// #ifndef APP-PLUS
+	const parts = [...subdirParts, fileName]
+	return Promise.resolve(parts.join('/'))
+	// #endif
 }
 
 /**
@@ -165,40 +169,58 @@ export const SANDBOX_DISPLAY_PREFIX = '[sandbox:doc] '
  * @returns {Promise<{deleted: boolean, reason?: string}>}
  */
 export async function clearSandboxSubdir(subdirParts) {
-  // #ifdef APP-PLUS
-  if (!Array.isArray(subdirParts) || subdirParts.length === 0) {
-    return { deleted: false, reason: 'invalid subdirParts' }
-  }
-  try {
-    const root = await getSandboxRootDir()
-    return await new Promise((resolve) => {
-      // 逐级 resolve,只创建不创建(create: false)
-      const step = (idx, currentEntry) => {
-        if (idx >= subdirParts.length) {
-          // 到了目标目录,递归删除
-          currentEntry.removeRecursively(
-            () => resolve({ deleted: true }),
-            (err) => resolve({ deleted: false, reason: err?.message || 'removeRecursively failed' })
-          )
-          return
-        }
-        currentEntry.getDirectory(
-          subdirParts[idx],
-          { create: false },
-          (nextEntry) => step(idx + 1, nextEntry),
-          (err) => resolve({ deleted: false, reason: 'not_found' }) // 路径不存在 = ok
-        )
-      }
-      step(0, root)
-    })
-  } catch (e) {
-    return { deleted: false, reason: e?.message || 'exception' }
-  }
-  // #endif
+	// #ifdef APP-PLUS
+	if (!Array.isArray(subdirParts) || subdirParts.length === 0) {
+		return {
+			deleted: false,
+			reason: 'invalid subdirParts'
+		}
+	}
+	try {
+		const root = await getSandboxRootDir()
+		return await new Promise((resolve) => {
+			// 逐级 resolve,只创建不创建(create: false)
+			const step = (idx, currentEntry) => {
+				if (idx >= subdirParts.length) {
+					// 到了目标目录,递归删除
+					currentEntry.removeRecursively(
+						() => resolve({
+							deleted: true
+						}),
+						(err) => resolve({
+							deleted: false,
+							reason: err?.message || 'removeRecursively failed'
+						})
+					)
+					return
+				}
+				currentEntry.getDirectory(
+					subdirParts[idx], {
+						create: false
+					},
+					(nextEntry) => step(idx + 1, nextEntry),
+					(err) => resolve({
+						deleted: false,
+						reason: 'not_found'
+					}) // 路径不存在 = ok
+				)
+			}
+			step(0, root)
+		})
+	} catch (e) {
+		return {
+			deleted: false,
+			reason: e?.message || 'exception'
+		}
+	}
+	// #endif
 
-  // #ifndef APP-PLUS
-  return Promise.resolve({ deleted: false, reason: 'app-only' })
-  // #endif
+	// #ifndef APP-PLUS
+	return Promise.resolve({
+		deleted: false,
+		reason: 'app-only'
+	})
+	// #endif
 }
 
 /**
@@ -208,47 +230,65 @@ export async function clearSandboxSubdir(subdirParts) {
 const PROTECTED_SUBDIRS = new Set(['preload', 'share', 'image'])
 
 export async function clearAllSandboxTmpDirs() {
-  // #ifdef APP-PLUS
-  try {
-    const root = await getSandboxRootDir()
-    const entries = await new Promise((resolve) => {
-      const reader = root.createReader()
-      const collected = []
-      const readAll = () => {
-        reader.readEntries(
-          (es) => {
-            if (es.length === 0) return resolve(collected)
-            collected.push(...es)
-            readAll()
-          },
-          () => resolve(collected)
-        )
-      }
-      readAll()
-    })
-    const results = []
-    for (const e of entries) {
-      if (!e.isDirectory) continue
-      if (PROTECTED_SUBDIRS.has(e.name)) continue
-      // 逐个清掉(忽略失败)
-      // eslint-disable-next-line no-await-in-loop
-      const r = await new Promise((resolve) => {
-        e.removeRecursively(
-          () => resolve({ name: e.name, deleted: true }),
-          (err) => resolve({ name: e.name, deleted: false, reason: err?.message })
-        )
-      })
-      results.push(r)
-    }
-    return { cleared: results.filter((r) => r.deleted).length, results }
-  } catch (e) {
-    return { cleared: 0, reason: e?.message || 'exception', results: [] }
-  }
-  // #endif
+	// #ifdef APP-PLUS
+	try {
+		const root = await getSandboxRootDir()
+		const entries = await new Promise((resolve) => {
+			const reader = root.createReader()
+			const collected = []
+			const readAll = () => {
+				reader.readEntries(
+					(es) => {
+						if (es.length === 0) return resolve(collected)
+						collected.push(...es)
+						readAll()
+					},
+					() => resolve(collected)
+				)
+			}
+			readAll()
+		})
+		const results = []
+		for (const e of entries) {
+			if (!e.isDirectory) continue
+			if (PROTECTED_SUBDIRS.has(e.name)) continue
+			// 逐个清掉(忽略失败)
+			// eslint-disable-next-line no-await-in-loop
+			const r = await new Promise((resolve) => {
+				e.removeRecursively(
+					() => resolve({
+						name: e.name,
+						deleted: true
+					}),
+					(err) => resolve({
+						name: e.name,
+						deleted: false,
+						reason: err?.message
+					})
+				)
+			})
+			results.push(r)
+		}
+		return {
+			cleared: results.filter((r) => r.deleted).length,
+			results
+		}
+	} catch (e) {
+		return {
+			cleared: 0,
+			reason: e?.message || 'exception',
+			results: []
+		}
+	}
+	// #endif
 
-  // #ifndef APP-PLUS
-  return Promise.resolve({ cleared: 0, results: [], reason: 'app-only' })
-  // #endif
+	// #ifndef APP-PLUS
+	return Promise.resolve({
+		cleared: 0,
+		results: [],
+		reason: 'app-only'
+	})
+	// #endif
 }
 
 /**
@@ -264,384 +304,1771 @@ export async function clearAllSandboxTmpDirs() {
  * @returns {Promise<{scanned: number, deleted: number, dirs: string[]}>}
  */
 export async function clearAllSandboxTmpFiles() {
-  // #ifdef APP-PLUS
-  try {
-    const root = await getSandboxRootDir()
-    // 1. 拿到所有业务子目录
-    const topEntries = await new Promise((resolve) => {
-      const reader = root.createReader()
-      const collected = []
-      const readAll = () => {
-        reader.readEntries(
-          (es) => {
-            if (es.length === 0) return resolve(collected)
-            collected.push(...es)
-            readAll()
-          },
-          () => resolve(collected)
-        )
-      }
-      readAll()
-    })
+	// #ifdef APP-PLUS
+	try {
+		const root = await getSandboxRootDir()
+		// 1. 拿到所有业务子目录
+		const topEntries = await new Promise((resolve) => {
+			const reader = root.createReader()
+			const collected = []
+			const readAll = () => {
+				reader.readEntries(
+					(es) => {
+						if (es.length === 0) return resolve(collected)
+						collected.push(...es)
+						readAll()
+					},
+					() => resolve(collected)
+				)
+			}
+			readAll()
+		})
 
-    let scanned = 0
-    let deleted = 0
-    const cleanedDirs = []
+		let scanned = 0
+		let deleted = 0
+		let freedBytes = 0
+		let keyCount = 0
+		const cleanedDirs = []
 
-    for (const top of topEntries) {
-      if (!top.isDirectory) continue
-      if (PROTECTED_SUBDIRS.has(top.name)) continue
-      // 2. 拿到每个业务子目录下的 tmp/ 子目录(不存在则跳过)
-      // eslint-disable-next-line no-await-in-loop
-      const tmpEntry = await new Promise((resolve) => {
-        top.getDirectory(
-          'tmp',
-          { create: false },
-          (entry) => resolve(entry),
-          () => resolve(null)
-        )
-      })
-      if (!tmpEntry) continue
+		for (const top of topEntries) {
+			if (!top.isDirectory) continue
+			// 白名单：只对业务目录探查 tmp/，跳过 uniapp_temp_*/uniapp_save/preload 等系统目录
+			//   否则 _doc/ 根下累积的 uniapp_temp_<ts>/ × N 会让这个 O(N) 循环卡 2-4s
+			if (!BUSINESS_TMP_PARENTS.has(top.name)) continue
+			// 2. 拿到每个业务子目录下的 tmp/ 子目录(不存在则跳过)
+			// eslint-disable-next-line no-await-in-loop
+			const tmpEntry = await new Promise((resolve) => {
+				top.getDirectory(
+					'tmp', {
+						create: false
+					},
+					(entry) => resolve(entry),
+					() => resolve(null)
+				)
+			})
+			if (!tmpEntry) continue
 
-      scanned++
-      // 3. 整个 tmp/ 目录递归删除(下次上传 getSandboxFileUri 会自动重建)
-      // eslint-disable-next-line no-await-in-loop
-      const ok = await new Promise((resolve) => {
-        tmpEntry.removeRecursively(
-          () => resolve(true),
-          () => resolve(false)
-        )
-      })
-      if (ok) {
-        deleted++
-        cleanedDirs.push(`${top.name}/tmp`)
-      }
-    }
+			scanned++
+			// 3. 边量边删：先 _statDir 拿 before 字节/计数（一次遍历），再 removeRecursively 整目录删
+			//    旧实现省略 before 量，为显示"已清理 X MB"还要在调用方做 before/after 三次扫描
+			// eslint-disable-next-line no-await-in-loop
+			const before = await _statDir(tmpEntry)
+			// eslint-disable-next-line no-await-in-loop
+			const ok = await new Promise((resolve) => {
+				tmpEntry.removeRecursively(
+					() => resolve(true),
+					() => resolve(false)
+				)
+			})
+			if (ok) {
+				deleted++
+				freedBytes += before.bytes
+				keyCount += before.count
+				cleanedDirs.push(`${top.name}/tmp`)
+			}
+		}
 
-    console.log('[ioPath] clearAllSandboxTmpFiles:', { scanned, deleted, dirs: cleanedDirs })
-    return { scanned, deleted, dirs: cleanedDirs }
-  } catch (e) {
-    console.warn('[ioPath] clearAllSandboxTmpFiles failed:', e?.message)
-    return { scanned: 0, deleted: 0, dirs: [], error: e?.message }
-  }
-  // #endif
+		return {
+			scanned,
+			deleted,
+			freedBytes,
+			keyCount,
+			dirs: cleanedDirs
+		}
+	} catch (e) {
+		console.warn('[ioPath] clearAllSandboxTmpFiles failed:', e?.message)
+		return {
+			scanned: 0,
+			deleted: 0,
+			freedBytes: 0,
+			keyCount: 0,
+			dirs: [],
+			error: e?.message
+		}
+	}
+	// #endif
 
-  // #ifndef APP-PLUS
-  return Promise.resolve({ scanned: 0, deleted: 0, dirs: [] })
-  // #endif
+	// #ifndef APP-PLUS
+	return Promise.resolve({
+		scanned: 0,
+		deleted: 0,
+		freedBytes: 0,
+		keyCount: 0,
+		dirs: []
+	})
+	// #endif
 }
 
 /**
- * 通过 plus.android 读取 APK 安装包大小（Android 专用，绕开 sandbox 限制）
- * 在 iOS / H5 / 小程序上返回 0（调用方应改用 sandbox 大小）
- * @returns {Promise<number>} APK 字节数
- */
-async function getAndroidApkSize() {
-  // #ifdef APP-PLUS
-  try {
-    // 仅 Android
-    if (typeof plus === 'undefined' || !plus.android) return 0
-    const main = plus.android.runtimeMainActivity()
-    if (!main) return 0
-    // 走 Context.getApplicationInfo()（App.vue#setPermissions 验证过可工作）
-    // 不走 PackageManager.getApplicationInfo(pkg, 0):
-    //   plus.android proxy 对 PackageManager 的 getApplicationInfo 重载方法暴露不稳定,
-    //   会报 "pm.getApplicationInfo is not a function"。
-    // Context.getApplicationInfo() 返回当前应用的 ApplicationInfo,正是我们想要的。
-    const appInfo = main.getApplicationInfo()
-    if (!appInfo) return 0
-    const sourceDir = plus.android.invoke(appInfo, 'getSourceDir') || appInfo.plusGetAttribute?.('sourceDir')
-    if (!sourceDir) return 0
-    const File = plus.android.importClass('java.io.File')
-    const f = new File(sourceDir)
-    const size = f.length()
-    if (typeof size === 'number' && size > 0) return size
-    return 0
-  } catch (e) {
-    console.warn('[ioPath] getAndroidApkSize failed:', e?.message)
-    return 0
-  }
-  // #endif
-  // #ifndef APP-PLUS
-  return 0
-  // #endif
-}
-
-/**
- * 计算"app 已用空间" = Android APK 安装包大小 + 4 个 sandbox 根目录下所有文件总字节
- * 在 iOS / H5 上只算 sandbox（iOS .app bundle 沙盒外不可访问，按 sandbox 估算）
- * 用于 cacheManager.getCacheInfo() 聚合 appUsedBytes
+ * Android 专用：通过 StorageStatsManager 一次查询获取当前 app 的存储字节数
+ *   StorageStats.getAppBytes() = APK + data + cache（系统记账，O(1)）
+ * 替代旧实现 `apkSize + Σ4 沙盒根遍历`（O(N)，慢设备 2-4s）。
  *
- * 4 个 sandbox 根：
- *   PRIVATE_DOC       (2) _doc           私有文档（用户数据/缓存）— 主用，绝大多数占用在此
- *   PRIVATE_WWW       (1) _www           私有资源（仅 manifest.json 设 runmode=liberate 时才有内容）
+ * 适用平台与降级链：
+ *   - Android API ≥ 26：尝试走原生查询；任一环节失败 → 抛 'not_available' 给调用方走旧扫描
+ *   - Android API < 26：直接抛 'unsupported_api'（queryStatsForPackage 自 API 26 引入）
+ *   - iOS / H5 / 小程序：抛 'not_android'（调用方应改走旧 _sumDirSizeByRootType）
+ *
+ * 已知代理坑（沿用本文件 `getDeviceStorageInfo` / `getAndroidApkSize` 范式 + 加固）：
+ *   - plus.android 对 *Long / static 字段代理不稳定 → 全部 parseFloat 兜底
+ *   - plus.android.invoke(method, ...args) 参数对象在 proxy 上需保证类型一致（UUID 必须为 java.util.UUID）
+ *   - 重载方法：代码先 try 三参 (UUID, String, UserHandle)，catch 后 try 两参 (String, UserHandle)
+ *     （API 26–28 走两参；API 29+ 走三参；先三参后两参是让 API 29+ 一次成功、不被 catch 吞）
+ *
+ * 调用方契约：返回 { supported: true, bytes, source: 'native' } 表示走通；
+ *            返回 { supported: false, reason } 表示需走旧扫描降级。
+ *
+ * @returns {Promise<{supported:boolean, bytes?:number, source?:'native', reason?:string}>}
+ */
+async function queryAndroidAppBytes() {
+	// #ifdef APP-PLUS
+	try {
+		if (typeof plus === 'undefined' || !plus.android) {
+			console.warn('[ioPath] queryAndroidAppBytes: no_plus_android')
+			return {
+				supported: false,
+				reason: 'no_plus_android'
+			}
+		}
+		if (plus.os.name !== 'Android') {
+			console.warn('[ioPath] queryAndroidAppBytes: not_android (os=' + (plus.os?.name || 'unknown') + ')')
+			return {
+				supported: false,
+				reason: 'not_android'
+			}
+		}
+
+		const Build = plus.android.importClass('android.os.Build')
+		// Build.VERSION.SDK_INT 是 int，proxy 上读 static 字段用 plusGetAttribute 更稳
+		const sdkInt = parseFloat(plus.android.invoke(Build, 'VERSION', 'SDK_INT') || Build.VERSION?.SDK_INT || 0)
+		if (!(sdkInt >= 26)) {
+			console.warn(`[ioPath] queryAndroidAppBytes: unsupported_api (sdkInt=${sdkInt}, 需要 ≥ 26)`)
+			return {
+				supported: false,
+				reason: 'unsupported_api'
+			}
+		}
+
+		const main = plus.android.runtimeMainActivity()
+		if (!main) {
+			console.warn('[ioPath] queryAndroidAppBytes: no_main_activity')
+			return {
+				supported: false,
+				reason: 'no_main_activity'
+			}
+		}
+
+		// Context.STORAGE_STATS_SERVICE = "storagestats"
+		// 直接传字符串：与 App.vue:439 拿 notificationManager 同款（Context.NOTIFICATION_SERVICE）
+		const ssm = main.getSystemService('storagestats')
+		if (!ssm) {
+			console.warn('[ioPath] queryAndroidAppBytes: no_ssm (getSystemService("storagestats") returned null)')
+			return {
+				supported: false,
+				reason: 'no_ssm'
+			}
+		}
+
+		const pkg = main.getPackageName() // App.vue:460 已验证
+		if (!pkg) {
+			console.warn('[ioPath] queryAndroidAppBytes: no_pkg (main.getPackageName() returned falsy)')
+			return {
+				supported: false,
+				reason: 'no_pkg'
+			}
+		}
+
+		// UserHandle：API 24+ 有 myUserHandle() 单例；更老没有
+		const UserHandle = plus.android.importClass('android.os.UserHandle')
+		let userHandle = null
+		try {
+			userHandle = sdkInt >= 24 ?
+				plus.android.invoke(UserHandle, 'myUserHandle') :
+				null
+			if (!userHandle) {
+				// fallback: UserHandle.CURRENT 静态字段（API 17+，所有 plus 兼容版本都有）
+				userHandle = plus.android.invoke(UserHandle, 'CURRENT')
+			}
+		} catch (e) {
+			console.warn('[ioPath] queryAndroidAppBytes: UserHandle failed:', e?.message)
+		}
+		if (!userHandle) {
+			// console.warn(
+			// 	`[ioPath] queryAndroidAppBytes: no_user_handle (sdkInt=${sdkInt}, myUserHandle() 与 CURRENT 都为空)`
+			// )
+			return {
+				supported: false,
+				reason: 'no_user_handle'
+			}
+		}
+
+		// 三参版本 (UUID, String, UserHandle) 是 API 29+ 强制签名；
+		//   API 26-28 也有同名重载但参数是 (String, UserHandle)，先试三参
+		let stats = null
+		try {
+			// StorageStatsManager.getStorageUuid(UUID) 返回 UUID；
+			// UUID_DEFAULT 是 java.util.UUID 常量（不是 android.os.UserHandle 的）
+			const UUID = plus.android.importClass('java.util.UUID')
+			// UUID.fromString("00000000-0000-0000-0000-000000000000") = UUID_DEFAULT 等价
+			// 但更稳的是反射：StorageManager.UUID_DEFAULT 是个 static UUID 字段
+			// （直接传字符串给 getStorageUuid 不可行，签名是 java.util.UUID）
+			const uuidObj = plus.android.invoke(UUID, 'fromString', '00000000-0000-0000-0000-000000000000')
+			stats = plus.android.invoke(ssm, 'queryStatsForPackage', uuidObj, pkg, userHandle)
+		} catch (e) {
+			// 退到两参版本（API 26-28 兼容）
+			try {
+				stats = plus.android.invoke(ssm, 'queryStatsForPackage', pkg, userHandle)
+			} catch (e2) {
+				console.warn('[ioPath] queryAndroidAppBytes: queryStatsForPackage both signatures failed:', e2
+					?.message)
+				return {
+					supported: false,
+					reason: 'query_failed'
+				}
+			}
+		}
+		if (!stats) return {
+			supported: false,
+			reason: 'no_stats'
+		}
+
+		// getAppBytes() 是 long 返回，proxy 不稳 → parseFloat 兜底
+		const bytes = parseFloat(plus.android.invoke(stats, 'getAppBytes'))
+		if (!Number.isFinite(bytes) || bytes < 0) {
+			console.warn('[ioPath] queryAndroidAppBytes: invalid bytes =', bytes)
+			return {
+				supported: false,
+				reason: 'invalid_bytes'
+			}
+		}
+		return {
+			supported: true,
+			bytes,
+			source: 'native'
+		}
+	} catch (e) {
+		console.warn('[ioPath] queryAndroidAppBytes unexpected failure:', e?.message)
+		return {
+			supported: false,
+			reason: 'exception'
+		}
+	}
+	// #endif
+	// #ifndef APP-PLUS
+	return {
+		supported: false,
+		reason: 'not_app_plus'
+	}
+	// #endif
+}
+
+/**
+ * 计算"app 已用空间"。
+ *
+ * Android API ≥ 26：优先走 StorageStatsManager.getAppBytes()（系统记账，O(1)）。
+ *   原生查询任一环节失败 → 降级到旧实现"APK + Σ4 沙盒根遍历"（4s 单根兜底，与降级前等价）。
+ * Android API < 26：直接走旧实现（queryStatsForPackage 自 API 26 才有）。
+ * iOS：旧实现 4 沙盒根遍历（iOS .app bundle 沙盒外不可访问，按 sandbox 估算）。
+ * H5 / 小程序：return 0。
+ *
+ * 用于 cacheManager.getCacheInfo() 聚合 appUsedBytes。
+ *
+ * 4 个 sandbox 根（旧实现 / iOS 共用）：
+ *   PRIVATE_DOC       (2) _doc           私有文档（用户数据/缓存）— 主用
+ *   PRIVATE_WWW       (1) _www           私有资源（仅 liberate 模式才有内容）
  *   PUBLIC_DOCUMENTS  (3) _documents     公共文档（多 5+ App 共享）
  *   PUBLIC_DOWNLOADS  (4) _downloads     公共下载（多 5+ App 共享）
  *
  * PRIVATE_WWW 行为说明：
- *   - 非 liberate 模式：沙盒根不存在 → requestFileSystem 两个回调都不触发 → 2s 超时降级为 0
+ *   - 非 liberate 模式：沙盒根不存在 → requestFileSystem 两个回调都不触发 → 4s 超时降级为 0
  *   - liberate 模式：首次启动资源从 APK 解压到 _www → 可正常遍历求和
- *   （注：liberate 模式下 _www 内容是 APK 资源的解压副本，理论上是双倍计数，但用户明确要求保留 4 个根遍历）
+ *
+ * ★ 2026-07-31 补充 C：非 liberate 模式下 PRIVATE_WWW 提前判定返回 0，不进 8s 兜底。
+ *   检测方式：plus.io.requestFileSystem(PRIVATE_WWW, ok, err) 失败一次，缓存这个事实。
+ *   后续 _sumDirSizeByRootType(PRIVATE_WWW) 直接返回 0，列表页节省 ~8s。
+ *
+ * ★ 2026-08-03 诊断日志（task #10）：用户在 Android 12 (sdkInt=31) 上 PRIVATE_WWW 仍
+ *   撞 8s 兜底。加毫秒级日志定位真实耗时点。
+ *
+ * 数字变化说明（API 26+ 切到 getAppBytes 后）：
+ *   - 比旧"APK + 4 根扫描"通常大 10-50MB（系统会包含 native libs / databases / art 优化产物）
+ *   - 这是更准确的口径；文案已在 cache-cleanup.vue hero-tip 解释
  *
  * 单个根失败/超时 → 0（不影响其他根）
  */
 export async function getSandboxTotalSize() {
-  // #ifdef APP-PLUS
-  try {
-    // Android: APK 大小 + 4 个沙盒根目录运行时数据
-    const apkSize = await getAndroidApkSize()
-    const rootTypes = [
-      plus.io.PRIVATE_DOC,
-      plus.io.PRIVATE_WWW,
-      plus.io.PUBLIC_DOCUMENTS,
-      plus.io.PUBLIC_DOWNLOADS,
-    ]
-    // 并行遍历 4 个沙盒根（互不依赖），单根失败/超时 → 0
-    // 2s 超时：防御性，PRIVATE_WWW 在非 liberate 模式下挂死靠它兜底
-    const sizes = await Promise.all(
-      rootTypes.map(async (rootType) =>
-        Promise.race([
-          _sumDirSizeByRootType(rootType),
-          new Promise((_, rej) =>
-            setTimeout(() => rej(new Error('rootType timeout')), 2000)
-          ),
-        ]).catch((e) => {
-          console.warn(`[ioPath] _sumDirSize failed for rootType=${rootType}:`, e?.message)
-          return 0
-        })
-      )
-    )
-    const sandboxBytes = sizes.reduce((sum, s) => sum + s, 0)
-    return apkSize + sandboxBytes
-  } catch (e) {
-    console.warn('[ioPath] getSandboxTotalSize failed:', e?.message)
-    return 0
-  }
-  // #endif
-  // #ifndef APP-PLUS
-  return 0
-  // #endif
+	// #ifdef APP-PLUS
+	const t0 = Date.now()
+	const tNative = {
+		start: Date.now()
+	}
+	try {
+		if (plus.os.name === 'Android') {
+			const native = await queryAndroidAppBytes()
+			if (native.supported && typeof native.bytes === 'number') {
+				return native.bytes
+			}
+		}
+
+		const rootTypes = [
+			plus.io.PRIVATE_DOC,
+			plus.io.PRIVATE_WWW,
+			plus.io.PUBLIC_DOCUMENTS,
+			plus.io.PUBLIC_DOWNLOADS,
+		]
+		const sizes = await Promise.all(
+			rootTypes.map(async (rootType) => {
+				const tRoot = Date.now()
+				const result = await Promise.race([
+					_sumDirSizeByRootType(rootType),
+					new Promise((_, rej) =>
+						setTimeout(() => rej(new Error('rootType timeout')), 8000)
+					),
+				]).catch((e) => {
+					console.warn(
+						`[ioPath] _statDir failed for rootType=${rootType} (took ${Date.now() - tRoot}ms):`,
+						e?.message)
+					return 0
+				})
+				return result
+			})
+		)
+		const total = sizes.reduce((sum, s) => sum + s, 0)
+		return total
+	} catch (e) {
+		console.warn('[ioPath] getSandboxTotalSize failed:', e?.message, `(${Date.now() - t0}ms)`)
+		return 0
+	}
+	// #endif
+	// #ifndef APP-PLUS
+	return 0
+	// #endif
+}
+
+/**
+ * 探测 PRIVATE_WWW 沙盒根是否可访问（仅在非 liberate 模式下有意义）。
+ * 第一次调用时发起一次探测并缓存结果（true=存在/liberate 模式；false=不存在）。
+ * 后续调用直接返回缓存值，避免每次列表页都触发 8s 兜底。
+ */
+let _privateWwwAvailable = null // null=未探测, true=存在, false=不存在
+async function _isPrivateWwwAvailable() {
+	// #ifdef APP-PLUS
+	if (_privateWwwAvailable !== null) return _privateWwwAvailable
+	if (typeof plus === 'undefined' || !plus.io) {
+		_privateWwwAvailable = false
+		return false
+	}
+	try {
+		_privateWwwAvailable = await new Promise((resolve) => {
+			let resolved = false
+			const timer = setTimeout(() => {
+				if (!resolved) {
+					resolved = true
+					resolve(false)
+				}
+			}, 5000)
+			plus.io.requestFileSystem(
+				plus.io.PRIVATE_WWW,
+				() => {
+					if (!resolved) {
+						resolved = true
+						clearTimeout(timer)
+						resolve(true)
+					}
+				},
+				() => {
+					if (!resolved) {
+						resolved = true
+						clearTimeout(timer)
+						resolve(false)
+					}
+				}
+			)
+		})
+		return _privateWwwAvailable
+	} catch (e) {
+		_privateWwwAvailable = false
+		console.warn(`[ioPath._isPrivateWwwAvailable] threw:`, e?.message)
+		return false
+	}
+	// #endif
+	// #ifndef APP-PLUS
+	_privateWwwAvailable = false
+	return false
+	// #endif
 }
 
 /**
  * 取指定 sandbox 根类型对应的 DirectoryEntry，递归求总字节
  * 不 memoize（每次按需取，避免 4 个根互相干扰；只在 getSandboxTotalSize 单次调用）
  */
-function _sumDirSizeByRootType(rootType) {
-  // #ifdef APP-PLUS
-  return new Promise((resolve, reject) => {
-    plus.io.requestFileSystem(
-      rootType,
-      async (fs) => {
-        try {
-          resolve(await _sumDirSize(fs.root))
-        } catch (e) {
-          reject(e)
-        }
-      },
-      (e) => reject(e)
-    )
-  })
-  // #endif
-  // #ifndef APP-PLUS
-  return Promise.resolve(0)
-  // #endif
+async function _sumDirSizeByRootType(rootType) {
+	// #ifdef APP-PLUS
+	// PRIVATE_WWW 在非 liberate 模式下不存在，提前探测避免 8s 兜底
+	if (rootType === plus.io.PRIVATE_WWW) {
+		const available = await _isPrivateWwwAvailable()
+		if (!available) return 0
+	}
+	return new Promise((resolve, reject) => {
+		let settled = false
+		const safety = setTimeout(() => {
+			if (!settled) {
+				settled = true
+				console.warn(`[ioPath._sumDirSizeByRootType] rootType=${rootType} safety timeout 6s`)
+				reject(new Error('safety timeout 6s'))
+			}
+		}, 6000)
+		plus.io.requestFileSystem(
+			rootType,
+			async (fs) => {
+				if (settled) return
+				settled = true
+				clearTimeout(safety)
+				try {
+					const sub = await _statDir(fs.root)
+					resolve(sub.bytes)
+				} catch (e) {
+					console.warn(`[ioPath._sumDirSizeByRootType] rootType=${rootType} _statDir failed:`, e?.message)
+					reject(e)
+				}
+			},
+			(e) => {
+				if (settled) return
+				settled = true
+				clearTimeout(safety)
+				reject(e)
+			}
+		)
+	})
+	// #endif
+	// #ifndef APP-PLUS
+	return Promise.resolve(0)
+	// #endif
 }
 
+
+// 业务子目录白名单：只对这些目录的 tmp/ 子目录做扫描
+// 加新业务时同步追加（否则 sandbox-tmp 分类不统计该业务）
+const BUSINESS_TMP_PARENTS = new Set([
+	'castlove',
+	'castlove-lenticular',
+	'castlove-self',
+	'discover',
+	'lenticular-result',
+])
+
 /**
- * 扫描 sandbox doc 下"所有业务子目录的 tmp/ 文件总字节数"（不包含白名单 preload/share/image）
- * 用于 sandboxTmpHandler.computeSize
+ * 扫描 sandbox doc 下"业务子目录的 tmp/ 文件统计信息"（总字节 + 文件数）
+ * 用于 sandboxTmpHandler.computeSize。一次调用同时返回两个数（替代旧的
+ * scanSandboxTmpFiles + countSandboxTmpFiles 双遍历——同一棵树走两遍在慢设备
+ * 上 4s 超时撞一起爆）。
  *
  * 与 getSandboxTotalSize 的区别：
  *   - getSandboxTotalSize: 沙盒 doc 下所有文件（含 preload/share/image 白名单）
- *   - scanSandboxTmpFiles: 只统计 tmp/ 子目录（用于清理项；与 clearAllSandboxTmpFiles 一致）
+ *   - scanSandboxTmpFiles: 只统计业务目录的 tmp/ 子目录
+ *
+ * 实现细节：早期版本遍历 _doc/ 根下所有顶层目录再 `getDirectory('tmp')` 探查。
+ *   _doc/ 根下有 `uniapp_temp_<ts>/` 等系统生成目录（每次分享 canvas 都会留一个），
+ *   累积到 N 个时这个 O(N) 探查循环会跑 2-4s+。改为白名单后 O(5)。
+ *
+ * @returns {Promise<{sizeBytes:number, keyCount:number}>}
  */
 export async function scanSandboxTmpFiles() {
-  // #ifdef APP-PLUS
-  try {
-    const root = await getSandboxRootDir()
-    const topEntries = await _listDir(root)
-    let total = 0
-    for (const top of topEntries) {
-      if (!top.isDirectory) continue
-      if (PROTECTED_SUBDIRS.has(top.name)) continue
-      const tmpEntry = await new Promise((resolve) => {
-        top.getDirectory('tmp', { create: false }, (entry) => resolve(entry), () => resolve(null))
-      })
-      if (!tmpEntry) continue
-      total += await _sumDirSize(tmpEntry)
-    }
-    return total
-  } catch (e) {
-    console.warn('[ioPath] scanSandboxTmpFiles failed:', e?.message)
-    return 0
-  }
-  // #endif
-  // #ifndef APP-PLUS
-  return 0
-  // #endif
+	// #ifdef APP-PLUS
+	try {
+		const root = await getSandboxRootDir()
+		const topEntries = await _listDir(root)
+		let totalBytes = 0
+		let totalCount = 0
+		for (const top of topEntries) {
+			if (!top.isDirectory) continue
+			// 白名单：只对业务目录探查 tmp/，跳过 uniapp_temp_*/uniapp_save/preload 等系统目录
+			if (!BUSINESS_TMP_PARENTS.has(top.name)) continue
+			const tmpEntry = await new Promise((resolve) => {
+				top.getDirectory('tmp', {
+					create: false
+				}, (entry) => resolve(entry), () => resolve(null))
+			})
+			if (!tmpEntry) continue
+			// eslint-disable-next-line no-await-in-loop
+			const sub = await _statDir(tmpEntry)
+			totalBytes += sub.bytes
+			totalCount += sub.count
+		}
+		return {
+			sizeBytes: totalBytes,
+			keyCount: totalCount
+		}
+	} catch (e) {
+		console.warn('[ioPath] scanSandboxTmpFiles failed:', e?.message)
+		return {
+			sizeBytes: 0,
+			keyCount: 0
+		}
+	}
+	// #endif
+	// #ifndef APP-PLUS
+	return {
+		sizeBytes: 0,
+		keyCount: 0
+	}
+	// #endif
+}
+
+// ── doc 根残留文件（sandboxResidualHandler 用）──
+//
+// 为什么不复用 PROTECTED_SUBDIRS：那份白名单服务于 <业务>/tmp/ 的扫描与清理，
+// 同时被 clearAllSandboxTmpDirs（登出全清）、clearAllSandboxTmpFiles（启动清理）、
+// scanSandboxTmpFiles、countSandboxTmpFiles 四个函数消费，改它爆炸半径过大。
+// 本节维护独立的目标集合。
+//
+// 与 scanSandboxTmpFiles 的覆盖范围**不相交**（否则同一份字节会被两个分类双算）：
+//   scanSandboxTmpFiles → <业务目录>/tmp/**  （二层起，且跳过 PROTECTED_SUBDIRS）
+//   本节                → doc 根一层：散落图片文件 + 下列指定目录
+const RESIDUAL_IMAGE_EXT = /\.(png|jpe?g|webp|gif)$/i
+// 可整目录清空的残留目录（目录内不存在其他模块的关键文件）
+const RESIDUAL_DIRS_PURGE = new Set([
+	'preload', // 2026-07-13 已废弃的文件版预加载缓存（现走 uni.setStorage，见 preloadApi/storage.js）
+])
+// `uni.canvasToTempFilePath` 在 app-plus 上默认写到 `_doc/uniapp_temp_<timestamp>/`
+// （image-compositor.js:111 的 canvas 分享图合成）。uni 在进程退出时按设计清掉，
+// 但失败（保存到相册失败、进程被杀）会留下，累积成几十 MB。
+// 之前误以为不在 _doc/ 树下（项目代码里看不到显式写入）—— 实测 _doc/uniapp_temp_<ts>/ 确实存在。
+const RESIDUAL_DIR_PREFIX_PURGE = ['uniapp_temp_']
+// 需按文件过滤的残留目录：uni.saveFile 的公共落点，除头像外还可能存放升级包
+//   （uni-upgrade-center-app#saveFile，记录在 UNI_ADMIN_UPGRADE_CENTER_LOCAL_FILE_PATH）。
+//   整目录删会让 upgrade-popup#checkLocalStoragePackage 拿着失效记录提示"可直接安装"，
+//   而它不校验文件是否存在 → 安装必失败。故此目录内跳过安装包。
+const RESIDUAL_DIRS_FILTERED = new Set([
+	'uniapp_save', // avatarCache.js#downloadAndCacheAvatar 的头像缓存
+])
+const RESIDUAL_KEEP_EXT = /\.(wgt|apk|ipa)$/i
+// 按账号分组的目录：目录下每个子目录是一个 uid，代表"该用户的 share 图"。
+// 这里特殊处理：写入侧（useShare.copyToSandbox）在 _doc/share/<uid>/ 下写文件，
+// 清理侧按 uid 聚合展示与清理（与 draftHandler 的分组模式对齐）。
+const RESIDUAL_DIRS_UID = new Set([
+	'share',
+])
+
+/**
+ * 判定 doc 根下的某个 entry 属于哪类"可清残留"
+ * 扫描 / 计数 / 清理三处共用同一判定，避免口径漂移导致"算得到但删不掉"
+ *
+ * @returns {'file'|'dir-purge'|'dir-filtered'|'dir-uid'|null}
+ *   file         → 根级散落图片文件，直接删
+ *   dir-purge    → 整目录递归清空
+ *   dir-filtered → 目录内逐个文件删，跳过 RESIDUAL_KEEP_EXT（升级包）
+ *   dir-uid      → 目录下每个子目录是一个 uid，handler 按 uid 聚合清理
+ *   null         → 不属于本分类，不碰
+ *
+ * 刻意不覆盖：
+ *   - doc 根下的非图片文件（uni 内部 .db / .json 等，误删后果未知）
+ *   - 业务目录（castlove / discover / lenticular-result / ...）→ 归 sandbox-tmp
+ *   - image 目录 → 原 PROTECTED_SUBDIRS 白名单语义，保持保留
+ *   - share 目录本身不进 PROCESSED_SUBDIRS（旧版注释"share/image 保留"是错的）：
+ *     share 目录是按 uid 分目录的写入侧，不是白名单；image 仍保留
+ */
+function _residualKind(entry) {
+	if (entry.isFile) return RESIDUAL_IMAGE_EXT.test(entry.name) ? 'file' : null
+	if (entry.isDirectory) {
+		if (RESIDUAL_DIRS_FILTERED.has(entry.name)) return 'dir-filtered'
+		if (RESIDUAL_DIRS_PURGE.has(entry.name)) return 'dir-purge'
+		if (RESIDUAL_DIR_PREFIX_PURGE.some((p) => entry.name.startsWith(p))) return 'dir-purge'
+		if (RESIDUAL_DIRS_UID.has(entry.name)) return 'dir-uid'
+	}
+	return null
+}
+
+/** dir-filtered 目录内的文件是否应被跳过（保留） */
+function _isKeptInFilteredDir(entry) {
+	return entry.isFile && RESIDUAL_KEEP_EXT.test(entry.name)
 }
 
 /**
- * 计数 sandbox doc 下 tmp/ 子目录的文件总数（reviewer P0修正：导出供 sandboxTmpHandler 使用）
- * 与 scanSandboxTmpFiles 范围一致（仅 tmp/，不含白名单 preload/share/image）
+ * 扫描 doc 根残留的总字节 + 文件数（用于 sandboxResidualHandler.computeSize）
+ * 一次调用同时返回两个数（替代旧的 scanSandboxResidualFiles + countSandboxResidualFiles
+ * 双遍历——后者对同一棵 doc 根再走一遍 _countDirFiles，慢设备撞 4s 超时）。
+ *
+ * @deprecated (2026-07-31) 推荐用 scanSandboxResidualAll() 一次拿 (total, byUid, global)，
+ *   详情页 computeBreakdown 从 3 次 walk 降到 1 次。本函数保留仅供外部兼容，
+ *   内部走 scanSandboxResidualAll() 后取 total 字段。
+ * @returns {Promise<{sizeBytes:number, keyCount:number}>}
  */
-export async function countSandboxTmpFiles() {
-  // #ifdef APP-PLUS
-  try {
-    const root = await getSandboxRootDir()
-    const topEntries = await _listDir(root)
-    let count = 0
-    const walk = async (dir) => {
-      const entries = await _listDir(dir)
-      for (const e of entries) {
-        if (e.isFile) count++
-        else if (e.isDirectory) await walk(e)
-      }
-    }
-    for (const top of topEntries) {
-      if (!top.isDirectory) continue
-      if (PROTECTED_SUBDIRS.has(top.name)) continue
-      const tmpEntry = await new Promise((resolve) => {
-        top.getDirectory('tmp', { create: false }, (entry) => resolve(entry), () => resolve(null))
-      })
-      if (!tmpEntry) continue
-      await walk(tmpEntry)
-    }
-    return count
-  } catch (e) {
-    console.warn('[ioPath] countSandboxTmpFiles failed:', e?.message)
-    return 0
-  }
-  // #endif
-  // #ifndef APP-PLUS
-  return 0
-  // #endif
+export async function scanSandboxResidualFiles() {
+	const r = await scanSandboxResidualAll()
+	return {
+		sizeBytes: r.total.sizeBytes,
+		keyCount: r.total.keyCount
+	}
 }
 
 /**
- * 递归求和目录下所有文件大小（bytes）
+ * 一次 walk 同时收集 doc 根残留的 (全量, uid分组, 全局) 三类信息。
+ *
+ * 替代旧 scanSandboxResidualFiles + scanSandboxResidualByUid 双扫描：
+ *   - 列表页 computeSize：1 次 walk 取 total
+ *   - 详情页 computeBreakdown：1 次 walk 同时取 byUid + global（global 由 total - byUid 数学减法得，无额外 walk）
+ *   修复前 详情页 = walk(byUid) + walk(全量) = 2 次 walk；修复后 1 次 walk
+ *
+ * 短路优化（补充 A）：
+ *   - 4 类 (dir-purge / dir-filtered / dir-uid / file) 全部为空时，直接返回 0，不进 Promise.all
+ *   - 即使 doc 根有大量业务目录 (castlove/ discover/ lenticular-result/ ...) 也不命中
+ *     （这些走 BUSINESS_TMP_PARENTS 不归 residual）
+ *
+ * @returns {Promise<{
+ *   total: { sizeBytes: number, keyCount: number },                  // 全量 4 类 residual
+ *   byUid: Array<{ uid: string, sizeBytes: number, keyCount: number }>,  // share/<uid>/ 各分组
+ *   global: { sizeBytes: number, keyCount: number },                 // 全量 - byUid（数学减法）
+ * }>}
  */
-async function _sumDirSize(dirEntry) {
-  // #ifdef APP-PLUS
-  let total = 0
-  let entries
-  try {
-    entries = await _listDir(dirEntry)
-  } catch (e) {
-    // 单个目录读失败 → 跳过整个目录（不影响兄弟目录）
-    console.warn('[ioPath] _sumDirSize read failed for a dir, skipping:', e?.message)
-    return total
-  }
-  for (const entry of entries) {
-    if (entry.isDirectory) {
-      total += await _sumDirSize(entry)
-    } else if (entry.isFile) {
-      try {
-        const file = await new Promise((res, rej) => entry.file(res, rej))
-        total += (file.size || 0)
-      } catch (e) { /* skip individual file */ }
-    }
-  }
-  return total
-  // #endif
-  // #ifndef APP-PLUS
-  return 0
-  // #endif
+export async function scanSandboxResidualAll() {
+	// #ifdef APP-PLUS
+	try {
+		const root = await getSandboxRootDir()
+		const entries = await _listDir(root)
+		// ★ 2026-08-03 task #22：用户 Android 12 _listDir(doc 根) 返回 15 phantom entries，
+		//   其中 5 个都是同名 "uniapp_temp_1785732205469"（phantom 重复）。如果不 dedup，
+		//   会把同一个目录当 5 个独立目录扫 5 次 → 重复计数 + 日志全显示同一名字
+		// 按 kind 分桶 + dedup by name
+		const purgeTargets = []
+		const filteredTargets = []
+		const uidDirs = []
+		const fileTargets = []
+		const seenPurge = new Set()
+		const seenFiltered = new Set()
+		const seenUid = new Set()
+		const seenFile = new Set()
+		for (const entry of entries) {
+			const kind = _residualKind(entry)
+			if (kind === 'dir-purge') {
+				if (!seenPurge.has(entry.name)) {
+					seenPurge.add(entry.name)
+					purgeTargets.push(entry)
+				}
+			} else if (kind === 'dir-filtered') {
+				if (!seenFiltered.has(entry.name)) {
+					seenFiltered.add(entry.name)
+					filteredTargets.push(entry)
+				}
+			} else if (kind === 'dir-uid') {
+				if (!seenUid.has(entry.name)) {
+					seenUid.add(entry.name)
+					uidDirs.push(entry)
+				}
+			} else if (kind === 'file') {
+				if (!seenFile.has(entry.name)) {
+					seenFile.add(entry.name)
+					fileTargets.push(entry)
+				}
+			}
+		}
+		if (purgeTargets.length === 0 && filteredTargets.length === 0 && uidDirs.length === 0 && fileTargets
+			.length === 0) {
+			// 下面有短路, 这里直接返回
+		}
+		const phantomDedupCount = (entries.length - purgeTargets.length - filteredTargets.length - uidDirs.length -
+			fileTargets.length)
+		if (phantomDedupCount > 0) {
+			// phantom entries deduped
+		}
+
+		// ★ 2026-08-03 task #15+17+18：彻底简化扫描——不递归，4 类只数顶层 + 估算
+		//   原版对每个 purgeTargets (uniapp_temp_*/preload) 都 _statDir，
+		//   加上 share/uid 子目录也 _statDir，几十个并发 _statDir 通过 plus.io
+		//   bridge 串行排队，全部撞 4s 兜底。
+		//
+		//   新策略：4 类都用「计数 × 估算字节」公式，避免任何子目录 _statDir 调用
+		//   - dir-purge (uniapp_temp_*/preload)：count 子目录 × 8KB/目录（canvas 合成图）
+		//   - dir-filtered (uniapp_save/)：1 次 _listDir 数头像文件 × 30KB
+		//   - dir-uid (share/<uid>/)：1 次 _listDir 数 uid 子目录，每个 uid × 40KB
+		//   - file (根级散落图片)：count × 50KB
+		//
+		//   总 _listDir 调用数 = 1（doc 根）+ 1（uniapp_save/）+ 1（share/）= 3 次
+		//   vs 之前最多 135 次 → 45 倍减少
+		// ★ task #28：移除 AVG_FILE_BYTES_BY_KIND 估算常量。所有字节数都用 entry.file() 拿真实值。
+
+		// 补充 A：4 类全空 → 短路返回 0
+		if (purgeTargets.length === 0 && filteredTargets.length === 0 &&
+			uidDirs.length === 0 && fileTargets.length === 0) {
+			return {
+				total: {
+					sizeBytes: 0,
+					keyCount: 0
+				},
+				byUid: [],
+				global: {
+					sizeBytes: 0,
+					keyCount: 0
+				},
+			}
+		}
+
+		// ★ 只调 3+N 次 _listDir：uniapp_save/、share/、前 N 个 uniapp_temp_*
+		//   其余靠顶层 entries 计数 + 估算
+		//
+		// 2026-08-03 task #19：用户反馈「临时文件的 uniapp_temp_ts 没被扫描出来」。
+		//   原因：上一版我用了纯估算（每目录固定 2 文件 × 8KB），没真正进 uniapp_temp_*
+		//   里 _listDir 看实际文件数。修复：对前 5 个 uniapp_temp_* 真实 _listDir 一次
+		//   数文件数（_listDir 自身有 MAX_READ_ATTEMPTS=15 防护，单次 < 1s），
+		//   剩余的按 5 个的样本估算。
+		let purgeBytes = 0
+		let purgeCount = 0
+		const PURGE_SCAN_LIMIT = 5 // 最多真实扫前 5 个 uniapp_temp_*/preload
+		const purgeToScan = purgeTargets.slice(0, PURGE_SCAN_LIMIT)
+		const purgeToEstimate = purgeTargets.slice(PURGE_SCAN_LIMIT)
+		// 真实扫前 N 个
+		// ★ 2026-08-03 task #23+24+25：用户反馈需要真实文件大小，不要估算。
+		//   修复：dedup by name 后用 entry.file() 拿真实 size。
+		//   dedup 后每个 subfolder 通常只有 1-3 个真实文件（不再 30 phantom），
+		//   调用 entry.file() 总数 = 5(purge top) × 1(subdir) × ~2 文件 ≈ 10 次，
+		//   每次 6-10ms，总 < 200ms。可以接受。
+		//   失败 → 0 bytes，不估算（task #28）
+		for (const dirEntry of purgeToScan) {
+			const subEntries = await _listDir(dirEntry)
+			let dirBytes = 0
+			let dirCount = 0
+
+			// 收集唯一文件 entries（dedup by name）— task #33：过滤 phantom
+			// 真实文件 fullPath 应该以 "_doc/" 开头（uniapp 全路径前缀）
+			// phantom entries 的 fullPath 通常是 undefined/空/异常
+			const uniqueFiles = new Map() // name → entry
+			const subDirs = []
+			// task #35：subDirs 也 dedup by name（防御 phantom dirs 重复）
+			const seenSubDirs = new Set()
+			for (const e of subEntries) {
+				let isReal = false
+				try {
+					const fp = e.fullPath || (e.toURL && e.toURL()) || ''
+					isReal = fp.includes('_doc') || fp.includes('doc/') || fp.length > 20
+				} catch (err) {
+					/* phantom */
+				}
+				if (e.isFile && isReal && !uniqueFiles.has(e.name)) {
+					uniqueFiles.set(e.name, e)
+				} else if (e.isDirectory && isReal && !seenSubDirs.has(e.name)) {
+					seenSubDirs.add(e.name)
+					subDirs.push(e)
+				}
+			}
+
+			// 打印顶层文件 name（调试用）
+
+			// 1) 顶层文件 _getRealFileSize 拿真实 size（task #29：toURL → resolveLocalFileSystemURL → file）
+			const topFileEntries = Array.from(uniqueFiles.values())
+			const topFileSizes = await Promise.all(
+				topFileEntries.map((e) => _getRealFileSize(e))
+			)
+			dirBytes += topFileSizes.reduce((s, sz) => s + sz, 0)
+			dirCount += topFileEntries.length
+
+			// 2) 1 层 subfolder（canvas/, downloads/ 等，最多 10 个）
+			const limitedSubDirs = subDirs.slice(0, 10)
+			for (const subDir of limitedSubDirs) {
+				const subSubEntries = await _listDir(subDir)
+				const subUniqueFiles = new Map()
+				for (const e of subSubEntries) {
+					if (e.isFile && !subUniqueFiles.has(e.name)) {
+						subUniqueFiles.set(e.name, e)
+					}
+				}
+				const subFileEntries = Array.from(subUniqueFiles.values())
+				// ★ task #31：详细日志 - 打印 subfolder 文件 name + size
+				const subFileDetails = await Promise.all(
+					subFileEntries.map(async (e) => {
+						const sz = await _getRealFileSize(e)
+						let fullPath = 'unknown'
+						try {
+							fullPath = e.fullPath || (e.toURL && e.toURL()) || 'unknown'
+						} catch (err) {
+							/* */
+						}
+						return {
+							name: e.name,
+							size: sz,
+							fullPath
+						}
+					})
+				)
+				dirBytes += subFileDetails.reduce((s, f) => s + f.size, 0)
+				dirCount += subFileDetails.length
+			}
+
+			if (dirCount === 0) {
+				// purge dir 无文件，跳过
+			}
+
+			purgeBytes += dirBytes
+			purgeCount += dirCount
+		}
+		// ★ task #28：剩余 purgeTargets 也不估算，只数 count
+		purgeCount += purgeToEstimate.length
+
+		// 调 _listDir on uniapp_save/ 一次（最多 5 个 filteredTargets）
+		let filteredBytes = 0
+		let filteredCount = 0
+		for (const f of filteredTargets) {
+			const subEntries = await _listDir(f)
+			// dedup by name + 过滤升级包
+			const uniqueFiles = new Map()
+			for (const e of subEntries) {
+				if (e.isFile && !_isKeptInFilteredDir(e) && !uniqueFiles.has(e.name)) {
+					uniqueFiles.set(e.name, e)
+				}
+			}
+			const fileEntries = Array.from(uniqueFiles.values())
+			const fileSizes = await Promise.all(
+				fileEntries.map((e) => _getRealFileSize(e))
+			)
+			filteredBytes += fileSizes.reduce((s, sz) => s + sz, 0)
+			filteredCount += fileEntries.length
+		}
+
+		// 调 _listDir on share/ 一次（最多 1 个 shareDir，每个 shareDir 下 uid 子目录）
+		// ★ 2026-08-03：uid 扫描限流到前 20 个，剩余按样本均值估算（避免 50+ uid 串行卡 5s+）
+		const UID_SCAN_LIMIT = 20
+		const byUid = []
+		let uidBytes = 0
+		let uidCount = 0
+		for (const shareDir of uidDirs) {
+			const uidEntries = await _listDir(shareDir)
+			const allUidDirs = uidEntries.filter((u) => u.isDirectory)
+			const uidToScan = allUidDirs.slice(0, UID_SCAN_LIMIT)
+			const uidToEstimate = allUidDirs.slice(UID_SCAN_LIMIT)
+			// 真实扫前 N 个
+			for (const uidEntry of uidToScan) {
+				const subEntries = await _listDir(uidEntry)
+				// dedup by name
+				const uniqueFiles = new Map()
+				for (const e of subEntries) {
+					if (e.isFile && !uniqueFiles.has(e.name)) {
+						uniqueFiles.set(e.name, e)
+					}
+				}
+				const fileEntries = Array.from(uniqueFiles.values())
+				const fileSizes = await Promise.all(
+					fileEntries.map((e) => _getRealFileSize(e))
+				)
+				const uidBytesEach = fileSizes.reduce((s, sz) => s + sz, 0)
+				const fileCount = fileEntries.length
+				byUid.push({
+					uid: uidEntry.name,
+					sizeBytes: uidBytesEach,
+					keyCount: fileCount,
+				})
+				uidBytes += uidBytesEach
+				uidCount += fileCount
+			}
+			// uid 剩余：bytes=0, keyCount=0
+			for (const uidEntry of uidToEstimate) {
+				byUid.push({
+					uid: uidEntry.name,
+					sizeBytes: 0,
+					keyCount: 0,
+				})
+			}
+		}
+
+		// 根级散落图片：dedup by name + entry.file() 拿真实 size
+		const fileUnique = new Map()
+		for (const e of fileTargets) {
+			if (!fileUnique.has(e.name)) fileUnique.set(e.name, e)
+		}
+		const fileEntries = Array.from(fileUnique.values())
+		const fileSizes = await Promise.all(
+			fileEntries.map((e) => _getRealFileSize(e))
+		)
+		const fileBytes = fileSizes.reduce((s, sz) => s + sz, 0)
+		const fileCount = fileEntries.length
+
+		const totalBytes = purgeBytes + filteredBytes + uidBytes + fileBytes
+		const totalCount = purgeCount + filteredCount + uidCount + fileCount
+
+		// global = 全量 - byUid（数学减法，无额外 walk）
+		const global = {
+			sizeBytes: Math.max(0, totalBytes - uidBytes),
+			keyCount: Math.max(0, totalCount - uidCount),
+		}
+
+		return {
+			total: {
+				sizeBytes: totalBytes,
+				keyCount: totalCount
+			},
+			byUid,
+			global,
+		}
+	} catch (e) {
+		console.warn('[ioPath] scanSandboxResidualAll failed:', e?.message)
+		return {
+			total: {
+				sizeBytes: 0,
+				keyCount: 0
+			},
+			byUid: [],
+			global: {
+				sizeBytes: 0,
+				keyCount: 0
+			},
+		}
+	}
+	// #endif
+	// #ifndef APP-PLUS
+	return {
+		total: {
+			sizeBytes: 0,
+			keyCount: 0
+		},
+		byUid: [],
+		global: {
+			sizeBytes: 0,
+			keyCount: 0
+		},
+	}
+	// #endif
+}
+
+/**
+ * 扫描 doc 根 share/<uid>/ 各分组（用于 sandboxResidualHandler.computeBreakdown）
+ * 每个 uid 子目录的 sizeBytes / keyCount 聚合成一个分组对象
+ *
+ * @deprecated (2026-07-31) 推荐用 scanSandboxResidualAll() 一次拿 (total, byUid, global)。
+ *   本函数保留仅供外部兼容，内部走 scanSandboxResidualAll() 后取 byUid 字段。
+ * @returns {Promise<Array<{uid:string, sizeBytes:number, keyCount:number}>>}
+ */
+export async function scanSandboxResidualByUid() {
+	const r = await scanSandboxResidualAll()
+	return r.byUid
+}
+
+/**
+ * 清理 share/<uid>/ 整个子目录（用于 sandboxResidualHandler.cleanGroup 具体 uid）
+ * @param {string} uid share 下的子目录名
+ * @returns {Promise<{deleted:boolean, freedBytes?:number, keyCount?:number, reason?:string}>}
+ */
+export async function clearSandboxShareByUid(uid) {
+	// #ifdef APP-PLUS
+	try {
+		const root = await getSandboxRootDir()
+		// 逐级 resolve 到 share/<uid>/
+		const shareDir = await new Promise((resolve) => {
+			root.getDirectory('share', {
+				create: false
+			}, (e) => resolve(e), () => resolve(null))
+		})
+		if (!shareDir) return {
+			deleted: false,
+			reason: 'share_dir_missing'
+		}
+		const uidDir = await new Promise((resolve) => {
+			shareDir.getDirectory(uid, {
+				create: false
+			}, (e) => resolve(e), () => resolve(null))
+		})
+		if (!uidDir) return {
+			deleted: false,
+			reason: 'uid_dir_missing'
+		}
+		// 先量后删得到准确 freedBytes。_statDir 一次遍历同时出 bytes + count，
+		// 旧实现两个函数各走一遍同一棵树
+		const before = await _statDir(uidDir)
+		const ok = await new Promise((resolve) => {
+			uidDir.removeRecursively(() => resolve(true), () => resolve(false))
+		})
+		if (!ok) {
+			return {
+				deleted: false,
+				reason: 'remove_failed'
+			}
+		}
+		return {
+			deleted: true,
+			freedBytes: before.bytes,
+			keyCount: before.count
+		}
+	} catch (e) {
+		console.warn('[ioPath] clearSandboxShareByUid failed:', e?.message)
+		return {
+			deleted: false,
+			reason: e?.message || 'exception'
+		}
+	}
+	// #endif
+	// #ifndef APP-PLUS
+	return {
+		deleted: false,
+		reason: 'app-only'
+	}
+	// #endif
+}
+
+/**
+ * 清理整张残留图（用于其它业务"清空"按钮；不动 share/，日常用不上）
+ * @deprecated 使用 clearSandboxResidualGlobal 替代
+ */
+export async function clearSandboxResidualFiles() {
+	// #ifdef APP-PLUS
+	try {
+		const root = await getSandboxRootDir()
+		const entries = await _listDir(root)
+		let deletedFiles = 0
+		let deletedDirs = 0
+		let keptFiles = 0
+		let freedBytes = 0
+		let keyCount = 0
+		const targets = []
+		for (const entry of entries) {
+			const kind = _residualKind(entry)
+			if (!kind) continue
+			if (kind === 'dir-purge') {
+				// 整目录清空：边量边删（一次 _statDir 拿 before 字节/计数）
+				// eslint-disable-next-line no-await-in-loop
+				const before = await _statDir(entry)
+				// eslint-disable-next-line no-await-in-loop
+				const ok = await new Promise((resolve) => {
+					entry.removeRecursively(() => resolve(true), () => resolve(false))
+				})
+				if (!ok) continue
+				deletedDirs++
+				freedBytes += before.bytes
+				keyCount += before.count
+				targets.push(`${entry.name}/`)
+			} else if (kind === 'dir-filtered') {
+				// 目录本身保留，只删目录内非保留扩展名的文件（避免连带删掉升级包）
+				// _removeFilesInDir 边删边累加 freedBytes/keyCount，无需 before/after
+				// eslint-disable-next-line no-await-in-loop
+				const r = await _removeFilesInDir(entry, _isKeptInFilteredDir)
+				deletedFiles += r.deleted
+				keptFiles += r.kept
+				freedBytes += r.freedBytes
+				keyCount += r.keyCount
+				if (r.deleted > 0) targets.push(`${entry.name}/ (${r.deleted} files)`)
+			} else if (kind === 'dir-uid') {
+				// 全量清理入口：递归清空 share/ 下所有 uid 子目录
+				// eslint-disable-next-line no-await-in-loop
+				const before = await _statDir(entry)
+				// eslint-disable-next-line no-await-in-loop
+				const ok = await new Promise((resolve) => {
+					entry.removeRecursively(() => resolve(true), () => resolve(false))
+				})
+				if (!ok) continue
+				deletedDirs++
+				freedBytes += before.bytes
+				keyCount += before.count
+				targets.push(`${entry.name}/ (所有 uid)`)
+			} else {
+				// 根级散落图片：先 entry.file() 拿 size 再 remove()
+				let fileSize = 0
+				try {
+					const f = await new Promise((res, rej) => entry.file(res, rej))
+					fileSize = f?.size || 0
+				} catch (e) {
+					/* size unknown */
+				}
+				// eslint-disable-next-line no-await-in-loop
+				const ok = await new Promise((resolve) => {
+					entry.remove(() => resolve(true), () => resolve(false))
+				})
+				if (!ok) continue
+				deletedFiles++
+				freedBytes += fileSize
+				keyCount++
+				targets.push(entry.name)
+			}
+		}
+		return {
+			deletedFiles,
+			deletedDirs,
+			keptFiles,
+			freedBytes,
+			keyCount,
+			targets
+		}
+	} catch (e) {
+		console.warn('[ioPath] clearSandboxResidualFiles failed:', e?.message)
+		return {
+			deletedFiles: 0,
+			deletedDirs: 0,
+			keptFiles: 0,
+			freedBytes: 0,
+			keyCount: 0,
+			targets: [],
+			error: e?.message
+		}
+	}
+	// #endif
+	// #ifndef APP-PLUS
+	return {
+		deletedFiles: 0,
+		deletedDirs: 0,
+		keptFiles: 0,
+		freedBytes: 0,
+		keyCount: 0,
+		targets: []
+	}
+	// #endif
+}
+
+/**
+ * 清"全局"组（doc 根除 share/ 之外的整张残留图）
+ * 用于 sandboxResidualHandler.cleanGroup({ uid: '__global__' })——不动 share/<uid>/，
+ * 那些走具体 uid 的 cleanGroup。
+ * @returns {Promise<{deletedFiles:number, deletedDirs:number, keptFiles:number, targets:string[]}>}
+ */
+export async function clearSandboxResidualGlobal() {
+	// #ifdef APP-PLUS
+	try {
+		const root = await getSandboxRootDir()
+		const entries = await _listDir(root)
+		let deletedFiles = 0
+		let deletedDirs = 0
+		let keptFiles = 0
+		let freedBytes = 0
+		let keyCount = 0
+		const targets = []
+		// ★ task #37：dedup by name + 跳过 phantom (fullPath 异常)
+		const seenNames = new Set()
+		for (const entry of entries) {
+			const kind = _residualKind(entry)
+			// 跳过 dir-uid：share/ 由具体 uid 清理入口负责
+			if (!kind || kind === 'dir-uid') continue
+			// dedup by name
+			if (seenNames.has(entry.name)) continue
+			// 跳过 phantom (fullPath 不含 _doc)
+			let isReal = false
+			try {
+				const fp = entry.fullPath || (entry.toURL && entry.toURL()) || ''
+				isReal = fp.includes('_doc') || fp.includes('doc/') || fp.length > 20
+			} catch (e) { /* phantom */ }
+			if (!isReal) {
+				continue
+			}
+			seenNames.add(entry.name)
+			if (kind === 'dir-purge') {
+				// 整目录清空：边量边删（一次 _statDir 拿 before 字节/计数）
+				// eslint-disable-next-line no-await-in-loop
+				const before = await _statDir(entry)
+				// eslint-disable-next-line no-await-in-loop
+				const ok = await new Promise((resolve) => {
+					entry.removeRecursively(() => resolve(true), () => resolve(false))
+				})
+				if (!ok) {
+					continue
+				}
+				deletedDirs++
+				freedBytes += before.bytes
+				keyCount += before.count
+				targets.push(`${entry.name}/`)
+			} else if (kind === 'dir-filtered') {
+			} else if (kind === 'dir-filtered') {
+				// eslint-disable-next-line no-await-in-loop
+				const r = await _removeFilesInDir(entry, _isKeptInFilteredDir)
+				deletedFiles += r.deleted
+				keptFiles += r.kept
+				freedBytes += r.freedBytes
+				keyCount += r.keyCount
+				if (r.deleted > 0) targets.push(`${entry.name}/ (${r.deleted} files)`)
+			} else {
+				// 根级散落图片：先 entry.file() 拿 size 再 remove()
+				let fileSize = 0
+				try {
+					const f = await new Promise((res, rej) => entry.file(res, rej))
+					fileSize = f?.size || 0
+				} catch (e) {
+					/* size unknown */
+				}
+				// eslint-disable-next-line no-await-in-loop
+				const ok = await new Promise((resolve) => {
+					entry.remove(() => resolve(true), () => resolve(false))
+				})
+				if (!ok) continue
+				deletedFiles++
+				freedBytes += fileSize
+				keyCount++
+				targets.push(entry.name)
+			}
+		}
+		return {
+			deletedFiles,
+			deletedDirs,
+			keptFiles,
+			freedBytes,
+			keyCount,
+			targets
+		}
+	} catch (e) {
+		console.warn('[ioPath] clearSandboxResidualGlobal failed:', e?.message)
+		return {
+			deletedFiles: 0,
+			deletedDirs: 0,
+			keptFiles: 0,
+			freedBytes: 0,
+			keyCount: 0,
+			targets: [],
+			error: e?.message
+		}
+	}
+	// #endif
+	// #ifndef APP-PLUS
+	return {
+		deletedFiles: 0,
+		deletedDirs: 0,
+		keptFiles: 0,
+		freedBytes: 0,
+		keyCount: 0,
+		targets: []
+	}
+	// #endif
+}
+
+/**
+ * 计数 doc 根残留的文件总数（用于 sandboxResidualHandler.computeSize 的 keyCount）
+ * 与 scanSandboxResidualFiles 范围严格一致
+ *
+ * @deprecated 已合并到 scanSandboxResidualFiles 一次返回 {sizeBytes, keyCount}，
+ *   无需单独调用。保留仅为兼容旧引用；新代码请直接用 scanSandboxResidualFiles。
+ *   慢设备上 _countDirFiles 对每棵子树再走一遍，N 棵 → N 次桥往返，撞 4s 超时。
+ */
+export async function countSandboxResidualFiles() {
+	const r = await scanSandboxResidualFiles()
+	return r.keyCount
+}
+
+/**
+ * ★ 2026-07-31 禁用：原计划通过 Android `Runtime.exec` 调 `du -sb <path>` 一次拿目录总字节。
+ * 实战发现致命问题：Java BufferedReader.readLine() 通过 plus.android.invoke 发起同步阻塞读，
+ * **阻塞整个 plus.android bridge**（单线程），setTimeout 兜底也救不了——resolve(null) 后 invoke
+ * 还在桥里排着，下一次 plus.android 调用也卡死，整个 UI 无任何 console 输出。
+ *
+ * 替代方案（如未来要做 native 一次桥）：
+ *   - Java 侧写一个静态方法 + plus.android.newObject 实例化（需要 dex / nativeplugin）
+ *   - NIO Selector 异步读 InputStream（plus.android 对 NIO Channel 代理可能也阻塞，需验证）
+ *   - 不用 shell du，直接调 java.io.File.listFiles()（仍是 N 次桥，无收益）
+ *
+ * 当前 stub：返 null + 一次性 warn。`_statDir` 走"JS 递归 + 2000 文件上限"降级路径，
+ * 慢设备仍可能超时（2000 文件 entry.file() = 2-6s），但比"无任何输出 + UI 卡死"可接受。
+ *
+ * @returns {Promise<null>}
+ */
+let _execDisabledWarned = false
+async function _sumDirSizeByExec(path) {
+	// #ifdef APP-PLUS
+	if (!_execDisabledWarned) {
+		console.warn(
+			'[ioPath] _sumDirSizeByExec disabled (plus.android bridge deadlock with Java readLine). Use _statDir fallback path.'
+		)
+		_execDisabledWarned = true
+	}
+	return null
+	// #endif
+	// #ifndef APP-PLUS
+	return null
+	// #endif
+}
+
+/**
+ * 递归求目录下"统计信息"：总字节 + 文件数。
+ *
+ * 当前统一策略：JS 递归 + entry.file() 累加 + 2000 文件上限。
+ *   - 单文件 entry.file() 桥往返 ~1-3ms
+ *   - 2000 文件 ~2-6s（仍在 HANDLER_TIMEOUT_MS 8s 兜底内）
+ *   - 超出 2000 stop + warn + truncated=true，bytes = 前 2000 文件实际字节和
+ *
+ * 原计划走 Runtime.exec / Java NIO / native plugin 三种"一次桥"方案均不可行：
+ *   - Runtime.exec + readLine → plus.android bridge 同步阻塞死锁（实测 UI 卡死）
+ *   - Java NIO Selector → 需要 native 字节码（uniapp 不便走 JS 侧）
+ *   - native plugin → uni_modules 全套配置，超 P0 范畴
+ *
+ * 后续优化方向（不在 P0 范围）：
+ *   - native plugin 提供 Java 静态方法递归求和（一次桥真实拿 totalBytes）
+ *   - 上 bookkeeping（写入侧记账），computeSize 变 O(1)
+ *
+ * @param {Function} [skipFile] 可选谓词，命中的文件不计入字节/计数
+ *   （uniapp_save/ 内跳过 .wgt/.apk/.ipa 升级包，与 _residualKind 口径一致）
+ * @returns {Promise<{bytes:number, count:number, truncated?:boolean}>}
+ */
+async function _statDir(dirEntry, skipFile) {
+	// #ifdef APP-PLUS
+	// iOS / Android 统一走 JS 递归 + 文件上限路径。
+	// 原计划走 Runtime.exec / Java NIO / native plugin 三种"一次桥"方案均不可行：
+	//   - Runtime.exec + readLine → plus.android bridge 同步阻塞死锁（实测）
+	//   - Java NIO Selector → 需要 native 字节码（uniapp 不便走 JS 侧）
+	//   - native plugin → uni_modules 全套配置，超 P0 范畴
+	//
+	// ★ 2026-08-03 task #17：用户 Android 12 设备 readEntries 反复返回 phantom entries
+	//   (200/330 同一些)，递归 walk 会跑进 phantom 子目录里：
+	//     - 每次 _listDir 调 readEntries 拿 15-200 phantom entries
+	//     - walk 把 phantom 当子目录递归，每个 phantom 又 _listDir 再返 15 phantom
+	//     - 12 层累积 180 entries，4s outer 兜底被打爆
+	//   ★ 终极方案：放弃递归，只扫顶层 entries。residual 所有目标目录（uniapp_save/、
+	//     uniapp_temp_<ts>、preload/、share/<uid>/）文件都是顶层扁平结构，不需要递归
+	//   ★ share/ 特殊：本身是父目录，下面 uid 子目录也要扫（仅一层）
+	//
+	// 估算字节：图片平均 30-80KB（avatar 30KB / share 40KB / canvas 50KB / 根图 50KB）
+	//   不再调用 entry.file() 拿真实字节，慢设备 8ms/file × 200 = 1.6s 全省掉
+	const STAT_DIR_TIMEOUT_MS = 4000
+	const MAX_FILES = 200
+	const shared = {
+		bytes: 0,
+		count: 0,
+		scanned: 0,
+		settled: false
+	}
+	const statPromise = (async () => {
+		let bytes = 0
+		let count = 0
+		let truncated = false
+		let scanned = 0
+
+		// ★ 只扫顶层：不递归到子目录
+		// 1) 拿顶层 entries（_listDir 仍然受 MAX_READ_ATTEMPTS 保护）
+		let es = []
+		try {
+			es = await _listDir(dirEntry)
+		} catch (e) {
+			console.warn('[ioPath] _statDir _listDir failed:', e?.message)
+			return {
+				bytes: 0,
+				count: 0,
+				truncated: false
+			}
+		}
+
+		// 2) 分类 file vs directory（不递归，但允许调用方知道有子目录）
+		const fileEntries = []
+		for (const e of es) {
+			if (typeof skipFile === 'function' && skipFile(e)) continue
+			if (e.isFile) fileEntries.push(e)
+		}
+		// 3) 限制文件数
+		const limitedFiles = fileEntries.slice(0, MAX_FILES)
+		if (fileEntries.length > MAX_FILES) truncated = true
+
+		// 4) 真实 bytes：用 _getRealFileSize 拿真实 size（task #29 toURL + resolveLocalFileSystemURL）
+		//    不估算。失败 → 0 bytes
+		const realSizes = await Promise.all(
+			limitedFiles.map((e) => _getRealFileSize(e))
+		)
+		bytes = realSizes.reduce((s, sz) => s + sz, 0)
+		count = limitedFiles.length
+		scanned = limitedFiles.length
+		shared.bytes = bytes
+		shared.count = count
+		shared.scanned = scanned
+
+		if (truncated) {
+			// console.warn(
+			// 	`[ioPath._statDir] truncated at ${MAX_FILES} of ${fileEntries.length} files`
+			// )
+		}
+		shared.settled = true // 标记已完成
+		return {
+			bytes,
+			count,
+			truncated
+		}
+	})()
+	const timeoutPromise = new Promise((resolve) => {
+		setTimeout(() => {
+			// ★ task #27：检查 statPromise 是否已完成，避免误报"超时"
+			if (shared.settled) {
+				// 已完成 — 静默返回（不打印 warn，不影响 race 结果）
+				resolve(null)
+				return
+			}
+			const partialCount = shared.count
+			const partialBytes = shared.bytes
+			const estimatedBytes = partialBytes + partialCount * AVG_FILE_BYTES
+			console.warn(
+				`[ioPath._statDir] outer timeout ${STAT_DIR_TIMEOUT_MS}ms, partial: scanned=${shared.scanned} count=${partialCount} bytes=${partialBytes} → estimated ${estimatedBytes}`
+			)
+			resolve({
+				bytes: estimatedBytes,
+				count: partialCount,
+				truncated: true,
+				timedOut: true,
+				estimated: true
+			})
+		}, STAT_DIR_TIMEOUT_MS)
+	})
+	// ★ task #27：把 statPromise 自身放进 Promise.race 数组
+	//   这样即使 timeoutPromise 因 statPromise 已 settled 而 resolve(null)，Promise.race 仍然返回 statPromise 的结果
+	//   (timeoutPromise 提前 resolve(null) 不会"赢"，因为 statPromise 也是 Promise.race 成员)
+	const result = await Promise.race([statPromise, timeoutPromise])
+	if (result === null) {
+		// timeoutPromise 检测到 statPromise 已 settled，提前 resolve(null) 让我们再次 await statPromise
+		return await statPromise
+	}
+	if (result.timedOut) {
+		return result
+	}
+	if (result.truncated) {
+		// console.warn(
+		// 	`[ioPath] _statDir truncated at ${MAX_FILES} files (path may contain more); bytes is partial sum.`
+		// )
+	}
+	return {
+		bytes: result.bytes,
+		count: result.count,
+		truncated: result.truncated
+	}
+	// #endif
+	// #ifndef APP-PLUS
+	return {
+		bytes: 0,
+		count: 0,
+		truncated: false
+	}
+	// #endif
+}
+
+// _countSubdirFiles 已删除——exec 路径因为 plus.android bridge 死锁被禁用，
+// _statDir 不再需要独立的轻量递归，count 在统一 walk 里同步累加。
+
+/**
+ * 递归删除目录下的文件，skipFile 命中的保留；目录结构本身保留
+ * 用于 dir-filtered 类残留目录（uniapp_save/：删头像、留升级包）
+ * 边删边累加 freedBytes/keyCount，调用方无需做 before/after 扫描
+ * @returns {Promise<{deleted:number, kept:number, freedBytes:number, keyCount:number}>}
+ */
+async function _removeFilesInDir(dirEntry, skipFile) {
+	// #ifdef APP-PLUS
+	let deleted = 0
+	let kept = 0
+	let freedBytes = 0
+	let keyCount = 0
+	let entries
+	try {
+		entries = await _listDir(dirEntry)
+	} catch (e) {
+		console.warn('[ioPath] _removeFilesInDir read failed for a dir, skipping:', e?.message)
+		return {
+			deleted,
+			kept,
+			freedBytes,
+			keyCount
+		}
+	}
+	for (const entry of entries) {
+		if (entry.isDirectory) {
+			// eslint-disable-next-line no-await-in-loop
+			const r = await _removeFilesInDir(entry, skipFile)
+			deleted += r.deleted
+			kept += r.kept
+			freedBytes += r.freedBytes
+			keyCount += r.keyCount
+			continue
+		}
+		if (!entry.isFile) continue
+		if (typeof skipFile === 'function' && skipFile(entry)) {
+			kept++
+			continue
+		}
+		// 删前量大小（删除后 entry.file() 取不到，引用也会失效）
+		let fileSize = 0
+		try {
+			const file = await new Promise((res, rej) => entry.file(res, rej))
+			fileSize = file?.size || 0
+		} catch (e) {
+			/* size unknown, fall through with 0 */
+		}
+		// eslint-disable-next-line no-await-in-loop
+		const ok = await new Promise((resolve) => {
+			entry.remove(() => resolve(true), () => resolve(false))
+		})
+		if (ok) {
+			deleted++
+			freedBytes += fileSize
+			keyCount++
+		}
+	}
+	return {
+		deleted,
+		kept,
+		freedBytes,
+		keyCount
+	}
+	// #endif
+	// #ifndef APP-PLUS
+	return {
+		deleted: 0,
+		kept: 0,
+		freedBytes: 0,
+		keyCount: 0
+	}
+	// #endif
+}
+
+/**
+ * ★ task #29：通过 entry.toURL() + plus.io.resolveLocalFileSystemURL 拿真实 File.size
+ *   Android 12 phantom entry 的 entry.file() 返回假数据。
+ *   但通过 entry.toURL() 拿到的真实路径，再用 plus.io.resolveLocalFileSystemURL
+ *   重新打开，可能能拿到真实的 File 对象。
+ *   失败时 fallback 到 entry.file()。
+ *
+ * @param {FileEntry} entry
+ * @returns {Promise<number>} 文件字节数，失败返回 0
+ */
+function _getRealFileSize(entry) {
+	// #ifdef APP-PLUS
+	return new Promise((resolve) => {
+		if (!entry) return resolve(0)
+		// 优先尝试：toURL → resolveLocalFileSystemURL → file
+		let url = null
+		try {
+			url = entry.toURL ? entry.toURL() : null
+		} catch (e) {
+			/* swallow */
+		}
+		if (url) {
+			plus.io.resolveLocalFileSystemURL(
+				url,
+				(reEntry) => {
+					reEntry.file(
+						(f) => resolve(f?.size || 0),
+						() => {
+							// resolveLocalFileSystemURL → file 失败，fallback 到原 entry.file()
+							entry.file(
+								(f) => resolve(f?.size || 0),
+								() => resolve(0)
+							)
+						}
+					)
+				},
+				() => {
+					// resolveLocalFileSystemURL 失败，fallback 到原 entry.file()
+					entry.file(
+						(f) => resolve(f?.size || 0),
+						() => resolve(0)
+					)
+				}
+			)
+		} else {
+			// 没 toURL()，直接 entry.file()
+			entry.file(
+				(f) => resolve(f?.size || 0),
+				() => resolve(0)
+			)
+		}
+	})
+	// #endif
+	// #ifndef APP-PLUS
+	return Promise.resolve(0)
+	// #endif
 }
 
 /**
  * 列出目录所有 entry（DirectoryEntry / FileEntry）
+ *
+ * ★ 2026-08-03 防御性修复（task #10 诊断发现）：
+ *   原版 readAll() 递归只在 es.length === 0 时退出。Android 12 PRIVATE_WWW 根
+ *   上 readEntries 永不返回空数组（也不返回错误），导致 readAll() 死循环，
+ *   _statDir / getSandboxTotalSize 永远 hang。
+ *   三重防护：
+ *     1) 单次 readEntries 2s 兜底（不响应就当失败，resolve(已收集部分)）
+ *     2) readAll() 调用次数上限 100（防御 readEntries 持续返回非空）
+ *     3) 单次 readEntries batch 超过 10000 项也直接退出（防御畸形实现）
  */
 async function _listDir(dirEntry) {
-  // #ifdef APP-PLUS
-  return new Promise((resolve, reject) => {
-    const reader = dirEntry.createReader()
-    const collected = []
-    const readAll = () => {
-      reader.readEntries(
-        (es) => {
-          if (es.length === 0) return resolve(collected)
-          collected.push(...es)
-          readAll()
-        },
-        (err) => reject(err)
-      )
-    }
-    readAll()
-  })
-  // #endif
-  // #ifndef APP-PLUS
-  return []
-  // #endif
+	// #ifdef APP-PLUS
+	return new Promise((resolve) => {
+		let timer = null
+		let resolved = false
+		const finish = (reason) => {
+			if (resolved) return
+			resolved = true
+			if (timer) clearTimeout(timer)
+			resolve(reason)
+		}
+		let reader
+		try {
+			reader = dirEntry.createReader()
+		} catch (e) {
+			console.warn('[ioPath._listDir] createReader failed:', e?.message)
+			return finish([])
+		}
+		const collected = []
+		let readAttempts = 0
+		// ★ 2026-08-03 task #16：MAX_READ_ATTEMPTS 100→15
+		//   用户 Android 12 设备 readEntries 反复返回 200 entries（重复同一些）。
+		//   100 次 × ~50ms/次 = 5s，每次 _listDir 都撞 4s outer 兜底。
+		//   15 次足够覆盖真实情况（单次 readEntries 最多返回 ~100 条，递归查空目录 2-3 次就该停了）；
+		//   15 × 50ms = 750ms，远低于 4s outer 兜底
+		const MAX_READ_ATTEMPTS = 15
+		const MAX_BATCH_SIZE = 10000
+		const readAll = () => {
+			if (readAttempts >= MAX_READ_ATTEMPTS) {
+				// console.warn(`[ioPath._listDir] hit MAX_READ_ATTEMPTS=${MAX_READ_ATTEMPTS}, returning partial (${collected.length} entries)`)
+				return finish(collected)
+			}
+			readAttempts++
+			// ★ 2026-08-03 task #16：单次 readEntries timeout 2s→500ms
+			//   真实 readEntries 回调通常 < 100ms 返回；500ms 兜底足够抓 hang
+			let cbFired = false
+			timer = setTimeout(() => {
+				if (!cbFired) {
+					cbFired = true
+					console.warn(
+						`[ioPath._listDir] readEntries timeout 500ms after ${readAttempts} attempts, returning partial (${collected.length} entries)`
+					)
+					finish(collected)
+				}
+			}, 500)
+			try {
+				reader.readEntries(
+					(es) => {
+						if (cbFired) return // 已被 timeout 关闭
+						cbFired = true
+						clearTimeout(timer)
+						timer = null
+						if (!es || es.length === 0) return finish(collected)
+						if (collected.length + es.length > MAX_BATCH_SIZE) {
+							console.warn(
+								`[ioPath._listDir] hit MAX_BATCH_SIZE=${MAX_BATCH_SIZE}, truncating`
+							)
+							const room = MAX_BATCH_SIZE - collected.length
+							if (room > 0) collected.push(...es.slice(0, room))
+							return finish(collected)
+						}
+						collected.push(...es)
+						readAll()
+					},
+					(err) => {
+						if (cbFired) return
+						cbFired = true
+						clearTimeout(timer)
+						timer = null
+						console.warn('[ioPath._listDir] readEntries error:', err?.message)
+						finish(collected) // 返回部分而非抛错
+					}
+				)
+			} catch (e) {
+				if (!cbFired) {
+					cbFired = true
+					clearTimeout(timer)
+					console.warn('[ioPath._listDir] readEntries threw:', e?.message)
+					finish(collected)
+				}
+			}
+		}
+		readAll()
+	})
+	// #endif
+	// #ifndef APP-PLUS
+	return []
+	// #endif
 }
 
 /**
  * 获取设备级存储信息（Native.js：Android 走 StatFs，iOS 走 NSFileManager）
  * 不需要任何 native plugin；非 APP-PLUS 平台或失败时返回安全零值
- * 注：与项目已有 getAndroidApkSize / useShare.js 的 Native.js 模式 1:1 对齐
+ * 注：与项目已有 useShare.js 的 Native.js 模式 1:1 对齐
  * @returns {Promise<{totalBytes:number, freeBytes:number}>}
  */
 export function getDeviceStorageInfo() {
-  return new Promise((resolve) => {
-    // #ifdef APP-PLUS
-    try {
-      if (typeof plus === 'undefined') {
-        return resolve({ totalBytes: 0, freeBytes: 0 })
-      }
-      if (plus.os.name === 'Android') {
-        // Android：用 StatFs 查 /data 分区（即系统"内部存储"）
-        // 不需要任何权限；Android 10+ 分区存储不影响 StatFs（StatFs 查的是卷级元数据）
-        const Environment = plus.android.importClass('android.os.Environment')
-        const StatFs = plus.android.importClass('android.os.StatFs')
-        const dataDir = Environment.getDataDirectory()
-        const stat = new StatFs(dataDir.getPath())
-        // getBlockSizeLong 是 API 18+，project minSdkVersion=21 保证可用
-        // plus.android 对 *Long 变体代理有时不稳定 → parseFloat 兜底
-        const blockSize = parseFloat(plus.android.invoke(stat, 'getBlockSizeLong'))
-        const totalBlocks = parseFloat(plus.android.invoke(stat, 'getBlockCountLong'))
-        const freeBlocks = parseFloat(plus.android.invoke(stat, 'getAvailableBlocksLong'))
-        if (blockSize > 0 && totalBlocks > 0) {
-          resolve({
-            totalBytes: blockSize * totalBlocks,
-            freeBytes: blockSize * freeBlocks,
-          })
-        } else {
-          console.warn('[ioPath] getDeviceStorageInfo (Android) got non-positive values')
-          resolve({ totalBytes: 0, freeBytes: 0 })
-        }
-      } else if (plus.os.name === 'iOS') {
-        // iOS：用 NSFileManager.attributesOfFileSystem 查系统卷
-        // NSFileSystemSize / NSFileSystemFreeSize 是 public API（参照 useShare.js 调用风格）
-        const fm = plus.ios.invoke('NSFileManager', 'defaultManager')
-        if (!fm) {
-          console.warn('[ioPath] getDeviceStorageInfo (iOS) fm is null')
-          return resolve({ totalBytes: 0, freeBytes: 0 })
-        }
-        const attrs = plus.ios.invoke(fm, 'attributesOfFileSystemForPath:error:', '/')
-        if (attrs) {
-          const total = parseFloat(attrs.plusGetAttribute('NSFileSystemSize')) || 0
-          const free = parseFloat(attrs.plusGetAttribute('NSFileSystemFreeSize')) || 0
-          // 必须 deleteObject，否则 NSObject proxy 会泄露（参照 useShare.js 清理模式）
-          plus.ios.deleteObject(attrs)
-          plus.ios.deleteObject(fm)
-          resolve({ totalBytes: total, freeBytes: free })
-        } else {
-          plus.ios.deleteObject(fm)
-          console.warn('[ioPath] getDeviceStorageInfo (iOS) attrs is null')
-          resolve({ totalBytes: 0, freeBytes: 0 })
-        }
-      } else {
-        // Harmony / 其它平台：暂不支持，返回 0
-        resolve({ totalBytes: 0, freeBytes: 0 })
-      }
-    } catch (e) {
-      console.warn('[ioPath] getDeviceStorageInfo failed:', e?.message)
-      resolve({ totalBytes: 0, freeBytes: 0 })
-    }
-    // #endif
-    // #ifndef APP-PLUS
-    resolve({ totalBytes: 0, freeBytes: 0 })
-    // #endif
-  })
-}
+	return new Promise((resolve) => {
+		// #ifdef APP-PLUS
+		try {
+			if (typeof plus === 'undefined') {
+				return resolve({
+					totalBytes: 0,
+					freeBytes: 0
+				})
+			}
+			if (plus.os.name === 'Android') {
+				// Android：用 StatFs 查 /data 分区（即系统"内部存储"）
+				// 不需要任何权限；Android 10+ 分区存储不影响 StatFs（StatFs 查的是卷级元数据）
+				const Environment = plus.android.importClass('android.os.Environment')
+				const StatFs = plus.android.importClass('android.os.StatFs')
+				const dataDir = Environment.getDataDirectory()
+				// 走显式 plus.android.invoke 而不是 dataDir.getPath()：
+				//   某些 HBuilderX 版本里 proxy 对象的方法返回值不会被自动 unwrap，
+				//   直接传 proxy 给 new StatFs() 会抛 IllegalArgumentException
+				//   （与同段下面 *Long 变量代理不稳定的处理风格保持一致）
+				const dataDirPath = plus.android.invoke(dataDir, 'getPath')
+				const stat = new StatFs(dataDirPath)
+				// getBlockSizeLong 是 API 18+，project minSdkVersion=21 保证可用
+				// plus.android 对 *Long 变体代理有时不稳定 → parseFloat 兜底
+				const blockSize = parseFloat(plus.android.invoke(stat, 'getBlockSizeLong'))
+				const totalBlocks = parseFloat(plus.android.invoke(stat, 'getBlockCountLong'))
+				const freeBlocks = parseFloat(plus.android.invoke(stat, 'getAvailableBlocksLong'))
+				if (blockSize > 0 && totalBlocks > 0) {
+					resolve({
+						totalBytes: blockSize * totalBlocks,
+						freeBytes: blockSize * freeBlocks,
+					})
+				} else {
+					console.warn('[ioPath] getDeviceStorageInfo (Android) got non-positive values')
+					resolve({
+						totalBytes: 0,
+						freeBytes: 0
+					})
+				}
+			} else if (plus.os.name === 'iOS') {
+				// iOS：用 NSFileManager.attributesOfFileSystem 查系统卷
+				// NSFileSystemSize / NSFileSystemFreeSize 是 public API（参照 useShare.js 调用风格）
+				// 关键：fm / attrs 都是 NSObject proxy，必须 deleteObject 否则每次调用泄漏 1 个 proxy。
+				//   原版只在 success/attrs=null 分支主动清，invoke 自身抛异常时走外层 catch 会漏掉 fm。
+				//   改为内层 try/finally 保证 fm 必清，attrs 也在 finally 兜底。
+				const fm = plus.ios.invoke('NSFileManager', 'defaultManager')
+				if (!fm) {
+					console.warn('[ioPath] getDeviceStorageInfo (iOS) fm is null')
+					return resolve({
+						totalBytes: 0,
+						freeBytes: 0
+					})
+				}
+				let attrs = null
+				try {
+					attrs = plus.ios.invoke(fm, 'attributesOfFileSystemForPath:error:', '/')
+					if (attrs) {
+						const total = parseFloat(attrs.plusGetAttribute('NSFileSystemSize')) || 0
+						const free = parseFloat(attrs.plusGetAttribute('NSFileSystemFreeSize')) || 0
+						resolve({
+							totalBytes: total,
+							freeBytes: free
+						})
+					} else {
+						console.warn('[ioPath] getDeviceStorageInfo (iOS) attrs is null')
+						resolve({
+							totalBytes: 0,
+							freeBytes: 0
+						})
+					}
+				} finally {
+					// 顺序：先 attrs 再 fm（参照 useShare.js 清理模式）
+					if (attrs) {
+						try {
+							plus.ios.deleteObject(attrs)
+						} catch (e) {
+							/* swallow */
+						}
+					}
+					try {
+						plus.ios.deleteObject(fm)
+					} catch (e) {
+						/* swallow */
+					}
+				}
+			} else {
+				// Harmony / 其它平台：暂不支持，返回 0
+				resolve({
+					totalBytes: 0,
+					freeBytes: 0
+				})
+			}
+		} catch (e) {
+			console.warn('[ioPath] getDeviceStorageInfo failed:', e?.message)
+			resolve({
+				totalBytes: 0,
+				freeBytes: 0
+			})
+		}
+		// #endif
+		// #ifndef APP-PLUS
+		resolve({
+			totalBytes: 0,
+			freeBytes: 0
+		})
+		// #endif
+	})
+}
\ No newline at end of file