feat: 团体奖牌 / 个人积分两个榜单的专属明细导出

用户答复「允许细化」——给另外两个榜单各做一份逐项来源导出（此前它们的「明细」共用
单位积分明细、个人榜连明细列都没有）。

- `GET /api/export/medals.xlsx` → `团体奖牌明细.xlsx`：总表 单位/大项/小项/组别/名次/奖牌/运动员-队
  + 每个有奖牌的单位一张分表（末尾小计 金X/银Y/铜Z）；无奖牌的单位不出分表。
  去重与牌色判定**完全交给 domain**（每组调 domain.BuildMedalStandings），导出侧只做
  「同一报名项归一组」，不复制任何计奖规则——双计通道只记一枚奖牌因此自动成立。
- `GET /api/export/athletes.xlsx` → `个人积分总明细.xlsx`：总表 单位/运动员/大项/小项/组别/
  名次/成绩/得分/来源 + 每个有得分的单位一张分表（按单位分，不按人分）。
  得分取**记到个人的原始分**（与个人积分榜同一口径，不看 count_to_team、不乘折算系数）。
- 管理端三个榜单的卡片头各一个导出入口（导出总明细 / 导出奖牌明细 / 导出个人明细），
  展开单位时明细卡头是「导出该单位明细」；导出页仍是 5 项，两个新导出只在积分榜页触发。

护栏（跨端点一致性，都有实测断言）：
- 奖牌明细逐单位与「团体奖牌榜」对齐，双计项目只出一行；
- 个人明细合计与「个人积分榜」一致，且把折算系数改成 0.5 后个人明细一分不变、单位总分变 5。

测试：服务端 12 包全绿（358 个测试函数）；前端 vue-tsc 通过、190 例全过；Console 18 文件。
docs/ 与 devdocs/ 同步（FAQ 到 Q72，含上一轮"个人积分榜不能导出"的修正）。

README.md

@@ -21,7 +21,7 @@
 - **运动员名册**：启用 / 停用 / **彻底删除**三档——「停用」保留全部历史数据、随时可启用；「彻底删除」把人员档案连同他名下的报名、成绩与积分流水一起删掉且不可恢复，并自动按新排序重算受影响小项的排名与积分（大屏同步更新）
 - **参赛单位名册**：启用 / 停用 / **彻底删除**三档——「停用」保留全部历史数据、随时可启用；「彻底删除」是**假删除**，只把单位从列表里移除（界面上没有恢复入口），它的报名、成绩、积分流水与名下运动员全部保留，**积分榜不会变化**；报名表里再次用到该单位编码会让它自动恢复
 - **赛事独立存档**：每个赛事一个独立项目目录，整包可导出/导入（含会标、背景图、单位 logo 与上传的字体），并可在管理端页内一键切换当前赛事
-- **结果导出**：Excel 总表、全部（多 sheet）、**全部（单页）**、分项成绩表、单位积分明细可分别导出；「积分榜」页还可导出**单位积分总明细**（总表 + 每个有数据的单位一张分表）与**单个单位的积分明细**
+- **结果导出**：Excel 总表、全部（多 sheet）、**全部（单页）**、分项成绩表、单位积分明细可分别导出；「积分榜」页三个榜单的卡片头各有自己的明细导出——单位总分榜**导出总明细**（总表 + 每个有数据的单位一张分表）、团体奖牌榜**导出奖牌明细**（逐枚奖牌列出来源）、个人积分榜**导出个人明细**（逐条得分来源，与个人榜一致且不受折算系数影响），展开单位还能**导出该单位明细**
 - **单位 logo**：积分榜、奖牌榜、分项成绩表与个人榜都会显示参赛单位 logo
 - **大屏字体可配**：标题字体与正文字体可在「系统设置 → 赛事信息 → 字体」里从四款内置字体中选，或上传自己的字体（ttf / otf / woff / woff2，单个不超过 20 MiB）；只作用于大屏，加载失败自动回落默认字体，字体文件随赛事项目包一起导出/导入
 

docs/上线检查清单.md

@@ -65,7 +65,7 @@
 
 - [ ] 录入员登录 → 录入一条成绩 → 存草稿 → 发布 → 大屏刷新
 - [ ] 撤销发布 → 修改 → 重新发布（历史记录里能看到链路）
-- [ ] 导出核对：「结果导出」里「全部」与「全部（单页）」都能正常下载（后者应是一个工作簿、只有一张表）；「积分榜」页点「导出总明细」得到 `单位积分总明细.xlsx`，展开某单位后点「导出该单位明细」得到 `单位积分明细.xlsx`
+- [ ] 导出核对：「结果导出」里「全部」与「全部（单页）」都能正常下载（后者应是一个工作簿、只有一张表）；「积分榜」页三个榜单的卡片头各有导出——单位总分榜「导出总明细」得到 `单位积分总明细.xlsx`、团体奖牌榜「导出奖牌明细」得到 `团体奖牌明细.xlsx`、个人积分榜「导出个人明细」得到 `个人积分总明细.xlsx`；展开某单位后还能点「导出该单位明细」得到 `单位积分明细.xlsx`
 - [ ] 断网 → 大屏仍显示缓存数据 → 恢复后自动补增量
 - [ ] 重启服务端 → Console 自动拉起
 

docs/使用手册.md

@@ -202,14 +202,17 @@
 
 - 团体奖牌榜显示金、银、铜与合计；
 - 个人积分榜显示运动员、单位、个人总分与奖牌数；
-- 团体奖牌榜那一列的「明细」展开的是**同一个单位积分明细面板**（见 8.1），不是奖牌专属明细；个人积分榜**没有明细列**。
+- 团体奖牌榜那一列的「明细」展开的是**同一个单位积分明细面板**（见 8.1），不是奖牌专属明细；但这份榜单本身有专属的逐枚奖牌导出（见 8.3）；
+- 个人积分榜**没有明细列**（不能点开下钻），但它的逐条得分来源也有专属导出（见 8.3）。
 
 ### 8.3 导出明细（xlsx）
 
-- **导出总明细**：页头右上角的按钮，导出 `单位积分总明细.xlsx`——一张带「单位」列的总表，外加每个**有数据**的单位一张分表；没有积分的单位不出分表；
-- **导出该单位明细**：右侧单位明细面板头部的按钮，先展开某个单位再点，导出 `单位积分明细.xlsx`（列：序号、大项、小项、组别、运动员、名次、成绩、来源、积分、备注，末行是「合计」）；
-- 团体奖牌榜展开的也是这个单位积分明细面板，所以同样用「导出该单位明细」导出；个人积分榜没有明细列，也就没有对应的导出；
-- 两个导出都是只读下载（访客也能用），不需要写权限；导出过程中按钮会变成「导出中…」并禁用，避免重复下载。
+- 三个榜单的**卡片头**各有一个导出按钮，按钮跟着当前页签切换；展开某个单位时，右侧明细卡头还有 **导出该单位明细**；
+- **导出总明细**（单位总分榜卡片头）：导出 `单位积分总明细.xlsx`——一张带「单位」列的总表，外加每个**有数据**的单位一张分表；没有积分的单位不出分表；
+- **导出奖牌明细**（团体奖牌榜卡片头）：导出 `团体奖牌明细.xlsx`——第一张总表逐枚奖牌列出「单位 / 大项 / 小项 / 组别 / 名次 / 奖牌 / 运动员、队」，`奖牌` 列是 `金牌` / `银牌` / `铜牌`；其后每个**有奖牌**的单位一张分表（列同上、去掉「单位」，末尾一行小计 `金 X / 银 Y / 铜 Z`），没有奖牌的单位不出分表。口径与「团体奖牌榜」一致：同一个报名项在「个人+团体」这类双计通道下只记一枚奖牌，不会重复计数；
+- **导出个人明细**（个人积分榜卡片头）：导出 `个人积分总明细.xlsx`——第一张总表逐条列出「单位 / 运动员 / 大项 / 小项 / 组别 / 名次 / 成绩 / 得分 / 来源」；其后每个**有得分**的单位一张分表（按单位分，不按人分），没有得分流水的人不出现在表里。`得分` 是记到个人的原始分，**与「个人积分榜」逐个数字一致，且不乘榜单口径里的个人项目得分折算系数**（那个系数只作用于单位总分）；
+- **导出该单位明细**（右侧单位明细面板头部）：先展开某个单位再点，导出 `单位积分明细.xlsx`（列：序号、大项、小项、组别、运动员、名次、成绩、来源、积分、备注，末行是「合计」）。团体奖牌榜展开的也是这个单位积分明细面板，所以想按单位逐条看时同样用它；
+- 这些导出都是只读下载（访客也能用），不需要写权限；导出过程中按钮会变成「导出中…」并禁用，避免重复下载。
 
 ### 8.4 推送明细到大屏
 
@@ -460,9 +463,12 @@
 | 全部（单页） | 所有单位、所有项目、所有成绩**平铺在一张表**里（一个工作簿只有一张表），适合筛选与二次统计 | `赛事成绩总表（单页）.xlsx` |
 | 分项成绩表 | 选择一个小项导出成绩与积分 | `分项成绩表.xlsx` |
 | 单位积分明细 | 选择一个单位，逐项列出得分来源 | `单位积分明细.xlsx` |
+| 团体奖牌明细 | **在「积分榜 → 团体奖牌榜」页操作**：逐枚奖牌列出单位 / 大项 / 小项 / 组别 / 名次 / 奖牌 / 运动员、队，每个有奖牌的单位一张分表（末尾小计） | `团体奖牌明细.xlsx` |
+| 个人积分总明细 | **在「积分榜 → 个人积分榜」页操作**：逐条列出单位 / 运动员 / 大项 / 小项 / 组别 / 名次 / 成绩 / 得分 / 来源，每个有得分的单位一张分表 | `个人积分总明细.xlsx` |
 
 - 「分项成绩表」需先选择小项，「单位积分明细」需先选择单位；
 - **「全部」与「全部（单页）」的区别**：两者内容同源，覆盖的都是全部小项的全部报名 / 成绩；「全部」把每个小项放成一张分表（多 sheet 工作簿），「全部（单页）」把所有行平铺进同一张表，每行前面补「大项 / 小项 / 组别」三列以便脱离表名也能看懂。单页表的列是：大项、小项、组别、名次、号码、单位、运动员/队、成绩、积分、状态、备注；
+- **「团体奖牌明细」与「个人积分总明细」不在本页**，在「积分榜」页对应榜单的卡片头点「导出奖牌明细」「导出个人明细」（见 8.3）；个人积分总明细里的「得分」与个人积分榜一致，不受榜单口径折算系数影响；
 - 导出文件由浏览器直接下载，表头、合并单元格与字体已按打印模板预设。
 
 ### 11.2 赛事项目包

docs/常见问题.md

@@ -219,7 +219,7 @@ Console 启动的多屏窗口默认每屏锁定一页。到「大屏控制」点
 ## 导出与导入
 
 **Q43：能导出哪些文件？**
