新增积分系统:打卡/测试达标赚积分,纯累计可配置

- point_rule 规则表 + point_log 流水表(0008 迁移),唯一键防刷:同一事件首次达标才发放,重复静默返回 0 - 打卡分值随任务设置(模板/实例 points 字段,默认 10);测试类 6 种事件按规则表取值,各有默认分(单词 20/数学课 15/语法点 15/周测 50×2/考试通过 100) - 发放埋点 6 处:打卡、单词检测、数学课、语法知识点、英语/数学周测、考试通过;周测达标联动打卡实例不重复计分 - 孩子端:/kid 总积分徽章,新增 /points 积分页(总积分+流水),测验结果页即时显示「+N 积分」,周测结果页刷新后从流水取回已发积分 - 家长端:功能管理新增「积分管理」Section(规则分值配置+每孩子总积分/最近流水);任务管理内联编辑任务分值 - 修复:drizzle 将 mysql2 重复键错误包进 cause,沿错误链识别 ER_DUP_ENTRY Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
docs: 家长中心待掌握错题查看设计文档
2026-08-18 17:58:53 +08:00 · 2026-08-18 09:29:01 +08:00 · 2026-08-17 17:25:04 +08:00 · 2026-08-17 16:24:31 +08:00 · 2026-08-17 16:24:23 +08:00
56 changed files with 2604 additions and 236 deletions
@@ -22,3 +22,6 @@ materials/

 # playwright-mcp debug snapshots
 .playwright-mcp/
