diff --git a/.gitignore b/.gitignore
index c00039c..6ccf44d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -27,3 +27,6 @@ yarn.lock
 
 # scratch
 .temp
+
+# 改动前本地备份（版本迭代时人工留存，不进版本库）
+.backup/
diff --git a/bug检测与修复.md b/bug检测与修复.md
new file mode 100644
index 0000000..69360d8
--- /dev/null
+++ b/bug检测与修复.md
@@ -0,0 +1,333 @@
+# 课程作业模块 · 前后端 Bug 检测与修复计划任务
+
+| 项 | 内容 |
+|---|---|
+| 前端 | `E:\YHXT\view\CourseHomework`（Vue3 + Vite + TS + view-ui-plus + alova） |
+| 后端 | `E:\YHXT\java\ClassHomeWork`（Spring Boot 2.7 + JPA，`/{platform}/…` 统一前缀，`platform=api`） |
+| 检测日期 | 2026-09-16 |
+| 检测方式 | 静态检视 + 契约逐字段对照 + 构建/类型检查 |
+| 文档性质 | 计划任务文档（检测项清单）＋ 执行记录（修复与回归结果） |
+
+---
+
+## 0. 检测范围与方法
+
+### 0.1 范围
+
+| 层 | 覆盖对象 |
+|---|---|
+| 前端契约层 | `src/types/homework.ts`、`src/types/homeworkV2.ts` |
+| 前端 API 层 | `src/api/module/{homework,teacherHomework,studentHomework,notification}.ts`、`src/utils/alova/*` |
+| 前端页面 | `src/views/homework/*.vue`（9 个页面） |
+| 前端组件/路由 | `src/components/{ReviewWorkbench,ReviewModal,AttachmentUpload,layout}.vue`、`src/router/routes.ts`、`src/utils/menuRoute.ts`、`src/App.vue` |
+| Mock | `src/assets/mock/homeworkapi.ts` |
+| 后端接口面 | `controller/api/{TeacherHomeworkV2,StudentHomework,Notification,Homework,File,BaseApi}Controller` |
+| 后端模型 | `model/homework/*`、`model/v2/*`、`model/BasePage*` |
+| 后端服务 | `service/impl/{TeacherHomeworkV2,StudentHomework,Homework,HomeworkProgressCalculator}Service` |
+
+### 0.2 方法
+
+1. **静态检测**：`vite build`（生产构建）、`vue-tsc --noEmit`（类型检查）。
+2. **契约逐字段对照**：前端 `types/*.ts` ↔ 后端 `model/**/*.java` 字段名与类型逐一对照。
+3. **端点对照**：前端 API 客户端方法与后端 Controller `@RequestMapping/@GetMapping/@PostMapping` 逐一对照（路径、动词、出入参）。
+4. **引用完整性**：已删除组件残留引用、未使用组件、未定义全局符号。
+5. **运行期口径**：状态机（`hwStatus` 五态 / `submitStatus` 五态 / `reviewStatus` 三态）在前后端的判定一致性。
+
+### 0.3 检测项清单（共 24 项）
+
+| 编号 | 检测项 | 方法 |
+|---|---|---|
+| C-01 | 生产构建是否通过 | `vite build --mode base` |
+| C-02 | TS 类型检查是否通过 | `vue-tsc --noEmit` |
+| C-03 | 已删除组件是否仍被引用 | grep 残留引用 |
+| C-04 | 是否存在未使用的死组件 | 反向引用计数 |
+| C-05 | 前端定义的接口路径后端是否真实存在 | 端点对照 |
+| C-06 | 路径参数名是否与后端 `@PathVariable` 一致 | 端点对照 |
+| C-07 | `@RequestBody` 是否用 POST/PUT + JSON | 端点对照 |
+| C-08 | 分页外壳字段是否一致 | `BasePageResult` 对照 |
+| C-09 | 分页入参语义是否一致（pageIndex 起始值） | `BasePageQuery` 对照 |
+| C-10 | V2 作业 VO 字段是否一致 | `HomeworkV2Vo` 对照 |
+| C-11 | V2 学生 VO 字段是否一致 | `StudentHomeworkVo/DetailVo` 对照 |
+| C-12 | 学生矩阵 VO 字段是否一致 | `StudentMatrixVo` 对照 |
+| C-13 | 提交版本 VO 字段是否一致 | `SubmissionVersionVo` 对照 |
+| C-14 | 通知 VO / 未读数是否一致 | `NotificationPageResult` 对照 |
+| C-15 | V1 作业列表 VO 字段是否一致 | `HomeworkVo` 对照 |
+| C-16 | V1 详情 VO 字段是否一致 | `HomeworkDetailVo` 对照 |
+| C-17 | V1 统计 VO 字段是否一致 | `HomeworkStatisticsVo` 对照 |
+| C-18 | 时间格式是否一致（全局 `yyyy-MM-dd HH:mm:ss`） | `JacksonConfig` + 前端解析 |
+| C-19 | 附件 URL 是否可解析（相对/绝对、contextPath） | 各页面 `previewUrl/downUrl` |
+| C-20 | 状态机判定是否前后端一致（可提交/可撤回/可编辑） | 页面 `canSubmit*` vs Service 校验 |
+| C-21 | 是否存在重复函数声明/无界缓存 | 代码检视 |
+| C-22 | 组件挂载期是否存在异步竞态 | 代码检视 |
+| C-23 | 构建/发布配置是否自洽（outDir、env、产物） | `vite.config.ts` + `.env.*` |
+| C-24 | 工作区未提交改动是否引入噪音 | `git status/diff` |
+
+---
+
+## 1. 检测结论摘要
+
+| 编号 | 问题 | 级别 | 影响面 | 状态 |
+|---|---|---|---|---|
+| B-01 | 学生端缺少 `allowLate` 字段，导致「截止后补交」能力在真实环境完全失效 | **P0** | 学生列表/详情/快捷提交 | 已修复 |
+| B-02 | `ReviewWorkbench` 附件 URL 未拼 `serviceHost`，线上图片/下载 404 | **P0** | 教师批阅工作台 | 已修复 |
+| B-03 | `HomeworkStatisticsVo` 前端声明 5 个幻影字段，后端从未返回 → 统计页 4 张卡片恒为 0/0%/空表 | **P0** | `/stats` 作业统计 | 已修复（前端降级）+ 后端补字段 |
+| B-04 | `HomeworkVo` 前端声明 `progress` 字段，后端从未返回 → 「全部作业」页 3 列进度恒为「—」 | **P0** | `/homeworklist` 全部作业 | 已修复（前端降级）+ 后端补字段 |
+| B-05 | `HomeworkDetailVo` 前端声明 `receiveText`，后端从未返回 → 详情页「接收班级」恒显示「全部班级」 | **P1** | `/homeworklist/detail` | 已修复（后端补字段 + 前端兜底） |
+| B-06 | `TeacherHomeworks.vue` 4 个行操作函数重复声明 | **P1** | `/list` 我布置的 | 已修复 |
+| B-07 | `TeacherHomeworks.vue` `moreActions` Map 每次重渲染累积、永不回收 | **P1** | `/list` 我布置的 | 已修复 |
+| B-08 | `NewHomework.vue` 编辑回显与班级树加载存在竞态，导致「全部班级」勾选态误判 | **P1** | `/list/new` 发作业 | 已修复 |
+| B-09 | `src/api/index.ts` 引用未定义的 `GlobalFetch()`，且 baseURL 硬编码远程域名 | **P2** | 潜在全局 auto-import 污染 | 已修复 |
+| B-10 | 7 个死组件 + 1 个 `index copy.vue` 残留，`auto-import` 扫描目录存在误引入风险 | **P2** | 构建体积/可维护性 | 已记录（不删除） |
+| B-11 | `.backup/` 未纳入 `.gitignore`，污染 `git status` | **P2** | 版本管理 | 已修复 |
+| B-12 | `routes.ts` 出现仅换行符差异的伪改动 | **P2** | 版本管理噪音 | 已记录 |
+| B-13 | `baseApi.setRole` 指向后端不存在的 `/api/base/SetRole`，真实环境每次跨角色路由切换都会 404 | **P2** | 控制台噪音 | 已记录（设计如此） |
+| B-14 | `vue-tsc` 在 Node 24 下崩溃（`Search string not found: "/supportedTSExtensions = .*(?=;)/"`），类型门禁实际失效 | **P1** | 全部 TS 代码 | 已记录（需换 Node 18/20 或升级 vue-tsc） |
+| C-01 | 生产构建通过（39.66s，exit 0） | — | — | 通过 |
+| C-02 | TS 类型检查**无法执行**（见 B-14） | — | — | 阻塞 |
+| C-05~C-07 | V2 端点 28 个 + 通知 3 个 + V1 冻结端点路径/动词与后端一致 | — | — | 通过 |
+| C-08/C-09 | `BasePageResult` 六字段、`pageIndex` 从 1 起前后端一致 | — | — | 通过 |
+| C-10~C-14 | V2 作业/学生/矩阵/版本/通知 VO 字段与后端逐一对应 | — | — | 通过 |
+| C-18 | 后端 `JacksonConfig` 全局 `yyyy-MM-dd HH:mm:ss`（无 `T`），前端一律 `String(v).slice()` 截取，一致 | — | — | 通过 |
+| C-23 | `outDir=dist` 直出、`.env.dev/.env.mock` 仅本地生效、产物不含环境值，自洽 | — | — | 通过 |
+
+**最严重的三条（P0）本质是同一个病根**：前端契约（`types/*.ts`）比后端实际返回**多声明的字段**，被 TypeScript 视为可选（`?:`），又被 `vue-tsc` 崩溃掩盖，于是「编译通过、构建成功、mock 模式下一切正常」——**只有连真实后端才会表现为静默的空值/功能失效**。mock（`homeworkapi.ts`）为了让页面「跑得起来」，主动补齐了这些后端并不存在的字段，进一步掩盖了问题。
+
+---
+
+## 2. 缺陷详情与修复方案
+
+### B-01 【P0】学生端 `allowLate` 字段缺失 → 截止后补交能力失效
+
+**证据链**
+
+- 后端 `model/v2/StudentHomeworkVo.java` 字段仅：`id/title/subject/teacherName/deadlineAt/submitType/hwStatus/hwStatusDesc/my`，**无 `allowLate`**。
+- 后端实体 `entity/Homework.java:188` 确有 `allow_late` 列（`private Integer allowLate = 0`），说明数据存在、只是学生端 VO 未透出。
+- 后端 `service/impl/StudentHomeworkService.java#copyBase()`（411~433 行）逐字段赋值，**未赋值 allowLate**。
+- 前端 `views/homework/StudentHomeworks.vue:110`：`if (x.hwStatus === "CLOSED") return x.allowLate === 1;`
+- 前端 `views/homework/HomeworkAccept.vue:104`：`if (d.hwStatus === "CLOSED") return d.allowLate === 1;`；第 307 行提示语 `v-if="detail.allowLate !== 1"`。
+- 前端类型 `types/homeworkV2.ts` 的 `StudentHomeworkV2Vo` **也未声明 `allowLate`**（TS 应报错，被 B-14 掩盖）。
+- mock 学生列表/详情响应同样未输出 `allowLate`。
+
+**后果**
+
+`x.allowLate` 恒为 `undefined` → `undefined === 1` 恒 `false`。因此后端即便 `allow_late=1`（`doSubmit` 允许 `LATE_SUBMITTED`），前端也**永远不渲染「补交作业」按钮**，并恒显示「作业已截止，如需补交请联系老师」。这是真实环境下可直接复现的功能性缺陷——接口允许、UI 拦住。
+
+**修复**
+
+| 文件 | 改动 |
+|---|---|
+| `ClassHomeWork/model/v2/StudentHomeworkVo.java` | 新增 `private Integer allowLate;`（含注释） |
+| `ClassHomeWork/service/impl/StudentHomeworkService.java` | `copyBase()` 增加 `vo.setAllowLate(h.getAllowLate());` |
+| 前端 `types/homeworkV2.ts` | `StudentHomeworkV2Vo` 新增 `allowLate?: number;` |
+| 前端 `assets/mock/homeworkapi.ts` | 学生列表与详情响应补 `allowLate: n.allowLate ?? 0` |
+
+---
+
+### B-02 【P0】`ReviewWorkbench` 附件 URL 未拼 `serviceHost` → 线上 404
+
+**证据链**
+
+- `components/AttachmentUpload.vue` 上传成功后写入 `fileUrl: "/api/file/Preview?id=" + fileid`（**相对路径**）。
+- `views/homework/StudentHomeworks.vue`、`HomeworkAccept.vue`、`Submissions.vue` 展示时均用 `serviceBase`（`config.serviceHost`）拼接相对路径。
+- 但 `components/ReviewWorkbench.vue`（教师批阅工作台，被 `Grade.vue` 与 `ReviewModal.vue` 共用，即 `/grade` 与 `/submissions` 两个入口）：
+  ```ts
+  function attUrl(a: AttachmentItem): string {
+      if (/^(https?:)?\/\//.test(a.fileUrl) || a.fileUrl.startsWith("data:")) return a.fileUrl;
+      return a.fileUrl;   // ← 相对路径原样返回，未拼 serviceBase
+  }
+  function attDownUrl(a: AttachmentItem): string {
+      return a.fileId ? `/api/file/Down?id=${a.fileId}` : a.fileUrl;  // ← 同样缺前缀
+  }
+  ```
+
+**后果**
+
+本地 `serviceHost` 为空（走 vite 同源代理）时正常；线上 `serviceHost` 为基础平台域名且应用部署于 `/{contextPath}/front/`，相对路径 `/api/...` 会被解析到**站点根**而非后端 contextPath，导致批阅时学生作答图片**裂图**、附件**下载 404**。教师端核心链路（看图给分）受阻。
+
+**修复**：`ReviewWorkbench.vue` 引入 `@/assets/config/host.config`，按 `config.isMock ? "" : config.serviceHost` 前缀拼接（与其它页面同一范式）。
+
+---
+
+### B-03 【P0】统计页幻影字段 → 4 张卡片恒为 0
+
+**证据链**
+
+- 前端 `types/homework.ts` 的 `HomeworkStatisticsVo` 声明：`myAssignCount?`、`pendingGrade?`、`avgSubmitRate?`、`byHomework?`、`scoreDist?`。
+- 后端 `model/homework/HomeworkStatisticsVo.java` 实际字段仅：`total`、`publishedCount`、`totalReadRecords`、`unreadForCurrentUser`、`byPublisher`、`byMonth`。
+- 后端 `service/impl/HomeworkService.java#statistics()`（702~756 行）只 set 这 6 个字段，**全库 grep `myAssignCount|avgSubmitRate|scoreDist|byHomework` 在 `src/main/java` 下零命中**。
+- `views/homework/HomeworkStats.vue` 直接消费：4 张卡片 `myAssignCount/pendingGrade/avgSubmitRate/total`、成绩分布 `stat.scoreDist`、各作业进度表 `stat.byHomework`。
+- mock `/api/homework/Statis`（`homeworkapi.ts:1319`）**主动补齐了**这 5 个字段 → mock 模式下页面完整，真实后端下全空。
+
+**后果**：真实环境 `/stats` 页显示「我布置的作业 0 / 待批改总量 0 / 平均提交率 0%」、成绩分布条全 0、各作业进度表「暂无数据」。属静默错误，用户会误以为没有数据。
+
+**修复（双管齐下）**
+
+1. **前端降级（可验证）**：`HomeworkStats.vue` 在字段缺失时明确呈现「后端未提供该口径」而非伪装成 0；仅在 `scoreDist?.length` / `byHomework?.length` 时渲染区块。
+2. **后端补字段（additive）**：`HomeworkStatisticsVo` 新增这 5 个字段，`statistics()` 基于 V2 `HomeworkProgressCalculator` 聚合填充。
+
+---
+
+### B-04 【P0】「全部作业」页进度列恒空
+
+**证据链**
+
+- 前端 `types/homework.ts` 的 `HomeworkVo` 声明 `progress?: HomeworkProgress | null`，`HomeworkList.vue` 用 `progressCell / gradeCell` 渲染「提交进度 / 未读未交 / 批改」三列，并读 `g.read`、`g.submitRate`、`g.pendingGrade`、`g.unread`。
+- 后端 `model/homework/HomeworkVo.java` **没有 `progress` 字段**；`service/impl/HomeworkService.java#toVo()`（903~920 行）只回填 `deadline/submitType/hwStatus/hwStatusDesc/read/readCount/deptName`。
+- `#adminList()`（345~362 行，即 `/homework/api/homework/SendList`）只额外填充 `UpFile` 附件串，**未填 progress**。
+- `/homeworklist` 路由与菜单 `modId=3` 均在生效（`routes.ts`、`config/menu.ts`）。
+
+**后果**：真实环境下「全部作业」页的提交进度条、未读未交、批改状态三列恒为「—」。
+
+**修复**
+
+1. **后端补字段**：`HomeworkVo` 新增 `progress`；`adminList()` 用 `HomeworkProgressCalculator` 聚合填充。
+2. **前端降级**：进度列在 `progress` 缺失时显示「—」（现有行为已如此），不伪装为 0。
+
+---
+
+### B-05 【P1】详情页「接收班级」恒显示「全部班级」
+
+**证据链**
+
+- `views/homework/HomeworkDetails.vue`（V1 管理分支）：`<Tag color="blue">接收班级：{{ detail.receiveText || "全部班级" }}</Tag>`。
+- 后端 `model/homework/HomeworkDetailVo.java` **无 `receiveText`**（字段：`serid/title/Contents/DeptID/DeptName/TeaName/EditDate/numcount/readnumcount/ReceiveList/DsfsTime/isDsfs/ChaoSend/tlist`）；全库 `grep receiveText src/main/java` 零命中。
+- 后端实际提供 `ReceiveList`（值 `"ALL"` 或 id 串）与 `tlist`。
+
+**修复**：后端 `HomeworkDetailVo` 新增 `receiveText` 并在 `getDetailMap()` 填充可读文本（「全部班级」或班级名串）；前端保留 `receiveText || "全部班级"` 兜底。
+
+---
+
+### B-06 / B-07 【P1】`TeacherHomeworks.vue` 重复声明与无界缓存
+
+**证据链**
+
+- `viewDetail / viewSubmissions / toGrade / edit` 四个函数在 `<script setup>` 中**各定义两次**（同一模块作用域重复 `function` 声明）。
+- `const moreActions = new Map<string, () => void>()`、`let moreSeq = 0` 位于模块级；`pubColumns` 是 `computed`，每次依赖变化重算都会调用 `mItem()` 递增 `moreSeq` 并写入 Map，**Map 只增不减**。
+
+**后果**：重复声明在 JS 中后者覆盖前者（静默），但违反类型检查（TS `Duplicate function implementation`），也让维护者误判生效分支；Map 在长时间停留/频繁翻页的列表页持续增长（内存缓慢泄漏）。
+
+**修复**：删除重复的 4 个函数定义；`moreActions` 改为每次 `pubColumns` 重算时重建（局部 Map），避免无界增长。
+
+---
+
+### B-08 【P1】`NewHomework.vue` 编辑回显与班级树竞态
+
+**证据链**
+
+- `onMounted(loadClasses)` 与 `onMounted(async () => { … await teacherApi.detail(); fillFromV2(d); })` 两次注册，`loadClasses()` 内部 `await teacherApi.classTree()`，**不保证先于详情回显完成**。
+- `fillFromV2()` 依赖 `allClassIds.value` 判断「是否全部班级」：
+  ```ts
+  if (cls.length && cls.length === allClassIds.value.length && cls.every(c => allClassIds.value.includes(c)))
+      allClasses.value = true;
+  ```
+- 若 `allClassIds` 仍为空（`length === 0`），条件恒不成立 → 即使该作业确实覆盖全部班级，也渲染为**未勾选「全部班级」**且多选框中班级列表为空（丢失勾选态）。
+
+**修复**：把初始化串行为「先 `await loadClasses()`，再拉详情并 `fillFromV2()`」，消除竞态。
+
+---
+
+### B-09 【P2】`src/api/index.ts` 引用未定义符号
+
+**证据链**：`src/api/index.ts` 顶部 `createAlova({ … requestAdapter: GlobalFetch() … })`，但该文件**未导入也未定义 `GlobalFetch`**；且 `baseURL: 'http://base.yunhaixingtong.com/homework'` 硬编码远程域名，与 `host.config.ts` 的运行时配置体系冲突。该文件未被任何模块引用，但 `vite.config.ts` 中 `ViteAutoImport({ dirs: ["src/api"] })` 会扫描该目录并生成全局声明（`auto-imports.d.ts` 中可见 `apiDefinitions/createApis/mountApis/withConfigType`），存在被误自动引入、进而在运行时抛 `GlobalFetch is not defined` 的风险。
+
+**修复**：删除该废弃入口文件（页面统一走 `api/module/*`，`src/api/index.ts` 与 `apiDefinitions.ts`/`createApis.ts` 为 `alova gen` 遗留）。
+
+---
+
+### B-10 / B-11 / B-12 / B-13 / B-14 其余记录项
+
+| 编号 | 内容 | 处置 |
+|---|---|---|
+| B-10 | 死组件：`BschImport.vue`、`GroupTreeSearchPanel.vue`、`MyTreeSearch.vue`、`TablePageAlova.vue`、`TablePageAlovaNew.vue`、`UploadFile.vue`、`UploadImg.vue`、`my_tree.vue`、`TreeNode/index copy.vue` 反向引用均为 0 | **不删除**（可能为后续页面预留），仅登记 |
+| B-11 | `.backup/` 未在 `.gitignore`，`git status` 出现 `?? .backup/20260916-m5-v2-mock/` | 追加忽略规则 |
+| B-12 | `src/router/routes.ts` 被 `git status` 标记为已修改，但 `git diff` 内容为空（仅 CRLF/LF 差异） | 记录；建议统一 `core.autocrlf` 或提交时按内容判定 |
+| B-13 | `App.vue` 每次跨角色路由切换调用 `baseApi.setRole` → 后端无 `/api/base/SetRole`，真实环境 404（已被 `try/catch` 吞掉） | 设计如此（仅 mock 用），保留但已在前端注释标明 |
+| B-14 | `vue-tsc@1.8.27` + Node 24 崩溃，`npm run build` 不含类型检查 → TS 契约门禁失效（正是 B-01/B-03/B-04 长期未被发现的原因） | 需将 Node 降到 18/20 或升级 `vue-tsc`；建议在 CI 增加类型检查步骤 |
+
+---
+
+## 3. 执行计划（修复顺序与验证）
+
+| 步骤 | 动作 | 验证方式 |
+|---|---|---|
+| S1 | 修复 B-01（后端 VO + Service；前端类型 + mock） | 后端字段对照；前端构建 |
+| S2 | 修复 B-02（ReviewWorkbench 拼 `serviceHost`） | 前端构建；代码走查三条附件路径 |
+| S3 | 修复 B-04 / B-05（后端 `HomeworkVo.progress`、`HomeworkDetailVo.receiveText` + 服务填充） | 字段对照 + 前端构建 |
+| S4 | 修复 B-03（统计 VO 补字段 + 前端降级展示） | 字段对照 + 前端构建 |
+| S5 | 修复 B-06 / B-07（`TeacherHomeworks.vue` 去重、Map 本地化） | 前端构建 |
+| S6 | 修复 B-08（`NewHomework.vue` 串行初始化） | 前端构建 |
+| S7 | 修复 B-09（删除废弃 `src/api/index.ts`） | 全局 grep 无引用；前端构建 |
+| S8 | 修复 B-11（`.gitignore` 追加 `.backup/`） | `git status` 干净 |
+| S9 | 回归：`vite build --mode base` 全绿 | exit code 0 |
+| S10 | 更新本文档「执行记录」并汇总遗留风险 | 文档 |
+
+**约束说明**：本机无 Maven、无 JDK（仅 JRE 8），后端 Java 改动**无法本地编译验证**，仅做「纯增量、机械式」修改（新增字段 + 赋值 + 新注入），需在装有 Maven 的环境中执行 `mvn -q clean compile` 复核。
+
+---
+
+## 4. 执行记录
+
+> 本节由执行过程回填，逐项记录改动文件与验证结果。
+
+### S1 · B-01 学生端 allowLate 透出
+
+- [x] `ClassHomeWork/src/main/java/com/yunhai/homework/model/v2/StudentHomeworkVo.java`：新增 `allowLate` 字段
+- [x] `ClassHomeWork/src/main/java/com/yunhai/homework/service/impl/StudentHomeworkService.java`：`copyBase()` 补 `vo.setAllowLate(...)`
+- [x] `src/types/homeworkV2.ts`：`StudentHomeworkV2Vo` 新增 `allowLate?: number`
+- [x] `src/assets/mock/homeworkapi.ts`：学生列表 + 学生详情响应补 `allowLate`
+
+### S2 · B-02 批阅工作台附件地址
+
+- [x] `src/components/ReviewWorkbench.vue`：引入 `host.config`，`attUrl/attDownUrl` 统一补 `serviceHost`
+
+### S3 · B-04 / B-05 后端 V1 VO 补字段
+
+- [x] `HomeworkVo.java`：新增 `progress`（`model/v2/ProgressVo`）
+- [x] `HomeworkDetailVo.java`：新增 `receiveText`
+- [x] `HomeworkService.java`：`adminList()` 填 `progress`；`getDetailMap()` 填 `receiveText`
+
+### S4 · B-03 统计口径
+
+- [x] `HomeworkStatisticsVo.java`：新增 `myAssignCount/pendingGrade/avgSubmitRate/byHomework/scoreDist`
+- [x] `HomeworkService.java`：`statistics()` 聚合填充
+- [x] `src/views/homework/HomeworkStats.vue`：字段缺失时降级为「—/暂未提供」，不再伪装为 0
+
+### S5 · B-06 / B-07 我布置的页
+
+- [x] `src/views/homework/TeacherHomeworks.vue`：删除 4 个重复函数；`moreActions` 改为列重算时重建
+
+### S6 · B-08 发作业页竞态
+
+- [x] `src/views/homework/NewHomework.vue`：初始化改为 `await loadClasses()` → 详情回显串行
+
+### S7 · B-09 废弃入口
+
+- [x] 删除 `src/api/index.ts`（含 `GlobalFetch` 未定义、硬编码 baseURL）
+
+### S8 · B-11 忽略规则
+
+- [x] `.gitignore` 追加 `.backup/`
+
+### S9 · 回归验证
+
+见 §5。
+
+---
+
+## 5. 回归验证结果
+
+| 验证项 | 命令 | 结果 |
+|---|---|---|
+| 生产构建 | `npx vite build --mode base` | 见下 |
+| 端点/契约复核 | 字段对照脚本 | 见下 |
+| Java 编译 | `mvn clean compile` | **未执行**（本机无 Maven/JDK） |
+
+---
+
+## 6. 遗留风险与后续建议
+
+1. **类型门禁形同虚设（B-14，最高优先）**：本次 B-01/B-03/B-04 三条 P0 全部是「类型声明比后端多」的静默错配。恢复 `vue-tsc` 可运行（Node 18/20 或升级 `vue-tsc`）并纳入 CI，是防止同类问题复发的根本手段。
+2. **mock 与真实后端口径漂移**：`homeworkapi.ts` 主动补齐了后端不存在的字段，使 mock 模式「看起来一切正常」，掩盖真实缺陷。建议以「后端 VO 为唯一真源」生成/校验 mock。
+3. **后端改动未经编译验证**：S1/S3/S4 涉及 Java 文件，本机无 Maven/JDK，需在构建环境跑 `mvn -q clean compile` 复核；若编译不通过，回退范围仅限本次新增的字段与注入。
+4. **`/stats` 与「全部作业」仍建议评估退役**：这两页属 V1 冻结面，其课程作业口径字段（提交进度/批改/成绩分布）在 V2 已有权威实现（`teacherApi.stats` / `published` 的 `progress`）。长期建议整体切 V2，避免在 V1 VO 上持续打补丁。
+5. **`GitHub` 换行符噪音（B-12）**：建议统一 `core.autocrlf` 或在 `.gitattributes` 中固定 `*.ts text eol=lf`，避免无内容变更的文件反复出现在 diff 中。
diff --git a/src/api/index.ts b/src/api/index.ts
deleted file mode 100644
index ad11b8e..0000000
--- a/src/api/index.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import { createAlova } from 'alova';
-import { createApis, withConfigType, mountApis } from './createApis';
-
-export const alovaInstance = createAlova({
-  baseURL: 'http://base.yunhaixingtong.com/homework',
-  requestAdapter: GlobalFetch(),
-  beforeRequest: method => {},
-  responded: res => {
-    return res.json();
-  }
-});
-
-export const $$userConfigMap = withConfigType({});
-
-const Apis = createApis(alovaInstance, $$userConfigMap);
-
-mountApis(Apis);
-
-export default Apis;
diff --git a/src/api/module/homework.ts b/src/api/module/homework.ts
index ee4620f..a460c41 100644
--- a/src/api/module/homework.ts
+++ b/src/api/module/homework.ts
@@ -4,45 +4,30 @@ import conf from "@/assets/config/host.config";
 import type {
     HomeworkVo,
     HomeworkDetailVo,
-    HomeworkPageResult,
     BasePageResult,
     UpFileResultVo,
     UpFileVo,
-    InitializeRedVo,
     NextPrevVo,
     ReadGroup,
     HomeworkStatisticsVo,
-    HomeworkRequest,
     HomeworkQuery,
     SchoolTreeNode,
-    ClassTreeNode,
-    SubmissionsResultVo,
-    SubmissionDetailVo,
-    GradeRequest,
-    MyHomeworksVo,
-    MySubmissionVo,
-    SubmitRequest,
 } from "@/types/homework";
 
 /**
- * 课程作业接口封装（P0 标准化后新契约，P1-7 TS 契约化）。
+ * 课程作业 V1 冻结接口封装（M5 后待评估退役）。
+ *
+ * 仅保留后端真实存在的 /api/homework/* 端点，服务未切换页面：
+ *  - /homeworklist 全部作业（HomeworkList.vue，SendList）
+ *  - /homeworklist/detail 管理视角详情（HomeworkDetails.vue V1 分支）
+ *  - /stats 作业统计（HomeworkStats.vue，Statis）
+ *  - /list/new?fid= 转发回显（GetDetail）
+ * 原 v1 伪接口（Submissions/SubmissionDetail/Grade/Remind/MyHomeworks/MySubmission/
+ * Submit，后端不存在、真实环境必 404）已随 M5 页面切换删除，见 m5-plan §1.2。
  *
  * 前缀说明：conf.serviceHost 本地为空（走 vite 代理），线上为基础平台域名；
  * platform 固定使用 "api"，与后端 Config.API_PATH 中的 api 匹配。
  * 统一响应由 alova-iview 解包为 data（code==0），页面直接使用返回值。
- *
- * 变更要点（P0）：
- * 1. 作业域去掉 Homework_list 二级段（/api/homework/Homework_list/List → /api/homework/List）
- * 2. 文件域从 base/ 迁移到 file/（/api/base/FileDown → /api/file/Down）
- * 3. 字典域与联系组域（发文部门管理、自定义联系组）随「应用设置」功能下线整体移除
- *    （见 classwork-frontend-m5-plan.md §7），本文件不再封装 /api/dict/* 与 /api/contacts/*
- * 4. postJSON 用于 @RequestBody 接口；postForm 用于 @RequestParam 接口（表单提交）
- * 5. 参数更名：chaoSend→fileIds、topmost→smsFlag
- * 6. Delete 入参从 ids 逗号串改为 List<Integer> JSON 数组
- *
- * 变更要点（P1-7）：
- * 7. 全部方法加返回值泛型标注，替换 Record<string, any>
- * 8. 列表分页 content 字段对齐后端 BasePageResult（非旧 list）
  */
 
 const HOMEWORK = "/api/homework";
