1.12.2

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

.gitignore

@@ -45,3 +45,7 @@ nul
 
 # TypeScript incremental compilation cache
 *.tsbuildinfo
+
+# temporary files
+tmp/
+temp/

docs/README.md

@@ -0,0 +1,288 @@
+# ERPAuto 文档指南
+
+本文档是 ERPAuto 项目文档的**分类指南和编写规范**，用于：
+
+- 指导文档的分类和归档
+- 规范新文档的命名和格式
+- 帮助开发者快速定位应创建的文档类型
+
+---
+
+## 📚 文档分类体系
+
+### 一、按受众分类
+
+| 分类           | 目录         | 受众       | 内容示例                     |
+| -------------- | ------------ | ---------- | ---------------------------- |
+| **用户文档**   | `user/`      | 最终用户   | 使用指南、配置说明、迁移指南 |
+| **开发者文档** | `developer/` | 开发人员   | 架构设计、开发指南、模块说明 |
+| **内部文档**   | `internal/`  | 项目维护者 | 分析报告、优化计划、模板     |
+
+### 二、按内容类型分类
+
+| 分类         | 目录                                | 内容特点                         |
+| ------------ | ----------------------------------- | -------------------------------- |
+| **功能特性** | `features/`                         | 功能说明、业务流程、重构概览     |
+| **调试指南** | `debugging/`                        | 调试指南、快速参考、故障排查     |
+| **测试文档** | `testing/`                          | 测试计划、测试报告、测试基础设施 |
+| **模块文档** | `cleaner/`, `browser/`, `database/` | 特定模块的详细文档               |
+| **计划文档** | `plans/`                            | 设计方案、实施计划               |
+| **发布说明** | `releases/`                         | 版本发布记录                     |
+
+---
+
+## 📝 文档命名规范
+
+### 文件名格式
+
+```
+<主题>-<子主题>-<类型>.md
+```
+
+**规则：**
+
+- 使用**小写字母**和**连字符** (`-`)
+- 不使用空格、下划线或大写字母
+- 保持简短但有描述性
+
+**示例：**
+
+```
+✅ user-override-match-feature.md
+✅ settings-partial-save.md
+✅ cleaner-validation-flow.md
+✅ test-improvement-plan.md
+
+❌ UserOverrideMatchFeature.md    # 驼峰命名
+❌ user_override_match.md         # 下划线
+❌ user override match.md         # 空格
+```
+
+### 类型后缀约定
+
+| 后缀           | 用途       | 示例                                      |
+| -------------- | ---------- | ----------------------------------------- |
+| `-guide.md`    | 指南类文档 | `erp-login-debug-guide.md`                |
+| `-quickref.md` | 快速参考   | `erp-login-debug-quickref.md`             |
+| `-flow.md`     | 流程说明   | `settings-save-button-flow.md`            |
+| `-feature.md`  | 功能特性   | `user-override-match-feature.md`          |
+| `-plan.md`     | 计划方案   | `test-improvement-plan.md`                |
+| `-report.md`   | 报告总结   | `TEST_REVIEW_REPORT.md`                   |
+| `-template.md` | 模板文件   | `cleaner-execution-report-template.md`    |
+| `-overview.md` | 概览说明   | `validation-handler-refactor-overview.md` |
+
+### Plans 路径专用命名规范
+
+`plans/` 目录使用**日期前缀**命名法，便于按时间排序和管理：
+
+```
+<YYYY-MM-DD>-<描述>-<类型>.md
+```
+
+**类型标识：**
+
+| 类型后缀     | 用途     | 内容重点                               |
+| ------------ | -------- | -------------------------------------- |
+| `-plan.md`   | 实施计划 | 任务分解、时间线、资源分配、风险评估   |
+| `-design.md` | 设计方案 | 技术架构、接口设计、数据模型、决策理由 |
+
+**示例：**
+
+```
+✅ 2026-04-13-cleaner-db-persistence-plan.md
+✅ 2026-04-13-cleaner-db-persistence-design.md
+✅ 2026-04-05-postgresql-integration-plan.md
+✅ 2026-04-05-postgresql-integration-design.md
+
+❌ cleaner-db-plan.md              # 缺少日期
+❌ 2026-4-13-cleaner-db-plan.md    # 日期格式不正确（应为 2026-04-13）
+❌ 2026-04-13-plan-cleaner-db.md   # 类型应在最后
+```
+
+**相关文件对：**
+同一个项目通常会有配对的计划和设计文档：
+
+- `2026-04-13-cleaner-db-persistence-plan.md` - 实施计划
+- `2026-04-13-cleaner-db-persistence-design.md` - 设计方案
+
+使用相同的日期和描述，便于关联查找。
+
+---
+
+## 🗂️ 分类决策流程
+
+创建新文档时，按以下流程确定分类：
+
+```
+1. 文档的读者是谁？
+   ├─ 最终用户 → user/
+   ├─ 开发者 → developer/
+   └─ 项目维护者 → internal/ 或其他专业目录
+
+2. 文档的内容类型是什么？
+   ├─ 功能说明 → features/
+   ├─ 调试帮助 → debugging/
+   ├─ 测试相关 → testing/
+   ├─ 模块特定 → cleaner/, browser/, database/
+   ├─ 设计计划 → plans/
+   └─ 发布记录 → releases/
+
+3. 是否需要快速参考？
+   └─ 是 → 使用 -quickref.md 后缀，放入 debugging/
+```
+
+### 分类示例
+
+| 文档主题          | 正确分类                                              | 理由         |
+| ----------------- | ----------------------------------------------------- | ------------ |
+| 如何配置 ERP 连接 | `user/config-erp-guide.md`                            | 用户操作指南 |
+| 日志系统设计      | `developer/architecture/logging-design.md`            | 架构设计     |
+| 登录失败排查      | `debugging/erp-login-quickref.md`                     | 调试快速参考 |
+| 测试覆盖率分析    | `testing/coverage-analysis-report.md`                 | 测试报告     |
+| 物料清理模块说明  | `cleaner/module-overview.md`                          | 模块文档     |
+| 新功能实施计划    | `plans/2026-04-14-new-feature-implementation-plan.md` | 实施计划     |
+| 数据库设计文档    | `plans/2026-04-14-database-schema-design.md`          | 设计方案     |
+
+---
+
+## 📋 文档模板
+
+### 指南类文档模板
+
+```markdown
+# <功能> 指南
+
+## 概述
+
+简要说明文档目的和适用范围。
+
+## 前置条件
+
+列出使用该功能的前提条件。
+
+## 操作步骤
+
+1. 步骤一
+2. 步骤二
+3. 步骤三
+
+## 常见问题
+
+- Q: 问题描述
+- A: 解决方案
+
+## 相关文档
+
+- [相关文档 1](link)
+- [相关文档 2](link)
+```
+
+### 功能特性文档模板
+
+```markdown
+# <功能名称> 特性说明
+
+## 背景
+
+为什么需要这个功能。
+
+## 功能描述
+
+功能的具体行为和预期结果。
+
+## 用户流程
+
+用户使用该功能的完整流程。
+
+## 技术实现
+
+关键实现细节（可选）。
+
+## 影响范围
+
+对其他模块的影响。
+```
+
+### 计划文档模板
+
+```markdown
+# <项目名称> 实施计划
+
+## 目标
+
+项目要达成的目标。
+
+## 范围
+
+包含和不包含的内容。
+
+## 任务分解
+
+- [ ] 任务 1
+- [ ] 任务 2
+- [ ] 任务 3
+
+## 时间线
+
+预计开始和结束时间。
+
+## 风险
+
+可能的风险和应对措施。
+```
+
+---
+
+## 🔧 文档维护
+
+### 文档更新
+
+- **功能变更时**：同步更新相关文档
+- **发现错误时**：立即修正并提交
+- **版本发布时**：更新 `releases/` 中的发布说明
+
+### 文档审查
+
+新文档创建后，应检查：
+
+- [ ] 分类是否正确
+- [ ] 命名是否符合规范
+- [ ] 是否使用了模板
+- [ ] 链接是否有效
+- [ ] 是否添加到相关索引
+
+### 废弃文档
+
+过时的文档应：
+
+1. 在文件顶部添加 `> ⚠️ 已废弃` 标记
+2. 说明废弃原因和替代文档
+3. 在下一个版本发布时移至 `archive/` 目录
+
+---
+
+## 📖 根目录文档
+
+`docs/` 根目录仅保留**跨category的项目级文档**：
+
+| 文档                                   | 用途              |
+| -------------------------------------- | ----------------- |
+| `README.md`                            | 本文档 - 分类指南 |
+| `build-and-release-guide.md`           | 构建和发布流程    |
+| `portable-auto-update-architecture.md` | 便携版更新架构    |
+
+**原则**：如果文档不属于特定分类，且对项目整体重要，可放在根目录。
+
+---
+
+## 🔍 找不到合适的分类？
+
+如果现有分类无法容纳你的文档：
+
+1. 检查是否可以归入 `internal/`（内部文档）
+2. 考虑是否应该创建新的子目录
+3. 在提交 PR 时说明分类理由
+
+---
+
+_最后更新：2026-04-14_

docs/cleaner/cleaner-role-based-flow.md

@@ -0,0 +1,309 @@
+# 清理器角色差异流程 — Admin vs User
+
+**文档版本**: 1.1
+**创建日期**: 2026-04-06
+**面向对象**: 开发人员
+
+## 概述
+
+清理器（Cleaner）在决定"哪些物料需要被清除"时，Admin 和 User 两个角色存在系统性的差异。这些差异贯穿三个阶段：**初始化 → 校验确认 → 执行清理**。
+
+本文档使用 Mermaid 图表说明每个阶段的角色分支逻辑。
+
+---
+
+## 全局流程概览
+
+```mermaid
+flowchart TB
+    subgraph init["阶段一：页面初始化"]
+        I1([页面加载]) --> I2{角色判断}
+        I2 -->|Admin| I3["管理员列表 ← 全部负责人<br/>默认选中全部"]
+        I2 -->|User| I4["管理员列表 ← 空<br/>默认选中仅自己"]
+    end
+
+    subgraph validate["阶段二：校验 → 勾选 → 同步数据库"]
+        V1([点击校验]) --> V2["后端查询物料<br/>（不区分角色）"]
+        V2 --> V3["物料匹配算法<br/>（User 有覆盖匹配）"]
+        V3 --> V4{角色判断}
+        V4 -->|Admin| V5["显示全部物料<br/>侧边栏可按负责人筛选"]
+        V4 -->|User| V6["仅显示自己的物料<br/>+ 无负责人的物料"]
+        V5 --> V7["用户勾选/取消勾选"]
+        V6 --> V7
+        V7 --> V8{点击同步数据库}
+        V8 --> V9{角色判断}
+        V9 -->|Admin| V10["处理范围：全部校验结果"]
+        V9 -->|User| V11["处理范围：仅筛选后结果"]
+    end
+
+    subgraph execute["阶段三：执行清理（ERP 删除）"]
+        E1([点击执行清理]) --> E2["getCleanerData(selectedManagers)<br/>获取物料代码"]
+        E2 --> E3{角色判断}
+        E3 -->|Admin| E3a{selectedManagers<br/>非空?}
+        E3a -->|"是"| E4["SQL WHERE ManagerName IN (选中)<br/>从 MaterialsToBeDeleted 获取"]
+        E3a -->|"否"| E4b["从 DiscreteMaterialPlanData<br/>按 orderNumbers 获取"]
+        E3 -->|User| E5["SQL WHERE ManagerName = 用户<br/>仅获取自己的物料代码"]
+        E4 --> E6["传递给 runCleaner 执行"]
+        E4b --> E6
+        E5 --> E6
+        E6 --> E7([在 ERP 中删除物料])
+    end
+
+    init --> validate --> execute
+```
+
+---
+
+## 阶段一：页面初始化
+
+**源码位置**: `src/renderer/src/hooks/cleaner/api.ts:25-52` 与 `src/renderer/src/hooks/useCleaner.ts:98-112`
+
+```mermaid
+flowchart TB
+    Start([页面加载]) --> GetAdmin["调用 auth:isAdmin<br/>判断是否管理员"]
+    GetAdmin --> GetUser["调用 auth:getCurrentUser<br/>获取当前用户名"]
+    GetUser --> RoleCheck{isAdmin?}
+
+    RoleCheck -->|Admin| GetManagers["调用 materials:getManagers<br/>获取全部负责人列表"]
+    GetManagers --> SelectAll["selectedManagers ← 全部负责人<br/>（默认全选）"]
+    SelectAll --> RenderSidebar["渲染 CleanerSidebar<br/>显示负责人复选框"]
+
+    RoleCheck -->|User| SetSelf["selectedManagers ← {currentUsername}<br/>（仅选中自己）"]
+    SetSelf --> NoSidebar["不渲染 CleanerSidebar<br/>无侧边栏"]
+
+    RenderSidebar --> Ready([就绪])
+    NoSidebar --> Ready
+```
+
+**差异总结**:
+
+| 维度       | Admin             | User   |
+| ---------- | ----------------- | ------ |
+| 侧边栏     | 有 CleanerSidebar | 无     |
+| 管理员列表 | 查询全部负责人    | 不查询 |
+| 默认选中   | 所有负责人        | 仅自己 |
+
+---
+
+## 阶段二：校验 → 勾选 → 同步数据库
+
+### 2.1 物料校验（后端，不区分角色）
+
+**源码位置**: `src/main/services/validation/validation-application-service.ts`
+
+校验阶段后端查询不区分角色，Admin 和 User 拿到相同的物料数据。区别在于**匹配算法**：
+
+```mermaid
+flowchart TB
+    Start([遍历每条物料记录]) --> P1{"优先级1<br/>MaterialsToBeDeleted<br/>精确匹配 MaterialCode?"}
+
+    P1 -->|"匹配"| SetManager["managerName ← 表中记录<br/>isMarkedForDeletion = true"]
+    P1 -->|"未匹配"| P2{"优先级2<br/>MaterialsTypeToBeDeleted<br/>MaterialName 包含匹配?"}
+
+    P2 -->|"匹配"| SetType["managerName ← 类型关键词负责人<br/>matchedTypeKeyword ← 匹配项"]
+    P2 -->|"未匹配"| SetNull["managerName = null"]
+
+    SetManager --> RoleCheck{角色?}
+    SetType --> RoleCheck
+    SetNull --> RoleCheck
+
+    RoleCheck -->|"Admin"| Skip["跳过覆盖<br/>使用当前结果"]
+    RoleCheck -->|"User"| P3{"优先级3（User 覆盖）<br/>自己的类型关键词匹配?"}
+
+    P3 -->|"匹配"| Override["强制覆盖<br/>managerName ← 当前用户"]
+    P3 -->|"未匹配"| Keep["保持当前结果"]
+    Skip --> Next(["下一条物料"])
+    Override --> Next
+    Keep --> Next
+```
+
+**匹配优先级说明**:
+
+| 优先级         | 数据源                     | 匹配方式              | 适用角色 |
+| -------------- | -------------------------- | --------------------- | -------- |
+| 1（最高）      | `MaterialsToBeDeleted`     | MaterialCode 精确匹配 | 全部     |
+| 2              | `MaterialsTypeToBeDeleted` | MaterialName 包含匹配 | 全部     |
+| 3（User 覆盖） | 当前用户的类型关键词       | MaterialName 包含匹配 | 仅 User  |
+
+> **优先级 3 的作用**：当某个物料按优先级 2 被分配给其他负责人，但当前 User 有匹配的类型关键词时，会强制覆盖为自己的。这确保 User 不会为他人操作物料。
+
+### 2.2 前端显示过滤
+
+**源码位置**: `src/renderer/src/hooks/cleaner/helpers.ts:34-57`
+
+校验结果返回前端后，会根据角色进行显示过滤：
+
+```mermaid
+flowchart TB
+    Input([校验结果 validationResults]) --> RoleCheck{角色判断}
+
+    RoleCheck -->|Admin| FilterManagers["按侧边栏选中的负责人过滤<br/>selectedManagers.has(managerName)<br/>|| !managerName"]
+    RoleCheck -->|User| FilterSelf["仅显示自己的 + 无负责人的<br/>managerName === currentUsername<br/>|| !managerName"]
+
+    FilterManagers --> FilterHidden["排除已隐藏的物料<br/>!hiddenItems.has(materialCode)"]
+    FilterSelf --> FilterHidden
+
+    FilterHidden --> Output([filteredResults<br/>用于表格显示])
+```
+
+### 2.3 确认删除（同步数据库）
+
+**源码位置**: `src/renderer/src/hooks/useCleaner.ts:289-344`
+
+```mermaid
+flowchart TB
+    Start([点击确认删除]) --> RoleScope{角色判断}
+
+    RoleScope -->|Admin| UseAll["resultsToProcess = validationResults<br/>处理全部校验结果"]
+    RoleScope -->|User| UseFiltered["resultsToProcess = filteredResults<br/>仅处理筛选后结果"]
+
+    UseAll --> BuildPlan["buildDeletionPlan(resultsToProcess, selectedItems)"]
+    UseFiltered --> BuildPlan
+
+    BuildPlan --> Loop["遍历 resultsToProcess"]
+    Loop --> Check{物料是否勾选?}
+
+    Check -->|"已勾选"| HasManager{有负责人?}
+    Check -->|"未勾选"| ToDelete["加入 materialsToDelete<br/>从数据库移除标记"]
+
+    HasManager -->|"有"| ToUpsert["加入 materialsToUpsert<br/>写入/更新到数据库"]
+    HasManager -->|"无"| Missing["加入 missingManager<br/>阻止操作"]
+
+    ToUpsert --> Save["调用 materials:upsertBatch"]
+    ToDelete --> Del["调用 materials:delete"]
+    Missing --> Warn(["弹窗警告：缺少负责人"])
+    Save --> Done([完成])
+    Del --> Done
+```
+
+**关键代码**:
+
+```typescript
+// Admin 处理全部结果，User 只处理筛选后的结果
+const resultsToProcess = isAdmin ? validationResults : filteredResults
+```
+
+**差异总结**:
+
+| 维度             | Admin                       | User                                   |
+| ---------------- | --------------------------- | -------------------------------------- |
+| 处理范围         | `validationResults`（全部） | `filteredResults`（自己的+无负责人的） |
+| 可操作物料       | 所有负责人的物料            | 仅自己的 + 无负责人的                  |
+| 能否修改他人数据 | 是                          | 否                                     |
+
+---
+
+## 阶段三：执行清理（ERP 删除）
+
+**源码位置**:
+
+- 前端调用: `src/renderer/src/hooks/cleaner/api.ts:116-166`
+- 获取数据: `src/main/services/validation/validation-application-service.ts:497-655`
+- 执行删除: `src/main/services/cleaner/cleaner-application-service.ts`
+
+```mermaid
+sequenceDiagram
+    participant UI as 前端 useCleaner
+    participant API as api.ts
+    participant Main as 主进程
+    participant DB as 数据库
+    participant ERP as ERP 系统
+
+    UI->>API: runCleanerExecution({ dryRun, selectedManagers, ... })
+    API->>Main: getCleanerData({ selectedManagers })
+
+    alt Admin + selectedManagers 非空
+        Main->>DB: SELECT MaterialCode FROM MaterialsToBeDeleted<br/>WHERE ManagerName IN (@manager0, @manager1, ...)
+        Note over Main,DB: 按选中的负责人过滤<br/>从 MaterialsToBeDeleted 获取
+    else Admin + selectedManagers 为空
+        Main->>DB: SELECT DISTINCT MaterialCode FROM DiscreteMaterialPlanData<br/>WHERE SourceNumber IN (orderNumbers)
+        Note over Main,DB: 按订单号查询<br/>从 DiscreteMaterialPlanData 获取
+    else User
+        Main->>DB: SELECT MaterialCode FROM MaterialsToBeDeleted<br/>WHERE ManagerName = @username
+        Note over Main,DB: 按 ManagerName 过滤<br/>仅获取自己的物料代码
+    end
+
+    DB-->>Main: materialCodes[]
+    Main-->>API: { orderNumbers, materialCodes }
+
+    Note over API: 传入角色过滤后的 materialCodes
+    API->>Main: cleaner.runCleaner({ orderNumbers, materialCodes, ... })
+
+    Main->>ERP: 按订单遍历，删除指定物料
+    ERP-->>Main: 删除结果
+    Main-->>API: CleanerResult
+    API-->>UI: 显示执行报告
+```
+
+**SQL 差异**:
+
+```mermaid
+flowchart TB
+    subgraph AdminWithMgr["Admin + selectedManagers 非空"]
+        A1["SELECT MaterialCode<br/>FROM MaterialsToBeDeleted<br/>WHERE ManagerName IN (@manager0, ...)<br/>AND MaterialCode IS NOT NULL"]
+    end
+
+    subgraph AdminNoMgr["Admin + selectedManagers 为空"]
+        A2["SELECT DISTINCT MaterialCode<br/>FROM DiscreteMaterialPlanData<br/>WHERE SourceNumber IN (orderNumbers)"]
+    end
+
+    subgraph User["User 查询"]
+        U1["SELECT MaterialCode<br/>FROM MaterialsToBeDeleted<br/>WHERE ManagerName = @username<br/>AND MaterialCode IS NOT NULL"]
+    end
+
+    AdminWithMgr --> |"按选中负责人过滤"| Result([传入 runCleaner])
+    AdminNoMgr --> |"按订单号查 DiscreteMaterialPlanData"| Result
+    User --> |"仅返回自己的物料代码"| Result
+```
+
+**差异总结**:
+
+| 维度       | Admin（有 selectedManagers） | Admin（无 selectedManagers）           | User                            |
+| ---------- | ---------------------------- | -------------------------------------- | ------------------------------- |
+| 数据源     | `MaterialsToBeDeleted`       | `DiscreteMaterialPlanData`             | `MaterialsToBeDeleted`          |
+| 查询条件   | `WHERE ManagerName IN (...)` | `WHERE SourceNumber IN (orderNumbers)` | `WHERE ManagerName = @username` |
+| 可删除物料 | 选中负责人的物料             | 订单关联的全部物料                     | 仅自己标记的物料                |
+| 无订单号时 | —                            | 返回空数组                             | —                               |
+
+---
+
+## 数据安全边界
+
+角色隔离在**三个层面**同时生效，形成纵深防御：
+
+```mermaid
+flowchart TB
+    subgraph layer1["第一层：前端过滤"]
+        L1["filterValidationResults()<br/>User 仅看到自己的物料"]
+    end
+
+    subgraph layer2["第二层：同步范围"]
+        L2["handleConfirmDeletion()<br/>User 仅同步 filteredResults"]
+    end
+
+    subgraph layer3["第三层：后端查询"]
+        L3["loadMaterialCodesForCleaner()<br/>Admin: WHERE ManagerName IN (selectedManagers)<br/>User: SQL WHERE ManagerName = user"]
+    end
+
+    L1 -->|"防止误操作"| L2
+    L2 -->|"缩小同步范围"| L3
+    L3 -->|"最终保证"| Safe([User 无法删除他人物料])
+```
+
+> **注意**：`runCleaner()` 本身不做角色过滤，它信任上游传入的 `materialCodes` 已经过角色过滤。安全性由 `getCleanerData()` 的 SQL 查询保证。
+
+---
+
+## 涉及文件索引
+
+| 文件                                                             | 关键函数/逻辑                                                                         | 行号                      |
+| ---------------------------------------------------------------- | ------------------------------------------------------------------------------------- | ------------------------- |
+| `src/renderer/src/hooks/cleaner/api.ts`                          | `initializeCleanerPage()`, `runCleanerExecution()`                                    | 25-52, 116-166            |
+| `src/renderer/src/hooks/useCleaner.ts`                           | `handleConfirmDeletion()`, 初始化逻辑                                                 | 98-120, 289-345           |
+| `src/renderer/src/hooks/cleaner/helpers.ts`                      | `filterValidationResults()`, `buildDeletionPlan()`                                    | 34-57, 59-92              |
+| `src/main/services/validation/validation-application-service.ts` | `getCleanerData()`, `loadMaterialCodesForCleaner()`, `queryMaterialCodesByManagers()` | 232-305, 497-604, 606-655 |
+| `src/main/services/cleaner/cleaner-application-service.ts`       | `runCleaner()`                                                                        | 31-168                    |
+| `src/main/ipc/cleaner-handler.ts`                                | `CLEANER_RUN` handler                                                                 | 16-22                     |
+| `src/main/ipc/validation-handler.ts`                             | `getCleanerData` handler                                                              | 194-223                   |
+| `src/preload/api/validation.ts`                                  | `getCleanerData()` IPC 桥接                                                           | 11-12                     |
+| `src/renderer/src/pages/CleanerPage.tsx`                         | 页面组件，条件渲染侧边栏                                                              | 74-82                     |

docs/plans/2026-04-13-cleaner-db-persistence-design.md

@@ -0,0 +1,239 @@
+# Cleaner 数据库持久化设计
+
+## 背景
+
+Cleaner 当前使用 Markdown 文件做执行记录持久化，通过 RustFS 上传存储。存在以下问题：
+
+- 报告是非结构化文本，无法程序化查询和统计
+- 历史记录无法按用户、时间、状态筛选
+- 重试时依赖文件名去重，覆盖了首次执行的崩溃信息
+- 前端需要通过 RustFS 下载报告再解析展示，链路长且脆弱
+
+Extractor 已有成熟的数据库持久化模式（`ExtractorOperationHistory` 表 + DAO + 前端弹窗），Cleaner 应复用相同模式。
+
+## 设计决策
+
+| 决策项   | 选择                                                         | 理由                                                                                |
+| -------- | ------------------------------------------------------------ | ----------------------------------------------------------------------------------- |
+| 表结构   | 独立建表，不与 Extractor 共用                                | Cleaner 数据结构差异大（双层、物料级详情），独立更清晰                              |
+| 记录粒度 | 执行 + 订单 + 物料三层                                       | 执行表存全局信息，订单表存订单汇总，物料表存操作明细                                |
+| 批次标识 | `BatchId`（UUID），与 Extractor 一致                         | 标准、简洁，不需要嵌入时间戳                                                        |
+| 重试记录 | 不覆盖，每次尝试独立写入，用 `AttemptNumber` 区分            | 保留完整审计链，为后续智能跳过提供数据基础                                          |
+| 报告文件 | 移除 Markdown 报告和 RustFS 上传                             | 数据库完全替代，报告相关代码（CleanerReportGenerator、generateAndUploadReport）删除 |
+| 前端历史 | 独立 CleanerOperationHistoryModal，复用 Extractor 的 UI 模式 | 放在 CleanerPage 上，与 Extractor 的"操作历史"按钮对齐                              |
+
+## 数据库表结构
+
+所有表的 schema 为 `ERPAuto`。
+
+### 1. `CleanerExecution`（执行级）
+
+全限定名：`ERPAuto.CleanerExecution`
+
+一次清理操作（含重试）的全局信息。每次尝试一行记录。
+
+| 列名                    | 类型             | 说明                                           |
+| ----------------------- | ---------------- | ---------------------------------------------- |
+| ID                      | INT IDENTITY     | 自增主键                                       |
+| BatchId                 | UNIQUEIDENTIFIER | 批次 ID，一次清理操作（含重试）共享            |
+| AttemptNumber           | INT              | 第几次尝试（1=首次，2=外层重试）               |
+| UserId                  | INT              | 操作用户 ID                                    |
+| Username                | NVARCHAR(255)    | 操作用户名                                     |
+| OperationTime           | DATETIME         | 操作时间                                       |
+| EndTime                 | DATETIME         | 结束时间                                       |
+| Status                  | NVARCHAR(50)     | pending / success / failed / partial / crashed |
+| IsDryRun                | BIT              | 是否模拟运行                                   |
+| TotalOrders             | INT              | 订单总数                                       |
+| OrdersProcessed         | INT              | 已处理订单数                                   |
+| TotalMaterialsDeleted   | INT              | 总删除物料数                                   |
+| TotalMaterialsSkipped   | INT              | 总跳过物料数                                   |
+| TotalMaterialsFailed    | INT              | 总失败物料数                                   |
+| TotalUncertainDeletions | INT              | 总不确定删除数                                 |
+| ErrorMessage            | NVARCHAR(MAX)    | 全局错误信息（如外层崩溃原因）                 |
+| AppVersion              | NVARCHAR(20)     | 应用版本号                                     |
+
+### 2. `CleanerOrderHistory`（订单级）
+
+全限定名：`ERPAuto.CleanerOrderHistory`
+
+每个订单在每次尝试中的执行结果。每个订单每次尝试一行记录。
+
+| 列名               | 类型             | 说明                       |
+| ------------------ | ---------------- | -------------------------- |
+| ID                 | INT IDENTITY     | 自增主键                   |
+| BatchId            | UNIQUEIDENTIFIER | 关联执行表 BatchId         |
+| AttemptNumber      | INT              | 关联执行表 AttemptNumber   |
+| OrderNumber        | NVARCHAR(255)    | 订单号                     |
+| Status             | NVARCHAR(50)     | pending / success / failed |
+| MaterialsDeleted   | INT              | 删除物料数                 |
+| MaterialsSkipped   | INT              | 跳过物料数                 |
+| MaterialsFailed    | INT              | 删除失败物料数             |
+| UncertainDeletions | INT              | 不确定删除数               |
+| RetryCount         | INT              | 内层重试次数               |
+| RetrySuccess       | BIT              | 内层重试是否成功           |
+| ErrorMessage       | NVARCHAR(MAX)    | 错误信息                   |
+
+关联方式：`BatchId + AttemptNumber` 关联执行表。
+
+### 3. `CleanerMaterialDetail`（物料级）
+
+全限定名：`ERPAuto.CleanerMaterialDetail`
+
+每个物料在每次尝试中的操作明细。
+
+| 列名               | 类型             | 说明                                   |
+| ------------------ | ---------------- | -------------------------------------- |
+| ID                 | INT IDENTITY     | 自增主键                               |
+| BatchId            | UNIQUEIDENTIFIER | 关联执行表 BatchId                     |
+| AttemptNumber      | INT              | 关联执行表 AttemptNumber               |
+| OrderNumber        | NVARCHAR(255)    | 所属订单号                             |
+| MaterialCode       | NVARCHAR(255)    | 物料代码                               |
+| MaterialName       | NVARCHAR(255)    | 物料名称                               |
+| RowNumber          | INT              | 行号                                   |
+| Result             | NVARCHAR(50)     | deleted / skipped / failed / uncertain |
+| Reason             | NVARCHAR(MAX)    | 跳过/失败原因                          |
+| AttemptCount       | INT              | 删除尝试次数                           |
+| FinalErrorCategory | NVARCHAR(50)     | 最终错误分类                           |
+
+关联方式：`BatchId + AttemptNumber + OrderNumber` 关联订单表。
+
+### 数据示例
+
+首次执行到第 80 个订单时崩溃，外层重试成功完成全部 211 个订单：
+
+**CleanerExecution**
+
+```
+BatchId=uuid-1, Attempt=1, Status=crashed,  TotalOrders=211, Processed=80,  ...
+BatchId=uuid-1, Attempt=2, Status=success,  TotalOrders=211, Processed=211, ...
+```
+
+**CleanerOrderHistory**（Attempt=1 中部分记录）
+
+```
+BatchId=uuid-1, Attempt=1, Order=SC001, Status=success, Deleted=5, Skipped=1
+BatchId=uuid-1, Attempt=1, Order=SC080, Status=crashed, Error=查询超时
+```
+
+**CleanerOrderHistory**（Attempt=2 中部分记录）
+
+```
+BatchId=uuid-1, Attempt=2, Order=SC001, Status=success, Deleted=5, Skipped=1
+BatchId=uuid-1, Attempt=2, Order=SC080, Status=success, Deleted=3, Skipped=0
+BatchId=uuid-1, Attempt=2, Order=SC211, Status=success, Deleted=2, Skipped=0
+```
+
+**CleanerMaterialDetail**（SC080 在 Attempt=2 中的物料）
+
+```
+BatchId=uuid-1, Attempt=2, Order=SC080, Material=MAT-001, Result=deleted
+BatchId=uuid-1, Attempt=2, Order=SC080, Material=MAT-002, Result=skipped, Reason=不可删除
+```
+
+## 写入时机
+
+```
+用户点击"执行清理"
+  → IPC: cleaner:run
+    → cleaner-handler.ts
+      → ① BatchId = randomUUID()
+      → ② 插入 CleanerExecution（Status=pending）
+      → ③ 插入 CleanerOrderHistory（所有订单，Status=pending）
+      → ④ 执行清理（CleanerApplicationService.runCleaner）
+      → ⑤ 更新 CleanerExecution（Status=success/failed/partial/crashed）
+      → ⑥ 更新 CleanerOrderHistory（每个订单的结果）
+      → ⑦ 插入 CleanerMaterialDetail（每个物料的操作明细）
+      → ⑧ 如果 crashed → 外层重试
+         → 插入新的 CleanerExecution（AttemptNumber=2, Status=pending）
+         → 插入新的 CleanerOrderHistory（AttemptNumber=2, Status=pending）
+         → 重新执行
+         → 更新执行表和订单表状态
+         → 插入物料明细
+```
+
+- 步骤 ②③：在 `cleaner-handler.ts` 中，执行前写入，记录操作人、全局配置、待处理订单
+- 步骤 ⑤⑥⑦：在 `CleanerApplicationService` 中，执行完成后回调 DAO 写入结果
+- 步骤 ⑧：外层重试时，三张表都新增 AttemptNumber=2 的记录，首次尝试的数据完整保留
+
+## 变更清单
+
+### 新增文件
+
+1. **`src/main/services/database/cleaner-operation-history-dao.ts`**
+   - `CleanerOperationHistoryDAO` 类
+   - 执行表操作：insertExecution、updateExecutionStatus
+   - 订单表操作：insertOrderRecords、updateOrderStatus
+   - 物料表操作：insertMaterialDetails
+   - 查询操作：getBatches、getBatchDetails（含订单+物料）、deleteBatch
+   - 参考 `ExtractorOperationHistoryDAO` 的模式，表名使用 `ERPAuto.CleanerExecution`、`ERPAuto.CleanerOrderHistory`、`ERPAuto.CleanerMaterialDetail`
+
+2. **`src/main/types/cleaner-history.types.ts`**
+   - `CleanerExecutionRecord`、`CleanerOrderRecord`、`CleanerMaterialRecord`
+   - `CleanerBatchStats`、`InsertCleanerExecutionInput`、`InsertOrderInput`、`InsertMaterialDetailInput`
+
+3. **`src/renderer/src/components/CleanerOperationHistoryModal.tsx`**
+   - 操作历史弹窗，复用 ExtractorOperationHistoryModal 的 UI 模式
+   - 批次列表（按 BatchId 聚合，显示操作时间、用户、状态、成功/失败数，区分多次尝试）
+   - 展开明细（订单列表，每订单的删除/跳过/失败数）
+   - 物料级详情（第二层展开，显示每个物料的操作结果）
+   - 管理员可按用户筛选、可删除批次
+
+### 修改文件
+
+4. **`src/main/ipc/cleaner-handler.ts`**
+   - `CLEANER_RUN` handler 中：执行前插入 execution + order 的 pending 记录，执行后更新结果
+   - 新增 IPC handlers：`CLEANER_HISTORY_BATCHES`、`CLEANER_HISTORY_DETAILS`、`CLEANER_HISTORY_DELETE`
+
+5. **`src/main/services/cleaner/cleaner-application-service.ts`**
+   - `runCleaner` 接收 `batchId` 参数
+   - 移除 `generateExecutionId()` 函数
+   - 移除 `generateAndUploadReport()` 方法
+   - 移除 `executionId` 相关逻辑
+   - 外层重试时，通过 DAO 写入 AttemptNumber=2 的执行记录和订单记录，不覆盖首次尝试
+   - 执行完成后回调 DAO 写入订单结果和物料明细
+
+6. **`src/main/ipc/index.ts`**
+   - 注册新的 cleaner history IPC handlers
+
+7. **`src/preload/api/cleaner.ts`**
+   - 新增 IPC 调用方法：getBatches、getBatchDetails、deleteBatch
+
+8. **`src/preload/index.d.ts`**
+   - `CleanerAPI` 接口新增 getBatches、getBatchDetails、deleteBatch 类型声明
+
+9. **`src/renderer/src/pages/CleanerPage.tsx`**
+   - 新增"操作历史"按钮
+   - 引入 CleanerOperationHistoryModal
+
+### 删除文件
+
+10. **`src/main/services/report/cleaner-report-generator.ts`**
+    - 整个文件删除，报告生成逻辑不再需要
+
+### 可选清理
+
+11. **`src/renderer/src/components/ReportViewerDialog.tsx`**
+    - 基于 RustFS 文件的报告查看器，Cleaner 不再使用
+    - 如果 Extractor 不共用此组件，可删除
+
+12. **`src/renderer/src/components/ReportAnalysisDialog.tsx`**
+    - 基于报告文件的分析，Cleaner 不再使用
+    - 后续可基于数据库重新实现统计分析
+
+## 移除的概念
+
+| 概念                           | 原因                              |
+| ------------------------------ | --------------------------------- |
+| ExecutionId（CLN-时间戳-随机） | 为文件名设计，数据库用 UUID       |
+| generateExecutionId()          | 随 ExecutionId 一起移除           |
+| CleanerReportGenerator         | Markdown 报告生成器，被数据库替代 |
+| generateAndUploadReport()      | RustFS 上传链路，被数据库写入替代 |
+| 报告文件名去重                 | 数据库 UUID 天然唯一              |
+| 重试覆盖旧报告                 | 数据库保留所有尝试记录            |
+
+## 不涉及的部分
+
+- Extractor 的持久化逻辑不变
+- 数据库 schema 迁移（需 DBA 创建表，应用层只做 CRUD）
+- 后续智能跳过功能（基于已有 success 记录跳过已成功的订单）
+- 内层重试逻辑（订单级/物料级）不变

docs/plans/2026-04-13-cleaner-db-persistence-plan.md

@@ -0,0 +1,699 @@
+# Cleaner 数据库持久化实施计划
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** 将 Cleaner 的执行记录从 Markdown 文件持久化迁移到数据库（三张表：执行级、订单级、物料级），并在前端新增操作历史弹窗。
+
+**Architecture:** 新建 `CleanerOperationHistoryDAO` 操作三张表（`ERPAuto.CleanerExecution`、`ERPAuto.CleanerOrderHistory`、`ERPAuto.CleanerMaterialDetail`），通过新增 IPC handlers 暴露给前端。执行前写入 pending 记录，执行后更新结果和物料明细。外层重试时新增 AttemptNumber=2 的记录，不覆盖首次尝试。移除 Markdown 报告生成和 RustFS 上传链路。
+
+**Tech Stack:** TypeScript, Electron IPC, SQL (MySQL/SQL Server/PostgreSQL via existing DAO+dialect pattern), React
+
+---
+
+## Task 1: 新增类型定义
+
+**Files:**
+
+- Create: `src/main/types/cleaner-history.types.ts`
+
+**Step 1: 创建类型文件**
+
+```typescript
+// src/main/types/cleaner-history.types.ts
+
+/**
+ * Cleaner 操作历史类型定义
+ */
+
+/** 执行级记录 */
+export interface CleanerExecutionRecord {
+  id?: number
+  batchId: string
+  attemptNumber: number
+  userId: number
+  username: string
+  operationTime: Date
+  endTime: Date | null
+  status: string
+  isDryRun: boolean
+  totalOrders: number
+  ordersProcessed: number
+  totalMaterialsDeleted: number
+  totalMaterialsSkipped: number
+  totalMaterialsFailed: number
+  totalUncertainDeletions: number
+  errorMessage: string | null
+  appVersion: string | null
+}
+
+/** 订单级记录 */
+export interface CleanerOrderRecord {
+  id?: number
+  batchId: string
+  attemptNumber: number
+  orderNumber: string
+  status: string
+  materialsDeleted: number
+  materialsSkipped: number
+  materialsFailed: number
+  uncertainDeletions: number
+  retryCount: number
+  retrySuccess: boolean
+  errorMessage: string | null
+}
+
+/** 物料级记录 */
+export interface CleanerMaterialRecord {
+  id?: number
+  batchId: string
+  attemptNumber: number
+  orderNumber: string
+  materialCode: string
+  materialName: string
+  rowNumber: number
+  result: string
+  reason: string | null
+  attemptCount: number
+  finalErrorCategory: string | null
+}
+
+/** 批次统计（前端列表展示用） */
+export interface CleanerBatchStats {
+  batchId: string
+  userId: number
+  username: string
+  operationTime: string
+  /** 最终一次尝试的状态 */
+  status: string
+  totalAttempts: number
+  totalOrders: number
+  ordersProcessed: number
+  totalMaterialsDeleted: number
+  totalMaterialsFailed: number
+  successCount: number
+  failedCount: number
+  isDryRun: boolean
+}
+
+/** 插入执行记录的输入 */
+export interface InsertCleanerExecutionInput {
+  batchId: string
+  attemptNumber: number
+  userId: number
+  username: string
+  isDryRun: boolean
+  totalOrders: number
+  appVersion: string
+}
+
+/** 插入订单记录的输入 */
+export interface InsertOrderInput {
+  orderNumber: string
+}
+
+/** 插入物料明细的输入 */
+export interface InsertMaterialDetailInput {
+  orderNumber: string
+  materialCode: string
+  materialName: string
+  rowNumber: number
+  result: string
+  reason: string | null
+  attemptCount: number
+  finalErrorCategory: string | null
+}
+
+/** 查询批次的选项 */
+export interface GetCleanerBatchesOptions {
+  limit?: number
+  offset?: number
+  usernames?: string[]
+}
+```
+
+**Step 2: 验证类型检查通过**
+
+Run: `npm run typecheck`
+Expected: PASS（新文件不影响现有代码）
+
+**Step 3: Commit**
+
+```
+feat(cleaner): add type definitions for cleaner operation history
+```
+
+---
+
+## Task 2: 新增 DAO 层
+
+**Files:**
+
+- Create: `src/main/services/database/cleaner-operation-history-dao.ts`
+
+**Step 1: 创建 DAO 文件**
+
+参考 `extractor-operation-history-dao.ts` 的模式（`create()` 获取数据库连接、`createDialect()` 处理 SQL 方言、`trackDuration()` 记录耗时）。表名使用 `ERPAuto` schema。
+
+关键方法：
+
+```typescript
+export class CleanerOperationHistoryDAO {
+  private dbService: IDatabaseService | null = null
+  private dialect: SqlDialect | null = null
+
+  // ===== 执行表 =====
+  private getExecutionTableName(): string {
+    return this.getDialect().quoteTableName('ERPAuto', 'CleanerExecution')
+  }
+
+  async insertExecution(input: InsertCleanerExecutionInput): Promise<boolean>
+  async updateExecutionStatus(
+    batchId: string,
+    attemptNumber: number,
+    status: string,
+    ordersProcessed: number,
+    materialsDeleted: number,
+    materialsSkipped: number,
+    materialsFailed: number,
+    uncertainDeletions: number,
+    endTime: Date,
+    errorMessage?: string
+  ): Promise<boolean>
+
+  // ===== 订单表 =====
+  private getOrderTableName(): string {
+    return this.getDialect().quoteTableName('ERPAuto', 'CleanerOrderHistory')
+  }
+
+  async insertOrderRecords(
+    batchId: string,
+    attemptNumber: number,
+    orders: InsertOrderInput[]
+  ): Promise<boolean>
+  async updateOrderStatus(
+    batchId: string,
+    attemptNumber: number,
+    orderNumber: string,
+    status: string,
+    materialsDeleted: number,
+    materialsSkipped: number,
+    materialsFailed: number,
+    uncertainDeletions: number,
+    retryCount: number,
+    retrySuccess: boolean,
+    errorMessage?: string
+  ): Promise<boolean>
+
+  // ===== 物料表 =====
+  private getMaterialTableName(): string {
+    return this.getDialect().quoteTableName('ERPAuto', 'CleanerMaterialDetail')
+  }
+
+  async insertMaterialDetails(
+    batchId: string,
+    attemptNumber: number,
+    details: InsertMaterialDetailInput[]
+  ): Promise<boolean>
+
+  // ===== 查询 =====
+  async getBatches(
+    userId?: number,
+    options?: GetCleanerBatchesOptions
+  ): Promise<CleanerBatchStats[]>
+  async getBatchDetails(
+    batchId: string
+  ): Promise<{ executions: CleanerExecutionRecord[]; orders: CleanerOrderRecord[] }>
+  async getMaterialDetails(
+    batchId: string,
+    attemptNumber: number,
+    orderNumber: string
+  ): Promise<CleanerMaterialRecord[]>
+
+  // ===== 删除 =====
+  async deleteBatch(
+    batchId: string,
+    requestingUserId: number,
+    isAdmin: boolean
+  ): Promise<{ success: boolean; error?: string }>
+
+  // ===== 列询执行级记录 =====
+  async getMaterialDetails(
+    batchId: string,
+    attemptNumber: number,
+    orderNumber: string
+  ): Promise<CleanerMaterialRecord[]>
+
+  // ===== 删除 =====
+  async deleteBatch(
+    batchId: string,
+    requestingUserId: number,
+    isAdmin: boolean
+  ): Promise<{ success: boolean; error?: string }>
+  async disconnect(): Promise<void>
+}
+```
+
+`getBatches` 查询逻辑：
+
+- `GROUP BY BatchId`，取 `MAX(AttemptNumber)` 对应的执行记录状态作为最终状态
+- 汇总订单级的 success/failed 计数
+- 支持 userId 过滤（普通用户）和 usernames 过滤（管理员）
+- 支持分页
+
+`getBatchDetails` 查询逻辑：
+
+- 返回某 BatchId 下所有 execution 记录 + order 记录
+- 前端用 attemptNumber 区分不同尝试
+
+每个 INSERT/UPDATE 使用 `trackDuration()` 包裹，error handling 与 Extractor DAO 一致。
+
+**Step 2: 验证类型检查通过**
+
+Run: `npm run typecheck`
+Expected: PASS
+
+**Step 3: Commit**
+
+```
+feat(cleaner): add CleanerOperationHistoryDAO for three-table persistence
+```
+
+---
+
+## Task 3: 新增 IPC channels
+
+**Files:**
+
+- Modify: `src/shared/ipc-channels.ts`
+
+**Step 1: 添加 cleaner history channels**
+
+在现有的 `CLEANER_PROGRESS` 之后添加：
+
+```typescript
+// Cleaner history
+CLEANER_HISTORY_GET_BATCHES: 'cleanerHistory:getBatches',
+CLEANER_HISTORY_GET_BATCH_DETAILS: 'cleanerHistory:getBatchDetails',
+CLEANER_HISTORY_GET_MATERIAL_DETAILS: 'cleanerHistory:getMaterialDetails',
+CLEANER_HISTORY_DELETE_BATCH: 'cleanerHistory:deleteBatch',
+```
+
+**Step 2: Commit**
+
+```
+feat(cleaner): add IPC channels for cleaner operation history
+```
+
+---
+
+## Task 4: 新增 IPC handler
+
+**Files:**
+
+- Create: `src/main/ipc/cleaner-history-handler.ts`
+- Modify: `src/main/ipc/index.ts` — 注册新 handler
+
+**Step 1: 创建 cleaner-history-handler.ts**
+
+参考 `operation-history-handler.ts` 的模式。四个 handler：
+
+- `CLEANER_HISTORY_GET_BATCHES`：获取批次列表，Admin 看全部，User 看自己的
+- `CLEANER_HISTORY_GET_BATCH_DETAILS`：获取某个批次的执行记录和订单记录
+- `CLEANER_HISTORY_GET_MATERIAL_DETAILS`：获取某个订单的物料明细
+- `CLEANER_HISTORY_DELETE_BATCH`：删除批次，权限校验与 Extractor 一致
+
+```typescript
+export function registerCleanerHistoryHandlers(): void {
+  const dao = new CleanerOperationHistoryDAO()
+
+  ipcMain.handle(
+    IPC_CHANNELS.CLEANER_HISTORY_GET_BATCHES,
+    async (event, options?: GetCleanerBatchesOptions): Promise<IpcResult<CleanerBatchStats[]>> => {
+      return withErrorHandling(async () => {
+        const currentUser = SessionManager.getInstance().getUserInfo()
+        if (!currentUser) throw new Error('用户未登录')
+        const userId = currentUser.userType === 'Admin' ? undefined : currentUser.id
+        return dao.getBatches(userId, options)
+      }, 'cleanerHistory:getBatches')
+    }
+  )
+
+  ipcMain.handle(
+    IPC_CHANNELS.CLEANER_HISTORY_GET_BATCH_DETAILS,
+    async (
+      event,
+      batchId: string
+    ): Promise<
+      IpcResult<{ executions: CleanerExecutionRecord[]; orders: CleanerOrderRecord[] }>
+    > => {
+      // ... 与 operation-history-handler 的 getBatchDetails 模式一致
+    }
+  )
+
+  ipcMain.handle(
+    IPC_CHANNELS.CLEANER_HISTORY_GET_MATERIAL_DETAILS,
+    async (
+      event,
+      batchId: string,
+      attemptNumber: number,
+      orderNumber: string
+    ): Promise<IpcResult<CleanerMaterialRecord[]>> => {
+      // ...
+    }
+  )
+
+  ipcMain.handle(
+    IPC_CHANNELS.CLEANER_HISTORY_DELETE_BATCH,
+    async (event, batchId: string): Promise<IpcResult<{ deleted: boolean }>> => {
+      // ... 权限校验后删除三张表的记录
+    }
+  )
+}
+```
+
+**Step 2: 在 index.ts 中注册**
+
+在 `registerIpcHandlers()` 中添加 `registerCleanerHistoryHandlers()` 调用，并在顶部添加 import。
+
+**Step 3: 验证类型检查通过**
+
+Run: `npm run typecheck`
+Expected: PASS
+
+**Step 4: Commit**
+
+```
+feat(cleaner): add IPC handlers for cleaner operation history
+```
+
+---
+
+## Task 5: 新增 Preload API
+
+**Files:**
+
+- Modify: `src/preload/api/cleaner.ts` — 新增 history 方法
+- Modify: `src/preload/index.d.ts` — 新增类型声明
+
+**Step 1: 在 cleaner.ts 中新增 history 方法**
+
+```typescript
+import type {
+  CleanerBatchStats,
+  CleanerExecutionRecord,
+  CleanerOrderRecord,
+  CleanerMaterialRecord,
+  GetCleanerBatchesOptions
+} from '../../main/types/cleaner-history.types'
+
+// 在 cleanerApi 对象中追加：
+getHistoryBatches: (options?: GetCleanerBatchesOptions): Promise<IpcResult<CleanerBatchStats[]>> =>
+  invokeIpc(IPC_CHANNELS.CLEANER_HISTORY_GET_BATCHES, options),
+
+getHistoryBatchDetails: (batchId: string): Promise<IpcResult<{
+  executions: CleanerExecutionRecord[]
+  orders: CleanerOrderRecord[]
+}>> =>
+  invokeIpc(IPC_CHANNELS.CLEANER_HISTORY_GET_BATCH_DETAILS, batchId),
+
+getHistoryMaterialDetails: (batchId: string, attemptNumber: number, orderNumber: string): Promise<IpcResult<CleanerMaterialRecord[]>> =>
+  invokeIpc(IPC_CHANNELS.CLEANER_HISTORY_GET_MATERIAL_DETAILS, batchId, attemptNumber, orderNumber),
+
+deleteHistoryBatch: (batchId: string): Promise<IpcResult<{ deleted: boolean }>> =>
+  invokeIpc(IPC_CHANNELS.CLEANER_HISTORY_DELETE_BATCH, batchId),
+```
+
+**Step 2: 在 index.d.ts 中更新 CleanerAPI 接口**
+
+在 `CleanerAPI` 接口中添加对应的类型声明，与实际 API 对齐。
+
+**Step 3: 验证类型检查通过**
+
+Run: `npm run typecheck`
+Expected: PASS
+
+**Step 4: Commit**
+
+```
+feat(cleaner): add preload API for cleaner operation history
+```
+
+---
+
+## Task 6: 改造 CleanerApplicationService — 写入数据库记录
+
+**Files:**
+
+- Modify: `src/main/services/cleaner/cleaner-application-service.ts`
+
+这是核心变更。`runCleaner` 方法需要：
+
+**Step 1: 修改 runCleaner 签名，接收 batchId 和 DAO**
+
+```typescript
+async runCleaner(
+  eventSender: WebContents,
+  input: CleanerInput,
+  batchId: string,
+  historyDao: CleanerOperationHistoryDAO
+): Promise<CleanerResult>
+```
+
+**Step 2: 移除报告相关代码**
+
+- 删除 `import { app } from 'electron'`（仅用于 `app.getVersion()`）
+- 删除 `generateExecutionId()` 函数
+- 删除 `generateAndUploadReport()` 方法
+- 删除所有 `executionId` 相关变量和日志
+
+**Step 3: 插入 pending 订单记录**
+
+在登录成功后、执行清理前，调用 `historyDao.insertOrderRecords(batchId, 1, orders)` 写入 pending 状态的订单记录。
+
+**Step 4: 执行后更新订单记录和写入物料明细**
+
+清理完成后遍历 `result.details`（`OrderCleanDetail[]`），对每个订单：
+
+- 调用 `historyDao.updateOrderStatus(...)` 更新订单结果
+- 调用 `historyDao.insertMaterialDetails(...)` 写入物料明细（skipped + failed 材料全部写入）
+
+**Step 5: 更新执行记录状态**
+
+调用 `historyDao.updateExecutionStatus(batchId, 1, ...)` 更新为最终状态。
+
+**Step 6: 外层重试改造**
+
+当 `result.crashed` 时：
+
+1. 调用 `historyDao.updateExecutionStatus(batchId, 1, 'crashed', ...)` 标记首次尝试为 crashed
+2. 调用 `historyDao.insertExecution({ batchId, attemptNumber: 2, ... })` 创建第二次尝试
+3. 调用 `historyDao.insertOrderRecords(batchId, 2, orders)` 写入第二次尝试的 pending 订单
+4. 重新登录并执行
+5. 执行后更新 AttemptNumber=2 的订单和物料记录
+
+**Step 7: 验证类型检查通过**
+
+Run: `npm run typecheck`
+Expected: PASS
+
+**Step 8: Commit**
+
+```
+refactor(cleaner): replace report generation with database persistence
+```
+
+---
+
+## Task 7: 改造 cleaner-handler.ts — 执行前后写入
+
+**Files:**
+
+- Modify: `src/main/ipc/cleaner-handler.ts`
+
+**Step 1: 修改 CLEANER_RUN handler**
+
+在调用 `cleanerService.runCleaner()` 之前：
+
+1. 获取当前用户信息
+2. `batchId = randomUUID()`
+3. 创建 `CleanerOperationHistoryDAO` 实例
+4. 调用 `dao.insertExecution({ batchId, attemptNumber: 1, userId, username, isDryRun, totalOrders, appVersion })`
+
+将 `batchId` 和 `dao` 传入 `runCleaner()`。
+
+执行完成后（无论成功失败），更新执行记录的最终状态。
+
+**Step 2: 移除 app.getVersion() 调用**
+
+`appVersion` 改为在 handler 层获取（因为 handler 已有 electron 访问权限），传给 DAO。
+
+**Step 3: 验证类型检查通过**
+
+Run: `npm run typecheck`
+Expected: PASS
+
+**Step 4: Commit**
+
+```
+refactor(cleaner): write execution records to database in IPC handler
+```
+
+---
+
+## Task 8: 删除 Markdown 报告生成器
+
+**Files:**
+
+- Delete: `src/main/services/report/cleaner-report-generator.ts`
+
+**Step 1: 删除文件**
+
+删除 `cleaner-report-generator.ts`。
+
+**Step 2: 检查是否有其他文件引用它**
+
+搜索 `cleaner-report-generator` 或 `CleanerReportGenerator`，如有引用则一并移除（主要是 `cleaner-application-service.ts` 中已删除的 import）。
+
+**Step 3: 验证编译通过**
+
+Run: `npm run typecheck`
+Expected: PASS
+
+**Step 4: Commit**
+
+```
+refactor(cleaner): remove Markdown report generator
+```
+
+---
+
+## Task 9: 前端 — 新增操作历史弹窗
+
+**Files:**
+
+- Create: `src/renderer/src/components/CleanerOperationHistoryModal.tsx`
+- Modify: `src/renderer/src/pages/CleanerPage.tsx`
+
+**Step 1: 创建 CleanerOperationHistoryModal**
+
+参考 `ExtractorOperationHistoryModal.tsx` 的 UI 模式和代码结构。关键差异：
+
+- 数据源使用 `window.electron.cleaner.getHistoryBatches()` 等新 API
+- 批次列表增加"尝试次数"列和"模拟运行"标识
+- 展开明细时，顶部显示执行级信息（尝试次数、crashed 状态等）
+- 订单表格增加 deleted/skipped/failed/uncertain 列
+- 订单行可再次展开查看物料明细（调用 `getHistoryMaterialDetails`）
+- 管理员按用户筛选、删除功能与 Extractor 一致
+
+**Step 2: 在 CleanerPage 中添加"操作历史"按钮和弹窗**
+
+- 在 `CleanerToolbar` 中添加"操作历史"按钮（或直接在 CleanerPage 添加）
+- 引入 `CleanerOperationHistoryModal` 组件
+- 传入 `user` 和 `isOpen/onClose` 控制
+
+**Step 3: 验证类型检查通过**
+
+Run: `npm run typecheck`
+Expected: PASS
+
+**Step 4: Commit**
+
+```
+feat(cleaner): add operation history modal with database-backed records
+```
+
+---
+
+## Task 10: 更新 renderer 类型定义
+
+**Files:**
+
+- Modify: `src/renderer/src/hooks/cleaner/types.ts`
+
+**Step 1: 添加 history 相关类型**
+
+在 types.ts 中添加前端需要的类型（或直接从 `cleaner-history.types.ts` import，根据项目的前端类型引用模式决定）。
+
+**Step 2: 验证类型检查通过**
+
+Run: `npm run typecheck`
+Expected: PASS
+
+**Step 3: Commit**
+
+```
+feat(cleaner): add renderer types for cleaner operation history
+```
+
+---
+
+## Task 11: 清理旧代码
+
+**Files:**
+
+- Modify: `src/renderer/src/hooks/cleaner/types.ts` — 移除 `CleanerReportData.crashed`（如果不再需要）
+- 检查 `ReportViewerDialog.tsx`、`ReportAnalysisDialog.tsx` 是否仍被 Cleaner 使用
+
+**Step 1: 清理 renderer 中不再需要的类型**
+
+- `CleanerReportData` 中如果 `crashed` 字段已无用，移除
+- 确认 `CleanerPhase` 的 `'retry'` 值是否仍需要（前端进度通知仍在使用，保留）
+
+**Step 2: 评估 ReportViewerDialog 和 ReportAnalysisDialog**
+
+这两个组件目前用于查看 Markdown 报告文件。如果 Cleaner 不再使用它们：
+
+- 在 CleanerPage 中移除相关按钮和引用
+- 不删除组件本身（Extractor 可能仍在使用，后续统一清理）
+
+**Step 3: 验证编译和类型检查通过**
+
+Run: `npm run typecheck && npm run lint`
+Expected: PASS
+
+**Step 4: Commit**
+
+```
+chore(cleaner): clean up legacy report-related code
+```
+
+---
+
+## Task 12: 集成测试
+
+**Step 1: 运行完整类型检查**
+
+Run: `npm run typecheck`
+Expected: PASS
+
+**Step 2: 运行 lint**
+
+Run: `npm run lint`
+Expected: PASS
+
+**Step 3: 运行单元测试**
+
+Run: `npm run test`
+Expected: PASS
+
+**Step 4: 手动验证**
+
+1. 启动 `npm run dev`
+2. 在 Cleaner 页面执行一次清理（模拟运行）
+3. 检查数据库三张表是否正确写入
+4. 点击"操作历史"按钮，验证批次列表和详情展示
+5. 模拟崩溃场景（如果可以），验证外层重试写入 AttemptNumber=2 的记录
+6. 用管理员账号验证用户筛选和删除功能
+
+---
+
+## 执行顺序
+
+```
+Task 1 (types) → Task 2 (DAO) → Task 3 (IPC channels) → Task 4 (IPC handler)
+  → Task 5 (preload) → Task 6 (CleanerApplicationService) → Task 7 (cleaner-handler)
+  → Task 8 (删除报告生成器) → Task 10 (renderer types) → Task 9 (前端弹窗)
+  → Task 11 (清理) → Task 12 (集成测试)
+```
+
+Task 9 和 Task 10 可以并行。Task 8 必须在 Task 6、7 之后。

docs/plans/2026-04-13-cleaner-outer-retry-design.md

@@ -0,0 +1,152 @@
+# Cleaner 外层重试机制设计
+
+## 背景
+
+当 CleanerService.performCleanup 的主循环抛出未捕获异常时（如查询超时、浏览器崩溃），代码进入 outer catch 块，直接返回 partial result。位于 try 块后半段的订单级重试逻辑（retryFailedOrders）永远没有机会执行。
+
+典型场景：211 个订单中处理到第 80 个时，查询列表页等待表格行超时 → Cleaner failed → 浏览器被关闭 → 剩余 131 个订单未处理 → 无重试。
+
+## 设计决策
+
+| 决策项       | 选择                      | 理由                             |
+| ------------ | ------------------------- | -------------------------------- |
+| 重试层级     | CleanerApplicationService | 崩溃后浏览器不可用，必须重新登录 |
+| 重试范围     | 全部订单重新跑            | 简单可靠，物料删除是幂等操作     |
+| 最大重试次数 | 1 次                      | 覆盖瞬态故障，不过度消耗时间     |
+| 触发条件     | result.crashed === true   | 仅 outer catch 触发时才重试      |
+| 报告去重     | 执行 ID                   | 用户点击执行时生成，重试不变     |
+
+## 变更清单
+
+### 1. CleanerResult 新增字段
+
+**文件**: `src/main/types/cleaner.types.ts`
+
+```typescript
+export interface CleanerResult {
+  // ... 现有字段
+  crashed?: boolean // true = outer catch triggered, 流程级崩溃
+}
+```
+
+同步更新 `src/shared/types/cleaner.types.ts`（如有独立定义）和 preload 暴露的类型声明。
+
+### 2. CleanerService 标记崩溃
+
+**文件**: `src/main/services/erp/cleaner.ts`，line 375 的 catch 块
+
+```typescript
+} catch (error) {
+  const message = error instanceof Error ? error.message : 'Unknown error'
+  log.error('Cleaner failed', { ... })
+  result.errors.push(`Clean failed: ${message}`)
+  result.crashed = true  // ← 新增
+}
+```
+
+### 3. CleanerApplicationService 重试逻辑
+
+**文件**: `src/main/services/cleaner/cleaner-application-service.ts`
+
+在 `runCleaner()` 中，`cleaner.clean()` 返回后增加重试判断：
+
+```
+runCleaner(eventSender, input) {
+  const executionId = generateExecutionId()  // 用户点击时生成
+  const startTime = Date.now()
+
+  // 1. 获取 ERP 配置、数据库连接、订单解析（不变）
+  // 2. 登录 ERP（不变）
+
+  let result = await cleaner.clean(modifiedInput)
+
+  // === 外层重试 ===
+  if (result.crashed) {
+    log.warn('检测到流程级崩溃，准备外层重试', { executionId })
+
+    await authService.close()  // 关闭不可用的浏览器
+    authService = new ErpAuthService({...})
+    await authService.login()  // 重新登录
+
+    cleaner = new CleanerService(authService)
+    result = await cleaner.clean(modifiedInput)  // 全部订单重新跑
+  }
+
+  // 3. 生成报告（使用 executionId 作为文件名一部分，避免重复）
+  await this.generateAndUploadReport(input, result, startTime, executionId)
+  return result
+}
+```
+
+### 4. 执行 ID 生成规则
+
+格式: `CLN-{yyyyMMddHHmmss}-{4位随机字母}`
+
+示例: `CLN-20260410112930-A7FK`
+
+生成时机: `runCleaner()` 入口处，在 ERP 登录之前。重试时同一个 executionId 不变。
+
+用途:
+
+- 报告文件名: `cleaner-report-CLN-20260410112930-A7FK.md`
+- RustFS 存储路径中包含该 ID，重试时覆盖同一文件
+- 报告内容中显示该 ID
+
+### 5. 报告增强
+
+**文件**: `src/main/services/report/cleaner-report-generator.ts`
+
+在执行摘要表格中新增字段:
+
+```markdown
+| 项目         | 值                        |
+| ------------ | ------------------------- | ------ |
+| **执行 ID**  | `CLN-20260410112930-A7FK` | ← 新增 |
+| **应用版本** | `1.11.1`                  | ← 新增 |
+| **执行时间** | `2026-04-10 11:29:30`     |
+| **执行模式** | `正式执行`                |
+| ...          | ...                       |
+```
+
+- **执行 ID**: 从 ReportOptions 传入
+- **应用版本**: `app.getVersion()`，沿用 logger 中已有的获取方式
+
+**ReportOptions 变更**:
+
+```typescript
+export interface ReportOptions {
+  dryRun: boolean
+  username: string
+  startTime: number
+  endTime: number
+  executionId: string // ← 新增
+  appVersion: string // ← 新增
+}
+```
+
+**报告文件名变更**:
+
+```
+旧: cleaner-report-2026-04-10-03-30-12.md
+新: cleaner-report-CLN-20260410112930-A7FK.md
+```
+
+重试时同一个 executionId 生成相同的文件名，本地文件和 RustFS 上传都会覆盖旧报告，无需额外去重逻辑。
+
+### 6. 进度通知增强
+
+重试时向前端发送进度通知，让用户知道正在重试:
+
+```typescript
+this.sendProgress(eventSender, '流程崩溃，正在重新登录并重试...', 0, {
+  phase: 'retry',
+  ...
+})
+```
+
+## 不涉及的部分
+
+- 前端 UI 变更（后续可单独做，展示重试状态）
+- IPC channel 变更
+- 内层重试逻辑（订单级/物料级）不变
+- 数据库 schema 变更

docs/releases/1.10.0.md

@@ -0,0 +1,16 @@
+# 1.10.0
+
+## 数据库
+
+- **新增 PostgreSQL 支持**：应用现可连接 PostgreSQL 数据库，与 MySQL、SQL Server 并列可选。
+- 数据库方言自动适配，SQL 语句根据数据库类型生成正确的标识符引用格式。
+
+## 稳定性
+
+- 修复 PostgreSQL 环境下表名双引号导致的 SQL 语法错误。
+- 修复 PostgreSQL 关键字冲突和大小写敏感问题，自动处理标识符转义。
+
+## 质量改进
+
+- 扩展核心业务模块（认证、清理、校验）的单元测试覆盖，提升回归检测能力。
+- 改进测试隔离性，减少跨用例状态泄漏和测试日志噪音。

docs/releases/1.11.0.md

@@ -0,0 +1,16 @@
+# 1.11.0
+
+## 物料清理
+
+- 管理员执行清理时可按负责人筛选物料，仅处理指定负责人的数据，避免误删其他人的标记。
+- 未选择负责人时自动按订单号关联查询物料，保证清理范围准确。
+
+## 审计日志
+
+- 统一审计记录中的计算机名称来源，消除多来源不一致的情况。
+- 增强审计日志的类型安全性和覆盖范围，异常情况下不再丢失日志。
+
+## 质量改进
+
+- 端到端测试迁移至 Playwright 框架，提升测试稳定性和执行效率。
+- 改进单元测试的隔离性和模拟驱动覆盖，减少跨用例状态干扰。

docs/releases/1.11.1.md

@@ -0,0 +1,5 @@
+# 1.11.1
+
+## 问题修复
+
+- 修复管理员按负责人筛选清理时，因类型声明缺失导致构建失败的问题。

docs/releases/1.12.0.md

@@ -0,0 +1,19 @@
+# 1.12.0
+
+## 清理操作历史
+
+- 新增操作历史面板，每次清理的执行记录、订单结果、物料明细均可回溯查看。
+- 历史记录按批次归档，支持管理员查看所有用户记录、普通用户查看自己的记录。
+- 批次支持展开查看多层详情：执行概况、订单状态、物料操作明细。
+
+## 订单追踪
+
+- 所有输入的订单（含总排号）均会记录在历史中，不再遗漏未找到或未匹配的订单。
+- 总排号与订单号并列显示，未匹配的总排号标注为"未找到"，ERP 中不存在的订单标注为"ERP 不存在"。
+- 内层重试和外层崩溃重试信息在订单详情中完整展示。
+
+## 改进
+
+- 数据库时间统一使用 UTC 存储，界面显示本地时间。
+- 试运行模式下跳过物料级别的数据库写入，避免产生无效记录。
+- 操作历史面板加宽至 140%，改善订单表格的阅读体验。

docs/releases/1.12.1.md

@@ -0,0 +1,6 @@
+# 1.12.1
+
+## 界面与交互
+
+- 操作历史面板新增序号列，订单和物料明细表均可直观查看行号。
+- 物料操作结果改用图标显示（已删除 / 已跳过 / 不确定 / 失败），悬停可查看状态名称。

docs/releases/1.12.2.md

@@ -0,0 +1,5 @@
+# 1.12.2
+
+## 问题修复
+
+- 修复管理员切换用户后登出，再次选择用户无法进入应用的问题。

docs/testing/TEST_COVERAGE_IMPROVEMENT_PLAN.md

@@ -0,0 +1,781 @@
+# ERPAuto 测试覆盖率提升计划
+
+## 1. 执行摘要
+
+### 1.1 当前状态评估
+
+| 指标               | 当前值 | 目标值 | 差距    |
+| ------------------ | ------ | ------ | ------- |
+| **总体行覆盖率**   | 11.36% | 70%    | -58.64% |
+| **总体函数覆盖率** | 21.29% | 70%    | -48.71% |
+| **总体分支覆盖率** | 10.08% | 60%    | -49.92% |
+| **测试文件总数**   | 54     | 100+   | -46+    |
+
+**关键模块覆盖率差距：**
+
+| 模块                                     | 当前覆盖率 | 要求阈值 | 优先级        |
+| ---------------------------------------- | ---------- | -------- | ------------- |
+| ERP 服务 (`src/main/services/erp/**`)    | 11.68%     | 80%      | P0            |
+| 更新服务 (`src/main/services/update/**`) | 42.45%     | 80%      | P0            |
+| 数据库服务                               | 17.24%     | 70%      | P1            |
+| 配置管理                                 | 20.56%     | 70%      | P1            |
+| 日志服务                                 | 70.67%     | 70%      | P2 (已达标的) |
+
+### 1.2 提升目标
+
+**阶段性目标：**
+
+- **Phase 1 (4 周)**：ERP 服务达到 60%，更新服务达到 70%
+- **Phase 2 (4 周)**：数据库服务达到 60%，配置管理达到 60%
+- **Phase 3 (4 周)**：所有关键模块达到目标阈值，总体覆盖率达到 70%
+
+**最终目标：**
+
+- 全局覆盖率：70% 行 / 70% 函数 / 60% 分支
+- ERP 服务：80% 行 / 80% 函数 / 70% 分支
+- 更新服务：80% 行 / 80% 函数 / 70% 分支
+
+### 1.3 时间线估算
+
+| 阶段     | 持续时间  | 里程碑                 |
+| -------- | --------- | ---------------------- |
+| Phase 1  | 4 周      | ERP 核心服务测试完成   |
+| Phase 2  | 4 周      | 数据层与配置层测试完成 |
+| Phase 3  | 4 周      | 集成测试与 E2E 补全    |
+| 缓冲期   | 2 周      | 修复与优化             |
+| **总计** | **14 周** | **达到目标覆盖率**     |
+
+---
+
+## 2. 分阶段提升计划
+
+### Phase 1: ERP 核心服务测试攻坚（第 1-4 周）
+
+**目标：** ERP 服务覆盖率从 11.68% 提升至 60%
+
+**工作内容：**
+
+| 模块                   | 文件数 | 新增测试数 | 优先级 |
+| ---------------------- | ------ | ---------- | ------ |
+| `erp-auth.ts`          | 1      | 15         | P0     |
+| `extractor.ts`         | 1      | 20         | P0     |
+| `extractor-core.ts`    | 1      | 15         | P0     |
+| `cleaner.ts`           | 1      | 12         | P0     |
+| `ErpBrowserManager.ts` | 1      | 10         | P1     |
+| `order-resolver.ts`    | 1      | 8          | P1     |
+| `page-diagnostics.ts`  | 1      | 6          | P2     |
+| `erp-error-context.ts` | 1      | 5          | P2     |
+| `locators.ts`          | 1      | 8          | P1     |
+
+**预计投入：** 80-100 小时
+
+**成功标准：**
+
+- [ ] ERP 服务行覆盖率 ≥ 60%
+- [ ] ERP 服务函数覆盖率 ≥ 70%
+- [ ] 新增测试文件：9 个
+- [ ] 所有 P0 模块有完整测试覆盖
+
+---
+
+### Phase 2: 数据层与配置层测试（第 5-8 周）
+
+**目标：** 数据库服务与配置管理覆盖率达标
+
+**工作内容：**
+
+#### 2.1 数据库服务（17.24% → 60%）
+
+| 模块                                           | 文件数 | 新增测试数 | 优先级 |
+| ---------------------------------------------- | ------ | ---------- | ------ |
+| `mysql.ts` / `sql-server.ts` / `postgresql.ts` | 3      | 18         | P0     |
+| `data-source.ts`                               | 1      | 8          | P0     |
+| `data-importer.ts`                             | 1      | 10         | P0     |
+| DAO 层文件                                     | 4      | 16         | P1     |
+| Repository 层                                  | 2      | 8          | P1     |
+| 数据库实体                                     | 2      | 6          | P2     |
+
+#### 2.2 配置管理（20.56% → 60%）
+
+| 模块                | 文件数 | 新增测试数 | 优先级 |
+| ------------------- | ------ | ---------- | ------ |
+| `config-manager.ts` | 1      | 20         | P0     |
+| 配置 Schema 验证    | 1      | 10         | P1     |
+
+#### 2.3 用户服务（新增）
+
+| 模块                         | 文件数 | 新增测试数 | 优先级 |
+| ---------------------------- | ------ | ---------- | ------ |
+| `session-manager.ts`         | 1      | 8          | P1     |
+| `user-erp-config-service.ts` | 1      | 10         | P1     |
+| `bip-users-dao.ts`           | 1      | 6          | P2     |
+
+**预计投入：** 100-120 小时
+
+**成功标准：**
+
+- [ ] 数据库服务行覆盖率 ≥ 60%
+- [ ] 配置管理行覆盖率 ≥ 60%
+- [ ] 新增测试文件：15 个
+- [ ] 所有数据库方言有完整测试
+
+---
+
+### Phase 3: 更新服务与其他模块补全（第 9-12 周）
+
+**目标：** 更新服务达到 80%，其他服务达到 70%
+
+**工作内容：**
+
+#### 3.1 更新服务（42.45% → 80%）
+
+| 模块                         | 文件数 | 新增测试数 | 优先级 |
+| ---------------------------- | ------ | ---------- | ------ |
+| `update-service.ts`          | 1      | 15         | P0     |
+| `update-catalog-service.ts`  | 1      | 12         | P0     |
+| `update-installer.ts`        | 1      | 10         | P0     |
+| `update-storage-client.ts`   | 1      | 10         | P0     |
+| `update-status-publisher.ts` | 1      | 6          | P1     |
+| `update-support.ts`          | 1      | 5          | P1     |
+| `update-utils.ts`            | 1      | 5          | P2     |
+
+#### 3.2 其他关键服务
+
+| 模块                       | 文件数 | 新增测试数 | 优先级 |
+| -------------------------- | ------ | ---------- | ------ |
+| 验证服务 (`validation/**`) | 3      | 15         | P1     |
+| 清理服务 (`cleaner/**`)    | 2      | 10         | P1     |
+| Excel 服务                 | 2      | 8          | P2     |
+| 报告生成                   | 1      | 6          | P2     |
+| Playwright 浏览器服务      | 2      | 10         | P1     |
+| RustFS 服务                | 2      | 8          | P2     |
+
+**预计投入：** 100-120 小时
+
+**成功标准：**
+
+- [ ] 更新服务行覆盖率 ≥ 80%
+- [ ] 更新服务函数覆盖率 ≥ 80%
+- [ ] 新增测试文件：17 个
+- [ ] 所有 P0/P1 模块覆盖率达标
+
+---
+
+### Phase 4: 集成测试与 E2E 强化（第 13-14 周）
+
+**目标：** 强化集成测试与端到端测试
+
+**工作内容：**
+
+#### 4.1 集成测试扩展（7 → 20 个）
+
+| 测试场景                   | 优先级 | 描述                   |
+| -------------------------- | ------ | ---------------------- |
+| ERP 登录 + 提取完整流程    | P0     | 验证认证与数据提取集成 |
+| 数据库事务完整流程         | P0     | 验证 TypeORM 事务边界  |
+| 配置热加载与验证           | P1     | 验证配置更新传播       |
+| 更新检查 + 下载 + 安装流程 | P0     | 验证更新完整链路       |
+| 日志异步写入与轮转         | P1     | 验证日志系统           |
+| 用户会话切换流程           | P1     | 验证多用户场景         |
+| Excel 导入导出完整流程     | P2     | 验证文件处理链         |
+
+#### 4.2 E2E 测试扩展（3 → 15 个）
+
+| 用户旅程             | 优先级 | 描述                             |
+| -------------------- | ------ | -------------------------------- |
+| 管理员完整工作流程   | P0     | 登录 → 提取 → 清理 → 验证 → 登出 |
+| 普通用户数据提取流程 | P0     | 登录 → 提取 → 查看结果           |
+| Guest 只读访问流程   | P1     | 登录 → 查看历史记录              |
+| 配置管理流程         | P1     | 修改配置 → 保存 → 验证生效       |
+| 自动更新流程         | P0     | 检查更新 → 下载 → 安装 → 重启    |
+| 错误恢复流程         | P1     | 断网重连、会话过期恢复           |
+| 批量处理流程         | P1     | 大批量订单处理性能验证           |
+
+**预计投入：** 60-80 小时
+
+**成功标准：**
+
+- [ ] 集成测试文件：20 个
+- [ ] E2E 测试文件：15 个
+- [ ] 关键用户旅程 100% 覆盖
+- [ ] 整体覆盖率达到 70%
+
+---
+
+## 3. 逐模块测试计划
+
+### 3.1 ERP 服务模块
+
+#### 3.1.1 `erp-auth.ts` (P0)
+
+**当前覆盖率：** < 20%  
+**目标覆盖率：** 80%
+
+| 测试场景            | 测试类型 | Mock 对象                       | 预期结果            |
+| ------------------- | -------- | ------------------------------- | ------------------- |
+| 成功登录流程        | 单元     | Playwright Browser/Context/Page | 返回有效 ErpSession |
+| 登录失败 - 网络错误 | 单元     | Playwright + 模拟网络错误       | 抛出连接错误        |
+| 登录失败 - 凭证错误 | 单元     | Page + 模拟错误消息             | 抛出认证错误        |
+| 会话复用 - 已登录   | 单元     | Session Mock                    | 直接返回现有会话    |
+| 登出流程            | 单元     | Browser/Context Mock            | 资源正确释放        |
+| 会话超时检测        | 单元     | Page + 超时 Mock                | 返回未登录状态      |
+| 页面元素定位失败    | 单元     | Page + Selector 失败            | 抛出元素未找到错误  |
+| SSL 证书错误处理    | 集成     | 真实 Browser + 自签名证书       | 成功建立连接        |
+
+**预计测试数：** 15
+
+---
+
+#### 3.1.2 `extractor.ts` (P0)
+
+**当前覆盖率：** ~30%  
+**目标覆盖率：** 80%
+
+| 测试场景       | 测试类型 | Mock 对象                  | 预期结果             |
+| -------------- | -------- | -------------------------- | -------------------- |
+| 单订单提取成功 | 单元     | ErpAuthService + Page      | 返回 ExtractorResult |
+| 批量订单提取   | 单元     | ErpAuthService + 循环 Mock | 正确分批处理         |
+| 订单号无效处理 | 单元     | Page + 错误响应            | 记录错误，继续处理   |
+| 下载文件合并   | 单元     | ExcelJS + fs Mock          | 生成合并文件         |
+| 数据库持久化   | 集成     | DatabaseService Mock       | 记录成功导入         |
+| 并发限制控制   | 单元     | 信号量 Mock                | 不超过并发上限       |
+| 提取中断恢复   | 集成     | 模拟中断 + 恢复            | 从断点继续           |
+| 结果统计准确性 | 单元     | 完整 Mock 链               | 统计数字准确         |
+
+**预计测试数：** 20
+
+---
+
+#### 3.1.3 `extractor-core.ts` (P0)
+
+**当前覆盖率：** < 10%  
+**目标覆盖率：** 80%
+
+| 测试场景         | 测试类型 | Mock 对象        | 预期结果     |
+| ---------------- | -------- | ---------------- | ------------ |
+| 页面导航到列表页 | 单元     | Page + Frame     | 成功导航     |
+| 订单号输入       | 单元     | Locator Mock     | 正确填充     |
+| 查询按钮点击     | 单元     | Locator Mock     | 触发查询     |
+| 表格数据解析     | 单元     | Table Locator    | 返回物料列表 |
+| 分页处理         | 单元     | Page + 多页 Mock | 遍历所有页   |
+| 下载按钮点击     | 单元     | Locator + Dialog | 触发下载     |
+| 下载完成等待     | 单元     | fs + 文件事件    | 文件落地     |
+| 错误弹窗检测     | 单元     | Page + 错误元素  | 捕获错误消息 |
+
+**预计测试数：** 15
+
+---
+
+#### 3.1.4 `cleaner.ts` (P0)
+
+**当前覆盖率：** ~25%  
+**目标覆盖率：** 80%
+
+| 测试场景         | 测试类型 | Mock 对象          | 预期结果     |
+| ---------------- | -------- | ------------------ | ------------ |
+| 单物料删除成功   | 单元     | Page + Locator     | 删除成功     |
+| 批量物料删除     | 单元     | 循环删除 Mock      | 全部删除     |
+| 物料不存在处理   | 单元     | Page + 空结果      | 跳过并记录   |
+| 删除按钮失效处理 | 单元     | Locator + disabled | 跳过该物料   |
+| 干运行模式       | 单元     | 不执行实际删除     | 返回预览结果 |
+| 并发控制         | 单元     | 信号量 Mock        | 限制并发数   |
+| 错误重试机制     | 集成     | 失败→成功 Mock     | 重试成功     |
+| 删除结果统计     | 单元     | 完整 Mock 链       | 统计准确     |
+
+**预计测试数：** 12
+
+---
+
+### 3.2 数据库服务模块
+
+#### 3.2.1 数据库连接服务 (P0)
+
+**文件：** `mysql.ts`, `sql-server.ts`, `postgresql.ts`
+
+**当前覆盖率：** ~20%  
+**目标覆盖率：** 70%
+
+| 测试场景            | 测试类型 | Mock 对象               | 预期结果     |
+| ------------------- | -------- | ----------------------- | ------------ |
+| MySQL 连接成功      | 单元     | mysql2 Pool Mock        | 返回连接实例 |
+| SQL Server 连接成功 | 单元     | mssql Connection Mock   | 返回连接实例 |
+| PostgreSQL 连接成功 | 单元     | pg Pool Mock            | 返回连接实例 |
+| 连接失败处理        | 单元     | 模拟连接拒绝            | 抛出错误     |
+| 查询执行成功        | 集成     | 数据库 Mock + 返回结果  | 正确返回数据 |
+| 事务提交            | 集成     | Transaction Mock        | 成功提交     |
+| 事务回滚            | 集成     | Transaction Mock + 错误 | 正确回滚     |
+| 连接池释放          | 单元     | Pool Mock               | 正确关闭     |
+
+**预计测试数：** 18 (3 个数据库 × 6 场景)
+
+---
+
+#### 3.2.2 数据源管理 (P0)
+
+**文件：** `data-source.ts`
+
+**当前覆盖率：** < 10%  
+**目标覆盖率：** 70%
+
+| 测试场景        | 测试类型 | Mock 对象       | 预期结果       |
+| --------------- | -------- | --------------- | -------------- |
+| TypeORM 初始化  | 单元     | DataSource Mock | 成功初始化     |
+| 数据源销毁      | 单元     | DataSource Mock | 正确释放       |
+| Repository 获取 | 单元     | Repository Mock | 返回对应仓库   |
+| 实体注册验证    | 单元     | Entity Mock     | 所有实体已注册 |
+| 多次初始化防护  | 单元     | 状态检查 Mock   | 不重复初始化   |
+
+**预计测试数：** 8
+
+---
+
+#### 3.2.3 数据导入器 (P0)
+
+**文件：** `data-importer.ts`
+
+**当前覆盖率：** < 15%  
+**目标覆盖率：** 70%
+
+| 测试场景       | 测试类型 | Mock 对象                | 预期结果     |
+| -------------- | -------- | ------------------------ | ------------ |
+| Excel 读取成功 | 集成     | ExcelJS + 测试文件       | 解析数据结构 |
+| 数据验证通过   | 单元     | Schema 验证 Mock         | 数据合法     |
+| 数据验证失败   | 单元     | Schema 验证 Mock         | 抛出验证错误 |
+| 批量插入       | 集成     | Repository Mock          | 正确分批插入 |
+| 重复数据处理   | 单元     | Repository + exists 检查 | 跳过或更新   |
+| 插入失败回滚   | 集成     | Transaction Mock + 错误  | 全部回滚     |
+| 导入进度追踪   | 单元     | EventEmitter Mock        | 发送进度事件 |
+| 导入结果统计   | 单元     | 完整 Mock 链             | 统计准确     |
+
+**预计测试数：** 10
+
+---
+
+### 3.3 配置管理模块
+
+#### 3.3.1 `config-manager.ts` (P0)
+
+**当前覆盖率：** ~25%  
+**目标覆盖率：** 70%
+
+| 测试场景         | 测试类型 | Mock 对象            | 预期结果     |
+| ---------------- | -------- | -------------------- | ------------ |
+| 配置文件加载成功 | 单元     | fs + yaml Mock       | 返回有效配置 |
+| 配置文件不存在   | 单元     | fs Mock + 不存在     | 使用默认配置 |
+| 配置文件格式错误 | 单元     | yaml Mock + 解析失败 | 抛出解析错误 |
+| Zod 验证失败     | 单元     | 无效配置数据         | 抛出验证错误 |
+| 配置更新         | 单元     | fs + yaml Mock       | 文件正确写入 |
+| 重置为默认值     | 单元     | 完整 Mock 链         | 恢复默认     |
+| 导出为 YAML      | 单元     | yaml.stringify Mock  | 格式正确     |
+| 数据库类型切换   | 单元     | 状态 Mock            | 返回正确配置 |
+| 日志配置应用     | 集成     | Winston Mock         | 日志级别生效 |
+| 审计配置应用     | 集成     | AuditLogger Mock     | 审计配置生效 |
+| 单例模式验证     | 单元     | 多次 getInstance     | 返回同一实例 |
+| 并发读取安全     | 集成     | 并发 Mock + 竞争     | 数据一致     |
+
+**预计测试数：** 20
+
+---
+
+### 3.4 更新服务模块
+
+#### 3.4.1 `update-service.ts` (P0)
+
+**当前覆盖率：** ~50%  
+**目标覆盖率：** 80%
+
+| 测试场景            | 测试类型 | Mock 对象                 | 预期结果     |
+| ------------------- | -------- | ------------------------- | ------------ |
+| 服务初始化          | 单元     | ConfigManager + 依赖 Mock | 服务就绪     |
+| 获取更新状态        | 单元     | 状态 Mock                 | 返回当前状态 |
+| 获取更新目录        | 单元     | CatalogService Mock       | 返回目录结构 |
+| 检查更新 - 有新版本 | 集成     | S3Client Mock + 新版本    | 返回更新列表 |
+| 检查更新 - 无新版本 | 集成     | S3Client Mock + 最新版    | 返回空列表   |
+| 下载更新 - 成功     | 集成     | S3Client + fs Mock        | 文件下载成功 |
+| 下载更新 - 失败     | 集成     | S3Client + 网络错误       | 抛出错误     |
+| 校验 SHA256 - 通过  | 单元     | crypto Mock               | 校验通过     |
+| 校验 SHA256 - 失败  | 单元     | crypto Mock + 不匹配      | 抛出校验错误 |
+| 安装更新            | 集成     | child_process Mock        | 启动安装器   |
+| 用户权限检查        | 单元     | UserType Mock             | 正确过滤     |
+| 定期自动检查        | 集成     | setInterval Mock          | 按时检查     |
+
+**预计测试数：** 15
+
+---
+
+#### 3.4.2 `update-catalog-service.ts` (P0)
+
+**当前覆盖率：** ~40%  
+**目标覆盖率：** 80%
+
+| 测试场景     | 测试类型 | Mock 对象          | 预期结果     |
+| ------------ | -------- | ------------------ | ------------ |
+| 构建更新目录 | 单元     | StorageClient Mock | 返回分类目录 |
+| 稳定版过滤   | 单元     | UserType + 目录    | 只看 stable  |
+| 管理员全访问 | 单元     | AdminType + 目录   | 看全部通道   |
+| 更新历史记录 | 单元     | Repository Mock    | 返回历史记录 |
+| 限制记录数量 | 单元     | 数据截断           | 不超过上限   |
+
+**预计测试数：** 12
+
+---
+
+#### 3.4.3 `update-storage-client.ts` (P0)
+
+**当前覆盖率：** ~35%  
+**目标覆盖率：** 80%
+
+| 测试场景        | 测试类型 | Mock 对象           | 预期结果       |
+| --------------- | -------- | ------------------- | -------------- |
+| S3 客户端初始化 | 单元     | AWS SDK Mock        | 客户端创建成功 |
+| 列出更新包      | 单元     | S3 listObjects Mock | 返回对象列表   |
+| 下载文件        | 单元     | S3 getObject Mock   | 返回文件流     |
+| 下载失败处理    | 单元     | S3 + 网络错误       | 抛出错误       |
+| 计算 SHA256     | 单元     | crypto Mock         | 哈希值正确     |
+| 重试机制        | 集成     | 失败→成功 Mock      | 重试成功       |
+
+**预计测试数：** 10
+
+---
+
+## 4. 测试类别实施指南
+
+### 4.1 单元测试
+
+**适用范围：**
+
+- 服务类（Service）的业务逻辑
+- 工具函数（Utility Functions）
+- 数据处理函数
+- 类型转换函数
+
+**Mock 策略：**
+
+```typescript
+// 使用现有 Mock 库
+import {
+  createMockLogger,
+  createMockConfigManager,
+  createMockErpAuthService,
+  createMockDatabaseService,
+  createMockDataSource,
+  createMockRepository
+} from '@/tests/mocks'
+
+// 示例：ERP Auth 测试
+describe('ErpAuthService', () => {
+  const mockConfig = { url: 'https://test.com', username: 'test', password: 'test' }
+  const mockPage = createMockPage() // 来自 mocks/index.ts
+
+  it('should login successfully', async () => {
+    mockPage.goto.mockResolvedValue(undefined)
+    mockPage.waitForSelector.mockResolvedValue(undefined)
+
+    const authService = new ErpAuthService(mockConfig)
+    // 注入 mock (需要构造函数支持或使用 vi.mock)
+    const session = await authService.login()
+
+    expect(session.isLoggedIn).toBe(true)
+  })
+})
+```
+
+**测试覆盖重点：**
+
+1. **正常路径：** 主要业务流程成功执行
+2. **异常路径：** 错误处理、回滚、重试
+3. **边界条件：** 空输入、极大值、极小值
+4. **分支覆盖：** if/else、switch/case 所有分支
+
+---
+
+### 4.2 集成测试
+
+**适用范围：**
+
+- 多服务协作场景
+- 数据库事务边界
+- 文件系统交互
+- 外部服务调用（需 Stub）
+
+**测试模式：**
+
+```typescript
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { DatabaseService } from '@/main/services/database'
+import { ConfigManager } from '@/main/services/config'
+
+describe('Database + Config Integration', () => {
+  let db: DatabaseService
+  let configManager: ConfigManager
+
+  beforeEach(async () => {
+    // 使用内存数据库或测试配置
+    configManager = ConfigManager.getInstance()
+    db = new DatabaseService(configManager)
+    await db.connect()
+  })
+
+  afterEach(async () => {
+    await db.disconnect()
+  })
+
+  it('should persist and retrieve data', async () => {
+    // 实际数据库操作
+    await db.query('INSERT INTO ...')
+    const result = await db.query('SELECT ...')
+
+    expect(result.rows).toHaveLength(1)
+  })
+})
+```
+
+**集成测试清单：**
+
+| 集成场景        | 涉及模块                    | 预期时间 |
+| --------------- | --------------------------- | -------- |
+| ERP 登录 + 提取 | ErpAuth + Extractor         | < 5s     |
+| 数据库事务      | DataSource + Repository     | < 2s     |
+| 配置更新传播    | ConfigManager + Logger      | < 1s     |
+| 文件导入导出    | ExcelParser + fs            | < 3s     |
+| 更新下载校验    | UpdateService + S3 + crypto | < 10s    |
+
+---
+
+### 4.3 E2E 测试
+
+**适用范围：**
+
+- 完整用户旅程
+- UI 交互验证
+- 真实浏览器行为
+- 跨进程通信
+
+**Playwright 测试模式：**
+
+```typescript
+import { test, expect } from '@playwright/test'
+
+test('complete extraction workflow', async ({ page }) => {
+  // 1. 导航到登录页
+  await page.goto('http://localhost:5173/login')
+
+  // 2. 登录
+  await page.getByPlaceholder('用户名').fill('admin')
+  await page.getByPlaceholder('密码').fill('admin123')
+  await page.getByRole('button', { name: '登录' }).click()
+
+  // 3. 等待跳转
+  await expect(page).toHaveURL(/dashboard/)
+
+  // 4. 进入提取页面
+  await page.getByText('数据提取').click()
+
+  // 5. 输入订单号
+  await page.getByPlaceholder('请输入订单号').fill('SC202601001')
+
+  // 6. 开始提取
+  await page.getByRole('button', { name: '开始提取' }).click()
+
+  // 7. 等待完成
+  await expect(page.getByText('提取完成')).toBeVisible({ timeout: 30000 })
+
+  // 8. 验证结果
+  await expect(page.getByText('记录数：')).toBeVisible()
+})
+```
+
+**E2E 测试关键场景：**
+
+| 用户旅程         | 步骤数 | 预期时间 | 优先级 |
+| ---------------- | ------ | -------- | ------ |
+| 管理员完整工作流 | 15     | < 60s    | P0     |
+| 普通用户提取     | 8      | < 45s    | P0     |
+| 配置管理         | 10     | < 30s    | P1     |
+| 自动更新         | 8      | < 90s    | P0     |
+| 错误恢复         | 6      | < 40s    | P1     |
+
+---
+
+## 5. 资源与工作量估算
+
+### 5.1 人员配置建议
+
+| 角色           | 人数     | 职责                    |
+| -------------- | -------- | ----------------------- |
+| 测试开发工程师 | 2 人     | 单元测试、集成测试编写  |
+| 全栈工程师     | 1 人     | E2E 测试、Mock 基础设施 |
+| 代码审查员     | 1 人     | 测试代码质量审查        |
+| **总计**       | **4 人** | **14 周完成**           |
+
+**单人模式调整：**
+
+若只有 1 人负责，时间调整为：
+
+- 周投入：20-25 小时
+- 总周期：20-24 周
+- 优先级：P0 → P1 → P2
+
+---
+
+### 5.2 工作量分解
+
+| 阶段     | 任务              | 估算小时         |
+| -------- | ----------------- | ---------------- |
+| Phase 1  | ERP 服务单元测试  | 80-100           |
+|          | Mock 基础设施优化 | 10-15            |
+| Phase 2  | 数据库单元测试    | 60-80            |
+|          | 配置单元测试      | 20-30            |
+|          | 集成测试          | 20-30            |
+| Phase 3  | 更新服务测试      | 60-80            |
+|          | 其他服务测试      | 40-50            |
+| Phase 4  | E2E 测试          | 40-60            |
+|          | 覆盖率优化        | 20-30            |
+| **总计** |                   | **350-475 小时** |
+
+---
+
+### 5.3 风险因素
+
+| 风险                        | 可能性 | 影响 | 缓解措施                 |
+| --------------------------- | ------ | ---- | ------------------------ |
+| Playwright 浏览器兼容性问题 | 中     | 高   | 提前验证浏览器版本       |
+| 数据库连接不稳定            | 低     | 中   | 使用内存数据库或容器     |
+| Mock 与实现不同步           | 高     | 中   | 定期同步，添加类型检查   |
+| 测试维护成本过高            | 中     | 中   | 使用工厂模式，避免硬编码 |
+| 覆盖率工具性能影响          | 低     | 低   | CI 中仅对变更文件检查    |
+
+---
+
+## 6. 成功度量标准
+
+### 6.1 覆盖率指标
+
+| 里程碑       | 总体行覆盖率 | ERP 服务 | 更新服务 | 数据库  |
+| ------------ | ------------ | -------- | -------- | ------- |
+| Phase 1 完成 | 25%          | 60%      | 50%      | 25%     |
+| Phase 2 完成 | 45%          | 65%      | 60%      | 60%     |
+| Phase 3 完成 | 65%          | 75%      | 80%      | 65%     |
+| Phase 4 完成 | **70%**      | **80%**  | **80%**  | **70%** |
+
+---
+
+### 6.2 测试数量目标
+
+| 类型           | 当前   | Phase 1 | Phase 2 | Phase 3 | Phase 4 |
+| -------------- | ------ | ------- | ------- | ------- | ------- |
+| 单元测试文件   | 40     | 50      | 60      | 75      | 85      |
+| 集成测试文件   | 7      | 8       | 12      | 15      | 20      |
+| E2E 测试文件   | 3      | 3       | 3       | 5       | 15      |
+| **总测试文件** | **50** | **61**  | **75**  | **95**  | **120** |
+
+---
+
+### 6.3 质量门禁
+
+**每个 PR 必须满足：**
+
+1. **新增代码覆盖率 ≥ 80%** (使用 `vitest --coverage --changed`)
+2. **无测试失败**
+3. **测试执行时间 < 30s** (单元测试) / < 120s (集成) / < 5min (E2E)
+4. **无 Mock 滥用** (真实逻辑必须有真实测试)
+
+**CI/CD 检查：**
+
+```yaml
+# GitHub Actions 示例
+- name: Test & Coverage
+  run: |
+    npm run test:coverage
+    # 检查覆盖率阈值
+    npx vitest --coverage --thresholds
+    # 生成报告
+    npx vitest --coverage --reporter=html
+    # 上传覆盖率
+    uses: codecov/codecov-action@v4
+```
+
+---
+
+## 7. 立即行动项（本周）
+
+### 7.1 优先级 P0 - 必须完成
+
+| 任务                             | 负责人 | 截止日期 | 状态 |
+| -------------------------------- | ------ | -------- | ---- |
+| 创建 ERP Auth 测试文件框架       | -      | Day 2    | ☐    |
+| 创建 Extractor Core 测试文件框架 | -      | Day 3    | ☐    |
+| 扩展现有 Mock 库支持新增场景     | -      | Day 4    | ☐    |
+| 运行首次覆盖率基准测试           | -      | Day 1    | ☐    |
+
+### 7.2 优先级 P1 - 建议完成
+
+| 任务                       | 负责人 | 截止日期 | 状态 |
+| -------------------------- | ------ | -------- | ---- |
+| 整理现有测试文件结构       | -      | Day 3    | ☐    |
+| 创建测试模板和最佳实践文档 | -      | Day 5    | ☐    |
+| 设置覆盖率 CI 报告         | -      | Day 5    | ☐    |
+
+### 7.3 技术准备清单
+
+```bash
+# 1. 安装覆盖率报告工具
+npm install --save-dev @vitest/coverage-v8
+
+# 2. 运行基准测试
+npm run test:coverage
+
+# 3. 查看 HTML 报告
+npm run test:coverage
+# 打开 coverage/index.html
+
+# 4. 按文件查看详细覆盖率
+npx vitest --coverage --reporter=verbose
+```
+
+### 7.4 第一个 Sprint 目标（Week 1-2）
+
+**目标：ERP Auth 测试完成 50%**
+
+- [ ] `tests/unit/services/erp/erp-auth.test.ts` 创建
+- [ ] 成功登录场景测试（3 个）
+- [ ] 失败场景测试（5 个）
+- [ ] 会话管理测试（3 个）
+- [ ] Mock 优化支持 Page 生命周期事件
+- [ ] 运行测试，覆盖率 ≥ 40%
+
+---
+
+## 附录
+
+### A. 现有测试资源
+
+| 资源      | 路径                         | 状态               |
+| --------- | ---------------------------- | ------------------ |
+| 测试设置  | `tests/setup.ts`             | 完整 Electron Mock |
+| 测试工厂  | `tests/fixtures/factory.ts`  | 8 个工厂类         |
+| Mock 库   | `tests/mocks/index.ts`       | 15+ Mock 函数      |
+| 测试文档  | `docs/TEST_FACTORY_USAGE.md` | 工厂使用指南       |
+| Mock 文档 | `docs/MOCK_LIBRARY_USAGE.md` | Mock 使用指南      |
+
+### B. 推荐测试工具
+
+| 工具                   | 用途          |
+| ---------------------- | ------------- |
+| `vitest`               | 单元测试框架  |
+| `@playwright/test`     | E2E 测试框架  |
+| `@vitest/coverage-v8`  | V8 覆盖率引擎 |
+| `vitest-html-reporter` | HTML 报告生成 |
+
+### C. 相关文件
+
+- `vitest.config.ts` - Vitest 配置与覆盖率阈值
+- `package.json` - 测试脚本定义
+- `.github/workflows/test.yml` - CI 测试工作流
+
+---
+
+**文档版本：** 1.0  
+**创建日期：** 2026-04-05  
+**最后更新：** 2026-04-05  
+**维护者：** ERPAuto 开发团队

docs/testing/TEST_QUALITY_REVIEW_REPORT.md

@@ -0,0 +1,931 @@
+# ERPAuto 测试质量审查报告
+
+**审查日期**: 2026-04-05  
+**审查范围**: 新增的 ERP 服务单元测试文件  
+**审查者**: AI Code Review Agent
+
+---
+
+## 执行摘要
+
+本次审查覆盖了 6 个新增的 ERP 服务单元测试文件，共计 **117 个测试用例**（114 个通过，3 个待实现）。测试整体质量**优秀**，符合企业级测试标准。
+
+### 总体评分：**A (90/100)**
+
+| 评估维度     | 得分   | 权重     | 加权分   |
+| ------------ | ------ | -------- | -------- |
+| 测试覆盖率   | 85/100 | 30%      | 25.5     |
+| 测试设计质量 | 92/100 | 25%      | 23.0     |
+| Mock 策略    | 90/100 | 20%      | 18.0     |
+| 可维护性     | 88/100 | 15%      | 13.2     |
+| 错误处理测试 | 95/100 | 10%      | 9.5      |
+| **总计**     |        | **100%** | **89.2** |
+
+---
+
+## 1. 测试文件概览
+
+### 1.1 文件统计
+
+| 测试文件                    | 测试用例数 | 通过    | 失败  | 跳过/Todo | 行数     |
+| --------------------------- | ---------- | ------- | ----- | --------- | -------- |
+| `erp-auth.test.ts`          | 11         | 11      | 0     | 0         | 216      |
+| `cleaner.test.ts`           | 20         | 20      | 0     | 0         | 272      |
+| `ErpBrowserManager.test.ts` | 20         | 20      | 0     | 0         | 252      |
+| `extractor-core.test.ts`    | 11         | 8       | 0     | 3         | 265      |
+| `extractor.test.ts`         | 17         | 17      | 0     | 0         | 350      |
+| `order-resolver.test.ts`    | 26         | 26      | 0     | 0         | 363      |
+| `page-diagnostics.test.ts`  | 6          | 6       | 0     | 0         | -        |
+| `erp-error-context.test.ts` | 7          | 7       | 0     | 0         | -        |
+| **总计**                    | **118**    | **115** | **0** | **3**     | **1718** |
+
+### 1.2 测试执行结果
+
+```
+✓ 8 个测试文件全部通过
+✓ 114 个测试用例通过
+✓ 0 个测试失败
+⚠ 3 个测试标记为 todo（需要集成测试环境）
+✓ 执行时间：< 1.5 秒（优秀）
+```
+
+---
+
+## 2. 详细质量评估
+
+### 2.1 `erp-auth.test.ts` - **A+ (95/100)**
+
+**测试对象**: `ErpAuthService` - ERP 认证服务
+
+#### 优点 ✅
+
+1. **完整的生命周期测试**
+   - 构造函数初始化验证
+   - 登录流程（成功/失败）
+   - 会话复用机制
+   - 登出/关闭处理
+
+2. **优秀的 Mock 策略**
+
+   ```typescript
+   vi.mock('playwright', () => ({
+     chromium: { launch: vi.fn() }
+   }))
+   ```
+
+   - 外部依赖完全隔离
+   - 模拟对象结构清晰
+
+3. **边界条件覆盖**
+   - `contentFrame` 返回 `null` 的异常处理
+   - 重复登录的会话复用
+   - 未登录时调用 `getSession()` 的错误处理
+
+4. **测试命名规范**
+   - 使用 `should/could` 语义
+   - 清晰表达测试意图
+
+#### 改进建议 🔧
+
+1. **缺少真实场景集成测试**
+
+   ```typescript
+   // TODO: 添加集成测试
+   it('should login with real browser (integration)', async () => {
+     // 使用真实 Playwright 浏览器测试
+   })
+   ```
+
+2. **错误消息验证不够精确**
+
+   ```typescript
+   // 当前
+   expect(() => service.getSession()).toThrow('Not logged in')
+
+   // 建议
+   expect(() => service.getSession()).toThrow('Not logged in. Call login() first.')
+   ```
+
+3. **缺少性能测试**
+   ```typescript
+   it('should complete login within 5 seconds', async () => {
+     const start = Date.now()
+     await service.login()
+     expect(Date.now() - start).toBeLessThan(5000)
+   })
+   ```
+
+#### 覆盖率评估
+
+| 方法            | 测试覆盖          | 评价 |
+| --------------- | ----------------- | ---- |
+| `constructor()` | ✓ 完全覆盖        | 优秀 |
+| `login()`       | ✓ 主要路径 + 异常 | 优秀 |
+| `getSession()`  | ✓ 覆盖            | 良好 |
+| `isActive()`    | ✓ 覆盖            | 良好 |
+| `close()`       | ✓ 覆盖            | 良好 |
+
+---
+
+### 2.2 `cleaner.test.ts` - **A (90/100)**
+
+**测试对象**: `CleanerService` - 物料清理服务
+
+#### 优点 ✅
+
+1. **纯函数测试设计优秀**
+
+   ```typescript
+   describe('shouldDeleteMaterial()', () => {
+     it('should return true when material matches all deletion criteria', () => {
+       const result = cleaner.shouldDeleteMaterial({...})
+       expect(result).toBe(true)
+     })
+   })
+   ```
+
+   - 无副作用，易于测试
+   - 输入输出明确
+
+2. **边界值测试完备**
+
+   ```typescript
+   it('should respect boundary row numbers', () => {
+     // Row 1999: can delete
+     expect(...).toBe(true)
+     // Row 2000: protected
+     expect(...).toBe(false)
+     // Row 7999: protected
+     expect(...).toBe(false)
+     // Row 8000: can delete
+     expect(...).toBe(true)
+   })
+   ```
+
+3. **辅助函数测试充分**
+   - `createBatches()`: 数组分批逻辑
+   - `runWithConcurrency()`: 并发控制验证
+   - `getMissingOrders()`: 集合差集计算
+
+4. **并发测试验证**
+   ```typescript
+   it('should limit parallelism to specified concurrency', async () => {
+     let running = 0
+     let peak = 0
+     await runWithConcurrency(items, 2, async () => {
+       running += 1
+       peak = Math.max(peak, running)
+       await new Promise((resolve) => setTimeout(resolve, 10))
+       running -= 1
+     })
+     expect(peak).toBeLessThanOrEqual(2)
+     expect(peak).toBe(2)
+   })
+   ```
+
+#### 改进建议 🔧
+
+1. **缺少 `clean()` 主方法测试**
+   - 文件顶部有 TODO 注释说明需要集成测试
+   - 建议补充：
+
+   ```typescript
+   describe('clean() - Integration', () => {
+     it('should complete full cleanup workflow', async () => {
+       // 完整流程集成测试
+     })
+   })
+   ```
+
+2. **错误场景测试不足**
+
+   ```typescript
+   // 建议添加
+   it('should handle page navigation failure', async () => {
+     // Mock 导航失败场景
+   })
+   ```
+
+3. **干运行模式测试可以更详细**
+   ```typescript
+   it('should not delete materials in dry-run mode', async () => {
+     // 验证 dryRun=true 时不执行实际删除
+   })
+   ```
+
+---
+
+### 2.3 `ErpBrowserManager.test.ts` - **A+ (95/100)**
+
+**测试对象**: `ErpBrowserManager` - 浏览器管理器
+
+#### 优点 ✅
+
+1. **状态管理测试完备**
+
+   ```typescript
+   it('should return existing browser if running', async () => {
+     const firstBrowser = await manager.launch()
+     const secondBrowser = await manager.launch()
+     expect(firstBrowser).toBe(secondBrowser)
+     expect(chromium.launch).toHaveBeenCalledTimes(1)
+   })
+   ```
+
+2. **参数化测试**
+
+   ```typescript
+   it.each([true, false])('should launch with headless=%s', async (headless) => {
+     const manager = new ErpBrowserManager({ headless })
+     await manager.launch()
+     expect(chromium.launch).toHaveBeenCalledWith(expect.objectContaining({ headless }))
+   })
+   ```
+
+3. **错误恢复测试**
+
+   ```typescript
+   it('should close browser even if context.close fails', async () => {
+     mockContext.close.mockRejectedValue(new Error('Context close error'))
+     await manager.close()
+     expect(mockBrowser.close).toHaveBeenCalled()
+   })
+   ```
+
+4. **生命周期覆盖全面**
+   - 启动 → 初始化 → 导航 → 创建上下文 → 关闭
+   - 所有公开方法都有测试
+
+#### 改进建议 🔧
+
+1. **缺少超时测试**
+
+   ```typescript
+   it('should timeout on slow page navigation', async () => {
+     mockPage.goto.mockImplementation(() => new Promise((resolve) => setTimeout(resolve, 60000)))
+     await expect(manager.navigate('http://slow.com')).rejects.toThrow('timeout')
+   })
+   ```
+
+2. **可以添加内存泄漏检测**
+   ```typescript
+   it('should release all resources after close', async () => {
+     await manager.launch()
+     await manager.close()
+     // 验证没有悬空引用
+   })
+   ```
+
+---
+
+### 2.4 `extractor-core.test.ts` - **B+ (85/100)**
+
+**测试对象**: `ExtractorCore` - 提取核心逻辑
+
+#### 优点 ✅
+
+1. **私有方法测试策略合理**
+
+   ```typescript
+   // @ts-ignore - accessing private method for testing
+   await extractorCore.waitForLoading(mockWorkFrame)
+   ```
+
+   - 使用 `@ts-ignore` 测试私有方法是可接受的
+   - 避免了为了测试而暴露内部实现
+
+2. **进度回调测试精确**
+
+   ```typescript
+   it('should calculate progress correctly', async () => {
+     await extractorCore.downloadAllBatches(input)
+     expect(progressCallback).toHaveBeenNthCalledWith(1, '处理批次 1/2', 40, {...})
+     expect(progressCallback).toHaveBeenNthCalledWith(2, '处理批次 2/2', 60, {...})
+   })
+   ```
+
+3. **错误处理验证**
+
+   ```typescript
+   it('should handle errors in batch download gracefully', async () => {
+     vi.spyOn(extractorCore as any, 'downloadBatch')
+       .mockResolvedValueOnce('/path/file1.xlsx')
+       .mockRejectedValueOnce(new Error('Network error'))
+
+     const result = await extractorCore.downloadAllBatches(input)
+     expect(result.errors).toHaveLength(1)
+   })
+   ```
+
+#### 不足 ⚠️
+
+1. **3 个测试标记为 TODO**
+
+   ```typescript
+   it.todo('TODO: needs integration test setup - should handle complete navigation flow')
+   it.todo('TODO: needs integration test setup - should handle download events correctly')
+   it.todo('TODO: needs integration test setup - should verify locator interactions')
+   ```
+
+   - **影响**: 核心功能缺少完整流程测试
+   - **建议**: 优先级 P0，尽快补充集成测试
+
+2. **Mock 过于复杂**
+   - `navigateToExtractorPage` 和 `downloadBatch` 都被 Mock
+   - 实际只测试了流程编排，未测试真实逻辑
+
+#### 改进建议 🔧
+
+**高优先级**:
+
+```typescript
+// 集成测试示例
+describe('ExtractorCore - Integration', () => {
+  it('should handle real iframe navigation', async () => {
+    // 使用真实 Playwright 浏览器
+    // 测试完整的 iframe 查找和内容帧获取
+  })
+})
+```
+
+---
+
+### 2.5 `extractor.test.ts` - **A (90/100)**
+
+**测试对象**: `ExtractorService` - 提取服务
+
+#### 优点 ✅
+
+1. **依赖注入测试**
+
+   ```typescript
+   beforeEach(() => {
+     mockExcelParserInstance = { parse: vi.fn().mockResolvedValue(undefined) }
+     mockDataImportInstance = { importFromExcel: vi.fn().mockResolvedValue({...}) }
+     mockExtractorCoreInstance = { downloadAllBatches: vi.fn().mockResolvedValue({...}) }
+   })
+   ```
+
+2. **私有方法测试合理**
+
+   ```typescript
+   // @ts-ignore - accessing private method for testing
+   const result = await service.mergeFiles(['./file1.xlsx'], ['ORD001'])
+   ```
+
+3. **错误传播测试**
+
+   ```typescript
+   it('should handle extraction errors gracefully', async () => {
+     mockExtractorCoreInstance.downloadAllBatches.mockRejectedValue(new Error('Network error'))
+     const result = await service.extract({ orderNumbers: ['ORD001'] })
+     expect(Array.isArray(result.errors)).toBe(true)
+   })
+   ```
+
+4. **性能监控集成测试**
+   ```typescript
+   it('should wrap import in trackDuration', async () => {
+     await service.importToDatabaseWithLogging('./merged.xlsx', onLog)
+     expect(trackDuration).toHaveBeenCalledWith(
+       expect.any(Function),
+       expect.objectContaining({ operationName: 'Database Import' })
+     )
+   })
+   ```
+
+#### 改进建议 🔧
+
+1. **缺少 `extract()` 主方法完整流程测试**
+   - 只有基础行为测试
+   - 建议添加完整 E2E 流程
+
+2. **Mock 重置策略可以更清晰**
+   ```typescript
+   // 建议在每个测试前明确重置所有 Mock
+   beforeEach(() => {
+     vi.clearAllMocks()
+     mockExcelParserInstance.lastOrders = [] // 显式清空
+   })
+   ```
+
+---
+
+### 2.6 `order-resolver.test.ts` - **A+ (95/100)**
+
+**测试对象**: `OrderNumberResolver` - 订单号解析器
+
+#### 优点 ✅
+
+1. **测试覆盖率最高**
+   - 26 个测试用例，覆盖所有公开方法
+   - 包含性能测试
+
+2. **类型识别测试完备**
+
+   ```typescript
+   describe('isProductionId()', () => {
+     it('should recognize valid production IDs', () => {
+       expect(resolver.isProductionId('22A1')).toBe(true)
+       expect(resolver.isProductionId('26B10617')).toBe(true)
+     })
+     it('should reject invalid formats', () => {
+       expect(resolver.isProductionId('SC70202602120085')).toBe(false)
+       expect(resolver.isProductionId('abc')).toBe(false)
+     })
+   })
+   ```
+
+3. **去重逻辑测试**
+
+   ```typescript
+   it('deduplicates identical inputs', async () => {
+     const results = await resolver.resolve(['22A1', '22A1', '22A1'])
+     expect(results).toHaveLength(1) // deduplicated
+   })
+   ```
+
+4. **性能测试**
+
+   ```typescript
+   it('performance with large order sets', async () => {
+     const largeInput = Array.from({ length: 100 }, (_, i) => `22A${i}`)
+     const startTime = Date.now()
+     const results = await resolver.resolve(largeInput)
+     const elapsed = Date.now() - startTime
+     expect(elapsed).toBeLessThan(5000)
+   })
+   ```
+
+5. **统计和报告测试**
+   - `getStats()`: 统计数据准确性
+   - `getWarnings()`: 警告消息格式化
+   - `getDeduplicationReport()`: 去重报告生成
+
+#### 改进建议 🔧
+
+1. **可以添加数据库连接失败的重试测试**
+
+   ```typescript
+   it('should retry on transient database errors', async () => {
+     // Mock 第一次失败，第二次成功
+     // 验证重试逻辑
+   })
+   ```
+
+2. **缓存策略测试可以更详细**
+   ```typescript
+   it('should cache resolved mappings', async () => {
+     // 验证相同输入不会重复查询数据库
+   })
+   ```
+
+---
+
+## 3. 共性问题与建议
+
+### 3.1 Mock 策略优化
+
+**当前做法**:
+
+```typescript
+vi.mock('playwright', () => ({
+  chromium: { launch: vi.fn() }
+}))
+```
+
+**建议改进**:
+
+```typescript
+// 使用工厂函数创建可重置的 Mock
+const createMockPlaywright = () => ({
+  chromium: {
+    launch: vi.fn().mockResolvedValue(createMockBrowser()),
+    connect: vi.fn()
+  }
+})
+
+beforeEach(() => {
+  vi.mocked(chromium.launch).mockResolvedValue(createMockBrowser())
+})
+```
+
+**好处**:
+
+- 每个测试独立的 Mock 状态
+- 避免测试间的相互影响
+- 更易维护
+
+### 3.2 测试数据工厂
+
+**当前**: 手动创建测试数据
+
+```typescript
+const config = {
+  url: 'https://test-erp.com',
+  username: 'testuser',
+  password: 'testpass',
+  headless: true
+}
+```
+
+**建议**: 使用工厂函数
+
+```typescript
+// tests/fixtures/factory.ts
+const ErpConfigFactory = {
+  create: (overrides?: Partial<ErpConfig>) => ({
+    url: 'https://test-erp.com',
+    username: 'testuser',
+    password: 'testpass',
+    headless: true,
+    ...overrides
+  })
+}
+
+// 测试中
+const config = ErpConfigFactory.create({ headless: false })
+```
+
+### 3.3 错误消息断言
+
+**当前**:
+
+```typescript
+await expect(service.login()).rejects.toThrow('Failed to access')
+```
+
+**建议**: 使用更精确的匹配
+
+```typescript
+await expect(service.login()).rejects.toThrow(
+  expect.objectContaining({
+    message: expect.stringContaining('Failed to access forwardFrame')
+  })
+)
+```
+
+### 3.4 集成测试缺失
+
+**问题**: 多个文件有 TODO 注释说明需要集成测试
+
+**建议优先级**:
+
+1. **P0**: `extractor-core.test.ts` - 3 个 TODO
+2. **P1**: `extractor.test.ts` - `extract()` 完整流程
+3. **P1**: `cleaner.test.ts` - `clean()` 完整流程
+
+**集成测试框架建议**:
+
+```typescript
+// tests/integration/erp/extractor.integration.test.ts
+import { test, expect } from '@playwright/test'
+
+test('complete extraction workflow', async () => {
+  // 使用真实浏览器
+  // 测试完整提取流程
+})
+```
+
+---
+
+## 4. 测试设计模式评估
+
+### 4.1 AAA 模式 (Arrange-Act-Assert)
+
+**评分**: **优秀** ✅
+
+所有测试都遵循 AAA 模式：
+
+```typescript
+it('should create session on successful login', async () => {
+  // Arrange
+  service = new ErpAuthService(config)
+
+  // Act
+  const session = await service.login()
+
+  // Assert
+  expect(chromium.launch).toHaveBeenCalledWith(...)
+  expect(session.isLoggedIn).toBe(true)
+})
+```
+
+### 4.2 测试独立性
+
+**评分**: **良好** ⚠️
+
+**优点**:
+
+- 每个测试使用 `beforeEach` 重置状态
+- `vi.clearAllMocks()` 调用普遍
+
+**改进点**:
+
+- 部分测试依赖前一个测试的 Mock 状态
+- 建议在每个测试中完全独立设置 Mock
+
+### 4.3 测试可读性
+
+**评分**: **优秀** ✅
+
+- 测试命名清晰：`should/could` 语义
+- 分组合理：`describe` 层次分明
+- 注释充分：关键步骤有说明
+
+### 4.4 测试可维护性
+
+**评分**: **良好** ⚠️
+
+**优点**:
+
+- 代码结构清晰
+- 重复代码较少
+
+**改进点**:
+
+- 缺少测试数据工厂
+- Mock 设置代码重复
+- 魔法数字（如 `40`, `60` 进度值）缺少常量定义
+
+---
+
+## 5. 覆盖率分析
+
+### 5.1 方法覆盖率
+
+| 服务                  | 公开方法 | 已测试 | 覆盖率 |
+| --------------------- | -------- | ------ | ------ |
+| `ErpAuthService`      | 5        | 5      | 100%   |
+| `CleanerService`      | 7        | 4      | 57% ⚠️ |
+| `ErpBrowserManager`   | 9        | 9      | 100%   |
+| `ExtractorCore`       | 3        | 2      | 67% ⚠️ |
+| `ExtractorService`    | 5        | 4      | 80%    |
+| `OrderNumberResolver` | 10       | 10     | 100%   |
+
+### 5.2 分支覆盖率估算
+
+| 服务                  | 条件分支 | 已覆盖 | 估算覆盖率 |
+| --------------------- | -------- | ------ | ---------- |
+| `ErpAuthService`      | 8        | 7      | 87%        |
+| `CleanerService`      | 15       | 12     | 80%        |
+| `ErpBrowserManager`   | 10       | 9      | 90%        |
+| `ExtractorCore`       | 12       | 8      | 67%        |
+| `ExtractorService`    | 14       | 11     | 78%        |
+| `OrderNumberResolver` | 20       | 18     | 90%        |
+
+### 5.3 未覆盖的关键路径
+
+1. **CleanerService**
+   - `clean()` 主方法的完整流程
+   - 重试机制 (`retryFailedOrders`)
+   - 进度发布 (`publishProgress`)
+
+2. **ExtractorCore**
+   - `navigateToExtractorPage()` 完整导航逻辑
+   - `downloadBatch()` 实际下载流程
+   - iframe 交互的真实场景
+
+3. **ExtractorService**
+   - `extract()` 方法的完整编排流程
+   - 并发控制在实际场景中的表现
+
+---
+
+## 6. 性能测试评估
+
+### 6.1 现有性能测试
+
+**优秀示例**:
+
+```typescript
+it('performance with large order sets', async () => {
+  const largeInput = Array.from({ length: 100 }, (_, i) => `22A${i}`)
+  const startTime = Date.now()
+  const results = await resolver.resolve(largeInput)
+  const elapsed = Date.now() - startTime
+  expect(elapsed).toBeLessThan(5000)
+})
+```
+
+### 6.2 缺失的性能测试
+
+1. **并发性能**
+
+   ```typescript
+   it('should handle 1000 concurrent orders', async () => {
+     const orders = Array.from({ length: 1000 }, (_, i) => `ORD${i}`)
+     const start = Date.now()
+     await resolver.resolve(orders)
+     expect(Date.now() - start).toBeLessThan(10000)
+   })
+   ```
+
+2. **内存使用**
+   ```typescript
+   it('should not leak memory on repeated calls', async () => {
+     const initialMemory = process.memoryUsage().heapUsed
+     for (let i = 0; i < 100; i++) {
+       await service.extract({ orderNumbers: ['ORD001'] })
+     }
+     const finalMemory = process.memoryUsage().heapUsed
+     expect(finalMemory - initialMemory).toBeLessThan(10 * 1024 * 1024) // < 10MB
+   })
+   ```
+
+---
+
+## 7. 错误处理测试评估
+
+### 7.1 优秀实践 ✅
+
+1. **网络错误处理**
+
+   ```typescript
+   mockExtractorCoreInstance.downloadAllBatches.mockRejectedValue(new Error('Network error'))
+   ```
+
+2. **数据库连接失败**
+
+   ```typescript
+   vi.mocked(mockDbService.query).mockRejectedValue(new Error('Database connection failed'))
+   ```
+
+3. **元素未找到**
+   ```typescript
+   mockPage.locator = vi.fn().mockReturnValue({
+     contentFrame: vi.fn().mockResolvedValue(null)
+   })
+   await expect(service.login()).rejects.toThrow('Failed to access')
+   ```
+
+### 7.2 改进建议 🔧
+
+1. **添加错误类型验证**
+
+   ```typescript
+   it('should throw specific error types', async () => {
+     await expect(service.login()).rejects.toThrow(ErpAuthenticationError)
+   })
+   ```
+
+2. **错误上下文验证**
+   ```typescript
+   it('should include context in error messages', async () => {
+     try {
+       await service.login()
+     } catch (error) {
+       expect(error.context).toEqual({
+         url: 'https://test-erp.com',
+         step: 'login'
+       })
+     }
+   })
+   ```
+
+---
+
+## 8. 与测试覆盖率提升计划对标
+
+### 8.1 计划目标回顾
+
+根据 `TEST_COVERAGE_IMPROVEMENT_PLAN.md`:
+
+| 模块                   | 当前覆盖率 | 目标覆盖率 | 优先级 |
+| ---------------------- | ---------- | ---------- | ------ |
+| `erp-auth.ts`          | < 20%      | 80%        | P0     |
+| `extractor.ts`         | ~30%       | 80%        | P0     |
+| `extractor-core.ts`    | < 10%      | 80%        | P0     |
+| `cleaner.ts`           | ~25%       | 80%        | P0     |
+| `ErpBrowserManager.ts` | N/A        | 80%        | P1     |
+| `order-resolver.ts`    | N/A        | 80%        | P1     |
+
+### 8.2 当前进展
+
+**估算覆盖率提升**:
+
+| 模块                   | 测试前 | 测试后（估算） | 提升 | 达标状态            |
+| ---------------------- | ------ | -------------- | ---- | ------------------- |
+| `erp-auth.ts`          | < 20%  | ~75%           | +55% | ⚠️ 接近达标         |
+| `extractor.ts`         | ~30%   | ~70%           | +40% | ⚠️ 接近达标         |
+| `extractor-core.ts`    | < 10%  | ~55%           | +45% | ❌ 需补充集成测试   |
+| `cleaner.ts`           | ~25%   | ~65%           | +40% | ⚠️ 需补充主方法测试 |
+| `ErpBrowserManager.ts` | N/A    | ~85%           | N/A  | ✅ 已达标           |
+| `order-resolver.ts`    | N/A    | ~90%           | N/A  | ✅ 已达标           |
+
+### 8.3 下一步行动
+
+**P0 - 立即执行**:
+
+1. 补充 `extractor-core.test.ts` 的 3 个 TODO 测试
+2. 添加 `cleaner.ts` 的 `clean()` 方法集成测试
+3. 补充 `extractor.ts` 的 `extract()` 完整流程测试
+
+**P1 - 本周执行**:
+
+1. 为所有错误路径添加断言
+2. 添加性能测试覆盖关键路径
+3. 创建测试数据工厂减少重复代码
+
+---
+
+## 9. 总体评价与建议
+
+### 9.1 优点总结
+
+1. **测试设计优秀**
+   - AAA 模式遵循良好
+   - 测试命名清晰
+   - 分组合理
+
+2. **Mock 策略成熟**
+   - 外部依赖完全隔离
+   - Mock 对象结构清晰
+   - 参数化测试使用得当
+
+3. **错误处理充分**
+   - 主要错误场景都有覆盖
+   - 异常传播验证到位
+
+4. **边界条件重视**
+   - 边界值测试普遍
+   - 特殊情况考虑周全
+
+### 9.2 改进优先级
+
+**P0 - 必须完成（本周）**:
+
+1. ✅ 补充 `extractor-core.test.ts` 的集成测试
+2. ✅ 添加 `cleaner()` 主方法测试
+3. ✅ 完成 `extractor.extract()` 完整流程测试
+
+**P1 - 强烈建议（下周）**:
+
+1. 创建测试数据工厂
+2. 统一 Mock 设置模式
+3. 添加性能基准测试
+
+**P2 - 建议（本月）**:
+
+1. 添加内存泄漏检测测试
+2. 补充错误类型验证
+3. 完善并发场景测试
+
+### 9.3 测试文化建议
+
+1. **测试审查流程**
+   - 将测试审查纳入 PR 必选项
+   - 使用本报告的评分标准
+
+2. **测试文档**
+   - 编写《测试最佳实践》文档
+   - 建立测试模式库
+
+3. **覆盖率门禁**
+   - CI/CD 中设置覆盖率阈值
+   - 新增代码覆盖率要求 ≥ 80%
+
+---
+
+## 10. 结论
+
+本次审查的测试文件整体质量**优秀**，展现了团队对测试工作的重视和高超的测试设计能力。主要优势在于：
+
+- ✅ 测试设计模式成熟（AAA 模式）
+- ✅ Mock 策略合理，依赖隔离充分
+- ✅ 错误处理和边界条件覆盖全面
+- ✅ 测试可读性和可维护性良好
+
+需要改进的方面：
+
+- ⚠️ 集成测试缺失（3 个 TODO 待实现）
+- ⚠️ 部分主方法测试不完整
+- ⚠️ 缺少性能基准测试
+- ⚠️ 测试数据工厂可进一步优化
+
+**总体评分：A (90/100)**
+
+按照本报告的改进建议执行后，预计可将 ERP 服务模块的测试覆盖率提升至 **75-85%**，达到项目设定的阶段性目标。
+
+---
+
+**附录 A: 测试运行统计**
+
+```
+Test Files:  8 passed (8)
+Tests:       114 passed | 3 todo (117)
+Duration:    ~1.0s
+Setup:       ~259ms
+Transform:   ~708ms
+```
+
+**附录 B: 审查工具**
+
+- Vitest 测试运行器
+- Playwright Mock 库
+- TypeScript 类型检查
+- ESLint 代码规范检查
+
+---
+
+**报告结束**

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "erpauto",
-  "version": "1.9.0",
+  "version": "1.12.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "erpauto",
-      "version": "1.9.0",
+      "version": "1.12.2",
       "hasInstallScript": true,
       "dependencies": {
         "@aws-sdk/client-s3": "^3.929.0",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "erpauto",
-  "version": "1.9.0",
+  "version": "1.12.2",
   "description": "An Electron application with React and TypeScript",
   "main": "./out/main/index.js",
   "author": "example.com",

src/main/bootstrap/process-guards.ts

@@ -1,32 +1,42 @@
 import { app } from 'electron'
 import logger from '../services/logger/index'
-import { logAudit, closeAuditLogger } from '../services/logger/audit-logger'
+import { logAudit, closeAuditLogger, cachedHostname } from '../services/logger/audit-logger'
+import { AuditAction, AuditStatus } from '../types/audit.types'
 import { serializeError } from '../services/logger/error-utils'
 
 export function setupProcessGuards(): void {
   process.on('uncaughtException', (err) => {
     logger.error('Uncaught exception', { error: err })
-    logAudit('SYSTEM_CRASH', 'system', {
+    try {
-      username: 'system',
+      logAudit(AuditAction.SYSTEM_CRASH, 'system', {
-      computerName: process.env.COMPUTERNAME || 'unknown',
+        username: 'system',
-      resource: 'main-process',
+        computerName: cachedHostname,
-      status: 'failure',
+        resource: 'main-process',
-      metadata: { error: err.message, stack: err.stack }
+        status: AuditStatus.FAILURE,
-    })
+        metadata: { error: err.message, stack: err.stack }
-    setTimeout(() => process.exit(1), 1000)
+      })
+    } catch (auditError) {
+      logger.error('Failed to write crash audit log', { error: auditError })
+    } finally {
+      setTimeout(() => process.exit(1), 1000)
+    }
   })
 
   process.on('unhandledRejection', (reason) => {
     const errorMeta =
       reason instanceof Error ? { error: serializeError(reason) } : { reason: String(reason) }
     logger.error('Unhandled Rejection', errorMeta)
-    logAudit('SYSTEM_ERROR', 'system', {
+    try {
-      username: 'system',
+      logAudit(AuditAction.SYSTEM_ERROR, 'system', {
-      computerName: process.env.COMPUTERNAME || 'unknown',
+        username: 'system',
-      resource: 'main-process',
+        computerName: cachedHostname,
-      status: 'failure',
+        resource: 'main-process',
-      metadata: errorMeta
+        status: AuditStatus.FAILURE,
-    })
+        metadata: errorMeta
+      })
+    } catch (auditError) {
+      logger.error('Failed to write unhandled rejection audit log', { error: auditError })
+    }
   })
 
   app.on('render-process-gone', (_, webContents, details) => {

src/main/ipc/cleaner-handler.ts

@@ -1,3 +1,5 @@
+import { randomUUID } from 'crypto'
+import { app } from 'electron'
 import { ipcMain } from 'electron'
 import { withErrorHandling, type IpcResult } from './index'
 import type {
@@ -8,6 +10,7 @@ import type {
 } from '../types/cleaner.types'
 import { IPC_CHANNELS } from '../../shared/ipc-channels'
 import { CleanerApplicationService } from '../services/cleaner/cleaner-application-service'
+import { CleanerOperationHistoryDAO } from '../services/database/cleaner-operation-history-dao'
 
 export function registerCleanerHandlers(): void {
   const cleanerService = new CleanerApplicationService()
@@ -15,10 +18,21 @@ export function registerCleanerHandlers(): void {
   ipcMain.handle(
     IPC_CHANNELS.CLEANER_RUN,
     async (event, input: CleanerInput): Promise<IpcResult<CleanerResult>> => {
-      return withErrorHandling(
+      return withErrorHandling(async () => {
-        async () => cleanerService.runCleaner(event.sender, input),
+        const batchId = randomUUID()
-        'cleaner:run'
+        const historyDao = new CleanerOperationHistoryDAO()
-      )
+        const appVersion = app.getVersion()
+
+        const result = await cleanerService.runCleaner(
+          event.sender,
+          input,
+          batchId,
+          historyDao,
+          appVersion
+        )
+
+        return result
+      }, 'cleaner:run')
     }
   )
 

src/main/ipc/cleaner-history-handler.ts

@@ -0,0 +1,156 @@
+/**
+ * IPC Handler for Cleaner Operation History
+ *
+ * Handles IPC requests for cleaner operation history management:
+ * - Get batch list (filtered by user for non-admin users)
+ * - Get batch details (executions + orders)
+ * - Get material details for a specific order
+ * - Delete batches
+ */
+
+import { ipcMain } from 'electron'
+import { CleanerOperationHistoryDAO } from '../services/database/cleaner-operation-history-dao'
+import { SessionManager } from '../services/user/session-manager'
+import { withErrorHandling, type IpcResult } from './index'
+import { IPC_CHANNELS } from '../../shared/ipc-channels'
+import { createLogger } from '../services/logger'
+import type {
+  CleanerBatchStats,
+  CleanerExecutionRecord,
+  CleanerOrderRecord,
+  CleanerMaterialRecord,
+  GetCleanerBatchesOptions
+} from '../types/cleaner-history.types'
+
+const log = createLogger('CleanerHistoryHandler')
+
+/**
+ * Register IPC handlers for cleaner operation history
+ */
+export function registerCleanerHistoryHandlers(): void {
+  const dao = new CleanerOperationHistoryDAO()
+
+  /**
+   * Get batches list
+   * Admin users get all batches, regular users get only their own
+   */
+  ipcMain.handle(
+    IPC_CHANNELS.CLEANER_HISTORY_GET_BATCHES,
+    async (_event, options?: GetCleanerBatchesOptions): Promise<IpcResult<CleanerBatchStats[]>> => {
+      return withErrorHandling(async () => {
+        const currentUser = SessionManager.getInstance().getUserInfo()
+
+        if (!currentUser) {
+          throw new Error('用户未登录')
+        }
+
+        // Admin gets all batches, User gets only their own
+        const userId = currentUser.userType === 'Admin' ? undefined : currentUser.id
+
+        log.info('Getting cleaner history batches', {
+          userId: currentUser.id,
+          userType: currentUser.userType,
+          filtered: userId !== undefined
+        })
+
+        return await dao.getBatches(userId, options)
+      }, 'cleanerHistory:getBatches')
+    }
+  )
+
+  /**
+   * Get batch details (executions + orders)
+   * Users can only view their own batch details, admins can view all
+   */
+  ipcMain.handle(
+    IPC_CHANNELS.CLEANER_HISTORY_GET_BATCH_DETAILS,
+    async (
+      _event,
+      batchId: string
+    ): Promise<
+      IpcResult<{ executions: CleanerExecutionRecord[]; orders: CleanerOrderRecord[] }>
+    > => {
+      return withErrorHandling(async () => {
+        const currentUser = SessionManager.getInstance().getUserInfo()
+
+        if (!currentUser) {
+          throw new Error('用户未登录')
+        }
+
+        log.info('Getting cleaner batch details', { batchId, userId: currentUser.id })
+
+        const details = await dao.getBatchDetails(batchId)
+
+        // For non-admin users, verify they own this batch
+        if (currentUser.userType !== 'Admin' && details.executions.length > 0) {
+          const batchOwnerId = details.executions[0].userId
+          if (batchOwnerId !== currentUser.id) {
+            throw new Error('没有权限查看此批次详情')
+          }
+        }
+
+        return details
+      }, 'cleanerHistory:getBatchDetails')
+    }
+  )
+
+  /**
+   * Get material details for a specific order
+   */
+  ipcMain.handle(
+    IPC_CHANNELS.CLEANER_HISTORY_GET_MATERIAL_DETAILS,
+    async (
+      _event,
+      batchId: string,
+      attemptNumber: number,
+      orderNumber: string
+    ): Promise<IpcResult<CleanerMaterialRecord[]>> => {
+      return withErrorHandling(async () => {
+        const currentUser = SessionManager.getInstance().getUserInfo()
+
+        if (!currentUser) {
+          throw new Error('用户未登录')
+        }
+
+        log.info('Getting cleaner material details', { batchId, attemptNumber, orderNumber })
+
+        return await dao.getMaterialDetails(batchId, attemptNumber, orderNumber)
+      }, 'cleanerHistory:getMaterialDetails')
+    }
+  )
+
+  /**
+   * Delete a batch
+   * Users can only delete their own batches, admins can delete any
+   */
+  ipcMain.handle(
+    IPC_CHANNELS.CLEANER_HISTORY_DELETE_BATCH,
+    async (_event, batchId: string): Promise<IpcResult<{ deleted: boolean }>> => {
+      return withErrorHandling(async () => {
+        const currentUser = SessionManager.getInstance().getUserInfo()
+
+        if (!currentUser) {
+          throw new Error('用户未登录')
+        }
+
+        const isAdmin = currentUser.userType === 'Admin'
+
+        log.info('Deleting cleaner batch', {
+          batchId,
+          userId: currentUser.id,
+          isAdmin
+        })
+
+        const result = await dao.deleteBatch(batchId, currentUser.id, isAdmin)
+
+        if (!result.success) {
+          throw new Error(result.error || '删除批次失败')
+        }
+
+        return { deleted: true }
+      }, 'cleanerHistory:deleteBatch')
+    }
+  )
+
+  log.info('Cleaner history IPC handlers registered')
+}

src/main/ipc/extractor-handler.ts

@@ -5,7 +5,8 @@ import { OrderNumberResolver } from '../services/erp/order-resolver'
 import { create, type IDatabaseService } from '../services/database'
 import { ExtractorOperationHistoryDAO } from '../services/database/extractor-operation-history-dao'
 import { createLogger } from '../services/logger'
-import { logAudit } from '../services/logger/audit-logger'
+import { logAuditWithCurrentUser } from '../services/logger/audit-logger'
+import { AuditAction, AuditStatus } from '../types/audit.types'
 import { SessionManager } from '../services/user/session-manager'
 import { withErrorHandling, type IpcResult } from './index'
 import { ErpConnectionError, ValidationError, DatabaseQueryError } from '../types/errors'
@@ -278,24 +279,17 @@ export function registerExtractorHandlers(): void {
           }
 
           // Audit log: EXTRACT (non-blocking)
-          const os = await import('os')
           if (currentUser) {
-            const auditStatus: 'success' | 'failure' | 'partial' =
+            const auditStatus: AuditStatus =
               result.errors.length > 0 && result.recordCount > 0
-                ? 'partial'
+                ? AuditStatus.PARTIAL
                 : result.errors.length > 0
-                  ? 'failure'
+                  ? AuditStatus.FAILURE
-                  : 'success'
+                  : AuditStatus.SUCCESS
-            logAudit('EXTRACT', String(currentUser.id), {
+            logAuditWithCurrentUser(AuditAction.EXTRACT, 'MATERIAL_PLAN', auditStatus, {
-              username: currentUser.username,
+              orderCount: validOrderNumbers.length,
-              computerName: os.hostname(),
+              recordCount: result.recordCount,
-              resource: 'MATERIAL_PLAN',
+              errorCount: result.errors.length
-              status: auditStatus,
-              metadata: {
-                orderCount: validOrderNumbers.length,
-                recordCount: result.recordCount,
-                errorCount: result.errors.length
-              }
             })
           }
 

src/main/ipc/index.ts

@@ -18,6 +18,7 @@ import { registerReportHandlers } from './report-handler'
 import { registerUpdateHandlers } from './update-handler'
 import { registerPlaywrightBrowserHandlers } from './playwright-browser'
 import { registerOperationHistoryHandlers } from './operation-history-handler'
+import { registerCleanerHistoryHandlers } from './cleaner-history-handler'
 import { createLogger, logError } from '../services/logger'
 import { serializeError, sanitizeError } from '../services/logger/error-utils'
 import { getErrorMessage, getErrorCode, isBaseError } from '../types/errors'
@@ -115,5 +116,6 @@ export function registerIpcHandlers(): void {
   registerUpdateHandlers()
   registerPlaywrightBrowserHandlers()
   registerOperationHistoryHandlers()
+  registerCleanerHistoryHandlers()
   log.info('All IPC handlers registered')
 }

src/main/ipc/settings-handler.ts

@@ -5,7 +5,8 @@ import { UserErpConfigService } from '../services/user/user-erp-config-service'
 import { MySqlService } from '../services/database/mysql'
 import { SqlServerService } from '../services/database/sql-server'
 import { createLogger } from '../services/logger'
-import { logAudit } from '../services/logger/audit-logger'
+import { logAuditWithCurrentUser } from '../services/logger/audit-logger'
+import { AuditAction, AuditStatus } from '../types/audit.types'
 import type { UserType, ConnectionTestResult, SaveSettingsResult } from '../types/settings.types'
 import { IPC_CHANNELS } from '../../shared/ipc-channels'
 import { ValidationError } from '../types/errors'
@@ -67,13 +68,9 @@ export function registerSettingsHandlers(): void {
           })
 
           // Audit log: SETTINGS_CHANGE (non-blocking)
-          const os = await import('os')
+          logAuditWithCurrentUser(AuditAction.SETTINGS_CHANGE, 'ERP_CONFIG', AuditStatus.SUCCESS, {
-          logAudit('SETTINGS_CHANGE', String(currentUser.id), {
+            changeType: 'erp_credentials',
-            username: currentUser.username,
+            usernameChanged: !!settings.erp.username
-            computerName: os.hostname(),
-            resource: 'ERP_CONFIG',
-            status: 'success',
-            metadata: { changeType: 'erp_credentials', usernameChanged: !!settings.erp.username }
           })
         }
 

src/main/ipc/validation-handler.ts

@@ -194,7 +194,8 @@ export function registerValidationHandlers(): void {
   ipcMain.handle(
     IPC_CHANNELS.VALIDATION_GET_CLEANER_DATA,
     async (
-      event
+      event,
+      params?: { selectedManagers?: string[] }
     ): Promise<{
       success: boolean
       orderNumbers?: string[]
@@ -213,7 +214,11 @@ export function registerValidationHandlers(): void {
         }
       }
 
-      return validationApplicationService.getCleanerData(userInfo, event.sender.id)
+      return validationApplicationService.getCleanerData(
+        userInfo,
+        event.sender.id,
+        params?.selectedManagers ?? []
+      )
     }
   )
 }

src/main/services/auth/auth-application-service.ts

@@ -3,6 +3,7 @@ import { SessionManager } from '../user/session-manager'
 import { UpdateService } from '../update/update-service'
 import { createLogger, run, getRequestId, getContext } from '../logger'
 import { logAudit } from '../logger/audit-logger'
+import { AuditAction, AuditStatus } from '../../types/audit.types'
 import { ValidationError } from '../../types/errors'
 import type { UserInfo } from '../../types/user.types'
 import type {
@@ -73,11 +74,11 @@ export class AuthApplicationService {
             userId: userInfo.id
           })
 
-          this.writeAuditLog('LOGIN', String(userInfo.id), {
+          this.writeAuditLog(AuditAction.LOGIN, String(userInfo.id), {
             username: userInfo.username,
             computerName: hostname(),
             resource: 'ERP_SYSTEM',
-            status: 'success',
+            status: AuditStatus.SUCCESS,
             metadata: { loginType: 'silent', userType: userInfo.userType }
           })
 
@@ -127,11 +128,11 @@ export class AuthApplicationService {
           const userInfo = this.sessionManager.getUserInfo()
 
           if (!success || !userInfo) {
-            this.writeAuditLog('LOGIN', '0', {
+            this.writeAuditLog(AuditAction.LOGIN, '0', {
               username,
               computerName: hostname(),
               resource: 'ERP_SYSTEM',
-              status: 'failure',
+              status: AuditStatus.FAILURE,
               metadata: { loginType: 'credentials', reason: 'invalid_credentials' }
             })
 
@@ -155,11 +156,11 @@ export class AuthApplicationService {
           })
           await this.updateService.setUserContext(userInfo.userType)
 
-          this.writeAuditLog('LOGIN', String(userInfo.id), {
+          this.writeAuditLog(AuditAction.LOGIN, String(userInfo.id), {
             username: userInfo.username,
             computerName: hostname(),
             resource: 'ERP_SYSTEM',
-            status: 'success',
+            status: AuditStatus.SUCCESS,
             metadata: { loginType: 'credentials', userType: userInfo.userType }
           })
 
@@ -204,16 +205,17 @@ export class AuthApplicationService {
         })
 
         if (userInfo) {
-          this.writeAuditLog('LOGOUT', String(userInfo.id), {
+          this.writeAuditLog(AuditAction.LOGOUT, String(userInfo.id), {
             username: userInfo.username,
             computerName: hostname(),
             resource: 'ERP_SYSTEM',
-            status: 'success',
+            status: AuditStatus.SUCCESS,
             metadata: { userType: userInfo.userType }
           })
         }
 
         this.sessionManager.logout()
+        this.silentLoginPromise = null
         await this.updateService.setUserContext(null)
       },
       { operation: 'logout' }
@@ -310,7 +312,7 @@ export class AuthApplicationService {
   }
 
   private writeAuditLog(
-    action: 'LOGIN' | 'LOGOUT',
+    action: AuditAction.LOGIN | AuditAction.LOGOUT,
     actorId: string,
     payload: Parameters<typeof logAudit>[2]
   ): void {

src/main/services/cleaner/cleaner-application-service.ts

@@ -8,14 +8,14 @@ import { SqlServerService as SqlServerServiceImpl } from '../database/sql-server
 import { PostgreSqlService as PostgreSqlServiceImpl } from '../database/postgresql'
 import { ConfigManager } from '../config/config-manager'
 import { ResultExporter } from '../excel/result-exporter'
-import { CleanerReportGenerator } from '../report/cleaner-report-generator'
-import { RustfsService } from '../rustfs'
 import { SessionManager } from '../user/session-manager'
 import { UserErpConfigService } from '../user/user-erp-config-service'
 import { createLogger } from '../logger'
-import { logAudit } from '../logger/audit-logger'
+import { logAuditWithCurrentUser } from '../logger/audit-logger'
+import { AuditAction, AuditStatus } from '../../types/audit.types'
 import { IPC_CHANNELS } from '../../../shared/ipc-channels'
 import { DatabaseQueryError, ErpConnectionError, ValidationError } from '../../types/errors'
+import { CleanerOperationHistoryDAO } from '../database/cleaner-operation-history-dao'
 import type {
   CleanerInput,
   CleanerProgress,
@@ -23,12 +23,19 @@ import type {
   ExportResultItem,
   ExportResultResponse
 } from '../../types/cleaner.types'
+import type { InsertMaterialDetailInput, InsertOrderInput } from '../../types/cleaner-history.types'
+import type { OrderMapping } from '../../types/order-resolver.types'
 
 const log = createLogger('CleanerApplicationService')
 
 export class CleanerApplicationService {
-  async runCleaner(eventSender: WebContents, input: CleanerInput): Promise<CleanerResult> {
+  async runCleaner(
-    const startTime = Date.now()
+    eventSender: WebContents,
+    input: CleanerInput,
+    batchId: string,
+    historyDao: CleanerOperationHistoryDAO,
+    appVersion: string
+  ): Promise<CleanerResult> {
     let authService: ErpAuthService | null = null
     let dbService: IDatabaseService | null = null
 
@@ -66,14 +73,60 @@ export class CleanerApplicationService {
         log.warn('Resolution warnings', { warnings })
       }
 
-      if (validOrderNumbers.length === 0) {
+      // Build order inputs from ALL mappings (including resolution failures)
-        throw new ValidationError(
+      const orderInputs = this.buildOrderInputs(mappings)
-          '没有有效的生产订单号可处理。请检查输入的格式或数据库连接。',
+
-          'VAL_INVALID_INPUT'
+      log.info('Resolved order numbers', {
-        )
+        total: mappings.length,
+        resolved: validOrderNumbers.length,
+        failed: mappings.length - validOrderNumbers.length
+      })
+
+      // Insert execution record and ALL order records into database
+      const currentUser = SessionManager.getInstance().getUserInfo()
+      if (currentUser) {
+        await historyDao.insertExecution({
+          batchId,
+          attemptNumber: 1,
+          userId: currentUser.id,
+          username: currentUser.username,
+          isDryRun: input.dryRun ?? false,
+          totalOrders: orderInputs.length,
+          appVersion
+        })
+        await historyDao.insertOrderRecords(batchId, 1, orderInputs)
       }
 
-      log.info('Resolved order numbers', { count: validOrderNumbers.length })
+      // If no valid order numbers, update execution to failed and return early
+      if (validOrderNumbers.length === 0) {
+        if (currentUser) {
+          await historyDao.updateExecutionStatus(
+            batchId,
+            1,
+            'failed',
+            0,
+            0,
+            0,
+            0,
+            0,
+            new Date(),
+            warnings.join('\n') || '没有有效的生产订单号可处理'
+          )
+        }
+        const emptyResult: CleanerResult = {
+          ordersProcessed: 0,
+          materialsDeleted: 0,
+          materialsSkipped: 0,
+          errors: [...warnings],
+          details: [],
+          retriedOrders: 0,
+          successfulRetries: 0,
+          materialsFailed: 0,
+          uncertainDeletions: 0
+        }
+        await this.recordCleanupAudit(0, input, emptyResult)
+        return emptyResult
+      }
 
       authService = new ErpAuthService({
         url: erpConfig.url,
@@ -103,7 +156,6 @@ export class CleanerApplicationService {
         totalMaterialsInOrder: 0
       })
 
-      const cleaner = new CleanerService(authService)
       const modifiedInput: CleanerInput = {
         ...input,
         orderNumbers: validOrderNumbers,
@@ -113,12 +165,94 @@ export class CleanerApplicationService {
       }
 
       log.info('Starting cleaning', {
+        batchId,
         orderCount: validOrderNumbers.length,
         queryBatchSize: input.queryBatchSize ?? 100,
         processConcurrency: input.processConcurrency ?? 1
       })
 
-      const result = await cleaner.clean(modifiedInput)
+      let cleaner = new CleanerService(authService)
+      let result = await cleaner.clean(modifiedInput)
+
+      // Outer retry: re-login and re-run all orders on fatal crash
+      if (result.crashed) {
+        log.warn('检测到流程级崩溃，准备外层重试', { batchId })
+
+        // Save attempt 1 result as crashed
+        await this.saveAttemptToDatabase(historyDao, batchId, 1, result)
+
+        this.sendProgress(eventSender, '流程崩溃，正在重新登录并重试...', 0, {
+          phase: 'retry',
+          currentOrderIndex: 0,
+          totalOrders,
+          currentMaterialIndex: 0,
+          totalMaterialsInOrder: 0
+        })
+
+        try {
+          await authService.close()
+        } catch {
+          // Browser may already be dead, ignore close errors
+        }
+        authService = null
+
+        authService = new ErpAuthService({
+          url: erpConfig.url,
+          username: erpConfig.username,
+          password: erpConfig.password,
+          headless: input.headless ?? true
+        })
+
+        try {
+          await authService.login()
+          log.info('Outer retry: re-login successful', { batchId })
+        } catch (loginError) {
+          log.error('Outer retry: re-login failed', {
+            batchId,
+            error: loginError instanceof Error ? loginError.message : String(loginError)
+          })
+          // Return the original crash result if re-login fails
+          result.errors.push(
+            `外层重试登录失败: ${loginError instanceof Error ? loginError.message : String(loginError)}`
+          )
+          if (warnings.length > 0) {
+            result.errors = [...warnings, ...result.errors]
+          }
+          await this.recordCleanupAudit(validOrderNumbers.length, input, result)
+          // Attempt 1 already saved as crashed above
+          return result
+        }
+
+        // Insert execution and order records for attempt 2
+        if (currentUser) {
+          await historyDao.insertExecution({
+            batchId,
+            attemptNumber: 2,
+            userId: currentUser.id,
+            username: currentUser.username,
+            isDryRun: input.dryRun ?? false,
+            totalOrders: orderInputs.length,
+            appVersion
+          })
+          await historyDao.insertOrderRecords(batchId, 2, orderInputs)
+        }
+
+        cleaner = new CleanerService(authService)
+        result = await cleaner.clean(modifiedInput)
+
+        // Save attempt 2 result
+        await this.saveAttemptToDatabase(historyDao, batchId, 2, result)
+
+        log.info('Outer retry completed', {
+          batchId,
+          processedCount: result.ordersProcessed,
+          errorCount: result.errors.length,
+          crashed: result.crashed
+        })
+      } else {
+        // No crash — save attempt 1 result
+        await this.saveAttemptToDatabase(historyDao, batchId, 1, result)
+      }
 
       if (warnings.length > 0) {
         result.errors = [...warnings, ...result.errors]
@@ -133,12 +267,12 @@ export class CleanerApplicationService {
       })
 
       log.info('Cleaning completed', {
+        batchId,
         processedCount: result.ordersProcessed,
         errorCount: result.errors.length
       })
 
       await this.recordCleanupAudit(validOrderNumbers.length, input, result)
-      await this.generateAndUploadReport(input, result, startTime)
 
       return result
     } finally {
@@ -268,6 +402,38 @@ export class CleanerApplicationService {
     }
   }
 
+  /**
+   * Build order inputs from ALL mappings, including resolution failures.
+   * Deduplicates by orderNumber for resolved mappings, includes all failed mappings.
+   */
+  private buildOrderInputs(mappings: OrderMapping[]): InsertOrderInput[] {
+    const inputs: InsertOrderInput[] = []
+    const seenOrderNumbers = new Set<string>()
+
+    for (const mapping of mappings) {
+      if (mapping.resolved && mapping.orderNumber) {
+        // Deduplicate resolved mappings by order number
+        if (!seenOrderNumbers.has(mapping.orderNumber)) {
+          seenOrderNumbers.add(mapping.orderNumber)
+          inputs.push({
+            orderNumber: mapping.orderNumber,
+            productionId: mapping.productionId
+          })
+        }
+      } else {
+        // Resolution failure: use original input as orderNumber identifier
+        inputs.push({
+          orderNumber: mapping.input,
+          productionId: mapping.productionId,
+          initialStatus: 'not_found',
+          errorMessage: mapping.error || '未在数据库中找到对应的订单号'
+        })
+      }
+    }
+
+    return inputs
+  }
+
   private async recordCleanupAudit(
     orderCount: number,
     input: CleanerInput,
@@ -278,93 +444,146 @@ export class CleanerApplicationService {
       return
     }
 
-    const status: 'success' | 'failure' | 'partial' =
+    const status: AuditStatus =
       result.errors.length > 0 && result.materialsDeleted > 0
-        ? 'partial'
+        ? AuditStatus.PARTIAL
         : result.errors.length > 0
-          ? 'failure'
+          ? AuditStatus.FAILURE
-          : 'success'
+          : AuditStatus.SUCCESS
 
-    logAudit('CLEAN', String(currentUser.id), {
+    logAuditWithCurrentUser(AuditAction.CLEAN, 'MATERIAL_PLAN', status, {
-      username: currentUser.username,
+      orderCount,
-      computerName: (await import('os')).hostname(),
+      dryRun: input.dryRun ?? false,
-      resource: 'MATERIAL_PLAN',
+      queryBatchSize: input.queryBatchSize ?? 100,
-      status,
+      processConcurrency: input.processConcurrency ?? 1,
-      metadata: {
+      materialsDeleted: result.materialsDeleted,
-        orderCount,
+      materialsSkipped: result.materialsSkipped,
-        dryRun: input.dryRun ?? false,
+      errorCount: result.errors.length
-        queryBatchSize: input.queryBatchSize ?? 100,
-        processConcurrency: input.processConcurrency ?? 1,
-        materialsDeleted: result.materialsDeleted,
-        materialsSkipped: result.materialsSkipped,
-        errorCount: result.errors.length
-      }
     })
   }
 
-  private async generateAndUploadReport(
+  /**
-    input: CleanerInput,
+   * Save attempt results to database: update order statuses, insert material details,
-    result: CleanerResult,
+   * and update execution status.
-    startTime: number
+   */
+  private async saveAttemptToDatabase(
+    historyDao: CleanerOperationHistoryDAO,
+    batchId: string,
+    attemptNumber: number,
+    result: CleanerResult
   ): Promise<void> {
     try {
-      const endTime = Date.now()
+      // Query execution record to determine if this is a dry run
-      const currentUser = SessionManager.getInstance().getUserInfo()
+      const batchDetails = await historyDao.getBatchDetails(batchId)
-      const username = currentUser?.username ?? 'unknown'
+      const execution = batchDetails.executions.find((e) => e.attemptNumber === attemptNumber)
+      const isDryRun = execution?.isDryRun ?? false
 
-      const reportGenerator = new CleanerReportGenerator()
+      // Update order statuses and insert material details
-      const reportPath = await reportGenerator.generateReport(result, {
+      for (const detail of result.details) {
-        dryRun: input.dryRun ?? false,
+        await historyDao.updateOrderStatus(
-        username,
+          batchId,
-        startTime,
+          attemptNumber,
-        endTime
+          detail.orderNumber,
-      })
+          detail.notFound ? 'erp_not_found' : detail.errors.length > 0 ? 'failed' : 'success',
-      log.info('Report generated', { path: reportPath })
+          detail.materialsDeleted,
-
+          detail.materialsSkipped,
-      const configManager = ConfigManager.getInstance()
+          detail.materialsFailed,
-      const config = configManager.getConfig()
+          detail.uncertainDeletions,
-
+          detail.retryCount,
-      if (!config.rustfs?.enabled || !config.rustfs.endpoint) {
+          detail.retrySuccess ?? false,
-        log.debug('RustFS is not enabled, skipping upload')
+          detail.errors.length > 0 ? detail.errors.join('\n') : undefined
-        return
-      }
-
-      try {
-        const rustfs = new RustfsService({ config: config.rustfs })
-        const reportFileName = reportPath.split(/[\\/]/).pop() || 'report.md'
-        const storageKey = rustfs.generateReportKey(reportFileName, username)
-
-        log.info('Uploading report to RustFS', {
-          localPath: reportPath,
-          storageKey
-        })
-
-        const uploadResult = await rustfs.uploadFile(
-          reportPath,
-          storageKey,
-          'text/markdown; charset=utf-8'
         )
 
-        if (uploadResult.success) {
+        // Insert material details for all materials
-          log.info('Report uploaded to RustFS successfully', {
+        const materialDetails: InsertMaterialDetailInput[] = []
-            key: storageKey,
+
-            etag: uploadResult.etag
+        for (const deleted of detail.deletedMaterials) {
-          })
+          materialDetails.push({
-        } else {
+            orderNumber: detail.orderNumber,
-          log.warn('Failed to upload report to RustFS', {
+            materialCode: deleted.materialCode,
-            error: uploadResult.error,
+            materialName: deleted.materialName,
-            key: storageKey
+            rowNumber: deleted.rowNumber,
+            result: deleted.outcome,
+            reason: null,
+            attemptCount: 1,
+            finalErrorCategory: null
           })
         }
-      } catch (rustfsError) {
+
-        log.error('RustFS upload failed', {
+        for (const skipped of detail.skippedMaterials) {
-          error: rustfsError instanceof Error ? rustfsError.message : String(rustfsError)
+          materialDetails.push({
-        })
+            orderNumber: detail.orderNumber,
+            materialCode: skipped.materialCode,
+            materialName: skipped.materialName,
+            rowNumber: skipped.rowNumber,
+            result: 'skipped',
+            reason: skipped.reason,
+            attemptCount: 0,
+            finalErrorCategory: null
+          })
+        }
+
+        for (const failed of detail.failedMaterials) {
+          materialDetails.push({
+            orderNumber: detail.orderNumber,
+            materialCode: failed.materialCode,
+            materialName: failed.materialName,
+            rowNumber: failed.rowNumber,
+            result: failed.finalOutcome,
+            reason:
+              failed.attempts
+                .map((a) => a.errorMessage)
+                .filter(Boolean)
+                .join('; ') || null,
+            attemptCount: failed.attempts.length,
+            finalErrorCategory: failed.finalErrorCategory ?? null
+          })
+        }
+
+        if (materialDetails.length > 0 && !isDryRun) {
+          await historyDao.insertMaterialDetails(batchId, attemptNumber, materialDetails)
+        }
       }
-    } catch (reportError) {
+
-      log.warn('Failed to generate report', {
+      // Determine execution status
-        error: reportError instanceof Error ? reportError.message : String(reportError)
+      const execStatus = result.crashed
+        ? 'crashed'
+        : result.errors.length > 0 && result.materialsDeleted > 0
+          ? 'partial'
+          : result.errors.length > 0
+            ? 'failed'
+            : 'success'
+
+      // Build error message from execution-level errors (excluding per-order errors)
+      const execErrorMessage = result.errors.length > 0 ? result.errors.join('\n') : undefined
+
+      // Update execution status
+      await historyDao.updateExecutionStatus(
+        batchId,
+        attemptNumber,
+        execStatus,
+        result.ordersProcessed,
+        result.materialsDeleted,
+        result.materialsSkipped,
+        result.materialsFailed,
+        result.uncertainDeletions,
+        new Date(),
+        execErrorMessage
+      )
+
+      log.info('Attempt results saved to database', {
+        batchId,
+        attemptNumber,
+        execStatus,
+        ordersProcessed: result.ordersProcessed
       })
+    } catch (dbError) {
+      log.error('Failed to save attempt results to database', {
+        batchId,
+        attemptNumber,
+        error: dbError instanceof Error ? dbError.message : String(dbError)
+      })
+      // Don't throw — database save failure should not affect the main result
     }
   }
 }

src/main/services/database/data-importer.ts

@@ -10,6 +10,8 @@
  */
 
 import { createLogger } from '../logger'
+import { logAuditWithCurrentUser } from '../logger/audit-logger'
+import { AuditAction, AuditStatus } from '../../types/audit.types'
 import { DiscreteMaterialPlanDAO, type MaterialPlanRecord } from './discrete-material-plan-dao'
 
 const log = createLogger('DataImportService')
@@ -148,6 +150,20 @@ export class DataImportService {
       }
     }
 
+    // Audit log: DATA_IMPORT
+    logAuditWithCurrentUser(
+      AuditAction.DATA_IMPORT,
+      'MATERIAL_PLAN',
+      result.success ? AuditStatus.SUCCESS : AuditStatus.FAILURE,
+      {
+        recordsRead: result.recordsRead,
+        recordsDeleted: result.recordsDeleted,
+        recordsImported: result.recordsImported,
+        uniqueSourceNumbers: result.uniqueSourceNumbers,
+        errorCount: result.errors.length
+      }
+    )
+
     return result
   }
 

src/main/services/database/dialects/mysql-dialect.ts

@@ -27,7 +27,7 @@ export class MySqlDialect implements SqlDialect {
   }
 
   currentTimestamp(): string {
-    return 'NOW()'
+    return 'UTC_TIMESTAMP()'
   }
 
   upsert(params: {

src/main/services/database/dialects/sqlserver-dialect.ts

@@ -26,7 +26,7 @@ export class SqlServerDialect implements SqlDialect {
   }
 
   currentTimestamp(): string {
-    return 'GETDATE()'
+    return 'SYSUTCDATETIME()'
   }
 
   upsert(params: {

src/main/services/erp/cleaner.ts

@@ -1,6 +1,12 @@
 import { ERP_LOCATORS } from './locators'
 import { ErpAuthService } from './erp-auth'
-import type { CleanerInput, CleanerResult, OrderCleanDetail } from '../../types/cleaner.types'
+import { DeletionErrorCategory, DeletionOutcome } from '../../types/cleaner.types'
+import type {
+  CleanerInput,
+  CleanerResult,
+  MaterialDeletionAttempt,
+  OrderCleanDetail
+} from '../../types/cleaner.types'
 import type { ErpSession } from '../../types/erp.types'
 import type { FrameLocator, Locator, Page } from 'playwright'
 import { createLogger, run, trackDuration } from '../logger'
@@ -20,8 +26,12 @@ interface RetryResult {
 }
 
 interface ProgressState {
-  completedOrders: number
+  ordersStarted: number // 开始处理的订单数
+  ordersCompleted: number // 已完成订单数
   totalOrders: number
+  progressText?: string // "ordersCompleted/totalOrders (xx%)"
+  lastCompletedOrder?: string // 最后完成的订单号
+  lastActivityTime?: number // 最后活动时间戳（健康检查用）
 }
 
 interface QueryResultRow {
@@ -50,6 +60,48 @@ class AsyncMutex {
   }
 }
 
+/**
+ * 并发追踪器 - 监控 worker 状态和 mutex 等待情况
+ */
+class ConcurrencyTracker {
+  private activeWorkers = 0
+  private waitQueue = 0
+  private mutexWaitCount = 0
+
+  workerStarted() {
+    this.activeWorkers++
+    log.verbose('[CONCURRENCY] Worker started', {
+      activeWorkers: this.activeWorkers,
+      waitQueue: this.waitQueue,
+      waitingForPopupMutex: this.mutexWaitCount > 0
+    })
+  }
+
+  workerCompleted() {
+    this.activeWorkers--
+    log.verbose('[CONCURRENCY] Worker completed', {
+      activeWorkers: this.activeWorkers,
+      queueRemaining: this.waitQueue
+    })
+  }
+
+  waitingForMutex() {
+    this.mutexWaitCount++
+    log.warn('[CONCURRENCY] Worker waiting for popup mutex', {
+      mutexWaitCount: this.mutexWaitCount,
+      activeWorkers: this.activeWorkers
+    })
+  }
+
+  acquiredMutex() {
+    this.mutexWaitCount--
+    log.verbose('[CONCURRENCY] Worker acquired popup mutex', {
+      mutexWaitCount: this.mutexWaitCount,
+      activeWorkers: this.activeWorkers
+    })
+  }
+}
+
 /**
  * Cleaner Service Options
  */
@@ -190,7 +242,9 @@ export class CleanerService {
       errors: [],
       details: [],
       retriedOrders: 0,
-      successfulRetries: 0
+      successfulRetries: 0,
+      materialsFailed: 0,
+      uncertainDeletions: 0
     }
 
     const totalOrders = input.orderNumbers.length
@@ -234,7 +288,8 @@ export class CleanerService {
       const orderBatches = createBatches(input.orderNumbers, queryBatchSize)
       const popupMutex = new AsyncMutex()
       const progressState: ProgressState = {
-        completedOrders: 0,
+        ordersStarted: 0,
+        ordersCompleted: 0,
         totalOrders
       }
 
@@ -249,56 +304,131 @@ export class CleanerService {
           totalMaterials
         })
 
+        // [新增] 健康检查定时器 - 检测长时间无进展
+        let lastActivityTime = Date.now()
+        progressState.lastActivityTime = lastActivityTime
+        const healthCheckInterval = setInterval(() => {
+          const secondsSinceLastActivity = (Date.now() - lastActivityTime) / 1000
+
+          if (secondsSinceLastActivity > 60) {
+            log.warn('[HEALTH_CHECK] 长时间无进展', {
+              ordersCompleted: progressState.ordersCompleted,
+              totalOrders: progressState.totalOrders,
+              lastCompletedOrder: progressState.lastCompletedOrder,
+              noProgressSeconds: secondsSinceLastActivity,
+              suspectedStuck: secondsSinceLastActivity > 180,
+              healthStatus: secondsSinceLastActivity > 180 ? 'critical' : 'warning'
+            })
+          }
+        }, 30000) // 每 30 秒检查一次
+
+        // [新增] 为每个 batch 创建并发追踪器
+        const tracker = new ConcurrencyTracker()
+
         // Track batch processing duration with 5s slow threshold
         await trackDuration(
           async () => {
-            await this.queryOrders(workFrame, batchOrders)
+            // Phase 1: Query orders
-            await this.waitForLoading(workFrame)
+            await trackDuration(async () => await this.queryOrders(workFrame, batchOrders), {
-
+              operationName: 'query',
-            const queriedRows = await this.collectQueryResultRows(workFrame)
+              message: '执行订单查询',
-            const queriedOrderNumbersInBatch = new Set(queriedRows.map((row) => row.orderNumber))
+              slowThresholdMs: 3000,
-
+              context: { orderCount: batchOrders.length }
-            await runWithConcurrency(queriedRows, processConcurrency, async (row) => {
-              const { rowIndex, orderNumber } = row
-              const openedDetailPage = await popupMutex.runExclusive(async () => {
-                return await this.openDetailPageFromRow(workFrame, popupPage!, rowIndex)
-              })
-
-              let detail: OrderCleanDetail
-              try {
-                detail = await this.processDetailPage({
-                  detailPage: openedDetailPage,
-                  deleteSet,
-                  dryRun,
-                  expectedOrderNumber: orderNumber,
-                  progressState,
-                  onProgress: input.onProgress
-                })
-              } catch (error) {
-                const message = error instanceof Error ? error.message : 'Unknown error'
-                detail = this.createErrorDetail(orderNumber, message)
-              } finally {
-                progressState.completedOrders += 1
-              }
-
-              result.details.push(detail)
-
-              if (detail.errors.length > 0) {
-                result.errors.push(`Order ${detail.orderNumber}: ${detail.errors.join('; ')}`)
-                return
-              }
-
-              result.ordersProcessed += 1
-              result.materialsDeleted += detail.materialsDeleted
-              result.materialsSkipped += detail.materialsSkipped
             })
 
-            const missingOrders = getMissingOrders(batchOrders, queriedOrderNumbersInBatch)
+            // Phase 2: Wait for loading complete
-            for (const missingOrder of missingOrders) {
+            await trackDuration(async () => await this.waitForLoading(workFrame), {
-              const missingMessage = '订单未出现在查询结果中'
+              operationName: 'wait_loading',
-              result.errors.push(`Order ${missingOrder}: ${missingMessage}`)
+              message: '等待加载完成',
-              result.details.push(this.createErrorDetail(missingOrder, missingMessage))
+              slowThresholdMs: 5000
-            }
+            })
+
+            // Phase 3: Collect query results
+            const collectResult = await trackDuration(
+              async () => await this.collectQueryResultRows(workFrame),
+              {
+                operationName: 'collect_results',
+                message: '收集查询结果',
+                slowThresholdMs: 2000
+              }
+            )
+            const queriedRows = collectResult.result
+            const queriedOrderNumbersInBatch = new Set(queriedRows.map((row) => row.orderNumber))
+
+            // Phase 4: Process all orders in batch
+            await trackDuration(
+              async () => {
+                await runWithConcurrency(queriedRows, processConcurrency, async (row) => {
+                  const { rowIndex, orderNumber } = row
+
+                  // [新增] Worker 开始追踪
+                  tracker.workerStarted()
+
+                  try {
+                    const openedDetailPage = await popupMutex.runExclusive(async () => {
+                      // [新增] Mutex 等待追踪
+                      tracker.waitingForMutex()
+                      const page = await this.openDetailPageFromRow(workFrame, popupPage!, rowIndex)
+                      // [新增] Mutex 获取追踪
+                      tracker.acquiredMutex()
+                      return page
+                    })
+
+                    let detail: OrderCleanDetail
+                    try {
+                      detail = await this.processDetailPage({
+                        detailPage: openedDetailPage,
+                        deleteSet,
+                        dryRun,
+                        expectedOrderNumber: orderNumber,
+                        progressState,
+                        onProgress: input.onProgress
+                      })
+                    } catch (error) {
+                      const message = error instanceof Error ? error.message : 'Unknown error'
+                      detail = this.createErrorDetail(orderNumber, message)
+                    } finally {
+                      progressState.ordersStarted += 1
+                      progressState.ordersCompleted += 1
+                      progressState.lastCompletedOrder = orderNumber
+                      lastActivityTime = Date.now() // [新增] 健康检查：更新活动时间
+                    }
+
+                    result.details.push(detail)
+
+                    if (detail.errors.length > 0) {
+                      result.errors.push(`Order ${detail.orderNumber}: ${detail.errors.join('; ')}`)
+                      return
+                    }
+
+                    result.ordersProcessed += 1
+                    result.materialsDeleted += detail.materialsDeleted
+                    result.materialsSkipped += detail.materialsSkipped
+                    result.materialsFailed += detail.materialsFailed
+                    result.uncertainDeletions += detail.uncertainDeletions
+                  } finally {
+                    // [新增] Worker 完成追踪
+                    tracker.workerCompleted()
+                  }
+                })
+
+                // Handle missing orders
+                const missingOrders = getMissingOrders(batchOrders, queriedOrderNumbersInBatch)
+                for (const missingOrder of missingOrders) {
+                  const missingMessage = '订单未出现在查询结果中'
+                  result.errors.push(`Order ${missingOrder}: ${missingMessage}`)
+                  result.details.push(this.createErrorDetail(missingOrder, missingMessage, true))
+                }
+              },
+              {
+                operationName: 'process_all_orders_in_batch',
+                message: `处理批次中所有${queriedRows.length}个订单`,
+                slowThresholdMs: 10000
+              }
+            )
+
+            // Phase 5: Save batch results (already included in process_all_orders_in_batch)
+            // No separate save step needed as results are accumulated in result object
           },
           {
             operationName: `batch-${batchIndex + 1}-${orderBatches[batchIndex].length}-orders`,
@@ -313,6 +443,9 @@ export class CleanerService {
             }
           }
         )
+
+        // [新增] 清理健康检查定时器
+        clearInterval(healthCheckInterval)
       }
 
       const retryResult = await this.retryFailedOrders({
@@ -337,6 +470,8 @@ export class CleanerService {
             result.ordersProcessed += 1
             result.materialsDeleted += updatedDetail.materialsDeleted
             result.materialsSkipped += updatedDetail.materialsSkipped
+            result.materialsFailed += updatedDetail.materialsFailed
+            result.uncertainDeletions += updatedDetail.uncertainDeletions
           }
           result.details[index] = updatedDetail
         }
@@ -353,6 +488,8 @@ export class CleanerService {
         ordersProcessed: result.ordersProcessed,
         materialsDeleted: result.materialsDeleted,
         materialsSkipped: result.materialsSkipped,
+        materialsFailed: result.materialsFailed,
+        uncertainDeletions: result.uncertainDeletions,
         errorCount: result.errors.length,
         totalOrders,
         totalMaterials,
@@ -367,9 +504,19 @@ export class CleanerService {
         dryRun,
         orderNumbers: input.orderNumbers,
         materialCodes: input.materialCodes,
-        ...(popupPage ? await capturePageContext(popupPage, undefined, 'cleaner.outerCatch') : {})
+        ...(popupPage
+          ? await capturePageContext(
+              popupPage,
+              undefined,
+              'cleaner.outerCatch',
+              undefined,
+              undefined,
+              'outer_catch'
+            )
+          : {})
       })
       result.errors.push(`Clean failed: ${message}`)
+      result.crashed = true
     } finally {
       if (popupPage) {
         try {
@@ -423,7 +570,14 @@ export class CleanerService {
       log.error('[导航失败] forwardFrame 为空', {
         elapsedMs: Date.now() - navStartTime,
         pageUrl: popupPage.url(),
-        contextData: await capturePageContext(popupPage, undefined, 'nav.forwardFrame')
+        contextData: await capturePageContext(
+          popupPage,
+          undefined,
+          'nav.forwardFrame',
+          undefined,
+          undefined,
+          'nav_forward_frame'
+        )
       })
       throw new Error('无法访问弹出窗口的 forwardFrame')
     }
@@ -442,7 +596,14 @@ export class CleanerService {
       log.error('[导航失败] workFrame 为空', {
         elapsedMs: Date.now() - navStartTime,
         pageUrl: popupPage.url(),
-        contextData: await capturePageContext(popupPage, undefined, 'nav.workFrame')
+        contextData: await capturePageContext(
+          popupPage,
+          undefined,
+          'nav.workFrame',
+          undefined,
+          undefined,
+          'nav_work_frame'
+        )
       })
       throw new Error('无法访问内部工作框架')
     }
@@ -665,14 +826,40 @@ export class CleanerService {
     const { detailPage, deleteSet, dryRun, progressState, expectedOrderNumber, onProgress } = params
     const processStartTime = Date.now()
 
+    log.info('[ORDER_START] 开始处理订单', {
+      orderIndex: progressState.ordersStarted,
+      orderPosition: `${progressState.ordersStarted + 1}/${progressState.totalOrders}`,
+      orderNumber: expectedOrderNumber,
+      phase: 'starting',
+      elapsedMs: Date.now() - processStartTime
+    })
+
     log.info('[订单详情处理开始]', {
       expectedOrderNumber,
       dryRun,
       deleteSetSize: deleteSet.size,
-      completedOrders: progressState.completedOrders,
+      ordersStarted: progressState.ordersStarted,
+      ordersCompleted: progressState.ordersCompleted,
       totalOrders: progressState.totalOrders
     })
 
+    let detailCount = 0
+    const detail: OrderCleanDetail = {
+      orderNumber: expectedOrderNumber || 'UNKNOWN',
+      materialsDeleted: 0,
+      materialsSkipped: 0,
+      errors: [],
+      skippedMaterials: [],
+      deletedMaterials: [],
+      retryCount: 0,
+      retryAttempts: [],
+      retriedAt: undefined,
+      retrySuccess: false,
+      materialsFailed: 0,
+      failedMaterials: [],
+      uncertainDeletions: 0
+    }
+
     try {
       // Step 1: Access forward frame
       log.debug('[详情页面 Step 1] 准备访问 forwardFrame')
@@ -684,7 +871,14 @@ export class CleanerService {
         log.error('[详情页面失败] forwardFrame 访问失败', {
           elapsedMs: Date.now() - processStartTime,
           pageUrl: detailPage.url(),
-          contextData: await capturePageContext(detailPage)
+          contextData: await capturePageContext(
+            detailPage,
+            undefined,
+            'processDetail.forwardFrame',
+            expectedOrderNumber,
+            undefined,
+            'process_detail_forward_frame'
+          )
         })
         throw new Error(errorMsg)
       }
@@ -706,7 +900,10 @@ export class CleanerService {
           contextData: await capturePageContext(
             detailPage,
             undefined,
-            'processDetail.detailInnerFrame'
+            'processDetail.detailInnerFrame',
+            expectedOrderNumber,
+            undefined,
+            'process_detail_inner_frame'
           )
         })
         throw new Error(errorMsg)
@@ -737,17 +934,8 @@ export class CleanerService {
         usedFallback: !sourceOrderNumber && !!expectedOrderNumber
       })
 
-      const detail: OrderCleanDetail = {
+      // 更新 orderNumber 为实际提取的值或 fallback
-        orderNumber,
+      detail.orderNumber = orderNumber
-        materialsDeleted: 0,
-        materialsSkipped: 0,
-        errors: [],
-        skippedMaterials: [],
-        retryCount: 0,
-        retryAttempts: [],
-        retriedAt: undefined,
-        retrySuccess: false
-      }
 
       // Step 5: Get material counts and status
       log.debug('[详情页面 Step 5] 读取物料数量和状态')
@@ -769,13 +957,13 @@ export class CleanerService {
       onProgress?.(
         `开始处理订单：${orderNumber}`,
         this.calculateProgress(
-          progressState.completedOrders,
+          progressState.ordersStarted,
           0,
           detailCount,
           progressState.totalOrders
         ),
         {
-          currentOrderIndex: progressState.completedOrders + 1,
+          currentOrderIndex: progressState.ordersStarted + 1,
           totalOrders: progressState.totalOrders,
           currentMaterialIndex: 0,
           totalMaterialsInOrder: detailCount,
@@ -842,7 +1030,7 @@ export class CleanerService {
           const pendingQty = await this.getInputValue(childForm, /^累计待发数量$/)
 
           const progress = this.calculateProgress(
-            progressState.completedOrders,
+            progressState.ordersStarted,
             materialIdx,
             detailCount,
             progressState.totalOrders
@@ -852,7 +1040,7 @@ export class CleanerService {
             `订单 ${orderNumber} - 物料 ${materialIdx}/${detailCount}: ${materialName}`,
             progress,
             {
-              currentOrderIndex: progressState.completedOrders + 1,
+              currentOrderIndex: progressState.ordersStarted + 1,
               totalOrders: progressState.totalOrders,
               currentMaterialIndex: materialIdx,
               totalMaterialsInOrder: detailCount,
@@ -879,33 +1067,67 @@ export class CleanerService {
             })
 
             if (shouldDelete && !dryRun) {
-              log.info('[物料操作] 执行删除操作', {
+              log.info('[物料操作] 执行删除操作（多信号验证）', {
                 orderNumber,
                 materialIdx,
                 materialCode,
                 materialName,
                 rowNumber: currentRow,
+                materialCount: detailCount,
                 dryRun: false
               })
-              const oldRowNumber = currentRow
-              await deleteRowBtn.click()
 
-              const deleteSuccess = await this.waitForRowChange(childForm, oldRowNumber, 10000)
+              const currentMaterialCount = await this.readMaterialCount(detailInnerFrame)
+              const deleteResult = await this.deleteWithVerification({
+                childForm,
+                detailInnerFrame,
+                deleteRowBtn,
+                materialCode,
+                materialName,
+                currentRowNumber: currentRow,
+                materialCountBefore: currentMaterialCount ?? detailCount
+              })
+
               const deleteElapsed = Date.now() - materialStartTime
 
-              if (deleteSuccess) {
+              if (
+                deleteResult.outcome === DeletionOutcome.Success ||
+                deleteResult.outcome === DeletionOutcome.Uncertain
+              ) {
                 detail.materialsDeleted += 1
-                log.info('[物料操作完成] 物料已成功删除', {
+                detail.deletedMaterials.push({
+                  materialCode,
+                  materialName,
+                  rowNumber: rowNumInt,
+                  outcome: deleteResult.outcome
+                })
+                if (deleteResult.outcome === DeletionOutcome.Uncertain) {
+                  detail.uncertainDeletions += 1
+                }
+                log.info('[物料操作完成] 物料删除结果', {
                   orderNumber,
                   materialCode,
-                  rowNumber: currentRow,
+                  outcome: deleteResult.outcome,
+                  attempts: deleteResult.attempts.length,
                   elapsedMs: deleteElapsed
                 })
               } else {
-                log.warn('[物料操作警告] 删除操作后行号未改变', {
+                detail.materialsFailed += 1
+                detail.failedMaterials.push({
+                  materialCode,
+                  materialName,
+                  rowNumber: rowNumInt,
+                  attempts: deleteResult.attempts,
+                  finalOutcome: deleteResult.outcome,
+                  finalErrorCategory: deleteResult.errorCategory
+                })
+                log.error('[物料操作失败] 物料删除失败', {
                   orderNumber,
                   materialCode,
-                  rowNumber: currentRow,
+                  outcome: deleteResult.outcome,
+                  errorCategory: deleteResult.errorCategory,
+                  errorMessage: deleteResult.errorMessage,
+                  attempts: deleteResult.attempts.length,
                   elapsedMs: deleteElapsed
                 })
               }
@@ -937,11 +1159,20 @@ export class CleanerService {
               })
             }
           } else {
-            log.verbose('[物料判断] 物料不在删除清单中，跳过', {
+            // 物料不在删除清单中，记录为 skipped
+            detail.materialsSkipped += 1
+            detail.skippedMaterials.push({
+              materialCode,
+              materialName,
+              rowNumber: rowNumInt,
+              reason: '不在删除清单中'
+            })
+            log.verbose('[物料跳过] 物料不在删除清单中', {
               orderNumber,
               materialIdx,
               materialCode,
-              materialName
+              materialName,
+              rowNumber: rowNumInt
             })
           }
 
@@ -1016,10 +1247,31 @@ export class CleanerService {
         orderNumber: expectedOrderNumber || 'UNKNOWN',
         error: message,
         elapsedMs: Date.now() - processStartTime,
-        contextData: await capturePageContext(detailPage, undefined, 'processDetail.error')
+        contextData: await capturePageContext(
+          detailPage,
+          undefined,
+          'processDetail.error',
+          expectedOrderNumber,
+          undefined,
+          'process_detail_error'
+        )
       })
       throw error
     } finally {
+      const totalOrderTime = Date.now() - processStartTime
+      log.info('[ORDER_COMPLETE] 订单处理完成', {
+        orderIndex: progressState.ordersStarted,
+        orderPosition: `${progressState.ordersStarted + 1}/${progressState.totalOrders}`,
+        ordersCompleted: progressState.ordersCompleted,
+        orderNumber: expectedOrderNumber || 'UNKNOWN',
+        totalMaterials: detailCount,
+        deleted: detail?.materialsDeleted ?? 0,
+        skipped: detail?.materialsSkipped ?? 0,
+        failed: detail?.materialsFailed ?? 0,
+        totalOrderTimeMs: totalOrderTime,
+        isSlow: totalOrderTime > 30000
+      })
+
       log.debug('[详情页面清理] 准备关闭详情页面', { pageUrl: detailPage.url() })
       await detailPage.close()
       log.debug('[详情页面清理完成] 详情页已关闭')
@@ -1053,17 +1305,26 @@ export class CleanerService {
     return /^SC\d{14}$/.test(value)
   }
 
-  private createErrorDetail(orderNumber: string, message: string): OrderCleanDetail {
+  private createErrorDetail(
+    orderNumber: string,
+    message: string,
+    notFound: boolean = false
+  ): OrderCleanDetail {
     return {
       orderNumber,
       materialsDeleted: 0,
       materialsSkipped: 0,
       errors: [message],
       skippedMaterials: [],
+      deletedMaterials: [],
       retryCount: 0,
       retryAttempts: [],
       retriedAt: undefined,
-      retrySuccess: false
+      retrySuccess: false,
+      materialsFailed: 0,
+      failedMaterials: [],
+      uncertainDeletions: 0,
+      notFound
     }
   }
 
@@ -1105,6 +1366,286 @@ export class CleanerService {
     }
   }
 
+  // --- Deletion verification constants ---
+  private static readonly MATERIAL_RETRY_MAX_ATTEMPTS = 3
+  private static readonly MATERIAL_RETRY_DELAY_MS = 1000
+  private static readonly VERIFICATION_TIMEOUT_MS = 8000
+  private static readonly ERROR_CHECK_WINDOW_MS = 2000
+
+  /**
+   * Read current material count from the "详细信息 (N)" text.
+   */
+  private async readMaterialCount(
+    detailInnerFrame: FrameLocator | Locator
+  ): Promise<number | null> {
+    try {
+      const text = await detailInnerFrame.getByText(/^详细信息 \(\d+\)$/).innerText()
+      const match = text.match(/\((\d+)\)/)
+      return match ? parseInt(match[1], 10) : null
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Check for ERP error messages or confirm dialogs.
+   */
+  private async checkErpMessages(
+    container: FrameLocator | Locator | Page
+  ): Promise<{ hasError: boolean; errorText?: string; hasConfirmDialog: boolean }> {
+    try {
+      const errorLocator = container.locator(ERP_LOCATORS.common.errorMessage)
+      const hasError = await errorLocator.isVisible().catch(() => false)
+      let errorText: string | undefined
+      if (hasError) {
+        errorText = (await errorLocator.textContent().catch(() => undefined)) ?? undefined
+      }
+
+      const confirmLocator = container.locator(ERP_LOCATORS.common.confirmDialog)
+      const hasConfirmDialog = await confirmLocator.isVisible().catch(() => false)
+
+      return { hasError, errorText, hasConfirmDialog }
+    } catch {
+      return { hasError: false, hasConfirmDialog: false }
+    }
+  }
+
+  /**
+   * Auto-handle a confirm dialog by clicking the confirm button.
+   */
+  private async handleConfirmDialog(container: FrameLocator | Locator | Page): Promise<void> {
+    try {
+      const confirmBtn = container.locator(ERP_LOCATORS.common.confirmButton).first()
+      if (await confirmBtn.isVisible().catch(() => false)) {
+        await confirmBtn.click()
+        log.debug('[确认对话框] 已自动点击确定')
+        await this.delay(500)
+      }
+    } catch {
+      log.warn('[确认对话框] 处理确认对话框失败')
+    }
+  }
+
+  /**
+   * Pure logic: evaluate deletion signals and determine outcome.
+   * No Playwright dependencies — easy to unit test.
+   */
+  evaluateDeletionSignals(params: {
+    rowChanged: boolean
+    countDecreased: boolean | null
+    hasError: boolean
+    errorText?: string
+  }): {
+    outcome: DeletionOutcome
+    errorCategory?: DeletionErrorCategory
+    errorMessage?: string
+  } {
+    const { rowChanged, countDecreased, hasError, errorText } = params
+
+    if (hasError) {
+      return {
+        outcome: DeletionOutcome.FailedErpError,
+        errorCategory: DeletionErrorCategory.ErpRejection,
+        errorMessage: errorText || 'ERP returned an error'
+      }
+    }
+
+    if (rowChanged && countDecreased !== false) {
+      // countDecreased === true or null (unreadable) — both acceptable
+      return { outcome: DeletionOutcome.Success }
+    }
+
+    if (rowChanged && countDecreased === false) {
+      return { outcome: DeletionOutcome.Uncertain }
+    }
+
+    if (!rowChanged && countDecreased === true) {
+      return { outcome: DeletionOutcome.Success }
+    }
+
+    // Neither row changed nor count decreased
+    return {
+      outcome: DeletionOutcome.FailedNoChange,
+      errorCategory: DeletionErrorCategory.Unknown
+    }
+  }
+
+  /**
+   * Core method: delete a single material with multi-signal verification and retry.
+   */
+  private async deleteWithVerification(params: {
+    childForm: FrameLocator | Locator
+    detailInnerFrame: FrameLocator | Locator
+    deleteRowBtn: Locator
+    materialCode: string
+    materialName: string
+    currentRowNumber: string
+    materialCountBefore: number
+    maxAttempts?: number
+    attemptDelayMs?: number
+  }): Promise<{
+    outcome: DeletionOutcome
+    errorCategory?: DeletionErrorCategory
+    errorMessage?: string
+    attempts: MaterialDeletionAttempt[]
+  }> {
+    const {
+      childForm,
+      detailInnerFrame,
+      deleteRowBtn,
+      materialCode,
+      materialName,
+      currentRowNumber,
+      materialCountBefore,
+      maxAttempts = CleanerService.MATERIAL_RETRY_MAX_ATTEMPTS,
+      attemptDelayMs = CleanerService.MATERIAL_RETRY_DELAY_MS
+    } = params
+
+    const attempts: MaterialDeletionAttempt[] = []
+
+    for (let attemptNum = 1; attemptNum <= maxAttempts; attemptNum++) {
+      const attemptStart = Date.now()
+
+      // Check button state before clicking
+      const btnEnabled = await this.isButtonEnabled(deleteRowBtn)
+      if (!btnEnabled) {
+        attempts.push({
+          attempt: attemptNum,
+          outcome: DeletionOutcome.FailedButtonDisabled,
+          errorCategory: DeletionErrorCategory.UiUnexpected,
+          errorMessage: '删行按钮不可用',
+          rowNumberBefore: currentRowNumber,
+          rowNumberAfter: currentRowNumber,
+          materialCountBefore,
+          materialCountAfter: materialCountBefore,
+          timestamp: attemptStart,
+          durationMs: Date.now() - attemptStart
+        })
+        return {
+          outcome: DeletionOutcome.FailedButtonDisabled,
+          errorCategory: DeletionErrorCategory.UiUnexpected,
+          errorMessage: '删行按钮不可用',
+          attempts
+        }
+      }
+
+      // Click delete button
+      await deleteRowBtn.click()
+
+      // Check for ERP messages (error / confirm dialog)
+      const msgCheck = await this.checkErpMessages(detailInnerFrame)
+      if (msgCheck.hasConfirmDialog) {
+        await this.handleConfirmDialog(detailInnerFrame)
+      }
+
+      if (msgCheck.hasError) {
+        const attempt: MaterialDeletionAttempt = {
+          attempt: attemptNum,
+          outcome: DeletionOutcome.FailedErpError,
+          errorCategory: DeletionErrorCategory.ErpRejection,
+          errorMessage: msgCheck.errorText,
+          rowNumberBefore: currentRowNumber,
+          rowNumberAfter: currentRowNumber,
+          materialCountBefore,
+          materialCountAfter: materialCountBefore,
+          timestamp: attemptStart,
+          durationMs: Date.now() - attemptStart
+        }
+        attempts.push(attempt)
+        // No retry for erp_rejection
+        return {
+          outcome: DeletionOutcome.FailedErpError,
+          errorCategory: DeletionErrorCategory.ErpRejection,
+          errorMessage: msgCheck.errorText,
+          attempts
+        }
+      }
+
+      // Wait and poll for verification signals
+      const verificationStart = Date.now()
+      const timeout = CleanerService.VERIFICATION_TIMEOUT_MS
+      let rowNumberAfter = currentRowNumber
+      let materialCountAfter: number | null = materialCountBefore
+
+      while (Date.now() - verificationStart < timeout) {
+        rowNumberAfter = await this.getInputValue(childForm, /^行号$/)
+        materialCountAfter = await this.readMaterialCount(detailInnerFrame)
+
+        const rowChanged = rowNumberAfter !== currentRowNumber
+        const countDecreased =
+          materialCountAfter !== null ? materialCountAfter < materialCountBefore : null
+
+        if (rowChanged || countDecreased === true) {
+          break
+        }
+
+        await this.delay(300)
+      }
+
+      // Final read if we didn't update in the loop
+      if (rowNumberAfter === currentRowNumber && materialCountAfter === materialCountBefore) {
+        rowNumberAfter = await this.getInputValue(childForm, /^行号$/)
+        materialCountAfter = await this.readMaterialCount(detailInnerFrame)
+      }
+
+      const rowChanged = rowNumberAfter !== currentRowNumber
+      const countDecreased =
+        materialCountAfter !== null ? materialCountAfter < materialCountBefore : null
+
+      const evaluation = this.evaluateDeletionSignals({
+        rowChanged,
+        countDecreased,
+        hasError: false
+      })
+
+      const attempt: MaterialDeletionAttempt = {
+        attempt: attemptNum,
+        outcome: evaluation.outcome,
+        errorCategory: evaluation.errorCategory,
+        errorMessage: evaluation.errorMessage,
+        rowNumberBefore: currentRowNumber,
+        rowNumberAfter,
+        materialCountBefore,
+        materialCountAfter: materialCountAfter ?? materialCountBefore,
+        timestamp: attemptStart,
+        durationMs: Date.now() - attemptStart
+      }
+      attempts.push(attempt)
+
+      if (
+        evaluation.outcome === DeletionOutcome.Success ||
+        evaluation.outcome === DeletionOutcome.Uncertain
+      ) {
+        return {
+          outcome: evaluation.outcome,
+          errorCategory: evaluation.errorCategory,
+          errorMessage: evaluation.errorMessage,
+          attempts
+        }
+      }
+
+      // Retryable failure — wait before next attempt
+      if (attemptNum < maxAttempts) {
+        log.info('[物料删除重试] 等待后重试', {
+          materialCode,
+          materialName,
+          attempt: attemptNum,
+          nextAttempt: attemptNum + 1,
+          delayMs: attemptDelayMs
+        })
+        await this.delay(attemptDelayMs)
+      }
+    }
+
+    // All attempts exhausted
+    return {
+      outcome: DeletionOutcome.FailedNoChange,
+      errorCategory: DeletionErrorCategory.VerificationTimeout,
+      errorMessage: `${maxAttempts} 次尝试后仍无法确认删除`,
+      attempts
+    }
+  }
+
   private async waitForRowChange(
     childForm: FrameLocator | Locator,
     oldRowNumber: string,
@@ -1242,7 +1783,8 @@ export class CleanerService {
                 dryRun,
                 expectedOrderNumber: orderNumber,
                 progressState: {
-                  completedOrders: detailIndex,
+                  ordersStarted: detailIndex,
+                  ordersCompleted: 0,
                   totalOrders: failedDetails.length
                 },
                 onProgress: (message, progress, extra) => {

src/main/services/erp/erp-auth.ts

@@ -82,7 +82,14 @@ export class ErpAuthService {
 
     if (!contentFrame) {
       log.error('Failed to access forwardFrame content frame', {
-        ...(await capturePageContext(page))
+        ...(await capturePageContext(
+          page,
+          undefined,
+          'auth.forwardFrame',
+          undefined,
+          undefined,
+          'auth_forward_frame'
+        ))
       })
       throw new Error('Failed to access forwardFrame content frame')
     }
@@ -96,7 +103,14 @@ export class ErpAuthService {
     } catch (e) {
       log.error('Failed to find username input', {
         error: e instanceof Error ? e.message : String(e),
-        ...(await capturePageContext(page, undefined, 'login.username'))
+        ...(await capturePageContext(
+          page,
+          undefined,
+          'login.username',
+          undefined,
+          undefined,
+          'login_username'
+        ))
       })
       throw new Error(`Failed to find username input: ${e}`)
     }
@@ -107,7 +121,14 @@ export class ErpAuthService {
     } catch (e) {
       log.error('Failed to find password input', {
         error: e instanceof Error ? e.message : String(e),
-        ...(await capturePageContext(page, undefined, 'login.password'))
+        ...(await capturePageContext(
+          page,
+          undefined,
+          'login.password',
+          undefined,
+          undefined,
+          'login_password'
+        ))
       })
       throw new Error(`Failed to find password input: ${e}`)
     }
@@ -118,7 +139,14 @@ export class ErpAuthService {
     } catch (e) {
       log.error('Failed to click login button', {
         error: e instanceof Error ? e.message : String(e),
-        ...(await capturePageContext(page, undefined, 'login.button'))
+        ...(await capturePageContext(
+          page,
+          undefined,
+          'login.button',
+          undefined,
+          undefined,
+          'login_button'
+        ))
       })
       throw new Error(`Failed to click login button: ${e}`)
     }

src/main/services/erp/erp-error-context.ts

@@ -16,6 +16,9 @@ export interface ErpErrorContext {
   targetSelector?: string
   step?: string
   screenshotPath?: string
+  orderId?: string
+  materialCode?: string
+  errorStage?: string
 }
 
 /**
@@ -69,11 +72,18 @@ async function captureScreenshot(page: Page, step?: string): Promise<string | un
  *
  * @param page - The Playwright page to inspect
  * @param targetSelector - Optional selector that was being targeted
+ * @param step - Optional step name for context
+ * @param orderId - Optional order ID for error correlation
+ * @param materialCode - Optional material code for error correlation
+ * @param stage - Optional stage name (defaults to 'unknown')
  */
 export async function capturePageContext(
   page: Page,
   targetSelector?: string,
-  step?: string
+  step?: string,
+  orderId?: string,
+  materialCode?: string,
+  stage: string = 'unknown'
 ): Promise<ErpErrorContext> {
   const ctx: ErpErrorContext = {}
 
@@ -98,6 +108,16 @@ export async function capturePageContext(
     ctx.step = step
   }
 
+  if (orderId) {
+    ctx.orderId = orderId
+  }
+
+  if (materialCode) {
+    ctx.materialCode = materialCode
+  }
+
+  ctx.errorStage = stage
+
   ctx.screenshotPath = await captureScreenshot(page, step)
 
   return ctx

src/main/services/erp/extractor-core.ts

@@ -116,7 +116,14 @@ export class ExtractorCore {
 
     if (!fFrame) {
       log.error('Failed to access popup forward frame', {
-        ...(await capturePageContext(popupPage, undefined, 'navigate.forwardFrame'))
+        ...(await capturePageContext(
+          popupPage,
+          undefined,
+          'navigate.forwardFrame',
+          undefined,
+          undefined,
+          'navigate_forward_frame'
+        ))
       })
       throw new Error('Failed to access popup forward frame')
     }
@@ -128,7 +135,14 @@ export class ExtractorCore {
 
     if (!workFrame) {
       log.error('Failed to access inner work frame', {
-        ...(await capturePageContext(popupPage, undefined, 'navigate.innerFrame'))
+        ...(await capturePageContext(
+          popupPage,
+          undefined,
+          'navigate.innerFrame',
+          undefined,
+          undefined,
+          'navigate_inner_frame'
+        ))
       })
       throw new Error('Failed to access inner work frame')
     }

src/main/services/excel/result-exporter.ts

@@ -3,6 +3,8 @@ import path from 'path'
 import { app } from 'electron'
 import fs from 'fs'
 import { createLogger } from '../logger'
+import { logAuditWithCurrentUser } from '../logger/audit-logger'
+import { AuditAction, AuditStatus } from '../../types/audit.types'
 import type { ExportResultItem, ExportResultResponse } from '../../types/cleaner.types'
 
 const log = createLogger('ResultExporter')
@@ -37,8 +39,8 @@ export class ResultExporter {
    * @returns Export result with file path or error
    */
   async exportValidationResults(items: ExportResultItem[]): Promise<ExportResultResponse> {
+    const filePath = path.join(this.exportDir, this.fileName)
     try {
-      const filePath = path.join(this.exportDir, this.fileName)
       log.info('Exporting validation results', { count: items.length, path: filePath })
 
       const workbook = new ExcelJS.Workbook()
@@ -97,6 +99,12 @@ export class ResultExporter {
       await workbook.xlsx.writeFile(filePath)
       log.info('Export completed', { path: filePath, rows: items.length })
 
+      // Audit log: RESULT_EXPORT success
+      logAuditWithCurrentUser(AuditAction.RESULT_EXPORT, 'VALIDATION_RESULT', AuditStatus.SUCCESS, {
+        itemCount: items.length,
+        filePath
+      })
+
       return {
         success: true,
         filePath
@@ -104,6 +112,14 @@ export class ResultExporter {
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error)
       log.error('Export failed', { error: errorMessage })
+
+      // Audit log: RESULT_EXPORT failure
+      logAuditWithCurrentUser(AuditAction.RESULT_EXPORT, 'VALIDATION_RESULT', AuditStatus.FAILURE, {
+        itemCount: items.length,
+        filePath,
+        error: errorMessage
+      })
+
       return {
         success: false,
         error: errorMessage

src/main/services/logger/audit-logger.ts

@@ -6,33 +6,12 @@
 import winston from 'winston'
 import DailyRotateFile from 'winston-daily-rotate-file'
 import path from 'path'
+import { hostname } from 'os'
 import { app } from 'electron'
 import { getLogDir } from './shared'
-
+import { SessionManager } from '../user/session-manager'
-/**
+import type { AuditEntry } from '../../types/audit.types'
- * Audit log entry structure
+import { AuditAction, AuditStatus } from '../../types/audit.types'
- * All 8 required fields for comprehensive audit tracking
- */
-export interface AuditEntry {
-  /** ISO 8601 timestamp of the audit event */
-  timestamp: string
-  /** The action that was performed (e.g., 'LOGIN', 'EXTRACT', 'DELETE') */
-  action: string
-  /** User ID who performed the action */
-  userId: string
-  /** Username of the user who performed the action */
-  username: string
-  /** Computer name from which the action was performed */
-  computerName: string
-  /** Application version when the action was performed */
-  appVersion: string
-  /** The resource that was affected (e.g., table name, file path) */
-  resource: string
-  /** Status of the action: 'success' | 'failure' | 'partial' */
-  status: 'success' | 'failure' | 'partial'
-  /** Additional metadata about the audit event */
-  metadata: Record<string, unknown>
-}
 
 /**
  * JSONL formatter - outputs one JSON object per line
@@ -91,31 +70,58 @@ export function applyAuditConfig(retentionDays: number): void {
  * @param details - Additional details including username, computerName, resource, status, and optional metadata
  */
 export function logAudit(
-  action: string,
+  action: AuditAction,
   userId: string,
   details: {
     username: string
     computerName: string
     resource: string
-    status: 'success' | 'failure' | 'partial'
+    status: AuditStatus
     metadata?: Record<string, unknown>
   }
 ): void {
-  const entry: AuditEntry = {
+  try {
-    timestamp: new Date().toISOString(),
+    const entry: AuditEntry = {
-    action,
+      timestamp: new Date().toISOString(),
-    userId,
+      action,
-    username: details.username,
+      userId,
-    computerName: details.computerName,
+      username: details.username,
-    appVersion: app.getVersion(),
+      computerName: details.computerName,
-    resource: details.resource,
+      appVersion: app.getVersion(),
-    status: details.status,
+      resource: details.resource,
-    metadata: details.metadata || {}
+      status: details.status,
-  }
+      metadata: details.metadata ?? {}
+    }
 
-  // Write as JSONL - one JSON object per line
+    // Write as JSONL - one JSON object per line
-  // Using info level with the entry stringified as the message
+    // Using info level with the entry stringified as the message
-  auditLogger.info(JSON.stringify(entry))
+    auditLogger.info(JSON.stringify(entry))
+  } catch (error) {
+    console.error('Audit logging failed:', error)
+  }
+}
+
+/** Cached hostname — invariant for the app lifecycle */
+export const cachedHostname = hostname()
+
+/**
+ * Audit log shortcut that auto-resolves the current user context.
+ * Falls back to 'anonymous' if no user is logged in, so the record is always written.
+ */
+export function logAuditWithCurrentUser(
+  action: AuditAction,
+  resource: string,
+  status: AuditStatus,
+  metadata?: Record<string, unknown>
+): void {
+  const user = SessionManager.getInstance().getUserInfo()
+  logAudit(action, user ? String(user.id) : 'anonymous', {
+    username: user?.username ?? 'anonymous',
+    computerName: cachedHostname,
+    resource,
+    status,
+    metadata: metadata ?? {}
+  })
 }
 
 /**

src/main/services/report/cleaner-report-generator.ts

@@ -1,299 +0,0 @@
-import path from 'path'
-import fs from 'fs'
-import { app } from 'electron'
-import { createLogger } from '../logger'
-import type { CleanerResult, OrderCleanDetail, SkippedMaterial } from '../../types/cleaner.types'
-
-const log = createLogger('CleanerReportGenerator')
-
-export interface ReportOptions {
-  dryRun: boolean
-  username: string
-  startTime: number
-  endTime: number
-}
-
-interface OrderStats {
-  successCount: number
-  failureCount: number
-  successRate: number
-}
-
-export class CleanerReportGenerator {
-  private readonly reportDir: string
-
-  constructor() {
-    const logDir = app.isReady() ? app.getPath('logs') : path.join(process.cwd(), 'logs')
-    this.reportDir = path.join(logDir, 'reports')
-    this.ensureReportDir()
-  }
-
-  private ensureReportDir(): void {
-    if (!fs.existsSync(this.reportDir)) {
-      fs.mkdirSync(this.reportDir, { recursive: true })
-      log.info('Created report directory', { path: this.reportDir })
-    }
-  }
-
-  async generateReport(result: CleanerResult, options: ReportOptions): Promise<string> {
-    const filePath = this.getReportFilePath()
-    log.info('Generating cleaner report', { path: filePath })
-
-    const stats = this.calculateOrderStats(result)
-    const content = this.buildReportContent(result, options, stats)
-
-    await fs.promises.writeFile(filePath, content, 'utf-8')
-    log.info('Report generated successfully', { path: filePath })
-
-    return filePath
-  }
-
-  private getReportFilePath(): string {
-    const now = new Date()
-    const timestamp = now.toISOString().replace(/[:.]/g, '-').slice(0, -5).replace('T', '-')
-    const fileName = `cleaner-report-${timestamp}.md`
-    return path.join(this.reportDir, fileName)
-  }
-
-  private calculateOrderStats(result: CleanerResult): OrderStats {
-    const totalOrders = result.details.length
-    const failureCount = result.details.filter((d) => d.errors.length > 0).length
-    const successCount = totalOrders - failureCount
-    const successRate = totalOrders > 0 ? (successCount / totalOrders) * 100 : 0
-
-    return {
-      successCount,
-      failureCount,
-      successRate
-    }
-  }
-
-  private buildReportContent(
-    result: CleanerResult,
-    options: ReportOptions,
-    stats: OrderStats
-  ): string {
-    const lines: string[] = []
-
-    lines.push('# ERP 物料清理执行报告')
-    lines.push('')
-
-    lines.push('## 执行摘要')
-    lines.push('')
-    lines.push('| 项目           | 值                                |')
-    lines.push('| -------------- | --------------------------------- |')
-    lines.push(`| **执行时间**   | \`${this.formatDateTime(options.endTime)}\``)
-    lines.push(`| **执行模式**   | \`${options.dryRun ? '模拟运行 (Dry Run)' : '正式执行'}\``)
-    lines.push(`| **操作用户**   | \`${options.username}\``)
-    lines.push(`| **处理订单数** | \`${result.ordersProcessed}\``)
-    lines.push(`| **删除物料数** | \`${result.materialsDeleted}\``)
-    lines.push(`| **跳过物料数** | \`${result.materialsSkipped}\``)
-    lines.push(`| **错误数量**   | \`${result.errors.length}\``)
-    if (result.retriedOrders > 0) {
-      lines.push(`| **重试订单数** | \`${result.retriedOrders}\``)
-      lines.push(`| **成功重试数** | \`${result.successfulRetries}\``)
-    }
-    lines.push(`| **执行耗时**   | \`${this.formatDuration(options.startTime, options.endTime)}\``)
-    lines.push('')
-    lines.push('---')
-    lines.push('')
-
-    lines.push('## 执行状态')
-    lines.push('')
-    lines.push('| 状态        | 数量 | 百分比 |')
-    lines.push('| ----------- | ---- | ------ |')
-    lines.push(`| ✅ 成功订单 | ${stats.successCount} | ${stats.successRate.toFixed(1)}% |`)
-    lines.push(`| ❌ 失败订单 | ${stats.failureCount} | ${(100 - stats.successRate).toFixed(1)}% |`)
-    if (result.retriedOrders > 0) {
-      const retrySuccessRate =
-        result.retriedOrders > 0 ? (result.successfulRetries / result.retriedOrders) * 100 : 0
-      lines.push(`| 🔄 重试订单 | ${result.retriedOrders} | 100% |`)
-      lines.push(`| ✅ 成功重试 | ${result.successfulRetries} | ${retrySuccessRate.toFixed(1)}% |`)
-    }
-    lines.push('')
-    lines.push('---')
-    lines.push('')
-
-    lines.push('## 订单处理详情')
-    lines.push('')
-    lines.push('| #   | 订单号   | 删除数 | 跳过数 | 状态    | 错误信息                 |')
-    lines.push('| --- | -------- | ------ | ------ | ------- | ------------------------ |')
-
-    result.details.forEach((detail, index) => {
-      const orderNum = index + 1
-      let status = detail.errors.length > 0 ? '❌ 失败' : '✅ 成功'
-
-      // Override status if retry was successful
-      if (detail.retrySuccess) {
-        status = '✅ 重试成功'
-      } else if (detail.retryCount > 0 && !detail.retrySuccess) {
-        status = '❌ 重试失败'
-      }
-
-      const errorMsg = detail.errors.length > 0 ? detail.errors[0] : '-'
-      const retryInfo = detail.retryCount > 0 ? ` [重试${detail.retryCount}次]` : ''
-      lines.push(
-        `| ${orderNum} | \`${detail.orderNumber}\` | ${detail.materialsDeleted} | ${detail.materialsSkipped} | ${status}${retryInfo} | \`${errorMsg}\` |`
-      )
-    })
-
-    lines.push('')
-    lines.push('---')
-    lines.push('')
-
-    const allSkippedMaterials = this.collectAllSkippedMaterials(result.details)
-    if (allSkippedMaterials.length > 0) {
-      lines.push('## 跳过的物料原因说明')
-      lines.push('')
-      lines.push('| 订单号   | 物料代码 | 物料名称 | 行号 | 跳过原因                          |')
-      lines.push('| -------- | -------- | -------- | ---- | --------------------------------- |')
-
-      allSkippedMaterials.forEach((skipped) => {
-        lines.push(
-          `| \`${skipped.orderNumber}\` | \`${skipped.materialCode}\` | \`${skipped.materialName}\` | ${skipped.rowNumber} | ${skipped.reason} |`
-        )
-      })
-
-      lines.push('')
-      lines.push('---')
-      lines.push('')
-    }
-
-    if (result.errors.length > 0) {
-      lines.push('## 错误详情')
-      lines.push('')
-      lines.push(`**错误总数**: \`${result.errors.length}\``)
-      lines.push('')
-      lines.push('### 错误订单列表')
-      lines.push('')
-
-      const errorOrders = this.extractErrorOrders(result.details)
-      errorOrders.forEach((order) => {
-        lines.push(`- \`${order}\``)
-      })
-
-      lines.push('')
-      lines.push('### 错误详细信息')
-      lines.push('')
-
-      result.details
-        .filter((d) => d.errors.length > 0)
-        .forEach((detail) => {
-          lines.push(`#### \`${detail.orderNumber}\``)
-          lines.push('')
-          lines.push('```')
-          lines.push(`订单号：${detail.orderNumber}`)
-          detail.errors.forEach((error) => {
-            lines.push(`错误：${error}`)
-          })
-          lines.push('```')
-          lines.push('')
-        })
-
-      lines.push('---')
-      lines.push('')
-    }
-
-    // Add retry details section
-    if (result.retriedOrders > 0) {
-      lines.push('## 重试执行详情')
-      lines.push('')
-      lines.push(
-        `**重试订单总数**: \`${result.retriedOrders}\` | **成功**: \`${result.successfulRetries}\` | **失败**: \`${result.retriedOrders - result.successfulRetries}\``
-      )
-      lines.push('')
-
-      const retriedDetails = result.details.filter((d) => d.retryCount > 0)
-
-      if (retriedDetails.length > 0) {
-        lines.push('### 重试订单列表')
-        lines.push('')
-        lines.push('| 订单号   | 重试次数 | 重试结果 | 重试时间     |')
-        lines.push('| -------- | -------- | -------- | ------------ |')
-
-        retriedDetails.forEach((detail) => {
-          const retryStatus = detail.retrySuccess ? '✅ 成功' : '❌ 失败'
-          const retryTime = detail.retriedAt ? this.formatDateTime(detail.retriedAt) : '-'
-          lines.push(
-            `| \`${detail.orderNumber}\` | ${detail.retryCount} | ${retryStatus} | ${retryTime} |`
-          )
-        })
-
-        lines.push('')
-        lines.push('### 重试尝试详细记录')
-        lines.push('')
-
-        retriedDetails.forEach((detail) => {
-          lines.push(`#### \`${detail.orderNumber}\``)
-          lines.push('')
-          lines.push(`- **重试次数**: ${detail.retryCount}`)
-          lines.push(`- **最终结果**: ${detail.retrySuccess ? '✅ 成功' : '❌ 失败'}`)
-
-          if (detail.retryAttempts && detail.retryAttempts.length > 0) {
-            lines.push('')
-            lines.push('**重试尝试记录**:')
-            lines.push('')
-            detail.retryAttempts.forEach((attempt, idx) => {
-              lines.push(
-                `${idx + 1}. **第${attempt.attempt}次尝试** - ${this.formatDateTime(attempt.timestamp)}`
-              )
-              lines.push(`   - 错误：${attempt.error}`)
-            })
-            lines.push('')
-          }
-
-          lines.push('---')
-          lines.push('')
-        })
-      }
-
-      lines.push('')
-    }
-
-    lines.push(`**报告生成时间**: \`${this.formatDateTime(options.endTime)}\``)
-    lines.push('**报表版本**: `v1.0`')
-
-    return lines.join('\n')
-  }
-
-  private collectAllSkippedMaterials(
-    details: OrderCleanDetail[]
-  ): Array<SkippedMaterial & { orderNumber: string }> {
-    const result: Array<SkippedMaterial & { orderNumber: string }> = []
-
-    details.forEach((detail) => {
-      if (detail.skippedMaterials && detail.skippedMaterials.length > 0) {
-        detail.skippedMaterials.forEach((skipped) => {
-          result.push({
-            ...skipped,
-            orderNumber: detail.orderNumber
-          })
-        })
-      }
-    })
-
-    return result
-  }
-
-  private extractErrorOrders(details: OrderCleanDetail[]): string[] {
-    return details.filter((d) => d.errors.length > 0).map((d) => d.orderNumber)
-  }
-
-  private formatDateTime(timestamp: number): string {
-    const date = new Date(timestamp)
-    const year = date.getFullYear()
-    const month = String(date.getMonth() + 1).padStart(2, '0')
-    const day = String(date.getDate()).padStart(2, '0')
-    const hours = String(date.getHours()).padStart(2, '0')
-    const minutes = String(date.getMinutes()).padStart(2, '0')
-    const seconds = String(date.getSeconds()).padStart(2, '0')
-    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`
-  }
-
-  private formatDuration(startTime: number, endTime: number): string {
-    const durationMs = endTime - startTime
-    const minutes = Math.floor(durationMs / 60000)
-    const seconds = Math.floor((durationMs % 60000) / 1000)
-    return `${minutes}分${seconds}秒`
-  }
-}

src/main/services/update/update-service.ts

@@ -1,6 +1,8 @@
 import * as fs from 'fs'
 import { ConfigManager } from '../config/config-manager'
 import { createLogger } from '../logger'
+import { logAuditWithCurrentUser } from '../logger/audit-logger'
+import { AuditAction, AuditStatus } from '../../types/audit.types'
 import type { UpdateConfig } from '../../types/config.schema'
 import type { UserType } from '../../types/user.types'
 import type {
@@ -281,10 +283,21 @@ export class UpdateService {
       log.error('Update package hash mismatch', {
         version: request.version,
         channel: request.channel,
-        expectedHash: request.sha256,
+        expectedHash: request.sha256.substring(0, 16),
-        actualHash: hash
+        actualHash: hash.substring(0, 16)
       })
       await fs.promises.rm(downloadPath, { force: true })
+
+      // Audit log: APP_UPDATE download hash mismatch
+      logAuditWithCurrentUser(AuditAction.APP_UPDATE, 'UPDATE_PACKAGE', AuditStatus.FAILURE, {
+        version: request.version,
+        channel: request.channel,
+        phase: 'download',
+        error: 'Hash mismatch',
+        expectedHash: request.sha256.substring(0, 16),
+        actualHash: hash.substring(0, 16)
+      })
+
       throw new Error('更新包校验失败，文件哈希不匹配')
     }
 
@@ -294,6 +307,13 @@ export class UpdateService {
       downloadPath
     })
 
+    // Audit log: APP_UPDATE download success
+    logAuditWithCurrentUser(AuditAction.APP_UPDATE, 'UPDATE_PACKAGE', AuditStatus.SUCCESS, {
+      version: request.version,
+      channel: request.channel,
+      phase: 'download'
+    })
+
     this.publishStatus({
       phase: 'downloaded',
       progress: 100,
@@ -336,11 +356,29 @@ export class UpdateService {
       error: undefined
     })
 
-    await this.installer.installDownloadedRelease(downloaded)
+    try {
-    log.info('Update installation completed', {
+      await this.installer.installDownloadedRelease(downloaded)
-      version: downloaded.version,
+      log.info('Update installation completed', {
-      channel: downloaded.channel
+        version: downloaded.version,
-    })
+        channel: downloaded.channel
+      })
+
+      // Audit log: APP_UPDATE install success
+      logAuditWithCurrentUser(AuditAction.APP_UPDATE, 'UPDATE_PACKAGE', AuditStatus.SUCCESS, {
+        version: downloaded.version,
+        channel: downloaded.channel,
+        phase: 'install'
+      })
+    } catch (installError) {
+      const msg = installError instanceof Error ? installError.message : String(installError)
+      logAuditWithCurrentUser(AuditAction.APP_UPDATE, 'UPDATE_PACKAGE', AuditStatus.FAILURE, {
+        version: downloaded.version,
+        channel: downloaded.channel,
+        phase: 'install',
+        error: msg
+      })
+      throw installError
+    }
   }
 
   private ensureInitialized(): void {

src/main/services/user/migration/add-productionid-to-cleaner-order.ts

@@ -0,0 +1,140 @@
+/**
+ * Migration Script: Add ProductionId column to CleanerOrderHistory table
+ *
+ * This script adds the ProductionId column to the ERPAuto.CleanerOrderHistory
+ * table for tracking the original production ID (总排号) input.
+ *
+ * Usage:
+ *   npx tsx src/main/services/user/migration/add-productionid-to-cleaner-order.ts
+ */
+
+import { ConfigManager } from '../../config/config-manager'
+import { MySqlService } from '../../database/mysql'
+import { SqlServerService } from '../../database/sql-server'
+import { PostgreSqlService } from '../../database/postgresql'
+import { createLogger } from '../../logger'
+
+const log = createLogger('Migration')
+
+async function runMySQLMigration(): Promise<void> {
+  const configManager = ConfigManager.getInstance()
+  await configManager.initialize()
+  const dbConfig = configManager.getConfig().database.mysql
+
+  const service = new MySqlService({
+    host: dbConfig.host,
+    port: dbConfig.port,
+    user: dbConfig.username,
+    password: dbConfig.password,
+    database: dbConfig.database
+  })
+
+  try {
+    await service.connect()
+    console.log('Connected to MySQL')
+
+    // Check if column already exists
+    const check = await service.query(
+      `SELECT COUNT(*) as cnt FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = 'CleanerOrderHistory' AND COLUMN_NAME = 'ProductionId'`
+    )
+    if ((check.rows[0]?.cnt as number) > 0) {
+      console.log('Column ProductionId already exists, skipping.')
+      return
+    }
+
+    await service.query(`ALTER TABLE CleanerOrderHistory ADD COLUMN ProductionId VARCHAR(50) NULL`)
+    console.log('Added ProductionId column to CleanerOrderHistory.')
+  } finally {
+    if (service.isConnected()) await service.disconnect()
+  }
+}
+
+async function runSqlServerMigration(): Promise<void> {
+  const configManager = ConfigManager.getInstance()
+  await configManager.initialize()
+  const dbConfig = configManager.getConfig().database.sqlserver
+
+  const service = new SqlServerService({
+    server: dbConfig.server,
+    port: dbConfig.port,
+    user: dbConfig.username,
+    password: dbConfig.password,
+    database: dbConfig.database,
+    options: { trustServerCertificate: dbConfig.trustServerCertificate }
+  })
+
+  try {
+    await service.connect()
+    console.log('Connected to SQL Server')
+
+    // Check if column already exists
+    const check = await service.query(
+      `SELECT COUNT(*) as cnt FROM sys.columns WHERE OBJECT_ID = OBJECT_ID('ERPAuto.CleanerOrderHistory') AND name = 'ProductionId'`
+    )
+    if ((check.rows[0]?.cnt as number) > 0) {
+      console.log('Column ProductionId already exists, skipping.')
+      return
+    }
+
+    await service.query(
+      `ALTER TABLE [ERPAuto].[CleanerOrderHistory] ADD ProductionId NVARCHAR(50) NULL`
+    )
+    console.log('Added ProductionId column to CleanerOrderHistory.')
+  } finally {
+    if (service.isConnected()) await service.disconnect()
+  }
+}
+
+async function runPostgreSqlMigration(): Promise<void> {
+  const configManager = ConfigManager.getInstance()
+  await configManager.initialize()
+  const dbConfig = configManager.getConfig().database.postgresql
+
+  const service = new PostgreSqlService({
+    host: dbConfig.host,
+    port: dbConfig.port,
+    user: dbConfig.username,
+    password: dbConfig.password,
+    database: dbConfig.database
+  })
+
+  try {
+    await service.connect()
+    console.log('Connected to PostgreSQL')
+
+    await service.query(
+      `ALTER TABLE "ERPAuto"."CleanerOrderHistory" ADD COLUMN IF NOT EXISTS "ProductionId" VARCHAR(50) NULL`
+    )
+    console.log('Added ProductionId column to CleanerOrderHistory.')
+  } finally {
+    if (service.isConnected()) await service.disconnect()
+  }
+}
+
+async function main(): Promise<void> {
+  console.log('Migration: Add ProductionId to CleanerOrderHistory')
+
+  const configManager = ConfigManager.getInstance()
+  await configManager.initialize()
+  const dbType = configManager.getDatabaseType()
+
+  console.log(`Database type: ${dbType}`)
+
+  if (dbType === 'mysql') {
+    await runMySQLMigration()
+  } else if (dbType === 'sqlserver') {
+    await runSqlServerMigration()
+  } else if (dbType === 'postgresql') {
+    await runPostgreSqlMigration()
+  } else {
+    console.error(`Unsupported database type: ${dbType}`)
+    process.exit(1)
+  }
+
+  console.log('Done.')
+}
+
+main().catch((err) => {
+  console.error('Migration failed:', err)
+  process.exit(1)
+})

src/main/services/user/user-erp-config-service.ts

@@ -14,6 +14,8 @@
 import { BIPUsersDAO } from './bip-users-dao'
 import { SessionManager } from './session-manager'
 import { createLogger } from '../logger'
+import { logAuditWithCurrentUser } from '../logger/audit-logger'
+import { AuditAction, AuditStatus } from '../../types/audit.types'
 
 const log = createLogger('UserErpConfigService')
 
@@ -131,9 +133,22 @@ export class UserErpConfigService {
         log.error('Failed to update ERP credentials', { username: currentUser.username })
       }
 
+      logAuditWithCurrentUser(
+        AuditAction.ERP_CREDENTIALS_UPDATE,
+        'ERP_CREDENTIALS',
+        success ? AuditStatus.SUCCESS : AuditStatus.FAILURE,
+        { targetUsername: currentUser.username, updateType: 'self' }
+      )
+
       return success
     } catch (error) {
       log.error('Error updating current user ERP credentials', { error })
+      logAuditWithCurrentUser(
+        AuditAction.ERP_CREDENTIALS_UPDATE,
+        'ERP_CREDENTIALS',
+        AuditStatus.FAILURE,
+        { targetUsername: 'unknown', updateType: 'self', error: String(error) }
+      )
       return false
     }
   }
@@ -159,9 +174,22 @@ export class UserErpConfigService {
         log.error('Failed to update ERP credentials', { username })
       }
 
+      logAuditWithCurrentUser(
+        AuditAction.ERP_CREDENTIALS_UPDATE,
+        'ERP_CREDENTIALS',
+        success ? AuditStatus.SUCCESS : AuditStatus.FAILURE,
+        { targetUsername: username, updateType: 'admin' }
+      )
+
       return success
     } catch (error) {
       log.error('Error updating user ERP credentials', { error })
+      logAuditWithCurrentUser(
+        AuditAction.ERP_CREDENTIALS_UPDATE,
+        'ERP_CREDENTIALS',
+        AuditStatus.FAILURE,
+        { targetUsername: username, updateType: 'admin', error: String(error) }
+      )
       return false
     }
   }

src/main/services/validation/validation-application-service.ts

@@ -231,7 +231,8 @@ export class ValidationApplicationService {
 
   async getCleanerData(
     userInfo: UserInfo,
-    senderId: number
+    senderId: number,
+    selectedManagers: string[] = []
   ): Promise<{
     success: boolean
     orderNumbers?: string[]
@@ -250,6 +251,7 @@ export class ValidationApplicationService {
             userId: userInfo.id,
             username,
             isAdmin,
+            selectedManagers,
             requestId
           })
 
@@ -270,7 +272,13 @@ export class ValidationApplicationService {
             })
           }
 
-          const materialCodes = await this.loadMaterialCodesForCleaner(dbService, username, isAdmin)
+          const materialCodes = await this.loadMaterialCodesForCleaner(
+            dbService,
+            username,
+            isAdmin,
+            selectedManagers,
+            orderNumbers
+          )
           log.info('Cleaner data retrieved', {
             userId: userInfo.id,
             orderCount: orderNumbers.length,
@@ -489,27 +497,54 @@ export class ValidationApplicationService {
   private async loadMaterialCodesForCleaner(
     dbService: ValidationDatabaseService,
     username: string,
-    isAdmin: boolean
+    isAdmin: boolean,
+    selectedManagers: string[],
+    orderNumbers: string[]
   ): Promise<string[]> {
     const markedTableName = getValidationTableName('dbo_MaterialsToBeDeleted')
 
-    if (isAdmin) {
+    // Admin with selected managers: filter MaterialsToBeDeleted by ManagerName IN (selectedManagers)
-      const result = await dbService.query(
+    if (isAdmin && selectedManagers && selectedManagers.length > 0) {
-        `
+      const materialCodes = await this.queryMaterialCodesByManagers(
-          SELECT MaterialCode
+        dbService,
-          FROM ${markedTableName}
+        markedTableName,
-          WHERE MaterialCode IS NOT NULL
+        selectedManagers
-        `
       )
-      const materialCodes = result.rows.map((row) => row.MaterialCode as string).filter(Boolean)
+      log.info(`Admin with selected managers: got ${materialCodes.length} materials`, {
-      log.info(`Admin user: got ${materialCodes.length} materials`, {
         userId: username,
         isAdmin: true,
+        selectedManagers,
         materialCount: materialCodes.length
       })
       return materialCodes
     }
 
+    // Admin without selected managers: query all materials from DiscreteMaterialPlanData by orderNumbers
+    if (isAdmin) {
+      if (orderNumbers.length === 0) {
+        log.warn('Admin without selected managers but no orderNumbers available', {
+          userId: username
+        })
+        return []
+      }
+      const materialDao = new DiscreteMaterialPlanDAO()
+      const records = await materialDao.queryBySourceNumbersDistinct(orderNumbers)
+      const materialCodes = [
+        ...new Set(records.map((r) => r.MaterialCode as string).filter(Boolean))
+      ]
+      log.info(
+        `Admin without selected managers: got ${materialCodes.length} materials from DiscreteMaterialPlanData`,
+        {
+          userId: username,
+          isAdmin: true,
+          orderCount: orderNumbers.length,
+          materialCount: materialCodes.length
+        }
+      )
+      return materialCodes
+    }
+
+    // Regular user: filter MaterialsToBeDeleted by ManagerName = username
     if (dbService.type === 'sqlserver') {
       const sql = await import('mssql')
       const result = await (dbService as SqlServerService).queryWithParams(
@@ -568,6 +603,57 @@ export class ValidationApplicationService {
     return materialCodes
   }
 
+  private async queryMaterialCodesByManagers(
+    dbService: ValidationDatabaseService,
+    tableName: string,
+    managers: string[]
+  ): Promise<string[]> {
+    if (dbService.type === 'sqlserver') {
+      const sql = await import('mssql')
+      const params: Record<string, { value: string; type: any }> = {}
+      const paramNames = managers.map((m, i) => {
+        const name = `@manager${i}`
+        params[`manager${i}`] = { value: m, type: sql.default.NVarChar }
+        return name
+      })
+      const result = await (dbService as SqlServerService).queryWithParams(
+        `
+          SELECT MaterialCode
+          FROM ${tableName}
+          WHERE ManagerName IN (${paramNames.join(', ')}) AND MaterialCode IS NOT NULL
+        `,
+        params
+      )
+      return result.rows
+        .map((row: Record<string, unknown>) => row.MaterialCode as string)
+        .filter(Boolean)
+    }
+
+    if (dbService.type === 'postgresql') {
+      const placeholders = managers.map((_, i) => `$${i + 1}`).join(', ')
+      const result = await dbService.query(
+        `
+          SELECT "MaterialCode"
+          FROM ${tableName}
+          WHERE "ManagerName" IN (${placeholders}) AND "MaterialCode" IS NOT NULL
+        `,
+        managers
+      )
+      return result.rows.map((row) => row.MaterialCode as string).filter(Boolean)
+    }
+
+    const placeholders = managers.map(() => '?').join(', ')
+    const result = await dbService.query(
+      `
+        SELECT MaterialCode
+        FROM ${tableName}
+        WHERE ManagerName IN (${placeholders}) AND MaterialCode IS NOT NULL
+      `,
+      managers
+    )
+    return result.rows.map((row) => row.MaterialCode as string).filter(Boolean)
+  }
+
   private async disconnectQuietly(dbService: ValidationDatabaseService): Promise<void> {
     try {
       await dbService.disconnect()

src/main/types/audit.types.ts

@@ -10,23 +10,31 @@ export enum AuditAction {
   LOGOUT = 'LOGOUT',
   EXTRACT = 'EXTRACT',
   CLEAN = 'CLEAN',
-  SETTINGS_CHANGE = 'SETTINGS_CHANGE'
+  SETTINGS_CHANGE = 'SETTINGS_CHANGE',
+  SYSTEM_CRASH = 'SYSTEM_CRASH',
+  SYSTEM_ERROR = 'SYSTEM_ERROR',
+  DATA_IMPORT = 'DATA_IMPORT',
+  RESULT_EXPORT = 'RESULT_EXPORT',
+  APP_UPDATE = 'APP_UPDATE',
+  ERP_CREDENTIALS_UPDATE = 'ERP_CREDENTIALS_UPDATE'
 }
 
 /**
  * Audit status enumeration
+ * Note: Values are lowercase to match JSON logging conventions
  */
 export enum AuditStatus {
-  SUCCESS = 'SUCCESS',
+  SUCCESS = 'success',
-  FAILURE = 'FAILURE'
+  FAILURE = 'failure',
+  PARTIAL = 'partial'
 }
 
 /**
  * Audit entry interface
  */
 export interface AuditEntry {
-  /** Timestamp of the action */
+  /** ISO timestamp of the action */
-  timestamp: Date
+  timestamp: string
   /** Action performed */
   action: AuditAction
   /** User ID who performed the action */
@@ -38,9 +46,9 @@ export interface AuditEntry {
   /** Application version when action was performed */
   appVersion: string
   /** Resource affected by the action */
-  resource?: string
+  resource: string
   /** Status of the action */
   status: AuditStatus
-  /** Additional metadata in JSON format */
+  /** Additional metadata */
-  metadata?: string
+  metadata: Record<string, unknown>
 }

src/main/types/cleaner-history.types.ts

@@ -0,0 +1,113 @@
+// src/main/types/cleaner-history.types.ts
+
+/**
+ * Cleaner 操作历史类型定义
+ */
+
+/** 执行级记录 */
+export interface CleanerExecutionRecord {
+  id?: number
+  batchId: string
+  attemptNumber: number
+  userId: number
+  username: string
+  operationTime: Date
+  endTime: Date | null
+  status: string
+  isDryRun: boolean
+  totalOrders: number
+  ordersProcessed: number
+  totalMaterialsDeleted: number
+  totalMaterialsSkipped: number
+  totalMaterialsFailed: number
+  totalUncertainDeletions: number
+  errorMessage: string | null
+  appVersion: string | null
+}
+
+/** 订单级记录 */
+export interface CleanerOrderRecord {
+  id?: number
+  batchId: string
+  attemptNumber: number
+  orderNumber: string
+  productionId: string | null
+  status: string
+  materialsDeleted: number
+  materialsSkipped: number
+  materialsFailed: number
+  uncertainDeletions: number
+  retryCount: number
+  retrySuccess: boolean
+  errorMessage: string | null
+}
+
+/** 物料级记录 */
+export interface CleanerMaterialRecord {
+  id?: number
+  batchId: string
+  attemptNumber: number
+  orderNumber: string
+  materialCode: string
+  materialName: string
+  rowNumber: number
+  result: string
+  reason: string | null
+  attemptCount: number
+  finalErrorCategory: string | null
+}
+
+/** 批次统计（前端列表展示用） */
+export interface CleanerBatchStats {
+  batchId: string
+  userId: number
+  username: string
+  operationTime: string
+  status: string
+  totalAttempts: number
+  totalOrders: number
+  ordersProcessed: number
+  totalMaterialsDeleted: number
+  totalMaterialsFailed: number
+  successCount: number
+  failedCount: number
+  isDryRun: boolean
+}
+
+/** 插入执行记录的输入 */
+export interface InsertCleanerExecutionInput {
+  batchId: string
+  attemptNumber: number
+  userId: number
+  username: string
+  isDryRun: boolean
+  totalOrders: number
+  appVersion: string
+}
+
+/** 插入订单记录的输入 */
+export interface InsertOrderInput {
+  orderNumber: string
+  productionId?: string
+  initialStatus?: string
+  errorMessage?: string
+}
+
+/** 插入物料明细的输入 */
+export interface InsertMaterialDetailInput {
+  orderNumber: string
+  materialCode: string
+  materialName: string
+  rowNumber: number
+  result: string
+  reason: string | null
+  attemptCount: number
+  finalErrorCategory: string | null
+}
+
+/** 查询批次的选项 */
+export interface GetCleanerBatchesOptions {
+  limit?: number
+  offset?: number
+  usernames?: string[]
+}

src/main/types/cleaner.types.ts

@@ -1,4 +1,4 @@
-export type CleanerPhase = 'login' | 'processing' | 'complete'
+export type CleanerPhase = 'login' | 'processing' | 'complete' | 'retry'
 
 export interface CleanerProgress {
   message: string
@@ -30,6 +30,11 @@ export interface CleanerResult {
   // Retry statistics
   retriedOrders: number
   successfulRetries: number
+  // Deletion verification statistics
+  materialsFailed: number
+  uncertainDeletions: number
+  // Outer retry: true when outer catch triggered (browser crash / fatal timeout)
+  crashed?: boolean
 }
 
 export interface SkippedMaterial {
@@ -39,6 +44,13 @@ export interface SkippedMaterial {
   reason: string
 }
 
+export interface DeletedMaterial {
+  materialCode: string
+  materialName: string
+  rowNumber: number
+  outcome: string
+}
+
 export interface RetryAttempt {
   attempt: number
   error: string
@@ -51,11 +63,58 @@ export interface OrderCleanDetail {
   materialsSkipped: number
   errors: string[]
   skippedMaterials: SkippedMaterial[]
+  deletedMaterials: DeletedMaterial[]
   // Retry-related fields
   retryCount: number
   retryAttempts?: RetryAttempt[]
   retriedAt?: number
   retrySuccess?: boolean
+  // Deletion verification fields
+  materialsFailed: number
+  failedMaterials: FailedMaterial[]
+  uncertainDeletions: number
+  // Missing order flag: true when order not found in ERP query results
+  notFound?: boolean
+}
+
+export enum DeletionOutcome {
+  Success = 'success',
+  FailedErpError = 'failed_erp_error',
+  FailedNoChange = 'failed_no_change',
+  FailedTimeout = 'failed_timeout',
+  FailedButtonDisabled = 'failed_button_disabled',
+  Uncertain = 'uncertain'
+}
+
+export enum DeletionErrorCategory {
+  ErpRejection = 'erp_rejection',
+  ErpBusy = 'erp_busy',
+  NetworkLag = 'network_lag',
+  UiUnexpected = 'ui_unexpected',
+  VerificationTimeout = 'verification_timeout',
+  Unknown = 'unknown'
+}
+
+export interface MaterialDeletionAttempt {
+  attempt: number
+  outcome: DeletionOutcome
+  errorCategory?: DeletionErrorCategory
+  errorMessage?: string
+  rowNumberBefore: string
+  rowNumberAfter: string
+  materialCountBefore: number
+  materialCountAfter: number
+  timestamp: number
+  durationMs: number
+}
+
+export interface FailedMaterial {
+  materialCode: string
+  materialName: string
+  rowNumber: number
+  attempts: MaterialDeletionAttempt[]
+  finalOutcome: DeletionOutcome
+  finalErrorCategory?: DeletionErrorCategory
 }
 
 /**

src/main/types/ipc-api.types.ts

@@ -11,6 +11,12 @@ import type {
   ExportResultItem,
   ExportResultResponse
 } from './cleaner.types'
+import type {
+  CleanerBatchStats,
+  CleanerExecutionRecord,
+  CleanerOrderRecord,
+  CleanerMaterialRecord
+} from './cleaner-history.types'
 import type { IpcResult } from './ipc.types'
 
 /**
@@ -113,6 +119,45 @@ export interface CleanerAPI {
    * @returns Unsubscribe function
    */
   onProgress: (callback: (data: CleanerProgress) => void) => () => void
+
+  /**
+   * Get cleaner operation history batches
+   * @param options - Query options (limit, offset, usernames)
+   */
+  getHistoryBatches: (options?: {
+    limit?: number
+    offset?: number
+    usernames?: string[]
+  }) => Promise<IpcResult<CleanerBatchStats[]>>
+
+  /**
+   * Get detailed execution and order records for a specific batch
+   * @param batchId - Batch ID
+   */
+  getHistoryBatchDetails: (batchId: string) => Promise<
+    IpcResult<{
+      executions: CleanerExecutionRecord[]
+      orders: CleanerOrderRecord[]
+    }>
+  >
+
+  /**
+   * Get material-level details for a specific order in a batch attempt
+   * @param batchId - Batch ID
+   * @param attemptNumber - Attempt number
+   * @param orderNumber - Order number
+   */
+  getHistoryMaterialDetails: (
+    batchId: string,
+    attemptNumber: number,
+    orderNumber: string
+  ) => Promise<IpcResult<CleanerMaterialRecord[]>>
+
+  /**
+   * Delete a cleaner history batch
+   * @param batchId - Batch ID
+   */
+  deleteHistoryBatch: (batchId: string) => Promise<IpcResult<{ deleted: boolean }>>
 }
 
 /**

src/preload/api/cleaner.ts

@@ -3,6 +3,14 @@ import type {
   CleanerProgress,
   ExportResultItem
 } from '../../main/types/cleaner.types'
+import type {
+  CleanerBatchStats,
+  CleanerExecutionRecord,
+  CleanerOrderRecord,
+  CleanerMaterialRecord,
+  GetCleanerBatchesOptions
+} from '../../main/types/cleaner-history.types'
+import type { IpcResult } from '../../main/types/ipc.types'
 import { IPC_CHANNELS } from '../../shared/ipc-channels'
 import { invokeIpc, ipcRenderer } from '../lib/ipc'
 
@@ -15,5 +23,35 @@ export const cleanerApi = {
       callback(data)
     ipcRenderer.on(IPC_CHANNELS.CLEANER_PROGRESS, subscription)
     return () => ipcRenderer.removeListener(IPC_CHANNELS.CLEANER_PROGRESS, subscription)
-  }
+  },
+
+  // Cleaner operation history
+  getHistoryBatches: (
+    options?: GetCleanerBatchesOptions
+  ): Promise<IpcResult<CleanerBatchStats[]>> =>
+    invokeIpc(IPC_CHANNELS.CLEANER_HISTORY_GET_BATCHES, options),
+
+  getHistoryBatchDetails: (
+    batchId: string
+  ): Promise<
+    IpcResult<{
+      executions: CleanerExecutionRecord[]
+      orders: CleanerOrderRecord[]
+    }>
+  > => invokeIpc(IPC_CHANNELS.CLEANER_HISTORY_GET_BATCH_DETAILS, batchId),
+
+  getHistoryMaterialDetails: (
+    batchId: string,
+    attemptNumber: number,
+    orderNumber: string
+  ): Promise<IpcResult<CleanerMaterialRecord[]>> =>
+    invokeIpc(
+      IPC_CHANNELS.CLEANER_HISTORY_GET_MATERIAL_DETAILS,
+      batchId,
+      attemptNumber,
+      orderNumber
+    ),
+
+  deleteHistoryBatch: (batchId: string): Promise<IpcResult<{ deleted: boolean }>> =>
+    invokeIpc(IPC_CHANNELS.CLEANER_HISTORY_DELETE_BATCH, batchId)
 } as const

src/preload/api/validation.ts

@@ -8,5 +8,6 @@ export const validationApi = {
     invokeIpc(IPC_CHANNELS.VALIDATION_SET_SHARED_PRODUCTION_IDS, productionIds),
   getSharedProductionIds: () => invokeIpc(IPC_CHANNELS.VALIDATION_GET_SHARED_PRODUCTION_IDS),
   clearSharedProductionIds: () => invokeIpc(IPC_CHANNELS.VALIDATION_CLEAR_SHARED_PRODUCTION_IDS),
-  getCleanerData: () => invokeIpc(IPC_CHANNELS.VALIDATION_GET_CLEANER_DATA)
+  getCleanerData: (params?: { selectedManagers?: string[] }) =>
+    invokeIpc(IPC_CHANNELS.VALIDATION_GET_CLEANER_DATA, params ?? { selectedManagers: [] })
 } as const

src/preload/index.d.ts

@@ -59,7 +59,7 @@ export interface ValidationAPI {
   setSharedProductionIds: (productionIds: string[]) => Promise<IpcResult<void>>
   getSharedProductionIds: () => Promise<IpcResult<{ productionIds: string[] }>>
   clearSharedProductionIds: () => Promise<IpcResult<void>>
-  getCleanerData: () => Promise<
+  getCleanerData: (params?: { selectedManagers?: string[] }) => Promise<
     IpcResult<{
       orderNumbers: string[]
       materialCodes: string[]
@@ -190,6 +190,91 @@ export interface OperationHistoryRecord {
   errorMessage: string | null
 }
 
+export interface CleanerHistoryBatchStats {
+  batchId: string
+  userId: number
+  username: string
+  operationTime: string
+  status: string
+  totalAttempts: number
+  totalOrders: number
+  ordersProcessed: number
+  totalMaterialsDeleted: number
+  totalMaterialsFailed: number
+  successCount: number
+  failedCount: number
+  isDryRun: boolean
+}
+
+export interface CleanerHistoryExecutionRecord {
+  id?: number
+  batchId: string
+  attemptNumber: number
+  userId: number
+  username: string
+  operationTime: Date
+  endTime: Date | null
+  status: string
+  isDryRun: boolean
+  totalOrders: number
+  ordersProcessed: number
+  totalMaterialsDeleted: number
+  totalMaterialsSkipped: number
+  totalMaterialsFailed: number
+  totalUncertainDeletions: number
+  errorMessage: string | null
+  appVersion: string | null
+}
+
+export interface CleanerHistoryOrderRecord {
+  id?: number
+  batchId: string
+  attemptNumber: number
+  orderNumber: string
+  status: string
+  materialsDeleted: number
+  materialsSkipped: number
+  materialsFailed: number
+  uncertainDeletions: number
+  retryCount: number
+  retrySuccess: boolean
+  errorMessage: string | null
+}
+
+export interface CleanerHistoryMaterialRecord {
+  id?: number
+  batchId: string
+  attemptNumber: number
+  orderNumber: string
+  materialCode: string
+  materialName: string
+  rowNumber: number
+  result: string
+  reason: string | null
+  attemptCount: number
+  finalErrorCategory: string | null
+}
+
+export interface CleanerHistoryAPI {
+  getHistoryBatches: (options?: {
+    limit?: number
+    offset?: number
+    usernames?: string[]
+  }) => Promise<IpcResult<CleanerHistoryBatchStats[]>>
+  getHistoryBatchDetails: (batchId: string) => Promise<
+    IpcResult<{
+      executions: CleanerHistoryExecutionRecord[]
+      orders: CleanerHistoryOrderRecord[]
+    }>
+  >
+  getHistoryMaterialDetails: (
+    batchId: string,
+    attemptNumber: number,
+    orderNumber: string
+  ) => Promise<IpcResult<CleanerHistoryMaterialRecord[]>>
+  deleteHistoryBatch: (batchId: string) => Promise<IpcResult<{ deleted: boolean }>>
+}
+
 export interface ProcessAPI {
   versions: {
     electron: string

src/renderer/src/components/CleanerOperationHistoryModal.tsx

@@ -0,0 +1,845 @@
+/**
+ * Cleaner Operation History Modal
+ *
+ * Displays cleaner operation history with batch statistics, execution records,
+ * order details, and material-level details.
+ * Admin users see all users' records, regular users see only their own.
+ */
+
+import React, { useState, useEffect, useCallback, useRef } from 'react'
+import { Modal } from './ui/Modal'
+import { useLogger } from '../hooks/useLogger'
+import {
+  RefreshCw,
+  Trash2,
+  ChevronDown,
+  ChevronRight,
+  CheckCircle,
+  XCircle,
+  CircleMinus,
+  AlertTriangle,
+  Clock,
+  Copy,
+  FlaskConical
+} from 'lucide-react'
+import type { UserInfo } from './UserSelectionDialog'
+import type {
+  CleanerHistoryBatchStats,
+  CleanerHistoryOrderRecord,
+  CleanerHistoryMaterialRecord
+} from '../hooks/cleaner/types'
+
+// The preload API returns Date for time fields, but IPC serialization converts them to strings.
+// Use a local type that accommodates both to satisfy TypeScript.
+interface ExecutionRecord {
+  id?: number
+  batchId: string
+  attemptNumber: number
+  userId: number
+  username: string
+  operationTime: string | Date
+  endTime: string | Date | null
+  status: string
+  isDryRun: boolean
+  totalOrders: number
+  ordersProcessed: number
+  totalMaterialsDeleted: number
+  totalMaterialsSkipped: number
+  totalMaterialsFailed: number
+  totalUncertainDeletions: number
+  errorMessage: string | null
+  appVersion: string | null
+}
+import { showSuccess, showError, showWarning } from '../stores/useAppStore'
+
+interface CleanerOperationHistoryModalProps {
+  isOpen: boolean
+  onClose: () => void
+  user?: { username: string; userType: string } | null
+}
+
+interface BatchItemProps {
+  batch: CleanerHistoryBatchStats
+  isAdmin: boolean
+  onDelete: (batchId: string) => void
+}
+
+const statusStyles: Record<string, string> = {
+  success: 'bg-green-100 text-green-700',
+  partial: 'bg-amber-100 text-amber-700',
+  failed: 'bg-red-100 text-red-700',
+  crashed: 'bg-red-100 text-red-700',
+  pending: 'bg-gray-100 text-gray-700',
+  not_found: 'bg-orange-100 text-orange-700',
+  erp_not_found: 'bg-orange-100 text-orange-700'
+}
+
+const statusLabels: Record<string, string> = {
+  success: '成功',
+  partial: '部分成功',
+  failed: '失败',
+  crashed: '崩溃',
+  pending: '进行中',
+  not_found: '未找到',
+  erp_not_found: 'ERP不存在'
+}
+
+const statusIcons: Record<string, React.ReactNode> = {
+  success: <CheckCircle size={16} className="text-green-600" />,
+  partial: <Clock size={16} className="text-amber-600" />,
+  failed: <XCircle size={16} className="text-red-600" />,
+  crashed: <XCircle size={16} className="text-red-600" />,
+  pending: <Clock size={16} className="text-gray-500" />,
+  not_found: <XCircle size={16} className="text-orange-600" />,
+  erp_not_found: <XCircle size={16} className="text-orange-600" />
+}
+
+const formatDateTime = (dateStr: string | Date | null | undefined): string => {
+  if (!dateStr) return '-'
+  const date = typeof dateStr === 'string' ? new Date(dateStr) : dateStr
+
+  if (isNaN(date.getTime())) {
+    return String(dateStr)
+  }
+
+  // Use local time instead of UTC for display
+  const year = date.getFullYear()
+  const month = String(date.getMonth() + 1).padStart(2, '0')
+  const day = String(date.getDate()).padStart(2, '0')
+  const hours = String(date.getHours()).padStart(2, '0')
+  const minutes = String(date.getMinutes()).padStart(2, '0')
+  const seconds = String(date.getSeconds()).padStart(2, '0')
+
+  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`
+}
+
+const formatDuration = (startTime: string | Date | null, endTime: string | Date | null) => {
+  if (!startTime || !endTime) return '-'
+  const start = typeof startTime === 'string' ? new Date(startTime) : startTime
+  const end = typeof endTime === 'string' ? new Date(endTime) : endTime
+  if (isNaN(start.getTime()) || isNaN(end.getTime())) return '-'
+
+  const diffMs = end.getTime() - start.getTime()
+  const seconds = Math.floor(diffMs / 1000)
+  if (seconds < 60) return `${seconds}秒`
+
+  const minutes = Math.floor(seconds / 60)
+  const remainSeconds = seconds % 60
+  if (minutes < 60) return `${minutes}分${remainSeconds}秒`
+
+  const hours = Math.floor(minutes / 60)
+  const remainMinutes = minutes % 60
+  return `${hours}时${remainMinutes}分`
+}
+
+// ====== BatchItem Component ======
+// Extracted from the modal so that expanding one batch doesn't re-render siblings.
+// Each BatchItem manages its own details, orders, and material state locally.
+const BatchItem = React.memo(({ batch, isAdmin, onDelete }: BatchItemProps) => {
+  const [isExpanded, setIsExpanded] = useState(false)
+  const [executions, setExecutions] = useState<ExecutionRecord[]>([])
+  const [orders, setOrders] = useState<CleanerHistoryOrderRecord[]>([])
+  const [currentAttempt, setCurrentAttempt] = useState<number | undefined>()
+  const [expandedOrders, setExpandedOrders] = useState<Set<string>>(() => new Set())
+  const [orderMaterials, setOrderMaterials] = useState<Map<string, CleanerHistoryMaterialRecord[]>>(
+    () => new Map()
+  )
+  const [loadingMaterials, setLoadingMaterials] = useState<Set<string>>(() => new Set())
+  const [isDeleting, setIsDeleting] = useState(false)
+
+  const detailsLoadedRef = useRef(false)
+  const loadedMaterialsRef = useRef<Set<string>>(new Set())
+  const logger = useLogger('BatchItem')
+
+  // Fetch batch details when first expanded
+  useEffect(() => {
+    if (!isExpanded || detailsLoadedRef.current) return
+    detailsLoadedRef.current = true
+
+    const fetchDetails = async () => {
+      try {
+        const result = await window.electron.cleaner.getHistoryBatchDetails(batch.batchId)
+        if (result.success && result.data) {
+          setExecutions(result.data.executions)
+          setOrders(result.data.orders)
+
+          const execs = result.data.executions
+          if (execs.length > 0) {
+            setCurrentAttempt(Math.max(...execs.map((e) => e.attemptNumber)))
+          }
+        }
+      } catch (err) {
+        logger.error('Failed to fetch batch details', {
+          error: err instanceof Error ? err.message : String(err),
+          batchId: batch.batchId
+        })
+      }
+    }
+
+    void fetchDetails()
+  }, [isExpanded, batch.batchId, logger])
+
+  const fetchMaterials = useCallback(
+    async (attemptNumber: number, orderNumber: string) => {
+      const cacheKey = `${attemptNumber}:${orderNumber}`
+      if (loadedMaterialsRef.current.has(cacheKey)) return
+      loadedMaterialsRef.current.add(cacheKey)
+
+      setLoadingMaterials((prev) => new Set(prev).add(cacheKey))
+      try {
+        const result = await window.electron.cleaner.getHistoryMaterialDetails(
+          batch.batchId,
+          attemptNumber,
+          orderNumber
+        )
+        if (result.success && result.data) {
+          setOrderMaterials((prev) => new Map(prev).set(cacheKey, result.data!))
+        }
+      } catch (err) {
+        logger.error('Failed to fetch material details', {
+          error: err instanceof Error ? err.message : String(err),
+          batchId: batch.batchId,
+          attemptNumber,
+          orderNumber
+        })
+      } finally {
+        setLoadingMaterials((prev) => {
+          const newSet = new Set(prev)
+          newSet.delete(cacheKey)
+          return newSet
+        })
+      }
+    },
+    [batch.batchId, logger]
+  )
+
+  const toggleOrderExpansion = (attemptNumber: number, orderNumber: string) => {
+    const cacheKey = `${attemptNumber}:${orderNumber}`
+    const isCurrentlyExpanded = expandedOrders.has(cacheKey)
+    setExpandedOrders((prev) => {
+      const newSet = new Set(prev)
+      if (newSet.has(cacheKey)) {
+        newSet.delete(cacheKey)
+      } else {
+        newSet.add(cacheKey)
+      }
+      return newSet
+    })
+    if (!isCurrentlyExpanded) {
+      void fetchMaterials(attemptNumber, orderNumber)
+    }
+  }
+
+  const handleDelete = async () => {
+    if (isDeleting) return
+    const confirmed = confirm('确定要删除此批次记录吗？此操作不可撤销。')
+    if (!confirmed) return
+
+    setIsDeleting(true)
+    try {
+      const result = await window.electron.cleaner.deleteHistoryBatch(batch.batchId)
+      if (result.success) {
+        onDelete(batch.batchId)
+      } else {
+        alert(result.error || '删除失败')
+      }
+    } catch (err) {
+      alert(err instanceof Error ? err.message : '删除失败')
+    } finally {
+      setIsDeleting(false)
+    }
+  }
+
+  const handleCopyColumn = (field: keyof CleanerHistoryOrderRecord) => {
+    const filtered =
+      currentAttempt !== undefined
+        ? orders.filter((o) => o.attemptNumber === currentAttempt)
+        : orders
+    const values = filtered
+      .map((o) => String(o[field] ?? ''))
+      .filter((v) => v && v !== '-')
+      .join('\n')
+
+    if (!values) {
+      showWarning('没有可复制的数据')
+      return
+    }
+
+    navigator.clipboard
+      .writeText(values)
+      .then(() => showSuccess(`已复制 ${values.split('\n').length} 条数据`))
+      .catch(() => showError('复制失败，请手动复制'))
+  }
+
+  const filteredOrders =
+    currentAttempt !== undefined ? orders.filter((o) => o.attemptNumber === currentAttempt) : orders
+
+  return (
+    <div className="border border-gray-200 rounded-lg overflow-hidden">
+      {/* Batch summary */}
+      <div
+        className={`flex items-center justify-between p-4 cursor-pointer transition-colors ${
+          isExpanded ? 'bg-gray-50' : 'hover:bg-gray-50'
+        }`}
+        onClick={() => setIsExpanded((prev) => !prev)}
+      >
+        <div className="flex items-center gap-4 flex-1">
+          <button className="p-1 hover:bg-gray-200 rounded">
+            {isExpanded ? <ChevronDown size={18} /> : <ChevronRight size={18} />}
+          </button>
+
+          <div className="flex-1 grid grid-cols-7 gap-3 text-sm">
+            <div>
+              <div className="text-gray-500 text-xs">操作时间</div>
+              <div className="font-medium text-gray-900">{formatDateTime(batch.operationTime)}</div>
+            </div>
+            <div>
+              <div className="text-gray-500 text-xs">操作用户</div>
+              <div className="font-medium text-gray-900">{batch.username}</div>
+            </div>
+            <div>
+              <div className="text-gray-500 text-xs">状态</div>
+              <div className="flex items-center gap-1">
+                {statusIcons[batch.status] || statusIcons.pending}
+                <span
+                  className={`px-2 py-0.5 rounded text-xs font-medium ${
+                    statusStyles[batch.status] || statusStyles.pending
+                  }`}
+                >
+                  {statusLabels[batch.status] || batch.status}
+                </span>
+              </div>
+            </div>
+            <div>
+              <div className="text-gray-500 text-xs">订单数</div>
+              <div className="font-medium text-gray-900">{batch.totalOrders}</div>
+            </div>
+            <div>
+              <div className="text-gray-500 text-xs">已删除</div>
+              <div className="font-medium text-green-600">{batch.totalMaterialsDeleted}</div>
+            </div>
+            <div>
+              <div className="text-gray-500 text-xs">失败</div>
+              <div className="font-medium text-gray-900">
+                {batch.totalMaterialsFailed > 0 ? (
+                  <span className="text-red-600">{batch.totalMaterialsFailed}</span>
+                ) : (
+                  '0'
+                )}
+              </div>
+            </div>
+            <div className="flex items-center gap-2">
+              {batch.isDryRun && (
+                <span className="inline-flex items-center gap-1 px-2 py-0.5 rounded text-xs font-medium bg-purple-100 text-purple-700">
+                  <FlaskConical size={12} />
+                  试运行
+                </span>
+              )}
+              {batch.totalAttempts > 1 && (
+                <span className="inline-flex items-center px-2 py-0.5 rounded text-xs font-medium bg-blue-100 text-blue-700">
+                  {batch.totalAttempts}次尝试
+                </span>
+              )}
+            </div>
+          </div>
+        </div>
+
+        {isAdmin && (
+          <button
+            className="p-2 hover:bg-red-50 text-gray-400 hover:text-red-600 rounded transition-colors disabled:opacity-50"
+            onClick={(e) => {
+              e.stopPropagation()
+              void handleDelete()
+            }}
+            disabled={isDeleting}
+            title="删除批次"
+          >
+            <Trash2 size={16} className={isDeleting ? 'animate-pulse' : ''} />
+          </button>
+        )}
+      </div>
+
+      {/* Batch details */}
+      {isExpanded && (
+        <div className="border-t border-gray-200 bg-white">
+          {/* Execution records */}
+          {executions.length > 0 && (
+            <div className="px-4 py-3 bg-gray-50/50 border-b border-gray-100">
+              <div className="text-xs font-medium text-gray-500 mb-2">执行记录</div>
+              {executions.length > 1 && (
+                <div className="flex gap-1 mb-2">
+                  {executions.map((exec) => (
+                    <button
+                      key={exec.attemptNumber}
+                      className={`px-3 py-1 rounded text-xs font-medium transition-colors ${
+                        currentAttempt === exec.attemptNumber
+                          ? 'bg-blue-600 text-white'
+                          : 'bg-gray-200 text-gray-700 hover:bg-gray-300'
+                      }`}
+                      onClick={() => setCurrentAttempt(exec.attemptNumber)}
+                    >
+                      第{exec.attemptNumber}次
+                    </button>
+                  ))}
+                </div>
+              )}
+              <div className="flex flex-wrap gap-4 text-xs text-gray-600">
+                {executions
+                  .filter((e) => currentAttempt === undefined || e.attemptNumber === currentAttempt)
+                  .map((exec) => (
+                    <React.Fragment key={exec.attemptNumber}>
+                      <span>耗时：{formatDuration(exec.operationTime, exec.endTime)}</span>
+                      <span>
+                        订单：{exec.ordersProcessed}/{exec.totalOrders}
+                      </span>
+                      <span>删除：{exec.totalMaterialsDeleted}</span>
+                      {exec.totalMaterialsFailed > 0 && (
+                        <span className="text-red-600">失败：{exec.totalMaterialsFailed}</span>
+                      )}
+                      {exec.totalUncertainDeletions > 0 && (
+                        <span className="text-amber-600">
+                          不确定：{exec.totalUncertainDeletions}
+                        </span>
+                      )}
+                      {exec.errorMessage && (
+                        <span className="text-red-600" title={exec.errorMessage}>
+                          错误：{exec.errorMessage.substring(0, 80)}
+                          {exec.errorMessage.length > 80 ? '...' : ''}
+                        </span>
+                      )}
+                      {exec.appVersion && <span className="text-gray-400">v{exec.appVersion}</span>}
+                    </React.Fragment>
+                  ))}
+              </div>
+            </div>
+          )}
+
+          {/* Order table */}
+          {filteredOrders.length > 0 ? (
+            <div className="overflow-x-auto">
+              <table className="w-full text-sm">
+                <thead className="bg-gray-50">
+                  <tr>
+                    <th className="px-4 py-2 text-left font-medium text-gray-600 w-8" />
+                    <th className="px-4 py-2 text-left font-medium text-gray-600 w-12 text-center">
+                      序号
+                    </th>
+                    <th className="px-4 py-2 text-left font-medium text-gray-600">总排号</th>
+                    <th className="px-4 py-2 text-left font-medium text-gray-600">
+                      <div className="flex items-center gap-2">
+                        订单号
+                        <button
+                          className="p-1 hover:bg-gray-200 rounded transition-colors"
+                          onClick={() => handleCopyColumn('orderNumber')}
+                          title="复制所有订单号"
+                        >
+                          <Copy size={14} className="text-gray-500 hover:text-gray-700" />
+                        </button>
+                      </div>
+                    </th>
+                    <th className="px-4 py-2 text-left font-medium text-gray-600">状态</th>
+                    <th className="px-4 py-2 text-left font-medium text-gray-600">重试</th>
+                    <th className="px-4 py-2 text-left font-medium text-gray-600">已删除</th>
+                    <th className="px-4 py-2 text-left font-medium text-gray-600">已跳过</th>
+                    <th className="px-4 py-2 text-left font-medium text-gray-600">失败</th>
+                    <th className="px-4 py-2 text-left font-medium text-gray-600">不确定</th>
+                    <th className="px-4 py-2 text-left font-medium text-gray-600">错误信息</th>
+                  </tr>
+                </thead>
+                <tbody className="divide-y divide-gray-100">
+                  {filteredOrders.map((order, index) => {
+                    const orderKey = `${currentAttempt ?? order.attemptNumber}:${order.orderNumber}`
+                    const isOrderExpanded = expandedOrders.has(orderKey)
+                    const materials = orderMaterials.get(orderKey) || []
+                    const isLoadingMaterials = loadingMaterials.has(orderKey)
+
+                    return (
+                      <React.Fragment key={orderKey}>
+                        <tr
+                          className="hover:bg-gray-50 cursor-pointer"
+                          onClick={() =>
+                            toggleOrderExpansion(
+                              currentAttempt ?? order.attemptNumber,
+                              order.orderNumber
+                            )
+                          }
+                        >
+                          <td className="px-4 py-2">
+                            {isOrderExpanded ? (
+                              <ChevronDown size={14} className="text-gray-400" />
+                            ) : (
+                              <ChevronRight size={14} className="text-gray-400" />
+                            )}
+                          </td>
+                          <td className="px-4 py-2 text-gray-500 font-medium text-xs text-center">
+                            {index + 1}
+                          </td>
+                          <td className="px-4 py-2 text-gray-900 font-mono text-xs">
+                            {order.productionId || '-'}
+                          </td>
+                          <td className="px-4 py-2 text-gray-900 font-mono text-xs">
+                            {order.status === 'not_found' ? '-' : order.orderNumber}
+                          </td>
+                          <td className="px-4 py-2">
+                            <span
+                              className={`inline-flex items-center gap-1 px-2 py-0.5 rounded text-xs font-medium ${
+                                statusStyles[order.status] || statusStyles.pending
+                              }`}
+                            >
+                              {statusIcons[order.status]}
+                              {statusLabels[order.status] || order.status}
+                            </span>
+                          </td>
+                          <td className="px-4 py-2">
+                            {order.retryCount > 0 ? (
+                              <div className="flex flex-col gap-1">
+                                <span className="inline-flex items-center gap-1 px-2 py-0.5 rounded text-xs font-medium bg-purple-100 text-purple-700">
+                                  <RefreshCw size={10} />
+                                  重试{order.retryCount}次
+                                </span>
+                                {order.retrySuccess && (
+                                  <span className="inline-flex items-center gap-1 px-2 py-0.5 rounded text-xs font-medium bg-green-100 text-green-700">
+                                    <CheckCircle size={10} />
+                                    成功
+                                  </span>
+                                )}
+                                {!order.retrySuccess && (
+                                  <span className="inline-flex items-center gap-1 px-2 py-0.5 rounded text-xs font-medium bg-red-100 text-red-700">
+                                    <XCircle size={10} />
+                                    失败
+                                  </span>
+                                )}
+                              </div>
+                            ) : (
+                              <span className="text-gray-400 text-xs">-</span>
+                            )}
+                          </td>
+                          <td className="px-4 py-2 text-green-600">{order.materialsDeleted}</td>
+                          <td className="px-4 py-2 text-gray-500">{order.materialsSkipped}</td>
+                          <td className="px-4 py-2 text-red-600">{order.materialsFailed || '-'}</td>
+                          <td className="px-4 py-2 text-amber-600">
+                            {order.uncertainDeletions || '-'}
+                          </td>
+                          <td className="px-4 py-2 text-red-600 text-xs max-w-xs truncate">
+                            {order.errorMessage || '-'}
+                          </td>
+                        </tr>
+
+                        {/* Material details */}
+                        {isOrderExpanded && (
+                          <tr>
+                            <td colSpan={11} className="bg-gray-50/50 px-8 py-3">
+                              {isLoadingMaterials ? (
+                                <div className="text-xs text-gray-500">加载物料详情...</div>
+                              ) : materials.length > 0 ? (
+                                <table className="w-full text-xs">
+                                  <thead>
+                                    <tr className="text-gray-500">
+                                      <th className="px-3 py-1.5 text-left font-medium w-12 text-center">
+                                        序号
+                                      </th>
+                                      <th className="px-3 py-1.5 text-left font-medium">
+                                        物料编码
+                                      </th>
+                                      <th className="px-3 py-1.5 text-left font-medium">
+                                        物料名称
+                                      </th>
+                                      <th className="px-3 py-1.5 text-left font-medium">行号</th>
+                                      <th className="px-3 py-1.5 text-left font-medium">结果</th>
+                                      <th className="px-3 py-1.5 text-left font-medium">原因</th>
+                                      <th className="px-3 py-1.5 text-left font-medium">
+                                        尝试次数
+                                      </th>
+                                    </tr>
+                                  </thead>
+                                  <tbody className="divide-y divide-gray-100">
+                                    {materials.map((mat, idx) => (
+                                      <tr key={idx} className="hover:bg-gray-50">
+                                        <td className="px-3 py-1.5 text-gray-500 font-medium text-xs text-center">
+                                          {idx + 1}
+                                        </td>
+                                        <td className="px-3 py-1.5 font-mono text-gray-700">
+                                          {mat.materialCode}
+                                        </td>
+                                        <td className="px-3 py-1.5 text-gray-700">
+                                          {mat.materialName}
+                                        </td>
+                                        <td className="px-3 py-1.5 text-gray-600">
+                                          {mat.rowNumber}
+                                        </td>
+                                        <td className="px-3 py-1.5">
+                                          {mat.result === 'success' || mat.result === 'deleted' ? (
+                                            <span
+                                              className="inline-block cursor-help"
+                                              title="Deleted"
+                                            >
+                                              <CheckCircle
+                                                size={16}
+                                                className="text-green-600 flex-shrink-0"
+                                                aria-label="Deleted"
+                                              />
+                                            </span>
+                                          ) : mat.result === 'skipped' ? (
+                                            <span
+                                              className="inline-block cursor-help"
+                                              title="Skipped"
+                                            >
+                                              <CircleMinus
+                                                size={16}
+                                                className="text-gray-400 flex-shrink-0"
+                                                aria-label="Skipped"
+                                              />
+                                            </span>
+                                          ) : mat.result === 'uncertain' ? (
+                                            <span
+                                              className="inline-block cursor-help"
+                                              title="Uncertain"
+                                            >
+                                              <AlertTriangle
+                                                size={16}
+                                                className="text-amber-600 flex-shrink-0"
+                                                aria-label="Uncertain"
+                                              />
+                                            </span>
+                                          ) : mat.result?.startsWith('failed') ? (
+                                            <span
+                                              className="inline-block cursor-help"
+                                              title="Failed"
+                                            >
+                                              <XCircle
+                                                size={16}
+                                                className="text-red-600 flex-shrink-0"
+                                                aria-label="Failed"
+                                              />
+                                            </span>
+                                          ) : null}
+                                        </td>
+                                        <td className="px-3 py-1.5 text-gray-600 max-w-xs truncate">
+                                          {mat.reason || '-'}
+                                        </td>
+                                        <td className="px-3 py-1.5 text-gray-600">
+                                          {mat.attemptCount > 1 ? (
+                                            <span className="text-amber-600">
+                                              {mat.attemptCount}
+                                            </span>
+                                          ) : (
+                                            '1'
+                                          )}
+                                        </td>
+                                      </tr>
+                                    ))}
+                                  </tbody>
+                                </table>
+                              ) : (
+                                <div className="text-xs text-gray-500">暂无物料详情</div>
+                              )}
+                            </td>
+                          </tr>
+                        )}
+                      </React.Fragment>
+                    )
+                  })}
+                </tbody>
+              </table>
+            </div>
+          ) : (
+            <div className="px-4 py-6 text-center text-sm text-gray-500">暂无订单记录</div>
+          )}
+        </div>
+      )}
+    </div>
+  )
+})
+
+BatchItem.displayName = 'BatchItem'
+
+// ====== Main Modal Component ======
+export const CleanerOperationHistoryModal: React.FC<CleanerOperationHistoryModalProps> = ({
+  isOpen,
+  onClose,
+  user
+}) => {
+  const [batches, setBatches] = useState<CleanerHistoryBatchStats[]>([])
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const [allUsers, setAllUsers] = useState<string[]>([])
+  const [selectedUsers, setSelectedUsers] = useState<string[]>([])
+  const logger = useLogger('CleanerOperationHistory')
+
+  const isAdmin = user?.userType === 'Admin'
+
+  const fetchBatches = useCallback(async () => {
+    setLoading(true)
+    setError(null)
+    try {
+      const options =
+        isAdmin && selectedUsers.length > 0
+          ? { limit: 100, usernames: selectedUsers }
+          : { limit: 100 }
+
+      const result = await window.electron.cleaner.getHistoryBatches(options)
+      if (result.success && result.data) {
+        setBatches(result.data)
+      } else {
+        setError(result.error || '获取历史记录失败')
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : '获取历史记录失败')
+    } finally {
+      setLoading(false)
+    }
+  }, [isAdmin, selectedUsers])
+
+  const fetchAllUsers = useCallback(async () => {
+    try {
+      const result = await window.electron.auth.getAllUsers()
+      if (result.success && result.data) {
+        const usernames = result.data.map((u: UserInfo) => u.username)
+        setAllUsers(usernames)
+      }
+    } catch (err) {
+      logger.error('Failed to fetch users list', {
+        error: err instanceof Error ? err.message : String(err)
+      })
+    }
+  }, [logger])
+
+  useEffect(() => {
+    if (isOpen) {
+      void fetchBatches()
+      if (isAdmin) {
+        void fetchAllUsers()
+      }
+    }
+  }, [isOpen, fetchBatches, fetchAllUsers, isAdmin])
+
+  const handleDeleteBatch = useCallback((batchId: string) => {
+    setBatches((prev) => prev.filter((b) => b.batchId !== batchId))
+  }, [])
+
+  const toggleUserFilter = (username: string) => {
+    setSelectedUsers((prev) =>
+      prev.includes(username) ? prev.filter((u) => u !== username) : [...prev, username]
+    )
+  }
+
+  const clearUserFilters = () => {
+    setSelectedUsers([])
+  }
+
+  if (!isOpen) return null
+
+  return (
+    <Modal
+      isOpen={isOpen}
+      onClose={onClose}
+      title="清理操作历史"
+      size="3xl"
+      className="!max-w-[68rem]"
+    >
+      <div className="flex flex-col h-[70vh]">
+        {/* Toolbar */}
+        <div className="flex items-start justify-between mb-4 pb-4 border-b border-gray-200">
+          <div className="flex-1">
+            {isAdmin && allUsers.length > 0 && (
+              <div className="mb-3">
+                <div className="text-xs text-gray-500 mb-2">筛选用户：</div>
+                <div className="flex flex-wrap gap-2">
+                  {allUsers.map((username) => {
+                    const isSelected = selectedUsers.includes(username)
+                    return (
+                      <button
+                        key={username}
+                        onClick={() => toggleUserFilter(username)}
+                        className={`inline-flex items-center gap-1.5 px-3 py-1.5 rounded-full text-sm font-medium transition-all ${
+                          isSelected
+                            ? 'bg-blue-600 text-white shadow-sm'
+                            : 'bg-gray-100 text-gray-700 hover:bg-gray-200'
+                        }`}
+                      >
+                        {username}
+                      </button>
+                    )
+                  })}
+                  {selectedUsers.length > 0 && (
+                    <button
+                      onClick={clearUserFilters}
+                      className="inline-flex items-center gap-1 px-3 py-1.5 rounded-full text-sm font-medium bg-red-50 text-red-600 hover:bg-red-100 transition-all"
+                    >
+                      清空筛选
+                    </button>
+                  )}
+                </div>
+              </div>
+            )}
+            <div className="flex items-center gap-4">
+              <span className="text-sm text-gray-600">
+                {isAdmin ? (
+                  <span className="text-amber-600 font-medium">
+                    管理员模式：
+                    {selectedUsers.length > 0
+                      ? `已选择 ${selectedUsers.length} 个用户`
+                      : '显示所有用户记录'}
+                  </span>
+                ) : (
+                  <span>仅显示您的操作记录</span>
+                )}
+              </span>
+              {batches.length > 0 && (
+                <span className="text-sm text-gray-500">共 {batches.length} 条批次</span>
+              )}
+            </div>
+          </div>
+          <button
+            className="p-2 hover:bg-gray-100 rounded-lg transition-colors disabled:opacity-50 flex-shrink-0"
+            onClick={() => void fetchBatches()}
+            disabled={loading}
+            title="刷新"
+          >
+            <RefreshCw size={18} className={loading ? 'animate-spin' : ''} />
+          </button>
+        </div>
+
+        {/* Error message */}
+        {error && (
+          <div className="mb-4 p-3 bg-red-50 border border-red-200 rounded-lg text-red-700 text-sm">
+            {error}
+          </div>
+        )}
+
+        {/* Batch list */}
+        <div className="flex-1 overflow-y-auto">
+          {loading && batches.length === 0 ? (
+            <div className="flex items-center justify-center h-32 text-gray-500">加载中...</div>
+          ) : batches.length === 0 ? (
+            <div className="flex items-center justify-center h-32 text-gray-500">暂无操作记录</div>
+          ) : (
+            <div className="flex flex-col gap-3">
+              {batches.map((batch) => (
+                <BatchItem
+                  key={batch.batchId}
+                  batch={batch}
+                  isAdmin={isAdmin}
+                  onDelete={handleDeleteBatch}
+                />
+              ))}
+            </div>
+          )}
+        </div>
+
+        {/* Footer */}
+        {/* Footer */}
+        <div className="pt-4 border-t border-gray-200 flex justify-end">
+          <button
+            className="px-6 py-2 rounded-md bg-gray-100 hover:bg-gray-200 text-gray-700 font-medium transition-colors"
+            onClick={onClose}
+          >
+            关闭
+          </button>
+        </div>
+      </div>
+    </Modal>
+  )
+}
+
+export default CleanerOperationHistoryModal

src/renderer/src/components/ExecutionReportDialog.tsx

@@ -8,7 +8,7 @@
  */
 
 import React from 'react'
-import { CheckCircle, XCircle, SkipForward, Package, Loader2 } from 'lucide-react'
+import { CheckCircle, XCircle, SkipForward, Package, Loader2, AlertTriangle } from 'lucide-react'
 import { Modal } from './ui/Modal'
 import type { CleanerProgress } from '../hooks/cleaner/types'
 
@@ -27,6 +27,9 @@ interface ExecutionReportDialogProps {
   // Retry-related props
   retriedOrders?: number
   successfulRetries?: number
+  // Deletion verification props
+  materialsFailed?: number
+  uncertainDeletions?: number
 }
 
 export const ExecutionReportDialog: React.FC<ExecutionReportDialogProps> = ({
@@ -42,12 +45,15 @@ export const ExecutionReportDialog: React.FC<ExecutionReportDialogProps> = ({
   startTime = null,
   triggerRef,
   retriedOrders = 0,
-  successfulRetries = 0
+  successfulRetries = 0,
+  materialsFailed = 0,
+  uncertainDeletions = 0
 }) => {
   const [now, setNow] = React.useState(() => Date.now())
 
   const hasErrors = errors.length > 0
   const hasRetries = retriedOrders > 0
+  const hasFailedMaterials = materialsFailed > 0 || uncertainDeletions > 0
   const showProgress = isExecuting && progress
   const isProgressing = !!showProgress
 
@@ -327,6 +333,36 @@ export const ExecutionReportDialog: React.FC<ExecutionReportDialogProps> = ({
                 </div>
               </>
             )}
+
+            {hasFailedMaterials && (
+              <>
+                {materialsFailed > 0 && (
+                  <div className="bg-gray-50 rounded-lg p-3 flex items-center gap-3 border border-gray-200">
+                    <div className="w-9 h-9 rounded-lg bg-red-50 flex items-center justify-center flex-shrink-0">
+                      <XCircle size={20} className="text-red-600" />
+                    </div>
+                    <div className="flex-1 min-w-0">
+                      <div className="text-xs text-gray-600">删除失败</div>
+                      <div className="text-xl font-semibold text-red-600">{materialsFailed}</div>
+                    </div>
+                  </div>
+                )}
+
+                {uncertainDeletions > 0 && (
+                  <div className="bg-gray-50 rounded-lg p-3 flex items-center gap-3 border border-gray-200">
+                    <div className="w-9 h-9 rounded-lg bg-yellow-50 flex items-center justify-center flex-shrink-0">
+                      <AlertTriangle size={20} className="text-yellow-600" />
+                    </div>
+                    <div className="flex-1 min-w-0">
+                      <div className="text-xs text-gray-600">不确定删除</div>
+                      <div className="text-xl font-semibold text-yellow-600">
+                        {uncertainDeletions}
+                      </div>
+                    </div>
+                  </div>
+                )}
+              </>
+            )}
           </div>
 
           {elapsedTime && (

src/renderer/src/components/cleaner/CleanerToolbar.tsx

@@ -4,8 +4,8 @@ import {
   Eye,
   EyeOff,
   FileSpreadsheet,
-  FileText,
   HardDrive,
+  History,
   Search,
   Settings2,
   Square
@@ -26,7 +26,7 @@ interface CleanerToolbarProps {
   handleValidation: () => Promise<void>
   handleConfirmDeletion: () => Promise<void>
   handleExportResults: () => Promise<void>
-  setIsReportViewerOpen: (open: boolean) => void
+  setShowHistoryModal: (open: boolean) => void
   typeManagementButtonRef: React.RefObject<HTMLButtonElement | null>
 }
 
@@ -43,7 +43,7 @@ export function CleanerToolbar({
   handleValidation,
   handleConfirmDeletion,
   handleExportResults,
-  setIsReportViewerOpen,
+  setShowHistoryModal,
   typeManagementButtonRef
 }: CleanerToolbarProps): React.JSX.Element {
   return (
@@ -123,6 +123,12 @@ export function CleanerToolbar({
           >
             <Settings2 size={14} /> 类型管理
           </button>
+          <button
+            onClick={() => setShowHistoryModal(true)}
+            className="text-xs bg-violet-50 border border-violet-200 text-violet-700 px-3 py-1.5 rounded shadow-sm hover:bg-violet-100 flex items-center gap-1.5 font-medium transition-colors"
+          >
+            <History size={14} /> 操作历史
+          </button>
           <button
             onClick={() => void handleExportResults()}
             disabled={isExporting || filteredResults.length === 0}
@@ -130,12 +136,6 @@ export function CleanerToolbar({
           >
             <FileSpreadsheet size={14} /> {isExporting ? '导出中...' : '导出结果'}
           </button>
-          <button
-            onClick={() => setIsReportViewerOpen(true)}
-            className="text-xs bg-emerald-50 border border-emerald-200 text-emerald-700 px-3 py-1.5 rounded shadow-sm hover:bg-emerald-100 flex items-center gap-1.5 font-medium transition-colors"
-          >
-            <FileText size={14} /> 查看报告
-          </button>
         </div>
       </div>
     </>

src/renderer/src/components/ui/Modal.tsx

@@ -15,6 +15,8 @@ interface ModalProps {
   title?: string
   children: React.ReactNode
   size?: 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl'
+  /** Additional CSS classes for the modal panel */
+  className?: string
   showCloseButton?: boolean
   /** Ref to the element that triggered opening the modal (for focus restoration) */
   triggerRef?: React.RefObject<HTMLElement | null>
@@ -47,6 +49,7 @@ export function Modal({
   title,
   children,
   size = 'md',
+  className,
   showCloseButton = true,
   triggerRef,
   titleId,
@@ -98,7 +101,7 @@ export function Modal({
         <div className="flex min-h-full items-center justify-center p-4">
           <div
             ref={dialogRef}
-            className={`relative w-full ${sizeStyles[size]} bg-white rounded-lg shadow-xl transform transition-all`}
+            className={`relative w-full ${sizeStyles[size]} bg-white rounded-lg shadow-xl transform transition-all ${className || ''}`}
             onClick={(e) => e.stopPropagation()}
           >
             {/* Header */}

src/renderer/src/hooks/cleaner/api.ts

@@ -20,6 +20,8 @@ interface CleanerRunPayload {
   errors: string[]
   retriedOrders: number
   successfulRetries: number
+  materialsFailed?: number
+  uncertainDeletions?: number
 }
 
 export async function initializeCleanerPage(): Promise<CleanerInitializationResult> {
@@ -118,8 +120,11 @@ export async function runCleanerExecution(params: {
   headless: boolean
   queryBatchSize: number
   processConcurrency: number
+  selectedManagers: string[]
 }): Promise<CleanerReportData> {
-  const cleanerDataResult = await window.electron.validation.getCleanerData()
+  const cleanerDataResult = await window.electron.validation.getCleanerData({
+    selectedManagers: params.selectedManagers
+  })
   const cleanerData = cleanerDataResult.success
     ? (cleanerDataResult.data as CleanerDataPayload | null)
     : null
@@ -158,7 +163,9 @@ export async function runCleanerExecution(params: {
     materialsSkipped: cleanerRunData.materialsSkipped,
     errors: cleanerRunData.errors,
     retriedOrders: cleanerRunData.retriedOrders,
-    successfulRetries: cleanerRunData.successfulRetries
+    successfulRetries: cleanerRunData.successfulRetries,
+    materialsFailed: cleanerRunData.materialsFailed ?? 0,
+    uncertainDeletions: cleanerRunData.uncertainDeletions ?? 0
   }
 }
 

src/renderer/src/hooks/cleaner/types.ts

@@ -35,7 +35,7 @@ export interface CleanerProgress {
   currentMaterialIndex: number
   totalMaterialsInOrder: number
   currentOrderNumber?: string
-  phase: 'login' | 'processing' | 'complete'
+  phase: 'login' | 'processing' | 'complete' | 'retry'
 }
 
 export interface CleanerReportData {
@@ -45,6 +45,9 @@ export interface CleanerReportData {
   errors: string[]
   retriedOrders?: number
   successfulRetries?: number
+  materialsFailed?: number
+  uncertainDeletions?: number
+  crashed?: boolean
 }
 
 export interface CleanerInitializationResult {
@@ -58,3 +61,71 @@ export interface CleanerConfigResult {
   queryBatchSize: number
   processConcurrency: number
 }
+
+// Cleaner operation history types (mirrors preload/index.d.ts)
+
+export interface CleanerHistoryBatchStats {
+  batchId: string
+  userId: number
+  username: string
+  operationTime: string
+  status: string
+  totalAttempts: number
+  totalOrders: number
+  ordersProcessed: number
+  totalMaterialsDeleted: number
+  totalMaterialsFailed: number
+  successCount: number
+  failedCount: number
+  isDryRun: boolean
+}
+
+export interface CleanerHistoryExecutionRecord {
+  id?: number
+  batchId: string
+  attemptNumber: number
+  userId: number
+  username: string
+  operationTime: string
+  endTime: string | null
+  status: string
+  isDryRun: boolean
+  totalOrders: number
+  ordersProcessed: number
+  totalMaterialsDeleted: number
+  totalMaterialsSkipped: number
+  totalMaterialsFailed: number
+  totalUncertainDeletions: number
+  errorMessage: string | null
+  appVersion: string | null
+}
+
+export interface CleanerHistoryOrderRecord {
+  id?: number
+  batchId: string
+  attemptNumber: number
+  orderNumber: string
+  productionId: string | null
+  status: string
+  materialsDeleted: number
+  materialsSkipped: number
+  materialsFailed: number
+  uncertainDeletions: number
+  retryCount: number
+  retrySuccess: boolean
+  errorMessage: string | null
+}
+
+export interface CleanerHistoryMaterialRecord {
+  id?: number
+  batchId: string
+  attemptNumber: number
+  orderNumber: string
+  materialCode: string
+  materialName: string
+  rowNumber: number
+  result: string
+  reason: string | null
+  attemptCount: number
+  finalErrorCategory: string | null
+}

src/renderer/src/hooks/useCleaner.ts

@@ -376,7 +376,8 @@ export function useCleaner() {
         dryRun,
         headless,
         queryBatchSize,
-        processConcurrency
+        processConcurrency,
+        selectedManagers: Array.from(selectedManagers)
       })
       setReportData(result)
     } catch (err) {

src/renderer/src/pages/CleanerPage.tsx

@@ -10,8 +10,9 @@ const MaterialTypeManagementDialog = React.lazy(
   () => import('../components/MaterialTypeManagementDialog')
 )
 const ExecutionReportDialog = React.lazy(() => import('../components/ExecutionReportDialog'))
-const ReportViewerDialog = React.lazy(() => import('../components/ReportViewerDialog'))
+const CleanerOperationHistoryModal = React.lazy(
-const ReportAnalysisDialog = React.lazy(() => import('../components/ReportAnalysisDialog'))
+  () => import('../components/CleanerOperationHistoryModal')
+)
 
 const CleanerPage: React.FC = () => {
   const typeManagementButtonRef = React.useRef<HTMLButtonElement>(null)
@@ -66,8 +67,7 @@ const CleanerPage: React.FC = () => {
     confirmDialog
   } = useCleaner()
 
-  const [isReportViewerOpen, setIsReportViewerOpen] = React.useState(false)
+  const [showHistoryModal, setShowHistoryModal] = React.useState(false)
-  const [isReportAnalysisOpen, setIsReportAnalysisOpen] = React.useState(false)
 
   return (
     <div className="h-full flex flex-col xl:flex-row gap-6 animate-in fade-in slide-in-from-bottom-4 duration-500">
@@ -96,7 +96,7 @@ const CleanerPage: React.FC = () => {
           handleValidation={handleValidation}
           handleConfirmDeletion={handleConfirmDeletion}
           handleExportResults={handleExportResults}
-          setIsReportViewerOpen={setIsReportViewerOpen}
+          setShowHistoryModal={setShowHistoryModal}
           typeManagementButtonRef={typeManagementButtonRef}
         />
 
@@ -162,24 +162,20 @@ const CleanerPage: React.FC = () => {
           triggerRef={executeButtonRef}
           retriedOrders={reportData?.retriedOrders}
           successfulRetries={reportData?.successfulRetries}
+          materialsFailed={reportData?.materialsFailed}
+          uncertainDeletions={reportData?.uncertainDeletions}
         />
       </Suspense>
 
       <Suspense fallback={null}>
-        <ReportViewerDialog
+        <CleanerOperationHistoryModal
-          isOpen={isReportViewerOpen}
+          isOpen={showHistoryModal}
-          onClose={() => setIsReportViewerOpen(false)}
+          onClose={() => setShowHistoryModal(false)}
-          isAdmin={isAdmin}
+          user={
-          currentUsername={currentUsername}
+            currentUsername
-          onOpenAnalysis={() => setIsReportAnalysisOpen(true)}
+              ? { username: currentUsername, userType: isAdmin ? 'Admin' : 'User' }
-        />
+              : null
-      </Suspense>
+          }
-
-      <Suspense fallback={null}>
-        <ReportAnalysisDialog
-          isOpen={isReportAnalysisOpen}
-          onClose={() => setIsReportAnalysisOpen(false)}
-          isAdmin={isAdmin}
         />
       </Suspense>
 

src/shared/ipc-channels.ts

@@ -21,6 +21,12 @@ export const IPC_CHANNELS = {
   CLEANER_EXPORT_RESULTS: 'cleaner:exportResults',
   CLEANER_PROGRESS: 'cleaner:progress',
 
+  // Cleaner operation history
+  CLEANER_HISTORY_GET_BATCHES: 'cleanerHistory:getBatches',
+  CLEANER_HISTORY_GET_BATCH_DETAILS: 'cleanerHistory:getBatchDetails',
+  CLEANER_HISTORY_GET_MATERIAL_DETAILS: 'cleanerHistory:getMaterialDetails',
+  CLEANER_HISTORY_DELETE_BATCH: 'cleanerHistory:deleteBatch',
+
   // Database service - MySQL
   DATABASE_MYSQL_CONNECT: 'database:mysql:connect',
   DATABASE_MYSQL_DISCONNECT: 'database:mysql:disconnect',

tests/e2e/auth-flow.test.ts

@@ -85,8 +85,10 @@ test.describe('Authentication Flow', () => {
       const errorMessage = page.locator('.error, [role="alert"], .text-red')
       const hasError = await errorMessage.count()
 
-      // Either error shown or still on login page
+      // Verify login was rejected: either error shown or still on login page
-      expect(hasError >= 0).toBe(true)
+      const loginDialog = page.locator('[data-testid="login-dialog"]')
+      const isStillOnLoginPage = await loginDialog.isVisible().catch(() => false)
+      expect(hasError > 0 || isStillOnLoginPage).toBe(true)
     }
   })
 })

tests/e2e/extractor-workflow.test.ts

@@ -5,45 +5,39 @@
  * Run: npx playwright test tests/e2e/extractor-workflow.test.ts
  */
 
-import { _electron as electron } from '@playwright/test'
+import { test, expect, type ElectronApplication, type Page } from '@playwright/test'
-import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import { _electron as electron } from 'playwright'
-import type { ElectronApplication, Page, BrowserWindow } from 'playwright'
 import { join } from 'path'
 
-describe('Extractor E2E Workflow', () => {
+let electronApp: ElectronApplication
-  let electronApp: ElectronApplication
+let page: Page
-  let window: BrowserWindow
-  let page: Page
-
-  beforeAll(async () => {
-    // Build the app first (if not already built)
-    // npm run build
 
+test.describe('Extractor E2E Workflow', () => {
+  test.beforeAll(async () => {
     // Launch Electron app for testing
     electronApp = await electron.launch({
       args: [join(process.cwd(), 'out/main/index.js')]
     })
 
     // Get the main window
-    window = await electronApp.firstWindow()
     page = await electronApp.firstWindow()
 
     // Wait for app to load
     await page.waitForLoadState('domcontentloaded')
-  }, 60000)
+  })
 
-  afterAll(async () => {
+  test.afterAll(async () => {
     if (electronApp) {
       await electronApp.close()
     }
-  }, 60000)
+  })
 
-  it('should launch the application', async () => {
+  test('should launch the application', async () => {
     const title = await page.title()
     expect(title).toBeDefined()
   })
 
-  it('should navigate to Extractor page', async () => {
+  test('should navigate to Extractor page', async () => {
     // Click on the "数据提取" link
     await page.click('a:has-text("数据提取")')
 
@@ -55,7 +49,7 @@ describe('Extractor E2E Workflow', () => {
     expect(pageTitle).toContain('ERP 数据提取')
   })
 
-  it('should display order number input', async () => {
+  test('should display order number input', async () => {
     // Check if order number textarea is visible
     const textarea = page.locator('.order-textarea')
     await expect(textarea).toBeVisible()
@@ -65,7 +59,7 @@ describe('Extractor E2E Workflow', () => {
     expect(placeholder).toContain('订单号')
   })
 
-  it('should update order count when typing', async () => {
+  test('should update order count when typing', async () => {
     // Fill in order numbers
     const textarea = page.locator('.order-textarea')
     await textarea.fill('SC70202602120085\nSC70202602120120')
@@ -79,7 +73,7 @@ describe('Extractor E2E Workflow', () => {
     expect(countText).toContain('2')
   })
 
-  it('should show error when extracting without order numbers', async () => {
+  test('should show error when extracting without order numbers', async () => {
     // Clear the textarea
     const textarea = page.locator('.order-textarea')
     await textarea.fill('')
@@ -90,7 +84,7 @@ describe('Extractor E2E Workflow', () => {
     expect(isDisabled).toBe(true)
   })
 
-  it('should have batch size input', async () => {
+  test('should have batch size input', async () => {
     const batchSizeInput = page.locator('input[type="number"]')
     await expect(batchSizeInput).toBeVisible()
 
@@ -98,7 +92,7 @@ describe('Extractor E2E Workflow', () => {
     expect(value).toBe('100')
   })
 
-  it('should have reset button', async () => {
+  test('should have reset button', async () => {
     const resetButton = page.locator('.btn-secondary:has-text("重置")')
     await expect(resetButton).toBeVisible()
 
@@ -111,7 +105,7 @@ describe('Extractor E2E Workflow', () => {
     expect(value).toBe('')
   })
 
-  it('should navigate back to home', async () => {
+  test('should navigate back to home', async () => {
     // Click back button
     await page.click('.nav-btn:has-text("返回主页")')
 

tests/fixtures/factory.ts

@@ -73,10 +73,12 @@ export class UserFactory {
   /**
    * Generate unique user ID
    *
-   * @returns Unique ID string in format USR-{timestamp}-{random}
+   * @returns Unique numeric ID
    */
-  private static generateId(): string {
+  private static idCounter = 0
-    return `USR-${Date.now()}-${Math.random().toString(36).substr(2, 6)}`
+
+  private static generateId(): number {
+    return ++UserFactory.idCounter
   }
 
   /**
@@ -417,11 +419,11 @@ export class AuditLogFactory {
    *
    * @example
    * // Successful login audit
-   * const entry = AuditLogFactory.createAuditLog('LOGIN', 'SUCCESS')
+   * const entry = AuditLogFactory.createAuditLog(AuditAction.LOGIN, AuditStatus.SUCCESS)
    *
    * @example
    * // Failed extract audit
-   * const entry = AuditLogFactory.createAuditLog('EXTRACT', 'FAILURE', { resource: 'Order SC123' })
+   * const entry = AuditLogFactory.createAuditLog(AuditAction.EXTRACT, AuditStatus.FAILURE, { resource: 'Order SC123' })
    */
   static createAuditLog(
     action: AuditAction = AuditAction.LOGIN,
@@ -429,13 +431,15 @@ export class AuditLogFactory {
     overrides?: Partial<AuditEntry>
   ): AuditEntry {
     return {
-      timestamp: new Date(),
+      timestamp: new Date().toISOString(),
       action,
       userId: 'USR-001',
       username: 'test_user',
       computerName: 'TEST-PC',
       appVersion: '1.0.0',
+      resource: 'test-resource',
       status,
+      metadata: {},
       ...overrides
     }
   }

tests/fixtures/other-factories.test.ts

@@ -91,7 +91,7 @@ describe('AuditLogFactory', () => {
   it('creates audit log with default values', () => {
     const entry = AuditLogFactory.createAuditLog()
 
-    expect(entry.timestamp).toBeInstanceOf(Date)
+    expect(typeof entry.timestamp).toBe('string')
     expect(entry.action).toBe(AuditAction.LOGIN)
     expect(entry.status).toBe(AuditStatus.SUCCESS)
     expect(entry.userId).toBe('USR-001')

tests/fixtures/types.ts

@@ -88,8 +88,8 @@ export interface Order {
  * Simplified user data for creating test users.
  */
 export interface TestUser {
-  /** User ID */
+  /** User ID (matches UserInfo.id: number) */
-  id: string
+  id: number
   /** Username for login */
   username: string
   /** User type/role */

tests/fixtures/user-factory.test.ts

@@ -2,17 +2,22 @@
  * UserFactory Unit Tests
  */
 
-import { describe, it, expect } from 'vitest'
+import { describe, it, expect, beforeEach } from 'vitest'
 import { UserFactory } from './factory'
 
 describe('UserFactory', () => {
+  beforeEach(() => {
+    // Reset ID counter to ensure test isolation
+    ;(UserFactory as any).idCounter = 0
+  })
+
   it('creates user with default role', () => {
     const user = UserFactory.createUser()
 
     expect(user.username).toMatch(/^test_user_\d+$/)
     expect(user.userType).toBe('User')
     expect(user.permissions).toEqual(['read', 'write'])
-    expect(user.id).toMatch(/^USR-\d+-[a-z0-9]+$/)
+    expect(user.id).toBeTypeOf('number')
   })
 
   it('creates admin with correct permissions', () => {
@@ -20,7 +25,7 @@ describe('UserFactory', () => {
 
     expect(admin.userType).toBe('Admin')
     expect(admin.permissions).toEqual(['read', 'write', 'delete', 'admin'])
-    expect(admin.id).toMatch(/^USR-\d+-[a-z0-9]+$/)
+    expect(admin.id).toBeTypeOf('number')
   })
 
   it('generates unique IDs', () => {

tests/unit/audit-logger.test.ts

@@ -8,6 +8,7 @@
  */
 
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { AuditAction, AuditStatus } from '../../src/main/types/audit.types'
 
 describe('Audit Logger', () => {
   let auditLoggerModule: typeof import('../../src/main/services/logger/audit-logger')
@@ -32,11 +33,11 @@ describe('Audit Logger', () => {
     const { logAudit, applyAuditConfig } = auditLoggerModule
 
     applyAuditConfig(30)
-    logAudit('LOGIN', 'user-001', {
+    logAudit(AuditAction.LOGIN, 'user-001', {
       username: 'alice',
       computerName: 'PC-001',
       resource: 'ERP_SYSTEM',
-      status: 'success',
+      status: AuditStatus.SUCCESS,
       metadata: { sessionId: 'abc' }
     })
 
@@ -60,26 +61,26 @@ describe('Audit Logger', () => {
 
     applyAuditConfig(30)
 
-    logAudit('EXTRACT', 'user1', {
+    logAudit(AuditAction.EXTRACT, 'user1', {
       username: 'extractor',
       computerName: 'PC-001',
       resource: 'materials',
-      status: 'success'
+      status: AuditStatus.SUCCESS
     })
 
-    logAudit('DELETE', 'user2', {
+    logAudit(AuditAction.CLEAN, 'user2', {
       username: 'cleaner',
       computerName: 'PC-002',
       resource: 'temp_files',
-      status: 'failure',
+      status: AuditStatus.FAILURE,
       metadata: { error: 'Permission denied' }
     })
 
-    logAudit('UPDATE', 'user3', {
+    logAudit(AuditAction.APP_UPDATE, 'user3', {
       username: 'updater',
       computerName: 'PC-003',
       resource: 'config',
-      status: 'partial',
+      status: AuditStatus.PARTIAL,
       metadata: { updated: 5, failed: 2 }
     })
 
@@ -95,11 +96,11 @@ describe('Audit Logger', () => {
 
     applyAuditConfig(30)
 
-    logAudit('PING', 'user-no-meta', {
+    logAudit(AuditAction.SYSTEM_ERROR, 'user-no-meta', {
       username: 'tester',
       computerName: 'PC-001',
       resource: 'ERP',
-      status: 'success'
+      status: AuditStatus.SUCCESS
     })
 
     const entry = JSON.parse(infoSpy.mock.calls[0][0])
@@ -111,11 +112,11 @@ describe('Audit Logger', () => {
 
     applyAuditConfig(30)
 
-    logAudit('LOGIN_ATTEMPT', 'user-special', {
+    logAudit(AuditAction.LOGIN, 'user-special', {
       username: 'user.name+test@example.com',
       computerName: 'DESKTOP-特殊字符-001',
       resource: 'ERP/子系统',
-      status: 'failure',
+      status: AuditStatus.FAILURE,
       metadata: { reason: '密码错误', attempt: 3 }
     })
 

tests/unit/cleaner-handler.test.ts

@@ -8,11 +8,23 @@ const withErrorHandlingMock = vi.fn(async (handler: () => Promise<unknown>) => {
 })
 
 const serviceMethods = {
-  runCleaner: vi.fn(async (_sender: unknown, input: unknown) => ({ success: true, input })),
+  runCleaner: vi.fn(
+    async (
+      _sender: unknown,
+      input: unknown,
+      _batchId: string,
+      _historyDao: unknown,
+      _appVersion: string
+    ) => ({ success: true, input })
+  ),
   exportResults: vi.fn(async (items: unknown[]) => ({ success: true, total: items.length }))
 }
 
 vi.mock('electron', () => ({
+  app: {
+    isPackaged: false,
+    getVersion: () => 'test-version'
+  },
   ipcMain: {
     handle: handleMock
   }
@@ -51,7 +63,14 @@ describe('registerCleanerHandlers', () => {
 
     const result = await runHandler?.(event, input)
 
-    expect(serviceMethods.runCleaner).toHaveBeenCalledWith(sender, input)
+    expect(serviceMethods.runCleaner).toHaveBeenCalledTimes(1)
+    const actualCall = serviceMethods.runCleaner.mock.calls[0]
+    expect(actualCall[0]).toBe(sender)
+    expect(actualCall[1]).toEqual(input)
+    expect(typeof actualCall[2]).toBe('string') // batchId is UUID
+    expect(actualCall[3]).toBeDefined() // historyDao
+    expect(actualCall[4]).toBe('test-version') // appVersion
+
     expect(result).toEqual({
       success: true,
       data: { success: true, input }

tests/unit/cleaner.test.ts

@@ -1,145 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import {
-  CleanerService,
-  createBatches,
-  getMissingOrders,
-  runWithConcurrency
-} from '../../src/main/services/erp/cleaner'
-
-describe('Cleaner Service (Unit)', () => {
-  describe('shouldDeleteMaterial', () => {
-    // CleanerService constructor requires ErpAuthService, but shouldDeleteMaterial doesn't use it
-    const cleaner = new CleanerService({} as any)
-
-    it('should skip materials with row number 2000-7999', () => {
-      const testCases = [
-        { rowNumber: 2000, pendingQty: '', materialCode: 'TEST001', expected: false },
-        { rowNumber: 5000, pendingQty: '', materialCode: 'TEST001', expected: false },
-        { rowNumber: 7999, pendingQty: '', materialCode: 'TEST001', expected: false },
-        { rowNumber: 1999, pendingQty: '', materialCode: 'TEST001', expected: true },
-        { rowNumber: 8000, pendingQty: '', materialCode: 'TEST001', expected: true }
-      ]
-
-      for (const tc of testCases) {
-        const shouldDelete = cleaner.shouldDeleteMaterial({
-          rowNumber: tc.rowNumber,
-          pendingQty: tc.pendingQty,
-          materialCode: tc.materialCode,
-          deleteSet: new Set(['TEST001'])
-        })
-        expect(shouldDelete).toBe(tc.expected)
-      }
-    })
-
-    it('should skip materials with non-empty pending quantity', () => {
-      const result = cleaner.shouldDeleteMaterial({
-        rowNumber: 100,
-        pendingQty: '5',
-        materialCode: 'TEST001',
-        deleteSet: new Set(['TEST001'])
-      })
-
-      expect(result).toBe(false)
-    })
-
-    it('should skip materials not in delete list', () => {
-      const result = cleaner.shouldDeleteMaterial({
-        rowNumber: 100,
-        pendingQty: '',
-        materialCode: 'NOT_IN_LIST',
-        deleteSet: new Set(['TEST001'])
-      })
-
-      expect(result).toBe(false)
-    })
-
-    it('should delete materials with empty pending qty and valid row number', () => {
-      const testCases = [
-        { rowNumber: 1, pendingQty: '', materialCode: 'TEST001', expected: true },
-        { rowNumber: 100, pendingQty: '', materialCode: 'TEST001', expected: true },
-        { rowNumber: 1999, pendingQty: '', materialCode: 'TEST001', expected: true },
-        { rowNumber: 8000, pendingQty: '', materialCode: 'TEST001', expected: true },
-        { rowNumber: 10000, pendingQty: '', materialCode: 'TEST001', expected: true }
-      ]
-
-      for (const tc of testCases) {
-        const shouldDelete = cleaner.shouldDeleteMaterial({
-          rowNumber: tc.rowNumber,
-          pendingQty: tc.pendingQty,
-          materialCode: tc.materialCode,
-          deleteSet: new Set(['TEST001'])
-        })
-        expect(shouldDelete).toBe(tc.expected)
-      }
-    })
-
-    it('should handle multiple conditions correctly', () => {
-      // Material in list, valid row, no pending qty = should delete
-      expect(
-        cleaner.shouldDeleteMaterial({
-          rowNumber: 100,
-          pendingQty: '',
-          materialCode: 'TEST001',
-          deleteSet: new Set(['TEST001'])
-        })
-      ).toBe(true)
-
-      // Material in list, protected row, no pending qty = should NOT delete
-      expect(
-        cleaner.shouldDeleteMaterial({
-          rowNumber: 7500,
-          pendingQty: '',
-          materialCode: 'TEST001',
-          deleteSet: new Set(['TEST001'])
-        })
-      ).toBe(false)
-
-      // Material in list, valid row, has pending qty = should NOT delete
-      expect(
-        cleaner.shouldDeleteMaterial({
-          rowNumber: 100,
-          pendingQty: '10',
-          materialCode: 'TEST001',
-          deleteSet: new Set(['TEST001'])
-        })
-      ).toBe(false)
-
-      // Material NOT in list = should NOT delete
-      expect(
-        cleaner.shouldDeleteMaterial({
-          rowNumber: 100,
-          pendingQty: '',
-          materialCode: 'OTHER',
-          deleteSet: new Set(['TEST001'])
-        })
-      ).toBe(false)
-    })
-  })
-
-  describe('batch and concurrency helpers', () => {
-    it('should split orders into batches', () => {
-      const batches = createBatches(['A', 'B', 'C', 'D', 'E'], 2)
-      expect(batches).toEqual([['A', 'B'], ['C', 'D'], ['E']])
-    })
-
-    it('should identify missing orders', () => {
-      const missing = getMissingOrders(['SC1', 'SC2', 'SC3'], new Set(['SC1', 'SC3']))
-      expect(missing).toEqual(['SC2'])
-    })
-
-    it('should respect concurrency limit', async () => {
-      const items = [1, 2, 3, 4, 5, 6]
-      let running = 0
-      let peak = 0
-      await runWithConcurrency(items, 2, async () => {
-        running += 1
-        peak = Math.max(peak, running)
-        await new Promise((resolve) => setTimeout(resolve, 10))
-        running -= 1
-        return true
-      })
-
-      expect(peak).toBeLessThanOrEqual(2)
-    })
-  })
-})

tests/unit/dialects/mysql-dialect.test.ts

@@ -46,8 +46,8 @@ describe('MySqlDialect', () => {
   })
 
   describe('currentTimestamp', () => {
-    it('should return NOW()', () => {
+    it('should return UTC_TIMESTAMP()', () => {
-      expect(dialect.currentTimestamp()).toBe('NOW()')
+      expect(dialect.currentTimestamp()).toBe('UTC_TIMESTAMP()')
     })
   })
 

tests/unit/dialects/sqlserver-dialect.test.ts

@@ -45,8 +45,8 @@ describe('SqlServerDialect', () => {
   })
 
   describe('currentTimestamp', () => {
-    it('should return GETDATE()', () => {
+    it('should return SYSUTCDATETIME()', () => {
-      expect(dialect.currentTimestamp()).toBe('GETDATE()')
+      expect(dialect.currentTimestamp()).toBe('SYSUTCDATETIME()')
     })
   })
 

tests/unit/erp-auth.unit.test.ts

@@ -1,28 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { ErpAuthService } from '../../src/main/services/erp/erp-auth'
-import type { ErpConfig } from '../../src/main/types/erp.types'
-
-const testConfig: ErpConfig = {
-  url: 'https://test.example.com',
-  username: 'testuser',
-  password: 'testpass'
-}
-
-describe('ERP Authentication Service (Unit)', () => {
-  describe('Initial State', () => {
-    it('should report inactive status before login', () => {
-      const service = new ErpAuthService(testConfig)
-      expect(service.isActive()).toBe(false)
-    })
-
-    it('should throw error when getting session before login', () => {
-      const service = new ErpAuthService(testConfig)
-      expect(() => service.getSession()).toThrow('Not logged in. Call login() first.')
-    })
-
-    it('should handle close when no session exists', async () => {
-      const service = new ErpAuthService(testConfig)
-      await expect(service.close()).resolves.toBeUndefined()
-    })
-  })
-})

tests/unit/extractor.test.ts

@@ -1,70 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest'
-import { ExtractorService } from '../../src/main/services/erp/extractor'
-import { ErpAuthService } from '../../src/main/services/erp/erp-auth'
-import type { ErpConfig } from '../../src/main/types/erp.types'
-
-describe('Extractor Service (Unit)', () => {
-  let authService: ErpAuthService
-  let extractor: ExtractorService
-  const mockConfig: ErpConfig = {
-    url: 'https://test.erp.com',
-    username: 'test_user',
-    password: 'test_pass'
-  }
-
-  beforeEach(() => {
-    authService = new ErpAuthService(mockConfig)
-    extractor = new ExtractorService(authService, './test-downloads')
-  })
-
-  describe('Service Initialization', () => {
-    it('should create service instance as ExtractorService', () => {
-      expect(extractor).toBeInstanceOf(ExtractorService)
-    })
-
-    it('should create service with default download directory', () => {
-      const defaultExtractor = new ExtractorService(authService)
-      expect(defaultExtractor).toBeInstanceOf(ExtractorService)
-    })
-
-    it('should create service with custom download directory', () => {
-      const customExtractor = new ExtractorService(authService, './custom-downloads')
-      expect(customExtractor).toBeInstanceOf(ExtractorService)
-    })
-  })
-
-  describe('Error Handling', () => {
-    it('should handle extraction with no auth session', async () => {
-      const result = await extractor.extract({
-        orderNumbers: ['ORDER1']
-      })
-
-      expect(result.errors.length).toBeGreaterThan(0)
-      expect(result.downloadedFiles).toHaveLength(0)
-    })
-
-    it('should include error message when session is missing', async () => {
-      const result = await extractor.extract({
-        orderNumbers: ['ORD-001', 'ORD-002']
-      })
-
-      expect(result.errors).toEqual(
-        expect.arrayContaining([expect.stringContaining('Not logged in')])
-      )
-    })
-
-    it('should return empty result structure even on failure', async () => {
-      const result = await extractor.extract({
-        orderNumbers: ['ORDER1']
-      })
-
-      expect(result).toHaveProperty('downloadedFiles')
-      expect(result).toHaveProperty('mergedFile')
-      expect(result).toHaveProperty('recordCount')
-      expect(result).toHaveProperty('errors')
-      expect(result).toHaveProperty('orderRecordCounts')
-      expect(result.mergedFile).toBeNull()
-      expect(result.recordCount).toBe(0)
-    })
-  })
-})

tests/unit/ipc/cleaner-handler.test.ts

@@ -0,0 +1,195 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { IPC_CHANNELS } from '../../../src/shared/ipc-channels'
+
+// Mock logger to prevent real winston initialization and console noise
+vi.mock('../../../src/main/services/logger', () => ({
+  createLogger: () => ({
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn()
+  }),
+  logError: vi.fn()
+}))
+
+vi.mock('../../../src/main/services/logger/error-utils', () => ({
+  serializeError: (err: any) => err,
+  sanitizeError: (err: any) => err
+}))
+
+// In-memory storage for registered IPC handlers
+const registeredHandlers: Map<string, (...args: any[]) => any> = new Map()
+
+// Mock Electron's ipcMain to capture registered handlers
+vi.mock('electron', () => {
+  return {
+    app: {
+      isPackaged: false,
+      getVersion: () => '1.0.0-test'
+    },
+    ipcMain: {
+      handle: (channel: string, listener: any) => {
+        registeredHandlers.set(channel, listener)
+      }
+    }
+  }
+})
+
+// Mock CleanerApplicationService to isolate IPC layer
+vi.doMock('../../../src/main/services/cleaner/cleaner-application-service', () => {
+  return {
+    CleanerApplicationService: class {
+      async runCleaner(_eventSender: any, input: any) {
+        const count = input?.orderNumbers?.length ?? 0
+        return {
+          ordersProcessed: count,
+          materialsDeleted: count,
+          materialsSkipped: 0,
+          errors: [],
+          details: [],
+          retriedOrders: 0,
+          successfulRetries: 0
+        } as any
+      }
+      async exportResults(_input: any) {
+        return { success: true, filePath: '/tmp/results.txt' } as any
+      }
+    }
+  }
+})
+
+// Load IPC handler module after mocks are in place
+describe('Cleaner IPC Handler', () => {
+  beforeEach(() => {
+    registeredHandlers.clear()
+  })
+
+  it('should register and handle cleaner:execute (CLEANER_RUN) IPC call', async () => {
+    const mod = await import('../../../src/main/ipc/cleaner-handler')
+    mod.registerCleanerHandlers()
+
+    const handler = registeredHandlers.get(IPC_CHANNELS.CLEANER_RUN)
+    expect(handler).toBeDefined()
+    expect(typeof handler).toBe('function')
+
+    const event: any = { sender: { id: 'renderer-1' } }
+    const input: any = {
+      orderNumbers: ['SC1', 'SC2'],
+      materialCodes: [],
+      dryRun: false,
+      queryBatchSize: 100,
+      processConcurrency: 1,
+      onProgress: vi.fn()
+    }
+
+    const result = await (handler as any)(event, input)
+    expect(result.success).toBe(true)
+    expect(result.data.ordersProcessed).toBe(2)
+  })
+
+  it('should handle cleaner:run with dryRun true', async () => {
+    const mod = await import('../../../src/main/ipc/cleaner-handler')
+    mod.registerCleanerHandlers()
+
+    const handler = registeredHandlers.get(IPC_CHANNELS.CLEANER_RUN)
+    expect(handler).toBeDefined()
+
+    const event: any = { sender: { id: 'renderer-2' } }
+    const input: any = {
+      orderNumbers: ['SC1'],
+      materialCodes: [],
+      dryRun: true,
+      queryBatchSize: 50,
+      processConcurrency: 1,
+      onProgress: vi.fn()
+    }
+    const result = await (handler as any)(event, input)
+    expect(result.success).toBe(true)
+    expect(result.data.ordersProcessed).toBe(1)
+  })
+
+  it('should return { success: false } when runCleaner throws', async () => {
+    vi.resetModules()
+    vi.doMock('../../../src/main/services/cleaner/cleaner-application-service', () => {
+      return {
+        CleanerApplicationService: class {
+          async runCleaner() {
+            throw new Error('boom')
+          }
+        }
+      }
+    })
+    const mod = await import('../../../src/main/ipc/cleaner-handler')
+    mod.registerCleanerHandlers()
+
+    const handler = registeredHandlers.get(IPC_CHANNELS.CLEANER_RUN)
+    expect(handler).toBeDefined()
+
+    const event: any = { sender: { id: 'renderer-3' } }
+    const input: any = {
+      orderNumbers: ['SC1'],
+      materialCodes: [],
+      dryRun: false,
+      queryBatchSize: 20,
+      processConcurrency: 1,
+      onProgress: vi.fn()
+    }
+    const result = await (handler as any)(event, input)
+    expect(result.success).toBe(false)
+    expect(result.error).toBe('boom')
+  })
+
+  it('should register and handle cleaner:exportResults (CLEANER_EXPORT_RESULTS) IPC call', async () => {
+    vi.resetModules()
+    vi.doMock('../../../src/main/services/cleaner/cleaner-application-service', () => {
+      return {
+        CleanerApplicationService: class {
+          async exportResults(items: any[]) {
+            return {
+              success: true,
+              filePath: '/tmp/exported.xlsx',
+              recordCount: items.length
+            } as any
+          }
+        }
+      }
+    })
+    const mod = await import('../../../src/main/ipc/cleaner-handler')
+    mod.registerCleanerHandlers()
+
+    const handler = registeredHandlers.get(IPC_CHANNELS.CLEANER_EXPORT_RESULTS)
+    expect(handler).toBeDefined()
+    expect(typeof handler).toBe('function')
+
+    const event: any = { sender: { id: 'renderer-4' } }
+    const items = [
+      { materialCode: 'M1', materialName: 'Mat A' },
+      { materialCode: 'M2', materialName: 'Mat B' }
+    ]
+
+    const result = await (handler as any)(event, items)
+    expect(result.success).toBe(true)
+    expect(result.data.recordCount).toBe(2)
+  })
+
+  it('should return { success: false } when exportResults throws', async () => {
+    vi.resetModules()
+    vi.doMock('../../../src/main/services/cleaner/cleaner-application-service', () => {
+      return {
+        CleanerApplicationService: class {
+          async exportResults() {
+            throw new Error('export failed')
+          }
+        }
+      }
+    })
+    const mod = await import('../../../src/main/ipc/cleaner-handler')
+    mod.registerCleanerHandlers()
+
+    const handler = registeredHandlers.get(IPC_CHANNELS.CLEANER_EXPORT_RESULTS)
+    const event: any = { sender: { id: 'renderer-5' } }
+    const result = await (handler as any)(event, [])
+    expect(result.success).toBe(false)
+    expect(result.error).toBe('export failed')
+  })
+})

tests/unit/mysql.test.ts

@@ -1,11 +1,51 @@
 /**
  * Unit tests for MySqlService
- * These tests do not require a MySQL instance
+ * Covers both unconnected state and connected-path operations using mocked mysql2/promise.
  */
 
-import { describe, it, expect, beforeEach } from 'vitest'
+import { describe, it, expect, beforeEach, vi } from 'vitest'
 import { MySqlService } from '@services/database/mysql'
 
+// ---- Hoisted mock functions ----
+const {
+  mockCreateConnection,
+  mockPing,
+  mockExecute,
+  mockBeginTransaction,
+  mockCommit,
+  mockRollback,
+  mockEnd
+} = vi.hoisted(() => ({
+  mockCreateConnection: vi.fn(),
+  mockPing: vi.fn(),
+  mockExecute: vi.fn(),
+  mockBeginTransaction: vi.fn(),
+  mockCommit: vi.fn(),
+  mockRollback: vi.fn(),
+  mockEnd: vi.fn()
+}))
+
+// Mock mysql2/promise driver
+vi.mock('mysql2/promise', () => ({
+  default: {
+    createConnection: mockCreateConnection
+  }
+}))
+
+// Mock logger
+vi.mock('@services/logger', () => ({
+  createLogger: () => ({
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn()
+  }),
+  trackDuration: async <T>(fn: () => Promise<T>) => {
+    const result = await fn()
+    return { result }
+  }
+}))
+
 const mockConfig = {
   host: 'localhost',
   port: 3306,
@@ -14,11 +54,30 @@ const mockConfig = {
   database: 'testdb'
 }
 
+function createMockConnection() {
+  return {
+    ping: mockPing,
+    execute: mockExecute,
+    beginTransaction: mockBeginTransaction,
+    commit: mockCommit,
+    rollback: mockRollback,
+    end: mockEnd
+  }
+}
+
 describe('MySqlService Unit Tests', () => {
   let service: MySqlService
 
   beforeEach(() => {
+    vi.clearAllMocks()
     service = new MySqlService(mockConfig)
+    mockCreateConnection.mockResolvedValue(createMockConnection())
+    mockPing.mockResolvedValue(undefined)
+    mockExecute.mockResolvedValue([[], []])
+    mockBeginTransaction.mockResolvedValue(undefined)
+    mockCommit.mockResolvedValue(undefined)
+    mockRollback.mockResolvedValue(undefined)
+    mockEnd.mockResolvedValue(undefined)
   })
 
   describe('constructor', () => {
@@ -35,15 +94,33 @@ describe('MySqlService Unit Tests', () => {
   })
 
   describe('connect', () => {
-    it('should throw error with invalid credentials', async () => {
+    it('should throw error when connection fails', async () => {
-      // This tests error handling without needing a real server
+      mockCreateConnection.mockRejectedValue(new Error('connect ECONNREFUSED'))
-      const invalidConfig = {
+      await expect(service.connect()).rejects.toThrow('Failed to connect to MySQL')
-        ...mockConfig,
+    })
-        host: 'invalid-host-that-does-not-exist'
-      }
-      const invalidService = new MySqlService(invalidConfig)
 
-      await expect(invalidService.connect()).rejects.toThrow('Failed to connect to MySQL')
+    it('should establish connection and ping server', async () => {
+      await service.connect()
+      expect(mockCreateConnection).toHaveBeenCalledWith({
+        host: 'localhost',
+        port: 3306,
+        user: 'test',
+        password: 'test',
+        database: 'testdb'
+      })
+      expect(mockPing).toHaveBeenCalled()
+      expect(service.isConnected()).toBe(true)
+    })
+
+    it('should throw when already connected', async () => {
+      await service.connect()
+      await expect(service.connect()).rejects.toThrow('Already connected to MySQL')
+    })
+
+    it('should throw when ping fails after connection created', async () => {
+      mockPing.mockRejectedValue(new Error('ping failed'))
+      await expect(service.connect()).rejects.toThrow('Failed to connect to MySQL')
+      // Note: source sets connection before ping, so it remains non-null after ping failure
     })
   })
 
@@ -51,6 +128,54 @@ describe('MySqlService Unit Tests', () => {
     it('should throw error when not connected', async () => {
       await expect(service.query('SELECT 1')).rejects.toThrow('Not connected to MySQL')
     })
+
+    it('should execute SELECT and return rows with columns', async () => {
+      await service.connect()
+      mockExecute.mockResolvedValue([
+        [
+          { id: 1, name: 'test' },
+          { id: 2, name: 'foo' }
+        ],
+        [{ name: 'id' }, { name: 'name' }]
+      ])
+
+      const result = await service.query('SELECT id, name FROM users')
+
+      expect(mockExecute).toHaveBeenCalledWith('SELECT id, name FROM users', undefined)
+      expect(result.rows).toEqual([
+        { id: 1, name: 'test' },
+        { id: 2, name: 'foo' }
+      ])
+      expect(result.columns).toEqual(['id', 'name'])
+      expect(result.rowCount).toBe(2)
+    })
+
+    it('should execute INSERT/UPDATE and return affected rows', async () => {
+      await service.connect()
+      mockExecute.mockResolvedValue([{ affectedRows: 3, changedRows: 2 }, []])
+
+      const result = await service.query('UPDATE users SET active = ?', [true])
+
+      expect(mockExecute).toHaveBeenCalledWith('UPDATE users SET active = ?', [true])
+      expect(result.rows).toEqual([])
+      expect(result.rowCount).toBe(3)
+    })
+
+    it('should use changedRows when affectedRows is zero', async () => {
+      await service.connect()
+      mockExecute.mockResolvedValue([{ affectedRows: 0, changedRows: 5 }, []])
+
+      const result = await service.query('UPDATE users SET x = 1')
+
+      expect(result.rowCount).toBe(5)
+    })
+
+    it('should wrap query errors with context', async () => {
+      await service.connect()
+      mockExecute.mockRejectedValue(new Error('syntax error'))
+
+      await expect(service.query('INVALID SQL')).rejects.toThrow('MySQL query failed')
+    })
   })
 
   describe('transaction', () => {
@@ -59,11 +184,56 @@ describe('MySqlService Unit Tests', () => {
         'Not connected to MySQL'
       )
     })
+
+    it('should execute all queries and commit', async () => {
+      await service.connect()
+
+      await service.transaction([
+        { sql: 'INSERT INTO t VALUES (?)', params: [1] },
+        { sql: 'UPDATE t SET x = ?' }
+      ])
+
+      expect(mockBeginTransaction).toHaveBeenCalled()
+      expect(mockExecute).toHaveBeenCalledTimes(2)
+      expect(mockExecute).toHaveBeenNthCalledWith(1, 'INSERT INTO t VALUES (?)', [1])
+      expect(mockExecute).toHaveBeenNthCalledWith(2, 'UPDATE t SET x = ?', undefined)
+      expect(mockCommit).toHaveBeenCalled()
+      expect(mockRollback).not.toHaveBeenCalled()
+    })
+
+    it('should rollback on query failure', async () => {
+      await service.connect()
+      mockExecute.mockRejectedValueOnce(new Error('constraint violation'))
+
+      await expect(
+        service.transaction([{ sql: 'INSERT INTO t VALUES (?)', params: [1] }])
+      ).rejects.toThrow('MySQL transaction failed')
+
+      expect(mockRollback).toHaveBeenCalled()
+      expect(mockCommit).not.toHaveBeenCalled()
+    })
   })
 
   describe('disconnect', () => {
     it('should resolve when not connected', async () => {
       await expect(service.disconnect()).resolves.not.toThrow()
     })
+
+    it('should end connection and reset state', async () => {
+      await service.connect()
+      expect(service.isConnected()).toBe(true)
+
+      await service.disconnect()
+
+      expect(mockEnd).toHaveBeenCalled()
+      expect(service.isConnected()).toBe(false)
+    })
+
+    it('should wrap disconnect errors', async () => {
+      await service.connect()
+      mockEnd.mockRejectedValue(new Error('connection lost'))
+
+      await expect(service.disconnect()).rejects.toThrow('Failed to disconnect from MySQL')
+    })
   })
 })

tests/unit/postgresql.test.ts

@@ -1,11 +1,47 @@
 /**
  * Unit tests for PostgreSqlService
- * These tests do not require a PostgreSQL instance
+ * Covers both unconnected state and connected-path operations using mocked pg driver.
+ * Also tests the prepareSql pure function (no mocks needed for those).
  */
 
-import { describe, it, expect, beforeEach } from 'vitest'
+import { describe, it, expect, beforeEach, vi } from 'vitest'
 import { PostgreSqlService, prepareSql } from '@main/services/database/postgresql'
 
+// ---- Hoisted mock functions ----
+const { mockPgPool, mockPgClient } = vi.hoisted(() => {
+  const client = {
+    query: vi.fn(),
+    release: vi.fn()
+  }
+  const pool = {
+    connect: vi.fn(() => client),
+    query: vi.fn(),
+    end: vi.fn()
+  }
+  return { mockPgPool: pool, mockPgClient: client }
+})
+
+// Mock pg driver (must use regular function because source uses `new Pool(...)`)
+vi.mock('pg', () => ({
+  Pool: vi.fn(function () {
+    return mockPgPool
+  })
+}))
+
+// Mock logger
+vi.mock('@main/services/logger', () => ({
+  createLogger: () => ({
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn()
+  }),
+  trackDuration: async <T>(fn: () => Promise<T>) => {
+    const result = await fn()
+    return { result }
+  }
+}))
+
 const mockConfig = {
   host: 'localhost',
   port: 5432,
@@ -18,7 +54,13 @@ describe('PostgreSqlService Unit Tests', () => {
   let service: PostgreSqlService
 
   beforeEach(() => {
+    vi.clearAllMocks()
     service = new PostgreSqlService(mockConfig)
+    mockPgPool.connect.mockResolvedValue(mockPgClient)
+    mockPgPool.query.mockResolvedValue({ rows: [], fields: [], rowCount: 0 })
+    mockPgPool.end.mockResolvedValue(undefined)
+    mockPgClient.query.mockResolvedValue({ rows: [] })
+    mockPgClient.release.mockReturnValue(undefined)
   })
 
   describe('constructor', () => {
@@ -40,10 +82,79 @@ describe('PostgreSqlService Unit Tests', () => {
     })
   })
 
+  describe('connect', () => {
+    it('should throw error when pool creation fails', async () => {
+      mockPgPool.connect.mockRejectedValue(new Error('connection refused'))
+      const svc = new PostgreSqlService(mockConfig)
+      await expect(svc.connect()).rejects.toThrow('Failed to connect to PostgreSQL')
+    })
+
+    it('should establish connection and release test client', async () => {
+      await service.connect()
+      expect(mockPgPool.connect).toHaveBeenCalled()
+      expect(mockPgClient.release).toHaveBeenCalled()
+      expect(service.isConnected()).toBe(true)
+    })
+
+    it('should throw when already connected', async () => {
+      await service.connect()
+      await expect(service.connect()).rejects.toThrow('Already connected to PostgreSQL')
+    })
+
+    it('should reset pool to null on connection failure', async () => {
+      mockPgPool.connect.mockRejectedValue(new Error('timeout'))
+      await expect(service.connect()).rejects.toThrow('Failed to connect to PostgreSQL')
+      expect(service.isConnected()).toBe(false)
+    })
+  })
+
   describe('query', () => {
     it('should throw error when not connected', async () => {
       await expect(service.query('SELECT 1')).rejects.toThrow('Not connected to PostgreSQL')
     })
+
+    it('should execute query and return rows with columns', async () => {
+      await service.connect()
+      mockPgPool.query.mockResolvedValue({
+        rows: [{ ID: 1, Name: 'test' }],
+        fields: [{ name: 'ID' }, { name: 'Name' }],
+        rowCount: 1
+      })
+
+      const result = await service.query('SELECT ID, Name FROM Users')
+
+      expect(result.rows).toEqual([{ ID: 1, Name: 'test' }])
+      expect(result.columns).toEqual(['ID', 'Name'])
+      expect(result.rowCount).toBe(1)
+    })
+
+    it('should pass params through to pool.query', async () => {
+      await service.connect()
+      mockPgPool.query.mockResolvedValue({ rows: [], fields: [], rowCount: 0 })
+
+      await service.query('SELECT * FROM Users WHERE ID = $1', [42])
+
+      expect(mockPgPool.query).toHaveBeenCalledWith(expect.any(String), [42])
+    })
+
+    it('should fallback to rows.length when rowCount is null', async () => {
+      await service.connect()
+      mockPgPool.query.mockResolvedValue({
+        rows: [{ ID: 1 }, { ID: 2 }],
+        fields: [{ name: 'ID' }],
+        rowCount: null
+      })
+
+      const result = await service.query('SELECT ID FROM Users')
+      expect(result.rowCount).toBe(2)
+    })
+
+    it('should wrap query errors with context', async () => {
+      await service.connect()
+      mockPgPool.query.mockRejectedValue(new Error('syntax error'))
+
+      await expect(service.query('INVALID SQL')).rejects.toThrow('PostgreSQL query failed')
+    })
   })
 
   describe('transaction', () => {
@@ -52,13 +163,33 @@ describe('PostgreSqlService Unit Tests', () => {
         'Not connected to PostgreSQL'
       )
     })
-  })
 
-  describe('connect', () => {
+    it('should execute all queries within BEGIN/COMMIT and release client', async () => {
-    it('should throw error with invalid host', async () => {
+      await service.connect()
-      const invalidConfig = { ...mockConfig, host: 'invalid-host-that-does-not-exist' }
+      mockPgClient.query.mockResolvedValue({ rows: [] })
-      const invalidService = new PostgreSqlService(invalidConfig)
+
-      await expect(invalidService.connect()).rejects.toThrow('Failed to connect to PostgreSQL')
+      await service.transaction([{ sql: 'SELECT 1', params: [1] }, { sql: 'SELECT 2' }])
+
+      // BEGIN + 2 queries + COMMIT
+      expect(mockPgClient.query).toHaveBeenCalledTimes(4)
+      expect(mockPgClient.query).toHaveBeenNthCalledWith(1, 'BEGIN')
+      expect(mockPgClient.query).toHaveBeenNthCalledWith(4, 'COMMIT')
+      expect(mockPgClient.release).toHaveBeenCalled()
+    })
+
+    it('should rollback and release client on query failure', async () => {
+      await service.connect()
+      mockPgClient.query
+        .mockResolvedValueOnce({ rows: [] }) // BEGIN
+        .mockRejectedValueOnce(new Error('constraint violation')) // query fails
+        .mockResolvedValueOnce({ rows: [] }) // ROLLBACK
+
+      await expect(service.transaction([{ sql: 'SELECT 1', params: [1] }])).rejects.toThrow(
+        'PostgreSQL transaction failed'
+      )
+
+      expect(mockPgClient.query).toHaveBeenCalledWith('ROLLBACK')
+      expect(mockPgClient.release).toHaveBeenCalled()
     })
   })
 
@@ -66,6 +197,23 @@ describe('PostgreSqlService Unit Tests', () => {
     it('should resolve when not connected', async () => {
       await expect(service.disconnect()).resolves.not.toThrow()
     })
+
+    it('should end pool and reset state', async () => {
+      await service.connect()
+      expect(service.isConnected()).toBe(true)
+
+      await service.disconnect()
+
+      expect(mockPgPool.end).toHaveBeenCalled()
+      expect(service.isConnected()).toBe(false)
+    })
+
+    it('should wrap disconnect errors', async () => {
+      await service.connect()
+      mockPgPool.end.mockRejectedValue(new Error('pool end failed'))
+
+      await expect(service.disconnect()).rejects.toThrow('Failed to disconnect from PostgreSQL')
+    })
   })
 })