+
+# 本地开发解答题照片回退目录
+.dev-uploads/
@@ -0,0 +1,76 @@
+# 家长中心「待掌握错题」查看 - 设计文档
+
+日期:2026-08-18
+状态:已批准
+
+## 背景
+
+家长中心「学习概览」tab 有一张「待掌握错题」计数卡片(显示某个孩子未掌握错题数 `wrongOpen`),
+目前**不可点击**。家长希望点击后能查看该孩子的错题信息。
+
+相关现状:
+
+- 孩子端已有完整错题本页 `/wrongbook`(仅 child 角色可进),展示组件 `WrongRow` 含
+  题干/标准答案/用户作答/解答题作答照片,并可「标记已掌握」。
+- 标记动作 `toggleMastered`(src/app/wrongbook/actions.ts)是 child 角色限定、按会话孩子 id 锁定。
+- 提交 ab84bec 移除了课程管理里的「孩子错题本」快照卡片,但概览 tab 的计数卡片仍在且不可点。
+
+## 需求(已与用户确认)
+
+1. 点击概览页「待掌握错题」卡片 → 进入该孩子(当前选中孩子)的错题查看页。
+2. 页面**只展示待掌握(未掌握)的错题**,不含已掌握。
+3. 家长可以「标记已掌握」,返回概览后计数同步下降。
+4. 页面内不需要孩子切换(看别的孩子需返回概览重新点)。
+
+## 方案选择
+
+- **方案 A(采用):新建家长版错题页 `/parent/wrongbook?kid=<id>`**
+  - 权限模型清晰(家长页 = 家庭归属校验),遵循现有 `/parent/grammar`、`/parent/words` 目录模式;
+    孩子端逻辑零改动。
+- 方案 B(弃):放开孩子端 `/wrongbook` 允许家长进入 → 孩子页面被家长/孩子两套模式搅乱。
+- 方案 C(弃):概览页内点击后同页展开列表 → 破坏日历布局,无法分享/刷新。
+
+## 设计
+
+### 1. 入口:src/app/parent/overview-tab.tsx
+
+「待掌握错题」卡片包 `<Link href={/parent/wrongbook?kid=${kid.id}}>`,样式保留,加 hover 微动效。
+
+### 2. 新页面:src/app/parent/wrongbook/page.tsx(server component)
+
+- 鉴权:未登录 `redirect("/login")`;非 parent `redirect("/kid")`(与其它家长页一致)。
+- 从 `searchParams.kid` 取孩子 id,校验 `familyId === 家长.familyId` 且 `role === child`,
+  不合法一律 `redirect("/parent")` —— 防越权查看别的家庭孩子。
+- 数据:`listWrong(kidId)` 过滤 `mastered === false`(复用现有 lib,不加新查询层)。
+- 渲染:header「← 返回家长中心」+「待掌握错题」+ 孩子名 + 数量;无错题显示空态
+  (🎉 没有待掌握错题);每题复用 `WrongRow`,解答题作答照片(OSS 签名 URL)逻辑同孩子端。
+
+### 3. 新 action:src/app/parent/wrongbook/actions.ts
+
+- `markMastered(id: number, mastered: boolean)`:
+  1. 取会话家长,非家长直接 return;
+  2. 按错题 id 查记录拿 `childUserId`;
+  3. 校验该孩子属于本家庭,否则 return;
+  4. 调现有 `setMastered(id, childUserId, mastered)`;
+  5. `revalidatePath("/parent")` + `revalidatePath("/parent/wrongbook")`。
+
+### 4. 组件复用:src/app/wrongbook/wrong-row.tsx
+
+- `WrongRow` 增加可选 prop `markAction?: (id: number, mastered: boolean) => Promise<void>`,
+  缺省走现有孩子端 `toggleMastered`;家长页传入 `markMastered`。
+- 孩子端行为零变化;家长版因只过滤未掌握,revalidate 后已标记行自然消失,
+  组件内不加任何分支逻辑。
+
+### 5. 不改动
+
+- DB schema(wrongBook 表已含 mastered 字段)
+- src/lib/wrongbook.ts(listWrong / setMastered 已够用)
+
+## 测试清单(手工,项目无自动化测试框架)
+
+1. 家长登录 → 点卡片 → 看到该孩子待掌握错题(含解答题照片)。
+2. 标记已掌握 → 行消失;返回概览计数 -1。
+3. 多孩子:选中 A 孩子进入 A 的错题;篡改 `?kid=` 为别的家庭孩子 → 被重定向回 `/parent`。
+4. 全部掌握后 → 🎉 空态。
+5. 孩子账号 / 未登录访问 `/parent/wrongbook` → 正确重定向。
+6. 部署 jump.hn12301.net 后线上复验。
@@ -0,0 +1,73 @@
+# 解答题拍照判分方案(设计决策记录)
+
+> 2026-08-06 用户授权:全部按推荐方案落地,无需逐项确认。本文档记录已确认的全部决策。
+
+## 一、目标
+
+考试板块支持**数学解答题**(计算/解方程/应用题):孩子在纸上写完整解答过程,手机拍照上传,AI 视觉模型按评分点部分给分。首期试点一张**初一入学考(小升初分班考)卷**,现有 5 张月考卷不动。
+
+## 二、已确认决策(逐条)
+
+| # | 决策点 | 结论 |
+| --- | --- | --- |
+| 1 | 题型范围 | 困难档:解答题**过程判分**(不是只判最终答案) |
+| 2 | 作答输入 | **纸上手写 + 拍照**(不做屏幕手写、不做分步结构化输入) |
+| 3 | AI 模型 | **阿里云百炼 Qwen-VL**(qwen-vl-max),用户 Tokenplan 计费;经 OpenAI 兼容端点调用 |
+| 4 | 答题流程 | **混合模式**:客观题(选择/判断/填空)App 内作答;**解答题逐题拍照**,不做整页拍 |
+| 5 | 判分规则 | **部分给分 + 评分点(rubric)锚定**:AI 逐点评判,只能返回离散分数,不给自由打分权 |
+| 6 | 题目配图 | 原卷裁剪为主、SVG 兜底,存 `public/exam/<卷id>/`;几何题判分时**原图+孩子照片一起喂模型**。本期入学卷无图题 |
+| 7 | 内容生产 | **零人工**:抓卷/转录 → **双模型背靠背独立验算,不一致即丢弃**;本期因网络策略无法直抓教育站,内容改为**本地 Obsidian 数学素材 + 经典分班考题型按真实卷格式组卷**,已在试卷 summary 标注 |
+| 8 | 计分 | 分值跟随原卷;总分 = 客观题 + 解答题部分得分;**达标线保持 80%**;exam_record 存每题照片 URL + 评分点命中明细 |
+| 9 | 错题本 | v1 **只存不重做**:存题目 + 当时照片 + AI 评判 + 参考解答;保留手动"已掌握";重做重判放二期 |
+| 10 | 质量控制 | AI 返回状态:`ok / blank(空白) / blurry(模糊) / printed(印刷体拒判) / unrelated(无关内容)`;非手写拒判;**每人每天限 30 次判分**;客户端压缩照片 ≤2MB |
+| 11 | 时效 | 同步等待 + "AI 判分中"动画;失败自动重试 1 次,再失败允许单题重拍重交,不阻塞其它题 |
+| 12 | 范围 | 解答题只进考试板块;课时练习/周测暂不加 |
+
+## 三、数据模型
+
+### QuizQ 扩展(`src/lib/quiz-parse.ts`)
+
+```ts
+{
+  type: "solve",
+  stem: string,          // 题干
+  figure?: string,       // 配图路径(可选,本期不用)
+  points: number,        // 本题满分(分值跟随原卷)
+  reference: string,     // 完整参考解答(判后展示)
+  rubric: { point: string; score: number }[],  // 评分点,合计 = points
+  explain: string        // 讲解
+}
+```
+
+### 新表 `ai_grade_log`(迁移 0004)
+
+判分审计 + 限频依据:child_user_id、paper_id、question_index、oss_key、status、earned、points、verdict(JSON:逐点命中+点评)、mock(是否演示判分)、created_at。
+
+### exam_record.answers
+
+解答题条目:`{ type:"solve", qIndex, ossKey, earned, hits:[{point,score,hit,reason}] }`;客观题保持原样。**成绩以服务端 ai_grade_log 为准,不信任客户端上报的分数**(防篡改)。
+
+## 四、判分链路
+
+```
+孩子拍照 → 客户端压缩(≤2MB,canvas) → 服务端签发 OSS 直传 URL → PUT OSS
+→ gradeSolve action:校验会话/限频(30/天) → 调百炼 Qwen-VL
+  prompt = 题干 + (原图) + 参考解答 + 评分点 + 孩子照片
+→ 结构化 JSON:{status, hits:[{hit,reason}], earned, comment}
+→ 写 ai_grade_log → 返回前端即时显示逐点得分
+→ 全卷提交 takeExam:客观题即时判 + 解答题取 ai_grade_log 最近一次 ok 判定
+→ 总分百分制,≥80 达标,错题(含照片)进 wrong_book,达标联动数学打卡
+```
+
+- **无 DASHSCOPE_API_KEY 时进入演示判分(mock)**:返回确定性模拟判定并标记 `mock=true`,供本地开发/测试;生产必须在服务器 .env 配置真 key。
+- OSS 未配置时(本地开发)走 `/api/dev-photo` 本地落盘回退,不影响生产。
+
+## 五、内容来源说明(本期入学卷)
+
+本 session 网络策略拦截了对教育网站(学科网/组卷网/瑞文/51test 等)的直接抓取,无法获取原始真实卷页面。本期入学卷改为:**按真实分班考的卷面结构(填空+选择+计算+应用,满分 100)** 组卷,题目取自本地 Obsidian 数学素材库的经典题型(鸡兔同笼、工程、分数百分数、行程等,均带验算)。`sourceUrl` 置空并在 `summary` 注明。待网络恢复后可用同流程替换为真实卷转录。
+
+## 六、上线前待办(需用户)
+
+1. 百炼控制台开通/确认 Tokenplan 覆盖 `qwen-vl-max`,取 API Key;
+2. 服务器 `/opt/services/superjump/.env` 增加 `DASHSCOPE_API_KEY=...`,重建容器;
+3. 跑 `npm run db:seed-exam` 灌入新卷(容器重建时自动 migrate)。
@@ -0,0 +1,22 @@
+CREATE TABLE `ai_grade_log` (
+	`id` bigint AUTO_INCREMENT NOT NULL,
+	`child_user_id` bigint NOT NULL,
+	`paper_id` varchar(191) NOT NULL,
+	`question_index` int NOT NULL,
+	`oss_key` varchar(300) NOT NULL,
+	`status` varchar(20) NOT NULL,
+	`earned` int NOT NULL DEFAULT 0,
+	`points` int NOT NULL DEFAULT 0,
+	`verdict` text,
+	`mock` boolean NOT NULL DEFAULT false,
+	`model` varchar(60),
+	`ms` int,
+	`created_at` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
+	CONSTRAINT `ai_grade_log_id` PRIMARY KEY(`id`)
+);
+--> statement-breakpoint
+ALTER TABLE `ai_grade_log` ADD CONSTRAINT `ai_grade_log_child_user_id_user_id_fk` FOREIGN KEY (`child_user_id`) REFERENCES `user`(`id`) ON DELETE cascade ON UPDATE no action;
+--> statement-breakpoint
+CREATE INDEX `idx_ai_grade_child_date` ON `ai_grade_log` (`child_user_id`,`created_at`);
+--> statement-breakpoint
+CREATE INDEX `idx_ai_grade_paper_q` ON `ai_grade_log` (`child_user_id`,`paper_id`,`question_index`);
@@ -0,0 +1,11 @@
+-- xuchao: 补齐 task_template 的模板生效方式字段。生产库曾手工 ALTER 过这三列,
+-- 故用 information_schema 判断实现幂等:已存在则跳过,保证生产与全新库都能安全执行。
+SET @has_mode = (SELECT COUNT(*) FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = 'task_template' AND column_name = 'mode');
+--> statement-breakpoint
+SET @ddl = IF(@has_mode = 0, 'ALTER TABLE `task_template` ADD COLUMN `mode` varchar(10) NOT NULL DEFAULT ''weekly'', ADD COLUMN `date_start` date, ADD COLUMN `date_end` date', 'SELECT 1');
+--> statement-breakpoint
+PREPARE stmt FROM @ddl;
+--> statement-breakpoint
+EXECUTE stmt;
+--> statement-breakpoint
+DEALLOCATE PREPARE stmt;
@@ -0,0 +1,118 @@
+-- xuchao: 修复历史迁移缺口。早期这些表是用 drizzle push/手工 DDL 建进生产的,
+-- 仓库里一直没有对应迁移,导致全新数据库建不出这些表。本迁移全部幂等:
+-- 表已存在则 CREATE TABLE IF NOT EXISTS 跳过,生产库重复执行无副作用。
+CREATE TABLE IF NOT EXISTS `grammar_point` (
+	`id` bigint AUTO_INCREMENT NOT NULL,
+	`point_id` varchar(191) NOT NULL,
+	`level` varchar(20) NOT NULL,
+	`level_name` varchar(50) NOT NULL,
+	`title` varchar(200) NOT NULL,
+	`difficulty` int NOT NULL DEFAULT 1,
+	`summary` text,
+	`prereq` text,
+	`md` mediumtext NOT NULL,
+	`seq` int NOT NULL,
+	`updated_at` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
+	CONSTRAINT `grammar_point_id` PRIMARY KEY(`id`),
+	CONSTRAINT `uq_grammar_point_id` UNIQUE(`point_id`)
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS `weekly_test` (
+	`id` bigint AUTO_INCREMENT NOT NULL,
+	`child_user_id` bigint NOT NULL,
+	`week_key` varchar(12) NOT NULL,
+	`score` int,
+	`correct` int,
+	`total` int,
+	`passed` boolean NOT NULL DEFAULT false,
+	`questions` mediumtext,
+	`taken_at` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
+	CONSTRAINT `weekly_test_id` PRIMARY KEY(`id`),
+	CONSTRAINT `uq_weekly_child_week` UNIQUE(`child_user_id`,`week_key`),
+	CONSTRAINT `fk_wt_child` FOREIGN KEY (`child_user_id`) REFERENCES `user`(`id`) ON DELETE cascade ON UPDATE no action
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS `word_progress` (
+	`id` bigint AUTO_INCREMENT NOT NULL,
+	`child_user_id` bigint NOT NULL,
+	`day` int NOT NULL,
+	`learned` mediumtext,
+	`score` int,
+	`passed` boolean NOT NULL DEFAULT false,
+	`completed_at` datetime,
+	CONSTRAINT `word_progress_id` PRIMARY KEY(`id`),
+	CONSTRAINT `uq_word_child_day` UNIQUE(`child_user_id`,`day`),
+	CONSTRAINT `fk_wp_child` FOREIGN KEY (`child_user_id`) REFERENCES `user`(`id`) ON DELETE cascade ON UPDATE no action
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS `word_recording` (
+	`id` bigint AUTO_INCREMENT NOT NULL,
+	`child_user_id` bigint NOT NULL,
+	`word` varchar(60) NOT NULL,
+	`day` int,
+	`oss_key` varchar(300) NOT NULL,
+	`created_at` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
+	CONSTRAINT `word_recording_id` PRIMARY KEY(`id`),
+	KEY `idx_rec_child` (`child_user_id`),
+	CONSTRAINT `fk_wr_child` FOREIGN KEY (`child_user_id`) REFERENCES `user`(`id`) ON DELETE cascade ON UPDATE no action
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS `wrong_book` (
+	`id` bigint AUTO_INCREMENT NOT NULL,
+	`child_user_id` bigint NOT NULL,
+	`source_type` varchar(10) NOT NULL,
+	`source_id` varchar(60) NOT NULL,
+	`source_title` varchar(200),
+	`question` mediumtext NOT NULL,
+	`user_answer` mediumtext,
+	`correct_answer` mediumtext,
+	`mastered` boolean NOT NULL DEFAULT false,
+	`created_at` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
+	`updated_at` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
+	CONSTRAINT `wrong_book_id` PRIMARY KEY(`id`),
+	KEY `idx_wrong_child` (`child_user_id`,`mastered`),
+	CONSTRAINT `fk_wb_child` FOREIGN KEY (`child_user_id`) REFERENCES `user`(`id`) ON DELETE cascade ON UPDATE no action
+);
+--> statement-breakpoint
+-- grammar_progress:0002 误用 seq 列建表,生产实际是 point_id。仅在缺 point_id 时转换。
+-- 顺序关键:先加 point_id 与 uq_grammar_child_point(child_user_id 为最左前缀,可承接外键),
+-- 之后才能安全删除被外键依赖的旧索引 uq_grammar_child_seq,全程不动外键本身。
+SET @gp_has_point = (SELECT COUNT(*) FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = 'grammar_progress' AND column_name = 'point_id');
+--> statement-breakpoint
+SET @ddl = IF(@gp_has_point = 0, 'ALTER TABLE `grammar_progress` ADD COLUMN `point_id` varchar(191) NOT NULL', 'SELECT 1');
+--> statement-breakpoint
+PREPARE stmt FROM @ddl;
+--> statement-breakpoint
+EXECUTE stmt;
+--> statement-breakpoint
+DEALLOCATE PREPARE stmt;
+--> statement-breakpoint
+SET @gp_has_point_idx = (SELECT COUNT(*) FROM information_schema.statistics WHERE table_schema = DATABASE() AND table_name = 'grammar_progress' AND index_name = 'uq_grammar_child_point');
+--> statement-breakpoint
+SET @ddl = IF(@gp_has_point_idx = 0, 'ALTER TABLE `grammar_progress` ADD CONSTRAINT `uq_grammar_child_point` UNIQUE (`child_user_id`,`point_id`)', 'SELECT 1');
+--> statement-breakpoint
+PREPARE stmt FROM @ddl;
+--> statement-breakpoint
+EXECUTE stmt;
+--> statement-breakpoint
+DEALLOCATE PREPARE stmt;
+--> statement-breakpoint
+SET @gp_has_seq_idx = (SELECT COUNT(*) FROM information_schema.statistics WHERE table_schema = DATABASE() AND table_name = 'grammar_progress' AND index_name = 'uq_grammar_child_seq');
+--> statement-breakpoint
+SET @ddl = IF(@gp_has_seq_idx > 0, 'ALTER TABLE `grammar_progress` DROP INDEX `uq_grammar_child_seq`', 'SELECT 1');
+--> statement-breakpoint
+PREPARE stmt FROM @ddl;
+--> statement-breakpoint
+EXECUTE stmt;
+--> statement-breakpoint
+DEALLOCATE PREPARE stmt;
+--> statement-breakpoint
+SET @gp_has_seq = (SELECT COUNT(*) FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = 'grammar_progress' AND column_name = 'seq');
+--> statement-breakpoint
+SET @ddl = IF(@gp_has_seq > 0, 'ALTER TABLE `grammar_progress` DROP COLUMN `seq`', 'SELECT 1');
+--> statement-breakpoint
+PREPARE stmt FROM @ddl;
+--> statement-breakpoint
+EXECUTE stmt;
+--> statement-breakpoint
+DEALLOCATE PREPARE stmt;
@@ -0,0 +1,12 @@
+-- xuchao: 单词词库落库,供家长端按天编辑。幂等:已存在则跳过。
+-- 初始数据由 scripts/seed-words.ts 从 src/content/words/words.json 灌入;
+-- 表空时 lib/words.ts 自动回退读 JSON,部署顺序不影响孩子端使用。
+CREATE TABLE IF NOT EXISTS `word_entry` (
+	`id` bigint AUTO_INCREMENT NOT NULL,
+	`word` varchar(60) NOT NULL,
+	`meaning` varchar(300) NOT NULL DEFAULT '',
+	`day` int NOT NULL,
+	`seq` int NOT NULL,
+	CONSTRAINT `word_entry_id` PRIMARY KEY(`id`),
+	KEY `idx_word_entry_day` (`day`)
+);
@@ -0,0 +1,42 @@
+-- xuchao: 积分系统——规则表 + 流水表(唯一键防刷) + 任务表加 points 列。全部幂等。
+CREATE TABLE IF NOT EXISTS `point_rule` (
+	`id` bigint AUTO_INCREMENT NOT NULL,
+	`event_type` varchar(30) NOT NULL,
+	`points` int NOT NULL DEFAULT 0,
+	`updated_at` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
+	CONSTRAINT `point_rule_id` PRIMARY KEY(`id`),
+	UNIQUE KEY `uq_point_rule_event` (`event_type`)
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS `point_log` (
+	`id` bigint AUTO_INCREMENT NOT NULL,
+	`child_user_id` bigint NOT NULL,
+	`event_type` varchar(30) NOT NULL,
+	`ref_key` varchar(100) NOT NULL,
+	`points` int NOT NULL,
+	`remark` varchar(200) NOT NULL DEFAULT '',
+	`created_at` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
+	CONSTRAINT `point_log_id` PRIMARY KEY(`id`),
+	UNIQUE KEY `uq_point_log_dedup` (`child_user_id`, `event_type`, `ref_key`),
+	KEY `idx_point_log_child` (`child_user_id`)
+);
+--> statement-breakpoint
+SET @has_tpl_points = (SELECT COUNT(*) FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = 'task_template' AND column_name = 'points');
+--> statement-breakpoint
+SET @ddl = IF(@has_tpl_points = 0, 'ALTER TABLE `task_template` ADD COLUMN `points` int NOT NULL DEFAULT 10', 'SELECT 1');
+--> statement-breakpoint
+PREPARE stmt FROM @ddl;
+--> statement-breakpoint
+EXECUTE stmt;
+--> statement-breakpoint
+DEALLOCATE PREPARE stmt;
+--> statement-breakpoint
+SET @has_inst_points = (SELECT COUNT(*) FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = 'task_instance' AND column_name = 'points');
+--> statement-breakpoint
+SET @ddl2 = IF(@has_inst_points = 0, 'ALTER TABLE `task_instance` ADD COLUMN `points` int NOT NULL DEFAULT 10', 'SELECT 1');
+--> statement-breakpoint
+PREPARE stmt2 FROM @ddl2;
+--> statement-breakpoint
+EXECUTE stmt2;
+--> statement-breakpoint
+DEALLOCATE PREPARE stmt2;
@@ -29,6 +29,41 @@
      "when": 1785772800000,
      "tag": "0003_math-and-exam",
      "breakpoints": true
+    },
+    {
+      "idx": 4,
+      "version": "5",
+      "when": 1785859200000,
+      "tag": "0004_ai-grade-log",
+      "breakpoints": true
+    },
+    {
+      "idx": 5,
+      "version": "5",
+      "when": 1786060800000,
+      "tag": "0005_task-template-mode",
+      "breakpoints": true
+    },
+    {
+      "idx": 6,
+      "version": "5",
+      "when": 1786064400000,
+      "tag": "0006_fill-missing-tables",
+      "breakpoints": true
+    },
+    {
+      "idx": 7,
+      "version": "5",
+      "when": 1786147200000,
+      "tag": "0007_word-entry",
+      "breakpoints": true
+    },
+    {
+      "idx": 8,
+      "version": "5",
+      "when": 1786233600000,
+      "tag": "0008_points",
+      "breakpoints": true
    }
  ]
 }
@@ -12,7 +12,8 @@ if (!url) {

 const connection = await mysql.createConnection(url);
 try {
-  await migrate(drizzle(connection), { migrationsFolder: "/app/drizzle" });
+  // xuchao: 容器内固定 /app/drizzle;本地测试可用 MIGRATIONS_DIR 覆盖
+  await migrate(drizzle(connection), { migrationsFolder: process.env.MIGRATIONS_DIR || "/app/drizzle" });
  console.log("数据库迁移完成");
 } finally {
  await connection.end();
@@ -0,0 +1,33 @@
+// xuchao: 单词词库种子——words.json 灌入 word_entry;仅表空时全量灌入,已有数据视为家长已编辑,跳过
+import { sql } from "drizzle-orm";
+import { drizzle } from "drizzle-orm/mysql2";
+import mysql from "mysql2/promise";
+import raw from "../src/content/words/words.json";
+import { wordEntry } from "../src/db/schema";
+
+async function main() {
+  const conn = await mysql.createConnection(process.env.DATABASE_URL!);
+  const db = drizzle(conn);
+
+  const [cnt] = await db.select({ n: sql<number>`COUNT(*)` }).from(wordEntry);
+  if (cnt.n > 0) {
+    console.log("word_entry 已有", cnt.n, "条,跳过灌入(视为已编辑数据)");
+    await conn.end();
+    return;
+  }
+
+  const rows = (raw as { word: string; meaning: string; day: number; seq: number }[]).map((w) => ({
+    word: w.word,
+    meaning: w.meaning,
+    day: w.day,
+    seq: w.seq,
+  }));
+  // 分批插入,避免单条 SQL 过大
+  for (let i = 0; i < rows.length; i += 500) {
+    await db.insert(wordEntry).values(rows.slice(i, i + 500));
+  }
+  console.log("word_entry 灌入完成:", rows.length, "条");
+  await conn.end();
+}
+
+main();
@@ -0,0 +1,49 @@
+// xuchao: 本地开发照片回退——OSS 未配置时,解答题照片直传/查看走本地磁盘
+// 生产环境配置了 OSS 或 NODE_ENV=production 时,本路由一律 404
+import { NextRequest, NextResponse } from "next/server";
+import fs from "node:fs";
+import path from "node:path";
+import { ossConfigured } from "@/lib/oss";
+
+const BASE = path.join(process.cwd(), ".dev-uploads");
+
+function disabled() {
+  return ossConfigured() || process.env.NODE_ENV === "production";
+}
+
+// xuchao: 键名白名单校验 + 防路径穿越
+function safePath(key: string): string | null {
+  if (!/^exam-solve\/\d+\/[\w-]+\/q\d+-[0-9a-f]{16}\.jpg$/.test(key)) return null;
+  const p = path.normalize(path.join(BASE, key));
+  return p.startsWith(BASE + path.sep) ? p : null;
+}
+
+// xuchao: 直传入口:multipart file + key
+export async function POST(req: NextRequest) {
+  if (disabled()) return NextResponse.json({ error: "not available" }, { status: 404 });
+  const form = await req.formData();
+  const file = form.get("file");
+  const key = form.get("key");
+  if (!(file instanceof File) || typeof key !== "string") {
+    return NextResponse.json({ error: "缺少文件或键名" }, { status: 400 });
+  }
+  const target = safePath(key);
+  if (!target) return NextResponse.json({ error: "键名不合法" }, { status: 400 });
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  const buf = Buffer.from(await file.arrayBuffer());
+  if (buf.byteLength > 8 * 1024 * 1024) {
+    return NextResponse.json({ error: "照片过大" }, { status: 400 });
+  }
+  fs.writeFileSync(target, buf);
+  return NextResponse.json({ ok: true, key });
+}
+
+// xuchao: 查看入口:?key=xxx
+export async function GET(req: NextRequest) {
+  if (disabled()) return NextResponse.json({ error: "not available" }, { status: 404 });
+  const key = req.nextUrl.searchParams.get("key") ?? "";
+  const target = safePath(key);
+  if (!target || !fs.existsSync(target)) return NextResponse.json({ error: "不存在" }, { status: 404 });
+  const buf = fs.readFileSync(target);
+  return new NextResponse(buf, { headers: { "Content-Type": "image/jpeg" } });
+}
@@ -1,18 +1,105 @@
 "use server";

-// xuchao: 考试判分——按卷面题判分,错题进错题本,达标联动数学打卡
+// xuchao: 考试判分——客观题即时判分;解答题拍照后 AI 按评分点判分,成绩以服务端日志为准
 import { revalidatePath } from "next/cache";
 import { getSessionUser } from "@/lib/auth";
-import { gradeAnswers, type AnswerValue } from "@/lib/grammar";
-import { getPaper, paperQuestions, recordExam } from "@/lib/exam";
+import { gradeOne, gradeAnswers, type AnswerValue } from "@/lib/grammar";
+import { getPaper, gradeCountToday, latestSolveLogs, paperQuestions, recordExam } from "@/lib/exam";
 import { recordWrong } from "@/lib/wrongbook";
+import { gradeSolvePhoto, type GradeVerdict } from "@/lib/ai-grade";
+import { ossConfigured, photoViewUrl, solveKey, uploadUrl } from "@/lib/oss";
+import { db } from "@/db";
+import { aiGradeLog } from "@/db/schema";
+
+// xuchao: 每人每天最多判分次数(防滥用)
+const GRADE_DAILY_LIMIT = 30;
+
+export type SolveDetail = {
+  qIndex: number;
+  ossKey: string;
+  status: string;
+  earned: number;
+  points: number;
+  hits: GradeVerdict["hits"];
+  comment: string;
+};

 export type ExamResult =
-  | { score: number; passed: boolean; correct: number; total: number; detail: boolean[] }
+  | {
+      score: number;
+      passed: boolean;
+      correct: number;
+      total: number;
+      detail: boolean[];
+      solves?: SolveDetail[];
+      pointsEarned: number;
+    }
  | { error: string };

-// 提交试卷:服务端判分、记录成绩、错题入库;可重考,取最近一次成绩
-export async function takeExam(paperId: string, answers: AnswerValue[]): Promise<ExamResult> {
+// xuchao: 签发解答题照片直传地址(或本地开发回退)
+export async function getSolveUploadUrl(
+  paperId: string,
+  questionIndex: number,
+): Promise<{ mode: "oss"; url: string; key: string } | { mode: "dev"; key: string } | { error: string }> {
+  const user = await getSessionUser();
+  if (!user || user.role !== "child") return { error: "会话无效,请重新激活设备" };
+  const key = solveKey(user.id, paperId, questionIndex);
+  if (!ossConfigured()) return { mode: "dev", key };
+  return { mode: "oss", url: uploadUrl(key, "image/jpeg"), key };
+}
+
+// xuchao: 单题判分——调 AI、写审计日志、返回逐评分点结果;限频 30 次/天
+export async function gradeSolve(
+  paperId: string,
+  questionIndex: number,
+  ossKey: string,
+): Promise<{ verdict: GradeVerdict; photoUrl: string } | { error: string }> {
+  const user = await getSessionUser();
+  if (!user || user.role !== "child") return { error: "会话无效,请重新激活设备" };
+
+  const paper = await getPaper(paperId);
+  if (!paper) return { error: "试卷不存在" };
+  const questions = paperQuestions(paper);
+  const q = questions[questionIndex];
+  if (!q || q.type !== "solve") return { error: "题目不存在或不是解答题" };
+
+  // xuchao: 键名必须属于本人本卷,防止拿别人的 key 判分
+  const prefix = `exam-solve/${user.id}/${paperId}/`;
+  if (!ossKey.startsWith(prefix) || !ossKey.endsWith(".jpg")) return { error: "照片键名不合法" };
+
+  const used = await gradeCountToday(user.id);
+  if (used >= GRADE_DAILY_LIMIT) return { error: `今日 AI 判分次数已用完(${GRADE_DAILY_LIMIT} 次),明天再来吧` };
+
+  const points = q.points ?? 0;
+  // xuchao: 未配 OSS 时照片在本地磁盘,AI 模型读不到,强制演示判分
+  const verdict = await gradeSolvePhoto({
+    stem: q.stem,
+    points,
+    rubric: q.rubric ?? [],
+    reference: q.reference ?? "",
+    photoUrl: photoViewUrl(ossKey),
+    figureUrl: q.figure ? `/exam/${paper.paperId}/${q.figure}` : undefined,
+  });
+
+  await db.insert(aiGradeLog).values({
+    childUserId: user.id,
+    paperId,
+    questionIndex,
+    ossKey,
+    status: verdict.status,
+    earned: verdict.earned,
+    points,
+    verdict: JSON.stringify({ hits: verdict.hits, comment: verdict.comment }),
+    mock: verdict.mock,
+    model: verdict.model,
+    ms: verdict.ms,
+  });
+
+  return { verdict, photoUrl: photoViewUrl(ossKey) };
+}
+
+// xuchao: 提交试卷——纯客观卷走原逻辑;含解答题的卷按分值加权,解答题得分取服务端判分日志
+export async function takeExam(paperId: string, answers: (AnswerValue | null)[]): Promise<ExamResult> {
  const user = await getSessionUser();
  if (!user || user.role !== "child") return { error: "会话无效,请重新激活设备" };

@@ -22,16 +109,82 @@ export async function takeExam(paperId: string, answers: AnswerValue[]): Promise
  const questions = paperQuestions(paper);
  if (questions.length === 0) return { error: "试卷暂无题目" };

-  const g = gradeAnswers(questions, answers);
-  questions.forEach((q, i) => {
-    if (!g.detail[i]) void recordWrong(user.id, "exam", paperId, paper.title, q, answers[i]);
-  });
-  await recordExam(user.id, paperId, paper.title, g.score, g.correct, g.total, g.passed, answers);
+  const hasSolve = questions.some((q) => q.type === "solve");

+  if (!hasSolve) {
+    // 原有客观卷判分路径,保持行为不变
+    const g = gradeAnswers(questions, answers.map((a) => a as AnswerValue));
+    questions.forEach((q, i) => {
+      if (!g.detail[i]) void recordWrong(user.id, "exam", paperId, paper.title, q, answers[i]);
+    });
+    const pointsEarned = await recordExam(user.id, paperId, paper.title, g.score, g.correct, g.total, g.passed, answers);
+    revalidateAll(paperId);
+    return { ...g, pointsEarned };
+  }
+
+  // xuchao: 混合卷加权判分——解答题只信服务端最近一次判定,不信任客户端上报
+  const logs = await latestSolveLogs(user.id, paperId);
+  let earnedSum = 0;
+  let pointSum = 0;
+  let correct = 0;
+  const detail: boolean[] = [];
+  const solves: SolveDetail[] = [];
+  const storedAnswers: unknown[] = [];
+
+  questions.forEach((q, i) => {
+    const pts = q.points ?? 1;
+    pointSum += pts;
+    if (q.type === "solve") {
+      const log = logs.get(i);
+      const okLog = log && log.status === "ok" ? log : null;
+      const earned = okLog ? Math.min(okLog.earned, pts) : 0;
+      earnedSum += earned;
+      const full = earned >= pts;
+      if (full) correct++;
+      detail.push(full);
+      const hits = okLog ? (JSON.parse(okLog.verdict ?? "{}") as { hits?: GradeVerdict["hits"] }).hits ?? [] : [];
+      solves.push({
+        qIndex: i,
+        ossKey: log?.ossKey ?? "",
+        status: log?.status ?? "missing",
+        earned,
+        points: pts,
+        hits,
+        comment: okLog ? (JSON.parse(okLog.verdict ?? "{}") as { comment?: string }).comment ?? "" : "未完成判分",
+      });
+      storedAnswers.push({ type: "solve", qIndex: i, ossKey: log?.ossKey ?? "", earned, points: pts });
+      if (!full) {
+        void recordWrong(user.id, "exam", paperId, paper.title, q, null, {
+          ossKey: log?.ossKey ?? "",
+          earned,
+          hits,
+        });
+      }
+    } else {
+      const ok = gradeOne(q, answers[i]);
+      if (ok) {
+        correct++;
+        earnedSum += pts;
+      } else {
+        void recordWrong(user.id, "exam", paperId, paper.title, q, answers[i]);
+      }
+      detail.push(ok);
+      storedAnswers.push(answers[i] ?? null);
+    }
+  });
+
+  const score = pointSum ? Math.round((earnedSum / pointSum) * 100) : 0;
+  const passed = score >= 80;
+  const pointsEarned = await recordExam(user.id, paperId, paper.title, score, correct, questions.length, passed, storedAnswers);
+  revalidateAll(paperId);
+  return { score, passed, correct, total: questions.length, detail, solves, pointsEarned };
+}
+
+function revalidateAll(paperId: string) {
  revalidatePath("/exam");
  revalidatePath(`/exam/${paperId}`);
  revalidatePath("/kid");
  revalidatePath("/parent");
  revalidatePath("/wrongbook");
-  return g;
+  revalidatePath("/points");
 }
@@ -8,15 +8,16 @@ import { cn } from "@/lib/utils";
 import { EXAM_TYPE_LABEL, listPapers, recordsByPaper } from "@/lib/exam";
 import { getSessionUser } from "@/lib/auth";

-// xuchao: 月份分组展示顺序与标签(初一上:9月~次年1月)
+// xuchao: 月份分组展示顺序与标签(入学分班考 + 初一上:9月~次年1月)
 const MONTH_LABEL: Record<number, string> = {
+  0: "入学 · 分班考",
  9: "9 月 · 有理数",
  10: "10 月 · 整式的加减",
  11: "11 月 · 一元一次方程",
  12: "12 月 · 几何图形初步",
  1: "1 月 · 期末全册",
 };
-const MONTH_ORDER = [9, 10, 11, 12, 1];
+const MONTH_ORDER = [0, 9, 10, 11, 12, 1];

 export default async function ExamHome() {
  const user = await getSessionUser();
@@ -7,6 +7,7 @@ import { photos, taskInstances } from "@/db/schema";
 import { todayStr } from "@/lib/dates";
 import { photoKey, uploadUrl } from "@/lib/oss";
 import { getSessionUser } from "@/lib/auth";
+import { awardPoints } from "@/lib/points";

 // 取当前孩子会话,非法则抛错(客户端会显示)
 async function requireChild() {
@@ -25,8 +26,8 @@ async function ownedTask(childId: number, instanceId: number) {
  return task;
 }

-// 勾选 / 取消勾选(仅限今天;需凭证的任务必须有照片才能勾)
-export async function toggleTask(instanceId: number, done: boolean) {
+// 勾选 / 取消勾选(仅限今天;需凭证的任务必须有照片才能勾);首次勾选发积分
+export async function toggleTask(instanceId: number, done: boolean): Promise<{ pointsEarned: number }> {
  const child = await requireChild();
  const task = await ownedTask(child.id, instanceId);
  if (task.date !== todayStr()) throw new Error("只能给今天的任务打卡");
@@ -45,7 +46,14 @@ export async function toggleTask(instanceId: number, done: boolean) {
    .set({ status: done ? "done" : "pending", doneAt: done ? new Date() : null })
    .where(eq(taskInstances.id, instanceId));

+  // xuchao: 首次完成才发分(唯一键防刷),分值取任务快照上的设置
+  const pointsEarned = done
+    ? await awardPoints(child.id, "checkin", `inst-${instanceId}`, task.points, task.title)
+    : 0;
+
  revalidatePath("/kid");
+  revalidatePath("/points");
+  return { pointsEarned };
 }

 // 签发照片直传地址(浏览器 PUT 到对象存储)
@@ -14,6 +14,7 @@ import { dayTasks, childCheckStats } from "@/lib/tasks";
 import { listPoints, passedByPoint } from "@/lib/grammar";
 import { listMathPoints, mathPassedByPoint } from "@/lib/math";
 import { recordsByPaper } from "@/lib/exam";
+import { totalPoints } from "@/lib/points";
 import { TaskCard } from "./task-card";

 export default async function KidPage() {
@@ -22,10 +23,11 @@ export default async function KidPage() {
  if (user.role !== "child") redirect("/parent");

  const today = todayStr();
-  const [tasks, streak, stats] = await Promise.all([
+  const [tasks, streak, stats, myPoints] = await Promise.all([
    dayTasks(user.id, today),
    streakOf(user.id),
    childCheckStats(user.id, 7),
+    totalPoints(user.id),
  ]);
  const doneCount = tasks.filter((t) => t.status === "done").length;
  const allDone = tasks.length > 0 && doneCount === tasks.length;
@@ -63,10 +65,20 @@ export default async function KidPage() {
          </h1>
          <p className="text-sm text-muted-foreground">{today}</p>
        </div>
-        <div className="flex items-center gap-1.5 rounded-full bg-gradient-to-r from-amber-400 to-orange-500 px-4 py-2 text-white shadow-[0_4px_14px_0_rgba(249,115,22,0.35)]">
-          <Flame className="size-5" fill="currentColor" />
-          <span className="text-xl font-extrabold">{streak}</span>
-          <span className="text-xs font-medium">天</span>
+        <div className="flex items-center gap-2">
+          <Link
+            href="/points"
+            className="flex items-center gap-1.5 rounded-full bg-gradient-to-r from-yellow-400 to-amber-500 px-3.5 py-2 text-white shadow-[0_4px_14px_0_rgba(245,158,11,0.35)]"
+            title="我的积分"
+          >
+            <span className="text-base">🪙</span>
+            <span className="text-xl font-extrabold">{myPoints}</span>
+          </Link>
+          <div className="flex items-center gap-1.5 rounded-full bg-gradient-to-r from-amber-400 to-orange-500 px-4 py-2 text-white shadow-[0_4px_14px_0_rgba(249,115,22,0.35)]">
+            <Flame className="size-5" fill="currentColor" />
+            <span className="text-xl font-extrabold">{streak}</span>
+            <span className="text-xs font-medium">天</span>
+          </div>
        </div>
      </header>

@@ -35,6 +35,7 @@ export function TaskCard({
  const fileRef = useRef<HTMLInputElement>(null);
  const [busy, startTransition] = useTransition();
  const [error, setError] = useState("");
+  const [earned, setEarned] = useState<number | null>(null);
  const done = task.status === "done";
  const canCheck = !task.requiresPhoto || task.photoUrls.length > 0;

@@ -46,7 +47,8 @@ export function TaskCard({
    }
    startTransition(async () => {
      try {
-        await toggleTask(task.id, !done);
+        const r = await toggleTask(task.id, !done);
+        setEarned(!done && r.pointsEarned > 0 ? r.pointsEarned : null);
      } catch (e) {
        setError(e instanceof Error ? e.message : "操作失败");
      }
@@ -111,6 +113,11 @@ export function TaskCard({
                补卡
              </span>
            )}
+            {earned !== null && (
+              <span className="rounded-full bg-amber-100 px-2 py-0.5 text-xs font-bold text-amber-600">
+                🪙 +{earned} 积分
+              </span>
+            )}
          </div>
        </div>
        {task.requiresPhoto && task.photoUrls.length < 3 && (
@@ -6,7 +6,7 @@ import { completePoint, extractQuiz, getPoint, gradeAnswers, type AnswerValue }
 import { recordWrong } from "@/lib/wrongbook";

 export type QuizResult =
-  | { score: number; passed: boolean; correct: number; total: number; detail: boolean[] }
+  | { score: number; passed: boolean; correct: number; total: number; detail: boolean[]; pointsEarned: number }
  | { error: string };

 // 提交结课练习:服务端按课文 quiz 判分,达标记进度并联动英语打卡
@@ -25,12 +25,13 @@ export async function submitQuiz(pointId: string, answers: AnswerValue[]): Promi
  questions.forEach((q, i) => {
    if (!g.detail[i]) void recordWrong(user.id, "lesson", pointId, point.title, q, answers[i]);
  });
-  await completePoint(user.id, pointId, point.title, g.score, g.passed);
+  const pointsEarned = await completePoint(user.id, pointId, point.title, g.score, g.passed);

  revalidatePath("/learn");
  revalidatePath(`/learn/${pointId}`);
  revalidatePath("/kid");
  revalidatePath("/parent");
  revalidatePath("/wrongbook");
-  return g;
+  revalidatePath("/points");
+  return { ...g, pointsEarned };
 }
@@ -1,17 +1,28 @@
 "use client";

-import { useTransition, useState } from "react";
+import { useTransition, useRef, useState } from "react";
 import Link from "next/link";
-import { Check, X } from "lucide-react";
+import { Camera, Check, Loader2, RotateCcw, X } from "lucide-react";
 import { Button } from "@/components/ui/button";
 import { cn } from "@/lib/utils";
 import type { QuizQ } from "@/lib/quiz-parse";
 import type { AnswerValue } from "@/lib/grammar";
+import type { GradeVerdict } from "@/lib/ai-grade";
+import { getSolveUploadUrl, gradeSolve } from "@/app/exam/actions";
 import { submitQuiz, type QuizResult } from "./actions";

 type AV = AnswerValue | null;

-// 结课检验:选择/判断/填空/连词成句/连线,提交后服务端判分,达标点亮并联动打卡
+// xuchao: 解答题拍照状态机
+type SolveState =
+  | { phase: "idle" }
+  | { phase: "preview"; blob: Blob; dataUrl: string }
+  | { phase: "grading"; dataUrl: string }
+  | { phase: "graded"; dataUrl: string; photoUrl: string; verdict: GradeVerdict };
+
+type CellValue = AV | SolveState;
+
+// 结课检验:选择/判断/填空/连词成句/连线/解答题(拍照),提交后服务端判分,达标点亮并联动打卡
 // 文案可配置:数学课/考试卷复用此组件时传入各自的标题、打卡文案与返回地址
 export function QuizBlock({
  pointId,
@@ -32,18 +43,21 @@ export function QuizBlock({
  backHref?: string;
  backLabel?: string;
 }) {
-  const [answers, setAnswers] = useState<AV[]>(questions.map(() => null));
+  const [answers, setAnswers] = useState<CellValue[]>(questions.map(() => null));
  const [result, setResult] = useState<Extract<QuizResult, { score: number }> | null>(null);
  const [error, setError] = useState("");
  const [pending, startTransition] = useTransition();

-  const set = (i: number, v: AV) => {
+  const set = (i: number, v: CellValue) => {
    const next = [...answers];
    next[i] = v;
    setAnswers(next);
  };

-  const isAnswered = (q: QuizQ, a: AV): boolean => {
+  const isAnswered = (q: QuizQ, a: CellValue): boolean => {
+    if (q.type === "solve") {
+      return !!a && typeof a === "object" && "phase" in a && a.phase === "graded" && a.verdict.status === "ok";
+    }
    if (q.type === "fill") return typeof a === "string" && a.trim() !== "";
    if (q.type === "order") return Array.isArray(a) && a.length === (q.words ?? []).length;
    if (q.type === "match") return Array.isArray(a) && a.length === (q.pairs ?? []).length && a.every((x) => x !== null && x !== "");
@@ -54,9 +68,11 @@ export function QuizBlock({
  const submit = () => {
    setError("");
    startTransition(async () => {
+      // xuchao: 解答题得分以服务端判分日志为准,客户端只传 null 占位
+      const payload = answers.map((a, i) => (questions[i].type === "solve" ? null : (a as AnswerValue)));
      const r = submitter
-        ? await submitter(answers.map((a) => a as AnswerValue))
-        : await submitQuiz(pointId, answers.map((a) => a as AnswerValue));
+        ? await submitter(payload as AnswerValue[])
+        : await submitQuiz(pointId, payload as AnswerValue[]);
      if ("error" in r) setError(r.error);
      else setResult(r);
    });
@@ -74,6 +90,7 @@ export function QuizBlock({
            <div key={qi} className="rounded-xl border border-slate-100 bg-slate-50/60 p-4">
              <p className="font-medium text-slate-900">
                {qi + 1}. {q.stem}
+                {q.type === "solve" && <span className="ml-2 rounded bg-amber-100 px-1.5 py-0.5 text-xs font-semibold text-amber-700">{q.points} 分 · 拍照作答</span>}
              </p>

              {q.type === "fill" && (
@@ -117,11 +134,21 @@ export function QuizBlock({
                </div>
              )}

-              {q.type === "order" && <OrderInput q={q} a={a} disabled={!!result} onChange={(v) => set(qi, v)} />}
+              {q.type === "order" && <OrderInput q={q} a={a as AV} disabled={!!result} onChange={(v) => set(qi, v)} />}

-              {q.type === "match" && <MatchInput q={q} a={a} disabled={!!result} onChange={(v) => set(qi, v)} />}
+              {q.type === "match" && <MatchInput q={q} a={a as AV} disabled={!!result} onChange={(v) => set(qi, v)} />}

-              {result && (
+              {q.type === "solve" && (
+                <SolveInput
+                  paperId={pointId}
+                  qIndex={qi}
+                  value={a as SolveState | null}
+                  disabled={!!result}
+                  onChange={(v) => set(qi, v)}
+                />
+              )}
+
+              {result && q.type !== "solve" && (
                <p className="mt-2 text-sm text-muted-foreground">
                  {q.type === "fill" && (
                    <span className="mr-2 font-medium text-emerald-700">参考:{(q.answers ?? []).join(" / ")}</span>
@@ -137,7 +164,14 @@ export function QuizBlock({
                  解说:{q.explain}
                </p>
              )}
-              {result && ok === false && <p className="mt-1 text-xs text-rose-600">这题答错了,看看上面的参考与解说。</p>}
+              {result && q.type === "solve" && (
+                <div className="mt-2 space-y-1 text-sm">
+                  <p className="font-medium text-emerald-700">参考解答:</p>
+                  <p className="whitespace-pre-line rounded-lg bg-white px-3 py-2 text-slate-700 ring-1 ring-slate-200">{q.reference}</p>
+                  <p className="text-muted-foreground">解说:{q.explain}</p>
+                </div>
+              )}
+              {result && ok === false && <p className="mt-1 text-xs text-rose-600">这题没拿满分,看看上面的参考与解说。</p>}
            </div>
          );
        })}
@@ -164,6 +198,9 @@ export function QuizBlock({
            答对 {result.correct} / {result.total}
            {result.passed ? ` · ${passText}` : " · 看看解说,再试一次"}
          </p>
+          {result.passed && result.pointsEarned > 0 && (
+            <p className="mt-1 text-base font-extrabold">🪙 +{result.pointsEarned} 积分</p>
+          )}
          <div className="mt-4 flex justify-center gap-3">
            {!result.passed && (
              <Button variant="secondary" onClick={() => window.location.reload()}>
@@ -180,6 +217,229 @@ export function QuizBlock({
  );
 }

+// xuchao: 解答题拍照输入——纸上写→拍照→压缩→直传→AI 逐评分点判分,可重拍
+function SolveInput({
+  paperId,
+  qIndex,
+  value,
+  disabled,
+  onChange,
+}: {
+  paperId: string;
+  qIndex: number;
+  value: SolveState | null;
+  disabled: boolean;
+  onChange: (v: SolveState) => void;
+}) {
+  const fileRef = useRef<HTMLInputElement>(null);
+  const [busy, setBusy] = useState("");
+  const [err, setErr] = useState("");
+  const st = value ?? { phase: "idle" as const };
+
+  // xuchao: 压缩到 ≤2MB(先缩到 2000px 内,再降质量)
+  const compress = (file: File) =>
+    new Promise<{ blob: Blob; dataUrl: string }>((resolve, reject) => {
+      const url = URL.createObjectURL(file);
+      const img = new Image();
+      img.onload = () => {
+        URL.revokeObjectURL(url);
+        const scale = Math.min(1, 2000 / Math.max(img.width, img.height));
+        const w = Math.max(1, Math.round(img.width * scale));
+        const h = Math.max(1, Math.round(img.height * scale));
+        const canvas = document.createElement("canvas");
+        canvas.width = w;
+        canvas.height = h;
+        const ctx = canvas.getContext("2d");
+        if (!ctx) return reject(new Error("浏览器不支持图片处理"));
+        ctx.drawImage(img, 0, 0, w, h);
+        let quality = 0.85;
+        const attempt = () =>
+          canvas.toBlob(
+            (b) => {
+              if (!b) return reject(new Error("图片压缩失败"));
+              if (b.size > 2 * 1024 * 1024 && quality > 0.4) {
+                quality -= 0.15;
+                return attempt();
+              }
+              const r = new FileReader();
+              r.onload = () => resolve({ blob: b, dataUrl: String(r.result) });
+              r.onerror = () => reject(new Error("读取图片失败"));
+              r.readAsDataURL(b);
+            },
+            "image/jpeg",
+            quality,
+          );
+        attempt();
+      };
+      img.onerror = () => {
+        URL.revokeObjectURL(url);
+        reject(new Error("图片加载失败,请换一张"));
+      };
+      img.src = url;
+    });
+
+  const onPick = async (file: File | undefined) => {
+    if (!file || disabled) return;
+    setErr("");
+    try {
+      const { blob, dataUrl } = await compress(file);
+      onChange({ phase: "preview", blob, dataUrl });
+    } catch (e) {
+      setErr(e instanceof Error ? e.message : "处理照片失败");
+    }
+  };
+
+  const doGrade = async (blob: Blob, dataUrl: string) => {
+    setErr("");
+    setBusy("上传中…");
+    onChange({ phase: "grading", dataUrl });
+    try {
+      const up = await getSolveUploadUrl(paperId, qIndex);
+      if ("error" in up) throw new Error(up.error);
+      if (up.mode === "oss") {
+        const resp = await fetch(up.url, { method: "PUT", headers: { "Content-Type": "image/jpeg" }, body: blob });
+        if (!resp.ok) throw new Error("照片上传失败,请重试");
+      } else {
+        const fd = new FormData();
+        fd.append("file", blob, "solve.jpg");
+        fd.append("key", up.key);
+        const resp = await fetch("/api/dev-photo", { method: "POST", body: fd });
+        if (!resp.ok) throw new Error("照片上传失败,请重试");
+      }
+      setBusy("AI 判分中…");
+      let r = await gradeSolve(paperId, qIndex, up.key);
+      // xuchao: 调用失败自动重试一次
+      if ("error" in r && /失败|超时/.test(r.error)) r = await gradeSolve(paperId, qIndex, up.key);
+      if ("error" in r) throw new Error(r.error);
+      onChange({ phase: "graded", dataUrl, photoUrl: r.photoUrl, verdict: r.verdict });
+    } catch (e) {
+      setErr(e instanceof Error ? e.message : "判分失败,请重试");
+      onChange({ phase: "preview", blob, dataUrl });
+    } finally {
+      setBusy("");
+    }
+  };
+
+  if (st.phase === "idle") {
+    return (
+      <div className="mt-2">
+        <input
+          ref={fileRef}
+          type="file"
+          accept="image/*"
+          capture="environment"
+          className="hidden"
+          onChange={(e) => {
+            void onPick(e.target.files?.[0]);
+            e.target.value = "";
+          }}
+        />
+        <button
+          type="button"
+          disabled={disabled}
+          onClick={() => fileRef.current?.click()}
+          className="flex w-full items-center justify-center gap-2 rounded-xl border-2 border-dashed border-indigo-300 bg-indigo-50/50 px-4 py-6 text-sm font-semibold text-indigo-700 hover:bg-indigo-50"
+        >
+          <Camera className="size-5" /> 在纸上写好,拍照上传
+        </button>
+        <p className="mt-1 text-xs text-muted-foreground">写清每一步过程,按评分点给分;请横拍、光线充足、字迹清楚。</p>
+      </div>
+    );
+  }
+
+  const dataUrl = st.phase === "preview" || st.phase === "grading" || st.phase === "graded" ? st.dataUrl : "";
+  return (
+    <div className="mt-2 space-y-2">
+      {/* eslint-disable-next-line @next/next/no-img-element */}
+      <img src={dataUrl} alt="作答照片" className="max-h-64 w-full rounded-lg border border-slate-200 object-contain" />
+
+      {st.phase === "preview" && !disabled && (
+        <div className="flex gap-2">
+          <Button size="sm" className="flex-1" onClick={() => void doGrade(st.blob, st.dataUrl)}>
+            <Check className="size-4" /> 就这张,开始判分
+          </Button>
+          <Button size="sm" variant="outline" onClick={() => fileRef.current?.click()}>
+            <RotateCcw className="size-4" /> 重拍
+          </Button>
+          <input
+            ref={fileRef}
+            type="file"
+            accept="image/*"
+            capture="environment"
+            className="hidden"
+            onChange={(e) => {
+              void onPick(e.target.files?.[0]);
+              e.target.value = "";
+            }}
+          />
+        </div>
+      )}
+
+      {st.phase === "grading" && (
+        <p className="flex items-center gap-2 text-sm font-medium text-indigo-600">
+          <Loader2 className="size-4 animate-spin" /> {busy || "AI 判分中…"}
+        </p>
+      )}
+
+      {st.phase === "graded" && (
+        <>
+          <SolveVerdict verdict={st.verdict} />
+          {st.verdict.status !== "ok" && !disabled && (
+            <Button size="sm" variant="outline" onClick={() => onChange({ phase: "idle" })}>
+              <RotateCcw className="size-4" /> 重新拍照
+            </Button>
+          )}
+        </>
+      )}
+
+      {err && <p className="text-sm font-medium text-destructive">{err}</p>}
+    </div>
+  );
+}
+
+// xuchao: 判分结果展示——逐评分点命中情况 + 得分 + AI 点评
+function SolveVerdict({ verdict }: { verdict: GradeVerdict }) {
+  if (verdict.status !== "ok") {
+    const tip: Record<string, string> = {
+      blank: "照片里没有作答内容,请写完再拍。",
+      blurry: "字迹太模糊啦,重新拍一张清楚点的。",
+      printed: "只能批改手写解答,请把过程写在纸上再拍。",
+      unrelated: "照片内容和这道题无关,请拍这道题的解答。",
+      error: "AI 判分出了点问题,请重试。",
+    };
+    return (
+      <div className="rounded-lg border border-amber-200 bg-amber-50 px-3 py-2 text-sm text-amber-800">
+        {tip[verdict.status] ?? "请重新拍照"} {verdict.comment && <span className="text-amber-700">({verdict.comment})</span>}
+      </div>
+    );
+  }
+  const total = verdict.hits.reduce((s, h) => s + h.score, 0);
+  return (
+    <div className="space-y-1.5 rounded-lg border border-indigo-100 bg-white px-3 py-2">
+      <p className="text-sm font-bold text-slate-900">
+        AI 判分:{verdict.earned} / {total} 分
+      </p>
+      <ul className="space-y-1">
+        {verdict.hits.map((h, i) => (
+          <li key={i} className="flex items-start gap-1.5 text-xs">
+            {h.hit ? (
+              <Check className="mt-0.5 size-3.5 shrink-0 text-emerald-600" />
+            ) : (
+              <X className="mt-0.5 size-3.5 shrink-0 text-rose-500" />
+            )}
+            <span className={h.hit ? "text-slate-600" : "text-rose-600"}>
+              ({h.score}分){h.point}
+              {h.reason && <span className="text-muted-foreground"> —— {h.reason}</span>}
+            </span>
+          </li>
+        ))}
+      </ul>
+      {verdict.comment && <p className="text-xs text-indigo-600">💬 {verdict.comment}</p>}
+      {verdict.mock && <p className="text-[10px] text-muted-foreground">演示判分(未配置 AI Key)</p>}
+    </div>
+  );
+}
+
 // 连词成句:点词入槽,再点槽里的词可移回
 function OrderInput({
  q,
@@ -7,7 +7,7 @@ import { completeMathPoint, extractQuiz, getMathPoint, gradeAnswers, type Answer
 import { recordWrong } from "@/lib/wrongbook";

 export type QuizResult =
-  | { score: number; passed: boolean; correct: number; total: number; detail: boolean[] }
+  | { score: number; passed: boolean; correct: number; total: number; detail: boolean[]; pointsEarned: number }
  | { error: string };

 // 提交数学课练习:服务端判分,达标记进度并联动数学打卡
@@ -26,12 +26,13 @@ export async function submitMathQuiz(pointId: string, answers: AnswerValue[]): P
  questions.forEach((q, i) => {
    if (!g.detail[i]) void recordWrong(user.id, "mlesson", pointId, point.title, q, answers[i]);
  });
-  await completeMathPoint(user.id, pointId, point.title, g.score, g.passed);
+  const pointsEarned = await completeMathPoint(user.id, pointId, point.title, g.score, g.passed);

  revalidatePath("/math");
  revalidatePath(`/math/${pointId}`);
  revalidatePath("/kid");
  revalidatePath("/parent");
  revalidatePath("/wrongbook");
-  return g;
+  revalidatePath("/points");
+  return { ...g, pointsEarned };
 }
@@ -10,9 +10,10 @@ import { recordWrong } from "@/lib/wrongbook";
 import { db } from "@/db";
 import { taskInstances, mathWeeklyTest } from "@/db/schema";
 import { todayStr } from "@/lib/dates";
+import { awardRulePoints } from "@/lib/points";

 export type MathWeeklyResult =
-  | { score: number; passed: boolean; correct: number; total: number; detail: boolean[] }
+  | { score: number; passed: boolean; correct: number; total: number; detail: boolean[]; pointsEarned: number }
  | { error: string };

 // 提交数学每周检测:判分、记录、错题入库、达标关联当日数学打卡
@@ -44,8 +45,10 @@ export async function takeMathWeekly(answers: AnswerValue[]): Promise<MathWeekly
    })
    .onDuplicateKeyUpdate({ set: { score: g.score, correct: g.correct, total: g.total, passed: g.passed } });

-  // 达标关联当日数学打卡
+  // 达标关联当日数学打卡,并发积分(首次达标才发)
+  let pointsEarned = 0;
  if (g.passed) {
+    pointsEarned = await awardRulePoints(user.id, "math_weekly", `week-${wk}`, `数学周检测 ${wk}`);
    const today = todayStr();
    const title = `数学周检测 · ${wk}`;
    const [ex] = await db
@@ -73,5 +76,6 @@ export async function takeMathWeekly(answers: AnswerValue[]): Promise<MathWeekly
  revalidatePath("/kid");
  revalidatePath("/parent");
  revalidatePath("/wrongbook");
-  return g;
+  revalidatePath("/points");
+  return { ...g, pointsEarned };
 }
@@ -4,6 +4,7 @@ import { redirect } from "next/navigation";
 import { BackgroundBlobs } from "@/components/background-blobs";
 import { getSessionUser } from "@/lib/auth";
 import { buildMathWeeklyQuestions, currentMathWeekKey, getMathWeeklyRecord } from "@/lib/math-weekly";
+import { getAwardedPoints } from "@/lib/points";
 import { QuizBlock } from "@/app/learn/quiz-block";
 import { takeMathWeekly } from "./actions";

@@ -15,6 +16,8 @@ export default async function MathWeeklyPage() {
  const wk = currentMathWeekKey();
  const record = await getMathWeeklyRecord(user.id, wk);
  const questions = record ? [] : await buildMathWeeklyQuestions(user.id, wk);
+  // xuchao: 已有记录时从流水取回本周达标的积分,结果页刷新后仍显示
+  const awarded = record?.passed ? await getAwardedPoints(user.id, "math_weekly", `week-${wk}`) : 0;

  return (
    <main className="relative mx-auto max-w-2xl space-y-5 p-4 pb-12">
@@ -42,6 +45,7 @@ export default async function MathWeeklyPage() {
          <p className="mt-1 text-sm opacity-90">
            答对 {record.correct} / {record.total} · {record.passed ? "本周掌握良好 🎉" : "看看错题本,下周再战"}
          </p>
+          {record.passed && awarded > 0 && <p className="mt-1 text-base font-extrabold">🪙 +{awarded} 积分</p>}
        </div>
      ) : (
        <QuizBlock
@@ -10,6 +10,7 @@ import { SUBJECT_VALUES } from "@/db/schema";
 import { todayStr } from "@/lib/dates";
 import { ensureDay } from "@/lib/tasks";
 import { getSessionUser } from "@/lib/auth";
+import { DEFAULT_RULE_POINTS, upsertPointRule } from "@/lib/points";

 function hashCode(code: string) {
  return crypto.createHash("sha256").update(code).digest("hex");
@@ -84,6 +85,8 @@ const templateSchema = z.object({
  dateEnd: z.string().nullish(),
  title: z.string().trim().min(1, "任务内容不能为空").max(100, "最多 100 字"),
  requiresPhoto: z.boolean(),
+  // xuchao: 该任务完成可得积分,0~9999
+  points: z.coerce.number().int().min(0).max(9999).catch(10),
 });

 async function requireOwnerOfChild(childId: number) {
@@ -109,6 +112,7 @@ export async function addTemplate(formData: FormData) {
    dateEnd: formData.get("dateEnd") || null,
    title: formData.get("title"),
    requiresPhoto: formData.get("requiresPhoto") === "on",
+    points: formData.get("points") || 10,
  });
  if (!parsed.success) throw new Error(parsed.error.issues[0].message);
  await requireOwnerOfChild(parsed.data.childId);
@@ -127,12 +131,51 @@ export async function addTemplate(formData: FormData) {
    dateEnd: parsed.data.dateEnd || null,
    title: parsed.data.title,
    requiresPhoto: parsed.data.requiresPhoto,
+    points: parsed.data.points,
    sortOrder: maxRow.maxSort + 1,
  });
  await ensureDay(parsed.data.childId, todayStr());
  revalidatePath("/parent");
 }

+// xuchao: 修改模板任务分值;当天未完成的快照同步更新,设置立即生效
+export async function updateTemplatePoints(templateId: number, points: number) {
+  const parent = await getSessionUser();
+  if (!parent || parent.role !== "parent") throw new Error("请先以家长身份登录");
+  const p = Math.max(0, Math.min(9999, Math.round(points)));
+  const [row] = await db
+    .select({ id: taskTemplates.id, childUserId: taskTemplates.childUserId })
+    .from(taskTemplates)
+    .innerJoin(users, eq(users.id, taskTemplates.childUserId))
+    .where(and(eq(taskTemplates.id, templateId), eq(users.familyId, parent.familyId)))
+    .limit(1);
+  if (!row) throw new Error("任务不存在");
+  await db.update(taskTemplates).set({ points: p }).where(eq(taskTemplates.id, templateId));
+  await db
+    .update(taskInstances)
+    .set({ points: p })
+    .where(
+      and(
+        eq(taskInstances.sourceTemplateId, templateId),
+        eq(taskInstances.date, todayStr()),
+        eq(taskInstances.status, "pending"),
+      ),
+    );
+  revalidatePath("/parent");
+  revalidatePath("/kid");
+}
+
+// xuchao: 保存测试类积分规则(只接受已知事件,分值 0~9999)
+export async function savePointRules(values: { eventType: string; points: number }[]) {
+  const parent = await getSessionUser();
+  if (!parent || parent.role !== "parent") throw new Error("请先以家长身份登录");
+  for (const v of values) {
+    if (!(v.eventType in DEFAULT_RULE_POINTS)) continue;
+    await upsertPointRule(v.eventType, Math.max(0, Math.min(9999, Math.round(v.points))));
+  }
+  revalidatePath("/parent");
+}
+
 // 删除模板任务:删除后立即对账当天,孩子端未完成的对应任务会同步移除
 export async function deleteTemplate(templateId: number) {
  const parent = await getSessionUser();
@@ -8,8 +8,8 @@ import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
 import { ChildManage } from "./child-manage";
 import { DevicesTab } from "./devices-tab";
 import { OverviewTab } from "./overview-tab";
+import { PointsManage } from "./points-manage";
 import { TemplatesTab } from "./templates-tab";
-import { PlayBtn } from "@/components/play-audio";

 export type DayCell = {
  done: number;
@@ -40,12 +40,23 @@ export type TemplatesData = {
      title: string;
      subject: string;
      requiresPhoto: boolean;
+      points: number;
      mode: string;
      dateStart: string | null;
      dateEnd: string | null;
    }[];
  }[];
 };
+// xuchao: 积分管理数据——测试类规则 + 每个孩子总积分/最近流水
+export type PointsData = {
+  rules: { eventType: string; label: string; points: number }[];
+  kids: {
+    id: number;
+    name: string;
+    total: number;
+    recent: { id: number; label: string; remark: string; points: number; date: string }[];
+  }[];
+};
 export type DevicesData = {
  rows: {
    id: number;
@@ -57,16 +68,6 @@ export type DevicesData = {
  }[];
 };
 export type WeeklyRow = { childName: string; weekKey: string; score: number; passed: boolean };
-export type RecordingRow = { childName: string; word: string; url: string; at: string };
-export type GrammarTestRow = { childName: string; title: string; score: number; passed: boolean; at: string };
-export type WrongItemRow = {
-  childName: string;
-  stem: string;
-  userAnswer: string;
-  correctAnswer: string;
-  sourceTitle: string;
-  mastered: boolean;
-};

 const tabCls = "data-[state=active]:bg-white data-[state=active]:text-indigo-600 data-[state=active]:shadow-soft";

@@ -85,17 +86,13 @@ export function ParentDashboard({
  templates,
  devices,
  weekly,
-  recordings,
-  grammarTests,
-  wrongItems,
+  points,
 }: {
  overview: OverviewData;
  templates: TemplatesData;
  devices: DevicesData;
  weekly: WeeklyRow[];
-  recordings: RecordingRow[];
-  grammarTests: GrammarTestRow[];
-  wrongItems: WrongItemRow[];
+  points: PointsData;
 }) {
  return (
    <main className="relative mx-auto max-w-3xl space-y-5 p-4 pb-10">
@@ -130,7 +127,11 @@ export function ParentDashboard({
            <TemplatesTab data={templates} />
          </Section>

-          <Section title="课程管理" desc="英语语法课程编辑与每周检测成绩">
+          <Section title="积分管理" desc="打卡分值在任务管理里按任务设置;测试类达标分值在下面调整,孩子首次达标才计分">
+            <PointsManage data={points} />
+          </Section>
+
+          <Section title="课程管理" desc="英语语法/单词、数学思维课程编辑与每周检测成绩">
            <div className="grid grid-cols-1 gap-3 sm:grid-cols-2">
              <Link href="/parent/grammar" className="block">
                <div className="rounded-xl border border-slate-100 bg-white p-4 shadow-soft transition-transform duration-200 hover:-translate-y-0.5">
@@ -138,6 +139,18 @@ export function ParentDashboard({
                  <p className="mt-1 text-xs text-muted-foreground">改标题/目标/课文,保存即生效</p>
                </div>
              </Link>
+              <Link href="/parent/words" className="block">
+                <div className="rounded-xl border border-slate-100 bg-white p-4 shadow-soft transition-transform duration-200 hover:-translate-y-0.5">
+                  <p className="font-bold text-slate-900">📖 编辑英语单词</p>
+                  <p className="mt-1 text-xs text-muted-foreground">按天增删改单词与释义,保存即生效</p>
+                </div>
+              </Link>
+              <Link href="/parent/math" className="block">
+                <div className="rounded-xl border border-slate-100 bg-white p-4 shadow-soft transition-transform duration-200 hover:-translate-y-0.5">
+                  <p className="font-bold text-slate-900">🧮 编辑数学思维课程</p>
+                  <p className="mt-1 text-xs text-muted-foreground">改标题/目标/课文,保存即生效</p>
+                </div>
+              </Link>
              <div className="rounded-xl border border-slate-100 bg-white p-4 shadow-soft">
                <p className="font-bold text-slate-900">📝 每周检测成绩</p>
                <div className="mt-2 space-y-1">
@@ -149,45 +162,6 @@ export function ParentDashboard({
                  ))}
                </div>
              </div>
-              <div className="rounded-xl border border-slate-100 bg-white p-4 shadow-soft sm:col-span-2">
-                <p className="font-bold text-slate-900">🎙️ 单词跟读录音</p>
-                <div className="mt-2 flex flex-wrap gap-2">
-                  {recordings.length === 0 && <p className="text-xs text-muted-foreground">暂无跟读录音</p>}
-                  {recordings.map((r, i) => (
-                    <div key={i} className="flex items-center gap-1.5 rounded-full bg-slate-50 px-2.5 py-1 text-sm ring-1 ring-slate-100">
-                      <span className="text-xs text-muted-foreground">{r.childName}</span>
-                      <span className="font-medium text-slate-800">{r.word}</span>
-                      <PlayBtn src={r.url} className="size-6" />
-                    </div>
-                  ))}
-                </div>
-              </div>
-              <div className="rounded-xl border border-slate-100 bg-white p-4 shadow-soft">
-                <p className="font-bold text-slate-900">📘 英语语法检测</p>
-                <div className="mt-2 space-y-1">
-                  {grammarTests.length === 0 && <p className="text-xs text-muted-foreground">暂无检测记录</p>}
-                  {grammarTests.map((g, i) => (
-                    <p key={i} className="truncate text-xs text-slate-600">
-                      {g.childName} · {g.title} · {g.score} 分 {g.passed ? "✅" : "❌"}
-                    </p>
-                  ))}
-                </div>
-              </div>
-              <div className="rounded-xl border border-slate-100 bg-white p-4 shadow-soft">
-                <p className="font-bold text-slate-900">📒 孩子错题本</p>
-                <div className="mt-2 space-y-2">
-                  {wrongItems.length === 0 && <p className="text-xs text-muted-foreground">暂无错题</p>}
-                  {wrongItems.map((w, i) => (
-                    <div key={i} className="rounded-lg bg-slate-50 p-2 text-xs">
-                      <p className="font-medium text-slate-800">
-                        {w.childName} · {w.stem}
-                      </p>
-                      <p className="mt-0.5 text-rose-600">答:{w.userAnswer || "未作答"}</p>
-                      <p className="text-emerald-700">正:{w.correctAnswer}</p>
-                    </div>
-                  ))}
-                </div>
-              </div>
            </div>
          </Section>

@@ -0,0 +1,42 @@
+import Link from "next/link";
+import { redirect } from "next/navigation";
+import { BackgroundBlobs } from "@/components/background-blobs";
+import { Badge } from "@/components/ui/badge";
+import { getSessionUser } from "@/lib/auth";
+import { getMathPoint } from "@/lib/math";
+import { EditorForm } from "../editor-form";
+
+// xuchao: 单个数学知识点编辑页
+export default async function MathEditPage({ params }: { params: Promise<{ pointId: string }> }) {
+  const parent = await getSessionUser();
+  if (!parent) redirect("/login");
+  if (parent.role !== "parent") redirect("/kid");
+
+  const pointId = (await params).pointId;
+  const point = await getMathPoint(pointId);
+  if (!point) redirect("/parent/math");
+
+  return (
+    <main className="relative mx-auto max-w-3xl space-y-5 p-4 pb-10">
+      <BackgroundBlobs />
+      <header className="flex flex-wrap items-center justify-between gap-2">
+        <Link href="/parent/math" className="text-sm font-medium text-indigo-600">
+          ← 课程列表
+        </Link>
+        <div className="flex items-center gap-2">
+          <Badge className="bg-indigo-100 text-indigo-700 hover:bg-indigo-100">{point.moduleName}</Badge>
+          <h1 className="text-lg font-extrabold text-slate-900">{point.title}</h1>
+        </div>
+      </header>
+
+      <div className="rounded-2xl border border-slate-100 bg-white p-5 shadow-soft">
+        <EditorForm
+          pointId={point.pointId}
+          initialTitle={point.title}
+          initialSummary={point.summary}
+          initialMd={point.md}
+        />
+      </div>
+    </main>
+  );
+}
@@ -0,0 +1,34 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { eq } from "drizzle-orm";
+import { db } from "@/db";
+import { mathPoints } from "@/db/schema";
+import { getSessionUser } from "@/lib/auth";
+
+// xuchao: 家长编辑数学知识点(标题/摘要/课文 markdown)
+export async function updateMathPoint(
+  pointId: string,
+  data: { title: string; summary: string; md: string },
+): Promise<{ ok?: true; error?: string }> {
+  const parent = await getSessionUser();
+  if (!parent || parent.role !== "parent") return { error: "请先以家长身份登录" };
+  if (!data.title.trim()) return { error: "标题不能为空" };
+  if (!data.md.trim()) return { error: "课文内容不能为空" };
+
+  await db
+    .update(mathPoints)
+    .set({
+      title: data.title.trim(),
+      summary: data.summary,
+      md: data.md,
+      updatedAt: new Date(),
+    })
+    .where(eq(mathPoints.pointId, pointId));
+
+  revalidatePath("/math");
+  revalidatePath(`/math/${pointId}`);
+  revalidatePath("/parent/math");
+  revalidatePath(`/parent/math/${pointId}`);
+  return { ok: true };
+}
@@ -0,0 +1,92 @@
+"use client";
+
+import { useState, useTransition } from "react";
+import { Eye, EyeOff, Save } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Md } from "@/app/learn/md";
+import { extractQuiz } from "@/lib/quiz-parse";
+import { updateMathPoint } from "./actions";
+
+// xuchao: 数学课程编辑器——结构同语法编辑器:改标题/摘要/课文 markdown,可预览,保存即生效
+export function EditorForm({
+  pointId,
+  initialTitle,
+  initialSummary,
+  initialMd,
+}: {
+  pointId: string;
+  initialTitle: string;
+  initialSummary: string | null;
+  initialMd: string;
+}) {
+  const [title, setTitle] = useState(initialTitle);
+  const [summary, setSummary] = useState(initialSummary ?? "");
+  const [md, setMd] = useState(initialMd);
+  const [preview, setPreview] = useState(false);
+  const [msg, setMsg] = useState<{ ok?: boolean; text: string } | null>(null);
+  const [pending, startTransition] = useTransition();
+
+  const quizCount = extractQuiz(md).length;
+
+  const save = () => {
+    setMsg(null);
+    startTransition(async () => {
+      const r = await updateMathPoint(pointId, { title, summary, md });
+      if (r.error) setMsg({ text: r.error });
+      else setMsg({ ok: true, text: "已保存,孩子端立即生效" });
+    });
+  };
+
+  return (
+    <div className="space-y-4">
+      <div className="grid gap-3 sm:grid-cols-2">
+        <div className="space-y-1">
+          <Label>标题</Label>
+          <Input value={title} onChange={(e) => setTitle(e.target.value)} />
+        </div>
+        <div className="space-y-1">
+          <Label>学习目标(一句话)</Label>
+          <Input value={summary} onChange={(e) => setSummary(e.target.value)} />
+        </div>
+      </div>
+
+      <div className="space-y-1">
+        <div className="flex items-center justify-between">
+          <Label>课文内容(Markdown,含 ```quiz 练习块)</Label>
+          <div className="flex items-center gap-2 text-xs text-muted-foreground">
+            <span>检测到练习题 {quizCount} 道</span>
+            <Button variant="outline" size="sm" type="button" onClick={() => setPreview((p) => !p)}>
+              {preview ? <EyeOff className="size-4" /> : <Eye className="size-4" />}
+              {preview ? "编辑" : "预览"}
+            </Button>
+          </div>
+        </div>
+        {preview ? (
+          <div className="max-h-[480px] overflow-y-auto rounded-xl border border-slate-100 bg-white p-4">
+            <Md text={md} />
+          </div>
+        ) : (
+          <textarea
+            value={md}
+            onChange={(e) => setMd(e.target.value)}
+            rows={18}
+            className="w-full rounded-lg border border-slate-200 bg-white p-3 font-mono text-xs leading-relaxed focus:border-indigo-500 focus:ring-2 focus:ring-indigo-200"
+          />
+        )}
+      </div>
+
+      <div className="flex items-center gap-3">
+        <Button size="lg" disabled={pending} onClick={save}>
+          <Save className="size-4" /> 保存
+        </Button>
+        {msg && (
+          <p className={msg.ok ? "text-sm font-medium text-emerald-600" : "text-sm font-medium text-destructive"}>
+            {msg.text}
+          </p>
+        )}
+      </div>
+    </div>
+  );
+}
@@ -0,0 +1,55 @@
+import Link from "next/link";
+import { Pencil } from "lucide-react";
+import { redirect } from "next/navigation";
+import { BackgroundBlobs } from "@/components/background-blobs";
+import { getSessionUser } from "@/lib/auth";
+import { listMathPoints, MODULES } from "@/lib/math";
+
+// xuchao: 数学思维课程编辑列表——按七大模块分组,点击进入单课编辑
+export default async function MathAdmin() {
+  const parent = await getSessionUser();
+  if (!parent) redirect("/login");
+  if (parent.role !== "parent") redirect("/kid");
+
+  const points = await listMathPoints();
+
+  return (
+    <main className="relative mx-auto max-w-2xl space-y-5 p-4 pb-10">
+      <BackgroundBlobs />
+      <header className="flex items-center justify-between">
+        <Link href="/parent" className="text-sm font-medium text-indigo-600">
+          ← 返回家长中心
+        </Link>
+        <h1 className="text-xl font-extrabold text-slate-900">数学思维课程编辑</h1>
+      </header>
+      <p className="rounded-lg border-l-4 border-indigo-400 bg-indigo-50 px-3 py-2 text-sm text-indigo-800">
+        点击任意课程即可修改标题、目标与课文内容,保存后孩子端立即生效。
+      </p>
+
+      {MODULES.map((mod) => {
+        const group = points.filter((p) => p.module === mod.id);
+        if (group.length === 0) return null;
+        return (
+          <section key={mod.id} className="rounded-xl border border-slate-100 bg-white p-4 shadow-soft">
+            <h2 className="mb-3 text-lg font-extrabold text-slate-900">
+              {mod.name}
+              <span className="ml-1 text-amber-500">{"★".repeat(mod.stars)}</span>
+            </h2>
+            <div className="grid grid-cols-1 gap-2 sm:grid-cols-2">
+              {group.map((p) => (
+                <Link
+                  key={p.pointId}
+                  href={`/parent/math/${p.pointId}`}
+                  className="flex items-center gap-2 rounded-lg border border-slate-200 bg-white px-3 py-2 text-sm text-slate-700 transition-all duration-200 hover:-translate-y-0.5 hover:border-indigo-300"
+                >
+                  <Pencil className="size-3.5 shrink-0 text-indigo-400" />
+                  <span className="truncate">{p.title}</span>
+                </Link>
+              ))}
+            </div>
+          </section>
+        );
+      })}
+    </main>
+  );
+}
@@ -17,11 +17,18 @@ import {
 import { SESSION_COOKIE, getSessionUser } from "@/lib/auth";
 import { addDays, dowOf, todayStr } from "@/lib/dates";
 import { passedCount, totalPoints } from "@/lib/grammar";
+import {
+  POINT_EVENT_LABELS,
+  listPointRules,
+  pointHistory,
+  totalPoints as childPointsTotal,
+} from "@/lib/points";
 import { viewUrl } from "@/lib/oss";
 import {
  ParentDashboard,
  type DevicesData,
  type OverviewData,
+  type PointsData,
  type TemplatesData,
  type WeeklyRow,
 } from "./dashboard";
@@ -136,6 +143,7 @@ export default async function ParentPage() {
          title: t.title,
          subject: t.subject,
          requiresPhoto: t.requiresPhoto,
+          points: t.points,
          mode: t.mode,
          dateStart: t.dateStart,
          dateEnd: t.dateEnd,
@@ -191,80 +199,25 @@ export default async function ParentPage() {
    passed: w.passed,
  }));

-  // ===== 单词跟读录音(课程管理回放) =====
-  const recRows = await db
-    .select({
-      childName: users.displayName,
-      word: wordRecording.word,
-      ossKey: wordRecording.ossKey,
-      createdAt: wordRecording.createdAt,
-    })
-    .from(wordRecording)
-    .innerJoin(users, eq(users.id, wordRecording.childUserId))
-    .where(eq(users.familyId, parent.familyId))
-    .orderBy(desc(wordRecording.createdAt))
-    .limit(20);
-  const recordings = recRows.map((r) => ({
-    childName: r.childName,
-    word: r.word,
-    url: viewUrl(r.ossKey),
-    at: dstr(r.createdAt),
-  }));
-
-  // ===== 英语语法检测明细 =====
-  const grammarRows = await db
-    .select({
-      childName: users.displayName,
-      title: grammarPoints.title,
-      score: grammarProgress.score,
-      passed: grammarProgress.passed,
-      completedAt: grammarProgress.completedAt,
-    })
-    .from(grammarProgress)
-    .innerJoin(users, eq(users.id, grammarProgress.childUserId))
-    .innerJoin(grammarPoints, eq(grammarPoints.pointId, grammarProgress.pointId))
-    .where(eq(users.familyId, parent.familyId))
-    .orderBy(desc(grammarProgress.completedAt))
-    .limit(20);
-  const grammarTests = grammarRows.map((g) => ({
-    childName: g.childName,
-    title: g.title,
-    score: g.score ?? 0,
-    passed: g.passed,
-    at: g.completedAt ? dstr(g.completedAt) : "",
-  }));
-
-  // ===== 孩子错题数据 =====
-  const wrongRows = await db
-    .select({
-      childName: users.displayName,
-      question: wrongBook.question,
-      userAnswer: wrongBook.userAnswer,
-      correctAnswer: wrongBook.correctAnswer,
-      sourceTitle: wrongBook.sourceTitle,
-      mastered: wrongBook.mastered,
-    })
-    .from(wrongBook)
-    .innerJoin(users, eq(users.id, wrongBook.childUserId))
-    .where(eq(users.familyId, parent.familyId))
-    .orderBy(desc(wrongBook.createdAt))
-    .limit(30);
-  const wrongItems = wrongRows.map((w) => {
-    let stem = "";
-    try {
-      stem = (JSON.parse(w.question) as { stem?: string }).stem ?? "";
-    } catch {
-      stem = "";
-    }
-    return {
-      childName: w.childName,
-      stem,
-      userAnswer: w.userAnswer ?? "",
-      correctAnswer: w.correctAnswer ?? "",
-      sourceTitle: w.sourceTitle ?? "",
-      mastered: w.mastered,
-    };
-  });
+  // ===== 积分管理(规则 + 每孩子总积分/最近流水) =====
+  const rules = await listPointRules();
+  const pointsData: PointsData = { rules, kids: [] };
+  const eventLabel = (t: string) => (t === "checkin" ? "打卡" : POINT_EVENT_LABELS[t] ?? t);
+  for (const kid of kids) {
+    const [total, recent] = await Promise.all([childPointsTotal(kid.id), pointHistory(kid.id, 5)]);
+    pointsData.kids.push({
+      id: kid.id,
+      name: kid.name,
+      total,
+      recent: recent.map((r) => ({
+        id: r.id,
+        label: eventLabel(r.eventType),
+        remark: r.remark,
+        points: r.points,
+        date: r.createdAt.toLocaleDateString("zh-CN", SH),
+      })),
+    });
+  }

  return (
    <ParentDashboard
@@ -272,9 +225,7 @@ export default async function ParentPage() {
      templates={templates}
      devices={devices}
      weekly={weekly}
-      recordings={recordings}
-      grammarTests={grammarTests}
-      wrongItems={wrongItems}
+      points={pointsData}
    />
  );
 }
@@ -0,0 +1,90 @@
+"use client";
+
+// xuchao: 积分管理——测试类规则分值配置 + 每个孩子总积分/最近流水
+import { useState, useTransition } from "react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { savePointRules } from "./actions";
+import type { PointsData } from "./dashboard";
+
+export function PointsManage({ data }: { data: PointsData }) {
+  const [values, setValues] = useState<Record<string, number>>(
+    Object.fromEntries(data.rules.map((r) => [r.eventType, r.points])),
+  );
+  const [saved, setSaved] = useState(false);
+  const [error, setError] = useState("");
+  const [pending, startTransition] = useTransition();
+
+  const save = () => {
+    setError("");
+    setSaved(false);
+    startTransition(async () => {
+      try {
+        await savePointRules(Object.entries(values).map(([eventType, points]) => ({ eventType, points })));
+        setSaved(true);
+      } catch (e) {
+        setError(e instanceof Error ? e.message : "保存失败");
+      }
+    });
+  };
+
+  return (
+    <div className="space-y-4">
+      <div className="rounded-xl border border-slate-100 bg-slate-50/60 p-3">
+        <h4 className="text-sm font-bold text-slate-900">测试类达标分值</h4>
+        <div className="mt-2 grid grid-cols-1 gap-2 sm:grid-cols-2">
+          {data.rules.map((r) => (
+            <label key={r.eventType} className="flex items-center gap-2 text-sm text-slate-700">
+              <span className="flex-1">{r.label}</span>
+              <Input
+                type="number"
+                min={0}
+                max={9999}
+                value={values[r.eventType]}
+                onChange={(e) => {
+                  setValues((v) => ({ ...v, [r.eventType]: Number(e.target.value) }));
+                  setSaved(false);
+                }}
+                className="h-8 w-20 text-right"
+              />
+              <span className="text-xs text-muted-foreground">分</span>
+            </label>
+          ))}
+        </div>
+        <div className="mt-3 flex items-center gap-2">
+          <Button size="sm" disabled={pending} onClick={save}>
+            保存分值
+          </Button>
+          {saved && <span className="text-xs font-medium text-emerald-600">已保存,下次达标生效</span>}
+          {error && <span className="text-xs font-medium text-destructive">{error}</span>}
+        </div>
+      </div>
+
+      <div className="space-y-3">
+        {data.kids.length === 0 && <p className="text-sm text-muted-foreground">还没有孩子,先去孩子管理添加。</p>}
+        {data.kids.map((k) => (
+          <div key={k.id} className="rounded-xl border border-slate-100 bg-white p-3">
+            <div className="flex items-center justify-between">
+              <span className="font-bold text-slate-900">{k.name}</span>
+              <span className="text-sm font-extrabold text-amber-600">🪙 {k.total} 积分</span>
+            </div>
+            {k.recent.length === 0 ? (
+              <p className="mt-1.5 text-xs text-muted-foreground">暂无积分记录</p>
+            ) : (
+              <div className="mt-1.5 space-y-1">
+                {k.recent.map((r) => (
+                  <p key={r.id} className="flex items-center gap-2 text-xs text-slate-600">
+                    <span className="flex-1 truncate">
+                      {r.label} · {r.remark} · {r.date}
+                    </span>
+                    <span className="shrink-0 font-bold text-amber-600">+{r.points}</span>
+                  </p>
+                ))}
+              </div>
+            )}
+          </div>
+        ))}
+      </div>
+    </div>
+  );
+}
@@ -9,7 +9,7 @@ import { Label } from "@/components/ui/label";
 import { cn } from "@/lib/utils";
 import { addDays, dowOf, mondayOf, todayStr } from "@/lib/dates";
 import { SUBJECTS, type Subject, subjectMeta } from "@/lib/subjects";
-import { addTemplate, deleteTemplate } from "./actions";
+import { addTemplate, deleteTemplate, updateTemplatePoints } from "./actions";
 import type { TemplatesData } from "./dashboard";

 type Item = TemplatesData["kids"][number]["items"][number];
@@ -31,6 +31,7 @@ export function TemplatesTab({ data }: { data: TemplatesData }) {
  const [subject, setSubject] = useState<Subject>("other");
  const [title, setTitle] = useState("");
  const [photo, setPhoto] = useState(false);
+  const [points, setPoints] = useState(10);
  const [rangeStart, setRangeStart] = useState(todayStr());
  const [rangeEnd, setRangeEnd] = useState(addDays(todayStr(), 6));
  const [error, setError] = useState("");
@@ -59,11 +60,13 @@ export function TemplatesTab({ data }: { data: TemplatesData }) {
      fd.set("dateEnd", rangeEnd);
    }
    if (photo) fd.set("requiresPhoto", "on");
+    fd.set("points", String(points));
    startTransition(async () => {
      try {
        await addTemplate(fd);
        setTitle("");
        setPhoto(false);
+        setPoints(10);
      } catch (err) {
        setError(err instanceof Error ? err.message : "添加失败");
      }
@@ -136,10 +139,27 @@ export function TemplatesTab({ data }: { data: TemplatesData }) {
                <span className="font-medium">{sm.label}</span>
                <span className="text-slate-600">{t.title}</span>
                <span className="text-xs text-muted-foreground">({modeLabel[t.mode] ?? t.mode})</span>
+                <span className="ml-auto flex items-center gap-1 text-xs text-amber-600" title="完成该任务可得的积分,改后当天未完成任务立即生效">
+                  🪙
+                  <input
+                    type="number"
+                    min={0}
+                    max={9999}
+                    defaultValue={t.points}
+                    aria-label={`${t.title} 积分`}
+                    onBlur={(e) => {
+                      const v = Number(e.target.value);
+                      if (Number.isFinite(v) && Math.round(v) !== t.points)
+                        startTransition(() => updateTemplatePoints(t.id, Math.round(v)));
+                    }}
+                    className="h-6 w-12 rounded-md border border-amber-200 bg-white px-1 text-right"
+                  />
+                  分
+                </span>
                <button
                  type="button"
                  aria-label={`删除 ${t.title}`}
-                  className="ml-auto text-muted-foreground hover:text-destructive"
+                  className="text-muted-foreground hover:text-destructive"
                  onClick={() => startTransition(() => deleteTemplate(t.id))}
                >
                  <Trash2 className="size-3.5" />
@@ -192,6 +212,18 @@ export function TemplatesTab({ data }: { data: TemplatesData }) {
              <Checkbox id="tpl-photo" checked={photo} onCheckedChange={(v) => setPhoto(v === true)} />
              <Label htmlFor="tpl-photo">需拍照</Label>
            </div>
+            <div className="space-y-1">
+              <Label>积分</Label>
+              <Input
+                type="number"
+                min={0}
+                max={9999}
+                value={points}
+                onChange={(e) => setPoints(Number(e.target.value))}
+                className="h-9 w-20 text-right"
+                title="完成该任务可得的积分"
+              />
+            </div>
            <Button type="submit" disabled={pending || title.trim() === ""}>
              添加
            </Button>
@@ -0,0 +1,33 @@
+import Link from "next/link";
+import { redirect } from "next/navigation";
+import { BackgroundBlobs } from "@/components/background-blobs";
+import { getSessionUser } from "@/lib/auth";
+import { wordsByDay } from "@/lib/words";
+import { DayForm } from "../day-form";
+
+// xuchao: 某一天的单词编辑页
+export default async function WordsDayAdmin({ params }: { params: Promise<{ day: string }> }) {
+  const parent = await getSessionUser();
+  if (!parent) redirect("/login");
+  if (parent.role !== "parent") redirect("/kid");
+
+  const day = Number((await params).day);
+  if (!Number.isInteger(day) || day < 1) redirect("/parent/words");
+  const words = await wordsByDay(day);
+
+  return (
+    <main className="relative mx-auto max-w-2xl space-y-5 p-4 pb-10">
+      <BackgroundBlobs />
+      <header className="flex items-center justify-between">
+        <Link href="/parent/words" className="text-sm font-medium text-indigo-600">
+          ← 天数列表
+        </Link>
+        <h1 className="text-xl font-extrabold text-slate-900">第 {day} 天单词</h1>
+      </header>
+
+      <div className="rounded-2xl border border-slate-100 bg-white p-5 shadow-soft">
+        <DayForm day={day} initial={words.map((w) => ({ word: w.word, meaning: w.meaning }))} />
+      </div>
+    </main>
+  );
+}
@@ -0,0 +1,53 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { eq, sql } from "drizzle-orm";
+import raw from "@/content/words/words.json";
+import { db } from "@/db";
+import { wordEntry } from "@/db/schema";
+import { getSessionUser } from "@/lib/auth";
+
+// xuchao: 整日保存单词——事务内删旧插新;保留词沿用原 seq,新词接续全库最大 seq
+export async function saveDayWords(
+  day: number,
+  words: { word: string; meaning: string }[],
+): Promise<{ ok?: true; error?: string }> {
+  const parent = await getSessionUser();
+  if (!parent || parent.role !== "parent") return { error: "请先以家长身份登录" };
+  if (!Number.isInteger(day) || day < 1) return { error: "天数无效" };
+  const cleaned = words
+    .map((w) => ({ word: w.word.trim(), meaning: w.meaning.trim() }))
+    .filter((w) => w.word);
+  if (cleaned.length === 0) return { error: "至少保留一个单词" };
+  if (new Set(cleaned.map((w) => w.word.toLowerCase())).size !== cleaned.length)
+    return { error: "同一天内单词不能重复" };
+
+  await db.transaction(async (tx) => {
+    // 首次编辑(表还没灌种子):先全量灌入打包词库,否则只存一天会丢失其余天
+    const [cnt] = await tx.select({ n: sql<number>`COUNT(*)` }).from(wordEntry);
+    if (cnt.n === 0) {
+      const rows = raw as { word: string; meaning: string; day: number; seq: number }[];
+      for (let i = 0; i < rows.length; i += 500) await tx.insert(wordEntry).values(rows.slice(i, i + 500));
+    }
+
+    const oldRows = await tx.select().from(wordEntry).where(eq(wordEntry.day, day));
+    const seqByWord = new Map(oldRows.map((r) => [r.word, r.seq]));
+    await tx.delete(wordEntry).where(eq(wordEntry.day, day));
+    const [mx] = await tx.select({ m: sql<number>`COALESCE(MAX(seq),0)` }).from(wordEntry);
+    let seq = mx.m;
+
+    await tx.insert(wordEntry).values(
+      cleaned.map((w) => ({
+        word: w.word,
+        meaning: w.meaning,
+        day,
+        seq: seqByWord.get(w.word) ?? ++seq,
+      })),
+    );
+  });
+
+  revalidatePath("/words");
+  revalidatePath(`/words/${day}`);
+  revalidatePath("/parent/words");
+  return { ok: true };
+}
@@ -0,0 +1,84 @@
+"use client";
+
+import { useState, useTransition } from "react";
+import { Plus, Save, X } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { saveDayWords } from "./actions";
+
+// xuchao: 按天编辑单词——逐词行编辑,可增删行,整日保存
+export function DayForm({
+  day,
+  initial,
+}: {
+  day: number;
+  initial: { word: string; meaning: string }[];
+}) {
+  const [rows, setRows] = useState(initial);
+  const [msg, setMsg] = useState<{ ok?: boolean; text: string } | null>(null);
+  const [pending, startTransition] = useTransition();
+
+  const set = (i: number, key: "word" | "meaning", v: string) => {
+    setRows((rs) => rs.map((r, j) => (j === i ? { ...r, [key]: v } : r)));
+    setMsg(null);
+  };
+
+  const save = () => {
+    setMsg(null);
+    startTransition(async () => {
+      const r = await saveDayWords(day, rows);
+      if (r.error) setMsg({ text: r.error });
+      else setMsg({ ok: true, text: "已保存,孩子端立即生效" });
+    });
+  };
+
+  return (
+    <div className="space-y-4">
+      <div className="space-y-2">
+        {rows.map((r, i) => (
+          <div key={i} className="flex items-center gap-2">
+            <Input
+              value={r.word}
+              onChange={(e) => set(i, "word", e.target.value)}
+              placeholder="单词"
+              className="w-36 shrink-0 font-medium"
+            />
+            <Input value={r.meaning} onChange={(e) => set(i, "meaning", e.target.value)} placeholder="中文释义" />
+            <button
+              type="button"
+              aria-label="删除该词"
+              onClick={() => {
+                setRows((rs) => rs.filter((_, j) => j !== i));
+                setMsg(null);
+              }}
+              className="shrink-0 rounded-md p-1.5 text-slate-400 transition-colors hover:bg-red-50 hover:text-red-500"
+            >
+              <X className="size-4" />
+            </button>
+          </div>
+        ))}
+      </div>
+
+      <div className="flex flex-wrap items-center gap-3">
+        <Button
+          variant="outline"
+          type="button"
+          onClick={() => {
+            setRows((rs) => [...rs, { word: "", meaning: "" }]);
+            setMsg(null);
+          }}
+        >
+          <Plus className="size-4" /> 添加单词
+        </Button>
+        <Button size="lg" disabled={pending} onClick={save}>
+          <Save className="size-4" /> 保存第 {day} 天
+        </Button>
+        {msg && (
+          <p className={msg.ok ? "text-sm font-medium text-emerald-600" : "text-sm font-medium text-destructive"}>
+            {msg.text}
+          </p>
+        )}
+      </div>
+    </div>
+  );
+}
@@ -0,0 +1,47 @@
+import Link from "next/link";
+import { redirect } from "next/navigation";
+import { BackgroundBlobs } from "@/components/background-blobs";
+import { getSessionUser } from "@/lib/auth";
+import { allWords } from "@/lib/words";
+
+// xuchao: 单词词库编辑列表——按天网格,格内显示当天词数,点击进入当天编辑
+export default async function WordsAdmin() {
+  const parent = await getSessionUser();
+  if (!parent) redirect("/login");
+  if (parent.role !== "parent") redirect("/kid");
+
+  const ws = await allWords();
+  const counts = new Map<number, number>();
+  let totalDays = 0;
+  for (const w of ws) {
+    counts.set(w.day, (counts.get(w.day) ?? 0) + 1);
+    totalDays = Math.max(totalDays, w.day);
+  }
+
+  return (
+    <main className="relative mx-auto max-w-2xl space-y-5 p-4 pb-10">
+      <BackgroundBlobs />
+      <header className="flex items-center justify-between">
+        <Link href="/parent" className="text-sm font-medium text-indigo-600">
+          ← 返回家长中心
+        </Link>
+        <h1 className="text-xl font-extrabold text-slate-900">英语单词编辑</h1>
+      </header>
+      <p className="rounded-lg border-l-4 border-indigo-400 bg-indigo-50 px-3 py-2 text-sm text-indigo-800">
+        共 {ws.length} 词 / {totalDays} 天。点击某一天可增删改当天单词,保存后孩子端立即生效。
+      </p>
+      <div className="grid grid-cols-4 gap-1.5 sm:grid-cols-7">
+        {Array.from({ length: totalDays }, (_, i) => i + 1).map((d) => (
+          <Link
+            key={d}
+            href={`/parent/words/${d}`}
+            className="flex flex-col items-center justify-center rounded-lg border border-slate-200 bg-white py-2 text-sm transition-all duration-200 hover:-translate-y-0.5 hover:border-indigo-300"
+          >
+            <span className="font-bold text-slate-800">第{d}天</span>
+            <span className="text-xs text-muted-foreground">{counts.get(d) ?? 0} 词</span>
+          </Link>
+        ))}
+      </div>
+    </main>
+  );
+}
@@ -0,0 +1,59 @@
+// xuchao: 孩子积分页——总积分 + 流水明细(只增不减)
+import Link from "next/link";
+import { redirect } from "next/navigation";
+import { BackgroundBlobs } from "@/components/background-blobs";
+import { getSessionUser } from "@/lib/auth";
+import { pointHistory, totalPoints, POINT_EVENT_LABELS } from "@/lib/points";
+
+const SH = { timeZone: "Asia/Shanghai" } as const;
+
+// checkin 的分值在任务上,不属测试类规则,单独给个名字
+const eventLabel = (eventType: string) =>
+  eventType === "checkin" ? "打卡" : POINT_EVENT_LABELS[eventType] ?? eventType;
+
+export default async function PointsPage() {
+  const user = await getSessionUser();
+  if (!user) redirect("/join");
+  if (user.role !== "child") redirect("/parent");
+
+  const [total, rows] = await Promise.all([totalPoints(user.id), pointHistory(user.id, 50)]);
+
+  return (
+    <main className="relative mx-auto min-h-dvh max-w-lg space-y-5 p-4 pb-12">
+      <BackgroundBlobs />
+      <header className="flex items-center justify-between">
+        <Link href="/kid" className="text-sm font-medium text-indigo-600">
+          ← 返回
+        </Link>
+        <h1 className="text-xl font-extrabold text-slate-900">我的积分</h1>
+        <span className="w-10" />
+      </header>
+
+      <div className="rounded-2xl bg-gradient-to-r from-yellow-400 to-amber-500 p-6 text-center text-white shadow-btn">
+        <p className="text-5xl font-extrabold">🪙 {total}</p>
+        <p className="mt-2 text-sm opacity-90">完成任务和达标检测都会攒积分,继续加油!</p>
+      </div>
+
+      <section className="rounded-xl border border-slate-100 bg-white p-4 shadow-soft">
+        <h2 className="font-extrabold text-slate-900">积分明细</h2>
+        {rows.length === 0 ? (
+          <p className="mt-3 text-sm text-muted-foreground">还没有积分记录,去完成今天的任务吧!</p>
+        ) : (
+          <div className="mt-2 divide-y divide-slate-100">
+            {rows.map((r) => (
+              <div key={r.id} className="flex items-center gap-2 py-2.5">
+                <div className="min-w-0 flex-1">
+                  <p className="truncate text-sm font-medium text-slate-800">{r.remark || eventLabel(r.eventType)}</p>
+                  <p className="text-xs text-muted-foreground">
+                    {eventLabel(r.eventType)} · {r.createdAt.toLocaleDateString("zh-CN", SH)}
+                  </p>
+                </div>
+                <span className="shrink-0 text-base font-extrabold text-amber-600">+{r.points}</span>
+              </div>
+            ))}
+          </div>
+        )}
+      </section>
+    </main>
+  );
+}
@@ -9,9 +9,10 @@ import { recordWrong } from "@/lib/wrongbook";
 import { db } from "@/db";
 import { taskInstances, weeklyTest } from "@/db/schema";
 import { todayStr } from "@/lib/dates";
+import { awardRulePoints } from "@/lib/points";

 export type WeeklyResult =
-  | { score: number; passed: boolean; correct: number; total: number; detail: boolean[] }
+  | { score: number; passed: boolean; correct: number; total: number; detail: boolean[]; pointsEarned: number }
  | { error: string };

 // 提交每周能力检测:判分、记录、错题入库、达标关联当日英语打卡
@@ -43,8 +44,10 @@ export async function takeWeekly(answers: AnswerValue[]): Promise<WeeklyResult>
    })
    .onDuplicateKeyUpdate({ set: { score: g.score, correct: g.correct, total: g.total, passed: g.passed } });

-  // 达标关联当日英语打卡
+  // 达标关联当日英语打卡,并发积分(首次达标才发)
+  let pointsEarned = 0;
  if (g.passed) {
+    pointsEarned = await awardRulePoints(user.id, "grammar_weekly", `week-${wk}`, `英语周检测 ${wk}`);
    const today = todayStr();
    const title = `英语周检测 · ${wk}`;
    const [ex] = await db
@@ -72,5 +75,6 @@ export async function takeWeekly(answers: AnswerValue[]): Promise<WeeklyResult>
  revalidatePath("/kid");
  revalidatePath("/parent");
  revalidatePath("/wrongbook");
-  return g;
+  revalidatePath("/points");
+  return { ...g, pointsEarned };
 }
@@ -3,6 +3,7 @@ import { redirect } from "next/navigation";
 import { BackgroundBlobs } from "@/components/background-blobs";
 import { getSessionUser } from "@/lib/auth";
 import { buildWeeklyQuestions, currentWeekKey, getWeeklyRecord } from "@/lib/weekly";
+import { getAwardedPoints } from "@/lib/points";
 import { QuizBlock } from "@/app/learn/quiz-block";
 import { takeWeekly } from "./actions";

@@ -14,6 +15,8 @@ export default async function WeeklyPage() {
  const wk = currentWeekKey();
  const record = await getWeeklyRecord(user.id, wk);
  const questions = record ? [] : await buildWeeklyQuestions(user.id, wk);
+  // xuchao: 已有记录时从流水取回本周一达标的积分,结果页刷新后仍显示
+  const awarded = record?.passed ? await getAwardedPoints(user.id, "grammar_weekly", `week-${wk}`) : 0;

  return (
    <main className="relative mx-auto max-w-2xl space-y-5 p-4 pb-12">
@@ -41,6 +44,7 @@ export default async function WeeklyPage() {
          <p className="mt-1 text-sm opacity-90">
            答对 {record.correct} / {record.total} · {record.passed ? "本周掌握良好 🎉" : "看看错题本,下周再战"}
          </p>
+          {record.passed && awarded > 0 && <p className="mt-1 text-base font-extrabold">🪙 +{awarded} 积分</p>}
        </div>
      ) : (
        <QuizBlock pointId="" questions={questions} submitter={takeWeekly} />
@@ -12,7 +12,7 @@ export default async function WordDayPage({ params }: { params: Promise<{ day: s
  if (user.role !== "child") redirect("/parent");

  const day = Number((await params).day);
-  const words = wordsByDay(day);
+  const words = await wordsByDay(day);
  if (words.length === 0) redirect("/words");

  const [prog] = await db
@@ -22,18 +22,20 @@ export default async function WordDayPage({ params }: { params: Promise<{ day: s
    .limit(1);
  const learned: string[] = prog?.learned ? JSON.parse(prog.learned) : [];

-  const items = words.map((w) => ({
-    word: w.word,
-    meaning: w.meaning,
-    similar: similarWords(w.word, 3).map((s) => ({ word: s.word, meaning: s.meaning })),
-  }));
+  const items = await Promise.all(
+    words.map(async (w) => ({
+      word: w.word,
+      meaning: w.meaning,
+      similar: (await similarWords(w.word, 3)).map((s) => ({ word: s.word, meaning: s.meaning })),
+    })),
+  );

  return (
    <WordDayClient
      day={day}
      items={items}
      learned={learned}
-      test={buildWordTest(day)}
+      test={await buildWordTest(day)}
      passed={prog?.passed ?? false}
      score={prog?.score ?? null}
    />
@@ -8,6 +8,7 @@ import { getSessionUser } from "@/lib/auth";
 import { buildWordTest } from "@/lib/words";
 import { uploadUrl } from "@/lib/oss";
 import { todayStr } from "@/lib/dates";
+import { awardRulePoints } from "@/lib/points";

 // 跟读录音直传签名(按实际录音类型签名,避免签名不匹配)
 export async function getRecUploadUrl(word: string, contentType: string): Promise<{ url: string; key: string }> {
@@ -39,14 +40,16 @@ export async function markLearned(day: number, word: string): Promise<void> {
  revalidatePath("/words/[day]", "layout");
 }

-// 提交每日单词检测:服务端组卷判分,达标关联当日英语打卡
+// 提交每日单词检测:服务端组卷判分,达标关联当日英语打卡并发积分
 export async function submitWordTest(
  day: number,
  answers: number[],
-): Promise<{ score: number; passed: boolean; correct: number; total: number; detail: boolean[] } | { error: string }> {
+): Promise<
+  { score: number; passed: boolean; correct: number; total: number; detail: boolean[]; pointsEarned: number } | { error: string }
+> {
  const u = await child();
  if (!u) return { error: "会话无效" };
-  const qs = buildWordTest(day);
+  const qs = await buildWordTest(day);
  if (qs.length === 0) return { error: "当天暂无单词" };
  let correct = 0;
  const detail = qs.map((q, i) => {
@@ -61,7 +64,10 @@ export async function submitWordTest(
    .values({ childUserId: u.id, day, score, passed, completedAt: new Date() })
    .onDuplicateKeyUpdate({ set: { score, passed, completedAt: sql`CURRENT_TIMESTAMP` } });

+  // xuchao: 首次达标发积分(唯一键防刷,重考不再发)
+  let pointsEarned = 0;
  if (passed) {
+    pointsEarned = await awardRulePoints(u.id, "word_test", `day-${day}`, `英语单词 · 第${day}天`);
    const today = todayStr();
    const title = `英语单词 · 第${day}天`;
    const [ex] = await db
@@ -88,7 +94,8 @@ export async function submitWordTest(
  revalidatePath("/words/[day]", "layout");
  revalidatePath("/kid");
  revalidatePath("/parent");
-  return { score, passed, correct, total: qs.length, detail };
+  revalidatePath("/points");
+  return { score, passed, correct, total: qs.length, detail, pointsEarned };
 }

 // 保存跟读录音(已直传 OSS,这里登记)
@@ -5,7 +5,7 @@ import { BackgroundBlobs } from "@/components/background-blobs";
 import { db } from "@/db";
 import { wordProgress } from "@/db/schema";
 import { getSessionUser } from "@/lib/auth";
-import { TOTAL_WORD_DAYS } from "@/lib/words";
+import { totalWordDays } from "@/lib/words";
 import { cn } from "@/lib/utils";

 export default async function WordsHome() {
@@ -18,6 +18,7 @@ export default async function WordsHome() {
    .from(wordProgress)
    .where(and(eq(wordProgress.childUserId, user.id), eq(wordProgress.passed, true)));
  const passedSet = new Set(passed.map((p) => p.day));
+  const TOTAL_WORD_DAYS = await totalWordDays();

  return (
    <main className="relative mx-auto min-h-dvh max-w-2xl space-y-5 p-4 pb-10">
@@ -94,7 +94,9 @@ export function WordDayClient({
  const [example, setExample] = useState<Record<string, string>>({});
  const [testOpen, setTestOpen] = useState(false);
  const [answers, setAnswers] = useState<(number | null)[]>(test.map(() => null));
-  const [result, setResult] = useState<{ score: number; passed: boolean } | null>(passed ? { score: score ?? 0, passed } : null);
+  const [result, setResult] = useState<{ score: number; passed: boolean; pointsEarned: number } | null>(
+    passed ? { score: score ?? 0, passed, pointsEarned: 0 } : null,
+  );
  const [pending, startTransition] = useTransition();

  const toggleLearn = (word: string) => {
@@ -126,7 +128,7 @@ export function WordDayClient({
  const submit = () => {
    startTransition(async () => {
      const r = await submitWordTest(day, answers.map((a) => a as number));
-      if (!("error" in r)) setResult({ score: r.score, passed: r.passed });
+      if (!("error" in r)) setResult({ score: r.score, passed: r.passed, pointsEarned: r.pointsEarned });
    });
  };

@@ -196,6 +198,7 @@ export function WordDayClient({
          {result && (
            <span className={cn("text-sm font-bold", result.passed ? "text-emerald-600" : "text-rose-600")}>
              {result.score} 分 {result.passed ? "· 已点亮" : ""}
+              {result.passed && result.pointsEarned > 0 ? ` · 🪙 +${result.pointsEarned} 积分` : ""}
            </span>
          )}
        </div>
@@ -3,6 +3,7 @@ import { redirect } from "next/navigation";
 import { BackgroundBlobs } from "@/components/background-blobs";
 import { getSessionUser } from "@/lib/auth";
 import { listWrong } from "@/lib/wrongbook";
+import { photoViewUrl } from "@/lib/oss";
 import type { QuizQ } from "@/lib/quiz-parse";
 import { WrongRow } from "./wrong-row";

@@ -39,6 +40,8 @@ export default async function WrongBookPage() {
            } catch {
              return null;
            }
+            // xuchao: 解答题展示当时的作答照片(OSS 签名地址;开发环境为本地回退)
+            const photoUrl = q.type === "solve" && q.solveSnap?.ossKey ? photoViewUrl(q.solveSnap.ossKey) : "";
            return (
              <WrongRow
                key={r.id}
@@ -48,6 +51,7 @@ export default async function WrongBookPage() {
                userAnswer={r.userAnswer}
                correctAnswer={r.correctAnswer}
                mastered={r.mastered}
+                photoUrl={photoUrl}
              />
            );
          })}
@@ -1,7 +1,7 @@
 "use client";

 import { useTransition } from "react";
-import { CheckCircle2, RotateCcw } from "lucide-react";
+import { Check, CheckCircle2, RotateCcw, X } from "lucide-react";
 import { Button } from "@/components/ui/button";
 import { cn } from "@/lib/utils";
 import type { QuizQ } from "@/lib/quiz-parse";
@@ -14,6 +14,7 @@ export function WrongRow({
  userAnswer,
  correctAnswer,
  mastered,
+  photoUrl = "",
 }: {
  id: number;
  sourceTitle: string | null;
@@ -21,8 +22,10 @@ export function WrongRow({
  userAnswer: string | null;
  correctAnswer: string | null;
  mastered: boolean;
+  photoUrl?: string;
 }) {
  const [pending, startTransition] = useTransition();
+  const isSolve = q.type === "solve";
  return (
    <div
      className={cn(
@@ -31,14 +34,46 @@ export function WrongRow({
      )}
    >
      <div className="flex items-start justify-between gap-2">
-        <p className="font-medium text-slate-900">{q.stem}</p>
+        <p className="font-medium text-slate-900">
+          {q.stem}
+          {isSolve && <span className="ml-2 rounded bg-amber-100 px-1.5 py-0.5 text-xs font-semibold text-amber-700">解答题</span>}
+        </p>
        <span className="shrink-0 rounded-full bg-slate-100 px-2 py-0.5 text-xs text-muted-foreground">
          {sourceTitle ?? "检测"}
        </span>
      </div>
+
+      {isSolve && photoUrl && (
+        // xuchao: 当时的作答照片(签名地址 5 分钟有效,页面刷新即重签)
+        <div className="mt-2">
+          {/* eslint-disable-next-line @next/next/no-img-element */}
+          <img src={photoUrl} alt="作答照片" className="max-h-56 rounded-lg border border-slate-200 object-contain" />
+        </div>
+      )}
+
+      {isSolve && (q.solveSnap?.hits?.length ?? 0) > 0 && (
+        <ul className="mt-2 space-y-1">
+          {q.solveSnap!.hits.map((h, i) => (
+            <li key={i} className="flex items-start gap-1.5 text-xs">
+              {h.hit ? (
+                <Check className="mt-0.5 size-3.5 shrink-0 text-emerald-600" />
+              ) : (
+                <X className="mt-0.5 size-3.5 shrink-0 text-rose-500" />
+              )}
+              <span className={h.hit ? "text-slate-600" : "text-rose-600"}>
+                ({h.score}分){h.point}
+              </span>
+            </li>
+          ))}
+        </ul>
+      )}
+
      <div className="mt-2 space-y-1 text-sm">
        <p className="text-rose-600">你的答案:{userAnswer ?? "未作答"}</p>
-        <p className="text-emerald-700">正确答案:{correctAnswer ?? ""}</p>
+        <p className={cn("text-emerald-700", isSolve && "whitespace-pre-line")}>
+          {isSolve ? "参考解答:" : "正确答案:"}
+          {correctAnswer ?? ""}
+        </p>
      </div>
      <p className="mt-2 rounded-lg bg-indigo-50 px-3 py-2 text-sm text-indigo-800">💡 {q.explain}</p>
      <div className="mt-3">
@@ -0,0 +1,336 @@
+{
+  "papers": [
+    {
+      "id": "g7s1-m00-entrance",
+      "grade": "g7",
+      "semester": "s1",
+      "month": 0,
+      "examType": "entrance",
+      "title": "初一入学分班考数学模拟卷(含解答题)",
+      "region": "通用",
+      "year": 2026,
+      "fullScore": 100,
+      "sourceUrl": "",
+      "summary": "按真实分班考卷面结构组卷:填空 8 题×3 分、选择 6 题×3 分、计算解答 4 题×5 分、应用解答 4 题共 38 分,满分 100 分。题目取自本地教研素材的经典分班考题型(鸡兔同笼、工程、分数百分数、行程等),经双模型独立验算;因抓取受限未用原卷页面转录。解答题需纸上手写后拍照,由 AI 按评分点逐步判分。",
+      "questions": [
+        {
+          "type": "fill",
+          "stem": "24 和 36 的最大公因数是____。",
+          "answers": [
+            "12"
+          ],
+          "explain": "24=2×2×2×3,36=2×2×3×3,公有质因数相乘:2×2×3=12。",
+          "points": 3
+        },
+        {
+          "type": "fill",
+          "stem": "8 和 12 的最小公倍数是____。",
+          "answers": [
+            "24"
+          ],
+          "explain": "8=2×2×2,12=2×2×3,最小公倍数=2×2×2×3=24。",
+          "points": 3
+        },
+        {
+          "type": "fill",
+          "stem": "一根绳子长 20 米,用去它的 3/5,还剩____米。",
+          "answers": [
+            "8"
+          ],
+          "explain": "用去 20×3/5=12 米,还剩 20-12=8 米(或 20×(1-3/5)=20×2/5=8 米)。",
+          "points": 3
+        },
+        {
+          "type": "fill",
+          "stem": "一个两位数,个位上的数字是十位上数字的 3 倍,且两个数位上的数字之和是 8,这个两位数是____。",
+          "answers": [
+            "26"
+          ],
+          "explain": "设十位为 a,则个位为 3a,a+3a=8,a=2,个位是 6,这个数是 26。",
+          "points": 3
+        },
+        {
+          "type": "fill",
+          "stem": "一个数除以 5,商是 8,余数是 2,这个数是____。",
+          "answers": [
+            "42"
+          ],
+          "explain": "被除数=商×除数+余数=8×5+2=42。",
+          "points": 3
+        },
+        {
+          "type": "fill",
+          "stem": "按规律填数:1,1,2,3,5,8,____。",
+          "answers": [
+            "13"
+          ],
+          "explain": "从第三项起,每个数等于前两个数的和:5+8=13。",
+          "points": 3
+        },
+        {
+          "type": "fill",
+          "stem": "把 120 按 2:3 分成两份,较大的一份是____。",
+          "answers": [
+            "72"
+          ],
+          "explain": "总份数 2+3=5,较大一份占 3/5:120×3/5=72。",
+          "points": 3
+        },
+        {
+          "type": "fill",
+          "stem": "一个圆的周长是 31.4 厘米,它的直径是____厘米。(π 取 3.14)",
+          "answers": [
+            "10"
+          ],
+          "explain": "直径=周长÷π=31.4÷3.14=10 厘米。",
+          "points": 3
+        },
+        {
+          "type": "choice",
+          "stem": "1 元和 5 元的纸币共 12 张,合计 28 元,其中 5 元纸币有( )张。",
+          "options": [
+            "A. 3",
+            "B. 4",
+            "C. 5",
+            "D. 6"
+          ],
+          "answer": 1,
+          "explain": "设 5 元 x 张,则 1 元 (12-x) 张:5x+(12-x)=28,4x=16,x=4。",
+          "points": 3
+        },
+        {
+          "type": "choice",
+          "stem": "一件衣服原价 200 元,打七五折出售,现价是( )元。",
+          "options": [
+            "A. 50",
+            "B. 150",
+            "C. 160",
+            "D. 175"
+          ],
+          "answer": 1,
+          "explain": "七五折即按原价的 75% 出售:200×75%=150 元。",
+          "points": 3
+        },
+        {
+          "type": "choice",
+          "stem": "路程一定,行驶的速度和所需的时间( )。",
+          "options": [
+            "A. 成正比例",
+            "B. 成反比例",
+            "C. 不成比例"
+          ],
+          "answer": 1,
+          "explain": "速度×时间=路程(一定),乘积一定,成反比例。",
+          "points": 3
+        },
+        {
+          "type": "choice",
+          "stem": "下面各数中,是质数的是( )。",
+          "options": [
+            "A. 51",
+            "B. 91",
+            "C. 97",
+            "D. 117"
+          ],
+          "answer": 2,
+          "explain": "51=3×17,91=7×13,117=3×39=9×13,都不是质数;97 只有 1 和它本身两个因数,是质数。",
+          "points": 3
+        },
+        {
+          "type": "choice",
+          "stem": "一个圆的半径扩大到原来的 2 倍,它的面积扩大到原来的( )倍。",
+          "options": [
+            "A. 2",
+            "B. 4",
+            "C. 6",
+            "D. 8"
+          ],
+          "answer": 1,
+          "explain": "面积=πr²,半径扩大 2 倍,面积扩大 2²=4 倍。",
+          "points": 3
+        },
+        {
+          "type": "choice",
+          "stem": "爸爸今年 40 岁,儿子今年 12 岁,( )年后爸爸的年龄是儿子的 3 倍。",
+          "options": [
+            "A. 1",
+            "B. 2",
+            "C. 3",
+            "D. 4"
+          ],
+          "answer": 1,
+          "explain": "设 x 年后:40+x=3×(12+x),40+x=36+3x,2x=4,x=2。",
+          "points": 3
+        },
+        {
+          "type": "solve",
+          "stem": "用简便方法计算:25×32×125",
+          "points": 5,
+          "reference": "25×32×125\n=25×(4×8)×125(把 32 拆成 4×8)\n=(25×4)×(8×125)(乘法交换律、结合律)\n=100×1000\n=100000",
+          "rubric": [
+            {
+              "point": "把 32 拆成 4×8,并合理运用乘法交换律/结合律重组算式",
+              "score": 2
+            },
+            {
+              "point": "正确算出 25×4=100 与 8×125=1000",
+              "score": 2
+            },
+            {
+              "point": "得出正确结果 100000",
+              "score": 1
+            }
+          ],
+          "explain": "看到 25 想 4,看到 125 想 8:把 32 拆成 4×8,凑成 25×4 与 8×125 两组整百整千。"
+        },
+        {
+          "type": "solve",
+          "stem": "用简便方法计算:3/4×5/6+5/6×1/4",
+          "points": 5,
+          "reference": "3/4×5/6+5/6×1/4\n=5/6×(3/4+1/4)(乘法分配律逆用)\n=5/6×1\n=5/6",
+          "rubric": [
+            {
+              "point": "发现公因数 5/6,逆用乘法分配律写成 5/6×(3/4+1/4)",
+              "score": 2
+            },
+            {
+              "point": "正确算出 3/4+1/4=1",
+              "score": 1
+            },
+            {
+              "point": "得出正确结果 5/6",
+              "score": 2
+            }
+          ],
+          "explain": "两个乘积都有因数 5/6,逆用分配律:5/6×(3/4+1/4)=5/6×1=5/6。"
+        },
+        {
+          "type": "solve",
+          "stem": "解方程:3x+5=2x+9",
+          "points": 5,
+          "reference": "3x+5=2x+9\n3x-2x=9-5(两边同时减 2x、减 5)\nx=4",
+          "rubric": [
+            {
+              "point": "正确移项(含未知数的项移到一边,常数项移到另一边,变号正确)",
+              "score": 2
+            },
+            {
+              "point": "得出 x=4",
+              "score": 2
+            },
+            {
+              "point": "写出结论或代入检验",
+              "score": 1
+            }
+          ],
+          "explain": "移项:3x-2x=9-5,即 x=4。检验:左边=3×4+5=17,右边=2×4+9=17,相等。"
+        },
+        {
+          "type": "solve",
+          "stem": "计算:4.8÷(1.2×2)+3.5",
+          "points": 5,
+          "reference": "4.8÷(1.2×2)+3.5\n=4.8÷2.4+3.5(先算括号里的)\n=2+3.5\n=5.5",
+          "rubric": [
+            {
+              "point": "按运算顺序先算括号内 1.2×2=2.4",
+              "score": 1
+            },
+            {
+              "point": "正确算出 4.8÷2.4=2",
+              "score": 2
+            },
+            {
+              "point": "得出正确结果 5.5",
+              "score": 2
+            }
+          ],
+          "explain": "运算顺序:先括号,再乘除,最后加减。4.8÷2.4=2,2+3.5=5.5。"
+        },
+        {
+          "type": "solve",
+          "stem": "笼子里有鸡和兔共 35 只,数一数共有 94 条腿。鸡和兔各有多少只?",
+          "points": 8,
+          "reference": "假设全是鸡:35×2=70(条腿)\n比实际少:94-70=24(条腿)\n每把一只鸡换成兔多 2 条腿:24÷2=12(只)\n兔有 12 只,鸡有 35-12=23(只)\n答:鸡有 23 只,兔有 12 只。",
+          "rubric": [
+            {
+              "point": "方法正确完整(假设法、方程法等任一种,数量关系列对)",
+              "score": 3
+            },
+            {
+              "point": "求出兔 12 只",
+              "score": 3
+            },
+            {
+              "point": "求出鸡 23 只并写出答句",
+              "score": 2
+            }
+          ],
+          "explain": "鸡兔同笼经典题:假设全是鸡得 70 条腿,差的 24 条腿由每只换兔补 2 条,兔=24÷2=12 只。也可设兔 x 只:4x+2(35-x)=94。"
+        },
+        {
+          "type": "solve",
+          "stem": "一件工作,甲单独做 20 天完成,乙单独做 30 天完成。两人合作,多少天可以完成?",
+          "points": 10,
+          "reference": "把工作总量看作 1。\n甲每天完成 1/20,乙每天完成 1/30。\n两人每天共完成:1/20+1/30=3/60+2/60=5/60=1/12\n完成天数:1÷1/12=12(天)\n答:两人合作 12 天可以完成。",
+          "rubric": [
+            {
+              "point": "设工作总量为 1,正确表示甲、乙工作效率 1/20 与 1/30",
+              "score": 3
+            },
+            {
+              "point": "正确求出效率和 1/20+1/30=1/12",
+              "score": 4
+            },
+            {
+              "point": "得出 12 天并写出答句",
+              "score": 3
+            }
+          ],
+          "explain": "工程问题:工作总量÷效率和=合作时间。1÷(1/20+1/30)=1÷1/12=12 天。"
+        },
+        {
+          "type": "solve",
+          "stem": "商店运来一批水果,上午卖出总数的 1/3,下午卖出总数的 1/4,还剩 50 千克。这批水果共有多少千克?",
+          "points": 10,
+          "reference": "把水果总数看作单位“1”。\n50 千克对应的分率:1-1/3-1/4=12/12-4/12-3/12=5/12\n总数:50÷5/12=50×12/5=120(千克)\n答:这批水果共有 120 千克。",
+          "rubric": [
+            {
+              "point": "找准单位“1”,正确求出 50 千克对应的分率 1-1/3-1/4=5/12",
+              "score": 4
+            },
+            {
+              "point": "正确列式 50÷5/12 并计算",
+              "score": 3
+            },
+            {
+              "point": "得出 120 千克并写出答句",
+              "score": 3
+            }
+          ],
+          "explain": "分数应用题:已知剩余量求单位“1”,用除法。剩余对应分率 5/12,总数=50÷5/12=120 千克。"
+        },
+        {
+          "type": "solve",
+          "stem": "甲、乙两地相距 480 千米,一辆客车从甲地出发,每小时行 60 千米;同时一辆货车从乙地出发,每小时行 40 千米,两车相向而行。经过几小时两车相遇?相遇时客车行了多少千米?",
+          "points": 10,
+          "reference": "速度和:60+40=100(千米/时)\n相遇时间:480÷100=4.8(小时)\n客车行驶路程:60×4.8=288(千米)\n答:经过 4.8 小时两车相遇,相遇时客车行了 288 千米。",
+          "rubric": [
+            {
+              "point": "正确求出速度和 60+40=100 千米/时",
+              "score": 2
+            },
+            {
+              "point": "得出相遇时间 480÷100=4.8 小时",
+              "score": 4
+            },
+            {
+              "point": "得出客车行了 288 千米并写出答句",
+              "score": 4
+            }
+          ],
+          "explain": "相遇问题:相遇时间=总路程÷速度和=480÷100=4.8 小时;客车路程=60×4.8=288 千米。"
+        }
+      ]
+    }
+  ]
+}
@@ -91,6 +91,8 @@ export const taskTemplates = mysqlTable(
    title: varchar("title", { length: 100 }).notNull(),
    subject: mysqlEnum("subject", SUBJECT_VALUES).notNull().default("other"),
    requiresPhoto: boolean("requires_photo").notNull().default(false),
+    // xuchao: 该任务完成可得积分(家长按任务难度单独设置)
+    points: int("points").notNull().default(10),
    // 模板生效方式:weekly=每周某weekday / date=某一天 / range=日期区间 / week=某一周
    mode: varchar("mode", { length: 10 }).notNull().default("weekly"),
    dateStart: date("date_start", { mode: "string" }),
@@ -114,6 +116,8 @@ export const taskInstances = mysqlTable(
    title: varchar("title", { length: 100 }).notNull(),
    subject: mysqlEnum("subject", SUBJECT_VALUES).notNull().default("other"),
    requiresPhoto: boolean("requires_photo").notNull().default(false),
+    // xuchao: 该任务完成可得积分(生成快照时从模板复制)
+    points: int("points").notNull().default(10),
    status: mysqlEnum("status", ["pending", "done"]).notNull().default("pending"),
    // 家长补卡标记,永久保留
    isMakeup: boolean("is_makeup").notNull().default(false),
@@ -181,6 +185,19 @@ export const wrongBook = mysqlTable(
  (t) => [index("idx_wrong_child").on(t.childUserId, t.mastered)],
 );

+// ===== 单词词库(内容存库,家长端可按天编辑;初始由 words.json 灌入)=====
+export const wordEntry = mysqlTable(
+  "word_entry",
+  {
+    id: bigint("id", { mode: "number" }).primaryKey().autoincrement(),
+    word: varchar("word", { length: 60 }).notNull(),
+    meaning: varchar("meaning", { length: 300 }).notNull().default(""),
+    day: int("day").notNull(), // 第几天学习
+    seq: int("seq").notNull(), // 全局顺序(组卷干扰项取材用)
+  },
+  (t) => [index("idx_word_entry_day").on(t.day)],
+);
+
 // ===== 单词每日进度(学会的词+检测成绩)=====
 export const wordProgress = mysqlTable(
  "word_progress",
@@ -346,3 +363,65 @@ export const examRecords = mysqlTable(
  },
  (t) => [uniqueIndex("uq_exam_child_paper").on(t.childUserId, t.paperId)],
 );
+
+// ===== AI 判分审计日志(限频依据 + 家长端可查 + 成绩溯源)=====
+export const aiGradeLog = mysqlTable(
+  "ai_grade_log",
+  {
+    id: bigint("id", { mode: "number" }).primaryKey().autoincrement(),
+    childUserId: bigint("child_user_id", { mode: "number" })
+      .notNull()
+      .references(() => users.id, { onDelete: "cascade" }),
+    paperId: varchar("paper_id", { length: 191 }).notNull(),
+    questionIndex: int("question_index").notNull(),
+    ossKey: varchar("oss_key", { length: 300 }).notNull(),
+    // xuchao: ok=正常判分 blank=空白 blurry=模糊 printed=印刷体拒判 unrelated=无关内容 error=调用失败
+    status: varchar("status", { length: 20 }).notNull(),
+    earned: int("earned").notNull().default(0),
+    points: int("points").notNull().default(0),
+    verdict: text("verdict"), // JSON:逐评分点命中与点评
+    mock: boolean("mock").notNull().default(false), // 演示判分标记(无 API key)
+    model: varchar("model", { length: 60 }),
+    ms: int("ms"), // 判分耗时
+    createdAt: datetime("created_at").notNull().default(sql`CURRENT_TIMESTAMP`),
+  },
+  (t) => [
+    index("idx_ai_grade_child_date").on(t.childUserId, t.createdAt),
+    index("idx_ai_grade_paper_q").on(t.childUserId, t.paperId, t.questionIndex),
+  ],
+);
+
+// ===== 积分规则(测试类事件分值,家长可调;打卡分值随任务本身设置)=====
+export const pointRule = mysqlTable(
+  "point_rule",
+  {
+    id: bigint("id", { mode: "number" }).primaryKey().autoincrement(),
+    // word_test/math_lesson/grammar_point/grammar_weekly/math_weekly/exam_pass
+    eventType: varchar("event_type", { length: 30 }).notNull(),
+    points: int("points").notNull().default(0),
+    updatedAt: datetime("updated_at").notNull().default(sql`CURRENT_TIMESTAMP`),
+  },
+  (t) => [uniqueIndex("uq_point_rule_event").on(t.eventType)],
+);
+
+// ===== 积分流水(只增不减;唯一键即防刷:同一事件实例只发一次)=====
+export const pointLog = mysqlTable(
+  "point_log",
+  {
+    id: bigint("id", { mode: "number" }).primaryKey().autoincrement(),
+    childUserId: bigint("child_user_id", { mode: "number" })
+      .notNull()
+      .references(() => users.id, { onDelete: "cascade" }),
+    // checkin/word_test/math_lesson/grammar_point/grammar_weekly/math_weekly/exam_pass
+    eventType: varchar("event_type", { length: 30 }).notNull(),
+    // 事件实例标识,如 inst-123 / day-5 / point-calc-01 / week-2026-W33 / paper-xxx
+    refKey: varchar("ref_key", { length: 100 }).notNull(),
+    points: int("points").notNull(),
+    remark: varchar("remark", { length: 200 }).notNull().default(""),
+    createdAt: datetime("created_at").notNull().default(sql`CURRENT_TIMESTAMP`),
+  },
+  (t) => [
+    uniqueIndex("uq_point_log_dedup").on(t.childUserId, t.eventType, t.refKey),
+    index("idx_point_log_child").on(t.childUserId),
+  ],
+);
@@ -0,0 +1,174 @@
+// xuchao: 解答题 AI 判分引擎——阿里云百炼 Qwen-VL,按评分点(rubric)部分给分
+// 无 DASHSCOPE_API_KEY 时进入演示判分(mock),供本地开发;生产必须配真 key
+
+export type SolveStatus = "ok" | "blank" | "blurry" | "printed" | "unrelated" | "error";
+export type RubricItem = { point: string; score: number };
+export type RubricHit = { point: string; score: number; hit: boolean; reason: string };
+export type GradeVerdict = {
+  status: SolveStatus;
+  hits: RubricHit[];
+  earned: number; // 由 hits 重算,不信任模型自报
+  comment: string;
+  mock: boolean;
+  model: string;
+  ms: number;
+};
+
+const ENDPOINT = "https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions";
+const MODEL = process.env.AI_GRADE_MODEL || "qwen-vl-max";
+const TIMEOUT_MS = 60_000;
+
+// xuchao: 判分提示词——题干+参考解答+评分点+学生手写照片,只允许离散给分
+function buildPrompt(stem: string, points: number, reference: string, rubric: RubricItem[], hasFigure: boolean) {
+  const rubricText = rubric.map((r, i) => `${i + 1}. ${r.point}(${r.score} 分)`).join("\n");
+  return `你是一位经验丰富的数学阅卷老师,正在批改学生手写的解答题照片。
+
+【题目】${stem}${hasFigure ? "\n(题目配有示意图,以题意为准)" : ""}
+【本题满分】${points} 分
+【参考解答】
+${reference}
+【评分点】
+${rubricText}
+
+请按以下步骤评判:
+1. 判断照片状态,status 只能是以下之一:
+   - ok:正常的手写解答
+   - blank:空白或没有作答内容
+   - blurry:字迹模糊无法辨认
+   - printed:印刷体内容(非手写,拒绝批改)
+   - unrelated:照片内容与本题无关
+2. 仅当 status=ok 时逐条评判评分点。学生方法可以与参考解答不同,只要该评分点的要求确实达成就 hit=true 并给该评分点满分,否则 hit=false 给 0 分。不允许给某个评分点部分分数。
+3. earned = 所有 hit=true 评分点分数之和,不得超过满分 ${points}。
+4. comment 给一句面向小学生的总体点评(指出亮点或主要问题)。
+
+只输出一个 JSON 对象,不要输出任何其他文字:
+{"status":"ok","hits":[{"hit":true,"reason":"简短理由"}],"earned":数字,"comment":"点评"}
+hits 数组元素个数必须等于评分点个数(${rubric.length}),顺序与评分点一致。status 非 ok 时 hits 为空数组、earned 为 0。`;
+}
+
+// xuchao: 演示判分(无 key):确定性模拟——最后一个评分点不得分,便于本地验证部分给分与错题链路
+function mockVerdict(stem: string, points: number, rubric: RubricItem[]): GradeVerdict {
+  const hits: RubricHit[] = rubric.map((r, i) => ({
+    point: r.point,
+    score: r.score,
+    hit: i < rubric.length - 1 || rubric.length === 1,
+    reason: i < rubric.length - 1 || rubric.length === 1 ? "演示判分:达成" : "演示判分:未达成(模拟扣分)",
+  }));
+  const earned = hits.reduce((s, h) => s + (h.hit ? h.score : 0), 0);
+  return {
+    status: "ok",
+    hits,
+    earned: rubric.length === 1 ? points : Math.min(earned, points),
+    comment: "这是演示判分(未配置百炼 API Key),结果仅用于流程测试。",
+    mock: true,
+    model: "mock",
+    ms: 0,
+  };
+}
+
+// xuchao: 从模型回复里稳健提取 JSON(容忍代码块包裹与多余文字)
+function extractJson(text: string): Record<string, unknown> | null {
+  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+  const body = fenced ? fenced[1] : text;
+  const start = body.indexOf("{");
+  const end = body.lastIndexOf("}");
+  if (start < 0 || end <= start) return null;
+  try {
+    return JSON.parse(body.slice(start, end + 1));
+  } catch {
+    return null;
+  }
+}
+
+const VALID_STATUS = new Set(["ok", "blank", "blurry", "printed", "unrelated"]);
+
+// xuchao: 校验并归一化模型判定;earned 一律按 hits 重算
+function normalizeVerdict(raw: Record<string, unknown>, rubric: RubricItem[], model: string, ms: number): GradeVerdict | null {
+  const status = typeof raw.status === "string" && VALID_STATUS.has(raw.status) ? (raw.status as SolveStatus) : null;
+  if (!status) return null;
+  let hits: RubricHit[] = [];
+  if (status === "ok") {
+    const arr = Array.isArray(raw.hits) ? raw.hits : null;
+    if (!arr || arr.length !== rubric.length) return null;
+    hits = rubric.map((r, i) => {
+      const h = (arr[i] ?? {}) as Record<string, unknown>;
+      return { point: r.point, score: r.score, hit: h.hit === true, reason: typeof h.reason === "string" ? h.reason : "" };
+    });
+  }
+  const earned = Math.min(
+    points_cap(rubric),
+    hits.reduce((s, h) => s + (h.hit ? h.score : 0), 0),
+  );
+  return {
+    status,
+    hits,
+    earned,
+    comment: typeof raw.comment === "string" ? raw.comment : "",
+    mock: false,
+    model,
+    ms,
+  };
+}
+
+const points_cap = (rubric: RubricItem[]) => rubric.reduce((s, r) => s + r.score, 0);
+
+// xuchao: 判分主入口;photoUrl 必须是公网可达地址(OSS 签名 URL)
+export async function gradeSolvePhoto(opts: {
+  stem: string;
+  points: number;
+  rubric: RubricItem[];
+  reference: string;
+  photoUrl: string;
+  figureUrl?: string;
+}): Promise<GradeVerdict> {
+  const { stem, points, rubric, reference, photoUrl, figureUrl } = opts;
+  const apiKey = process.env.DASHSCOPE_API_KEY;
+  if (!apiKey) return mockVerdict(stem, points, rubric);
+
+  const content: Record<string, unknown>[] = [
+    { type: "text", text: buildPrompt(stem, points, reference, rubric, !!figureUrl) },
+    { type: "image_url", image_url: { url: photoUrl } },
+  ];
+  if (figureUrl) content.push({ type: "image_url", image_url: { url: figureUrl } });
+
+  let lastErr = "";
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const t0 = Date.now();
+    try {
+      const ctrl = new AbortController();
+      const timer = setTimeout(() => ctrl.abort(), TIMEOUT_MS);
+      const resp = await fetch(ENDPOINT, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` },
+        body: JSON.stringify({
+          model: MODEL,
+          messages: [{ role: "user", content }],
+          temperature: 0.1,
+        }),
+        signal: ctrl.signal,
+      });
+      clearTimeout(timer);
+      if (!resp.ok) {
+        lastErr = `HTTP ${resp.status}`;
+        continue;
+      }
+      const data = (await resp.json()) as { choices?: { message?: { content?: string } }[] };
+      const text = data.choices?.[0]?.message?.content ?? "";
+      const raw = extractJson(text);
+      if (!raw) {
+        lastErr = "JSON 解析失败";
+        continue;
+      }
+      const v = normalizeVerdict(raw, rubric, MODEL, Date.now() - t0);
+      if (!v) {
+        lastErr = "判定结构不符";
+        continue;
+      }
+      return v;
+    } catch (e) {
+      lastErr = e instanceof Error ? e.message : String(e);
+    }
+  }
+  // xuchao: 两次均失败——返回 error 状态,前端提示重拍,不写入得分
+  return { status: "error", hits: [], earned: 0, comment: `判分失败(${lastErr}),请重试`, mock: false, model: MODEL, ms: 0 };
+}
@@ -1,12 +1,14 @@
 // xuchao: 考试板块——试卷查询与作答记录
-import { and, eq, sql } from "drizzle-orm";
+import { and, desc, eq, gte, sql } from "drizzle-orm";
 import { db } from "@/db";
-import { examPapers, examRecords, taskInstances } from "@/db/schema";
+import { aiGradeLog, examPapers, examRecords, taskInstances } from "@/db/schema";
 import { todayStr } from "@/lib/dates";
 import type { QuizQ } from "@/lib/quiz-parse";
+import { awardRulePoints } from "@/lib/points";

 // xuchao: 试卷题型标签(展示用)
 export const EXAM_TYPE_LABEL: Record<string, string> = {
+  entrance: "入学考",
  monthly: "月考",
  unit: "单元卷",
  midterm: "期中",
@@ -85,7 +87,7 @@ export async function recordsByPaper(childId: number): Promise<Map<string, { sco
  return new Map(rows.map((r) => [r.paperId, { score: r.score ?? 0, passed: r.passed }]));
 }

-// xuchao: 记录作答;达标联动当天数学打卡(允许重考覆盖成绩)
+// xuchao: 记录作答;达标联动当天数学打卡并发积分(首次达标才发);返回实发积分
 export async function recordExam(
  childId: number,
  paperId: string,
@@ -95,7 +97,7 @@ export async function recordExam(
  total: number,
  passed: boolean,
  answers: unknown[],
-) {
+): Promise<number> {
  await db
    .insert(examRecords)
    .values({
@@ -111,7 +113,8 @@ export async function recordExam(
      set: { score, correct, total, passed, answers: JSON.stringify(answers), takenAt: sql`CURRENT_TIMESTAMP` },
    });

-  if (!passed) return;
+  if (!passed) return 0;
+  const pointsEarned = await awardRulePoints(childId, "exam_pass", `paper-${paperId}`, paperTitle);
  const today = todayStr();
  const ckTitle = `考试 · ${paperTitle.length > 24 ? paperTitle.slice(0, 24) + "…" : paperTitle}`;
  const [existing] = await db
@@ -138,4 +141,29 @@ export async function recordExam(
      sortOrder: 96,
    });
  }
+  return pointsEarned;
+}
+
+// xuchao: 当日 AI 判分次数(限频用,含全部状态)
+export async function gradeCountToday(childId: number): Promise<number> {
+  const midnight = new Date(`${todayStr()}T00:00:00`);
+  const [r] = await db
+    .select({ n: sql<number>`COUNT(*)` })
+    .from(aiGradeLog)
+    .where(and(eq(aiGradeLog.childUserId, childId), gte(aiGradeLog.createdAt, midnight)));
+  return Number(r?.n ?? 0);
+}
+
+// xuchao: 某孩子某卷每道解答题最近一次判分日志(交卷计分用)
+export async function latestSolveLogs(childId: number, paperId: string) {
+  const rows = await db
+    .select()
+    .from(aiGradeLog)
+    .where(and(eq(aiGradeLog.childUserId, childId), eq(aiGradeLog.paperId, paperId)))
+    .orderBy(desc(aiGradeLog.id));
+  const byQ = new Map<number, (typeof rows)[number]>();
+  for (const r of rows) {
+    if (!byQ.has(r.questionIndex)) byQ.set(r.questionIndex, r);
+  }
+  return byQ;
 }
@@ -3,6 +3,7 @@ import { db } from "@/db";
 import { grammarPoints, grammarProgress, taskInstances } from "@/db/schema";
 import { todayStr } from "@/lib/dates";
 import { extractQuiz, type QuizQ } from "@/lib/quiz-parse";
+import { awardRulePoints } from "@/lib/points";

 export { extractQuiz, type QuizQ };

@@ -63,19 +64,22 @@ export async function passedCount(childId: number): Promise<number> {

 const norm = (s: unknown) => String(s ?? "").trim().toLowerCase();

-// 服务端判分:五种题型 choice/judge/fill/order/match
+// 服务端判分:六种题型 choice/judge/fill/order/match/solve(solve 不在此处判,走 AI)
 export type AnswerValue = number | string | string[];
+
+// xuchao: 单题客观判分(solve 返回 false,由 AI 判分链路单独处理)
+export function gradeOne(q: QuizQ, a: AnswerValue | null | undefined): boolean {
+  if (q.type === "fill") return (q.answers ?? []).some((x) => norm(x) === norm(a));
+  if (q.type === "order") return Array.isArray(a) && a.join(" ").trim() === (q.answer as string[]).join(" ").trim();
+  if (q.type === "match") return Array.isArray(a) && (q.pairs ?? []).every((p, pi) => norm(a[pi]) === norm(p[1]));
+  if (q.type === "solve") return false;
+  return Number(a) === (q.answer as number);
+}
+
 export function gradeAnswers(questions: QuizQ[], answers: AnswerValue[]) {
  let correct = 0;
  const detail = questions.map((q, i) => {
-    const a = answers[i];
-    let ok = false;
-    if (q.type === "fill") ok = (q.answers ?? []).some((x) => norm(x) === norm(a));
-    else if (q.type === "order")
-      ok = Array.isArray(a) && a.join(" ").trim() === (q.answer as string[]).join(" ").trim();
-    else if (q.type === "match")
-      ok = Array.isArray(a) && (q.pairs ?? []).every((p, pi) => norm(a[pi]) === norm(p[1]));
-    else ok = Number(a) === (q.answer as number);
+    const ok = gradeOne(q, answers[i]);
    if (ok) correct++;
    return ok;
  });
@@ -83,20 +87,21 @@ export function gradeAnswers(questions: QuizQ[], answers: AnswerValue[]) {
  return { score, passed: score >= 80, correct, total: questions.length, detail };
 }

-// 记录结果;通过则同步完成当天英语打卡
+// 记录结果;通过则同步完成当天英语打卡;返回首次达标所发积分
 export async function completePoint(
  childId: number,
  pointId: string,
  title: string,
  score: number,
  passed: boolean,
-) {
+): Promise<number> {
  await db
    .insert(grammarProgress)
    .values({ childUserId: childId, pointId, score, passed })
    .onDuplicateKeyUpdate({ set: { score, passed, completedAt: sql`CURRENT_TIMESTAMP` } });

-  if (!passed) return;
+  if (!passed) return 0;
+  const pointsEarned = await awardRulePoints(childId, "grammar_point", `point-${pointId}`, title);
  const today = todayStr();
  const ckTitle = `英语语法 · ${title}`;
  const [existing] = await db
@@ -123,4 +128,5 @@ export async function completePoint(
      sortOrder: 99,
    });
  }
+  return pointsEarned;
 }
@@ -5,6 +5,7 @@ import { mathPoints, mathProgress, taskInstances } from "@/db/schema";
 import { todayStr } from "@/lib/dates";
 import { extractQuiz, type QuizQ } from "@/lib/quiz-parse";
 import { gradeAnswers, type AnswerValue } from "@/lib/grammar";
+import { awardRulePoints } from "@/lib/points";

 export { extractQuiz, type QuizQ };
 export { gradeAnswers, type AnswerValue };
@@ -64,20 +65,21 @@ export async function mathPassedByPoint(childId: number): Promise<Set<string>> {
  return new Set(rows.map((r) => r.pointId));
 }

-// xuchao: 记录结果;通过则同步完成当天数学打卡
+// xuchao: 记录结果;通过则同步完成当天数学打卡;返回首次达标所发积分
 export async function completeMathPoint(
  childId: number,
  pointId: string,
  title: string,
  score: number,
  passed: boolean,
-) {
+): Promise<number> {
  await db
    .insert(mathProgress)
    .values({ childUserId: childId, pointId, score, passed })
    .onDuplicateKeyUpdate({ set: { score, passed, completedAt: sql`CURRENT_TIMESTAMP` } });

-  if (!passed) return;
+  if (!passed) return 0;
+  const pointsEarned = await awardRulePoints(childId, "math_lesson", `point-${pointId}`, title);
  const today = todayStr();
  const ckTitle = `数学思维 · ${title}`;
  const [existing] = await db
@@ -104,4 +106,5 @@ export async function completeMathPoint(
      sortOrder: 97,
    });
  }
+  return pointsEarned;
 }
@@ -36,3 +36,19 @@ export function viewUrl(key: string) {
 export function photoKey(childId: number, date: string) {
  return `photos/${childId}/${date}/${crypto.randomBytes(8).toString("hex")}.jpg`;
 }
+
+// xuchao: 是否已配置 OSS(未配置时本地开发走 /api/dev-photo 落盘回退)
+export function ossConfigured() {
+  return !!(BUCKET && ID && SECRET);
+}
+
+// xuchao: 解答题作答照片键名:exam-solve/孩子ID/试卷/题号-随机.jpg
+export function solveKey(childId: number, paperId: string, questionIndex: number) {
+  return `exam-solve/${childId}/${paperId}/q${questionIndex}-${crypto.randomBytes(8).toString("hex")}.jpg`;
+}
+
+// xuchao: 作答照片展示地址:OSS 签名 GET;开发环境返回本地回退路由地址
+export function photoViewUrl(key: string) {
+  if (ossConfigured()) return viewUrl(key);
+  return `/api/dev-photo?key=${encodeURIComponent(key)}`;
+}
@@ -0,0 +1,114 @@
+// xuchao: 积分系统——纯累计,首次达标才发(唯一键防刷);打卡分值随任务,测试类分值在 point_rule 可调
+import { and, desc, eq, sql } from "drizzle-orm";
+import { db } from "@/db";
+import { pointLog, pointRule } from "@/db/schema";
+
+// 测试类事件中文名(家长规则页展示用);checkin 分值在任务上,不进规则表
+export const POINT_EVENT_LABELS: Record<string, string> = {
+  word_test: "单词检测达标",
+  math_lesson: "数学课达标",
+  grammar_point: "语法知识点达标",
+  grammar_weekly: "英语周检测达标",
+  math_weekly: "数学周检测达标",
+  exam_pass: "考试通过",
+};
+
+// 规则表无记录时的默认分值(家长改过即落库覆盖)
+export const DEFAULT_RULE_POINTS: Record<string, number> = {
+  word_test: 20,
+  math_lesson: 15,
+  grammar_point: 15,
+  grammar_weekly: 50,
+  math_weekly: 50,
+  exam_pass: 100,
+};
+
+// xuchao: drizzle 会把 mysql2 错误包进 cause,沿错误链识别重复键
+function isDupEntry(e: unknown): boolean {
+  let cur: unknown = e;
+  for (let i = 0; cur && i < 5; i++) {
+    const c = cur as { code?: string; errno?: number };
+    if (c.code === "ER_DUP_ENTRY" || c.errno === 1062) return true;
+    cur = (cur as { cause?: unknown }).cause;
+  }
+  return false;
+}
+
+// 发放积分;同一 (child,eventType,refKey) 重复插入命中唯一键→静默跳过返回 0
+export async function awardPoints(
+  childId: number,
+  eventType: string,
+  refKey: string,
+  points: number,
+  remark: string,
+): Promise<number> {
+  if (!points || points <= 0) return 0;
+  try {
+    await db.insert(pointLog).values({ childUserId: childId, eventType, refKey, points, remark });
+    return points;
+  } catch (e: unknown) {
+    if (isDupEntry(e)) return 0;
+    throw e;
+  }
+}
+
+// 测试类事件发放:按规则表取分值(缺省用默认值),返回实发分值(0=已发过)
+export async function awardRulePoints(
+  childId: number,
+  eventType: string,
+  refKey: string,
+  remark: string,
+): Promise<number> {
+  const pts = await getRulePoints(eventType);
+  return awardPoints(childId, eventType, refKey, pts, remark);
+}
+
+export async function getRulePoints(eventType: string): Promise<number> {
+  const [row] = await db.select().from(pointRule).where(eq(pointRule.eventType, eventType)).limit(1);
+  return row?.points ?? DEFAULT_RULE_POINTS[eventType] ?? 0;
+}
+
+// 家长规则页:DB 值优先,缺的用默认值补齐
+export async function listPointRules(): Promise<{ eventType: string; label: string; points: number }[]> {
+  const rows = await db.select().from(pointRule);
+  const map = new Map(rows.map((r) => [r.eventType, r.points]));
+  return Object.keys(DEFAULT_RULE_POINTS).map((eventType) => ({
+    eventType,
+    label: POINT_EVENT_LABELS[eventType],
+    points: map.get(eventType) ?? DEFAULT_RULE_POINTS[eventType],
+  }));
+}
+
+export async function upsertPointRule(eventType: string, points: number): Promise<void> {
+  await db
+    .insert(pointRule)
+    .values({ eventType, points })
+    .onDuplicateKeyUpdate({ set: { points, updatedAt: new Date() } });
+}
+
+export async function totalPoints(childId: number): Promise<number> {
+  const [r] = await db
+    .select({ n: sql<number>`COALESCE(SUM(points),0)` })
+    .from(pointLog)
+    .where(eq(pointLog.childUserId, childId));
+  return r.n;
+}
+
+// xuchao: 查询某事件已发积分(周测结果页刷新后仍要显示「+N 积分」)
+export async function getAwardedPoints(childId: number, eventType: string, refKey: string): Promise<number> {
+  const [row] = await db
+    .select({ points: pointLog.points })
+    .from(pointLog)
+    .where(and(eq(pointLog.childUserId, childId), eq(pointLog.eventType, eventType), eq(pointLog.refKey, refKey)))
+    .limit(1);
+  return row?.points ?? 0;
+}
+
+export async function pointHistory(childId: number, limit = 50) {
+  return db
+    .select()
+    .from(pointLog)
+    .where(eq(pointLog.childUserId, childId))
+    .orderBy(desc(pointLog.id))
+    .limit(limit);
+}
@@ -1,13 +1,20 @@
 // 纯解析工具:不依赖数据库,可安全在客户端组件中使用

 export type QuizQ = {
-  type: "choice" | "fill" | "judge" | "order" | "match";
+  type: "choice" | "fill" | "judge" | "order" | "match" | "solve";
  stem: string;
  options?: string[];
  answer?: number | string[];
  answers?: string[];
  words?: string[]; // order:打乱的词
  pairs?: [string, string][]; // match:左右配对
+  // xuchao: solve 解答题(拍照 + AI 按评分点判分)
+  figure?: string; // 题目配图路径(public/exam/<卷>/xxx)
+  points?: number; // solve:本题满分
+  reference?: string; // solve:完整参考解答
+  rubric?: { point: string; score: number }[]; // solve:评分点,合计 = points
+  // xuchao: 错题本里的解答题作答快照(照片 + 逐点判定),交卷入错题本时写入
+  solveSnap?: { ossKey: string; earned: number; hits: { point: string; score: number; hit: boolean; reason: string }[] };
  explain: string;
 };

@@ -44,6 +44,7 @@ export async function ensureDay(childId: number, date: string) {
            title: t.title,
            subject: t.subject,
            requiresPhoto: t.requiresPhoto,
+            points: t.points,
            sortOrder: t.sortOrder,
            sourceTemplateId: t.id,
          })),
@@ -71,6 +72,7 @@ export async function ensureDay(childId: number, date: string) {
          title: t.title,
          subject: t.subject,
          requiresPhoto: t.requiresPhoto,
+          points: t.points,
          sortOrder: t.sortOrder,
          sourceTemplateId: t.id,
        });
@@ -1,13 +1,27 @@
+import { asc, sql } from "drizzle-orm";
 import raw from "@/content/words/words.json";
+import { db } from "@/db";
+import { wordEntry } from "@/db/schema";

 export type Word = { word: string; meaning: string; day: number; seq: number };

-export const WORDS = raw as Word[];
-export const TOTAL_WORD_DAYS = WORDS.reduce((m, w) => Math.max(m, w.day), 0);
+// xuchao: 词库以 word_entry 表为准(家长端可编辑);表空回退打包的 words.json,
+// 保证未灌种子数据的部署孩子端照常可用
+export async function allWords(): Promise<Word[]> {
+  const rows = await db.select().from(wordEntry).orderBy(asc(wordEntry.seq));
+  if (rows.length > 0) return rows.map((r) => ({ word: r.word, meaning: r.meaning, day: r.day, seq: r.seq }));
+  return raw as Word[];
+}
+
+export async function totalWordDays(): Promise<number> {
+  const ws = await allWords();
+  return ws.reduce((m, w) => Math.max(m, w.day), 0);
+}

 // 某一天的单词
-export function wordsByDay(day: number): Word[] {
-  return WORDS.filter((w) => w.day === day);
+export async function wordsByDay(day: number): Promise<Word[]> {
+  const ws = await allWords();
+  return ws.filter((w) => w.day === day);
 }

 // 标准发音(有道公共语音,美式 type=2 / 英式 type=1)
@@ -21,21 +35,22 @@ function lev(a: string, b: string): number {
    n = b.length;
  if (Math.abs(m - n) > 2) return 99;
  const dp = Array.from({ length: m + 1 }, (_, i) => [i, ...Array(n).fill(0)]);
-  for (let j = 0; j <= n; j++) dp[0][j] = j;
  for (let i = 1; i <= m; i++)
    for (let j = 1; j <= n; j++)
      dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
  return dp[m][n];
 }

-// 每日检测组卷(确定性):选最多 10 词,选中文释义,干扰项用相邻词的释义
+// 每日检测组卷(确定性):选最多 10 词,选中文释义,干扰项按全库位置偏移取释义
 export type WordTestQ = { word: string; options: string[]; answer: number };
-export function buildWordTest(day: number): WordTestQ[] {
-  const ws = wordsByDay(day);
-  const pick = ws.slice(0, 10);
+export async function buildWordTest(day: number): Promise<WordTestQ[]> {
+  const ws = await allWords();
+  const dayWords = ws.filter((w) => w.day === day);
+  const pick = dayWords.slice(0, 10);
  return pick.map((w) => {
+    const idx = ws.indexOf(w);
    const distractors = [1, 2, 3]
-      .map((off) => WORDS[(w.seq - 1 + off * 37) % WORDS.length].meaning)
+      .map((off) => ws[(idx + off * 37) % ws.length].meaning)
      .filter((m) => m && m !== w.meaning)
      .slice(0, 3);
    const options = [w.meaning || w.word, ...distractors];
@@ -46,10 +61,18 @@ export function buildWordTest(day: number): WordTestQ[] {
  });
 }

-export function similarWords(word: string, n = 3): Word[] {
-  return WORDS.filter((w) => w.word !== word)
+export async function similarWords(word: string, n = 3): Promise<Word[]> {
+  const ws = await allWords();
+  return ws
+    .filter((w) => w.word !== word)
    .map((w) => ({ w, d: lev(word, w.word) }))
    .sort((a, b) => a.d - b.d)
    .slice(0, n)
    .map((x) => x.w);
 }
+
+// 词库总数(家长端展示用)
+export async function countWordEntries(): Promise<number> {
+  const [r] = await db.select({ n: sql<number>`COUNT(*)` }).from(wordEntry);
+  return r.n;
+}
@@ -6,6 +6,7 @@ import type { AnswerValue } from "@/lib/grammar";

 // 各类题型的"用户作答"与"标准答案"可读文本
 export function answerText(q: QuizQ, a: AnswerValue | null | undefined): string {
+  if (q.type === "solve") return `拍照作答,得 ${q.solveSnap?.earned ?? 0} / ${q.points ?? 0} 分`;
  if (a == null) return "未作答";
  if (q.type === "fill") return String(a);
  if (q.type === "order") return Array.isArray(a) ? a.join(" ") : String(a);
@@ -14,6 +15,7 @@ export function answerText(q: QuizQ, a: AnswerValue | null | undefined): string
  return opts[Number(a)] ?? String(a);
 }
 export function correctText(q: QuizQ): string {
+  if (q.type === "solve") return q.reference ?? "";
  if (q.type === "fill") return (q.answers ?? []).join(" / ");
  if (q.type === "order") return (q.answer as string[]).join(" ");
  if (q.type === "match") return (q.pairs ?? []).map((p) => `${p[0]}→${p[1]}`).join("、");
@@ -23,6 +25,7 @@ export function correctText(q: QuizQ): string {

 // 错题入库(同一孩子同一来源同一题干去重)
 // sourceType:lesson/weekly=英语,mlesson/mweekly=数学,exam=考试卷
+// solveExtra:解答题的作答快照(照片 key + 逐评分点判定),并入题目 JSON 供错题本回看
 export async function recordWrong(
  childId: number,
  sourceType: "lesson" | "weekly" | "mlesson" | "mweekly" | "exam",
@@ -30,7 +33,9 @@ export async function recordWrong(
  sourceTitle: string,
  q: QuizQ,
  user: AnswerValue | null | undefined,
+  solveExtra?: NonNullable<QuizQ["solveSnap"]>,
 ) {
+  const stored: QuizQ = q.type === "solve" ? { ...q, solveSnap: solveExtra } : q;
  const rows = await db
    .select({ question: wrongBook.question })
    .from(wrongBook)
@@ -48,9 +53,9 @@ export async function recordWrong(
    sourceType,
    sourceId,
    sourceTitle,
-    question: JSON.stringify(q),
-    userAnswer: answerText(q, user),
-    correctAnswer: correctText(q),
+    question: JSON.stringify(stored),
+    userAnswer: answerText(stored, user),
+    correctAnswer: correctText(stored),
  });
 }
Author	SHA1	Message	Date
jacobxu666andClaude Opus 4.8	7a11a89031	新增积分系统:打卡/测试达标赚积分,纯累计可配置 - point_rule 规则表 + point_log 流水表(0008 迁移),唯一键防刷:同一事件首次达标才发放,重复静默返回 0 - 打卡分值随任务设置(模板/实例 points 字段,默认 10);测试类 6 种事件按规则表取值,各有默认分(单词 20/数学课 15/语法点 15/周测 50×2/考试通过 100) - 发放埋点 6 处:打卡、单词检测、数学课、语法知识点、英语/数学周测、考试通过;周测达标联动打卡实例不重复计分 - 孩子端:/kid 总积分徽章,新增 /points 积分页(总积分+流水),测验结果页即时显示「+N 积分」,周测结果页刷新后从流水取回已发积分 - 家长端:功能管理新增「积分管理」Section(规则分值配置+每孩子总积分/最近流水);任务管理内联编辑任务分值 - 修复:drizzle 将 mysql2 重复键错误包进 cause,沿错误链识别 ER_DUP_ENTRY Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-08-18 17:58:53 +08:00
jacobxu666andClaude Haiku 4.5	841f937b8e	docs: 家长中心待掌握错题查看设计文档家长概览「待掌握错题」卡片当前不可点击,设计为新建 /parent/wrongbook?kid=xx 页面(仅展示未掌握错题、家长可标记已掌握), 复用孩子端 WrongRow 组件,家庭归属防越权。 Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>	2026-08-18 09:29:01 +08:00
jacobxu666andClaude Opus 4.8	5f207e4a57	课程管理新增单词与数学思维内容编辑:单词词库落库(word_entry+0007迁移,表空回退words.json),家长端按天增删改单词;数学思维编辑器对标语法编辑器;课程管理加入两张入口卡片 Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-08-17 17:25:04 +08:00
jacobxu666andClaude Opus 4.8	ab84bec1b4	家长端课程管理移除跟读录音、语法检测分数、孩子错题本卡片,只保留课程编辑与每周检测成绩 Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-08-17 16:24:31 +08:00
jacobxu666andClaude Opus 4.8	f80a931ef0	新增解答题拍照判分:百炼 Qwen-VL 按评分点逐点判分,无 API Key 时演示判分回退;混合卷按真实分值加权计分;判分照片与评分点进错题本;补齐历史迁移缺口(0005 模板生效方式/0006 五张缺失表+grammar_progress point_id) Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-08-17 16:24:23 +08:00