feat(rbac): 成绩录入/导入放开到本班班主任（需求 6 与需求 7 口径统一）

依据: 需求 6 明确要求'成绩与表格导入……老师端与学生端班级账号均可用且不越权'，
      需求 7 的权限清单并未把成绩收归管理员专属（只限制班级增删改、人员分配与科任权限）。

变更:
- shared/permissions: canManageGrades(classRole) = ADMIN | HEAD；canImport 按 kind 分发
  （成绩=ADMIN|HEAD、名单=仅管理员、课表时间=ADMIN|HEAD）；PERMISSION_MATRIX 同步
- lib/access: assertCanManageGrades(user, classId) 异步按班级角色判定，科任/跨班给出针对性提示
- grades 服务与路由、imports 的模板/预览/提交路由放宽为 ADMIN|TEACHER，
  服务层按 kind + 班级二次校验（名单仍仅管理员，科任仍 403）
- Web 管理端: 成绩录入菜单对教师可见；写入/导入按钮仅对'管理员或所选班级班主任'显示

验证:
- verify:e2e 133/133（新增: 班主任录入本班成绩 201 + 跨班 403、班主任模板/预览/导入本班成绩可用、
  科任导入 403、班主任名单模板与导入 403、append 重复导入跳过）
- verify:web 19/19（新增: 班主任可见成绩导入入口并打开弹窗，越权入口仍隐藏、菜单 5 项）
- verify:desktop 47/47（未受影响）
文档: README 权限矩阵与'需求 6/7 口径统一'对照表、各项计数更新

packages/server/scripts/verify-e2e.mjs

@@ -622,8 +622,10 @@ async function main() {
   }
 
   // ---------------------------------------------------------------- 6.4 班级角色权限矩阵
-  // 依据需求：班主任/科任老师不能增删改班级；仅管理员可分配人员；
-  // 科任老师仅作业/叫人/通知；班主任另可管理本班课表；成绩录入仅管理员。
+  // 依据需求 7：班主任/科任老师不能增删改班级；仅管理员可分配人员；
+  // 科任老师仅作业/叫人/通知；班主任另可管理本班课表。
+  // 结合需求 6（成绩与表格导入"老师端可用且不越权"）：成绩写入放开到**本班班主任**，
+  // 科任老师仍然 403，班主任跨班同样 403。
   {
     record('管理员登录（用于权限矩阵校验）', Boolean(adminToken), '已在上文登录');
 
@@ -736,22 +738,45 @@ async function main() {
       });
       record('科任老师录入成绩被拒绝（403）', subjectGrades.status === 403, `status=${subjectGrades.status}`);
 
+      // 需求 6：班主任可以录入**本班**成绩（老师端可用），科任老师与跨班仍然被拒
       const headGrades = await api('/grades', {
         method: 'POST',
         token: teacherToken,
         body: {
           classId: classId,
           userId: studentUser?.id,
-          examName: '班主任越权成绩',
+          examName: '班主任本班成绩',
           score: 90,
           totalScore: 100,
         },
       });
       record(
-        '班主任录入成绩被拒绝（403，成绩仅管理员）',
-        headGrades.status === 403,
+        '班主任录入本班成绩成功（201，需求 6）',
+        headGrades.status === 201,
         `status=${headGrades.status}`,
       );