-结果导出现在有五类 Excel：**总表**（`总积分榜.xlsx`）、**全部**（`赛事成绩总表.xlsx`，多 sheet）、**全部（单页）**（`赛事成绩总表（单页）.xlsx`，单张表平铺）、**分项成绩表**（`分项成绩表.xlsx`）、**单位积分明细**（`单位积分明细.xlsx`）；「积分榜」页另有**导出总明细**（`单位积分总明细.xlsx`）与**导出该单位明细**（`单位积分明细.xlsx`）。另外可导出赛事项目包（zip）与规则包（YAML）。
+结果导出页有五类 Excel：**总表**（`总积分榜.xlsx`）、**全部**（`赛事成绩总表.xlsx`，多 sheet）、**全部（单页）**（`赛事成绩总表（单页）.xlsx`，单张表平铺）、**分项成绩表**（`分项成绩表.xlsx`）、**单位积分明细**（`单位积分明细.xlsx`）。「积分榜」页另有四项：单位总分榜卡片头的**导出总明细**（`单位积分总明细.xlsx`）、团体奖牌榜卡片头的**导出奖牌明细**（`团体奖牌明细.xlsx`）、个人积分榜卡片头的**导出个人明细**（`个人积分总明细.xlsx`），以及展开单位后明细卡头的**导出该单位明细**（`单位积分明细.xlsx`）。另外可导出赛事项目包（zip）与规则包（YAML）。
 
 **Q44：导出文件保存在哪？**
 浏览器默认下载目录。服务端生成的临时包位于 `data\exports\`，下载完成后自动删除。
@@ -391,9 +391,19 @@ Console 启动的多屏窗口默认每屏锁定一页。到「大屏控制」点
 两种方式：
 
 1. **只导一个单位**：到「积分榜」页展开该单位的明细，点右侧明细面板头部的「导出该单位明细」，得到 `单位积分明细.xlsx`（逐条列出每一分的来源，末行是「合计」）；
-2. **一次导全部单位**：点「积分榜」页右上角的「导出总明细」，得到 `单位积分总明细.xlsx`——一张带「单位」列的总表，外加每个**有数据**的单位一张分表（没有积分的单位不出分表）。
+2. **一次导全部单位**：在「积分榜 → 单位总分榜」的**卡片头**点「导出总明细」，得到 `单位积分总明细.xlsx`——一张带「单位」列的总表，外加每个**有数据**的单位一张分表（没有积分的单位不出分表）。
 
-团体奖牌榜那一列的「明细」展开的是**同一个单位积分明细面板**，所以也用「导出该单位明细」。另外「导出 → 结果导出」里的「单位积分明细」也能先选一个单位再导出。这些导出都是只读下载，访客也能用。
+团体奖牌榜那一列的「明细」展开的仍是**同一个单位积分明细面板**，所以想按单位看时也可以在那上面点「导出该单位明细」；但团体奖牌榜本身另有专属的逐枚奖牌导出（卡片头「导出奖牌明细」，见 Q71），个人积分榜也有专属的逐条得分导出（卡片头「导出个人明细」，见 Q70、Q72）。另外「导出 → 结果导出」里的「单位积分明细」也能先选一个单位再导出。这些导出都是只读下载，访客也能用。
 
 **Q70：个人积分榜能导出明细吗？**
-不能。个人积分榜只有榜单（运动员、单位、个人总分与奖牌数），**没有明细列，也没有对应的明细导出**。需要看某个人 / 某个单位的得分来源时，用「导出总明细」或「导出该单位明细」：记到个人的流水会按折算系数并入所属单位的合计列出（见 Q14、Q18）。
+能。个人积分榜的**卡片头**有「导出个人明细」按钮，导出 `个人积分总明细.xlsx`：第一张总表逐条列出「单位 / 运动员 / 大项 / 小项 / 组别 / 名次 / 成绩 / 得分 / 来源」，其后每个**有得分**的单位一张分表（按单位分，不按人分；没有得分流水的人不出现在表里）。`得分` 是记到个人的原始分，与「个人积分榜」逐个数字一致，**不受榜单口径里的个人项目得分折算系数影响**（那个系数只作用于单位总分），详见 Q72。
+
+**Q71：团体奖牌榜能导出每一块奖牌的来源吗？**
+能。到「积分榜 → 团体奖牌榜」，点**卡片头**的「导出奖牌明细」，得到 `团体奖牌明细.xlsx`：
+
+- 第一张总表逐枚列出「单位 / 大项 / 小项 / 组别 / 名次 / 奖牌 / 运动员、队」，`奖牌` 列是 `金牌` / `银牌` / `铜牌`；
+- 其后每个**有奖牌**的单位一张分表，列与总表相同但去掉「单位」，末尾多一行小计 `金 X / 银 Y / 铜 Z`；没有奖牌的单位不出分表；
+- 口径与「团体奖牌榜」一致：同一个报名项在「个人+团体」这类双计通道下只记一枚奖牌，导出不会重复计数。
+
+**Q72：个人积分明细导出的数字跟个人积分榜对得上吗？会不会受榜单口径系数影响？**
+对得上，而且**不受系数影响**。「导出个人明细」（`个人积分总明细.xlsx`）里的 `得分` 是**记到个人的原始分**，与「个人积分榜」逐个数字一致；「基础数据 → 积分模板 → 榜单口径」里的个人项目得分折算系数（键名 `standings.individual_to_team_weight`，默认 1）只在汇总环节把个人分折算进单位总分，**不会改变个人明细里的数字**——比如把系数改成 0.5，个人明细的得分仍是原始分，只有单位总分变小（见 Q18）。

docs/部署指南.md

@@ -463,7 +463,7 @@ http://<主机IP>:19540/display
 - `uploads/`：**全部上传资源**——赛事会标、大屏会标、大屏背景图、各参赛单位 logo，以及**上传的字体**（放在 `uploads/fonts/` 下，见使用手册 14.3）。导入时会连文件一起落到新项目目录的 `uploads/`，切换过去后图片直接显示、字体直接可用，不用重新上传；
 - `rules.yaml`：当前规则包的一份 YAML 副本，便于单独复用到别的赛事；规则本身存在赛事库里，导入后即刻生效，这份只是副本。
 
-导出界面同一页的「结果导出」标签可以把最终结果导成 xlsx：**总表**（总积分榜 + 团体奖牌榜 + 个人积分奖牌榜，一个工作簿）、**全部**（总表 + 全部分项）、**分项成绩表**（按小项）、**单位积分明细**（按单位）四项各自可单独导出打印。
+导出界面同一页的「结果导出」标签可以把最终结果导成 xlsx：**总表**（总积分榜 + 团体奖牌榜 + 个人积分奖牌榜，一个工作簿）、**全部**（总表 + 全部分项）、**全部（单页）**（所有成绩平铺在一张表）、**分项成绩表**（按小项）、**单位积分明细**（按单位）各自可单独导出打印；「积分榜」页三个榜单的卡片头还各有明细导出（**导出总明细** / **导出奖牌明细** / **导出个人明细**，见使用手册 8.3）。
 
 导入与切换：
 

server/internal/export/athletes.go

@@ -0,0 +1,256 @@
+package export
+
+import (
+	"database/sql"
+	"fmt"
+	"io"
+	"sort"
+	"strconv"
+
+	"github.com/xuri/excelize/v2"
+
+	"git.yeij.top/AskaEth/Scoreboard/server/internal/domain"
+)
+
+// athleteDetailSheet 是「个人积分总明细」总表的表名。
+const athleteDetailSheet = "个人积分总明细"
+
+// AthleteDetailRow 是个人得分明细的一行：某运动员一次得分的来源。
+// Points 是记到个人的原始分，与个人积分榜同口径，不乘 individual_to_team_weight。
+type AthleteDetailRow struct {
+	AthleteName string
+	SportName   string
+	EventName   string
+	Category    string
+	Rank        int
+	ResultText  string
+	Points      float64
+	Source      string
+
+	// 排序键与所属单位，只在本包内用，不导出。
+	teamID     int64
+	sportSort  int
+	eventSort  int
+	catSort    int
+	eventID    int64
+	categoryID int64
+	ledgerID   int64
+}
+
+// AthleteDetailSheet 是某个单位的一张分表（按单位分表，不按人分）。
+type AthleteDetailSheet struct {
+	Team domain.Team
+	Rows []AthleteDetailRow
+}
+
+// AthleteDetailWorkbook 是「个人积分总明细」的内容：一张总表 + 每个有得分的单位一张分表。
+type AthleteDetailWorkbook struct {
+	Meta   Meta
+	Sheets []AthleteDetailSheet
+}
+
+var athleteDetailColumns = []column{
+	{"单位", 22, kindText},
+	{"运动员", 14, kindText},
+	{"大项", 14, kindText},
+	{"小项", 18, kindText},
+	{"组别", 14, kindText},
+	{"名次", 8, kindCenter},
+	{"成绩", 12, kindCenter},
+	{"得分", 8, kindNumber},
+	{"来源", 12, kindCenter},
+}
+
+// athleteTeamColumns 是单位分表的列：与总表一致，去掉「单位」列。
+var athleteTeamColumns = athleteDetailColumns[1:]
+
+// ExportAthleteDetailXLSX 导出个人得分明细，落盘到 dst。
+func ExportAthleteDetailXLSX(db *sql.DB, dst string, opts Options) error {
+	wb, err := LoadAthleteDetailWorkbook(db, opts)
+	if err != nil {
+		return err
+	}
+	f, err := athleteDetailFile(wb)
+	if err != nil {
+		return err
+	}
+	return saveWorkbook(f, dst)
+}
+
+// WriteAthleteDetailXLSX 把个人得分明细写成 xlsx 流，供 HTTP 直接响应下载。
+func WriteAthleteDetailXLSX(w io.Writer, wb AthleteDetailWorkbook) error {
+	f, err := athleteDetailFile(wb)
+	if err != nil {
+		return err
+	}
+	return f.Write(w)
+}
+
+func athleteDetailFile(wb AthleteDetailWorkbook) (*excelize.File, error) {
+	return buildWorkbook(athleteDetailSheet, func(f *excelize.File, st *styleSet) error {
+		meta := wb.Meta.normalized()
+		namer := &sheetNamer{}
+		master := namer.add(athleteDetailSheet)
+		if err := addSheet(f, master); err != nil {
+			return err
+		}
+		if err := writeSheet(f, st, master, meta, sheetTitle(meta, athleteDetailSheet),
+			athleteDetailColumns, athleteMasterRows(wb.Sheets)); err != nil {
+			return err
+		}
+
+		for _, s := range wb.Sheets {
+			unit := displayName(s.Team.Name, s.Team.ShortName)
+			name := namer.add(unit + "个人得分明细")
+			if err := addSheet(f, name); err != nil {
+				return err
+			}
+			if err := writeSheet(f, st, name, meta, sheetTitle(meta, unit+" · 个人得分明细"),
+				athleteTeamColumns, athleteTeamRows(s.Rows)); err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+}
+
+func athleteMasterRows(sheets []AthleteDetailSheet) [][]any {
+	var out [][]any
+	for _, s := range sheets {
+		unit := displayName(s.Team.Name, s.Team.ShortName)
+		for _, r := range s.Rows {
+			out = append(out, append([]any{unit}, athleteRow(r)...))
+		}
+	}
+	return out
+}
+
+func athleteTeamRows(rows []AthleteDetailRow) [][]any {
+	out := make([][]any, 0, len(rows))
+	for _, r := range rows {
+		out = append(out, athleteRow(r))
+	}
+	return out
+}
+
+func athleteRow(r AthleteDetailRow) []any {
+	rank := ""
+	if r.Rank > 0 {
+		rank = strconv.Itoa(r.Rank)
+	}
+	return []any{r.AthleteName, r.SportName, r.EventName, r.Category, rank, r.ResultText, r.Points, r.Source}
+}
+
+// LoadAthleteDetailWorkbook 读取记到个人的积分流水，逐条列出来源。
+//
+// 得分口径 = 个人积分榜：只取未作废且 athlete_id 非空的流水，points 保持原始分，
+// 既不乘 standings.individual_to_team_weight，也不按 count_to_team 过滤
+// （「个人+团体」项目的个人通道照样算在个人头上）。
+// 没有得分流水的运动员不会出现在任何一张表里。
+func LoadAthleteDetailWorkbook(db *sql.DB, opts Options) (AthleteDetailWorkbook, error) {
+	if db == nil {
+		return AthleteDetailWorkbook{}, ErrNoDatabase
+	}
+	meta, _, err := resolveMeta(db, opts.Meta)
+	if err != nil {
+		return AthleteDetailWorkbook{}, err
+	}
+	rows, err := loadAthleteDetailRows(db)
+	if err != nil {
+		return AthleteDetailWorkbook{}, err
+	}
+	byTeam := make(map[int64][]AthleteDetailRow, len(rows))
+	for _, r := range rows {
+		byTeam[r.teamID] = append(byTeam[r.teamID], r)
+	}
+
+	teams, err := loadTeams(db, false)
+	if err != nil {
+		return AthleteDetailWorkbook{}, err
+	}
+	order, err := teamStandingsOrder(db, opts)
+	if err != nil {
+		return AthleteDetailWorkbook{}, err
+	}
+	orderTeamsByStandings(teams, order)
+
+	sheets := make([]AthleteDetailSheet, 0, len(teams))
+	for _, t := range teams {
+		teamRows := byTeam[t.ID]
+		if len(teamRows) == 0 {
+			continue
+		}
+		sortAthleteDetailRows(teamRows)
+		sheets = append(sheets, AthleteDetailSheet{Team: t, Rows: teamRows})
+	}
+	return AthleteDetailWorkbook{Meta: meta, Sheets: sheets}, nil
+}
+
+func loadAthleteDetailRows(db *sql.DB) ([]AthleteDetailRow, error) {
+	rows, err := db.Query(`
+		SELECT l.team_id, COALESCE(a.name, ''),
+		       COALESCE(s.name, ''), COALESCE(e.name, ''), COALESCE(c.name, ''),
+		       COALESCE(r.rank, 0), COALESCE(r.result_text, ''), COALESCE(r.unit, ''),
+		       l.points, l.source_type,
+		       COALESCE(s.sort_order, 0), COALESCE(e.sort_order, 0), COALESCE(c.sort_order, 0),
+		       COALESCE(l.event_id, 0), COALESCE(c.id, 0), l.id
+		  FROM score_ledger l
+		  LEFT JOIN athletes a ON a.id = l.athlete_id
+		  LEFT JOIN events e ON e.id = l.event_id
+		  LEFT JOIN sports s ON s.id = e.sport_id
+		  LEFT JOIN entries en ON en.id = l.entry_id
+		  LEFT JOIN event_categories c ON c.id = en.category_id
+		  LEFT JOIN results r ON r.id = l.result_id
+		 WHERE l.athlete_id IS NOT NULL AND l.athlete_id <> 0 AND l.voided = 0`)
+	if err != nil {
+		return nil, fmt.Errorf("export: 读取个人得分明细: %w", err)
+	}
+	defer func() { _ = rows.Close() }()
+
+	var out []AthleteDetailRow
+	for rows.Next() {
+		var (
+			row        AthleteDetailRow
+			source     string
+			resultText string
+			unit       string
+		)
+		if err := rows.Scan(&row.teamID, &row.AthleteName,
+			&row.SportName, &row.EventName, &row.Category,
+			&row.Rank, &resultText, &unit, &row.Points, &source,
+			&row.sportSort, &row.eventSort, &row.catSort,
+			&row.eventID, &row.categoryID, &row.ledgerID); err != nil {
+			return nil, fmt.Errorf("export: 扫描个人得分明细: %w", err)
+		}
+		row.ResultText = displayResult(resultText, unit)
+		row.Source = sourceLabel(source)
+		out = append(out, row)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("export: 遍历个人得分明细: %w", err)
+	}
+	return out, nil
+}
+
+// sortAthleteDetailRows 按运动员分组、组内按项目既有顺序排列，读起来像「某人的得分清单」。
+func sortAthleteDetailRows(rows []AthleteDetailRow) {
+	sort.SliceStable(rows, func(i, j int) bool {
+		a, b := rows[i], rows[j]
+		switch {
+		case a.AthleteName != b.AthleteName:
+			return a.AthleteName < b.AthleteName
+		case a.sportSort != b.sportSort:
+			return a.sportSort < b.sportSort
+		case a.eventSort != b.eventSort:
+			return a.eventSort < b.eventSort
+		case a.eventID != b.eventID:
+			return a.eventID < b.eventID
+		case a.catSort != b.catSort:
+			return a.catSort < b.catSort
+		case a.categoryID != b.categoryID:
+			return a.categoryID < b.categoryID
+		default:
+			return a.ledgerID < b.ledgerID
+		}
+	})
+}

server/internal/export/athletes_test.go

@@ -0,0 +1,270 @@
+package export
+
+import (
+	"database/sql"
+	"path/filepath"
+	"testing"
+)
+
+func insertAthlete(t *testing.T, db *sql.DB, name string, teamID int64) int64 {
+	t.Helper()
+	res, err := db.Exec(`INSERT INTO athletes(name, gender, team_id) VALUES (?, '男', ?)`, name, teamID)
+	if err != nil {
+		t.Fatalf("造运动员 %s: %v", name, err)
+	}
+	id, err := res.LastInsertId()
+	if err != nil {
+		t.Fatalf("取运动员 id: %v", err)
+	}
+	return id
+}
+
+// 个人得分明细：总表 + 每个有得分的单位一张分表，逐条列出得分来源。
+func TestExportAthleteDetailXLSX(t *testing.T) {
+	db := openEventDB(t)
+	seedEvent(t, db) // T1 张三 10 分、T2 李四 8 分
+
+	dst := filepath.Join(t.TempDir(), "个人.xlsx")
+	if err := ExportAthleteDetailXLSX(db, dst, Options{}); err != nil {
+		t.Fatalf("导出个人得分明细: %v", err)
+	}
+	f := openXLSX(t, dst)
+	defer func() { _ = f.Close() }()
+
+	want := []string{"个人积分总明细", "第一分公司个人得分明细", "第二分公司个人得分明细"}
+	if got := f.GetSheetList(); !equalStrings(got, want) {
+		t.Fatalf("sheet 列表 = %v，期望 %v", got, want)
+	}
+
+	master, err := f.GetRows("个人积分总明细")
+	if err != nil {
+		t.Fatalf("读取总表: %v", err)
+	}
+	if len(master) != 6 { // 4 行版式 + 2 条流水
+		t.Fatalf("总表行数 = %d，期望 6", len(master))
+	}
+	header := []string{"单位", "运动员", "大项", "小项", "组别", "名次", "成绩", "得分", "来源"}
+	for i, want := range header {
+		if got := cell(master, 3, i); got != want {
+			t.Errorf("表头第 %d 列 = %q，期望 %q", i, got, want)
+		}
+	}
+	first := []string{"第一分公司", "张三", "田径", "100米跑", "男子", "1", "11.58 秒", "10", "成绩"}
+	for i, want := range first {
+		if got := cell(master, 4, i); got != want {
+			t.Errorf("首行第 %d 列 = %q，期望 %q", i, got, want)
+		}
+	}
+
+	// 单位分表 = 总表去掉「单位」列。
+	team, err := f.GetRows("第一分公司个人得分明细")
+	if err != nil {
+		t.Fatalf("读取单位分表: %v", err)
+	}
+	if len(team) != 5 { // 4 行版式 + 1 条流水
+		t.Fatalf("第一分公司分表行数 = %d，期望 5", len(team))
+	}
+	teamRow := []string{"张三", "田径", "100米跑", "男子", "1", "11.58 秒", "10", "成绩"}
+	for i, want := range teamRow {
+		if got := cell(team, 4, i); got != want {
+			t.Errorf("分表首行第 %d 列 = %q，期望 %q", i, got, want)
+		}
+	}
+}
+
+// 跨端点一致性：明细里某人的得分之和 == 个人积分榜上那个人的总分；
+// 且折算系数只影响单位总分，个人明细必须一分不动。
+func TestAthleteDetailMatchesBoardAndIgnoresWeight(t *testing.T) {
+	db := openEventDB(t)
+	seedEvent(t, db)
+
+	assertAthleteDetailMatchesBoard(t, db)
+
+	if _, err := db.Exec(`UPDATE settings SET value = '0.5' WHERE key = 'standings.individual_to_team_weight'`); err != nil {
+		t.Fatalf("修改折算系数: %v", err)
+	}
+	// 系数 0.5 下重跑：个人明细与个人积分榜仍然一致（都是原始分 10 / 8）。
+	assertAthleteDetailMatchesBoard(t, db)
+
+	// 对照：同一份数据上单位总分被折半，证明系数确实生效，不是设置没写进去。
+	board, err := LoadStandingsWorkbook(db, Options{})
+	if err != nil {
+		t.Fatalf("读取总积分榜: %v", err)
+	}
+	for _, row := range board.Team {
+		if row.TeamID == 1 && row.Points != 5 {
+			t.Errorf("系数 0.5 时单位 1 总分 = %v，期望 5", row.Points)
+		}
+	}
+
+	// 单元格里必须是原始分 10，而不是折算后的 5。
+	dst := filepath.Join(t.TempDir(), "个人.xlsx")
+	if err := ExportAthleteDetailXLSX(db, dst, Options{}); err != nil {
+		t.Fatalf("系数 0.5 下导出个人得分明细: %v", err)
+	}
+	f := openXLSX(t, dst)
+	defer func() { _ = f.Close() }()
+	rows, err := f.GetRows("第一分公司个人得分明细")
+	if err != nil {
+		t.Fatalf("读取分表: %v", err)
+	}
+	if got := cell(rows, 4, 6); got != "10" {
+		t.Errorf("系数 0.5 时个人明细得分 = %q，期望 10（原始分，不折算）", got)
+	}
+}
+
+// 只记单位的流水不算个人得分；count_to_team = 0 的流水照样算在个人头上。
+func TestAthleteDetailLedgerScope(t *testing.T) {
+	db := openEventDB(t)
+	seedEvent(t, db)
+	// 仅记单位（athlete_id 为空）：不进个人明细。
+	insertLedger(t, db, 1, 99)
+	// 「个人+团体」项目的个人通道流水：计入个人榜，但不进单位总分。
+	if _, err := db.Exec(`INSERT INTO score_ledger(team_id, athlete_id, event_id, entry_id, result_id,
+	                          source_type, source_id, points, count_to_team)
+	                      VALUES (1, 1, 1, 1, 1, 'result', 1, 7, 0)`); err != nil {
+		t.Fatalf("写入个人通道流水: %v", err)
+	}
+
+	wb := athleteDetailWorkbook(t, db)
+	if got := athletePointsFromDetail(wb, "张三"); got != 17 {
+		t.Errorf("张三明细得分 = %v，期望 17（10 + 只记个人的 7）", got)
+	}
+	board := athletePointsFromBoard(t, db)
+	if board[1] != 17 {
+		t.Errorf("个人积分榜张三总分 = %v，期望 17", board[1])
+	}
+	for _, s := range wb.Sheets {
+		for _, r := range s.Rows {
+			if r.Points == 99 {
+				t.Errorf("仅记单位的流水不应出现在个人明细: %+v", r)
+			}
+		}
+	}
+}
+
+// 没有得分流水的运动员不出现在任何一张表里。
+func TestAthleteDetailSkipsAthleteWithoutLedger(t *testing.T) {
+	db := openEventDB(t)
+	seedEvent(t, db)
+	insertAthlete(t, db, "王五", 1)
+
+	dst := filepath.Join(t.TempDir(), "个人.xlsx")
+	if err := ExportAthleteDetailXLSX(db, dst, Options{}); err != nil {
+		t.Fatalf("导出个人得分明细: %v", err)
+	}
+	f := openXLSX(t, dst)
+	defer func() { _ = f.Close() }()
+	for _, name := range f.GetSheetList() {
+		rows, err := f.GetRows(name)
+		if err != nil {
+			t.Fatalf("读取 %s: %v", name, err)
+		}
+		for r := range rows {
+			for c := 0; c < 9; c++ {
+				if cell(rows, r, c) == "王五" {
+					t.Errorf("%s 第 %d 行出现了无得分的运动员", name, r)
+				}
+			}
+		}
+	}
+}
+
+// 一条个人流水都没有时不报错：只有总表，能重新解析。
+func TestExportAthleteDetailEmptyEvent(t *testing.T) {
+	db := openEventDB(t)
+	insertTeam(t, db, "T1", "第一分公司", "一公司", 1, true)
+
+	dst := filepath.Join(t.TempDir(), "个人.xlsx")
+	if err := ExportAthleteDetailXLSX(db, dst, Options{}); err != nil {
+		t.Fatalf("空赛事导出个人得分明细: %v", err)
+	}
+	f := openXLSX(t, dst)
+	defer func() { _ = f.Close() }()
+	if got := f.GetSheetList(); !equalStrings(got, []string{"个人积分总明细"}) {
+		t.Fatalf("sheet 列表 = %v，期望只有总表", got)
+	}
+	rows, err := f.GetRows("个人积分总明细")
+	if err != nil {
+		t.Fatalf("读取总表: %v", err)
+	}
+	if len(rows) != 4 {
+		t.Fatalf("总表行数 = %d，期望 4", len(rows))
+	}
+	if got := cell(rows, 3, 0); got != "单位" {
+		t.Errorf("表头首列 = %q，期望 单位", got)
+	}
+}
+
+func athleteDetailWorkbook(t *testing.T, db *sql.DB) AthleteDetailWorkbook {
+	t.Helper()
+	wb, err := LoadAthleteDetailWorkbook(db, Options{})
+	if err != nil {
+		t.Fatalf("读取个人得分明细: %v", err)
+	}
+	return wb
+}
+
+// athletePointsFromBoard 是「个人积分榜」端点同源的口径：domain.BuildAthleteStandings 的总分。
+func athletePointsFromBoard(t *testing.T, db *sql.DB) map[int64]float64 {
+	t.Helper()
+	wb, err := LoadStandingsWorkbook(db, Options{})
+	if err != nil {
+		t.Fatalf("读取个人积分榜: %v", err)
+	}
+	out := make(map[int64]float64, len(wb.Athlete))
+	for _, row := range wb.Athlete {
+		out[row.AthleteID] = row.Points
+	}
+	return out
+}
+
+func athletePointsFromDetail(wb AthleteDetailWorkbook, name string) float64 {
+	var total float64
+	for _, s := range wb.Sheets {
+		for _, r := range s.Rows {
+			if r.AthleteName == name {
+				total += r.Points
+			}
+		}
+	}
+	return total
+}
+
+// assertAthleteDetailMatchesBoard 逐人比对：明细得分之和 == 个人积分榜总分；
+// 并且两边的人必须一一对应（榜单上的人都有明细，明细里的人都在榜上）。
+func assertAthleteDetailMatchesBoard(t *testing.T, db *sql.DB) {
+	t.Helper()
+	wb := athleteDetailWorkbook(t, db)
+	board, err := LoadStandingsWorkbook(db, Options{})
+	if err != nil {
+		t.Fatalf("读取个人积分榜: %v", err)
+	}
+	byName := make(map[string]float64, len(board.Athlete))
+	for _, row := range board.Athlete {
+		byName[row.Name] = row.Points
+	}
+
+	detailNames := make(map[string]bool)
+	for _, s := range wb.Sheets {
+		for _, r := range s.Rows {
+			detailNames[r.AthleteName] = true
+		}
+	}
+	for name, want := range byName {
+		if !detailNames[name] {
+			t.Errorf("个人积分榜上的 %q 没有明细行", name)
+			continue
+		}
+		got := athletePointsFromDetail(wb, name)
+		t.Logf("运动员 %q：明细合计 %v，个人积分榜 %v", name, got, want)
+		if got != want {
+			t.Errorf("运动员 %q：明细合计 %v，个人积分榜 %v", name, got, want)
+		}
+	}
+	for name := range detailNames {
+		if _, ok := byName[name]; !ok {
+			t.Errorf("明细里的运动员 %q 不在个人积分榜上", name)
+		}
+	}
+}

server/internal/export/medals.go

@@ -0,0 +1,370 @@
+package export
+
+import (
+	"database/sql"
+	"fmt"
+	"io"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/xuri/excelize/v2"
+
+	"git.yeij.top/AskaEth/Scoreboard/server/internal/domain"
+)
+
+// medalDetailSheet 是「团体奖牌明细」总表的表名。
+const medalDetailSheet = "团体奖牌明细"
+
+// 奖牌文案：与名次 1/2/3 一一对应。
+const (
+	medalGold   = "金牌"
+	medalSilver = "银牌"
+	medalBronze = "铜牌"
+)
+
+// MedalDetailRow 是团体奖牌明细的一行：某单位的一块奖牌来自哪个小项/组别/名次。
+type MedalDetailRow struct {
+	SportName   string
+	EventName   string
+	Category    string
+	Rank        int
+	Medal       string
+	Participant string
+
+	// 排序键，只在本包内用，不导出。
+	sportSort  int
+	eventSort  int
+	catSort    int
+	eventID    int64
+	categoryID int64
+	resultID   int64
+}
+
+// MedalDetailSheet 是某个有奖牌的单位的一张分表。
+type MedalDetailSheet struct {
+	Team domain.Team
+	Rows []MedalDetailRow
+}
+
+// MedalDetailWorkbook 是「团体奖牌明细」的内容：一张总表 + 每个有奖牌的单位一张分表。
+type MedalDetailWorkbook struct {
+	Meta   Meta
+	Sheets []MedalDetailSheet
+}
+
+var medalDetailColumns = []column{
+	{"单位", 22, kindText},
+	{"大项", 14, kindText},
+	{"小项", 18, kindText},
+	{"组别", 14, kindText},
+	{"名次", 8, kindCenter},
+	{"奖牌", 8, kindCenter},
+	{"运动员/队", 18, kindText},
+}
+
+// medalTeamColumns 是单位分表的列：与总表一致，去掉「单位」列。
+var medalTeamColumns = medalDetailColumns[1:]
+
+// ExportMedalDetailXLSX 导出团体奖牌明细，落盘到 dst。
+func ExportMedalDetailXLSX(db *sql.DB, dst string, opts Options) error {
+	wb, err := LoadMedalDetailWorkbook(db, opts)
+	if err != nil {
+		return err
+	}
+	f, err := medalDetailFile(wb)
+	if err != nil {
+		return err
+	}
+	return saveWorkbook(f, dst)
+}
+
+// WriteMedalDetailXLSX 把团体奖牌明细写成 xlsx 流，供 HTTP 直接响应下载。
+func WriteMedalDetailXLSX(w io.Writer, wb MedalDetailWorkbook) error {
+	f, err := medalDetailFile(wb)
+	if err != nil {
+		return err
+	}
+	return f.Write(w)
+}
+
+func medalDetailFile(wb MedalDetailWorkbook) (*excelize.File, error) {
+	return buildWorkbook(medalDetailSheet, func(f *excelize.File, st *styleSet) error {
+		meta := wb.Meta.normalized()
+		namer := &sheetNamer{}
+		master := namer.add(medalDetailSheet)
+		if err := addSheet(f, master); err != nil {
+			return err
+		}
+		if err := writeSheet(f, st, master, meta, sheetTitle(meta, medalDetailSheet),
+			medalDetailColumns, medalMasterRows(wb.Sheets)); err != nil {
+			return err
+		}
+
+		for _, s := range wb.Sheets {
+			unit := displayName(s.Team.Name, s.Team.ShortName)
+			name := namer.add(unit + "奖牌明细")
+			if err := addSheet(f, name); err != nil {
+				return err
+			}
+			if err := writeSheet(f, st, name, meta, sheetTitle(meta, unit+" · 奖牌明细"),
+				medalTeamColumns, medalTeamRows(s.Rows)); err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+}
+
+func medalMasterRows(sheets []MedalDetailSheet) [][]any {
+	var out [][]any
+	for _, s := range sheets {
+		unit := displayName(s.Team.Name, s.Team.ShortName)
+		for _, r := range s.Rows {
+			out = append(out, append([]any{unit}, medalRow(r)...))
+		}
+	}
+	return out
+}
+
+// medalTeamRows 单位分表：逐项奖牌行 + 末尾一行小计（金/银/铜数量）。
+func medalTeamRows(rows []MedalDetailRow) [][]any {
+	out := make([][]any, 0, len(rows)+1)
+	var gold, silver, bronze int
+	for _, r := range rows {
+		switch r.Medal {
+		case medalGold:
+			gold++
+		case medalSilver:
+			silver++
+		case medalBronze:
+			bronze++
+		}
+		out = append(out, medalRow(r))
+	}
+	// 没有奖牌的单位不会进 Sheets，这里的合计行必然跟着数据行；列序 大项/小项/组别/名次/奖牌/运动员-队。
+	return append(out, []any{"小计", "", "", "", fmt.Sprintf("金 %d / 银 %d / 铜 %d", gold, silver, bronze), ""})
+}
+
+func medalRow(r MedalDetailRow) []any {
+	rank := ""
+	if r.Rank > 0 {
+		rank = strconv.Itoa(r.Rank)
+	}
+	return []any{r.SportName, r.EventName, r.Category, rank, r.Medal, r.Participant}
+}
+
+// LoadMedalDetailWorkbook 读取全部奖牌来源。
+// 单位顺序沿用「团体奖牌榜」（与单位总分榜同序），没有奖牌的单位不出分表。
+func LoadMedalDetailWorkbook(db *sql.DB, opts Options) (MedalDetailWorkbook, error) {
+	if db == nil {
+		return MedalDetailWorkbook{}, ErrNoDatabase
+	}
+	meta, settings, err := resolveMeta(db, opts.Meta)
+	if err != nil {
+		return MedalDetailWorkbook{}, err
+	}
+	// 名次输入与榜单同源：loadRanked 只取已发布、有效、计分小项的名次。
+	ranked, err := loadRanked(db)
+	if err != nil {
+		return MedalDetailWorkbook{}, err
+	}
+	excludeTeam := strings.EqualFold(strings.TrimSpace(settings["standings.medal_counts_team_events"]), "false")
+	hits := medalHits(ranked, excludeTeam)
+	ctx, err := loadMedalContext(db)
+	if err != nil {
+		return MedalDetailWorkbook{}, err
+	}
+	teams, err := loadTeams(db, false)
+	if err != nil {
+		return MedalDetailWorkbook{}, err
+	}
+	order, err := teamStandingsOrder(db, opts)
+	if err != nil {
+		return MedalDetailWorkbook{}, err
+	}
+	orderTeamsByStandings(teams, order)
+
+	sheets := make([]MedalDetailSheet, 0, len(teams))
+	for _, t := range teams {
+		rows := medalRowsOfTeam(t.ID, hits, ctx)
+		if len(rows) == 0 {
+			continue
+		}
+		sheets = append(sheets, MedalDetailSheet{Team: t, Rows: rows})
+	}
+	return MedalDetailWorkbook{Meta: meta, Sheets: sheets}, nil
+}
+
+// medalHit 是一枚奖牌：来自哪条成绩、什么名次、什么牌。
+type medalHit struct {
+	resultID int64
+	rank     int
+	medal    string
+}
+
+// medalHits 逐「报名项」判定获奖单位。
+//
+// 同一报名项在多条计分通道下会展开成多条名次，只能记一枚奖牌——选通道、联队份额展开、
+// 名次换牌色这些规则都交给 domain 的团体奖牌榜函数（domain.BuildMedalStandings）判定，
+// 导出侧不复制计奖规则。传入的单位/流水/运动员都为空，返回的行只可能来自该报名项的奖牌。
+func medalHits(ranked []domain.RankedResult, excludeTeam bool) map[int64][]medalHit {
+	out := make(map[int64][]medalHit)
+	for _, group := range medalGroups(ranked) {
+		if len(group) == 0 {
+			continue
+		}
+		rows := domain.BuildMedalStandings(domain.StandingsInput{
+			Ranked:                 group,
+			ExcludeTeamEventMedals: excludeTeam,
+		})
+		rr := group[0]
+		for _, row := range rows {
+			for i := 0; i < row.Gold; i++ {
+				out[row.TeamID] = append(out[row.TeamID], medalHit{rr.ResultID, 1, medalGold})
+			}
+			for i := 0; i < row.Silver; i++ {
+				out[row.TeamID] = append(out[row.TeamID], medalHit{rr.ResultID, 2, medalSilver})
+			}
+			for i := 0; i < row.Bronze; i++ {
+				out[row.TeamID] = append(out[row.TeamID], medalHit{rr.ResultID, 3, medalBronze})
+			}
+		}
+	}
+	return out
+}
+
+// medalGroupKey 与 domain 的奖牌去重键同构：同一小项、同一组别的同一报名项只记一枚奖牌。
+// 聚合通道不对应单条报名项（entryID = 0）时退回「名次主体」，仍无法识别主体时每条自成一枚。
+type medalGroupKey struct {
+	eventID    int64
+	categoryID int64
+	entryID    int64
+	scope      domain.Scope
+	subject    int64
+	unique     int
+}
+
+func medalGroups(ranked []domain.RankedResult) [][]domain.RankedResult {
+	index := make(map[medalGroupKey]int, len(ranked))
+	var groups [][]domain.RankedResult
+	degenerate := 0
+	for _, rr := range ranked {
+		k := medalGroupKey{eventID: rr.EventID, categoryID: rr.CategoryID, entryID: rr.EntryID}
+		if k.entryID == 0 {
+			k.scope = rr.Scope
+			if rr.Scope == domain.ScopeAthlete {
+				k.subject = rr.AthleteID
+			} else {
+				k.subject = rr.TeamID
+			}
+			if k.subject == 0 {
+				degenerate++
+				k.unique = degenerate
+			}
+		}
+		i, ok := index[k]
+		if !ok {
+			i = len(groups)
+			index[k] = i
+			groups = append(groups, nil)
+		}
+		groups[i] = append(groups[i], rr)
+	}
+	return groups
+}
+
+// medalContext 是一条成绩的展示字段与排序键。
+type medalContext struct {
+	sportName   string
+	eventName   string
+	category    string
+	participant string
+	sportSort   int
+	eventSort   int
+	catSort     int
+	eventID     int64
+	categoryID  int64
+}
+
+func loadMedalContext(db *sql.DB) (map[int64]medalContext, error) {
+	rows, err := db.Query(`
+		SELECT r.id, COALESCE(s.name, ''), e.name, COALESCE(c.name, ''),
+		       COALESCE(a.name, ''), COALESCE(en.member_names, ''),
+		       COALESCE(s.sort_order, 0), e.sort_order, COALESCE(c.sort_order, 0),
+		       e.id, COALESCE(c.id, 0)
+		  FROM results r
+		  JOIN entries en ON en.id = r.entry_id
+		  JOIN events e ON e.id = r.event_id
+		  LEFT JOIN sports s ON s.id = e.sport_id
+		  LEFT JOIN event_categories c ON c.id = en.category_id
+		  LEFT JOIN athletes a ON a.id = en.athlete_id`)
+	if err != nil {
+		return nil, fmt.Errorf("export: 读取奖牌来源: %w", err)
+	}
+	defer func() { _ = rows.Close() }()
+
+	out := make(map[int64]medalContext)
+	for rows.Next() {
+		var (
+			resultID    int64
+			athleteName string
+			memberJSON  string
+			c           medalContext
+		)
+		if err := rows.Scan(&resultID, &c.sportName, &c.eventName, &c.category,
+			&athleteName, &memberJSON, &c.sportSort, &c.eventSort, &c.catSort,
+			&c.eventID, &c.categoryID); err != nil {
+			return nil, fmt.Errorf("export: 扫描奖牌来源: %w", err)
+		}
+		c.participant = participantName(athleteName, memberJSON)
+		out[resultID] = c
+	}
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("export: 遍历奖牌来源: %w", err)
+	}
+	return out, nil
+}
+
+// medalRowsOfTeam 把某单位的奖牌拼成展示行，按大项/小项/组别/名次的既有顺序排列。
+func medalRowsOfTeam(teamID int64, hits map[int64][]medalHit, ctx map[int64]medalContext) []MedalDetailRow {
+	list := hits[teamID]
+	rows := make([]MedalDetailRow, 0, len(list))
+	for _, h := range list {
+		c := ctx[h.resultID]
+		rows = append(rows, MedalDetailRow{
+			SportName:   c.sportName,
+			EventName:   c.eventName,
+			Category:    c.category,
+			Rank:        h.rank,
+			Medal:       h.medal,
+			Participant: c.participant,
+			sportSort:   c.sportSort,
+			eventSort:   c.eventSort,
+			catSort:     c.catSort,
+			eventID:     c.eventID,
+			categoryID:  c.categoryID,
+			resultID:    h.resultID,
+		})
+	}
+	sort.SliceStable(rows, func(i, j int) bool {
+		a, b := rows[i], rows[j]
+		switch {
+		case a.sportSort != b.sportSort:
+			return a.sportSort < b.sportSort
+		case a.eventSort != b.eventSort:
+			return a.eventSort < b.eventSort
+		case a.eventID != b.eventID:
+			return a.eventID < b.eventID
+		case a.catSort != b.catSort:
+			return a.catSort < b.catSort
+		case a.categoryID != b.categoryID:
+			return a.categoryID < b.categoryID
+		case a.Rank != b.Rank:
+			return a.Rank < b.Rank
+		default:
+			return a.resultID < b.resultID
+		}
+	})
+	return rows
+}

server/internal/export/medals_test.go

@@ -0,0 +1,242 @@
+package export
+
+import (
+	"database/sql"
+	"path/filepath"
+	"testing"
+)
+
+// addBronzeEntry 给 seedEvent 的小项补一条第 3 名，让一块金牌之外还有银、铜。
+func addBronzeEntry(t *testing.T, db *sql.DB) {
+	t.Helper()
+	// entries 对（组别，单位，运动员）唯一，第 3 名要再派一名运动员。
+	stmts := []string{
+		`INSERT INTO athletes(name, gender, team_id) VALUES ('王六', '男', 2)`,
+		`INSERT INTO entries(event_id, category_id, team_id, athlete_id, bib) VALUES (1, 1, 2, 3, '103')`,
+		`INSERT INTO results(event_id, entry_id, rank, result_text, result_value, unit, state)
+		 VALUES (1, 3, 3, '12.10', 12.10, 's', 'published')`,
+	}
+	for _, s := range stmts {
+		if _, err := db.Exec(s); err != nil {
+			t.Fatalf("造数据 %q: %v", s, err)
+		}
+	}
+}
+
+// 团体奖牌明细：总表逐块列出，每个有奖牌的单位一张分表，分表末尾一行小计。
+func TestExportMedalDetailXLSX(t *testing.T) {
+	db := openEventDB(t)
+	seedEvent(t, db) // T1 第 1 名、T2 第 2 名
+	addBronzeEntry(t, db)
+
+	dst := filepath.Join(t.TempDir(), "奖牌.xlsx")
+	if err := ExportMedalDetailXLSX(db, dst, Options{}); err != nil {
+		t.Fatalf("导出团体奖牌明细: %v", err)
+	}
+	f := openXLSX(t, dst)
+	defer func() { _ = f.Close() }()
+
+	want := []string{"团体奖牌明细", "第一分公司奖牌明细", "第二分公司奖牌明细"}
+	if got := f.GetSheetList(); !equalStrings(got, want) {
+		t.Fatalf("sheet 列表 = %v，期望 %v", got, want)
+	}
+
+	master, err := f.GetRows("团体奖牌明细")
+	if err != nil {
+		t.Fatalf("读取总表: %v", err)
+	}
+	// 4 行版式 + 3 块奖牌
+	if len(master) != 7 {
+		t.Fatalf("总表行数 = %d，期望 7", len(master))
+	}
+	header := []string{"单位", "大项", "小项", "组别", "名次", "奖牌", "运动员/队"}
+	for i, want := range header {
+		if got := cell(master, 3, i); got != want {
+			t.Errorf("表头第 %d 列 = %q，期望 %q", i, got, want)
+		}
+	}
+	first := []string{"第一分公司", "田径", "100米跑", "男子", "1", "金牌", "张三"}
+	for i, want := range first {
+		if got := cell(master, 4, i); got != want {
+			t.Errorf("首行第 %d 列 = %q，期望 %q", i, got, want)
+		}
+	}
+	if got := cell(master, 5, 5); got != "银牌" {
+		t.Errorf("第二行奖牌 = %q，期望 银牌", got)
+	}
+	if got := cell(master, 6, 5); got != "铜牌" {
+		t.Errorf("第三行奖牌 = %q，期望 铜牌", got)
+	}
+	if got := cell(master, 6, 0); got != "第二分公司" {
+		t.Errorf("第三行单位 = %q，期望 第二分公司", got)
+	}
+
+	// 分表列 = 总表去掉「单位」列 + 末尾小计。
+	gold, err := f.GetRows("第一分公司奖牌明细")
+	if err != nil {
+		t.Fatalf("读取金牌单位分表: %v", err)
+	}
+	if len(gold) != 6 { // 4 行版式 + 1 块奖牌 + 小计
+		t.Fatalf("第一分公司分表行数 = %d，期望 6", len(gold))
+	}
+	if got := cell(gold, 3, 0); got != "大项" {
+		t.Errorf("分表表头首列 = %q，期望 大项", got)
+	}
+	if got := cell(gold, 4, 5); got != "张三" {
+		t.Errorf("分表首行运动员 = %q，期望 张三", got)
+	}
+	if got := cell(gold, 5, 0); got != "小计" {
+		t.Errorf("分表小计行首列 = %q，期望 小计", got)
+	}
+	if got := cell(gold, 5, 4); got != "金 1 / 银 0 / 铜 0" {
+		t.Errorf("分表小计 = %q，期望 金 1 / 银 0 / 铜 0", got)
+	}
+
+	silver, err := f.GetRows("第二分公司奖牌明细")
+	if err != nil {
+		t.Fatalf("读取银铜单位分表: %v", err)
+	}
+	if len(silver) != 7 { // 4 行版式 + 银、铜各 1 块 + 小计
+		t.Fatalf("第二分公司分表行数 = %d，期望 7", len(silver))
+	}
+	if got := cell(silver, 6, 4); got != "金 0 / 银 1 / 铜 1" {
+		t.Errorf("分表小计 = %q，期望 金 0 / 银 1 / 铜 1", got)
+	}
+}
+
+// 奖牌明细必须与团体奖牌榜逐单位对得上，包括「个人+团体」双计项目只记一枚奖牌。
+func TestMedalDetailMatchesBoard(t *testing.T) {
+	db := openEventDB(t)
+	seedEvent(t, db)
+	addBronzeEntry(t, db)
+	// 再造一个双计项目：同一条成绩在 athlete + team 两条通道下各产出一条名次。
+	stmts := []string{
+		`INSERT INTO events(sport_id, code, name, event_type, result_mode, result_type, compare, status)
+		 VALUES (1, 'E2', '100米跑（双计）', 'individual_team', 'auto', 'time', 'asc', 'published')`,
+		`INSERT INTO event_categories(event_id, name, sort_order) VALUES (2, '男子', 1)`,
+		`INSERT INTO event_score_channels(event_id, scope, basis, profile_id)
+		 SELECT 2, 'athlete', 'result', id FROM scoring_profiles WHERE code = 'individual_top6'`,
+		`INSERT INTO event_score_channels(event_id, scope, basis, profile_id)
+		 SELECT 2, 'team', 'result', id FROM scoring_profiles WHERE code = 'team_top6'`,
+		`INSERT INTO entries(event_id, category_id, team_id, athlete_id, bib) VALUES (2, 2, 1, 1, '301')`,
+		`INSERT INTO results(event_id, entry_id, rank, result_text, result_value, unit, state)
+		 SELECT 2, id, 1, '11.00', 11.00, 's', 'published' FROM entries WHERE event_id = 2`,
+	}
+	for _, s := range stmts {
+		if _, err := db.Exec(s); err != nil {
+			t.Fatalf("造数据 %q: %v", s, err)
+		}
+	}
+
+	wb, err := LoadMedalDetailWorkbook(db, Options{})
+	if err != nil {
+		t.Fatalf("读取奖牌明细: %v", err)
+	}
+	board, err := LoadStandingsWorkbook(db, Options{})
+	if err != nil {
+		t.Fatalf("读取团体奖牌榜: %v", err)
+	}
+
+	// 双计项目只贡献一枚金牌（去重成一条），不是两条。
+	dual := 0
+	total := 0
+	for _, s := range wb.Sheets {
+		for _, r := range s.Rows {
+			total++
+			if r.EventName == "100米跑（双计）" {
+				dual++
+			}
+		}
+	}
+	if dual != 1 {
+		t.Errorf("双计项目奖牌明细行数 = %d，期望 1（同一报名项只记一枚）", dual)
+	}
+	if total != 4 { // 3 块单通道奖牌 + 1 块双计奖牌
+		t.Errorf("奖牌明细总行数 = %d，期望 4", total)
+	}
+
+	for i, row := range board.Medal {
+		gold, silver, bronze := medalCountsOf(wb, row.TeamID)
+		t.Logf("单位 %d：明细 金%d/银%d/铜%d，榜单 金%d/银%d/铜%d", row.TeamID, gold, silver, bronze, row.Gold, row.Silver, row.Bronze)
+		if gold != row.Gold || silver != row.Silver || bronze != row.Bronze {
+			t.Errorf("单位 %d 奖牌明细 金%d/银%d/铜%d，榜单 金%d/银%d/铜%d（榜第 %d 名）",
+				row.TeamID, gold, silver, bronze, row.Gold, row.Silver, row.Bronze, i+1)
+		}
+		if gold+silver+bronze == 0 {
+			// 榜上有名字但没有奖牌的单位不应出现在明细里。
+			for _, s := range wb.Sheets {
+				if s.Team.ID == row.TeamID {
+					t.Errorf("无奖牌单位 %d 不应出分表", row.TeamID)
+				}
+			}
+		}
+	}
+}
+
+// 没有奖牌（甚至没有小项）时不报错，返回只有表头的总表。
+func TestExportMedalDetailEmptyEvent(t *testing.T) {
+	db := openEventDB(t)
+	insertTeam(t, db, "T1", "第一分公司", "一公司", 1, true)
+
+	dst := filepath.Join(t.TempDir(), "奖牌.xlsx")
+	if err := ExportMedalDetailXLSX(db, dst, Options{}); err != nil {
+		t.Fatalf("无奖牌导出: %v", err)
+	}
+	f := openXLSX(t, dst)
+	defer func() { _ = f.Close() }()
+
+	if got := f.GetSheetList(); !equalStrings(got, []string{"团体奖牌明细"}) {
+		t.Fatalf("sheet 列表 = %v，期望只有总表", got)
+	}
+	rows, err := f.GetRows("团体奖牌明细")
+	if err != nil {
+		t.Fatalf("读取总表: %v", err)
+	}
+	if len(rows) != 4 { // 标题 / 副标题 / 空行 / 表头
+		t.Fatalf("总表行数 = %d，期望 4", len(rows))
+	}
+	if got := cell(rows, 3, 0); got != "单位" {
+		t.Errorf("表头首列 = %q，期望 单位", got)
+	}
+}
+
+// 已隐藏但有奖牌的单位在榜上，导出要与榜单一致地保留它。
+func TestMedalDetailKeepsHiddenTeamWithMedals(t *testing.T) {
+	db := openEventDB(t)
+	seedEvent(t, db)
+	silent := insertTeam(t, db, "H2", "被隐藏且无牌", "隐藏二", 4, false)
+	hideTeam(t, db, silent)
+
+	wb, err := LoadMedalDetailWorkbook(db, Options{})
+	if err != nil {
+		t.Fatalf("读取奖牌明细: %v", err)
+	}
+	for _, s := range wb.Sheets {
+		if s.Team.ID == silent {
+			t.Fatalf("无奖牌的隐藏单位不应出分表: %+v", s.Team)
+		}
+	}
+	if len(wb.Sheets) != 2 {
+		t.Fatalf("分表数 = %d，期望 2（T1 金、T2 银）", len(wb.Sheets))
+	}
+}
+
+func medalCountsOf(wb MedalDetailWorkbook, teamID int64) (int, int, int) {
+	var gold, silver, bronze int
+	for _, s := range wb.Sheets {
+		if s.Team.ID != teamID {
+			continue
+		}
+		for _, r := range s.Rows {
+			switch r.Medal {
+			case medalGold:
+				gold++
+			case medalSilver:
+				silver++
+			case medalBronze:
+				bronze++
+			}
+		}
+	}
+	return gold, silver, bronze
+}

server/internal/export/team_all.go

@@ -123,18 +123,7 @@ func LoadAllTeamDetailsWorkbook(db *sql.DB, opts Options) (AllTeamDetailsWorkboo
 	if err != nil {
 		return AllTeamDetailsWorkbook{}, err
 	}
-	sort.SliceStable(teams, func(i, j int) bool {
-		oi, iok := order[teams[i].ID]
-		oj, jok := order[teams[j].ID]
-		if iok != jok {
-			return iok
-		}
-		if iok {
-			return oi < oj
-		}
-		// 都不在榜上时保持 loadTeams 的 sort_order, code 顺序。
-		return false
-	})
+	orderTeamsByStandings(teams, order)
 
 	sheets := make([]TeamDetailSheet, 0, len(teams))
 	for _, t := range teams {
@@ -171,3 +160,19 @@ func teamStandingsOrder(db *sql.DB, opts Options) (map[int64]int, error) {
 	}
 	return order, nil
 }
+
+// orderTeamsByStandings 把单位按「单位总分榜」顺序（得分高的在前）原地排序；
+// 榜上没有的单位保持 loadTeams 的 sort_order, code 顺序，排在榜上有名的单位之后。
+func orderTeamsByStandings(teams []domain.Team, order map[int64]int) {
+	sort.SliceStable(teams, func(i, j int) bool {
+		oi, iok := order[teams[i].ID]
+		oj, jok := order[teams[j].ID]
+		if iok != jok {
+			return iok
+		}
+		if iok {
+			return oi < oj
+		}
+		return false
+	})
+}

server/internal/httpapi/export_handlers.go

@@ -29,6 +29,9 @@ func (s *server) exportRoutes(mux *http.ServeMux) {
 	mux.HandleFunc("GET /api/export/all-flat.xlsx", s.read(auth.RoleGuest, s.exportAllFlatXLSX))
 	// Go 1.22 ServeMux 的通配段必须独占一段，所以分项/单位导出用 /{id}，文件名由响应头给出。
 	mux.HandleFunc("GET /api/export/events/{id}", s.read(auth.RoleGuest, s.exportEventXLSX))
+	// 团体奖牌明细 / 个人得分明细：与总积分榜同一份官方名次与流水。
+	mux.HandleFunc("GET /api/export/medals.xlsx", s.read(auth.RoleGuest, s.exportMedalsXLSX))
+	mux.HandleFunc("GET /api/export/athletes.xlsx", s.read(auth.RoleGuest, s.exportAthletesXLSX))
 	// teams.xlsx 与 teams/{id} 段数不同，ServeMux 不会冲突。
 	mux.HandleFunc("GET /api/export/teams.xlsx", s.read(auth.RoleGuest, s.exportAllTeamsXLSX))
 	mux.HandleFunc("GET /api/export/teams/{id}", s.read(auth.RoleGuest, s.exportTeamXLSX))
@@ -94,6 +97,28 @@ func (s *server) exportAllFlatXLSX(w http.ResponseWriter, r *http.Request) (any,
 	})
 }
 
+// exportMedalsXLSX 导出团体奖牌明细：每块奖牌逐项来源，总表 + 每个有奖牌的单位一张分表。
+func (s *server) exportMedalsXLSX(w http.ResponseWriter, r *http.Request) (any, error) {
+	wb, err := export.LoadMedalDetailWorkbook(s.ev, export.Options{})
+	if err != nil {
+		return nil, internal(err)
+	}
+	return s.streamDownload(w, "团体奖牌明细.xlsx", xlsxMIME, func(out io.Writer) error {
+		return export.WriteMedalDetailXLSX(out, wb)
+	})
+}
+
+// exportAthletesXLSX 导出个人得分明细：记到个人的流水逐条列出，总表 + 每个有得分的单位一张分表。
+func (s *server) exportAthletesXLSX(w http.ResponseWriter, r *http.Request) (any, error) {
+	wb, err := export.LoadAthleteDetailWorkbook(s.ev, export.Options{})
+	if err != nil {
+		return nil, internal(err)
+	}
+	return s.streamDownload(w, "个人积分总明细.xlsx", xlsxMIME, func(out io.Writer) error {
+		return export.WriteAthleteDetailXLSX(out, wb)
+	})
+}
+
 // exportAllTeamsXLSX 导出所有单位的积分明细：第一张总表 + 每个单位一张分表。
 func (s *server) exportAllTeamsXLSX(w http.ResponseWriter, r *http.Request) (any, error) {
 	wb, err := export.LoadAllTeamDetailsWorkbook(s.ev, export.Options{})

server/internal/httpapi/export_records_test.go

@@ -0,0 +1,199 @@
+package httpapi_test
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xuri/excelize/v2"
+)
+
+type athleteStandingRow struct {
+	AthleteID   int64   `json:"athleteId"`
+	AthleteName string  `json:"athleteName"`
+	TotalPoints float64 `json:"totalPoints"`
+}
+
+// seedScoredResults 给 seed 的报名项补成绩与积分流水：
+// 单位 A 的运动员拿第 1 名 10 分，单位 B 的运动员拿第 2 名 8 分。
+func (e *testEnv) seedScoredResults(t *testing.T, ids seedIDs) {
+	t.Helper()
+	for _, in := range []struct {
+		entry         int64
+		rank          int
+		text          string
+		value         float64
+		team, athlete int64
+		points        float64
+	}{
+		{ids.entryA, 1, "11.58", 11.58, ids.teamA, ids.athleteA, 10},
+		{ids.entryB, 2, "11.90", 11.90, ids.teamB, ids.athB, 8},
+	} {
+		e.exec(t, `INSERT INTO results (event_id, entry_id, rank, result_text, result_value, unit, state)
+		           VALUES (?, ?, ?, ?, ?, 's', 'published')`,
+			ids.event, in.entry, in.rank, in.text, in.value)
+		e.exec(t, `INSERT INTO score_ledger (team_id, athlete_id, event_id, entry_id, result_id,
+		                                     source_type, source_id, points)
+		           SELECT ?, ?, ?, ?, id, 'result', 1, ? FROM results WHERE entry_id = ?`,
+			in.team, in.athlete, ids.event, in.entry, in.points, in.entry)
+	}
+}
+
+// guest 能下载团体奖牌明细；每块奖牌对应一条成绩。
+func TestExportMedalsXLSXGuest(t *testing.T) {
+	env := newTestEnv(t)
+	ids := env.seed(t)
+	env.seedScoredResults(t, ids)
+
+	client, _ := env.client()
+	status, header, body := env.getRaw(t, client, "/api/export/medals.xlsx")
+	if status != http.StatusOK {
+		t.Fatalf("guest 下载奖牌明细应 200，得到 %d %s", status, body)
+	}
+	wantCD := "attachment; filename*=UTF-8''" + url.PathEscape("团体奖牌明细.xlsx")
+	if got := header.Get("Content-Disposition"); got != wantCD {
+		t.Errorf("Content-Disposition = %q，期望 %q", got, wantCD)
+	}
+
+	f := openWorkbook(t, body)
+	defer func() { _ = f.Close() }()
+	// 单位 B 只有银牌也有分表；两个单位都有奖牌 → 总表 + 2 张分表。
+	want := []string{"团体奖牌明细", "第一分公司奖牌明细", "第二分公司奖牌明细"}
+	if got := f.GetSheetList(); !equalSheetList(got, want) {
+		t.Fatalf("sheet 列表 = %v，期望 %v", got, want)
+	}
+	master, err := f.GetRows("团体奖牌明细")
+	if err != nil {
+		t.Fatalf("读取总表: %v", err)
+	}
+	if len(master) != 6 { // 4 行版式 + 金、银各 1 块
+		t.Fatalf("总表行数 = %d，期望 6", len(master))
+	}
+	if got := masterCell(master, 4, 5); got != "金牌" {
+		t.Errorf("首行奖牌 = %q，期望 金牌", got)
+	}
+	if got := masterCell(master, 5, 5); got != "银牌" {
+		t.Errorf("次行奖牌 = %q，期望 银牌", got)
+	}
+	gold, err := f.GetRows("第一分公司奖牌明细")
+	if err != nil {
+		t.Fatalf("读取分表: %v", err)
+	}
+	if got := masterCell(gold, len(gold)-1, 4); got != "金 1 / 银 0 / 铜 0" {
+		t.Errorf("分表小计 = %q", got)
+	}
+
+	// 与团体奖牌榜一致：standings.xlsx 里单位 A 的金牌数 = 明细里金牌行数。
+	_, _, standingsBody := env.getRaw(t, client, "/api/export/standings.xlsx")
+	sf := openWorkbook(t, standingsBody)
+	defer func() { _ = sf.Close() }()
+	medalRows, err := sf.GetRows("团体奖牌榜")
+	if err != nil {
+		t.Fatalf("读取团体奖牌榜: %v", err)
+	}
+	if got := masterCell(medalRows, 4, 3); got != "1" {
+		t.Errorf("团体奖牌榜首队金牌 = %q，期望 1", got)
+	}
+}
+
+// guest 能下载个人得分明细；明细得分之和必须等于个人积分榜端点的总分，且不受折算系数影响。
+func TestExportAthletesXLSXGuest(t *testing.T) {
+	env := newTestEnv(t)
+	ids := env.seed(t)
+	env.seedScoredResults(t, ids)
+
+	client, _ := env.client()
+	status, header, body := env.getRaw(t, client, "/api/export/athletes.xlsx")
+	if status != http.StatusOK {
+		t.Fatalf("guest 下载个人得分明细应 200，得到 %d %s", status, body)
+	}
+	wantCD := "attachment; filename*=UTF-8''" + url.PathEscape("个人积分总明细.xlsx")
+	if got := header.Get("Content-Disposition"); got != wantCD {
+		t.Errorf("Content-Disposition = %q，期望 %q", got, wantCD)
+	}
+
+	f := openWorkbook(t, body)
+	defer func() { _ = f.Close() }()
+	want := []string{"个人积分总明细", "第一分公司个人得分明细", "第二分公司个人得分明细"}
+	if got := f.GetSheetList(); !equalSheetList(got, want) {
+		t.Fatalf("sheet 列表 = %v，期望 %v", got, want)
+	}
+	master, err := f.GetRows("个人积分总明细")
+	if err != nil {
+		t.Fatalf("读取总表: %v", err)
+	}
+	if len(master) != 6 { // 4 行版式 + 2 条个人流水
+		t.Fatalf("总表行数 = %d，期望 6", len(master))
+	}
+	if got := masterCell(master, 4, 1); got != "张伟" {
+		t.Errorf("首行运动员 = %q，期望 张伟", got)
+	}
+
+	// 跨端点：明细合计 == GET /api/standings/athletes 的总分。
+	assertAPIAthleteTotals(t, env, client, f, 10)
+
+	// 折算系数只影响单位总分：个人明细与个人积分榜都必须原样不动。
+	env.exec(t, `UPDATE settings SET value = '0.5' WHERE key = 'standings.individual_to_team_weight'`)
+	_, _, body2 := env.getRaw(t, client, "/api/export/athletes.xlsx")
+	f2 := openWorkbook(t, body2)
+	defer func() { _ = f2.Close() }()
+	rows, err := f2.GetRows("第一分公司个人得分明细")
+	if err != nil {
+		t.Fatalf("读取分表: %v", err)
+	}
+	if got := masterCell(rows, 4, 6); got != "10" {
+		t.Errorf("系数 0.5 时个人明细得分 = %q，期望 10", got)
+	}
+	assertAPIAthleteTotals(t, env, client, f2, 10)
+}
+
+// assertAPIAthleteTotals 比对 xlsx 里张伟的得分合计与 /api/standings/athletes 的总分。
+func assertAPIAthleteTotals(t *testing.T, env *testEnv, client *http.Client, f *excelize.File, want float64) {
+	t.Helper()
+	rows, err := f.GetRows("个人积分总明细")
+	if err != nil {
+		t.Fatalf("读取总表: %v", err)
+	}
+	var sum float64
+	var seen bool
+	for r := range rows {
+		if masterCell(rows, r, 1) != "张伟" {
+			continue
+		}
+		seen = true
+		v, err := strconv.ParseFloat(strings.TrimSpace(masterCell(rows, r, 7)), 64)
+		if err != nil {
+			t.Fatalf("解析明细得分 %q: %v", masterCell(rows, r, 7), err)
+		}
+		sum += v
+	}
+	if !seen {
+		t.Fatalf("个人明细里没有张伟的行")
+	}
+	if sum != want {
+		t.Errorf("张伟明细得分合计 = %v，期望 %v", sum, want)
+	}
+
+	status, _, body := env.getRaw(t, client, "/api/standings/athletes")
+	if status != http.StatusOK {
+		t.Fatalf("个人积分榜应 200，得到 %d %s", status, body)
+	}
+	var envl envelope
+	if err := json.Unmarshal(body, &envl); err != nil {
+		t.Fatalf("解析个人积分榜: %v (%s)", err, body)
+	}
+	list := decodeData[[]athleteStandingRow](t, envl)
+	for _, row := range list {
+		if row.AthleteName != "张伟" {
+			continue
+		}
+		if row.TotalPoints != sum {
+			t.Errorf("个人积分榜张伟总分 = %v，明细合计 = %v", row.TotalPoints, sum)
+		}
+		return
+	}
+	t.Fatalf("个人积分榜上没有张伟: %+v", list)
+}

web/src/admin/components/system/systemApi.ts

@@ -516,7 +516,15 @@ export const backupsApi = {
 // 结果导出（xlsx）
 // ---------------------------------------------------------------------------
 
-export type ResultExportKind = 'standings' | 'all' | 'allFlat' | 'event' | 'team' | 'teamAll'
+export type ResultExportKind =
+  | 'standings'
+  | 'all'
+  | 'allFlat'
+  | 'event'
+  | 'team'
+  | 'teamAll'
+  | 'medalAll'
+  | 'athleteAll'
 
 export interface ResultExportRequest {
   kind: ResultExportKind
@@ -536,6 +544,8 @@ const RESULT_EXPORT_FILENAME: Record<ResultExportKind, string> = {
   event: '分项成绩表.xlsx',
   team: '单位积分明细.xlsx',
   teamAll: '单位积分总明细.xlsx',
+  medalAll: '团体奖牌明细.xlsx',
+  athleteAll: '个人积分总明细.xlsx',
 }
 
 function mockDownload(request: ResultExportRequest, context: string): DownloadFile {
@@ -575,6 +585,9 @@ export const resultsExportApi = {
         }
         // 总明细：服务端把「单位」列加在最前，再给每个有明细行的单位附一张分表。
         if (request.kind === 'teamAll') path = '/export/teams.xlsx'
+        // 奖牌 / 个人明细同样是「总表 + 每个单位一张分表」，都不需要额外参数。
+        if (request.kind === 'medalAll') path = '/export/medals.xlsx'
+        if (request.kind === 'athleteAll') path = '/export/athletes.xlsx'
         const blob = await requestBlob(path, { timeoutMs: 60_000 })
         return { blob, filename: RESULT_EXPORT_FILENAME[request.kind] }
       },

web/src/admin/pages/StandingsPage.vue

@@ -27,8 +27,8 @@ const expandedTeamId = ref<number | null>(null)
 const breakdowns = ref<Record<number, TeamBreakdown>>({})
 const loadingBreakdown = ref(false)
 const pushing = ref(false)
-/** 正在进行的导出任务；非空时两个导出按钮都禁用，避免重复触发下载。 */
-const exporting = ref<'team' | 'teamAll' | null>(null)
+/** 正在进行的导出任务；非空时全部导出按钮都禁用，避免重复触发下载。 */
+const exporting = ref<'team' | 'teamAll' | 'medalAll' | 'athleteAll' | null>(null)
 const closeDialog = ref(false)
 const search = ref('')
 
@@ -117,15 +117,20 @@ async function exportTeamDetail(): Promise<void> {
   }
 }
 
-async function exportAllTeams(): Promise<void> {
+/** 榜单级明细导出（单位总分 / 团体奖牌 / 个人积分），与单位明细共用同一个单飞锁。 */
+async function exportBoard(
+  kind: 'teamAll' | 'medalAll' | 'athleteAll',
+  label: string,
+): Promise<void> {
   if (exporting.value !== null) return
-  exporting.value = 'teamAll'
+  exporting.value = kind
   try {
-    const result = await resultsExportApi.download({ kind: 'teamAll' })
+    const result = await resultsExportApi.download({ kind })
     adminApi.client.exports.save(result.data.blob, result.data.filename)
     toast.success(`已导出 ${result.data.filename}`, result.mock ? '示例数据：内容为占位文本' : null)
   } catch (caught) {
-    toast.error('导出总明细失败', describeError(caught))
+    // 服务端原文（无权限 / 生成失败 / 连不上）原样带出，不吞成笼统的「导出失败」。
+    toast.error(`${label}失败`, describeError(caught))
   } finally {
     exporting.value = null
   }
@@ -157,15 +162,6 @@ async function refresh(): Promise<void> {
         <button class="mx-btn mx-btn-secondary" type="button" @click="refresh">
           <MxIcon name="refresh" :size="15" /> 刷新
         </button>
-        <button
-          class="mx-btn mx-btn-secondary"
-          type="button"
-          :disabled="exporting !== null"
-          @click="exportAllTeams"
-        >
-          <MxIcon name="export" :size="15" />
-          {{ exporting === 'teamAll' ? '导出中…' : '导出总明细' }}
-        </button>
         <button class="mx-btn mx-btn-ghost" type="button" @click="closeDialog = true">
           <MxIcon name="close" :size="15" /> 关闭大屏明细
         </button>
@@ -195,8 +191,41 @@ async function refresh(): Promise<void> {
       <section class="mx-card">
         <div class="mx-card-head">
           <span class="mx-card-title">{{ TABS.find((tab) => tab.key === activeTab)?.label }}</span>
-          <span class="mx-badge mx-badge-info">
-            更新于 {{ formatDateTime(data.lastRefreshAt) }}
+          <span class="card-actions">
+            <span class="mx-badge mx-badge-info">
+              更新于 {{ formatDateTime(data.lastRefreshAt) }}
+            </span>
+            <!-- 每个榜单各有自己的明细导出，按钮跟着当前页签切换。 -->
+            <button
+              v-if="activeTab === 'points'"
+              class="mx-btn mx-btn-secondary mx-btn-sm"
+              type="button"
+              :disabled="exporting !== null"
+              @click="exportBoard('teamAll', '导出总明细')"
+            >
+              <MxIcon name="export" :size="14" />
+              {{ exporting === 'teamAll' ? '导出中…' : '导出总明细' }}
+            </button>
+            <button
+              v-else-if="activeTab === 'medals'"
+              class="mx-btn mx-btn-secondary mx-btn-sm"
+              type="button"
+              :disabled="exporting !== null"
+              @click="exportBoard('medalAll', '导出奖牌明细')"
+            >
+              <MxIcon name="export" :size="14" />
+              {{ exporting === 'medalAll' ? '导出中…' : '导出奖牌明细' }}
+            </button>
+            <button
+              v-else
+              class="mx-btn mx-btn-secondary mx-btn-sm"
+              type="button"
+              :disabled="exporting !== null"
+              @click="exportBoard('athleteAll', '导出个人明细')"
+            >
+              <MxIcon name="export" :size="14" />
+              {{ exporting === 'athleteAll' ? '导出中…' : '导出个人明细' }}
+            </button>
           </span>
         </div>
 
@@ -317,7 +346,7 @@ async function refresh(): Promise<void> {
           <span class="mx-card-title">
             {{ activeBreakdown === null ? '单位积分明细' : `${activeBreakdown.teamName} · 明细` }}
           </span>
-          <span class="detail-actions">
+          <span class="card-actions">
             <button
               class="mx-btn mx-btn-secondary mx-btn-sm"
               type="button"
@@ -450,8 +479,8 @@ tr.expanded {
   position: sticky;
   top: 0;
 }
-/* 明细卡头部要同时放「导出」与「推送」两个按钮，超出时换行而不是撑破卡片。 */
-.detail-actions {
+/* 卡片头 / 明细卡头部的操作组：更新徽标 + 导出（+ 推送），放不下时换行而不是撑破卡片。 */
+.card-actions {
   display: flex;
   align-items: center;
   gap: 8px;

web/src/admin/tests/standings-export-api.test.ts

@@ -144,3 +144,79 @@ test('连不上服务端时降级为占位文件，网络错误留在 mockReason
   assert.equal(mockReason.value, '无法连接服务端')
   assert.equal(lastRequest.url, '/api/export/teams.xlsx')
 })
+
+test('奖牌明细导出走 GET /api/export/medals.xlsx，文件名是「团体奖牌明细.xlsx」', async () => {
+  respondWith(() => xlsxResponse())
+
+  const result = await resultsExportApi.download({ kind: 'medalAll' })
+
+  assert.equal(lastRequest.url, '/api/export/medals.xlsx')
+  assert.equal(lastRequest.method, 'GET')
+  assert.equal(result.data.filename, '团体奖牌明细.xlsx')
+  assert.equal(result.mock, false, '正常响应不应被当成示例数据')
+})
+
+test('个人明细导出走 GET /api/export/athletes.xlsx，文件名是「个人积分总明细.xlsx」', async () => {
+  respondWith(() => xlsxResponse())
+
+  const result = await resultsExportApi.download({ kind: 'athleteAll' })
+
+  assert.equal(lastRequest.url, '/api/export/athletes.xlsx')
+  assert.equal(lastRequest.method, 'GET')
+  assert.equal(result.data.filename, '个人积分总明细.xlsx')
+})
+
+// 整榜导出不需要 teamId；一旦误落进 team 分支就会变成 /export/teams/undefined。
+test('medalAll / athleteAll 不被 team 分支截胡，也不要求 teamId', async () => {
+  respondWith(() => xlsxResponse())
+  await resultsExportApi.download({ kind: 'medalAll' })
+  assert.equal(lastRequest.url, '/api/export/medals.xlsx')
+
+  respondWith(() => xlsxResponse())
+  await resultsExportApi.download({ kind: 'athleteAll' })
+  assert.equal(lastRequest.url, '/api/export/athletes.xlsx')
+})
+
+test('奖牌明细失败时服务端原文原样抛出，不吞成笼统的「导出失败」', async () => {
+  respondWith(() =>
+    jsonResponse({ ok: false, error: { code: 'INTERNAL', message: '奖牌明细生成失败：event.db 已锁定' } }, 500),
+  )
+
+  await assert.rejects(
+    () => resultsExportApi.download({ kind: 'medalAll' }),
+    (error: unknown) => {
+      assert.ok(error instanceof ApiError)
+      assert.equal(error.status, 500)
+      assert.equal(error.message, '奖牌明细生成失败：event.db 已锁定')
+      return true
+    },
+  )
+})
+
+test('个人明细失败时 403 原文原样抛出', async () => {
+  respondWith(() =>
+    jsonResponse({ ok: false, error: { code: 'FORBIDDEN', message: '需要裁判长权限' } }, 403),
+  )
+
+  await assert.rejects(
+    () => resultsExportApi.download({ kind: 'athleteAll' }),
+    (error: unknown) => {
+      assert.ok(error instanceof ApiError)
+      assert.equal(error.status, 403)
+      assert.equal(error.message, '需要裁判长权限')
+      return true
+    },
+  )
+})
+
+// 占位文件名也要跟着 kind 走，否则连不上时会存成一个叫「单位积分总明细（示例数据）.txt」的奖牌文件。
+test('连不上时新 kind 的占位文件名也正确', async () => {
+  respondWith(() => {
+    throw new TypeError('fetch failed')
+  })
+
+  const result = await resultsExportApi.download({ kind: 'medalAll' })
+
+  assert.equal(result.mock, true)
+  assert.equal(result.data.filename, '团体奖牌明细（示例数据）.txt')
+})