@@ -65,24 +50,6 @@ function postJSON<T = any>(url: string, data?: Record<string, any> | any[]): Met
     );
 }
 
-/** POST 表单（与后端 @RequestParam 对齐，application/x-www-form-urlencoded），T 为返回数据类型 */
-function postForm<T = any>(url: string, data?: Record<string, any>): Method<T> {
-    const pairs = data
-        ? Object.entries(data).filter(([, v]) => v !== undefined && v !== null)
-        : [];
-    const form = pairs.map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join("&");
-    // 同时把参数拼到 URL query：后端 @RequestParam 表单/查询参数都能接收，
-    // 且本地 vite-plugin-mock 不解析 urlencoded body，靠 query 才能拿到参数（不影响线上）。
-    const fullUrl = form ? `${url}${url.includes("?") ? "&" : "?"}${form}` : url;
-    return new Method<T>(
-        "POST",
-        alovaInstance,
-        fullUrl,
-        { headers: { "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8" } },
-        form || undefined
-    );
-}
-
 /** 附件下载直链（浏览器 location.href 跳转） */
 function fileDownUrl(fileId: number): string {
     return `${conf.serviceHost}${FILE}/Down?id=${fileId}`;
@@ -103,34 +70,20 @@ class BaseApi {
     getUserMod() {
         return get<SchoolTreeNode[]>(`${BASE}/GetUserMod`);
     }
-    /** 年级→班级树（学生场景：选择通知对象到班级一级） */
-    getClassTree() {
-        return get<ClassTreeNode[]>(`${BASE}/GetClassTree`);
-    }
-    /** 端分离入口：切换当前视角（teacher / student / parent），需在拉取用户信息前调用 */
+    /** 端分离入口（仅 mock）：切换当前视角（teacher / student / parent），需在拉取用户信息前调用 */
     setRole(as: "teacher" | "student" | "parent") {
         return postJSON<{ role: string }>(`${BASE}/SetRole`, { as });
     }
 }
 
 class HomeworkApi {
-    // ========== 收件箱 ==========
-    /** 已收作业列表 */
-    list(params: HomeworkQuery) {
-        return get<HomeworkPageResult<HomeworkVo>>(`${HOMEWORK}/List`, params);
-    }
-    /** 清单：一键全部已读 */
-    initializeRed() {
-        return postForm<InitializeRedVo>(`${HOMEWORK}/InitializeRed`);
-    }
-
-    // ========== 已发/全部作业 ==========
+    // ========== 全部作业（/homeworklist 管理页） ==========
     /** 已发/全部作业列表（scope="user" 只看自己，不传=全部） */
     sendList(params: HomeworkQuery) {
         return get<BasePageResult<HomeworkVo>>(`${HOMEWORK}/SendList`, params);
     }
 
-    // ========== 详情 ==========
+    // ========== 详情（/homeworklist/detail 管理视角 + /list/new?fid= 转发回显） ==========
     /** 查看详情（type=1 标读；type=0 编辑不标读） */
     modify(serid: number, type = 1) {
         return get<HomeworkDetailVo>(`${HOMEWORK}/Detail`, { serid, type });
@@ -147,70 +100,14 @@ class HomeworkApi {
     orgizeModify(serid: number) {
         return get<ReadGroup[]>(`${HOMEWORK}/ReadDetail`, { serid });
     }
-    /** 追加接收人 */
-    receiveUsers(serid: number, users: string) {
-        return postForm<void>(`${HOMEWORK}/ReceiveUsers`, { serid, users });
-    }
 
-    // ========== 发布/编辑/删除 ==========
-    /** 新建作业（JSON body，fileIds 为附件ID逗号串，smsFlag 为短信标记） */
-    create(data: HomeworkRequest) {
-        return postJSON<number>(`${HOMEWORK}/Create`, data);
-    }
-    /** 编辑作业（JSON body，含 id） */
-    editHomework(data: HomeworkRequest) {
-        return postJSON<void>(`${HOMEWORK}/Edit`, data);
-    }
+    // ========== 维护（管理页） ==========
     /** 删除作业（ids 数组，支持批量） */
     deleteHomework(ids: number | string) {
         // 兼容页面传单个 id 或逗号串，统一转成数组
         const idArr = String(ids).split(",").map(Number).filter(Boolean);
         return postJSON<void>(`${HOMEWORK}/Delete`, idArr);
     }
-    /** 撤回 */
-    userPull(serid: number) {
-        return postForm<void>(`${HOMEWORK}/UserPull`, { serid });
-    }
-    /** 置顶/取消置顶 */
-    setTopmost(serid: number, topmost = 1) {
-        return postForm<void>(`${HOMEWORK}/SetTopmost`, { serid, topmost });
-    }
-    /** 催收未读 */
-    expedite(serid: number) {
-        return postForm<void>(`${HOMEWORK}/Expedite`, { serid });
-    }
-
-    // ========== 课程作业 v1：提交情况 / 批改 / 催交 ==========
-    /** 某作业的提交名单（按班级分组）+ 汇总；submitStatus: all/unsubmitted/submitted/pending/graded/needRedo */
-    submissions(serid: number, submitStatus = "all") {
-        return get<SubmissionsResultVo>(`${HOMEWORK}/Submissions`, { serid, submitStatus });
-    }
-    /** 单份提交详情（批改工作台右侧） */
-    submissionDetail(subId: number) {
-        return get<SubmissionDetailVo>(`${HOMEWORK}/SubmissionDetail`, { subId });
-    }
-    /** 批改（JSON body）：action=grade/redo/excellent */
-    grade(data: GradeRequest) {
-        return postJSON<void>(`${HOMEWORK}/Grade`, data);
-    }
-    /** 催交未交学生 */
-    remind(serid: number) {
-        return postForm<{ reminded: number }>(`${HOMEWORK}/Remind`, { serid });
-    }
-
-    // ========== v2 学生端 ==========
-    /** 今日/我的作业（当前学生视角，含提交与批改态 + 分桶计数） */
-    myHomeworks() {
-        return get<MyHomeworksVo>(`${HOMEWORK}/MyHomeworks`);
-    }
-    /** 我对某作业的详情（作业信息 + 我的提交/批改） */
-    mySubmission(serid: number) {
-        return get<MySubmissionVo>(`${HOMEWORK}/MySubmission`, { serid });
-    }
-    /** 提交 / 订正重交（JSON body：serid, text, images, attachments） */
-    submit(data: SubmitRequest) {
-        return postJSON<{ subId: number; submitStatus: string }>(`${HOMEWORK}/Submit`, data);
-    }
 
     // ========== 附件 ==========
     fileDownUrl = fileDownUrl;
diff --git a/src/assets/mock/homeworkapi.ts b/src/assets/mock/homeworkapi.ts
index 739dc55..8409f44 100644
--- a/src/assets/mock/homeworkapi.ts
+++ b/src/assets/mock/homeworkapi.ts
@@ -1,23 +1,26 @@
 /**
  * 课程作业本地 Mock 数据（vite-plugin-mock，仅在 `npm run dev:mock`（--mode mock）下生效）。
  *
- * 契约对齐 src/api/module/homework.ts（P0 标准化）：
- *  - /api/homework/{List,SendList,Detail,GetDetail,GetNextPrev,ReadDetail,Create,Edit,Delete,
- *                  InitializeRed,UserPull,SetTopmost,Expedite,ReceiveUsers,Statis}
- *  - /api/base/{GetUserInfo,GetUserMod,GetLayout,GetClassTree,FileUpload}
- *  - /api/file/{UploadImage,Preview}
- * （原 /api/dict/* 与 /api/contacts/* 随「应用设置」功能下线移除，见 classwork-frontend-m5-plan.md §7）
+ * M5 起以 V2 接口面为主（对齐 src/api/module/{teacherHomework,studentHomework,notification}.ts）：
+ *  - /api/teacher/homeworks/*（19 端点，PRD §18 页 1~6）
+ *  - /api/student/homeworks/*（6 端点，PRD 学生页 1~3）
+ *  - /api/notifications/*（3 端点）
+ * V1 冻结接口仅保留仍被未切换页面消费的 7 个（/homeworklist 全部作业、其详情、/stats 统计、
+ * GetDetail 转发回显），由同一份 V2 存储派生（与后端同一张 homework 表一致）：
+ *  - /api/homework/{SendList,Detail,GetDetail,GetNextPrev,ReadDetail,Delete,Statis}
+ *  - /api/base/{GetUserInfo,GetUserMod,GetLayout,SetRole,FileUpload}
+ *  - /api/file/{Upload,UploadImage,Preview}
+ * 已删除的伪接口（后端不存在）：Submissions/SubmissionDetail/Grade/Remind/MyHomeworks/
+ * MySubmission/Submit/Create/Edit/InitializeRed/UserPull/SetTopmost/Expedite/ReceiveUsers/List。
  * 统一响应 {code,msg,data}，由 alova-core 解包为 data（code==0）。
  *
- * 课程作业（任课教师布置场景）关键点：
- *  1. 布置对象到「班级」一级：receiveList = "ALL" 或 班级 id 逗号串；应查看/已查看人数按班级学生数累加。
- *  2. 当前登录演示身份 = 数学教师 朱皓东(zhd)；收件箱以「初一(1)班(1301)」视角判定已读/未读。
- *  3. 课程作业不做审批（无送审环节，发布即可见），详见 classwork-frontend-m5-plan.md §6。
+ * 演示身份：教师 = 数学教师 朱皓东(zhd)；学生 = 初一(1)班 王伟(stu130101)。
+ * 端分离：App.vue 按 URL 前缀调 /api/base/SetRole 切换 viewerRole（仅 mock 有此端点）。
  */
 
 /* ============================ 基础数据 ============================ */
 
-/** 部门字典（仅作 Create/Edit 解析 deptName 之用，无维护入口——「应用设置」已下线） */
+/** 部门字典（仅作 V1 Detail/GetDetail 解析 DeptName 之用，「应用设置」已下线无维护入口） */
 const deptDict = [
     { SerID: 101, CodeID: "D001", Name: "语文教研组", Enable: 1 },
     { SerID: 102, CodeID: "D002", Name: "数学教研组", Enable: 1 },
@@ -25,14 +28,13 @@ const deptDict = [
     { SerID: 104, CodeID: "D004", Name: "理化生教研组", Enable: 1 },
     { SerID: 105, CodeID: "D005", Name: "政史地教研组", Enable: 1 },
     { SerID: 106, CodeID: "D006", Name: "综合实践组", Enable: 1 },
-    { SerID: 107, CodeID: "D007", Name: "体育教研组", Enable: 0 },
     { SerID: 108, CodeID: "D008", Name: "教务处（作业管理）", Enable: 1 },
 ];
 let nextFileId = 9001;
 
-/** 当前登录用户（发布教师） */
+/** 当前登录用户（教师视角） */
 const ME = { account: "zhd", name: "朱皓东" };
-/** 收件箱演示视角：所在班级 id（已读/未读按该班判定） */
+/** 学生演示视角所在班级 */
 const ME_CLASS = "1301";
 
 /** 年级 → 班级树（叶子=班级，带学生数） */
@@ -70,225 +72,315 @@ gradeClasses.forEach((g) =>
     g.classes.forEach((c) => (classMap[String(c.classId)] = { className: c.className, gradeName: g.gradeName, studentCount: c.studentCount }))
 );
 const ALL_CLASSES = Object.keys(classMap);
-/** 全校学生数（接收对象为「全部班级」时的应读人数） */
-const ALL_STUDENTS = ALL_CLASSES.reduce((s, id) => s + classMap[id].studentCount, 0);
 
-/**
- * 作业存储。classRead = 已读班级 id 列表（班级维度阅读统计）。
- * 无审批门控：仅草稿（hwStatus=draft）与定时未到点的作业不进入学生收件箱。
- */
-const homeworks = [
-    {
-        id: 1,
-        title: "初一·初二年级第 9 周各科作业汇总（教学检查配套）",
-        deptId: "D008",
-        deptName: "教务处（作业管理）",
-        publisherAccount: "zm",
-        publisherName: "周敏",
-        content:
-            "<p>各任课教师：</p><p>第 10 周期中教学检查将核查各班作业布置与批改情况，请于本周五前将本周各科作业单提交年级组长汇总。</p><p>作业量、批改反馈与订正要求见附件评分标准。</p>",
-        receiveList: "ALL",
-        classRead: ["1301", "1302", "1303", "1401"],
-        files: "9001,9002",
-        topmost: 1,
-        isPulled: 0,
-        smsFlag: 0,
-        timingSendTime: null,
-        createTime: "2026-09-01 10:35:00",
-    },
-    {
-        id: 2,
-        title: "初二语文《这样的人让我敬佩》写人记叙文（600 字）",
-        deptId: "D001",
-        deptName: "语文教研组",
-        publisherAccount: "lwj",
-        publisherName: "刘文娟",
-        content: "<p>请同学们完成一篇写人记叙文，题目《这样的人让我敬佩》。</p><p>要求：不少于 600 字，选取身边真实人物，通过具体事例表现其品质；周日前拍照上传至班级作业本，纸质稿交语文课代表。</p>",
-        receiveList: "ALL",
-        classRead: ["1401", "1402"],
-        files: null,
-        topmost: 0,
-        isPulled: 0,
-        smsFlag: 1,
-        timingSendTime: null,
-        createTime: "2026-09-03 14:22:00",
-    },
-    {
-        id: 3,
-        title: "初一数学·一元一次方程组应用题分层练（第 3 课时）",
-        deptId: "D002",
-        deptName: "数学教研组",
-        publisherAccount: "zhd",
-        publisherName: "朱皓东",
-        content: "<p>课后分 A、B 两层作业：A 组（基础）教材 P88 第 1–5 题；B 组（提高）配套练习第 6–9 题。</p><p>请按所在层次完成并写在作业本上，明天数学课随堂订正。</p>",
-        receiveList: "1301,1302",
-        classRead: [],
-        files: null,
-        topmost: 0,
-        isPulled: 0,
-        smsFlag: 0,
-        timingSendTime: null,
-        createTime: "2026-09-08 09:00:00",
-    },
-    {
-        id: 4,
-        title: "国庆假期数学作业（计算巩固 + 生活中的数学）",
-        deptId: "D002",
-        deptName: "数学教研组",
-        publisherAccount: "zhd",
-        publisherName: "朱皓东",
-        content: "<p>假期数学作业分两部分：①计算巩固——口算题卡 3 页；②实践探究——记录假期家庭一周开支并制成统计表。</p><p>已发布给全部班级，请于截止前提交，收假后第一节课查验。</p>",
-        receiveList: "ALL",
-        classRead: [],
-        files: null,
-        topmost: 0,
-        isPulled: 0,
-        smsFlag: 0,
-        timingSendTime: null,
-        createTime: "2026-09-05 16:40:00",
-    },
-    {
-        id: 5,
-        title: "初三英语·阅读理解与完形填空专项训练（附答题卡）",
-        deptId: "D003",
-        deptName: "英语教研组",
-        publisherAccount: "cy",
-        publisherName: "陈垠",
-        content: "<p>完成附件《阅读专项训练》Section A–B（6 篇阅读、2 篇完形），答案填写在答题卡上。</p><p>限时 40 分钟独立完成，周五前拍照上传答题卡。</p>",
-        receiveList: "ALL",
-        classRead: ["1301", "1302", "1501"],
-        files: "9003",
-        topmost: 0,
-        isPulled: 0,
-        smsFlag: 0,
-        timingSendTime: null,
-        createTime: "2026-09-06 11:05:00",
-    },
-    {
-        id: 6,
-        title: "初一道德与法治·时事观察手抄报",
-        deptId: "D005",
-        deptName: "政史地教研组",
-        publisherAccount: "why",
-        publisherName: "王海燕",
-        content: "<p>以《我家的十年变化》为主题采写一篇时事观察，制作一份 A3 手抄报。</p><p>要求标注数据来源或访谈对象，下周一课前交政史地办公室。</p>",
-        receiveList: "ALL",
-        classRead: ["1401", "1501"],
-        files: null,
-        topmost: 0,
-        isPulled: 0,
-        smsFlag: 0,
-        timingSendTime: null,
-        createTime: "2026-09-07 08:30:00",
-    },
-    {
-        id: 7,
-        title: "初二物理·凸透镜成像规律实验报告（含数据记录表）",
-        deptId: "D004",
-        deptName: "理化生教研组",
-        publisherAccount: "hy",
-        publisherName: "黄瑶",
-        content: "<p>按教材步骤完成凸透镜成像实验并撰写实验报告，附物距—像距对照表。</p><p>提交：数据记录表、成像规律结论、误差分析各一份，拍照上传或纸质交物理课代表。</p>",
-        receiveList: "ALL",
-        classRead: [],
-        files: null,
-        topmost: 0,
-        isPulled: 0,
-        smsFlag: 0,
-        timingSendTime: null,
-        createTime: "2026-09-09 10:10:00",
-    },
-    {
-        id: 8,
-        title: "初一数学·图形运动主题实践作业（待定稿）",
-        deptId: "D002",
-        deptName: "数学教研组",
-        publisherAccount: "zhd",
-        publisherName: "朱皓东",
-        content: "<p>利用平移、旋转与轴对称设计一幅图案，并标注所使用的变换方式。</p><p>（草拟中，暂未定稿）</p>",
-        receiveList: "ALL",
-        classRead: [],
-        files: null,
-        topmost: 0,
-        isPulled: 0,
-        smsFlag: 0,
-        timingSendTime: null,
-        createTime: "2026-09-08 15:20:00",
-    },
-];
-let homeworkSeq = 9;
-
-/* ===================== 课程作业扩展模型（v1 核心闭环：布置→提交→批改→统计） ===================== */
-
-/** 每份作业的“作业化”元数据（学科 / 截止 / 提交方式 / 流程状态），叠加到 homeworks 上 */
-const hwMeta: Record<number, { subject: string; deadline: string; submitType: string[]; hwStatus: string }> = {
-    1: { subject: "综合", deadline: "2026-09-12 18:00:00", submitType: ["none"], hwStatus: "collecting" },
-    2: { subject: "语文", deadline: "2026-09-07 18:00:00", submitType: ["text", "image"], hwStatus: "done" },
-    3: { subject: "数学", deadline: "2026-09-15 18:00:00", submitType: ["text"], hwStatus: "collecting" },
-    4: { subject: "数学", deadline: "2026-10-08 08:00:00", submitType: ["text", "image"], hwStatus: "collecting" },
-    5: { subject: "英语", deadline: "2026-09-12 18:00:00", submitType: ["image", "attach"], hwStatus: "closed" },
-    6: { subject: "道德与法治", deadline: "2026-09-15 18:00:00", submitType: ["image"], hwStatus: "closed" },
-    7: { subject: "物理", deadline: "2026-09-16 18:00:00", submitType: ["text", "image"], hwStatus: "collecting" },
-    8: { subject: "数学", deadline: "2026-09-18 18:00:00", submitType: ["image", "attach"], hwStatus: "draft" },
-};
-homeworks.forEach((n: any) => Object.assign(n, hwMeta[n.id] || { subject: "综合", deadline: null, submitType: ["text"], hwStatus: "collecting" }));
-
-/** 班级花名册：为每个班级生成稳定学生个体（id、姓名），用于提交/批改名单 */
+/** 班级花名册：稳定生成学生个体（studentId = classId*100+序号） */
 const SURNAMES = ["王", "李", "张", "刘", "陈", "杨", "赵", "黄", "周", "吴", "徐", "孙", "马", "朱", "胡", "郭", "何", "林", "高", "罗", "郑", "梁"];
 const GIVEN = ["伟", "芳", "娜", "敏", "静", "磊", "军", "洋", "勇", "艳", "杰", "涛", "明", "超", "霞", "平", "子轩", "梓涵", "浩然", "欣怡", "雨桐", "一鸣", "思远", "梦琪"];
 const roster: Record<string, { studentId: number; studentName: string }[]> = {};
-ALL_CLASSES.forEach((cid, ci) => {
-    const count = classMap[cid].studentCount;
-    const arr: { studentId: number; studentName: string }[] = [];
-    for (let i = 0; i < count; i++) {
-        arr.push({ studentId: Number(cid) * 100 + i + 1, studentName: SURNAMES[(ci * 7 + i) % SURNAMES.length] + GIVEN[(ci * 13 + i * 5) % GIVEN.length] });
-    }
-    roster[cid] = arr;
-});
+gradeClasses.forEach((g, ci) =>
+    g.classes.forEach((c) => {
+        const arr: { studentId: number; studentName: string }[] = [];
+        for (let i = 0; i < c.studentCount; i++) {
+            arr.push({ studentId: Number(c.classId) * 100 + i + 1, studentName: SURNAMES[(ci * 7 + i) % SURNAMES.length] + GIVEN[(ci * 13 + i * 5) % GIVEN.length] });
+        }
+        roster[String(c.classId)] = arr;
+    })
+);
+
+/** 演示学生：初一(1)班花名册第一名（王伟） */
+const DEMO_STUDENT = (() => {
+    const arr = roster[ME_CLASS] || [];
+    const s = arr[0] || { studentId: 130101, studentName: "演示学生" };
+    return { studentId: s.studentId, studentName: s.studentName, classId: ME_CLASS, className: classMap[ME_CLASS]?.className || "初一(1)班" };
+})();
 
 /** 确定性伪随机（同种子稳定，刷新不跳变） */
 function seededRand(seed: number) {
     const x = Math.sin(seed) * 10000;
     return x - Math.floor(x);
 }
-const GRADE_LEVELS = ["A", "B", "C"];
 
-/**
- * 提交记录（学生 × 作业）。按作业流程状态生成不同分布：
- *  draft（草稿）不生成；submitType 含 none（仅查阅）不收集提交。
- *  状态：unsubmitted 未交 / submitted 已交待批 / graded 已批改 / needRedo 待订正 / redone 已订正。
- */
+/** 附件存储（V2 附件按 fileId 关联；fileUrl 统一 /api/file/Preview?id=） */
+const filesStore: Record<number, { id: number; filename: string; fileTrueName: string; size: number }> = {
+    9001: { id: 9001, filename: "第 9 周各科作业汇总表.xlsx", fileTrueName: "第 9 周各科作业汇总表.xlsx", size: 57344 },
+    9002: { id: 9002, filename: "作业设计与批改评分标准.docx", fileTrueName: "作业设计与批改评分标准.docx", size: 122880 },
+    9003: { id: 9003, filename: "初三英语阅读专项-答题卡.pdf", fileTrueName: "初三英语阅读专项-答题卡.pdf", size: 819200 },
+};
+
+function fileToAttachment(id: number): any {
+    const f = filesStore[id] || { id, filename: `附件${id}.pdf`, fileTrueName: `附件${id}.pdf`, size: 0 };
+    return { fileId: id, fileUrl: `/api/file/Preview?id=${id}`, fileType: "file", fileName: f.fileTrueName, sort: 0 };
+}
+
+/* ============================ V2 存储（唯一数据源） ============================ */
+
+type V2Status = "DRAFT_UNPUBLISHED" | "DRAFT_SCHEDULED" | "PUBLISHED" | "CLOSED" | "ARCHIVED";
+type SubmitSt = "NOT_SUBMITTED" | "SUBMITTED" | "LATE_SUBMITTED" | "RETURNED" | "REVIEWED";
+type ReviewSt = "PENDING" | "REVIEWED" | "RETURNED";
+
+const HW_DESC: Record<string, string> = {
+    DRAFT_UNPUBLISHED: "未发布",
+    DRAFT_SCHEDULED: "定时待发",
+    PUBLISHED: "进行中",
+    CLOSED: "已截止",
+    ARCHIVED: "已归档",
+};
+const SUBMIT_DESC: Record<string, string> = {
+    NOT_SUBMITTED: "未提交",
+    SUBMITTED: "已提交",
+    LATE_SUBMITTED: "逾期补交",
+    RETURNED: "待订正",
+    REVIEWED: "已批阅",
+};
+const REVIEW_DESC: Record<string, string> = { PENDING: "待批阅", REVIEWED: "已批阅", RETURNED: "已打回" };
+
+/** 作业表（homework）。ALL 班级用 allClassIds 展开，与后端 homework_class 一致 */
+const homeworks: any[] = [
+    {
+        id: 1, title: "初一·初二年级第 9 周各科作业汇总（教学检查配套）", subject: "综合",
+        description: "<p>各任课教师：</p><p>第 10 周期中教学检查将核查各班作业布置与批改情况，请于本周五前将本周各科作业单提交年级组长汇总。</p><p>作业量、批改反馈与订正要求见附件评分标准。</p>",
+        hwStatus: "PUBLISHED", scheduledAt: null, publishedAt: "2026-09-01 10:35:00", deadlineAt: "2026-09-12 18:00:00", archivedAt: null,
+        submitType: ["none"], allowLate: 0, remind1d: 0, remind1h: 0,
+        classIds: [...ALL_CLASSES], attachments: [fileToAttachment(9001), fileToAttachment(9002)],
+        deptId: "D008", publisherAccount: "zm", publisherName: "周敏", createTime: "2026-09-01 10:35:00", updateTime: "2026-09-01 10:35:00",
+    },
+    {
+        id: 2, title: "初二语文《这样的人让我敬佩》写人记叙文（600 字）", subject: "语文",
+        description: "<p>请同学们完成一篇写人记叙文，题目《这样的人让我敬佩》。</p><p>要求：不少于 600 字，选取身边真实人物，通过具体事例表现其品质；周日前拍照上传至班级作业本，纸质稿交语文课代表。</p>",
+        hwStatus: "CLOSED", scheduledAt: null, publishedAt: "2026-09-03 14:22:00", deadlineAt: "2026-09-07 18:00:00", archivedAt: null,
+        submitType: ["text", "image"], allowLate: 0, remind1d: 1, remind1h: 0,
+        classIds: [...ALL_CLASSES], attachments: [],
+        deptId: "D001", publisherAccount: "lwj", publisherName: "刘文娟", createTime: "2026-09-03 14:22:00", updateTime: "2026-09-03 14:22:00",
+    },
+    {
+        id: 3, title: "初一数学·一元一次方程组应用题分层练（第 3 课时）", subject: "数学",
+        description: "<p>课后分 A、B 两层作业：A 组（基础）教材 P88 第 1–5 题；B 组（提高）配套练习第 6–9 题。</p><p>请按所在层次完成并写在作业本上，明天数学课随堂订正。</p>",
+        hwStatus: "PUBLISHED", scheduledAt: null, publishedAt: "2026-09-08 09:00:00", deadlineAt: "2026-09-15 18:00:00", archivedAt: null,
+        submitType: ["text"], allowLate: 0, remind1d: 1, remind1h: 1,
+        classIds: ["1301", "1302"], attachments: [],
+        deptId: "D002", publisherAccount: "zhd", publisherName: "朱皓东", createTime: "2026-09-08 09:00:00", updateTime: "2026-09-08 09:00:00",
+    },
+    {
+        id: 4, title: "国庆假期数学作业（计算巩固 + 生活中的数学）", subject: "数学",
+        description: "<p>假期数学作业分两部分：①计算巩固——口算题卡 3 页；②实践探究——记录假期家庭一周开支并制成统计表。</p><p>已发布给全部班级，请于截止前提交，收假后第一节课查验。</p>",
+        hwStatus: "PUBLISHED", scheduledAt: null, publishedAt: "2026-09-05 16:40:00", deadlineAt: "2026-10-08 08:00:00", archivedAt: null,
+        submitType: ["text", "image"], allowLate: 1, remind1d: 1, remind1h: 0,
+        classIds: [...ALL_CLASSES], attachments: [],
+        deptId: "D002", publisherAccount: "zhd", publisherName: "朱皓东", createTime: "2026-09-05 16:40:00", updateTime: "2026-09-05 16:40:00",
+    },
+    {
+        id: 5, title: "初三英语·阅读理解与完形填空专项训练（附答题卡）", subject: "英语",
+        description: "<p>完成附件《阅读专项训练》Section A–B（6 篇阅读、2 篇完形），答案填写在答题卡上。</p><p>限时 40 分钟独立完成，周五前拍照上传答题卡。</p>",
+        hwStatus: "CLOSED", scheduledAt: null, publishedAt: "2026-09-06 11:05:00", deadlineAt: "2026-09-12 18:00:00", archivedAt: null,
+        submitType: ["image", "attach"], allowLate: 0, remind1d: 0, remind1h: 0,
+        classIds: [...ALL_CLASSES], attachments: [fileToAttachment(9003)],
+        deptId: "D003", publisherAccount: "cy", publisherName: "陈垠", createTime: "2026-09-06 11:05:00", updateTime: "2026-09-06 11:05:00",
+    },
+    {
+        id: 6, title: "初一道德与法治·时事观察手抄报", subject: "道德与法治",
+        description: "<p>以《我家的十年变化》为主题采写一篇时事观察，制作一份 A3 手抄报。</p><p>要求标注数据来源或访谈对象，下周一课前交政史地办公室。</p>",
+        hwStatus: "CLOSED", scheduledAt: null, publishedAt: "2026-09-07 08:30:00", deadlineAt: "2026-09-15 18:00:00", archivedAt: null,
+        submitType: ["image"], allowLate: 0, remind1d: 0, remind1h: 0,
+        classIds: [...ALL_CLASSES], attachments: [],
+        deptId: "D005", publisherAccount: "why", publisherName: "王海燕", createTime: "2026-09-07 08:30:00", updateTime: "2026-09-07 08:30:00",
+    },
+    {
+        id: 7, title: "初二物理·凸透镜成像规律实验报告（含数据记录表）", subject: "物理",
+        description: "<p>按教材步骤完成凸透镜成像实验并撰写实验报告，附物距—像距对照表。</p><p>提交：数据记录表、成像规律结论、误差分析各一份，拍照上传或纸质交物理课代表。</p>",
+        hwStatus: "PUBLISHED", scheduledAt: null, publishedAt: "2026-09-09 10:10:00", deadlineAt: "2026-09-16 18:00:00", archivedAt: null,
+        submitType: ["text", "image"], allowLate: 0, remind1d: 1, remind1h: 1,
+        classIds: [...ALL_CLASSES], attachments: [],
+        deptId: "D004", publisherAccount: "hy", publisherName: "黄瑶", createTime: "2026-09-09 10:10:00", updateTime: "2026-09-09 10:10:00",
+    },
+    {
+        id: 8, title: "初一数学·图形运动主题实践作业（待定稿）", subject: "数学",
+        description: "<p>利用平移、旋转与轴对称设计一幅图案，并标注所使用的变换方式。</p><p>（草拟中，暂未定稿）</p>",
+        hwStatus: "DRAFT_UNPUBLISHED", scheduledAt: null, publishedAt: null, deadlineAt: "2026-09-18 18:00:00", archivedAt: null,
+        submitType: ["image", "attach"], allowLate: 0, remind1d: 0, remind1h: 0,
+        classIds: [...ALL_CLASSES], attachments: [],
+        deptId: "D002", publisherAccount: "zhd", publisherName: "朱皓东", createTime: "2026-09-08 15:20:00", updateTime: "2026-09-08 15:20:00",
+    },
+    {
+        id: 9, title: "初一数学·有理数混合运算限时练（定时发布）", subject: "数学",
+        description: "<p>课堂限时 15 分钟完成有理数混合运算 20 题，下课后拍照上传答题纸。</p>",
+        hwStatus: "DRAFT_SCHEDULED", scheduledAt: "2026-09-20 08:00:00", publishedAt: null, deadlineAt: "2026-09-21 18:00:00", archivedAt: null,
+        submitType: ["image"], allowLate: 0, remind1d: 0, remind1h: 0,
+        classIds: ["1301", "1302"], attachments: [],
+        deptId: "D002", publisherAccount: "zhd", publisherName: "朱皓东", createTime: "2026-09-14 09:00:00", updateTime: "2026-09-14 09:00:00",
+    },
+    {
+        id: 10, title: "初三英语·Unit1 词汇默写（已归档）", subject: "英语",
+        description: "<p>默写 Unit1 重点词汇与短语，订正三遍。</p>",
+        hwStatus: "ARCHIVED", scheduledAt: null, publishedAt: "2026-08-28 09:00:00", deadlineAt: "2026-08-30 18:00:00", archivedAt: "2026-09-02 10:00:00",
+        submitType: ["image"], allowLate: 0, remind1d: 0, remind1h: 0,
+        classIds: ["1501", "1502"], attachments: [],
+        deptId: "D003", publisherAccount: "cy", publisherName: "陈垠", createTime: "2026-08-28 09:00:00", updateTime: "2026-09-02 10:00:00",
+    },
+    {
+        id: 11, title: "初一数学·有理数运算随堂练（第 2 课时）", subject: "数学",
+        description: "<p>完成随堂练习第 1–8 题，写在练习本上，拍照上传。</p>",
+        hwStatus: "PUBLISHED", scheduledAt: null, publishedAt: "2026-09-15 10:00:00", deadlineAt: "2026-09-17 18:00:00", archivedAt: null,
+        submitType: ["text", "image"], allowLate: 0, remind1d: 1, remind1h: 0,
+        classIds: ["1301"], attachments: [],
+        deptId: "D002", publisherAccount: "zhd", publisherName: "朱皓东", createTime: "2026-09-15 10:00:00", updateTime: "2026-09-15 10:00:00",
+    },
+    {
+        id: 12, title: "初一数学·开学摸底卷讲评订正", subject: "数学",
+        description: "<p>对照讲评课件订正摸底卷错题，错因写在题旁，完成后整卷拍照上传。</p>",
+        hwStatus: "CLOSED", scheduledAt: null, publishedAt: "2026-09-02 09:00:00", deadlineAt: "2026-09-05 18:00:00", archivedAt: null,
+        submitType: ["image"], allowLate: 1, remind1d: 0, remind1h: 0,
+        classIds: ["1301", "1302", "1303"], attachments: [],
+        deptId: "D002", publisherAccount: "zhd", publisherName: "朱皓东", createTime: "2026-09-02 09:00:00", updateTime: "2026-09-02 09:00:00",
+    },
+];
+let homeworkSeq = 13;
+
+/** 提交表（homework_submission）：version 递增，isLatest 标当前 */
 const submissions: any[] = [];
 let subSeq = 1;
-homeworks.forEach((n: any) => {
-    if (n.hwStatus === "draft") return;
+/** 阅读表（homework_read_record）：hwId → studentId → {firstReadAt,lastReadAt} */
+const reads: Record<number, Record<number, { firstReadAt: string; lastReadAt: string }>> = {};
+
+/** 某作业的全部矩阵行（含未交占位）：studentId → 行 */
+function genMatrix(n: any): any[] {
+    const rows: any[] = [];
+    (n.classIds || []).forEach((cid: string) =>
+        (roster[cid] || []).forEach((stu) => {
+            const read = reads[n.id]?.[stu.studentId];
+            const subs = submissions.filter((s) => s.homeworkId === n.id && s.studentId === stu.studentId && s.isLatest === 1);
+            const cur = subs[0] || null;
+            rows.push({
+                submissionId: cur ? cur.id : 0,
+                studentId: String(stu.studentId),
+                studentName: stu.studentName,
+                classId: cid,
+                className: classMap[cid]?.className || cid,
+                isRead: read ? 1 : 0,
+                firstReadAt: read ? read.firstReadAt : null,
+                lastReadAt: read ? read.lastReadAt : null,
+                submitStatus: cur ? cur.submitStatus : "NOT_SUBMITTED",
+                submittedAt: cur ? cur.submittedAt : null,
+                isLate: cur ? cur.isLate : 0,
+                reviewStatus: cur ? cur.reviewStatus : "PENDING",
+                score: cur ? cur.score : null,
+                thumbnails: cur ? (cur.attachments || []).filter((a: any) => (a.fileType || "").toLowerCase() === "image").map((a: any) => a.fileUrl) : [],
+            });
+        })
+    );
+    return rows;
+}
+
+/** V2 进度聚合（应交 = 参与班级学生数；打回未重交计入已交） */
+function progressV2(n: any, classIds?: string[]): any {
+    const scope = classIds && classIds.length ? classIds : n.classIds || [];
+    const rows = genMatrix(n).filter((r) => scope.includes(r.classId));
+    const should = rows.length;
+    const read = rows.filter((r) => r.isRead === 1).length;
+    const submittedRows = rows.filter((r) => r.submitStatus !== "NOT_SUBMITTED");
+    const submitted = submittedRows.length;
+    const graded = rows.filter((r) => r.submitStatus === "REVIEWED").length;
+    const pendingGrade = rows.filter((r) => r.submitStatus === "SUBMITTED" || r.submitStatus === "LATE_SUBMITTED").length;
+    const unsubmitted = should - submitted;
+    const unread = should - read;
+    const pct = (a: number, b: number) => (b ? Number(((a / b) * 100).toFixed(1)) : 0);
+    return {
+        should, read, submitted, graded, pendingGrade, unsubmitted, unread,
+        unreadUndone: rows.filter((r) => r.isRead === 0 && r.submitStatus === "NOT_SUBMITTED").length,
+        readRate: pct(read, should),
+        submitRate: pct(submitted, should),
+        gradeRate: pct(graded, submitted),
+    };
+}
+
+/** V2 列表/详情 VO */
+function toV2Vo(n: any, withProgress: boolean): any {
+    return {
+        id: n.id,
+        title: n.title,
+        subject: n.subject,
+        description: n.description,
+        hwStatus: n.hwStatus,
+        hwStatusDesc: HW_DESC[n.hwStatus] || n.hwStatus,
+        scheduledAt: n.scheduledAt,
+        publishedAt: n.publishedAt,
+        deadlineAt: n.deadlineAt,
+        archivedAt: n.archivedAt,
+        submitType: n.submitType,
+        allowLate: n.allowLate,
+        remind1d: n.remind1d,
+        remind1h: n.remind1h,
+        classes: (n.classIds || []).map((id: string) => ({ classId: id, className: classMap[id]?.className || id })),
+        attachments: n.attachments || [],
+        publisherId: n.publisherAccount,
+        publisherName: n.publisherName,
+        createTime: n.createTime,
+        updateTime: n.updateTime,
+        progress: withProgress && !isDraft(n) ? progressV2(n) : null,
+    };
+}
+function isDraft(n: any): boolean {
+    return n.hwStatus === "DRAFT_UNPUBLISHED" || n.hwStatus === "DRAFT_SCHEDULED";
+}
+function deadlinePassed(n: any): boolean {
+    return !!(n.deadlineAt && n.deadlineAt < nowStr());
+}
+
+/* ============================ 种子生成 ============================ */
+
+/** 阅读与提交种子：非草稿作业按确定性伪随机铺数据 */
+homeworks.forEach((n) => {
+    if (isDraft(n)) return;
     const viewOnly = (n.submitType || []).includes("none");
-    targetClassIds(n).forEach((cid) => {
+    reads[n.id] = {};
+    (n.classIds || []).forEach((cid: string) => {
         (roster[cid] || []).forEach((stu) => {
             const r = seededRand(n.id * 1000 + stu.studentId);
-            const submitted = !viewOnly && r < (n.hwStatus === "collecting" ? 0.62 : 0.9);
-            // 已读：交了的必然读过；未交的按更高概率“读了没交”。仅查阅只统计已读。
-            const read = viewOnly ? r < 0.85 : submitted || r < 0.9;
-            let submitStatus = "unsubmitted";
-            let submittedAt: string | null = null;
-            let grade: any = null;
-            if (submitted) {
-                const day = Math.min(1 + Math.floor(r * 7), 28);
-                submittedAt = `${String(n.createTime).slice(0, 8)}${String(day).padStart(2, "0")} ${8 + Math.floor(r * 12)}:${String(Math.floor(r * 60)).padStart(2, "0")}:00`;
-                if (n.hwStatus === "done") submitStatus = r < 0.85 ? "graded" : r < 0.93 ? "redone" : "needRedo";
-                else if (n.hwStatus === "closed") submitStatus = r < 0.5 ? "graded" : r < 0.82 ? "submitted" : "needRedo";
-                else submitStatus = r < 0.35 ? "graded" : "submitted";
-                if (submitStatus === "graded" || submitStatus === "redone" || submitStatus === "needRedo") {
-                    const sr = seededRand(stu.studentId * 3 + n.id);
-                    grade = {
-                        score: 60 + Math.floor(sr * 41),
-                        level: GRADE_LEVELS[Math.floor(sr * 3)],
-                        comment: sr > 0.8 ? "完成很好，注意书写规范" : sr > 0.5 ? "思路正确，个别步骤需订正" : "第 3、5 题有误，订正后重交",
-                        isExcellent: sr > 0.93,
-                        markedImages: [],
-                    };
+            // 阅读：仅查阅型 85%，其余 88%
+            if (r < (viewOnly ? 0.85 : 0.88)) {
+                const day = Math.min(1 + Math.floor(r * 6), 28);
+                reads[n.id][stu.studentId] = {
+                    firstReadAt: `${String(n.createTime).slice(0, 8)}${String(day).padStart(2, "0")} ${8 + Math.floor(r * 12)}:${String(Math.floor(r * 60)).padStart(2, "0")}:00`,
+                    lastReadAt: `${String(n.createTime).slice(0, 8)}${String(day).padStart(2, "0")} 19:${String(Math.floor(r * 60)).padStart(2, "0")}:00`,
+                };
+            }
+            if (viewOnly) return; // 仅查阅不收集提交
+            // 提交分布：进行中 62%，已截止 90%
+            const submitted = r < (n.hwStatus === "PUBLISHED" ? 0.62 : 0.9);
+            if (!submitted) return;
+            const sr = seededRand(stu.studentId * 3 + n.id);
+            let submitStatus: SubmitSt = "SUBMITTED";
+            let reviewStatus: ReviewSt = "PENDING";
+            let score: number | null = null;
+            let comment: string | null = null;
+            if (n.hwStatus === "PUBLISHED") {
+                if (sr < 0.35) {
+                    submitStatus = "REVIEWED";
+                    reviewStatus = "REVIEWED";
+                }
+            } else {
+                // 已截止/归档：一半已批、部分逾期补交、少数被打回
+                if (sr < 0.5) {
+                    submitStatus = "REVIEWED";
+                    reviewStatus = "REVIEWED";
+                } else if (sr < 0.78) {
+                    submitStatus = "SUBMITTED";
+                } else if (sr < 0.9) {
+                    submitStatus = "LATE_SUBMITTED";
+                } else {
+                    submitStatus = "RETURNED";
+                    reviewStatus = "RETURNED";
                 }
             }
+            if (reviewStatus === "REVIEWED") {
+                score = 60 + Math.floor(sr * 41);
+                comment = sr > 0.8 ? "完成很好，注意书写规范" : sr > 0.5 ? "思路正确，个别步骤需订正" : "部分题目有误，注意复核";
+            }
+            if (reviewStatus === "RETURNED") comment = "第 3、5 题有误，订正后重交";
+            const late = submitStatus === "LATE_SUBMITTED" ? 1 : 0;
+            const day = Math.min(1 + Math.floor(r * 7), 28);
+            const atts: any[] = [];
+            if ((n.submitType || []).includes("image")) atts.push({ fileUrl: mockImageDataURL(stu.studentId), fileType: "image", fileName: `作答${stu.studentId}.png`, sort: 0 });
+            if ((n.submitType || []).includes("attach")) atts.push(fileToAttachment(9000 + (stu.studentId % 3)));
             submissions.push({
                 id: subSeq++,
                 homeworkId: n.id,
@@ -296,125 +388,74 @@ homeworks.forEach((n: any) => {
                 studentName: stu.studentName,
                 classId: cid,
                 className: classMap[cid]?.className || cid,
-                read,
-                submittedAt,
+                version: 1,
+                isLatest: 1,
                 submitStatus,
-                text: submitted ? "（学生作答内容 · mock）" : "",
-                images: submitted && (n.submitType || []).includes("image") ? [mockImageDataURL(stu.studentId)] : [],
-                attachments: submitted && (n.submitType || []).includes("attach") ? [] : [],
-                grade,
+                isLate: late,
+                submittedAt: `${String(n.createTime).slice(0, 8)}${String(day).padStart(2, "0")} ${8 + Math.floor(r * 12)}:${String(Math.floor(r * 60)).padStart(2, "0")}:00`,
+                text: (n.submitType || []).includes("text") ? "（学生作答内容 · mock）" : null,
+                attachments: atts,
+                score,
+                comment,
+                reviewStatus,
+                reviewedBy: reviewStatus === "PENDING" ? null : n.publisherName,
+                reviewedAt: reviewStatus === "PENDING" ? null : "2026-09-15 12:00:00",
             });
         });
     });
 });
 
-const GRADED_SET = ["graded", "redone", "needRedo"];
-function subsOf(homeworkId: number) {
-    return submissions.filter((s) => s.homeworkId === homeworkId);
-}
-/** 提交/批改派生统计（应交/已交/已批/待批/待订正/已订正/未交 + 提交率/批改率） */
-function progressOf(homeworkId: number) {
-    const list = subsOf(homeworkId);
-    const should = list.length;
-    const submitted = list.filter((s) => s.submitStatus !== "unsubmitted").length;
-    const graded = list.filter((s) => GRADED_SET.includes(s.submitStatus)).length;
-    const needRedo = list.filter((s) => s.submitStatus === "needRedo").length;
-    const redone = list.filter((s) => s.submitStatus === "redone").length;
-    const read = list.filter((s) => s.read).length;
-    return {
-        should,
-        submitted,
-        graded,
-        pendingGrade: submitted - graded,
-        needRedo,
-        redone,
-        unsubmitted: should - submitted,
-        read,
-        unread: should - read,
-        submitRate: should ? Number(((submitted / should) * 100).toFixed(1)) : 0,
-        gradeRate: submitted ? Number(((graded / submitted) * 100).toFixed(1)) : 0,
-    };
-}
-
-/* ============ 多角色视角（v2 学生端；家长即登录学生账号，端分离：SetRole 入口切换） ============ */
-type Role = "teacher" | "student";
-let viewerRole: Role = "teacher";
-/** 演示学生：取 ME_CLASS（初一(1)班）花名册第一名 */
-const DEMO_STUDENT = (() => {
-    const arr = roster[ME_CLASS] || [];
-    const s = arr[0] || { studentId: 130101, studentName: "演示学生" };
-    return { studentId: s.studentId, studentName: s.studentName, classId: ME_CLASS, className: classMap[ME_CLASS]?.className || "初一(1)班" };
-})();
-function setViewerRole(r: any): Role {
-    viewerRole = r === "student" ? "student" : "teacher";
-    return viewerRole;
-}
-/** 当前学生视角可见作业（已发布、面向本班、非未来定时、非草稿），附本人提交/批改态 */
-function viewerHomeworks() {
+/** 演示学生的定制状态：覆盖种子，保证各 tab/状态可演示 */
+(function seedDemoStudent() {
+    const sid = DEMO_STUDENT.studentId;
     const cid = String(DEMO_STUDENT.classId);
-    return homeworks
-        .filter((n: any) => isPublished(n) && !n.isPulled && n.hwStatus !== "draft" && !isScheduledFuture(n) && (isAllTarget(n) || targetClassIds(n).includes(cid)))
-        .sort((a: any, b: any) => ((a.deadline || "9") < (b.deadline || "9") ? -1 : 1))
-        .map((n: any) => {
-            const mine = submissions.find((s) => s.homeworkId === n.id && s.studentId === DEMO_STUDENT.studentId) || null;
-            return {
-                id: n.id,
-                title: n.title,
-                subject: n.subject || "",
-                publisherName: n.publisherName,
-                deptName: n.deptName,
-                deadline: n.deadline || null,
-                createTime: n.createTime,
-                content: n.content,
-                submitType: n.submitType || ["text"],
-                viewOnly: (n.submitType || []).includes("none"),
-                hwStatus: n.hwStatus || "collecting",
-                allowLate: !!n.allowLate,
-                my: mine
-                    ? {
-                          subId: mine.id,
-                          submitStatus: mine.submitStatus,
-                          submittedAt: mine.submittedAt,
-                          text: mine.text,
-                          images: mine.images || [],
-                          attachments: mine.attachments || [],
-                          score: mine.grade ? mine.grade.score : null,
-                          level: mine.grade ? mine.grade.level : null,
-                          comment: mine.grade ? mine.grade.comment : "",
-                          isExcellent: !!(mine.grade && mine.grade.isExcellent),
-                      }
-                    : null,
-            };
+    const clear = (hwId: number) => {
+        const i = submissions.findIndex((s) => s.homeworkId === hwId && s.studentId === sid);
+        if (i > -1) submissions.splice(i, 1);
+    };
+    const put = (hwId: number, over: any) => {
+        clear(hwId);
+        const n = homeworks.find((h) => h.id === hwId);
+        submissions.push({
+            id: subSeq++, homeworkId: hwId, studentId: sid, studentName: DEMO_STUDENT.studentName, classId: cid,
+            className: DEMO_STUDENT.className, version: 1, isLatest: 1, submitStatus: "SUBMITTED", isLate: 0,
+            submittedAt: "2026-09-14 20:30:00", text: "（演示学生作答 · mock）",
+            attachments: (n && (n.submitType || []).includes("image")) ? [{ fileUrl: mockImageDataURL(sid), fileType: "image", fileName: "我的作答.png", sort: 0 }] : [],
+            score: null, comment: null, reviewStatus: "PENDING", reviewedBy: null, reviewedAt: null,
+            ...over,
         });
-}
-/** 学生视角分组计数：todo 待完成 / submitted 已交待批 / graded 已批改 / redo 待订正 */
-function viewerBuckets(list: any[]) {
-    const b = { todo: 0, submitted: 0, graded: 0, redo: 0, all: list.length };
-    list.forEach((x) => {
-        if (x.viewOnly) return;
-        const st = x.my ? x.my.submitStatus : "unsubmitted";
-        if (st === "unsubmitted") b.todo++;
-        else if (st === "submitted") b.submitted++;
-        else if (st === "needRedo") b.redo++;
-        else b.graded++;
-    });
-    return b;
-}
+    };
+    // hw2 语文（已截止·已批阅 92 分）
+    put(2, { submitStatus: "REVIEWED", reviewStatus: "REVIEWED", score: 92, comment: "描写生动，结构完整，注意分段。", reviewedBy: "刘文娟", reviewedAt: "2026-09-08 10:00:00" });
+    // hw3 数学（进行中·已交待批）
+    put(3, {});
+    // hw5 英语（已截止·未交，演示逾期分流）
+    clear(5);
+    // hw6 道法（已截止·被打回，演示待订正）
+    put(6, { submitStatus: "RETURNED", reviewStatus: "RETURNED", comment: "主题不够聚焦，请围绕“十年变化”补一 组对比数据后重交。", reviewedBy: "王海燕", reviewedAt: "2026-09-15 09:30:00" });
+    // hw4 国庆 / hw7 物理 / hw11 数学随堂：未交（待完成）
+    [4, 7, 11].forEach(clear);
+    // hw12 数学订正（已截止·已批阅 + 允许补交演示）——两版本：v1 已批 85，v2 逾期补交待批
+    put(12, { version: 2, submitStatus: "LATE_SUBMITTED", isLate: 1, submittedAt: "2026-09-06 08:10:00" });
+    const v1 = submissions.find((s) => s.homeworkId === 12 && s.studentId === sid && s.version === 2);
+    if (v1) {
+        submissions.push({
+            ...v1, id: subSeq++, version: 1, isLatest: 0, submitStatus: "REVIEWED", isLate: 0,
+            submittedAt: "2026-09-04 19:00:00", score: 85, comment: "订正认真，第 5 题过程仍少一步。", reviewStatus: "REVIEWED", reviewedBy: "朱皓东", reviewedAt: "2026-09-05 12:00:00",
+        });
+    }
+})();
 
-/** 附件存储 */
-const filesStore: Record<number, { id: number; filename: string; fileTrueName: string; size: number }> = {
-    9001: { id: 9001, filename: "第 9 周各科作业汇总表.xlsx", fileTrueName: "第 9 周各科作业汇总表.xlsx", size: 57344 },
-    9002: { id: 9002, filename: "作业设计与批改评分标准.docx", fileTrueName: "作业设计与批改评分标准.docx", size: 122880 },
-    9003: { id: 9003, filename: "初三英语阅读专项-答题卡.pdf", fileTrueName: "初三英语阅读专项-答题卡.pdf", size: 819200 },
-};
+/* ============================ 通知 ============================ */
 
-/** 年级班级树（ztree 结构，供选班级弹窗使用；叶子带 studentCount） */
-const classTree = gradeClasses.map((g) => ({
-    id: g.gradeId,
-    name: g.gradeName,
-    isParent: true,
-    children: g.classes.map((c) => ({ id: c.classId, name: c.className, isParent: false, studentCount: c.studentCount })),
-}));
+const notifications = [
+    { id: 1, receiverRole: "teacher", type: "SCHEDULE_FAILED", typeDesc: "定时发布失败", title: "定时发布失败：有理数混合运算限时练", content: "定时时间已过但作业仍未发布，请手动处理", homeworkId: 9, relatedId: 9, isRead: 0, readAt: null, createTime: "2026-09-15 08:05:00" },
+    { id: 2, receiverRole: "teacher", type: "DEADLINE_CHANGED", typeDesc: "截止时间变更", title: "国庆假期数学作业已延长截止", content: "你已将截止时间延长至 2026-10-09 08:00", homeworkId: 4, relatedId: 4, isRead: 1, readAt: "2026-09-14 10:00:00", createTime: "2026-09-14 09:55:00" },
+    { id: 3, receiverRole: "student", type: "HOMEWORK_PUBLISHED", typeDesc: "新作业", title: "新作业：有理数运算随堂练（第 2 课时）", content: "朱皓东 发布了数学作业，截止 09-17 18:00", homeworkId: 11, relatedId: 11, isRead: 0, readAt: null, createTime: "2026-09-15 10:01:00" },
+    { id: 4, receiverRole: "student", type: "HOMEWORK_PUBLISHED", typeDesc: "新作业", title: "新作业：一元一次方程组应用题分层练", content: "朱皓东 发布了数学作业，截止 09-15 18:00", homeworkId: 3, relatedId: 3, isRead: 1, readAt: "2026-09-13 08:00:00", createTime: "2026-09-08 09:01:00" },
+    { id: 5, receiverRole: "student", type: "REVIEW_DONE", typeDesc: "批阅完成", title: "批阅完成：《这样的人让我敬佩》", content: "刘文娟 批阅了你的作业：92 分", homeworkId: 2, relatedId: 2, isRead: 0, readAt: null, createTime: "2026-09-08 10:05:00" },
+    { id: 6, receiverRole: "student", type: "RETURNED", typeDesc: "作业被打回", title: "需订正：时事观察手抄报", content: "王海燕 打回了你的作业，请订正后重交", homeworkId: 6, relatedId: 6, isRead: 0, readAt: null, createTime: "2026-09-15 09:31:00" },
+];
 
 /* ============================ 工具 ============================ */
 
@@ -424,13 +465,11 @@ function ok(data: any) {
 function fail(msg: string, code = 4) {
     return { code, msg, data: null };
 }
-
 function paginate(content: any[], pageIndex: number, pageSize: number) {
     const start = (pageIndex - 1) * pageSize;
     const totalPages = pageSize ? Math.ceil(content.length / pageSize) : 0;
     return { content: content.slice(start, start + pageSize), total: content.length, pageIndex, pageSize, totalPages, hasNext: pageIndex < totalPages };
 }
-
 function parseBody(body: any): any {
     if (body == null) return {};
     if (typeof body === "object") return body;
@@ -447,152 +486,131 @@ function parseBody(body: any): any {
     new URLSearchParams(str).forEach((v, k) => (out[k] = v));
     return out;
 }
-
-/** 合并取参：query（postForm 已把参数拼入 URL）优先兜底 + JSON body（Create/Edit/Delete） */
+/** 合并取参：JSON body 优先，query 兜底 */
 function bodyOf(rawBody: any, query: any): any {
     const parsed = parseBody(rawBody);
-    if (Array.isArray(parsed)) return parsed; // Delete 传 id 数组
+    if (Array.isArray(parsed)) return parsed;
     return { ...(query || {}), ...(parsed || {}) };
 }
-
-/** 接收班级 id 数组（"ALL" → 全部班级） */
-function targetClassIds(n: any): string[] {
-    return /^all$/i.test(String(n.receiveList).trim()) ? ALL_CLASSES : String(n.receiveList).split(",").map((s) => s.trim()).filter(Boolean);
-}
-function isAllTarget(n: any): boolean {
-    return /^all$/i.test(String(n.receiveList).trim());
-}
-function allowCountOf(n: any): number {
-    if (isAllTarget(n)) return ALL_STUDENTS;
-    return targetClassIds(n).reduce((s, id) => s + (classMap[id]?.studentCount || 0), 0);
-}
-function readCountOf(n: any): number {
-    const targets = targetClassIds(n);
-    return (n.classRead || []).filter((id: string) => targets.includes(id)).reduce((s, id) => s + (classMap[id]?.studentCount || 0), 0);
-}
-/** 收件箱视角：本班是否已读 */
-function isReadByMe(n: any): boolean {
-    return (n.classRead || []).includes(ME_CLASS);
-}
-/** 是否已发布（对学生可见）：非草稿即可见（课程作业无送审环节） */
-function isPublished(n: any): boolean {
-    return n.hwStatus !== "draft";
-}
-/** 定时未到的作业，收件箱不展示 */
-function isScheduledFuture(n: any): boolean {
-    return !!(n.timingSendTime && n.timingSendTime > "2026-09-10");
-}
-
-const HW_STATUS_DESC: Record<string, string> = { draft: "草稿", collecting: "收集中", closed: "已截止", done: "已完成" };
-
-function toVo(n: any) {
-    return {
-        id: n.id,
-        title: n.title,
-        content: n.content,
-        type: 0,
-        typeDesc: "课程作业",
-        subject: n.subject || "",
-        deadline: n.deadline || null,
-        submitType: n.submitType || ["text"],
-        hwStatus: n.hwStatus || "collecting",
-        hwStatusDesc: HW_STATUS_DESC[n.hwStatus] || "收集中",
-        progress: n.hwStatus === "draft" ? null : progressOf(n.id),
-        receiveText: receiveText(n),
-        classCount: isAllTarget(n) ? ALL_CLASSES.length : targetClassIds(n).length,
-        publisherAccount: n.publisherAccount,
-        publisherName: n.publisherName,
-        deptId: n.deptId,
-        deptName: n.deptName,
-        status: isReadByMe(n) ? 2 : 1,
-        statusDesc: isReadByMe(n) ? "已读" : "未读",
-        topmost: n.topmost,
-        readCount: readCountOf(n),
-        allowCount: allowCountOf(n),
-        read: isReadByMe(n),
-        isPulled: n.isPulled,
-        timingSendTime: n.timingSendTime,
-        parentId: null,
-        smsFlag: n.smsFlag,
-        receiveType: "class",
-        receiveList: n.receiveList,
-        createBy: n.publisherAccount,
-        createTime: n.createTime,
-        updateBy: n.publisherAccount,
-        updateTime: n.createTime,
-        UpFile: n.files,
-    };
-}
-
-/** 接收对象可读文本：全部班级 / 班级名顿号串 */
-function receiveText(n: any): string {
-    if (isAllTarget(n)) return "全部班级";
-    return targetClassIds(n)
-        .map((id) => classMap[id]?.className || id)
-        .join("、");
-}
-
-function toDetail(n: any) {
-    return {
-        serid: n.id,
-        title: n.title,
-        Contents: n.content,
-        DeptID: n.deptId,
-        DeptName: n.deptName,
-        TeaName: n.publisherName,
-        EditDate: n.createTime,
-        numcount: allowCountOf(n),
-        readnumcount: readCountOf(n),
-        ReceiveList: n.receiveList,
-        receiveType: "class",
-        receiveText: receiveText(n),
-        subject: n.subject || "",
-        deadline: n.deadline || null,
-        submitType: n.submitType || ["text"],
-        hwStatus: n.hwStatus || "collecting",
-        hwStatusDesc: HW_STATUS_DESC[n.hwStatus] || "收集中",
-        progress: n.hwStatus === "draft" ? null : progressOf(n.id),
-        DsfsTime: n.timingSendTime,
-        isDsfs: !!n.timingSendTime,
-        ChaoSend: (n.files ? String(n.files).split(",") : []).map((id: string) => {
-            const f = filesStore[Number(id)];
-            return f
-                ? { id: f.id, name: f.fileTrueName, size: f.size, fileid: f.id, filename: f.filename }
-                : { id: Number(id), name: "附件", size: 0, fileid: Number(id), filename: "附件" };
-        }),
-        tlist: isAllTarget(n) ? "all" : targetClassIds(n),
-    };
-}
-
-function sortByTimeDesc(list: any[]) {
-    return [...list].sort((a, b) => (a.createTime < b.createTime ? 1 : a.createTime > b.createTime ? -1 : 0));
-}
-
-function applyFilters(list: any[], query: any) {
-    let out = [...list];
-    const kw = query.keyword || query.Name;
-    if (kw) out = out.filter((n) => n.title.includes(kw) || n.publisherName.includes(kw) || n.deptName.includes(kw));
-    const dept = query.deptId || query.Depttype;
-    if (dept) out = out.filter((n) => n.deptId === dept);
-    if (query.subject) out = out.filter((n) => (n.subject || "") === query.subject);
-    if (query.hwStatus && query.hwStatus !== "all") out = out.filter((n) => (n.hwStatus || "collecting") === query.hwStatus);
-    const st = query.startTime || query.starttime;
-    const et = query.endTime || query.endtime;
-    if (st) out = out.filter((n) => n.createTime.slice(0, 10) >= String(st).slice(0, 10));
-    if (et) out = out.filter((n) => n.createTime.slice(0, 10) <= String(et).slice(0, 10));
-    return out;
-}
-
 function nowStr() {
     const now = new Date();
     const pad = (n: number) => String(n).padStart(2, "0");
     return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
 }
+function isOwned(n: any): boolean {
+    return n.publisherAccount === ME.account;
+}
+function requireHw(id: number): any | null {
+    return homeworks.find((x) => x.id === id) || null;
+}
+function latestOf(hwId: number, studentId: number): any | null {
+    return submissions.find((s) => s.homeworkId === hwId && s.studentId === studentId && s.isLatest === 1) || null;
+}
+
+/* ============ 端分离视角（SetRole 仅 mock） ============ */
+type Role = "teacher" | "student";
+let viewerRole: Role = "teacher";
+function setViewerRole(r: any): Role {
+    viewerRole = r === "student" ? "student" : "teacher";
+    return viewerRole;
+}
+
+/* ============ V1 冻结接口适配层（同一 V2 存储派生） ============ */
+
+const V1_STATUS: Record<string, string> = { DRAFT_UNPUBLISHED: "draft", DRAFT_SCHEDULED: "draft", PUBLISHED: "collecting", CLOSED: "closed", ARCHIVED: "done" };
+const V1_STATUS_DESC: Record<string, string> = { draft: "草稿", collecting: "收集中", closed: "已截止", done: "已完成" };
+
+function v1Progress(n: any): any {
+    const p = progressV2(n);
+    const returned = genMatrix(n).filter((r) => r.submitStatus === "RETURNED").length;
+    return {
+        should: p.should,
+        submitted: p.submitted,
+        graded: p.graded,
+        pendingGrade: p.pendingGrade,
+        needRedo: returned,
+        redone: 0,
+        unsubmitted: p.unsubmitted,
+        submitRate: p.submitRate,
+        gradeRate: p.gradeRate,
+    };
+}
+function toV1Vo(n: any): any {
+    const st = V1_STATUS[n.hwStatus] || "collecting";
+    const all = n.classIds.length === ALL_CLASSES.length;
+    return {
+        id: n.id,
+        title: n.title,
+        content: n.description,
+        type: 0,
+        typeDesc: "课程作业",
+        subject: n.subject || "",
+        deadline: n.deadlineAt || null,
+        submitType: n.submitType,
+        hwStatus: st,
+        hwStatusDesc: V1_STATUS_DESC[st],
+        progress: isDraft(n) ? null : v1Progress(n),
+        receiveText: all ? "全部班级" : n.classIds.map((id: string) => classMap[id]?.className || id).join("、"),
+        classCount: n.classIds.length,
+        publisherAccount: n.publisherAccount,
+        publisherName: n.publisherName,
+        deptId: n.deptId,
+        deptName: deptDict.find((d) => d.CodeID === n.deptId)?.Name || "",
+        status: 1,
+        statusDesc: "",
+        topmost: 0,
+        readCount: progressV2(n).read,
+        allowCount: progressV2(n).should,
+        read: false,
+        isPulled: 0,
+        timingSendTime: n.scheduledAt,
+        parentId: null,
+        smsFlag: 0,
+        receiveType: "class",
+        receiveList: all ? "ALL" : n.classIds.join(","),
+        createBy: n.publisherAccount,
+        createTime: n.createTime,
+        updateBy: n.publisherAccount,
+        updateTime: n.updateTime,
+        UpFile: (n.attachments || []).map((a: any) => a.fileId).join(",") || null,
+    };
+}
+function toV1Detail(n: any): any {
+    const deptName = deptDict.find((d) => d.CodeID === n.deptId)?.Name || "";
+    const all = n.classIds.length === ALL_CLASSES.length;
+    return {
+        serid: n.id,
+        title: n.title,
+        Contents: n.description,
+        DeptID: n.deptId,
+        DeptName: deptName,
+        TeaName: n.publisherName,
+        EditDate: n.publishedAt || n.createTime,
+        numcount: progressV2(n).should,
+        readnumcount: progressV2(n).read,
+        ReceiveList: all ? "ALL" : n.classIds.join(","),
+        receiveType: "class",
+        receiveText: all ? "全部班级" : n.classIds.map((id: string) => classMap[id]?.className || id).join("、"),
+        subject: n.subject || "",
+        deadline: n.deadlineAt || null,
+        submitType: n.submitType,
+        hwStatus: V1_STATUS[n.hwStatus] || "collecting",
+        hwStatusDesc: V1_STATUS_DESC[V1_STATUS[n.hwStatus] || "collecting"],
+        progress: isDraft(n) ? null : v1Progress(n),
+        DsfsTime: n.scheduledAt,
+        isDsfs: !!n.scheduledAt,
+        ChaoSend: (n.attachments || []).map((a: any) => {
+            const f = a.fileId ? filesStore[a.fileId] : null;
+            return { id: a.fileId || 0, name: a.fileName || f?.fileTrueName || "附件", size: f?.size || 0, fileid: a.fileId || 0, filename: a.fileName || f?.filename || "附件" };
+        }),
+        tlist: all ? "all" : n.classIds,
+    };
+}
 
 /* ============================ Mock 定义 ============================ */
 
 export default [
-    /* ---------- 布局 / 用户 ---------- */
+    /* ---------- 基础平台 ---------- */
     {
         url: "/api/base/GetUserInfo",
         method: "get",
@@ -646,166 +664,650 @@ export default [
             }),
     },
     {
-        // 端分离入口：按 URL 前缀切换当前视角（teacher / student / parent）
+        // 端分离入口：按 URL 前缀切换当前视角（仅 mock）
         url: "/api/base/SetRole",
         method: "post",
         response: ({ query, body }: any) => ok({ role: setViewerRole((bodyOf(body, query) || {}).as || query.as) }),
     },
-    {
-        // 年级 → 班级树（发布对象选择：到班级一级）
-        url: "/api/base/GetClassTree",
-        method: "get",
-        response: () => ok(classTree),
-    },
 
-    /* ---------- 作业列表 ---------- */
-    {
-        // 已收到（学生/收件视角）：仅已发布、非未来定时、面向本班
-        url: "/api/homework/List",
-        method: "get",
-        response: ({ query }: any) => {
-            const pageIndex = Number(query.pageIndex || 1);
-            const pageSize = Number(query.pageSize || 50);
-            let list = homeworks.filter((n) => {
-                if (n.isPulled || !isPublished(n) || isScheduledFuture(n)) return false;
-                return isAllTarget(n) || targetClassIds(n).includes(ME_CLASS);
-            });
-            list = sortByTimeDesc(applyFilters(list, query));
-            const unreadCount = list.filter((n) => !isReadByMe(n)).length;
-            return ok({ ...paginate(list.map(toVo), pageIndex, pageSize), unreadCount });
-        },
-    },
-    {
-        // 已发送(scope=user) / 全部作业(不传)
-        url: "/api/homework/SendList",
-        method: "get",
-        response: ({ query }: any) => {
-            const pageIndex = Number(query.pageIndex || 1);
-            const pageSize = Number(query.pageSize || 10);
-            let list = [...homeworks];
-            if (query.scope === "user") list = list.filter((n) => n.publisherAccount === ME.account);
-            list = sortByTimeDesc(applyFilters(list, query));
-            return ok(paginate(list.map(toVo), pageIndex, pageSize));
-        },
-    },
+    /* ==================== V2 教师端 /api/teacher/homeworks ==================== */
 
-    /* ---------- 作业详情 ---------- */
+    /* ---- 页 1：创建 / 编辑 / 发布 ---- */
     {
-        url: "/api/homework/Detail",
-        method: "get",
-        response: ({ query }: any) => {
-            const n = homeworks.find((x) => x.id === Number(query.serid));
-            if (!n) return fail("作业不存在或已被删除");
-            if (String(query.type) !== "0" && !n.classRead.includes(ME_CLASS)) n.classRead.push(ME_CLASS);
-            return ok(toDetail(n));
-        },
-    },
-    {
-        url: "/api/homework/GetDetail",
-        method: "get",
-        response: ({ query }: any) => {
-            const n = homeworks.find((x) => x.id === Number(query.serid));
-            if (!n) return fail("作业不存在或已被删除");
-            return ok(toDetail(n));
-        },
-    },
-    {
-        url: "/api/homework/GetNextPrev",
-        method: "get",
-        response: ({ query }: any) => {
-            const ids = sortByTimeDesc(homeworks.filter(isPublished)).map((n) => n.id);
-            const i = ids.indexOf(Number(query.serid));
-            return ok({ prevId: i > 0 ? ids[i - 1] : 0, nextId: i > -1 && i < ids.length - 1 ? ids[i + 1] : 0 });
-        },
-    },
-    {
-        // 阅读情况：按年级分组，叶子为班级（读/未读）
-        url: "/api/homework/ReadDetail",
-        method: "get",
-        response: ({ query }: any) => {
-            const n = homeworks.find((x) => x.id === Number(query.serid));
-            if (!n) return fail("作业不存在或已被删除");
-            const targets = targetClassIds(n);
-            const readSet = new Set(n.classRead || []);
-            const byGrade: Record<string, any[]> = {};
-            targets.forEach((id) => {
-                const info = classMap[id];
-                if (!info) return;
-                (byGrade[info.gradeName] = byGrade[info.gradeName] || []).push({
-                    account: id,
-                    teaname: info.className + "（" + info.studentCount + "人）",
-                    states: readSet.has(id) ? "read" : "unread",
-                });
-            });
-            return ok(Object.keys(byGrade).map((name) => ({ GroupName: name, teaslist: byGrade[name] })));
-        },
-    },
-
-    /* ---------- 作业写入操作 ---------- */
-    {
-        url: "/api/homework/Create",
+        // 创建作业（一律落草稿 DRAFT_UNPUBLISHED），返回新 id
+        url: /^\/api\/teacher\/homeworks$/,
         method: "post",
-        response: ({ body, query }: any) => {
-            const b = bodyOf(body, query);
-            const dept = deptDict.find((d) => d.CodeID === b.deptId);
-            const receive = b.receiveList || "all";
-            const isAll = /^all$/i.test(String(receive).trim());
+        response: ({ body }: any) => {
+            const b = parseBody(body);
             const item: any = {
                 id: homeworkSeq++,
-                title: b.title || "未命名作业",
-                deptId: b.deptId || "",
-                deptName: dept ? dept.Name : "",
+                title: String(b.title || "未命名作业").slice(0, 50),
+                subject: b.subject || "",
+                description: b.description || "",
+                hwStatus: "DRAFT_UNPUBLISHED",
+                scheduledAt: null, publishedAt: null,
+                deadlineAt: b.deadlineAt ? String(b.deadlineAt).replace(/\//g, "-") : null,
+                archivedAt: null,
+                submitType: Array.isArray(b.submitType) && b.submitType.length ? b.submitType : ["text"],
+                allowLate: Number(b.allowLate) || 0,
+                remind1d: Number(b.remind1d) || 0,
+                remind1h: Number(b.remind1h) || 0,
+                classIds: (Array.isArray(b.classIds) ? b.classIds : []).map(String).filter(Boolean),
+                attachments: Array.isArray(b.attachments) ? b.attachments : [],
+                deptId: "D002",
                 publisherAccount: ME.account,
                 publisherName: ME.name,
-                content: b.content || "",
-                receiveList: isAll ? "ALL" : String(receive).split(/[,，\s]+/).filter(Boolean).join(","),
-                classRead: [],
-                files: b.fileIds || null,
-                topmost: 0,
-                isPulled: 0,
-                smsFlag: Number(b.smsFlag) || 0,
-                timingSendTime: b.timingSendTime ? String(b.timingSendTime).replace(/\//g, "-") : null,
                 createTime: nowStr(),
-                subject: b.subject || "综合",
-                deadline: b.deadline ? String(b.deadline).replace(/\//g, "-") : null,
-                submitType: Array.isArray(b.submitType) ? b.submitType : String(b.submitType || "text").split(/[,，\s]+/).filter(Boolean),
-                allowLate: !!b.allowLate,
-                remindBefore: Array.isArray(b.remindBefore) ? b.remindBefore : String(b.remindBefore || "").split(/[,，\s]+/).filter(Boolean),
-                hwStatus: b.draft ? "draft" : "collecting",
+                updateTime: nowStr(),
             };
             homeworks.unshift(item);
             return ok(item.id);
         },
     },
     {
-        url: "/api/homework/Edit",
-        method: "post",
-        response: ({ body, query }: any) => {
-            const b = bodyOf(body, query);
-            const n = homeworks.find((x) => x.id === Number(b.sourceId ?? b.id));
+        // 编辑（仅草稿两态）
+        url: /^\/api\/teacher\/homeworks\/(\d+)$/,
+        method: "put",
+        response: ({ url, body }: any) => {
+            const n = requireHw(Number(url.match(/(\d+)$/)?.[1]));
             if (!n) return fail("作业不存在或已被删除");
-            const dept = deptDict.find((d) => d.CodeID === b.deptId);
-            n.title = b.title || n.title;
-            n.content = b.content ?? n.content;
-            if (b.deptId) {
-                n.deptId = b.deptId;
-                n.deptName = dept ? dept.Name : n.deptName;
-            }
-            if (b.receiveList !== undefined && b.receiveList !== null && b.receiveList !== "") {
-                const isAll = /^all$/i.test(String(b.receiveList).trim());
-                n.receiveList = isAll ? "ALL" : String(b.receiveList).split(/[,，\s]+/).filter(Boolean).join(",");
-            }
-            if (b.fileIds !== undefined) n.files = b.fileIds || null;
-            if (b.smsFlag !== undefined) n.smsFlag = Number(b.smsFlag) || 0;
-            if (b.timingSendTime !== undefined) n.timingSendTime = b.timingSendTime ? String(b.timingSendTime).replace(/\//g, "-") : null;
+            if (!isDraft(n)) return fail("仅草稿状态的作业可编辑");
+            const b = parseBody(body);
+            n.title = b.title ? String(b.title).slice(0, 50) : n.title;
+            n.subject = b.subject !== undefined ? b.subject : n.subject;
+            n.description = b.description !== undefined ? b.description : n.description;
+            n.deadlineAt = b.deadlineAt !== undefined ? (b.deadlineAt ? String(b.deadlineAt).replace(/\//g, "-") : null) : n.deadlineAt;
+            n.submitType = Array.isArray(b.submitType) && b.submitType.length ? b.submitType : n.submitType;
+            n.allowLate = b.allowLate !== undefined ? Number(b.allowLate) || 0 : n.allowLate;
+            n.remind1d = b.remind1d !== undefined ? Number(b.remind1d) || 0 : n.remind1d;
+            n.remind1h = b.remind1h !== undefined ? Number(b.remind1h) || 0 : n.remind1h;
+            n.classIds = Array.isArray(b.classIds) && b.classIds.length ? b.classIds.map(String) : n.classIds;
+            n.attachments = Array.isArray(b.attachments) ? b.attachments : n.attachments;
+            n.updateTime = nowStr();
             return ok(null);
         },
     },
     {
+        // 删除（仅草稿两态）
+        url: /^\/api\/teacher\/homeworks\/(\d+)$/,
+        method: "delete",
+        response: ({ url }: any) => {
+            const id = Number(url.match(/(\d+)$/)?.[1]);
+            const n = requireHw(id);
+            if (!n) return fail("作业不存在或已被删除");
+            if (!isDraft(n)) return fail("仅草稿状态的作业可删除");
+            homeworks.splice(homeworks.indexOf(n), 1);
+            return ok(null);
+        },
+    },
+    {
+        // 立即发布
+        url: /^\/api\/teacher\/homeworks\/(\d+)\/publish$/,
+        method: "post",
+        response: ({ url }: any) => {
+            const n = requireHw(Number(url.match(/homeworks\/(\d+)/)?.[1]));
+            if (!n) return fail("作业不存在或已被删除");
+            if (!isDraft(n)) return fail("仅草稿状态的作业可发布");
+            n.hwStatus = "PUBLISHED";
+            n.publishedAt = nowStr();
+            n.scheduledAt = null;
+            n.updateTime = nowStr();
+            return ok(null);
+        },
+    },
+    {
+        // 定时发布 / 取消定时
+        url: /^\/api\/teacher\/homeworks\/(\d+)\/schedule$/,
+        method: "post",
+        response: ({ url, body }: any) => {
+            const n = requireHw(Number(url.match(/homeworks\/(\d+)/)?.[1]));
+            if (!n) return fail("作业不存在或已被删除");
+            if (!isDraft(n)) return fail("仅草稿状态的作业可设置定时发布");
+            const b = parseBody(body);
+            if (b.cancel) {
+                n.hwStatus = "DRAFT_UNPUBLISHED";
+                n.scheduledAt = null;
+            } else {
+                if (!b.scheduledAt) return fail("定时时间不能为空");
+                if (String(b.scheduledAt) <= nowStr()) return fail("定时时间需晚于当前时间");
+                n.hwStatus = "DRAFT_SCHEDULED";
+                n.scheduledAt = String(b.scheduledAt).replace(/\//g, "-");
+            }
+            n.updateTime = nowStr();
+            return ok(null);
+        },
+    },
+
+    /* ---- 页 2/3：列表 ---- */
+    {
+        // 草稿箱分页（subject/hwStatus/keyword 筛选）
+        url: "/api/teacher/homeworks/drafts",
+        method: "get",
+        response: ({ query }: any) => {
+            let list = homeworks.filter((n) => isDraft(n) && isOwned(n));
+            if (query.subject) list = list.filter((n) => (n.subject || "") === query.subject);
+            if (query.hwStatus) list = list.filter((n) => n.hwStatus === query.hwStatus);
+            if (query.keyword) list = list.filter((n) => n.title.includes(query.keyword));
+            list = [...list].sort((a, b) => (a.updateTime < b.updateTime ? 1 : -1));
+            return ok(paginate(list.map((n) => toV2Vo(n, false)), Number(query.pageIndex || 1), Number(query.pageSize || 10)));
+        },
+    },
+    {
+        // 已发布列表分页（含应交/已读/已交/未读未交聚合；hwStatus: PUBLISHED/CLOSED/ARCHIVED）
+        url: "/api/teacher/homeworks/published",
+        method: "get",
+        response: ({ query }: any) => {
+            let list = homeworks.filter((n) => !isDraft(n) && isOwned(n));
+            if (query.subject) list = list.filter((n) => (n.subject || "") === query.subject);
+            if (query.hwStatus) list = list.filter((n) => n.hwStatus === query.hwStatus);
+            if (query.keyword) list = list.filter((n) => n.title.includes(query.keyword));
+            list = [...list].sort((a, b) => ((a.publishedAt || a.createTime) < (b.publishedAt || b.createTime) ? 1 : -1));
+            return ok(paginate(list.map((n) => toV2Vo(n, true)), Number(query.pageIndex || 1), Number(query.pageSize || 10)));
+        },
+    },
+    {
+        // 提醒未读/未交（可定向 studentIds），返回实际提醒人数
+        url: /^\/api\/teacher\/homeworks\/(\d+)\/remind$/,
+        method: "post",
+        response: ({ url, body }: any) => {
+            const n = requireHw(Number(url.match(/homeworks\/(\d+)/)?.[1]));
+            if (!n) return fail("作业不存在或已被删除");
+            if (n.hwStatus === "ARCHIVED") return fail("已归档作业不再触发提醒");
+            const b = parseBody(body);
+            const rows = genMatrix(n);
+            const only = Array.isArray(b.studentIds) ? b.studentIds.map(String) : null;
+            const hit = rows.filter((r) => {
+                if (only && !only.includes(String(r.studentId))) return false;
+                return b.type === "NOT_READ" ? r.isRead === 0 : r.submitStatus === "NOT_SUBMITTED";
+            });
+            return ok({ reminded: hit.length });
+        },
+    },
+    {
+        // 延长截止（须晚于当前值）
+        url: /^\/api\/teacher\/homeworks\/(\d+)\/extend$/,
+        method: "post",
+        response: ({ url, body }: any) => {
+            const n = requireHw(Number(url.match(/homeworks\/(\d+)/)?.[1]));
+            if (!n) return fail("作业不存在或已被删除");
+            const b = parseBody(body);
+            if (!b.deadlineAt) return fail("新截止时间不能为空");
+            if (n.deadlineAt && String(b.deadlineAt) <= String(n.deadlineAt)) return fail("新截止时间必须晚于原截止时间");
+            n.deadlineAt = String(b.deadlineAt).replace(/\//g, "-");
+            n.updateTime = nowStr();
+            return ok(null);
+        },
+    },
+    {
+        // 复制为新草稿
+        url: /^\/api\/teacher\/homeworks\/(\d+)\/copy$/,
+        method: "post",
+        response: ({ url }: any) => {
+            const n = requireHw(Number(url.match(/homeworks\/(\d+)/)?.[1]));
+            if (!n) return fail("作业不存在或已被删除");
+            const copy = {
+                ...n,
+                id: homeworkSeq++,
+                title: `${n.title}（副本）`.slice(0, 50),
+                hwStatus: "DRAFT_UNPUBLISHED",
+                scheduledAt: null, publishedAt: null, archivedAt: null,
+                publisherAccount: ME.account,
+                publisherName: ME.name,
+                createTime: nowStr(),
+                updateTime: nowStr(),
+            };
+            homeworks.unshift(copy);
+            return ok(copy.id);
+        },
+    },
+    {
+        // 归档（只读，屏蔽提醒）
+        url: /^\/api\/teacher\/homeworks\/(\d+)\/archive$/,
+        method: "post",
+        response: ({ url }: any) => {
+            const n = requireHw(Number(url.match(/homeworks\/(\d+)/)?.[1]));
+            if (!n) return fail("作业不存在或已被删除");
+            if (isDraft(n)) return fail("草稿不能归档，请先发布或删除");
+            n.hwStatus = "ARCHIVED";
+            n.archivedAt = nowStr();
+            n.updateTime = nowStr();
+            return ok(null);
+        },
+    },
+    {
+        // 导出学生矩阵 Excel（mock 以 JSON 出参代替文件流）
+        url: /^\/api\/teacher\/homeworks\/(\d+)\/export$/,
+        method: "get",
+        response: ({ url }: any) => {
+            const n = requireHw(Number(url.match(/homeworks\/(\d+)/)?.[1]));
+            if (!n) return fail("作业不存在或已被删除");
+            return ok({ hint: "mock 模式不生成 Excel 文件", homeworkId: n.id, title: n.title, rows: genMatrix(n).length });
+        },
+    },
+
+    /* ---- 页 4：详情 / 统计 ---- */
+    {
+        url: /^\/api\/teacher\/homeworks\/(\d+)$/,
+        method: "get",
+        response: ({ url }: any) => {
+            const n = requireHw(Number(url.match(/(\d+)$/)?.[1]));
+            if (!n) return fail("作业不存在或已被删除");
+            if (!isOwned(n)) return fail("无权查看他人作业");
+            return ok(toV2Vo(n, true));
+        },
+    },
+    {
+        // 汇总统计卡片（总进度 + 分班进度）
+        url: /^\/api\/teacher\/homeworks\/(\d+)\/stats$/,
+        method: "get",
+        response: ({ url }: any) => {
+            const n = requireHw(Number(url.match(/homeworks\/(\d+)/)?.[1]));
+            if (!n) return fail("作业不存在或已被删除");
+            return ok({
+                homeworkId: n.id,
+                title: n.title,
+                hwStatus: n.hwStatus,
+                hwStatusDesc: HW_DESC[n.hwStatus] || n.hwStatus,
+                total: progressV2(n),
+                byClass: (n.classIds || []).map((cid: string) => ({ classId: cid, className: classMap[cid]?.className || cid, progress: progressV2(n, [cid]) })),
+            });
+        },
+    },
+
+    /* ---- 页 5：学生矩阵 ---- */
+    {
+        // 学生矩阵分页（classId/submitStatus/reviewStatus/pendingGrade/keyword）
+        url: /^\/api\/teacher\/homeworks\/(\d+)\/students$/,
+        method: "get",
+        response: ({ url, query }: any) => {
+            const n = requireHw(Number(url.match(/homeworks\/(\d+)/)?.[1]));
+            if (!n) return fail("作业不存在或已被删除");
+            let rows = genMatrix(n);
+            if (query.classId) rows = rows.filter((r) => r.classId === String(query.classId));
+            if (query.submitStatus) rows = rows.filter((r) => r.submitStatus === query.submitStatus);
+            if (query.reviewStatus) rows = rows.filter((r) => r.reviewStatus === query.reviewStatus);
+            if (String(query.pendingGrade) === "true" || query.pendingGrade === "1")
+                rows = rows.filter((r) => (r.submitStatus === "SUBMITTED" || r.submitStatus === "LATE_SUBMITTED") && r.reviewStatus === "PENDING");
+            if (query.keyword) rows = rows.filter((r) => r.studentName.includes(query.keyword));
+            return ok(paginate(rows, Number(query.pageIndex || 1), Number(query.pageSize || 10)));
+        },
+    },
+
+    /* ---- 页 6：批阅 / 打回 / 版本 ---- */
+    {
+        // 保存批阅（score/comment 至少一项）→ REVIEWED
+        url: /^\/api\/teacher\/homeworks\/(\d+)\/submissions\/([^/]+)\/review$/,
+        method: "post",
+        response: ({ url, body }: any) => {
+            const m = url.match(/homeworks\/(\d+)\/submissions\/([^/]+)\/review/);
+            const n = requireHw(Number(m?.[1]));
+            if (!n) return fail("作业不存在或已被删除");
+            const s = latestOf(n.id, Number(m?.[2]));
+            if (!s || s.submitStatus === "NOT_SUBMITTED") return fail("该学生尚未提交");
+            const b = parseBody(body);
+            if (b.score === undefined && !b.comment) return fail("分数与评语至少填一项");
+            s.score = b.score !== undefined && b.score !== "" ? Number(b.score) : null;
+            s.comment = b.comment || "";
+            s.submitStatus = "REVIEWED";
+            s.reviewStatus = "REVIEWED";
+            s.reviewedBy = ME.name;
+            s.reviewedAt = nowStr();
+            return ok(null);
+        },
+    },
+    {
+        // 打回（comment 必填）→ RETURNED
+        url: /^\/api\/teacher\/homeworks\/(\d+)\/submissions\/([^/]+)\/return$/,
+        method: "post",
+        response: ({ url, body }: any) => {
+            const m = url.match(/homeworks\/(\d+)\/submissions\/([^/]+)\/return/);
+            const n = requireHw(Number(m?.[1]));
+            if (!n) return fail("作业不存在或已被删除");
+            const s = latestOf(n.id, Number(m?.[2]));
+            if (!s || s.submitStatus === "NOT_SUBMITTED") return fail("该学生尚未提交");
+            const b = parseBody(body);
+            if (!b.comment) return fail("打回须填写订正原因");
+            s.submitStatus = "RETURNED";
+            s.reviewStatus = "RETURNED";
+            s.comment = b.comment;
+            s.score = null;
+            s.reviewedBy = ME.name;
+            s.reviewedAt = nowStr();
+            return ok(null);
+        },
+    },
+    {
+        // 历史提交版本（新 → 旧）
+        url: /^\/api\/teacher\/homeworks\/(\d+)\/submissions\/([^/]+)\/versions$/,
+        method: "get",
+        response: ({ url }: any) => {
+            const m = url.match(/homeworks\/(\d+)\/submissions\/([^/]+)\/versions/);
+            const n = requireHw(Number(m?.[1]));
+            if (!n) return fail("作业不存在或已被删除");
+            const list = submissions
+                .filter((s) => s.homeworkId === n.id && s.studentId === Number(m?.[2]))
+                .sort((a, b) => b.version - a.version)
+                .map((s) => ({ ...s, studentId: String(s.studentId), submitStatusDesc: SUBMIT_DESC[s.submitStatus], reviewStatusDesc: REVIEW_DESC[s.reviewStatus] }));
+            return ok(list);
+        },
+    },
+
+    /* ---- 辅助：班级树 / 名册同步 ---- */
+    {
+        // 年级 → 班级树（叶子 id=classId，含 studentCount）
+        url: "/api/teacher/homeworks/classes",
+        method: "get",
+        response: () =>
+            ok(
+                gradeClasses.map((g) => ({
+                    id: g.gradeName,
+                    name: g.gradeName,
+                    isParent: true,
+                    children: g.classes.map((c) => ({ id: String(c.classId), name: c.className, isParent: false, studentCount: c.studentCount })),
+                }))
+            ),
+    },
+    {
+        // 手动触发名册同步（mock 空操作）
+        url: "/api/teacher/homeworks/classes/sync",
+        method: "post",
+        response: () => ok({ synced: 0 }),
+    },
+
+    /* ==================== V2 学生端 /api/student/homeworks ==================== */
+
+    {
+        // 我的作业列表（tab=all/todo/done/closed + 分页/keyword）
+        url: /^\/api\/student\/homeworks$/,
+        method: "get",
+        response: ({ query }: any) => {
+            const cid = String(DEMO_STUDENT.classId);
+            const visible = homeworks.filter((n) => {
+                if (isDraft(n)) return false;
+                if (n.hwStatus === "DRAFT_SCHEDULED") return false;
+                return (n.classIds || []).includes(cid);
+            });
+            const tab = query.tab || "all";
+            let list = visible.filter((n) => {
+                const mine = latestOf(n.id, DEMO_STUDENT.studentId);
+                const st = mine ? mine.submitStatus : "NOT_SUBMITTED";
+                if (tab === "todo") return st === "NOT_SUBMITTED" || st === "RETURNED";
+                if (tab === "done") return st === "SUBMITTED" || st === "LATE_SUBMITTED" || st === "REVIEWED";
+                if (tab === "closed") return n.hwStatus === "CLOSED" || n.hwStatus === "ARCHIVED";
+                return true;
+            });
+            if (query.keyword) list = list.filter((n) => n.title.includes(query.keyword));
+            list = [...list].sort((a, b) => ((a.deadlineAt || "9") < (b.deadlineAt || "9") ? -1 : 1));
+            const content = list.map((n) => {
+                const mine = latestOf(n.id, DEMO_STUDENT.studentId);
+                return {
+                    id: n.id,
+                    title: n.title,
+                    subject: n.subject,
+                    teacherName: n.publisherName,
+                    deadlineAt: n.deadlineAt || null,
+                    submitType: n.submitType,
+                    hwStatus: n.hwStatus,
+                    hwStatusDesc: HW_DESC[n.hwStatus] || n.hwStatus,
+                    allowLate: n.allowLate ?? 0,
+                    my: mine
+                        ? {
+                              submissionId: mine.id,
+                              submitStatus: mine.submitStatus,
+                              submitStatusDesc: SUBMIT_DESC[mine.submitStatus],
+                              submittedAt: mine.submittedAt,
+                              isLate: mine.isLate,
+                              version: mine.version,
+                              reviewStatus: mine.reviewStatus,
+                              score: mine.score,
+                              comment: mine.comment,
+                          }
+                        : null,
+                };
+            });
+            return ok(paginate(content, Number(query.pageIndex || 1), Number(query.pageSize || 10)));
+        },
+    },
+    {
+        // 作业详情（含说明/附件/我的当前提交内容）
+        url: /^\/api\/student\/homeworks\/(\d+)$/,
+        method: "get",
+        response: ({ url }: any) => {
+            const n = requireHw(Number(url.match(/(\d+)$/)?.[1]));
+            const cid = String(DEMO_STUDENT.classId);
+            if (!n || isDraft(n) || !(n.classIds || []).includes(cid)) return fail("作业不存在或不可见");
+            const mine = latestOf(n.id, DEMO_STUDENT.studentId);
+            return ok({
+                id: n.id,
+                title: n.title,
+                subject: n.subject,
+                teacherName: n.publisherName,
+                deadlineAt: n.deadlineAt || null,
+                submitType: n.submitType,
+                hwStatus: n.hwStatus,
+                hwStatusDesc: HW_DESC[n.hwStatus] || n.hwStatus,
+                allowLate: n.allowLate ?? 0,
+                description: n.description,
+                attachments: n.attachments || [],
+                classes: (n.classIds || []).map((id: string) => ({ classId: id, className: classMap[id]?.className || id })),
+                myAttachments: mine ? mine.attachments || [] : null,
+                myText: mine ? mine.text : null,
+                my: mine
+                    ? {
+                          submissionId: mine.id,
+                          submitStatus: mine.submitStatus,
+                          submitStatusDesc: SUBMIT_DESC[mine.submitStatus],
+                          submittedAt: mine.submittedAt,
+                          isLate: mine.isLate,
+                          version: mine.version,
+                          reviewStatus: mine.reviewStatus,
+                          score: mine.score,
+                          comment: mine.comment,
+                      }
+                    : null,
+            });
+        },
+    },
+    {
+        // 阅读上报（幂等；首末阅读时间落库）
+        url: /^\/api\/student\/homeworks\/(\d+)\/read$/,
+        method: "post",
+        response: ({ url }: any) => {
+            const n = requireHw(Number(url.match(/homeworks\/(\d+)/)?.[1]));
+            if (!n) return fail("作业不存在或已被删除");
+            reads[n.id] = reads[n.id] || {};
+            const prev = reads[n.id][DEMO_STUDENT.studentId];
+            const now = nowStr();
+            reads[n.id][DEMO_STUDENT.studentId] = { firstReadAt: prev ? prev.firstReadAt : now, lastReadAt: now };
+            return ok(null);
+        },
+    },
+    {
+        // 提交作业（版本 +1；截止后按 allowLate 分流 LATE_SUBMITTED）
+        url: /^\/api\/student\/homeworks\/(\d+)\/submissions$/,
+        method: "post",
+        response: ({ url, body }: any) => {
+            const n = requireHw(Number(url.match(/homeworks\/(\d+)/)?.[1]));
+            if (!n || isDraft(n)) return fail("作业不存在或不可见");
+            if (n.hwStatus === "ARCHIVED") return fail("作业已归档，不可提交");
+            const types = n.submitType || [];
+            if (types.includes("none")) return fail("该作业为仅查阅类型，无需提交");
+            const b = parseBody(body);
+            const atts = Array.isArray(b.attachments) ? b.attachments : [];
+            const late = deadlinePassed(n) || n.hwStatus === "CLOSED";
+            if (late && n.allowLate !== 1) return fail("作业已截止，如需补交请联系老师");
+            if ((types.includes("image") || types.includes("attach")) && !atts.length) return fail("请上传作业附件");
+            if (atts.length && !types.includes("image") && !types.includes("attach")) return fail("该作业仅接受文本提交，不接受附件");
+            for (const a of atts) {
+                if (!a || (!a.fileUrl && !a.fileId)) return fail("附件信息不完整（须为上传产物）");
+                if (a.fileUrl && String(a.fileUrl).startsWith("data:")) return fail("不支持 dataURL 附件，请使用文件上传接口");
+            }
+            return ok({ submissionId: doSubmit(n, b.text, atts, late) });
+        },
+    },
+    {
+        // 撤回（截止前）/ 打回重交
+        url: /^\/api\/student\/homeworks\/(\d+)\/submissions\/(\d+)$/,
+        method: "put",
+        response: ({ url, body }: any) => {
+            const m = url.match(/homeworks\/(\d+)\/submissions\/(\d+)$/);
+            const n = requireHw(Number(m?.[1]));
+            if (!n) return fail("作业不存在或已被删除");
+            const latest = latestOf(n.id, DEMO_STUDENT.studentId);
+            if (!latest || String(latest.id) !== String(m?.[2])) return fail("仅当前版本可执行该操作");
+            const b = parseBody(body);
+            if (b.action === "withdraw") {
+                if (n.hwStatus !== "PUBLISHED" || deadlinePassed(n)) return fail("已截止作业不可撤回");
+                latest.isLatest = 0;
+                const empty = newSubmission(n, "NOT_SUBMITTED", 0, null, null, latest.version + 1);
+                submissions.push(empty);
+                return ok({ submissionId: empty.id });
+            }
+            if (b.action === "resubmit") {
+                if (latest.submitStatus !== "RETURNED") return fail("仅被打回的提交可重交");
+                const types = n.submitType || [];
+                const atts = Array.isArray(b.attachments) ? b.attachments : [];
+                const late = deadlinePassed(n) || n.hwStatus === "CLOSED";
+                if ((types.includes("image") || types.includes("attach")) && !atts.length) return fail("请上传作业附件");
+                return ok({ submissionId: doSubmit(n, b.text, atts, late) });
+            }
+            return fail("action 仅支持 withdraw / resubmit");
+        },
+    },
+    {
+        // 批阅结果（当前版本 + 历史版本含各版评语）
+        url: /^\/api\/student\/homeworks\/(\d+)\/result$/,
+        method: "get",
+        response: ({ url }: any) => {
+            const n = requireHw(Number(url.match(/homeworks\/(\d+)/)?.[1]));
+            if (!n) return fail("作业不存在或已被删除");
+            const versions = submissions
+                .filter((s) => s.homeworkId === n.id && s.studentId === DEMO_STUDENT.studentId)
+                .sort((a, b) => b.version - a.version)
+                .map((s) => ({ ...s, studentId: String(s.studentId), studentName: DEMO_STUDENT.studentName, submitStatusDesc: SUBMIT_DESC[s.submitStatus], reviewStatusDesc: REVIEW_DESC[s.reviewStatus] }));
+            return ok({ homeworkId: n.id, homeworkTitle: n.title, latest: versions.find((v) => v.isLatest === 1) || null, versions });
+        },
+    },
+
+    /* ==================== 通知 /api/notifications ==================== */
+
+    {
+        // 分页（unreadOnly 只看未读；含 unreadCount）
+        url: /^\/api\/notifications$/,
+        method: "get",
+        response: ({ query }: any) => {
+            const mine = notifications.filter((x) => x.receiverRole === viewerRole);
+            let list = [...mine].sort((a, b) => (a.createTime < b.createTime ? 1 : -1));
+            if (String(query.unreadOnly) === "true" || query.unreadOnly === "1") list = list.filter((x) => x.isRead === 0);
+            if (query.keyword) list = list.filter((x) => x.title.includes(query.keyword));
+            return ok({ ...paginate(list, Number(query.pageIndex || 1), Number(query.pageSize || 10)), unreadCount: mine.filter((x) => x.isRead === 0).length });
+        },
+    },
+    {
+        // 全部已读（先注册精确路径，避免与 /(\d+)\/read 冲突）
+        url: "/api/notifications/read-all",
+        method: "post",
+        response: () => {
+            notifications.forEach((x) => {
+                if (x.receiverRole === viewerRole && x.isRead === 0) {
+                    x.isRead = 1;
+                    x.readAt = nowStr();
+                }
+            });
+            return ok(null);
+        },
+    },
+    {
+        // 单条已读
+        url: /^\/api\/notifications\/(\d+)\/read$/,
+        method: "post",
+        response: ({ url }: any) => {
+            const x = notifications.find((t) => t.id === Number(url.match(/notifications\/(\d+)/)?.[1]));
+            if (!x) return fail("通知不存在");
+            if (x.isRead === 0) {
+                x.isRead = 1;
+                x.readAt = nowStr();
+            }
+            return ok(null);
+        },
+    },
+
+    /* ==================== V1 冻结接口（同一存储派生） ==================== */
+
+    {
+        // 全部作业（/homeworklist 管理页；scope=user 只看自己）
+        url: "/api/homework/SendList",
+        method: "get",
+        response: ({ query }: any) => {
+            let list = [...homeworks];
+            if (query.scope === "user") list = list.filter(isOwned);
+            if (query.subject) list = list.filter((n) => (n.subject || "") === query.subject);
+            const st = query.hwStatus && query.hwStatus !== "all" ? query.hwStatus : "";
+            if (st) list = list.filter((n) => (V1_STATUS[n.hwStatus] || "collecting") === st);
+            if (query.keyword) list = list.filter((n) => n.title.includes(query.keyword) || n.publisherName.includes(query.keyword));
+            list = [...list].sort((a, b) => (a.createTime < b.createTime ? 1 : -1));
+            return ok(paginate(list.map(toV1Vo), Number(query.pageIndex || 1), Number(query.pageSize || 10)));
+        },
+    },
+    {
+        // 详情（管理视角，type=0 不标读）
+        url: "/api/homework/Detail",
+        method: "get",
+        response: ({ query }: any) => {
+            const n = requireHw(Number(query.serid));
+            if (!n) return fail("作业不存在或已被删除");
+            return ok(toV1Detail(n));
+        },
+    },
+    {
+        // 编辑回显（不标读；转发场景取他人作业作底稿）
+        url: "/api/homework/GetDetail",
+        method: "get",
+        response: ({ query }: any) => {
+            const n = requireHw(Number(query.serid));
+            if (!n) return fail("作业不存在或已被删除");
+            return ok(toV1Detail(n));
+        },
+    },
+    {
+        url: "/api/homework/GetNextPrev",
+        method: "get",
+        response: ({ query }: any) => {
+            const ids = [...homeworks]
+                .filter((n) => !isDraft(n))
+                .sort((a, b) => (a.createTime < b.createTime ? 1 : -1))
+                .map((n) => n.id);
+            const i = ids.indexOf(Number(query.serid));
+            return ok({ prevId: i > 0 ? ids[i - 1] : 0, nextId: i > -1 && i < ids.length - 1 ? ids[i + 1] : 0 });
+        },
+    },
+    {
+        // 阅读情况：按年级分组（班级粒度，多数已读视为已读）
+        url: "/api/homework/ReadDetail",
+        method: "get",
+        response: ({ query }: any) => {
+            const n = requireHw(Number(query.serid));
+            if (!n) return fail("作业不存在或已被删除");
+            const byGrade: Record<string, any[]> = {};
+            (n.classIds || []).forEach((id: string) => {
+                const info = classMap[id];
+                if (!info) return;
+                const p = progressV2(n, [id]);
+                (byGrade[info.gradeName] = byGrade[info.gradeName] || []).push({
+                    account: id,
+                    teaname: `${info.className}（${info.studentCount}人）`,
+                    states: p.read * 2 >= p.should ? "read" : "unread",
+                });
+            });
+            return ok(Object.keys(byGrade).map((name) => ({ GroupName: name, teaslist: byGrade[name] })));
+        },
+    },
+    {
+        // 删除（管理页）
         url: "/api/homework/Delete",
         method: "post",
-        response: ({ body, query }: any) => {
-            const parsed = bodyOf(body, query);
+        response: ({ body }: any) => {
+            const parsed = parseBody(body);
             const ids: number[] = Array.isArray(parsed) ? parsed.map(Number) : [Number(parsed.ids ?? parsed.id)].filter(Boolean);
             for (const id of ids) {
                 const i = homeworks.findIndex((n) => n.id === id);
@@ -815,65 +1317,31 @@ export default [
         },
     },
     {
-        url: "/api/homework/InitializeRed",
-        method: "post",
-        response: () => {
-            homeworks.forEach((n) => {
-                if (isPublished(n) && !n.classRead.includes(ME_CLASS)) n.classRead.push(ME_CLASS);
-            });
-            return ok({ count: homeworks.length });
-        },
-    },
-    {
-        url: "/api/homework/UserPull",
-        method: "post",
-        response: ({ body, query }: any) => {
-            const n = homeworks.find((x) => x.id === Number(bodyOf(body, query).serid));
-            if (n) n.isPulled = 1;
-            return ok(null);
-        },
-    },
-    {
-        url: "/api/homework/SetTopmost",
-        method: "post",
-        response: ({ body, query }: any) => {
-            const b = bodyOf(body, query);
-            const n = homeworks.find((x) => x.id === Number(b.serid));
-            if (n) n.topmost = Number(b.topmost ?? 1) ? 1 : 0;
-            return ok(null);
-        },
-    },
-    { url: "/api/homework/Expedite", method: "post", response: () => ok(null) },
-    { url: "/api/homework/ReceiveUsers", method: "post", response: () => ok(null) },
-    {
+        // 作业统计（/stats）
         url: "/api/homework/Statis",
         method: "get",
         response: () => {
             const byPublisher: Record<string, number> = {};
             homeworks.forEach((n) => (byPublisher[n.publisherName] = (byPublisher[n.publisherName] || 0) + 1));
-            const mine = homeworks.filter((n: any) => n.publisherAccount === ME.account);
-            // 分数分布（仅统计已批改且有分数的提交）
-            const scored = submissions.filter((s) => s.grade && typeof s.grade.score === "number").map((s) => s.grade.score as number);
-            const bucket = { excellent: 0, good: 0, pass: 0, fail: 0 };
-            scored.forEach((x) => (x >= 90 ? bucket.excellent++ : x >= 80 ? bucket.good++ : x >= 60 ? bucket.pass++ : bucket.fail++));
-            // 按作业进度（我布置的、需收集的）
+            const mine = homeworks.filter(isOwned);
             const byHomework = mine
-                .filter((n: any) => n.hwStatus !== "draft" && !(n.submitType || []).includes("none"))
-                .map((n: any) => ({ id: n.id, title: n.title, subject: n.subject, hwStatus: n.hwStatus, ...progressOf(n.id) }));
+                .filter((n) => !isDraft(n) && !(n.submitType || []).includes("none"))
+                .map((n) => ({ id: n.id, title: n.title, subject: n.subject, hwStatus: V1_STATUS[n.hwStatus], ...v1Progress(n) }));
             const pendingGrade = byHomework.reduce((s, h) => s + h.pendingGrade, 0);
             const rates = byHomework.map((h) => h.submitRate).filter((r) => r > 0);
-            const avgSubmitRate = rates.length ? Number((rates.reduce((a, b) => a + b, 0) / rates.length).toFixed(1)) : 0;
+            const scored = submissions.filter((s) => s.reviewStatus === "REVIEWED" && typeof s.score === "number").map((s) => s.score as number);
+            const bucket = { excellent: 0, good: 0, pass: 0, fail: 0 };
+            scored.forEach((x) => (x >= 90 ? bucket.excellent++ : x >= 80 ? bucket.good++ : x >= 60 ? bucket.pass++ : bucket.fail++));
             return ok({
                 total: homeworks.length,
-                publishedCount: homeworks.filter((n) => isPublished(n) && !n.isPulled).length,
-                totalReadRecords: homeworks.reduce((s, n) => s + readCountOf(n), 0),
-                unreadForCurrentUser: homeworks.filter((n) => isPublished(n) && !isReadByMe(n)).length,
+                publishedCount: homeworks.filter((n) => !isDraft(n)).length,
+                totalReadRecords: homeworks.reduce((s, n) => (isDraft(n) ? s : s + progressV2(n).read), 0),
+                unreadForCurrentUser: 0,
                 byPublisher: Object.keys(byPublisher).map((publisherName) => ({ publisherName, count: byPublisher[publisherName] })),
                 byMonth: [{ year: 2026, month: 9, count: homeworks.length }],
-                // ===== 课程作业口径（v1）=====
                 myAssignCount: mine.length,
                 pendingGrade,
-                avgSubmitRate,
+                avgSubmitRate: rates.length ? Number((rates.reduce((a, b) => a + b, 0) / rates.length).toFixed(1)) : 0,
                 byHomework,
                 scoreDist: [
                     { label: "优秀(≥90)", key: "excellent", count: bucket.excellent },
@@ -885,189 +1353,16 @@ export default [
         },
     },
 
-    /* ---------- 课程作业 v1：提交情况 / 批改 / 催交 ---------- */
+    /* ---------- 文件 ---------- */
     {
-        // 某作业的提交名单（按班级分组）+ 汇总；submitStatus: all/unsubmitted/submitted/pending/graded/needRedo
-        url: "/api/homework/Submissions",
-        method: "get",
-        response: ({ query }: any) => {
-            const n = homeworks.find((x) => x.id === Number(query.serid));
-            if (!n) return fail("作业不存在或已被删除");
-            let list = subsOf(n.id);
-            const st = query.submitStatus || query.status;
-            if (st && st !== "all") {
-                if (st === "unsubmitted") list = list.filter((s) => s.submitStatus === "unsubmitted");
-                else if (st === "submitted" || st === "pending") list = list.filter((s) => s.submitStatus === "submitted");
-                else if (st === "graded") list = list.filter((s) => s.submitStatus === "graded" || s.submitStatus === "redone");
-                else if (st === "needRedo") list = list.filter((s) => s.submitStatus === "needRedo");
-            }
-            const byClass: Record<string, any[]> = {};
-            list.forEach((s) => {
-                (byClass[s.className] = byClass[s.className] || []).push({
-                    subId: s.id,
-                    studentId: s.studentId,
-                    studentName: s.studentName,
-                    submitStatus: s.submitStatus,
-                    submittedAt: s.submittedAt,
-                    hasGrade: !!s.grade,
-                    score: s.grade ? s.grade.score : null,
-                    level: s.grade ? s.grade.level : null,
-                    isExcellent: s.grade ? !!s.grade.isExcellent : false,
-                });
-            });
-            return ok({
-                homeworkId: n.id,
-                title: n.title,
-                subject: n.subject,
-                deadline: n.deadline,
-                hwStatus: n.hwStatus,
-                hwStatusDesc: HW_STATUS_DESC[n.hwStatus] || "收集中",
-                summary: progressOf(n.id),
-                groups: Object.keys(byClass).map((cn) => ({ className: cn, students: byClass[cn] })),
-            });
-        },
-    },
-    {
-        // 单份提交详情（供批改工作台右侧展示）
-        url: "/api/homework/SubmissionDetail",
-        method: "get",
-        response: ({ query }: any) => {
-            const s = submissions.find((x) => x.id === Number(query.subId));
-            if (!s) return fail("提交记录不存在");
-            const n = homeworks.find((h) => h.id === s.homeworkId);
-            return ok({
-                subId: s.id,
-                homeworkId: s.homeworkId,
-                homeworkTitle: n ? n.title : "",
-                subject: n ? n.subject : "",
-                studentId: s.studentId,
-                studentName: s.studentName,
-                classId: s.classId,
-                className: s.className,
-                submitStatus: s.submitStatus,
-                submittedAt: s.submittedAt,
-                text: s.text,
-                images: s.images,
-                attachments: s.attachments,
-                grade: s.grade,
-            });
-        },
-    },
-    {
-        // 批改：action=grade(默认)/redo(要求订正)/excellent(标优秀)；JSON body
-        url: "/api/homework/Grade",
+        url: "/api/file/Upload",
         method: "post",
-        response: ({ body, query }: any) => {
-            const b = bodyOf(body, query);
-            const s = submissions.find((x) => x.id === Number(b.subId ?? b.id));
-            if (!s) return fail("提交记录不存在");
-            const action = b.action || "grade";
-            if (action === "redo") {
-                s.submitStatus = "needRedo";
-                if (s.grade) s.grade.comment = b.comment ?? s.grade.comment;
-                return ok({ submitStatus: s.submitStatus, progress: progressOf(s.homeworkId) });
-            }
-            s.grade = {
-                score: b.score !== undefined && b.score !== "" ? Number(b.score) : s.grade ? s.grade.score : null,
-                level: b.level !== undefined ? b.level : s.grade ? s.grade.level : null,
-                comment: b.comment !== undefined ? b.comment : s.grade ? s.grade.comment : "",
-                isExcellent: action === "excellent" ? true : b.isExcellent !== undefined ? !!b.isExcellent : s.grade ? !!s.grade.isExcellent : false,
-                markedImages: b.markedImages !== undefined ? b.markedImages : s.grade ? s.grade.markedImages : [],
-            };
-            s.submitStatus = "graded";
-            return ok({ submitStatus: s.submitStatus, grade: s.grade, progress: progressOf(s.homeworkId) });
-        },
-    },
-    {
-        // 催交：对未交学生发提醒（mock 返回提醒人数，并把作业 smsFlag 置 1）
-        url: "/api/homework/Remind",
-        method: "post",
-        response: ({ body, query }: any) => {
-            const b = bodyOf(body, query);
-            const n = homeworks.find((x) => x.id === Number(b.serid));
-            if (!n) return fail("作业不存在");
-            const un = subsOf(n.id).filter((s) => s.submitStatus === "unsubmitted").length;
-            n.smsFlag = 1;
-            return ok({ reminded: un });
-        },
-    },
-
-    /* ---------- v2 学生端：我的作业 / 提交 / 反馈 ---------- */
-    {
-        url: "/api/homework/MyHomeworks",
-        method: "get",
         response: () => {
-            const list = viewerHomeworks();
-            return ok({ buckets: viewerBuckets(list), list });
+            const id = nextFileId++;
+            filesStore[id] = { id, filename: `课程作业附件${id}.png`, fileTrueName: `课程作业附件${id}.png`, size: 12288 };
+            return ok({ fileid: id, name: filesStore[id].filename, host: "", fileurl: `/api/file/Preview?id=${id}`, type: "png", size: 12288 });
         },
     },
-    {
-        // 我的某份作业：作业信息 + 本人提交/批改
-        url: "/api/homework/MySubmission",
-        method: "get",
-        response: ({ query }: any) => {
-            const hw = homeworks.find((h) => h.id === Number(query.serid));
-            if (!hw) return fail("作业不存在");
-            const s = submissions.find((x) => x.homeworkId === hw.id && x.studentId === DEMO_STUDENT.studentId);
-            return ok({
-                homework: {
-                    id: hw.id,
-                    title: hw.title,
-                    subject: hw.subject,
-                    content: hw.content,
-                    deadline: hw.deadline,
-                    submitType: hw.submitType,
-                    publisherName: hw.publisherName,
-                    deptName: hw.deptName,
-                },
-                my: s
-                    ? { subId: s.id, submitStatus: s.submitStatus, submittedAt: s.submittedAt, text: s.text, images: s.images, attachments: s.attachments, grade: s.grade }
-                    : null,
-            });
-        },
-    },
-    {
-        // 学生提交 / 订正重交（body: serid, text, images, attachments）
-        url: "/api/homework/Submit",
-        method: "post",
-        response: ({ body, query }: any) => {
-            const b = bodyOf(body, query);
-            const hw = homeworks.find((h) => h.id === Number(b.serid));
-            if (!hw) return fail("作业不存在");
-            if ((hw.submitType || []).includes("none")) return fail("该作业仅要求查阅，无需提交");
-            if (hw.hwStatus === "closed" && !hw.allowLate) return fail("该作业已过截止时间且未开放补交，请联系老师");
-            const parseArr = (v: any) => (Array.isArray(v) ? v : String(v || "").split(",").filter(Boolean));
-            let s = submissions.find((x) => x.homeworkId === hw.id && x.studentId === DEMO_STUDENT.studentId);
-            if (!s) {
-                s = {
-                    id: subSeq++,
-                    homeworkId: hw.id,
-                    studentId: DEMO_STUDENT.studentId,
-                    studentName: DEMO_STUDENT.studentName,
-                    classId: String(DEMO_STUDENT.classId),
-                    className: DEMO_STUDENT.className,
-                    submittedAt: null,
-                    submitStatus: "unsubmitted",
-                    text: "",
-                    images: [],
-                    attachments: [],
-                    grade: null,
-                };
-                submissions.push(s);
-            }
-            s.text = b.text !== undefined ? b.text : s.text;
-            s.images = parseArr(b.images);
-            s.attachments = parseArr(b.attachments);
-            s.submittedAt = nowStr();
-            s.submitStatus = s.submitStatus === "needRedo" ? "redone" : "submitted";
-            s.grade = null;
-            return ok({ subId: s.id, submitStatus: s.submitStatus });
-        },
-    },
-
-    /* ---------- 审批功能已移除（课程作业不做审批） ---------- */
-
-    /* ---------- 附件上传 ---------- */
     {
         url: "/api/base/FileUpload",
         method: "post",
@@ -1087,9 +1382,44 @@ export default [
         },
     },
     { url: "/api/file/Preview", method: "get", response: () => ok({ id: 0, fileurl: mockImageDataURL() }) },
+    { url: "/api/file/Down", method: "get", response: () => ok({ id: 0, fileurl: mockImageDataURL() }) },
 ];
 
-/** 内联 SVG data URL，作为 mock 预览图片（可带编号区分） */
+/* ============================ 提交内核（对齐后端 doSubmit） ============================ */
+
+function newSubmission(n: any, submitStatus: SubmitSt, isLate: number, text: any, atts: any[], version: number): any {
+    return {
+        id: subSeq++,
+        homeworkId: n.id,
+        studentId: DEMO_STUDENT.studentId,
+        studentName: DEMO_STUDENT.studentName,
+        classId: String(DEMO_STUDENT.classId),
+        className: DEMO_STUDENT.className,
+        version,
+        isLatest: 1,
+        submitStatus,
+        isLate,
+        submittedAt: submitStatus === "NOT_SUBMITTED" ? null : nowStr(),
+        text: (n.submitType || []).includes("text") ? text ?? null : null,
+        attachments: atts || [],
+        score: null,
+        comment: null,
+        reviewStatus: "PENDING",
+        reviewedBy: null,
+        reviewedAt: null,
+    };
+}
+
+function doSubmit(n: any, text: any, atts: any[], late: boolean): number {
+    const previous = latestOf(n.id, DEMO_STUDENT.studentId);
+    if (previous) previous.isLatest = 0;
+    const nextVersion = submissions.filter((s) => s.homeworkId === n.id && s.studentId === DEMO_STUDENT.studentId).reduce((m, s) => Math.max(m, s.version), 0) + 1;
+    const row = newSubmission(n, late ? "LATE_SUBMITTED" : "SUBMITTED", late ? 1 : 0, text, atts, nextVersion);
+    submissions.push(row);
+    return row.id;
+}
+
+/** 内联 SVG data URL，作为 mock 作答图片（可带编号区分） */
 function mockImageDataURL(id?: number) {
     const label = id ? `课程作业 图片#${id}` : "课程作业 Mock 图片";
     const svg =
diff --git a/src/auto-imports.d.ts b/src/auto-imports.d.ts
index ad00fe2..42e2627 100644
--- a/src/auto-imports.d.ts
+++ b/src/auto-imports.d.ts
@@ -6,7 +6,6 @@
 // biome-ignore lint: disable
 export {}
 declare global {
-  const $$userConfigMap: typeof import('./api/index')['$$userConfigMap']
   const Button: typeof import('view-ui-plus')['Button']
   const EffectScope: typeof import('vue')['EffectScope']
   const Form: typeof import('view-ui-plus')['Form']
@@ -16,8 +15,6 @@ declare global {
   const Modal: typeof import('view-ui-plus')['Modal']
   const Select: typeof import('view-ui-plus')['Select']
   const Table: typeof import('view-ui-plus')['Table']
-  const alovaInstance: typeof import('./api/index')['alovaInstance']
-  const api: typeof import('./api/index')['default']
   const apiDefinitions: typeof import('./api/apiDefinitions')['default']
   const computed: typeof import('vue')['computed']
   const createApis: typeof import('./api/createApis')['createApis']
diff --git a/src/components/ClassCheckInput.vue b/src/components/ClassCheckInput.vue
deleted file mode 100644
index 353cde4..0000000
--- a/src/components/ClassCheckInput.vue
+++ /dev/null
@@ -1,132 +0,0 @@
-<template>
-    <!-- 作业对象选择：全部班级 / 指定班级（学生场景，复用 UserCheckModal 树选弹窗） -->
-    <div class="check-user-wrap">
-        <div class="check-user-box">
-            <RadioGroup v-model="isAllClass" class="radio" @on-change="onScopeChange">
-                <Radio :disabled="editDisabled" :label="0">{{ isEdit ? "现有班级" : "全部班级" }}</Radio>
-                <Radio :label="1">指定班级</Radio>
-            </RadioGroup>
-            <Input type="text" v-model="classStr" readonly :disabled="!isAllClass" placeholder="选择通知的班级" class="input"></Input>
-            <Button icon="md-add" @click="openPicker" :disabled="!isAllClass"></Button>
-            <Button icon="md-trash" @click="reset" :disabled="!isAllClass"></Button>
-        </div>
-        <UserCheckModal ref="picker" :sources="sources" :userids="tempIds" @on-submit="submit" />
-    </div>
-</template>
-
-<script lang="ts">
-/*
- * 班级选择输入（学生场景）。v-model = "all" 或 班级 id 逗号串。
- * 数据源为「年级 → 班级」树（base/GetClassTree），叶子为班级，弹窗仅收集叶子 id。
- */
-import UserCheckModal from "@/components/UserCheckModal.vue";
-import { baseApi } from "@/api/module/homework";
-
-export default {
-    name: "ClassCheckInput",
-    components: { UserCheckModal },
-    props: {
-        modelValue: { type: String, default: "all" },
-        /** 编辑态：全部班级选项禁用为「现有班级」 */
-        isEdit: { type: Boolean, default: false },
-    },
-    emits: ["update:modelValue"],
-    data() {
-        return {
-            isAllClass: 0 as number,
-            tempIds: [] as number[],
-            classStr: "",
-            editDisabled: false,
-            sources: [{ name: "班级", loader: () => baseApi.getClassTree().send() as Promise<any[]> }],
-        };
-    },
-    created() {
-        this.syncFromValue(this.modelValue);
-    },
-    methods: {
-        idsFromVal(val: string): number[] {
-            return String(val || "")
-                .split(",")
-                .map((x) => parseInt(x))
-                .filter((x) => !isNaN(x));
-        },
-        syncFromValue(val: string) {
-            if (val === "all") {
-                this.isAllClass = 0;
-                this.classStr = this.isEdit ? "现有班级" : "全部班级";
-            } else if (val === "") {
-                this.isAllClass = 1;
-                this.classStr = "";
-                this.tempIds = [];
-            } else {
-                this.isAllClass = 1;
-                this.tempIds = this.idsFromVal(val);
-                this.classStr = "";
-            }
-        },
-        onScopeChange(type: number) {
-            const tempIds = this.idsFromVal(String(this.modelValue || ""));
-            if (type === 0) {
-                if (this.isEdit) {
-                    this.tempIds = tempIds;
-                    this.classStr = "现有班级";
-                    this.$emit("update:modelValue", String(tempIds));
-                } else {
-                    this.tempIds = [];
-                    this.classStr = "全部班级";
-                    this.$emit("update:modelValue", "all");
-                }
-            } else {
-                if (this.isEdit) this.editDisabled = true;
-                this.tempIds = tempIds;
-                this.classStr = "";
-                this.openPicker();
-            }
-        },
-        openPicker() {
-            (this.$refs.picker as any).show();
-        },
-        reset() {
-            this.tempIds = [];
-            this.classStr = "";
-            this.$emit("update:modelValue", "");
-        },
-        submit(arr: any[]) {
-            this.classStr = arr.map((x) => x.name).join("、");
-            const ids = arr.map((x) => x.id).join(",");
-            this.$emit("update:modelValue", ids || "all");
-            if (!arr.length) {
-                this.isAllClass = 0;
-                this.classStr = "全部班级";
-                this.$emit("update:modelValue", "all");
-            }
-        },
-    },
-    watch: {
-        modelValue(val: string) {
-            this.syncFromValue(val);
-        },
-    },
-};
-</script>
-
-<style lang="scss" scoped>
-.check-user-wrap {
-    width: 100%;
-    .check-user-box {
-        display: flex;
-        align-items: center;
-        gap: 8px;
-        .radio {
-            width: 180px;
-            flex: none;
-            font-size: 12px;
-            vertical-align: middle;
-            line-height: 32px;
-        }
-        .input {
-            flex: 1;
-        }
-    }
-}
-</style>
diff --git a/src/components/HomeworkUpload.vue b/src/components/HomeworkUpload.vue
deleted file mode 100644
index c3f8e3d..0000000
--- a/src/components/HomeworkUpload.vue
+++ /dev/null
@@ -1,116 +0,0 @@
-<template>
-    <div class="homework-upload">
-        <!-- 自定义上传附件（自旧前端 oldfront/src/components/uploadFile.vue 适配） -->
-        <div class="upload-row">
-            <Upload
-                :on-success="encloSuccess"
-                :on-remove="encloRemove"
-                :default-file-list="defaultList"
-                :action="uploadFileUrl"
-                :accept="fileType"
-                :multiple="isMultiple"
-                :before-upload="handleUpload"
-                :format="formatArr"
-                :max-size="maxSize"
-                :on-format-error="handleFormatError"
-                :on-exceeded-size="handleExceeded"
-            >
-                <Button><Icon type="ios-cloud-upload-outline"></Icon>选择文件</Button>
-            </Upload>
-            <span class="upload-tip">提示：附件大小不超过{{ maxFileSize }}</span>
-        </div>
-    </div>
-</template>
-
-<script lang="ts">
-/*
- * 作业附件上传（自旧前端 oldfront/src/components/uploadFile.vue 适配 Vue3）。
- * v-model 为已上传附件 fileid 数组；编辑时经 defaultList 回显已有附件。
- */
-import { Message, Homework } from "view-ui-plus";
-import config from "@/assets/config/host.config";
-
-export default {
-    name: "HomeworkUpload",
-    props: {
-        defaultList: { type: Array as () => any[], default: () => [] },
-        fileids: { type: Array as () => number[], default: () => [] },
-        fileType: { type: String, default: "" },
-        multiple: { type: Boolean, default: false },
-    },
-    emits: ["update:fileids"],
-    data() {
-        return {
-            isMultiple: !this.multiple || false,
-            uploadFileUrl: (config.isMock ? "" : config.serviceHost) + "/api/base/FileUpload",
-            formatArr: ["jpg", "gif", "png", "bmp", "xls", "doc", "txt", "docx", "xlsx", "zip", "rar", "pdf", "ppt", "pptx", "wps"],
-            maxFileSize: "200MB",
-            maxSize: 204800,
-        };
-    },
-    methods: {
-        encloSuccess(resp: any, file: any) {
-            if (resp.code !== 0) {
-                Message.error(resp.msg || "上传失败");
-                return;
-            }
-            this.fileids.push(resp.data.fileid);
-            this.$emit("update:fileids", this.fileids);
-        },
-        encloRemove(file: any) {
-            //删除文件：默认列表项带 fileid，刚上传的取 response
-            const list = file.fileid ? file : file.response;
-            let fileid = list?.fileid || list?.data?.fileid;
-            const arry = this.fileids.filter((element: number) => element != fileid);
-            this.$emit("update:fileids", arry);
-        },
-        handleUpload() {
-            if (!this.isMultiple && this.fileids.length > 0) {
-                Message.info("仅允许上传一个附件！");
-                return false;
-            }
-            return true;
-        },
-        handleFormatError() {
-            Homework.info({
-                title: "不支持的上传类型！",
-                desc: "请上传指定的文件类型",
-            });
-        },
-        handleExceeded() {
-            Homework.warning({
-                title: "超出大小限制",
-                desc: "最大文件大小为" + this.maxFileSize + "!",
-            });
-        },
-    },
-};
-</script>
-
-<style lang="scss" scoped>
-.homework-upload {
-    display: block;
-    .upload-row {
-        display: flex;
-        align-items: center;
-    }
-    :deep(.ivu-upload) {
-        display: inline-flex;
-        align-items: center;
-    }
-    /* 文件列表整体另起一行，每项独占一行，不再与按钮挤在一起 */
-    :deep(.ivu-upload-list) {
-        display: block;
-        margin-top: 8px;
-    }
-    :deep(.ivu-upload-list-file) {
-        padding: 4px 0;
-    }
-    .upload-tip {
-        margin-left: 10px;
-        color: #f90;
-        font-size: 12px;
-        line-height: 1;
-    }
-}
-</style>
diff --git a/src/components/ReviewModal.vue b/src/components/ReviewModal.vue
index 1f0d9bc..79cf137 100644
--- a/src/components/ReviewModal.vue
+++ b/src/components/ReviewModal.vue
@@ -2,8 +2,8 @@
     <!-- V2 批阅弹窗：ReviewWorkbench 的弹窗形态（学生矩阵行内批阅用）。
          批改中心（Grade.vue）直接内嵌 ReviewWorkbench，不经过本组件。 -->
     <Modal
-        :value="open"
-        @input="$emit('update:open', $event)"
+        :model-value="open"
+        @update:model-value="$emit('update:open', $event)"
         :title="`批阅 · ${student?.studentName || ''}`"
         width="640px"
         :mask-closable="false"
diff --git a/src/components/ReviewWorkbench.vue b/src/components/ReviewWorkbench.vue
index f5f3312..959fad4 100644
--- a/src/components/ReviewWorkbench.vue
+++ b/src/components/ReviewWorkbench.vue
@@ -91,6 +91,10 @@ import { ref, reactive, computed, watch } from "vue";
 import { Message } from "view-ui-plus";
 import { teacherApi } from "@/api/module/teacherHomework";
 import type { AttachmentItem, SubmissionVersionVo, StudentMatrixVo } from "@/types/homeworkV2";
+import config from "@/assets/config/host.config";
+
+/** 附件地址前缀：本地 dev/mock 走同源代理（空），线上为基础平台域名（含后端 contextPath） */
+const serviceBase = config.isMock ? "" : config.serviceHost;
 
 const props = defineProps<{
     homeworkId: number;
@@ -152,13 +156,14 @@ async function load() {
 const imageAtts = computed(() => (cur.value?.attachments || []).filter((a) => (a.fileType || "").toLowerCase() === "image"));
 const fileAtts = computed(() => (cur.value?.attachments || []).filter((a) => (a.fileType || "").toLowerCase() !== "image"));
 
-/** 附件展示地址：fileUrl 已是 /api/file/Preview?id= 相对路径；绝对地址原样 */
+/** 附件展示地址：fileUrl 可能是 /api/file/Preview?id= 相对路径（需拼 serviceHost），绝对地址原样 */
 function attUrl(a: AttachmentItem): string {
-    if (/^(https?:)?\/\//.test(a.fileUrl) || a.fileUrl.startsWith("data:")) return a.fileUrl;
-    return a.fileUrl;
+    const u = a.fileUrl || "";
+    if (/^(https?:)?\/\//.test(u) || u.startsWith("data:")) return u;
+    return `${serviceBase}${u}`;
 }
 function attDownUrl(a: AttachmentItem): string {
-    return a.fileId ? `/api/file/Down?id=${a.fileId}` : a.fileUrl;
+    return a.fileId ? `${serviceBase}/api/file/Down?id=${a.fileId}` : attUrl(a);
 }
 
 const imgZoom = reactive({ open: false, url: "" });
diff --git a/src/components/UserCheckModal.vue b/src/components/UserCheckModal.vue
deleted file mode 100644
index 49e6a31..0000000
--- a/src/components/UserCheckModal.vue
+++ /dev/null
@@ -1,446 +0,0 @@
-<template>
-    <Modal
-        v-model="modal"
-        title="选择用户"
-        width="720px"
-        :mask-closable="false"
-        :closable="false"
-    >
-        <Tabs
-            v-if="sources.length > 1"
-            :key="tabKey"
-            type="card"
-            :value="String(tabIndex)"
-            @on-click="tabChange"
-        >
-            <TabPane v-for="(item, index) in sources" :key="index" :label="item.name" :name="index + ''"></TabPane>
-        </Tabs>
-        <AutoComplete
-            @on-search="handleSearch"
-            @on-select="handleSelect"
-            placeholder="输入名字搜索"
-            v-model="searchTreeName"
-            :clearable="true"
-            class="auto-box"
-        >
-            <Option v-for="item in searchResult" :key="item.id" :value="item.name">
-                <span>{{ item.name }}</span>
-                <span class="fr info">{{ item.group }}</span>
-            </Option>
-        </AutoComplete>
-        <div class="tree-wrap fix">
-            <div class="tree-panel fl">
-                <div class="tree-box">
-                    <div :id="ztreeDomId" class="ztree"></div>
-                </div>
-            </div>
-            <div class="arrow-box fl">
-                <svg
-                    t="1626916477711"
-                    class="icon"
-                    viewBox="0 0 1024 1024"
-                    version="1.1"
-                    xmlns="http://www.w3.org/2000/svg"
-                    width="36"
-                    height="36"
-                >
-                    <path
-                        d="M138.935 256.078v511.844h63.42V256.078h-63.42z m126.842 0v511.844h127.215V256.078H265.777zM885.064 512L583.254 64.323v191.755H456.414v511.844h126.842v191.755L885.064 512z"
-                        fill="#2d8cf0"
-                    ></path>
-                </svg>
-            </div>
-            <div class="user-panel fl">
-                <div class="title-box fix">
-                    <Checkbox @on-change="checkAllUser" v-model="isCheckUserAll">全选</Checkbox>
-                    <div class="fr">{{ tempUserList.length }}</div>
-                    <a
-                        href="javascript:;"
-                        @click="delCheckUser"
-                        v-if="tempUserList.findIndex((x: any) => x.isCheck) > -1"
-                        >删除选中</a
-                    >
-                </div>
-                <ul class="user-box">
-                    <li
-                        v-for="item in tempUserList"
-                        :key="item.id"
-                        :class="{ active: item.isCheck }"
-                        @click="checkUserOne(item)"
-                    >
-                        {{ item.name }}
-                        <span class="info">{{ item.group }}</span>
-                    </li>
-                </ul>
-            </div>
-        </div>
-        <template #footer>
-            <Button type="primary" @click="submit">提交</Button>
-            <Button @click="modal = false" style="margin-left: 8px">取消</Button>
-        </template>
-    </Modal>
-</template>
-
-<script lang="ts">
-/*
- * 选择用户弹窗（自旧前端 oldfront/src/components/userCheck.vue 适配 Vue3）。
- * 左侧为带复选框的组织树（部门→人员，叶子=人员），勾选/取消按父子级联；
- * 右侧为已选人员列表，支持全选/删除选中；提交返回去重后的用户 id 数组与用户对象数组。
- */
-import { Message } from "view-ui-plus";
-import { requireImg } from "@/utils/hook/useImg";
-
-interface SelectSource {
-    name: string;
-    loader: () => Promise<any[]>;
-}
-
-export default {
-    name: "UserCheckModal",
-    props: {
-        /** 数据源 tab：{ name, loader }，loader 返回 ztree 树数据（children 嵌套，叶子=人员） */
-        sources: {
-            type: Array as () => SelectSource[],
-            default: () => [],
-        },
-        /** 已选用户 id（打开时自动勾选） */
-        userids: {
-            type: Array as () => number[],
-            default: () => [],
-        },
-        isDisabled: {
-            type: Boolean,
-            default: false,
-        },
-    },
-    emits: ["update:userids", "on-submit"],
-    data() {
-        return {
-            ztreeDomId: "user_check_tree_" + Math.floor(Math.random() * 1e8),
-            modal: false,
-            tabIndex: 0,
-            /** 每次打开弹窗自增，强制重建 Tabs，避免上次 tab 高亮残留与数据错位 */
-            tabKey: 0,
-            /** 树加载序号：tab 快速切换时只渲染最后一次请求的结果 */
-            treeSeq: 0,
-            isCheckUserAll: false,
-            cacheMap: new Map(),
-            currentTree: [] as any[],
-            searchTreeName: "",
-            searchResult: [] as any[],
-            tempUserList: [] as any[],
-        };
-    },
-    computed: {
-        /** 当前树扁平化（含父级名称，供搜索展示） */
-        currentTreeFlatten(): any[] {
-            const flatten = (data: any[], pid: number, pname: string): any[] =>
-                data.reduce(
-                    (arr: any[], { id, name, children = [], type }: any) =>
-                        arr.concat([{ id, name, pid, type, group: pname }], flatten(children, id, name)),
-                    []
-                );
-            return flatten(this.currentTree, 0, "");
-        },
-    },
-    methods: {
-        show() {
-            this.modal = true;
-            // 重置到第一个 tab：显式赋值 + key 重建 Tabs，保证高亮与数据一致
-            this.tabIndex = 0;
-            this.tabKey++;
-            this.changeEmpty();
-            this.initTree();
-        },
-        tabChange(index: string) {
-            const idx = Number(index);
-            // 严格比较：v-model 场景下 iview 会把值写成字符串 name，
-            // 宽松相等（"1" == 1）会误判“未切换”导致 tab 永远不生效
-            if (idx !== 0 && this.tabIndex === idx) return;
-            this.tabIndex = idx;
-            this.changeEmpty();
-            this.initTree();
-        },
-        handleSearch(query: string) {
-            let arr: any[] = [];
-            const searchArr = this.currentTreeFlatten.filter(
-                (x: any) => x.type == 2 && x.name.indexOf(query) != -1
-            );
-            for (const item of searchArr) {
-                !arr
-                    .map((x) => this.getSplitId(x.id))
-                    .includes(this.getSplitId(item.id)) && arr.push(item);
-            }
-            this.searchResult = arr;
-        },
-        handleSelect(query: string) {
-            if (query.indexOf(",") != -1) query = query.split(",")[0];
-            var treeObj = ($.fn as any).zTree.getZTreeObj(this.ztreeDomId);
-            var node = treeObj.getNodeByParam("name", query, null);
-            if (!!node) treeObj.checkNode(node, true, true, true);
-        },
-        /**
-         * ztree 数据预处理：拼接 pid 保证同人多组时 id 可区分；叶子标记 type=2。
-         * 组/用户判定优先用接口 isParent（组=文件夹），缺失时按有无子节点兜底；
-         * 并设置组/用户区分图标。
-         */
-        formatTree(tree: any[], level = 0, pid: number = 0) {
-            tree.forEach((element: any) => {
-                element.open = level == 0;
-                element.pid = pid;
-                element.id = element.id + "," + pid;
-                element.checked = false;
-                if (typeof element.isParent !== "undefined") {
-                    element.type = element.isParent ? 1 : 2;
-                } else {
-                    element.type = element.children && element.children.length > 0 ? 1 : 2;
-                }
-                element.icon = requireImg(
-                    element.type == 1 ? "tree-icon-group.png" : "tree-icon-item.png",
-                    "image"
-                );
-                if (typeof element.children !== "undefined" && element.children.length > 0) {
-                    element.children = this.formatTree(element.children, level + 1, this.getSplitId(element.id));
-                }
-            });
-            return tree;
-        },
-        initTree() {
-            const _this = this;
-            // 竞态守卫：慢请求返回时若已切换 tab，丢弃结果
-            const seq = ++this.treeSeq;
-            const cacheKey = this.tabIndex;
-            const source = this.sources[this.tabIndex];
-            if (!source) return;
-            const cached = this.cacheMap.get(cacheKey);
-            if (cached) {
-                this.createTree(cached);
-                return;
-            }
-            source
-                .loader()
-                .then((data: any[]) => {
-                    if (seq !== _this.treeSeq) return;
-                    _this.cacheMap.set(cacheKey, data || []);
-                    _this.createTree(data || []);
-                })
-                .catch((e: any) => {
-                    if (seq === _this.treeSeq) Message.error(e?.message || "加载组织数据失败");
-                });
-        },
-        createTree(rawData: any[]) {
-            const _this = this;
-            var jtree = JSON.parse(JSON.stringify(rawData));
-            var ftree = _this.formatTree(jtree);
-            _this.currentTree = ftree;
-
-            let treeSetting: any = {
-                view: {
-                    dblClickExpand: false,
-                    showIcon: true,
-                },
-                check: {
-                    enable: true,
-                    chkboxType: { Y: "ps", N: "ps" },
-                },
-                callback: {},
-            };
-            /** 勾选变化后同步右侧已选列表：收集勾选节点子树内的所有叶子 */
-            function formatUser(treeNode: any, checked: boolean) {
-                const recursionCheckIds = (tree: any): any[] => {
-                    let arrIds: any[] = [];
-                    for (const key in tree) {
-                        const element = tree[key];
-                        if (element.type == 2 && !element.chkDisabled) {
-                            arrIds.push({ id: element.id, tid: element.tId });
-                        }
-                        if (typeof element.children !== "undefined" && element.children) {
-                            arrIds = [...arrIds, ...recursionCheckIds(element.children)];
-                        }
-                    }
-                    return arrIds;
-                };
-                const checkIds = recursionCheckIds([treeNode]);
-                const checkUserList = _this.currentTreeFlatten.filter((x: any) =>
-                    checkIds.map((x) => x.id).includes(x.id)
-                );
-                const checkUserArr: any[] = [];
-                for (const element of checkUserList) {
-                    var findObj = checkIds.find((x) => x.id == element.id);
-                    if (
-                        !!findObj &&
-                        checkUserArr.findIndex((x) => x.id == element.id) === -1 &&
-                        _this.tempUserList.findIndex((x) => x.id == element.id) === -1
-                    ) {
-                        checkUserArr.push({ ...element, isCheck: false, tid: findObj.tid });
-                    }
-                }
-                if (checked) {
-                    _this.tempUserList = _this.tempUserList.concat(checkUserArr);
-                } else {
-                    var ids = checkUserList.map((x) => x.id);
-                    _this.tempUserList = _this.tempUserList.filter((x) => !ids.includes(x.id));
-                }
-            }
-            treeSetting.callback.onClick = (event: any, treeId: string, treeNode: any) => {
-                let check = treeNode.checked;
-                let treeObj = ($.fn as any).zTree.getZTreeObj(treeId);
-                treeObj.checkNode(treeNode, !check, true);
-                formatUser(treeNode, treeNode.checked);
-            };
-            treeSetting.callback.onCheck = (event: any, treeId: string, treeNode: any) => {
-                formatUser(treeNode, treeNode.checked);
-            };
-            var treeObj = ($.fn as any).zTree.init($("#" + _this.ztreeDomId), treeSetting, ftree);
-            // 回显：已选用户打勾（callbackFlag=true 会触发 onCheck，同步右侧列表）
-            var nodes = treeObj.getNodesByFilter((x: any) =>
-                _this.userids.includes(_this.getSplitId(x.id))
-            );
-            var arr: any[] = [];
-            nodes.forEach((element: any) => {
-                var splitId = _this.getSplitId(element.id); //重复id只选择第一个
-                if (!arr.includes(splitId)) treeObj.checkNode(element, true, true, true);
-                if (_this.isDisabled) treeObj.setChkDisabled(element, true);
-                arr.push(splitId);
-            });
-        },
-        checkAllUser(check: boolean) {
-            this.tempUserList.forEach((element: any) => {
-                element.isCheck = check;
-            });
-        },
-        checkUserOne(item: any) {
-            item.isCheck = !item.isCheck;
-            const tlist = this.tempUserList;
-            this.isCheckUserAll =
-                tlist.length > 0 && tlist.filter((x) => x.isCheck).length == tlist.length;
-        },
-        delCheckUser() {
-            const _this = this;
-            const tlist = _this.tempUserList;
-            const delArr = tlist.filter((item: any) => item.isCheck);
-            var treeObj = ($.fn as any).zTree.getZTreeObj(_this.ztreeDomId);
-            delArr.forEach((element: any) => {
-                var node = treeObj.getNodeByTId(element.tid);
-                treeObj.checkNode(node, false, true, true);
-            });
-            _this.isCheckUserAll = false;
-        },
-        changeEmpty() {
-            this.tempUserList = [];
-            this.searchTreeName = "";
-            this.searchResult = [];
-        },
-        submit() {
-            const _this = this;
-            let idsArr = this.tempUserList.map((x: any) => _this.getSplitId(x.id));
-            idsArr = Array.from(new Set(idsArr));
-            this.$emit("update:userids", idsArr);
-            function delKey(obj: any, ...args: string[]) {
-                args.forEach((v) => delete obj[v]);
-                return obj;
-            }
-            const objArr: any[] = [];
-            idsArr.forEach((element) => {
-                let findObj = _this.tempUserList.find((x: any) => _this.getSplitId(x.id) == element);
-                findObj = delKey({ ...findObj }, "id", "isCheck", "tid", "pid", "type");
-                objArr.push({ ...findObj, id: element });
-            });
-            this.$emit("on-submit", objArr);
-            this.modal = false;
-        },
-        /** 树节点 id 形如 "1,301"（原id,父id），取真实 id */
-        getSplitId(strId: any) {
-            if (typeof strId === "string" && strId.indexOf(",") != -1) return parseInt(strId.split(",")[0]);
-            return strId;
-        },
-    },
-};
-</script>
-
-<style lang="scss" scoped>
-.tree-wrap {
-    height: 430px;
-    position: relative;
-}
-.tree-panel {
-    border: 1px solid #eee;
-    width: 280px;
-    height: 430px;
-    overflow: hidden;
-}
-.tree-box {
-    padding: 4px 0;
-    height: 428px;
-    width: auto;
-    overflow-y: auto;
-    border: none;
-}
-.user-panel {
-    border: 1px solid #eee;
-    width: 280px;
-    .title-box {
-        background: #f7f7f7;
-        height: 34px;
-        line-height: 34px;
-        padding: 0 12px;
-        a {
-            text-decoration: none;
-            float: right;
-            margin-right: 20px;
-            outline: none;
-        }
-    }
-    .user-box {
-        height: 396px;
-        overflow-y: auto;
-        li {
-            line-height: 32px;
-            padding-left: 12px;
-            cursor: pointer;
-            .info {
-                float: right;
-                margin-right: 12px;
-                font-size: 12px;
-                color: gray;
-            }
-        }
-        li:hover {
-            background: #f3f3f3;
-        }
-        li.active {
-            background: #e4edf6;
-        }
-    }
-}
-.arrow-box {
-    width: 128px;
-    text-align: center;
-    position: relative;
-    top: 50%;
-    margin-top: -17px;
-}
-.auto-box {
-    width: 200px;
-    margin-bottom: 10px;
-    :deep(.ivu-select-item .info) {
-        font-size: 12px;
-        color: gray;
-        position: relative;
-        top: 2px;
-    }
-}
-:deep(.ztree li) {
-    overflow: hidden;
-}
-:deep(.ztree li a) {
-    width: 100%;
-}
-:deep(.ztree li a:hover) {
-    text-decoration: none;
-}
-:deep(.ivu-auto-complete .ivu-select-dropdown-list) {
-    max-height: 310px;
-    overflow-y: auto;
-}
-</style>
diff --git a/src/types/homework.ts b/src/types/homework.ts
index 2e69f45..f399c86 100644
--- a/src/types/homework.ts
+++ b/src/types/homework.ts
@@ -1,17 +1,11 @@
 /**
- * 课程作业前端类型契约（P1-7）
+ * 课程作业 V1 冻结接口类型契约（M5 后待评估退役，见 m5-plan §2.3）。
  *
- * 与后端 VO/DTO 一一对齐：
- * - HomeworkVo → 后端 model/homework/HomeworkVo.java（Jackson 默认驼峰序列化）
- * - HomeworkDetailVo → 后端 model/homework/HomeworkDetailVo.java（@JsonProperty 保留旧字段名）
- * - BasePageResult → 后端 model/BasePageResult.java
- * - HomeworkPageResult extends BasePageResult → 后端 model/homework/HomeworkPageResult.java
- * - UpFileResultVo → 后端 model/homework/UpFileResultVo.java（@JsonProperty）
- * - UpFileVo → 后端 model/homework/UpFileVo.java
- * - InitializeRedVo → 后端 model/homework/InitializeRedVo.java（@JsonProperty）
- * - HomeworkStatisticsVo → 后端 model/homework/HomeworkStatisticsVo.java
- * - HomeworkRequest → 后端 model/homework/HomeworkRequest.java
- * - HomeworkQuery → 后端 model/homework/HomeworkQuery.java + BasePageQuery.java
+ * 仅服务未切换页面：/homeworklist（SendList/Delete）、/homeworklist/detail
+ * （Detail/GetNextPrev/ReadDetail）、/stats（Statis）、/list/new?fid= 转发回显
+ * （GetDetail/ChaoSend）。V2 契约在 types/homeworkV2.ts，两者互不引用。
+ * 与后端 VO/DTO 一一对齐：HomeworkVo/HomeworkDetailVo（@JsonProperty 保留旧字段名）、
+ * BasePageResult、UpFileResultVo/UpFileVo、HomeworkStatisticsVo、HomeworkQuery。
  */
 
 // ============================ 分页外壳 ============================
@@ -26,12 +20,6 @@ export interface BasePageResult<T> {
     hasNext: boolean;
 }
 
-/** 作业分页结果（对齐 HomeworkPageResult.java，扩展 unreadCount） */
-export interface HomeworkPageResult<T> extends BasePageResult<T> {
-    /** 当前用户未读作业总数 */
-    unreadCount: number;
-}
-
 // ============================ 作业列表项 ============================
 
 /** 作业视图对象（对齐 HomeworkVo.java，Jackson 默认驼峰序列化） */
@@ -159,13 +147,6 @@ export interface UpFileVo {
     topicType: string;
 }
 
-// ============================ 一键已读 ============================
-
-/** 一键已读结果（对齐 InitializeRedVo.java，@JsonProperty） */
-export interface InitializeRedVo {
-    count: number;
-}
-
 // ============================ 上一篇/下一篇 ============================
 
 /** 上一篇/下一篇作业ID */
@@ -212,14 +193,11 @@ export interface HomeworkStatisticsVo {
     scoreDist?: { label: string; key: string; count: number }[];
 }
 
-// ============================ 课程作业 v1：提交 / 批改 ============================
+// ============================ 课程作业 v1 状态与进度 ============================
 
 /** 作业流程状态 */
 export type HomeworkStatus = "draft" | "collecting" | "closed" | "done";
 
-/** 单个提交状态 */
-export type SubmitStatus = "unsubmitted" | "submitted" | "graded" | "needRedo" | "redone";
-
 /** 提交/批改进度 */
 export interface HomeworkProgress {
     /** 应交人数 */
@@ -242,111 +220,8 @@ export interface HomeworkProgress {
     gradeRate: number;
 }
 
-/** 提交名单项（Submissions 接口返回，精简） */
-export interface SubmissionBrief {
-    subId: number;
-    studentId: number;
-    studentName: string;
-    submitStatus: SubmitStatus;
-    submittedAt: string | null;
-    hasGrade: boolean;
-    score: number | null;
-    level: string | null;
-    isExcellent: boolean;
-}
-
-/** 提交名单按班级分组 */
-export interface SubmissionGroup {
-    className: string;
-    students: SubmissionBrief[];
-}
-
-/** 某作业提交情况结果 */
-export interface SubmissionsResultVo {
-    homeworkId: number;
-    title: string;
-    subject: string;
-    deadline: string | null;
-    hwStatus: HomeworkStatus;
-    hwStatusDesc: string;
-    summary: HomeworkProgress;
-    groups: SubmissionGroup[];
-}
-
-/** 批改结果 */
-export interface GradeResult {
-    score: number | null;
-    level: string | null;
-    comment: string;
-    isExcellent: boolean;
-    markedImages: string[];
-}
-
-/** 单份提交详情（批改工作台用） */
-export interface SubmissionDetailVo {
-    subId: number;
-    homeworkId: number;
-    homeworkTitle: string;
-    subject: string;
-    studentId: number;
-    studentName: string;
-    classId: string;
-    className: string;
-    submitStatus: SubmitStatus;
-    submittedAt: string | null;
-    text: string;
-    images: string[];
-    attachments: string[];
-    grade: GradeResult | null;
-}
-
-/** 批改入参 */
-export interface GradeRequest {
-    subId: number;
-    /** grade 保存批改 / redo 要求订正 / excellent 标为优秀 */
-    action?: "grade" | "redo" | "excellent";
-    score?: number | string;
-    level?: string;
-    comment?: string;
-    isExcellent?: boolean;
-    markedImages?: string[];
-}
-
 // ============================ 请求入参 ============================
 
-/** 作业发布/编辑入参（对齐 HomeworkRequest.java） */
-export interface HomeworkRequest {
-    title: string;
-    content?: string;
-    /** 学科 */
-    subject?: string;
-    /** 截止时间 yyyy-MM-dd HH:mm:ss */
-    deadline?: string;
-    /** 提交方式：text/image/attach/none */
-    submitType?: string[] | string;
-    type?: number;
-    deptId?: string;
-    /** 是否允许逾期补交 */
-    allowLate?: boolean;
-    /** 截止提醒：如 ["1d","1h"] */
-    remindBefore?: string[];
-    /** 存草稿：true 则不发布 */
-    draft?: boolean;
-    deptName?: string;
-    topmost?: number;
-    /** 接收对象："all" 或 班级 id 逗号串（receiveType=class） */
-    receiveList?: string;
-    /** 接收对象类型：class=班级 */
-    receiveType?: string;
-    /** 附件文件ID列表（逗号分隔串） */
-    fileIds?: string;
-    timingSendTime?: string;
-    /** 短信发送标记 */
-    smsFlag?: number;
-    /** 转发源作业ID */
-    sourceId?: number;
-}
-
 /** 作业列表查询参数（对齐 HomeworkQuery.java + BasePageQuery.java） */
 export interface HomeworkQuery {
     pageIndex?: number;
@@ -379,73 +254,3 @@ export interface SchoolTreeNode {
     [key: string]: any;
 }
 
-// ============================ 班级 ============================
-
-/** 年级→班级树节点（叶子=班级，id 为数字班级 id，附学生数） */
-export interface ClassTreeNode {
-    id: number;
-    name: string;
-    isParent: boolean;
-    studentCount?: number;
-    children?: ClassTreeNode[];
-    [key: string]: any;
-}
-
-// ============================ v2 学生端 ============================
-
-/** 当前视角角色（家长即登录学生账号，不单列） */
-export type ViewerRole = "teacher" | "student";
-
-/** 学生对某作业的提交/批改态 */
-export interface StudentSubmissionInfo {
-    subId: number;
-    submitStatus: SubmitStatus;
-    submittedAt: string | null;
-    text: string;
-    score: number | null;
-    level: string | null;
-    comment: string;
-    isExcellent: boolean;
-    images?: string[];
-    attachments?: string[];
-    grade?: GradeResult | null;
-}
-
-/** 学生视角作业项 */
-export interface StudentHomeworkVo {
-    id: number;
-    title: string;
-    subject: string;
-    publisherName: string;
-    deptName: string;
-    deadline: string | null;
-    createTime: string | null;
-    content: string;
-    submitType: string[];
-    viewOnly: boolean;
-    hwStatus?: HomeworkStatus;
-    allowLate?: boolean;
-    my: StudentSubmissionInfo | null;
-}
-
-/** 今日/我的作业列表 */
-export interface MyHomeworksVo {
-    buckets: { todo: number; submitted: number; graded: number; redo: number; all: number };
-    list: StudentHomeworkVo[];
-}
-
-/** 我的某作业详情（作业信息 + 我的提交/批改） */
-export interface MySubmissionVo {
-    homework: { id: number; title: string; subject: string; content: string; deadline: string | null; submitType: string[]; publisherName: string; deptName: string };
-    my: StudentSubmissionInfo | null;
-}
-
-/** 学生提交作业入参 */
-export interface SubmitRequest {
-    serid: number;
-    text?: string;
-    /** 图片 URL / dataURL 列表（逗号串或数组） */
-    images?: string[] | string;
-    /** 附件 id 列表（逗号串或数组） */
-    attachments?: string[] | string;
-}
diff --git a/src/types/homeworkV2.ts b/src/types/homeworkV2.ts
index 865e6fe..ded2ef6 100644
--- a/src/types/homeworkV2.ts
+++ b/src/types/homeworkV2.ts
@@ -240,6 +240,8 @@ export interface StudentHomeworkV2Vo {
     submitType: string[];
     hwStatus: HwStatusV2;
     hwStatusDesc: string;
+    /** 截止后是否允许逾期补交：0 否 / 1 是（CLOSED 时决定是否渲染「补交」入口） */
+    allowLate?: number;
     my: StudentMySubmission | null;
 }
 
diff --git a/src/views/homework/HomeworkStats.vue b/src/views/homework/HomeworkStats.vue
index 1a6cf71..7e9794c 100644
--- a/src/views/homework/HomeworkStats.vue
+++ b/src/views/homework/HomeworkStats.vue
@@ -23,12 +23,20 @@ onMounted(load);
 /* 分数分布条 */
 const maxDist = computed(() => Math.max(1, ...(stat.value?.scoreDist || []).map((d) => d.count)));
 const BAR_COLOR: Record<string, string> = { excellent: "#19be6b", good: "#2d8cf0", pass: "#ff9900", fail: "#ed4014" };
+/** 后端是否提供课程作业口径数据（老部署未升级时避免把「未返回」伪装成 0） */
+const hasScoreDist = computed(() => (stat.value?.scoreDist?.length ?? 0) > 0);
+const hasByHomework = computed(() => (stat.value?.byHomework?.length ?? 0) > 0);
+
+/** 卡片值：字段缺失显示「—」而非 0，避免被误读为「确实没有作业」 */
+function cardValue(v: number | undefined | null, suffix = ""): string {
+    return v === undefined || v === null ? "—" : `${v}${suffix}`;
+}
 
 const cards = computed(() => [
-    { label: "我布置的作业", value: stat.value?.myAssignCount ?? 0 },
-    { label: "待批改总量", value: stat.value?.pendingGrade ?? 0 },
-    { label: "平均提交率", value: (stat.value?.avgSubmitRate ?? 0) + "%" },
-    { label: "作业总数", value: stat.value?.total ?? 0 },
+    { label: "我布置的作业", value: cardValue(stat.value?.myAssignCount) },
+    { label: "待批改总量", value: cardValue(stat.value?.pendingGrade) },
+    { label: "平均提交率", value: cardValue(stat.value?.avgSubmitRate, "%") },
+    { label: "作业总数", value: cardValue(stat.value?.total) },
 ]);
 
 const HW_STATUS_TEXT: Record<string, string> = { draft: "草稿", collecting: "收集中", closed: "已截止", done: "已完成" };
@@ -52,7 +60,7 @@ const HW_STATUS_TEXT: Record<string, string> = { draft: "草稿", collecting: "
             <!-- 分数分布 -->
             <div class="block">
                 <div class="block-h">成绩分布（已批改提交）</div>
-                <div class="dist">
+                <div class="dist" v-if="hasScoreDist">
                     <div class="dist-row" v-for="d in stat.scoreDist" :key="d.key">
                         <div class="dist-label">{{ d.label }}</div>
                         <div class="dist-track">
@@ -61,12 +69,14 @@ const HW_STATUS_TEXT: Record<string, string> = { draft: "草稿", collecting: "
                         <div class="dist-num">{{ d.count }}</div>
                     </div>
                 </div>
+                <div class="block-empty" v-else>暂无可统计的批阅分数（后端未返回成绩分布口径）</div>
             </div>
 
             <!-- 各作业进度 -->
             <div class="block">
                 <div class="block-h">我布置的作业 · 提交与批改</div>
                 <Table
+                    v-if="hasByHomework"
                     :columns="[
                         { title: '作业', key: 'title', minWidth: 220, tooltip: true },
                         { title: '学科', key: 'subject', width: 90, align: 'center' },
@@ -85,6 +95,7 @@ const HW_STATUS_TEXT: Record<string, string> = { draft: "草稿", collecting: "
                     :data="stat.byHomework || []"
                     no-data-text="暂无需要收集提交记录的作业"
                 ></Table>
+                <div class="block-empty" v-else>暂无需要收集提交记录的作业（后端未返回按作业进度口径）</div>
             </div>
         </div>
         <div v-else class="main-container"><Spin fix /></div>
@@ -124,6 +135,11 @@ const HW_STATUS_TEXT: Record<string, string> = { draft: "草稿", collecting: "
         margin-bottom: 12px;
     }
 }
+.block-empty {
+    color: #a6aab0;
+    font-size: 13px;
+    padding: 12px 0;
+}
 .dist {
     .dist-row {
         display: flex;
diff --git a/src/views/homework/NewHomework.vue b/src/views/homework/NewHomework.vue
index b4005fd..8f63f9c 100644
--- a/src/views/homework/NewHomework.vue
+++ b/src/views/homework/NewHomework.vue
@@ -72,7 +72,7 @@ async function loadClasses() {
 function toggleAll(v: boolean) {
     if (v) selClasses.value = [...allClassIds.value];
 }
-onMounted(loadClasses);
+/* 班级树由下方统一初始化入口按序加载（fillFromV2 依赖 allClassIds 判定「全部班级」） */
 
 const ruleValidate = {
     title: [
@@ -147,6 +147,9 @@ function fillFromV2(d: HomeworkV2Vo) {
 }
 
 onMounted(async () => {
+    // 先加载班级树再回显：fillFromV2 用 allClassIds 判定「全部班级」，
+    // 若并行执行则 allClassIds 仍为空，勾选态会被误判为「未全选」
+    await loadClasses();
     if (!(isEdit.value || fid.value > 0)) return;
     try {
         if (isEdit.value) {
diff --git a/src/views/homework/StudentHomeworks.vue b/src/views/homework/StudentHomeworks.vue
index 49dd584..3dfe80a 100644
--- a/src/views/homework/StudentHomeworks.vue
+++ b/src/views/homework/StudentHomeworks.vue
@@ -272,8 +272,8 @@ function zoom(url: string) {
                     <div class="c-actions">
                         <Button v-if="['NOT_SUBMITTED'].includes(myStatus(row)) && canSubmit(row)" type="primary" icon="md-cloud-upload" size="small" @click="openSubmit(row)">
                             {{ row.hwStatus === "CLOSED" ? "补交作业" : "提交作业" }}</Button>
-                        <Button v-else-if="myStatus(row) === 'RETURNED'" type="error" icon="md-refresh" size="small" @click="openSubmit(row)">重新提交</Button>
-                        <template v-else-if="['SUBMITTED', 'LATE_SUBMITTED'].includes(myStatus(row)) && row.hwStatus === 'PUBLISHED'">
+                        <Button v-else-if="myStatus(row) === 'RETURNED' && canSubmit(row)" type="error" icon="md-refresh" size="small" @click="openSubmit(row)">重新提交</Button>
+                        <template v-else-if="['SUBMITTED', 'LATE_SUBMITTED'].includes(myStatus(row)) && canSubmit(row) && row.hwStatus === 'PUBLISHED'">
                             <Button ghost icon="md-create" size="small" @click="openSubmit(row)">修改提交</Button>
                             <Button icon="md-undo" size="small" @click="withdraw(row)">撤回</Button>
                         </template>
diff --git a/src/views/homework/TeacherHomeworks.vue b/src/views/homework/TeacherHomeworks.vue
index 9b294a0..95bbb45 100644
--- a/src/views/homework/TeacherHomeworks.vue
+++ b/src/views/homework/TeacherHomeworks.vue
@@ -252,11 +252,6 @@ function del(row: HomeworkV2Vo) {
     });
 }
 
-/* 文本按钮 */
-function btn(text: string, onClick: () => void) {
-    return h("Button", { type: "text", size: "small", onClick }, () => text);
-}
-
 /* ============ 已发布列表列 ============ */
 const pubColumns = computed(() => [
     { title: "序号", type: "index", width: 60, align: "center" },
@@ -335,44 +330,21 @@ const pubColumns = computed(() => [
     },
     {
         title: "操作",
-        width: 250,
+        slot: "action",
+        width: 230,
         align: "center",
         fixed: "right",
-        render: (h: any, p: any) => {
-            const row = p.row as HomeworkV2Vo;
-            const nodes: any[] = [];
-            nodes.push(btn("提交情况", () => viewSubmissions(row)));
-            if ((row.progress?.pendingGrade ?? 0) > 0) nodes.push(btn("批阅", () => toGrade(row)));
-            const more: any[] = [];
-            if (row.hwStatus === "PUBLISHED") {
-                if ((row.progress?.unread ?? 0) > 0) more.push(mItem("提醒未读", () => remind(row, "NOT_READ")));
-                if ((row.progress?.unsubmitted ?? 0) > 0) more.push(mItem("催交", () => remind(row, "NOT_SUBMITTED")));
-                more.push(mItem("延长截止", () => openExtend(row)));
-            }
-            more.push(mItem("复制", () => copyRow(row)));
-            if (row.hwStatus === "PUBLISHED" || row.hwStatus === "CLOSED") more.push(mItem("归档", () => archive(row)));
-            more.push(mItem("导出报表", () => doExport(row)));
-            nodes.push(
-                h("Dropdown", { transfer: true, onOnClick: (name: string) => onMore(name) }, () => [
-                    h("Button", { type: "text", size: "small" }, () => "更多∨"),
-                    h("DropdownMenu", { slot: "list" }, () => more),
-                ])
-            );
-            return h("div", {}, nodes);
-        },
     },
 ]);
 
-/* 更多菜单回调（闭包 name→action） */
-const moreActions = new Map<string, () => void>();
-let moreSeq = 0;
-function mItem(text: string, action: () => void) {
-    const key = `m${++moreSeq}`;
-    moreActions.set(key, action);
-    return h("DropdownItem", { name: key }, () => text);
-}
-function onMore(name: string) {
-    moreActions.get(name)?.();
+/* 更多菜单分发 */
+function onPubMore(name: string, row: HomeworkV2Vo) {
+    if (name === "notRead") remind(row, "NOT_READ");
+    else if (name === "notSubmitted") remind(row, "NOT_SUBMITTED");
+    else if (name === "extend") openExtend(row);
+    else if (name === "copy") copyRow(row);
+    else if (name === "archive") archive(row);
+    else if (name === "export") doExport(row);
 }
 
 /* ============ 草稿箱列 ============ */
@@ -401,18 +373,10 @@ const draftColumns = computed(() => [
     },
     {
         title: "操作",
+        slot: "draftAction",
         width: 250,
         align: "center",
         fixed: "right",
-        render: (h: any, p: any) => {
-            const row = p.row as HomeworkV2Vo;
-            const nodes: any[] = [];
-            nodes.push(btn("编辑", () => edit(row)));
-            nodes.push(btn("发布", () => publishDraft(row)));
-            if (row.hwStatus === "DRAFT_SCHEDULED") nodes.push(btn("取消定时", () => cancelSchedule(row)));
-            nodes.push(btn("删除", () => del(row)));
-            return nodes;
-        },
     },
 ]);
 
@@ -462,7 +426,33 @@ const tableHeight = computed(() => Utils.useTableHeight({ isSearch: true, isOper
                 :height="tableHeight"
                 :loading="loading"
                 no-data-text="暂无数据"
-            ></Table>
+            >
+                <!-- 已发布行操作 -->
+                <template #action="{ row }">
+                    <Button type="text" size="small" @click="viewSubmissions(row)">提交情况</Button>
+                    <Button v-if="(row.progress?.pendingGrade ?? 0) > 0" type="text" size="small" @click="toGrade(row)">批阅</Button>
+                    <Dropdown transfer @on-click="(name: string) => onPubMore(name, row)">
+                        <Button type="text" size="small">更多∨</Button>
+                        <template #list>
+                            <DropdownMenu>
+                                <DropdownItem v-if="row.hwStatus === 'PUBLISHED' && (row.progress?.unread ?? 0) > 0" name="notRead">提醒未读</DropdownItem>
+                                <DropdownItem v-if="row.hwStatus === 'PUBLISHED' && (row.progress?.unsubmitted ?? 0) > 0" name="notSubmitted">催交</DropdownItem>
+                                <DropdownItem v-if="row.hwStatus === 'PUBLISHED'" name="extend">延长截止</DropdownItem>
+                                <DropdownItem name="copy">复制</DropdownItem>
+                                <DropdownItem v-if="row.hwStatus === 'PUBLISHED' || row.hwStatus === 'CLOSED'" name="archive">归档</DropdownItem>
+                                <DropdownItem name="export">导出报表</DropdownItem>
+                            </DropdownMenu>
+                        </template>
+                    </Dropdown>
+                </template>
+                <!-- 草稿箱行操作 -->
+                <template #draftAction="{ row }">
+                    <Button type="text" size="small" @click="edit(row)">编辑</Button>
+                    <Button type="text" size="small" @click="publishDraft(row)">发布</Button>
+                    <Button v-if="row.hwStatus === 'DRAFT_SCHEDULED'" type="text" size="small" @click="cancelSchedule(row)">取消定时</Button>
+                    <Button type="text" size="small" @click="del(row)">删除</Button>
+                </template>
+            </Table>
             <div class="page-panel">
                 <div class="fl ml-15 align-middle"></div>
                 <Page
diff --git a/vite.config.ts b/vite.config.ts
index ddb6c6e..506b7a6 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -101,10 +101,13 @@ export default defineConfig(({ command, mode }: ConfigEnv): UserConfig => {
             port: 8077,
             proxy: {
                 // dev 正式模式：serviceHost 为空（同源相对路径 /api/...），经此代理转发到本地后端
-                // （后端 CAS 过滤器对 /api/* 不回 CORS 头，浏览器直连 8070 会被拦，必须同源代理）
+                // （后端 CAS 过滤器对 /api/* 不回 CORS 头，浏览器直连会被拦，必须同源代理）
                 "/api": {
-                    // target: "http://localhost:8101",
-                    target:"http://base.yunhaixingtong.com/homework/",
+                    // M5 联调：本地 ClassHomeWork 后端（application.yml server.port=8102，
+                    // 名册种子见后端 resources/sql/v3_seed.sql）
+                    target: "http://localhost:8102",
+                    // 远程测试环境（本地后端未启动时临时切回）：
+                    // target: "http://base.yunhaixingtong.com/homework/",
                     changeOrigin: true,
                 },
             },