+      if (headGrades.payload?.data?.id) {
+        await api(`/grades/${headGrades.payload.data.id}`, { method: 'DELETE', token: teacherToken });
+      }
+
+      if (foreignClass) {
+        const headCrossGrades = await api('/grades', {
+          method: 'POST',
+          token: teacherToken,
+          body: {
+            classId: foreignClass.id,
+            userId: studentUser?.id,
+            examName: '班主任跨班成绩',
+            score: 90,
+            totalScore: 100,
+          },
+        });
+        record(
+          '班主任录入他人班级成绩被拒绝（403）',
+          headCrossGrades.status === 403,
+          `status=${headCrossGrades.status}`,
+        );
+      }
 
       const adminGrades = await api('/grades', {
         method: 'POST',
@@ -874,8 +899,22 @@ async function main() {
     `status=${templateXlsxResponse.status} bytes=${templateXlsxBuffer.length}`,
   );
 
-  const templateDenied = await api('/imports/template?kind=grades&format=csv', { token: teacherToken });
-  record('教师下载成绩模板被拒绝（403）', templateDenied.status === 403, `status=${templateDenied.status}`);
+  // 需求 6：成绩模板对老师端开放（空白模板，不含任何业务数据）；名单模板仍仅管理员
+  const teacherGradeTemplate = await api('/imports/template?kind=grades&format=csv', { token: teacherToken });
+  record(
+    '班主任可下载成绩模板（需求 6：老师端可用）',
+    teacherGradeTemplate.status === 200,
+    `status=${teacherGradeTemplate.status}`,
+  );
+
+  const teacherRosterTemplate = await api('/imports/template?kind=students&format=csv', {
+    token: teacherToken,
+  });
+  record(
+    '班主任下载名单模板被拒绝（403，名单仅管理员）',
+    teacherRosterTemplate.status === 403,
+    `status=${teacherRosterTemplate.status}`,
+  );
 
   // 8.2 ClassIsland 课表时间配置：预览 -> 导入 -> 失败回滚 -> 合并 -> 越权 -> 清理
   const sampleLayout = {
@@ -1142,15 +1181,18 @@ async function main() {
     `失败=${gradesBroken.payload?.data?.failed} 首条=第 ${brokenErrors[0]?.row} 行：${brokenErrors[0]?.message ?? ''}`,
   );
 
-  const gradesByTeacher = await api('/imports/table/commit', {
+  // 班主任（本班）重复导入 append 模式：已存在的记录应被跳过而不是报错（需求 6）
+  const gradesByHeadTeacher = await api('/imports/table/commit', {
     method: 'POST',
     token: teacherToken,
     body: { ...gradesCommitBody, mode: 'append' },
   });
   record(
-    '教师（非管理员）导入成绩被拒绝（403）',
-    gradesByTeacher.status === 403,
-    `status=${gradesByTeacher.status}`,
+    '班主任重复导入本班成绩按 append 跳过',
+    gradesByHeadTeacher.status === 200 &&
+      (gradesByHeadTeacher.payload?.data?.skipped ?? 0) >= 1 &&
+      (gradesByHeadTeacher.payload?.data?.inserted ?? -1) === 0,
+    `status=${gradesByHeadTeacher.status} 跳过=${gradesByHeadTeacher.payload?.data?.skipped} 新增=${gradesByHeadTeacher.payload?.data?.inserted}`,
   );
 
   // 8.4 学生名单导入（仅管理员）+ 数据清理
@@ -1180,6 +1222,116 @@ async function main() {
     `新增=${studentsCommit.payload?.data?.inserted} 失败=${studentsCommit.payload?.data?.failed}`,
   );
 
+  // 8.5 需求 6：表格导入在"老师端"可用且不越权
+  //     班主任 → 本班成绩可预览/导入；科任 → 403；班主任 → 名单导入仍 403（人员管理仅管理员）
+  const teacherGradesPreview = await api('/imports/table/preview', {
+    method: 'POST',
+    token: teacherToken,
+    body: { kind: 'grades', fileName: 'grades.csv', contentBase64: gradesCsvBase64 },
+  });
+  record(
+    '班主任可预览成绩表（需求 6：老师端可用）',
+    teacherGradesPreview.status === 200 && (teacherGradesPreview.payload?.data?.totalRows ?? 0) === 3,
+    `status=${teacherGradesPreview.status} 行数=${teacherGradesPreview.payload?.data?.totalRows ?? '-'}`,
+  );
+
+  const teacherGradesCommit = await api('/imports/table/commit', {
+    method: 'POST',
+    token: teacherToken,
+    body: {
+      kind: 'grades',
+      classId,
+      fileName: 'grades.csv',
+      contentBase64: gradesCsvBase64,
+      mapping: {
+        username: '用户名',
+        name: '姓名',
+        examName: '考试名称',
+        score: '分数',
+        totalScore: '总分',
+        courseName: '课程',
+      },
+      mode: 'upsert',
+    },
+  });
+  record(
+    '班主任可导入本班成绩（upsert）',
+    teacherGradesCommit.status === 200 &&
+      (teacherGradesCommit.payload?.data?.inserted ?? 0) +
+        (teacherGradesCommit.payload?.data?.updated ?? 0) >=
+        1,
+    `status=${teacherGradesCommit.status} 新增=${teacherGradesCommit.payload?.data?.inserted} 更新=${teacherGradesCommit.payload?.data?.updated} 失败=${teacherGradesCommit.payload?.data?.failed}`,
+  );
+
+  // teacher2 是高二(3)班的科任老师（班主任是 teacher1）——这才是真正的"科任"场景
+  const subjectOnlyClass = classes.find((item) => item.name?.includes('高二(3)')) ?? null;
+  const subjectGradesImport = await api('/imports/table/commit', {
+    method: 'POST',
+    token: teacher2Token,
+    body: {
+      kind: 'grades',
+      classId: subjectOnlyClass?.id ?? classId,
+      fileName: 'grades.csv',
+      contentBase64: gradesCsvBase64,
+      mapping: {
+        username: '用户名',
+        name: '姓名',
+        examName: '考试名称',
+        score: '分数',
+        totalScore: '总分',
+        courseName: '课程',
+      },
+      mode: 'upsert',
+    },
+  });
+  record(
+    '科任老师导入本班成绩被拒绝（403，需求 7）',
+    Boolean(subjectOnlyClass) && subjectGradesImport.status === 403,
+    `班级=${subjectOnlyClass?.name ?? '未找到高二(3)班'} status=${subjectGradesImport.status}`,
+  );
+
+  if (foreignClass) {
+    const crossGradesImport = await api('/imports/table/commit', {
+      method: 'POST',
+      token: teacherToken,
+      body: {
+        kind: 'grades',
+        classId: foreignClass.id,
+        fileName: 'grades.csv',
+        contentBase64: gradesCsvBase64,
+        mapping: {
+          username: '用户名',
+          name: '姓名',
+          examName: '考试名称',
+          score: '分数',
+          totalScore: '总分',
+          courseName: '课程',
+        },
+        mode: 'upsert',
+      },
+    });
+    record(
+      '班主任向他人班级导入成绩被拒绝（403）',
+      crossGradesImport.status === 403,
+      `status=${crossGradesImport.status}`,
+    );
+  }
+
+  const teacherRosterPreview = await api('/imports/table/preview', {
+    method: 'POST',
+    token: teacherToken,
+    body: {
+      kind: 'students',
+      fileName: 'students.csv',
+      contentBase64: Buffer.from(`\ufeff用户名,姓名${NL}whatever,某人${NL}`, 'utf8').toString('base64'),
+    },
+  });
+  record(
+    '班主任预览学生名单模板被拒绝（403，名单仅管理员）',
+    teacherRosterPreview.status === 403,
+    `status=${teacherRosterPreview.status}`,
+  );
+
   const studentsByTeacher = await api('/imports/table/commit', {
     method: 'POST',
     token: teacherToken,

packages/server/src/lib/access.ts

@@ -157,11 +157,27 @@ export async function assertCanPublishContent(user: TokenPayload, classId: strin
   }
 }
 
-/** 成绩录入 / 修改 / 导入：仅管理员 */
-export function assertCanManageGrades(user: TokenPayload): void {
-  if (!canManageGrades(user.role)) {
-    throw ApiError.forbidden('只有管理员可以录入、修改或导入成绩');
+/**
+ * 成绩录入 / 修改 / 导入：管理员，或**本班班主任**（需求 6"老师端可用且不越权"）。
+ * 科任老师仍然被拒（需求 7：科任只有作业 / 叫人 / 通知）。
+ *
+ * @param classId 目标成绩所属班级；不传时按"全局"判定（仅管理员可用，例如空白模板下载）
+ */
+export async function assertCanManageGrades(user: TokenPayload, classId?: string): Promise<void> {
+  if (!classId) {
+    // 没有班级上下文（例如下载空白模板）：只有管理员可以执行
+    if (user.role !== 'ADMIN') throw ApiError.forbidden('该操作需要指定班级，只有管理员可以全局执行');
+    return;
   }
+
+  const classRole = await resolveUserClassRole(user, classId);
+  if (canManageGrades(classRole)) return;
+
+  throw ApiError.forbidden(
+    classRole === 'SUBJECT'
+      ? '科任老师不能录入或导入成绩，请联系班主任或管理员'
+      : '只能录入或导入自己担任班主任的班级的成绩',
+  );
 }
 
 /** 学生的主班级，未分配班级时抛 403 */

packages/server/src/modules/grades/grades.module.ts

@@ -1,4 +1,4 @@
-import { Router } from 'express';
+import { Router } from 'express';
 import { sendCreated, sendOk } from '../../lib/http.js';
 import { idParamSchema } from '../../lib/schemas.js';
 import { authenticate, getAuthUser, requireRole } from '../../middleware/auth.js';
@@ -52,7 +52,7 @@ router.get(
 );
 
 /** POST /api/grades - 录入单条成绩（广播 grade:updated） */
-router.post('/', requireRole('ADMIN'), validate({ body: createGradeSchema }), async (req, res) => {
+router.post('/', requireRole('ADMIN', 'TEACHER'), validate({ body: createGradeSchema }), async (req, res) => {
   const user = getAuthUser(req);
   sendCreated(
     res,
@@ -62,16 +62,21 @@ router.post('/', requireRole('ADMIN'), validate({ body: createGradeSchema }), as
 });
 
 /** POST /api/grades/bulk - 批量录入 / 导入成绩 */
-router.post('/bulk', requireRole('ADMIN'), validate({ body: bulkCreateGradeSchema }), async (req, res) => {
-  const user = getAuthUser(req);
-  const grades = await gradeService.bulkCreateGrades(user, req.body as BulkCreateGradeInput);
-  sendCreated(res, { count: grades.length, items: grades }, `已录入 ${grades.length} 条成绩`);
-});
+router.post(
+  '/bulk',
+  requireRole('ADMIN', 'TEACHER'),
+  validate({ body: bulkCreateGradeSchema }),
+  async (req, res) => {
+    const user = getAuthUser(req);
+    const grades = await gradeService.bulkCreateGrades(user, req.body as BulkCreateGradeInput);
+    sendCreated(res, { count: grades.length, items: grades }, `已录入 ${grades.length} 条成绩`);
+  },
+);
 
 /** PATCH /api/grades/:id - 修改成绩 */
 router.patch(
   '/:id',
-  requireRole('ADMIN'),
+  requireRole('ADMIN', 'TEACHER'),
   validate({ params: idParamSchema, body: updateGradeSchema }),
   async (req, res) => {
     const user = getAuthUser(req);
@@ -81,12 +86,17 @@ router.patch(
 );
 
 /** DELETE /api/grades/:id - 删除成绩 */
-router.delete('/:id', requireRole('ADMIN'), validate({ params: idParamSchema }), async (req, res) => {
-  const user = getAuthUser(req);
-  const { id } = validatedParams<{ id: string }>(req);
-  await gradeService.deleteGrade(user, id);
-  sendOk(res, { id }, '成绩已删除');
-});
+router.delete(
+  '/:id',
+  requireRole('ADMIN', 'TEACHER'),
+  validate({ params: idParamSchema }),
+  async (req, res) => {
+    const user = getAuthUser(req);
+    const { id } = validatedParams<{ id: string }>(req);
+    await gradeService.deleteGrade(user, id);
+    sendOk(res, { id }, '成绩已删除');
+  },
+);
 
 export const gradesModule = defineModule({
   name: 'grades',

packages/server/src/modules/grades/grades.service.ts

@@ -106,7 +106,7 @@ export async function getGradeStats(user: TokenPayload, options: ListGradeOption
 }
 
 export async function createGrade(user: TokenPayload, input: CreateGradeInput): Promise<GradeDto> {
-  assertCanManageGrades(user);
+  await assertCanManageGrades(user, input.classId);
   await assertStudentInClass(input.userId, input.classId);
   if (input.courseId) await assertCourseInClass(input.courseId, input.classId);
 
@@ -127,7 +127,7 @@ export async function createGrade(user: TokenPayload, input: CreateGradeInput):
 
 /** 批量录入：同一个考试一次提交整班成绩 */
 export async function bulkCreateGrades(user: TokenPayload, input: BulkCreateGradeInput): Promise<GradeDto[]> {
-  assertCanManageGrades(user);
+  await assertCanManageGrades(user, input.classId);
   if (input.courseId) await assertCourseInClass(input.courseId, input.classId);
 
   const publishedAt = parseOptionalDate(input.publishedAt) ?? new Date();
@@ -163,7 +163,7 @@ export async function updateGrade(
 ): Promise<GradeDto> {
   const current = await prisma.grade.findUnique({ where: { id: gradeId } });
   if (!current) throw ApiError.notFound('成绩记录不存在');
-  assertCanManageGrades(user);
+  await assertCanManageGrades(user, current.classId);
   if (input.courseId) await assertCourseInClass(input.courseId, current.classId);
 
   const updated = await prisma.grade.update({
@@ -189,7 +189,7 @@ export async function updateGrade(
 export async function deleteGrade(user: TokenPayload, gradeId: string): Promise<void> {
   const current = await prisma.grade.findUnique({ where: { id: gradeId } });
   if (!current) throw ApiError.notFound('成绩记录不存在');
-  assertCanManageGrades(user);
+  await assertCanManageGrades(user, current.classId);
   await prisma.grade.delete({ where: { id: gradeId } });
   emitToClass(current.classId, SOCKET_EVENTS.gradeUpdated, {
     ...toGradeDto({ ...current, course: null, student: null, class: null }),

packages/server/src/modules/imports/imports.module.ts

@@ -1,5 +1,5 @@
 import { Router } from 'express';
-import { sendOk } from '../../lib/http.js';
+import { ApiError, sendOk } from '../../lib/http.js';
 import { authenticate, getAuthUser, requireRole } from '../../middleware/auth.js';
 import { validate, validatedBody, validatedQuery } from '../../middleware/validate.js';
 import { defineModule } from '../module.types.js';
@@ -25,9 +25,12 @@ router.use(authenticate());
 
 /**
  * GET /api/imports/template?kind=grades|students&format=csv|xlsx - 下载导入模板
- * 成绩模板=管理员；名单模板=管理员（与写入权限一致，不额外开入口）
+ * 成绩模板：管理员或班主任（空白模板，不含任何业务数据）；名单模板：仅管理员
  */
-router.get('/template', requireRole('ADMIN'), (req, res) => {
+router.get('/template', requireRole('ADMIN', 'TEACHER'), (req, res) => {
+  if (req.query.kind === 'students' && getAuthUser(req).role !== 'ADMIN') {
+    throw ApiError.forbidden('只有管理员可以导入学生名单');
+  }
   const kind = req.query.kind === 'students' ? 'students' : 'grades';
   const format = req.query.format === 'xlsx' ? 'xlsx' : 'csv';
   if (format === 'xlsx') {
@@ -46,16 +49,30 @@ router.get('/template', requireRole('ADMIN'), (req, res) => {
 
 /**
  * POST /api/imports/table/preview - 上传表格并预览（解析 + 必填列校验 + 建议字段映射）
- * 仅管理员：与"成绩录入 / 名单管理"权限一致
+ * 成绩：管理员或班主任；学生名单：仅管理员（与写入权限保持一致）
  */
-router.post('/table/preview', requireRole('ADMIN'), validate({ body: tableFileSchema }), (req, res) => {
-  sendOk(res, previewTable(validatedBody<TableFileInput>(req)), '表格解析成功');
-});
+router.post(
+  '/table/preview',
+  requireRole('ADMIN', 'TEACHER'),
+  validate({ body: tableFileSchema }),
+  (req, res) => {
+    const input = validatedBody<TableFileInput>(req);
+    if (input.kind === 'students' && getAuthUser(req).role !== 'ADMIN') {
+      throw ApiError.forbidden('只有管理员可以导入学生名单');
+    }
+    sendOk(res, previewTable(input), '表格解析成功');
+  },
+);
 
-/** POST /api/imports/table/commit - 执行导入（字段映射 + 写入模式 + 结果统计） */
+/**
+ * POST /api/imports/table/commit - 执行导入（字段映射 + 写入模式 + 结果统计）
+ *
+ * 路由放行 ADMIN|TEACHER，真正的权限在 service 内按 kind + 班级二次校验：
+ * 成绩 → 管理员或本班班主任；学生名单 → 仅管理员；科任老师一律 403（需求 7）。
+ */
 router.post(
   '/table/commit',
-  requireRole('ADMIN'),
+  requireRole('ADMIN', 'TEACHER'),
   validate({ body: tableCommitSchema }),
   async (req, res) => {
     const result = await commitTable(getAuthUser(req), validatedBody<TableCommitInput>(req));

packages/server/src/modules/imports/table-import.service.ts

@@ -221,7 +221,8 @@ function cellValue(row: string[], columns: string[], mapping: Record<string, str
 
 /** 导入成绩：学生按用户名/姓名匹配；重复（同班级+学生+考试+课程）按 mode 处理 */
 export async function commitGrades(user: TokenPayload, input: TableCommitInput): Promise<ImportResult> {
-  assertCanManageGrades(user);
+  // 成绩导入：管理员或本班班主任（需求 6）；科任 403
+  await assertCanManageGrades(user, input.classId);
   const buffer = decodeBase64(input.contentBase64);
   const parsed = parseTable(buffer, input.fileName);