feat(entry): 团体项目多队（迁移 0025）+ 修联队团体名次 / 大屏分项成绩 / 预览算分口径；版本 dev_0.5.5

## 一、新能力：团体项目多队
现场：羽毛球双打，一个单位可能派两个队，一个单位两个队各占一个名次。
- 迁移 `0025_entry_squad.sql`：`entries` 加 `squad TEXT NOT NULL DEFAULT ''`（自由文本队名，空串＝不区分队伍）；
  唯一索引由 `(category_id, team_id) WHERE athlete_id IS NULL` 换成 `(category_id, team_id, squad) WHERE athlete_id IS NULL`
  —— 原来那条正是「一个单位在一个组别只能报一条团体报名」的拦路虎。
- 导入：**第 13 列「队伍」**（`squad` / 队伍 / 队名 / 队伍名，可选，放最后）；老 12 列表照常导入。
- 显示：`单位名 + 队名`（不加括号），榜单不写队名（分与牌本来就归单位）。
- 新增「改队名」：`PUT /api/entries/{id}/squad` + 「成员单位与份额」弹窗里的队伍输入框（只对纯团体报名显示）。
  改队名**不需要重算**（`grep squad server/internal/domain/` = 0 处，改名前后流水/名次/榜单逐字节相同）。
- **老数据零变化**：接口层 JSON 剥掉新字段后逐字节相同；导出层 9 份导出件全单元格 750 行 dump 的 md5 相同。

## 二、修：团体名次控件没体现联队
联队的成员单位在「团体名次」里各占一行 → **合并成一行**（标签用大屏/导出一致的联队名），名次**只落主单位**；
成员单位不再进保存载荷，顺手堵掉「看 A、B 各一行，给 B 也录一个名次 → B 重复拿分」。
被并掉的成员单位原来若录过名次，区块里点名提示「已并入联队那一行，保存后清除」，不静默吞。

## 三、修：大屏「分项成绩」排名错乱
现场：第 3 栏列出的项目排名跳着显示（3、6、9、14、15、16），羽毛球单打第 1 名不显示。
**根因**：`group.rows.slice(0, 6)` 取的是**数据到达顺序**，整条渲染链**没有一处读 `rank`**。
修法：按名次升序（并列保持原先后、无名次排最后）再截断 —— 与同页「实时赛况」的既有口径一致。
复现证据：修前 `actual: [3,6,9,14,15,16]`（与现场数字一致）、`expected: [1,2,3,4,5,6]`。
顺带澄清：「只有第 3 栏出问题」不是栏的问题，是那一栏分到的数据次序不成立。

## 四、修：录入页预览算分与后端口径不一致（四处 + 一条延伸）
现场：手动录名次的项目（台球）「积分（自动）」列全是 0，而后端**有分**。
1. **预览不读 `channel_manual_ranks`、也不按通道 scope 分名次来源** → 「按单位录名次」的项目预览全 0，反过来名次填在成绩表时预览有分而服务端 0；
2. **末位归零判据不同**：预览原本「区间跨末位就整组归零」，与后端的 `startRank == lastPlace` 不符（并列第 1 时预览 0、服务端 10）；
3. **`compare=none` 时预览静默降级成 manual**（后端此时直接报错）→ 改为同口径：显示**原因**而不是一个算不出来的数字；
4. **管理端保存计分通道缺守卫**：`compare=none + basis=result/aggregate` 原先只有规则包导入拦，手工能配出来、到发布才报错 → 保存前 400 + 人话。
延伸：预览的「已发布分」基线**只扣行分**，不挂报名项的分（团体名次那类）没扣 → 发布确认框「最大分差」虚高；新增 `unitPoints` 一并扣。

## 五、修：手录名次项目的「成绩」列空白
`displayResult()` 在 `resultValue`/`resultText` 都拿不到时**漏出空值**（且函数声明返回 `string`）→
新增占位 `—`、类型收紧，实时赛况与底栏对齐同一口径。

## 文档
`docs/报名名单导入规范.md`（12 → 13 列）、`docs/使用手册.md`（多队章节）、
`docs/升级说明.md`（新增 `dev_0.5.5` 一节）、`debug/使用说明/` 七份同步。

## 验证
- 全量自检两轮**全绿、`EXIT=0`**：服务端 14 包 / 前端 **883 例** 0 fail / Console 68 例 0 fail。
- 各块都先写会红的测试、留了原始输出（含现场报的那组数字与「预览全 0」）。

## 版本
`dev_0.5.4` → **`dev_0.5.5`**（含数据迁移 `0025`）；安装器素材同步重生成（照例只动 `brand.bmp` 两张）。

## 下一批
`dev_0.5.6` = **团体报名队员身份**（把队员从文字名单变成人员关联，标识用**号码布**），工单见 `devdocs/20-团体报名队员身份.md`。

server/internal/export/entries.go

@@ -131,7 +131,7 @@ func LoadEntriesWorkbook(db *sql.DB, filter EntriesFilter, opts Options) (Entrie
 
 	query := `
 		SELECT COALESCE(ev.code, ''), COALESCE(ev.name, ''), COALESCE(c.name, ''),
-		       COALESCE(t.code, ''), COALESCE(t.name, ''),
+		       COALESCE(t.code, ''), COALESCE(t.name, ''), COALESCE(en.squad, ''),
 		       COALESCE(a.name, ''), COALESCE(en.member_names, ''),
 		       COALESCE(a.id_card, ''), COALESCE(en.bib, ''), en.heat,
 		       COALESCE(a.gender, ''), a.age, en.status, COALESCE(en.remark, ''), en.id
@@ -198,10 +198,11 @@ func LoadEntriesWorkbook(db *sql.DB, filter EntriesFilter, opts Options) (Entrie
 			heat        sql.NullInt64
 			age         sql.NullInt64
 			athleteName string
+			squad       string
 			entryID     int64
 		)
 		if err := rows.Scan(&row.EventCode, &row.EventName, &row.Category, &row.TeamCode, &row.TeamName,
-			&athleteName, &memberJSON, &row.IDCard, &row.Bib, &heat,
+			&squad, &athleteName, &memberJSON, &row.IDCard, &row.Bib, &heat,
 			&row.Gender, &age, &row.Status, &row.Remark, &entryID); err != nil {
 			return EntriesWorkbook{}, fmt.Errorf("export: 扫描报名名单: %w", err)
 		}
@@ -222,6 +223,10 @@ func LoadEntriesWorkbook(db *sql.DB, filter EntriesFilter, opts Options) (Entrie
 			row.TeamName = joint.Name()
 			row.Remark = appendNote(row.Remark, joint.shareRatioNote())
 		}
+		// 队名接在单位名后面（口径：单位名+队名，不加括号），空队名时一个字都不加：
+		// 老数据与单队单位的这份名单必须与升级前逐行一致。单位编码不动 —— 队名不是编码的一部分，
+		// 编码列照旧是可以直接拿去重导的写法。
+		row.TeamName = withSquad(row.TeamName, squad)
 		out = append(out, row)
 	}
 	if err := rows.Err(); err != nil {

server/internal/export/load.go

@@ -542,7 +542,8 @@ func loadEventRows(db *sql.DB, eventID, categoryID int64, includeDrafts bool, jo
 	// 行上的名次与积分因此天然是空的——导出必须把它标成「未结算」，见 Unsettled。
 	query := `
 		SELECT COALESCE(cr.rank, r.rank, 0), COALESCE(r.is_tie, 0), COALESCE(en.bib, ''),
-		       COALESCE(en.member_names, ''), COALESCE(t.name, ''), COALESCE(a.name, ''),
+		       COALESCE(en.member_names, ''), COALESCE(t.name, ''), COALESCE(en.squad, ''),
+		       COALESCE(a.name, ''),
 		       COALESCE(r.result_text, ''), COALESCE(r.unit, ''),
 		       COALESCE((SELECT SUM(l.points) FROM score_ledger l
 		                 WHERE l.entry_id = en.id AND l.voided = 0), 0),
@@ -594,6 +595,7 @@ func loadEventRows(db *sql.DB, eventID, categoryID int64, includeDrafts bool, jo
 			row                     EventResultRow
 			rank, isTie             int
 			memberJSON, athleteName string
+			squad                   string
 			resultStat, resultState sql.NullString
 			entryStat, entryRemark  string
 			resultNote              string
@@ -601,7 +603,7 @@ func loadEventRows(db *sql.DB, eventID, categoryID int64, includeDrafts bool, jo
 			required, published     int
 			entryID                 int64
 		)
-		if err := rows.Scan(&rank, &isTie, &row.Bib, &memberJSON, &row.TeamName, &athleteName,
+		if err := rows.Scan(&rank, &isTie, &row.Bib, &memberJSON, &row.TeamName, &squad, &athleteName,
 			&row.ResultText, &row.Unit, &row.Points, &resultStat, &resultState, &entryStat,
 			&entryRemark, &resultNote, &hasValue, &required, &published, &entryID); err != nil {
 			return nil, fmt.Errorf("export: 扫描成绩: %w", err)
@@ -616,6 +618,9 @@ func loadEventRows(db *sql.DB, eventID, categoryID int64, includeDrafts bool, jo
 			row.TeamName = joint.Name()
 			row.Remark = appendNote(row.Remark, joint.shareNote())
 		}
+		// 队名接在单位名后面（口径：单位名+队名，不加括号）。放在联队之后：联队名本身就是单位名，
+		// 「A+B联队二队」读起来才是「这个联队的第二支队」。空队名时这一行不动，导出件与升级前逐字一致。
+		row.TeamName = withSquad(row.TeamName, squad)
 		// results.state 是 NOT NULL，所以 state 为空只可能是 LEFT JOIN 没命中所致：这条报名还没录成绩。
 		// 它与「有草稿没发布」要分开：前者三格都没值，后者只是成绩值不对外。
 		row.NoResult = !resultState.Valid
@@ -724,7 +729,7 @@ func loadTeamDetailRows(db *sql.DB, teamID int64, joints map[int64]jointTeam) ([
 		       COALESCE(a.name, ''), `+teamDetailRankExpr+`, COALESCE(r.result_text, ''),
 		       COALESCE(r.unit, ''),
 		       l.source_type, l.points, COALESCE(l.void_reason, ''), COALESCE(l.athlete_id, 0),
-		       COALESCE(l.event_id, 0), COALESCE(l.entry_id, 0)
+		       COALESCE(l.event_id, 0), COALESCE(l.entry_id, 0), COALESCE(en.squad, '')
 		FROM score_ledger l
 		LEFT JOIN events e ON e.id = l.event_id
 		LEFT JOIN sports s ON s.id = e.sport_id
@@ -759,7 +764,8 @@ func loadTeamDetailRows(db *sql.DB, teamID int64, joints map[int64]jointTeam) ([
 		var athleteID, eventID, entryID int64
 		var resultText, unit string
 		if err := rows.Scan(&r.SportName, &r.EventName, &r.Category, &r.AthleteName, &r.Rank,
-			&resultText, &unit, &source, &r.Points, &r.Remark, &athleteID, &eventID, &entryID); err != nil {
+			&resultText, &unit, &source, &r.Points, &r.Remark, &athleteID, &eventID, &entryID,
+			&r.squad); err != nil {
 			return nil, fmt.Errorf("export: 扫描积分明细: %w", err)
 		}
 		// 成绩与分项成绩表 / 个人明细同口径（走 displayResult），否则同一场比赛的同一个成绩

server/internal/export/medals.go

@@ -36,6 +36,11 @@ type MedalDetailRow struct {
 	// 口径是每个成员单位各记一整枚，各单位的奖牌数加起来会比实际颁发的多，这一格就是那句解释。
 	jointNote string
 
+	// squad 是这块奖牌对应报名项的队名（entries.squad），只有总表的「单位」列用它：
+	// 一个单位两个队各拿一块牌时，总表上要认得出来哪块是哪个队的。分表没有「单位」列，
+	// 表名本身就是单位（它是一整份单位级清单，不按队拆）。
+	squad string
+
 	// 排序键，只在本包内用，不导出。
 	sportSort  int
 	eventSort  int
@@ -129,7 +134,9 @@ func medalMasterRows(sheets []MedalDetailSheet) [][]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)...))
+			// 队名接在单位名后面（口径：单位名+队名）：一个单位两个队各拿一块牌时，
+			// 总表上两块牌的单位列不是同一行字，读者才知道哪块是哪个队拿的。空队名时一个字都不加。
+			out = append(out, append([]any{withSquad(unit, r.squad)}, medalRow(r)...))
 		}
 	}
 	return out
@@ -213,9 +220,15 @@ func LoadMedalDetailWorkbook(db *sql.DB, opts Options) (MedalDetailWorkbook, err
 	}
 	orderTeamsByStandings(teams, order)
 
+	// 队名按报名项读一次给全部奖牌行复用（逐行去查库是白跑）。
+	squads, err := loadEntrySquads(db)
+	if err != nil {
+		return MedalDetailWorkbook{}, err
+	}
+
 	sheets := make([]MedalDetailSheet, 0, len(teams))
 	for _, t := range teams {
-		rows := medalRowsOfTeam(t.ID, hits, ctx, eventCtx, joints)
+		rows := medalRowsOfTeam(t.ID, hits, ctx, eventCtx, joints, squads)
 		if len(rows) == 0 {
 			continue
 		}
@@ -409,7 +422,8 @@ func loadMedalEventContext(db *sql.DB) (map[eventCategoryKey]medalContext, error
 
 // medalRowsOfTeam 把某单位的奖牌拼成展示行，按大项/小项/组别/名次的既有顺序排列。
 // 展示字段优先按成绩取（能带上运动员 / 接力队名单），取不到再按小项 + 组别兜底。
-func medalRowsOfTeam(teamID int64, hits map[int64][]medalHit, ctx map[int64]medalContext, eventCtx map[eventCategoryKey]medalContext, joints map[int64]jointTeam) []MedalDetailRow {
+// squads 是「报名 id → 队名」，用来给总表的单位列补上这块奖牌是哪个队拿的。
+func medalRowsOfTeam(teamID int64, hits map[int64][]medalHit, ctx map[int64]medalContext, eventCtx map[eventCategoryKey]medalContext, joints map[int64]jointTeam, squads map[int64]string) []MedalDetailRow {
 	list := hits[teamID]
 	rows := make([]MedalDetailRow, 0, len(list))
 	for _, h := range list {
@@ -430,6 +444,7 @@ func medalRowsOfTeam(teamID int64, hits map[int64][]medalHit, ctx map[int64]meda
 			eventID:     c.eventID,
 			categoryID:  c.categoryID,
 			resultID:    h.resultID,
+			squad:       squads[h.entryID],
 		}
 		// 联队奖牌：把成员单位与「各单位各记 1 枚」写在奖牌那一格（口径 3）。
 		// 名次不带报名项时（聚合通道）不补：那种名次本来就不拆份额，说明只会误导。

server/internal/export/squad.go

@@ -0,0 +1,54 @@
+package export
+
+import (
+	"database/sql"
+	"fmt"
+	"strings"
+)
+
+// 本文件是「队名」（entries.squad，迁移 0025）在导出侧的读法。
+//
+// 同一个单位在同一组别可以派多支队参赛（例如羽毛球双打，一个单位两个队各占一个名次），
+// 报名上多出一列自由文本队名，空串 = 不区分队伍 —— 那是老数据与单队单位的默认值。
+//
+// 显示口径（与大屏、管理端同一份实现）：**单位名 + 队名**，不加括号也不加分隔符，例如「第一分公司二队」。
+// 现场就是把它当一个单位名念的，括号与空格只会白占列宽，还会让同一支队在两份材料里写法不一样。
+
+// withSquad 把队名接在单位名后面；队名为空（或只有空白）时**一个字都不加**。
+//
+// 空队名什么都不加是硬门槛：升级后导出的老赛事必须与升级前逐行一致。
+// 顺带去掉队名首尾空白：它由现场自由填写，带着空格会把「第一分公司 二队」这种读法印进导出件。
+func withSquad(name, squad string) string {
+	squad = strings.TrimSpace(squad)
+	if squad == "" {
+		return name
+	}
+	return name + squad
+}
+
+// loadEntrySquads 读全部带队名的报名，按报名 id 归组。
+//
+// 只取非空的行：绝大多数报名的 squad 都是空串，整表扫回来再逐行判空是白花内存。
+func loadEntrySquads(db *sql.DB) (map[int64]string, error) {
+	rows, err := db.Query(`SELECT id, squad FROM entries WHERE TRIM(COALESCE(squad, '')) <> ''`)
+	if err != nil {
+		return nil, fmt.Errorf("export: 读取报名队名: %w", err)
+	}
+	defer func() { _ = rows.Close() }()
+
+	out := make(map[int64]string)
+	for rows.Next() {
+		var (
+			entryID int64
+			squad   string
+		)
+		if err := rows.Scan(&entryID, &squad); err != nil {
+			return nil, fmt.Errorf("export: 扫描报名队名: %w", err)
+		}
+		out[entryID] = squad
+	}
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("export: 遍历报名队名: %w", err)
+	}
+	return out, nil
+}

server/internal/export/squad_dump_test.go

@@ -0,0 +1,183 @@
+package export
+
+import (
+	"bytes"
+	"database/sql"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xuri/excelize/v2"
+)
+
+// 这份用例是「squad 为空时导出件逐行一致」这条硬门槛的对拍工具。
+//
+// 做法：造一份**全部报名都没有队名**的赛事库（队名列留空 = 老数据与单队单位的原样），
+// 把每一份导出件的每一张工作表、每一个单元格 dump 成文本；同一个用例文件放到改动前的代码上
+// 再跑一次（`git archive` 取一份 HEAD 的树，只补上这次迁移与这个用例文件），两份 dump
+// `diff` 必须为空。
+//
+// 落地路径由 EXPORT_SQUAD_DUMP 指定，不设时写进 t.TempDir() —— 也就是说平时它只当一次
+// 「全部导出件都能加载」的冒烟，不往仓库里落文件。
+func TestSquadEmptyExportDumpIsUnchanged(t *testing.T) {
+	db := openEventDB(t)
+	seedSquadDumpEvent(t, db)
+
+	opts := Options{Meta: Meta{GeneratedAt: time.Unix(1700000000, 0)}}
+	empty := dumpAllWorkbooks(t, db, opts)
+
+	// 先落盘：对拍要的是「改动前那份代码产出的文本」，它不能因为后面的自检失败而没写出来。
+	path := os.Getenv("EXPORT_SQUAD_DUMP")
+	if path == "" {
+		path = filepath.Join(t.TempDir(), "squad-empty-dump.txt")
+	}
+	if err := os.WriteFile(path, []byte(empty), 0o644); err != nil {
+		t.Fatalf("写出 dump: %v", err)
+	}
+	t.Logf("空队名 dump：%s（%d 个单元格）", path, strings.Count(empty, "\n"))
+
+	// 敏感度自检：给那条团体报名写上队名后重新 dump，两次必须不同。
+	// 少了这一步，「两份 dump 一样」也可能只是因为 dump 根本没覆盖到单位列 —— 那就白对拍了。
+	if _, err := db.Exec(`UPDATE entries SET squad = '二队' WHERE event_id = 2`); err != nil {
+		t.Fatalf("写入队名: %v", err)
+	}
+	withSquadDump := dumpAllWorkbooks(t, db, opts)
+	if withSquadDump == empty {
+		t.Fatal("给报名写上队名后 dump 没变：这份对拍看不见单位列，对拍结论无效" +
+			"（在对拍用的旧代码上这条自检本来就会红——旧代码根本不看 squad，正说明两份 dump 的差异只可能来自这次改动）")
+	}
+	if !strings.Contains(withSquadDump, "第一分公司二队") {
+		t.Fatal("带队名的 dump 里找不到「第一分公司二队」：队名没有写进导出件")
+	}
+}
+
+// seedSquadDumpEvent 造一份覆盖面尽量宽的赛事库，且**所有报名的队名都留空**：
+// 个人小项（含空批次、团体行回落成员名单）+ 一条纯团体报名 + 联队份额。
+// 个人路径与团体路径都要有，否则这次改动覆盖的两处读取点里会漏掉一处。
+func seedSquadDumpEvent(t *testing.T, db *sql.DB) {
+	t.Helper()
+	seedEvent(t, db)      // T1/T2、100 米跑、两条已发布成绩与流水
+	addBronzeEntry(t, db) // 第 3 名（一个单位两条报名）
+	stmts := []string{
+		`INSERT INTO sports(code, name, sort_order) VALUES ('SP2', '羽毛球', 2)`,
+		`INSERT INTO events(sport_id, code, name, event_type, result_mode, result_type, compare, status)
+		 VALUES (2, 'E2', '男子双打', 'team', 'auto', 'score', 'desc', '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, 'team', 'result', id FROM scoring_profiles WHERE code = 'individual_top6'`,
+		`INSERT INTO entries(event_id, category_id, team_id, member_names, bib, heat)
+		 VALUES (2, 1, 1, '["王磊","赵雷"]', '201', 1)`,
+		`INSERT INTO results(event_id, entry_id, rank, result_text, result_value, unit, state)
+		 SELECT 2, id, 1, '2:0', 2, 'pts', 'published' FROM entries WHERE event_id = 2`,
+		`INSERT INTO score_ledger(team_id, event_id, entry_id, result_id, source_type, source_id, points)
+		 SELECT 1, 2, e.id, r.id, 'result', r.id, 10
+		   FROM entries e JOIN results r ON r.entry_id = e.id WHERE e.event_id = 2`,
+		// 联队：这条团体报名由两个单位合报（奖牌各记一枚），队名列仍然是空的。
+		`INSERT INTO entry_team_shares(entry_id, team_id, points_share, medal_share, sort_order)
+		 SELECT e.id, t.id, 1, 1, t.id - 1 FROM entries e CROSS JOIN teams t WHERE e.event_id = 2`,
+	}
+	for _, s := range stmts {
+		if _, err := db.Exec(s); err != nil {
+			t.Fatalf("造数据 %q: %v", s, err)
+		}
+	}
+	seedChannelRanks(t, db)
+}
+
+// dumpAllWorkbooks 把全部导出件 dump 成一份文本：先写每个工作簿的 sheet 列表（表名里也有单位名），
+// 再逐单元格写 `工作簿|工作表|行|列|值`。用 Write*（生产走的是同一条流）而不是落盘再读，
+// 保证 dump 的就是响应体里那份文件。
+func dumpAllWorkbooks(t *testing.T, db *sql.DB, opts Options) string {
+	t.Helper()
+	var sb strings.Builder
+
+	dump := func(name string, write func(io.Writer) error) {
+		t.Helper()
+		var buf bytes.Buffer
+		if err := write(&buf); err != nil {
+			t.Fatalf("导出 %s: %v", name, err)
+		}
+		f, err := excelize.OpenReader(bytes.NewReader(buf.Bytes()))
+		if err != nil {
+			t.Fatalf("打开 %s: %v", name, err)
+		}
+		defer func() { _ = f.Close() }()
+		sheets := f.GetSheetList()
+		sort.Strings(sheets)
+		fmt.Fprintf(&sb, "== %s sheets=%s\n", name, strings.Join(sheets, ","))
+		for _, sheet := range sheets {
+			rows, err := f.GetRows(sheet)
+			if err != nil {
+				t.Fatalf("读取 %s!%s: %v", name, sheet, err)
+			}
+			for r, row := range rows {
+				for c, v := range row {
+					fmt.Fprintf(&sb, "%s|%s|%d|%d|%q\n", name, sheet, r+1, c+1, v)
+				}
+			}
+		}
+	}
+
+	standings, err := LoadStandingsWorkbook(db, opts)
+	if err != nil {
+		t.Fatalf("读总表: %v", err)
+	}
+	dump("总表", func(w io.Writer) error { return WriteStandingsXLSX(w, standings) })
+
+	events, err := LoadEventWorkbook(db, 0, opts)
+	if err != nil {
+		t.Fatalf("读分项成绩表: %v", err)
+	}
+	dump("分项成绩表", func(w io.Writer) error { return WriteEventXLSX(w, events) })
+
+	flat, err := LoadFlatWorkbook(db, opts)
+	if err != nil {
+		t.Fatalf("读全部成绩单页: %v", err)
+	}
+	dump("全部成绩单页", func(w io.Writer) error { return WriteFlatXLSX(w, flat) })
+
+	all, err := LoadAllWorkbook(db, opts)
+	if err != nil {
+		t.Fatalf("读全部: %v", err)
+	}
+	dump("全部", func(w io.Writer) error { return WriteAllXLSX(w, all) })
+
+	entries, err := LoadEntriesWorkbook(db, EntriesFilter{}, opts)
+	if err != nil {
+		t.Fatalf("读报名名单: %v", err)
+	}
+	dump("报名名单", func(w io.Writer) error { return WriteEntriesXLSX(w, entries) })
+
+	medals, err := LoadMedalDetailWorkbook(db, opts)
+	if err != nil {
+		t.Fatalf("读单位奖牌明细: %v", err)
+	}
+	dump("单位奖牌明细", func(w io.Writer) error { return WriteMedalDetailXLSX(w, medals) })
+
+	athletes, err := LoadAthleteDetailWorkbook(db, opts)
+	if err != nil {
+		t.Fatalf("读个人得分明细: %v", err)
+	}
+	dump("个人得分明细", func(w io.Writer) error { return WriteAthleteDetailXLSX(w, athletes) })
+
+	details, err := LoadAllTeamDetailsWorkbook(db, opts)
+	if err != nil {
+		t.Fatalf("读总明细: %v", err)
+	}
+	dump("总明细", func(w io.Writer) error { return WriteAllTeamDetailsXLSX(w, details) })
+
+	for _, teamID := range []int64{1, 2} {
+		wb, err := LoadTeamDetailWorkbook(db, teamID, opts)
+		if err != nil {
+			t.Fatalf("读单位 %d 积分明细: %v", teamID, err)
+		}
+		name := fmt.Sprintf("单位%d积分明细", teamID)
+		dump(name, func(w io.Writer) error { return WriteTeamDetailXLSX(w, wb) })
+	}
+	return sb.String()
+}

server/internal/export/squad_test.go

@@ -0,0 +1,210 @@
+package export
+
+import (
+	"database/sql"
+	"path/filepath"
+	"testing"
+)
+
+// seedSquads 造一场「一个单位派两支队」的团体赛：羽毛球男子双打，第一分公司派一队 / 二队，
+// 两队分别拿第 1、第 2 名（口径 3：一个单位两个队各占一个名次、各拿一块牌，不去重不合并），
+// 第二分公司一支不区分队伍的队（squad 留空 = 老写法）拿第 3 名。
+func seedSquads(t *testing.T, db *sql.DB) {
+	t.Helper()
+	stmts := []string{
+		`INSERT INTO teams(code, name, short_name, sort_order) VALUES ('T1', '第一分公司', '一公司', 1)`,
+		`INSERT INTO teams(code, name, short_name, sort_order) VALUES ('T2', '第二分公司', '二公司', 2)`,
+		`INSERT INTO sports(code, name) VALUES ('SP1', '羽毛球')`,
+		`INSERT INTO events(sport_id, code, name, event_type, result_mode, result_type, compare, status)
+		 VALUES (1, 'E1', '男子双打', 'team', 'auto', 'score', 'desc', 'published')`,
+		`INSERT INTO event_categories(event_id, name, sort_order) VALUES (1, '男子', 1)`,
+		`INSERT INTO event_score_channels(event_id, scope, basis, profile_id)
+		 SELECT 1, 'team', 'result', id FROM scoring_profiles WHERE code = 'individual_top6'`,
+		// 同一个单位在同一组别的两条团体报名：靠 squad 区分，只有带上 squad 的唯一索引才放得下。
+		`INSERT INTO entries(event_id, category_id, team_id, member_names, squad, bib)
+		 VALUES (1, 1, 1, '["王磊","赵雷"]', '一队', '101')`,
+		`INSERT INTO entries(event_id, category_id, team_id, member_names, squad, bib)
+		 VALUES (1, 1, 1, '["陈刚","郑凯"]', '二队', '102')`,
+		`INSERT INTO entries(event_id, category_id, team_id, member_names, bib)
+		 VALUES (1, 1, 2, '["孙七","周八"]', '103')`,
+		`INSERT INTO results(event_id, entry_id, rank, result_text, result_value, unit, state)
+		 VALUES (1, 1, 1, '2:0', 2, 'pts', 'published')`,
+		`INSERT INTO results(event_id, entry_id, rank, result_text, result_value, unit, state)
+		 VALUES (1, 2, 2, '2:1', 2, 'pts', 'published')`,
+		`INSERT INTO results(event_id, entry_id, rank, result_text, result_value, unit, state)
+		 VALUES (1, 3, 3, '2:1', 2, 'pts', 'published')`,
+		`INSERT INTO score_ledger(team_id, event_id, entry_id, result_id, source_type, source_id, points)
+		 VALUES (1, 1, 1, 1, 'result', 1, 10)`,
+		`INSERT INTO score_ledger(team_id, event_id, entry_id, result_id, source_type, source_id, points)
+		 VALUES (1, 1, 2, 2, 'result', 2, 8)`,
+		`INSERT INTO score_ledger(team_id, event_id, entry_id, result_id, source_type, source_id, points)
+		 VALUES (2, 1, 3, 3, 'result', 3, 6)`,
+		`UPDATE settings SET value = '测试运动会' WHERE key = 'event.name'`,
+		`UPDATE settings SET value = '测试主办方' WHERE key = 'event.organizer'`,
+	}
+	for _, s := range stmts {
+		if _, err := db.Exec(s); err != nil {
+			t.Fatalf("造数据 %q: %v", s, err)
+		}
+	}
+}
+
+// 分项成绩表：单位列在队名非空时写「单位名+队名」，一个单位的两个队各占一行。
+func TestEventSheetShowsSquadAfterUnitName(t *testing.T) {
+	db := openEventDB(t)
+	seedSquads(t, db)
+	seedChannelRanks(t, db)
+
+	dst := filepath.Join(t.TempDir(), "成绩表.xlsx")
+	if err := ExportEventXLSX(db, 0, dst, Options{}); err != nil {
+		t.Fatalf("导出分项成绩表: %v", err)
+	}
+	rows := readSheet(t, dst, "羽毛球·男子双打·男子")
+
+	// 4 行版式 + 3 条报名，按名次排：一队、二队、第二分公司。
+	want := []string{"第一分公司一队", "第一分公司二队", "第二分公司"}
+	for i, w := range want {
+		if got := cell(rows, 4+i, 2); got != w {
+			t.Errorf("第 %d 行单位 = %q，期望 %q", i+1, got, w)
+		}
+	}
+}
+
+// 全部成绩（单页）：与分项成绩表同源，单位列同样带上队名。
+func TestFlatSheetShowsSquadAfterUnitName(t *testing.T) {
+	db := openEventDB(t)
+	seedSquads(t, db)
+	seedChannelRanks(t, db)
+
+	dst := filepath.Join(t.TempDir(), "单页.xlsx")
+	if err := ExportFlatXLSX(db, dst, Options{}); err != nil {
+		t.Fatalf("导出全部成绩（单页）: %v", err)
+	}
+	rows := readSheet(t, dst, "全部成绩")
+
+	// 单页表在「名次」前多了 大项/小项/组别 三列，单位列是第 6 列。
+	want := []string{"第一分公司一队", "第一分公司二队", "第二分公司"}
+	for i, w := range want {
+		if got := cell(rows, 4+i, 5); got != w {
+			t.Errorf("第 %d 行单位 = %q，期望 %q", i+1, got, w)
+		}
+	}
+}
+
+// 报名名单：单位名列在队名非空时写「单位名+队名」，不区分队伍的报名照旧只写单位名。
+func TestEntriesSheetShowsSquadAfterUnitName(t *testing.T) {
+	db := openEventDB(t)
+	seedSquads(t, db)
+
+	dst := filepath.Join(t.TempDir(), "报名名单.xlsx")
+	if err := ExportEntriesXLSX(db, dst, EntriesFilter{}, Options{}); err != nil {
+		t.Fatalf("导出报名名单: %v", err)
+	}
+	rows := readSheet(t, dst, "报名名单")
+
+	// 列序：小项编码/小项名/组别/单位编码/单位名/…，单位名是第 5 列。
+	want := []string{"第一分公司一队", "第一分公司二队", "第二分公司"}
+	for i, w := range want {
+		if got := cell(rows, 4+i, 4); got != w {
+			t.Errorf("第 %d 行单位名 = %q，期望 %q", i+1, got, w)
+		}
+	}
+}
+
+// 单位奖牌明细：总表的单位列按该奖牌对应报名项的队名写全；一个单位两个队各拿一块牌，
+// 就是两块牌（口径 3），不合并、不去重。
+func TestMedalDetailShowsSquadAfterUnitName(t *testing.T) {
+	db := openEventDB(t)
+	seedSquads(t, db)
+	seedChannelRanks(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() }()
+
+	wantSheets := []string{"单位奖牌明细", "第一分公司奖牌明细", "第二分公司奖牌明细"}
+	if got := f.GetSheetList(); !equalStrings(got, wantSheets) {
+		t.Fatalf("sheet 列表 = %v，期望 %v", got, wantSheets)
+	}
+
+	master, err := f.GetRows("单位奖牌明细")
+	if err != nil {
+		t.Fatalf("读取总表: %v", err)
+	}
+	want := []string{"第一分公司一队", "第一分公司二队", "第二分公司"}
+	for i, w := range want {
+		if got := cell(master, 4+i, 0); got != w {
+			t.Errorf("总表第 %d 行单位 = %q，期望 %q", i+1, got, w)
+		}
+	}
+	// 第一分公司是一枚金牌加一枚银牌（两个队各一块），分表的小计照实写两块。
+	unit, err := f.GetRows("第一分公司奖牌明细")
+	if err != nil {
+		t.Fatalf("读取分表: %v", err)
+	}
+	if got := cell(unit, len(unit)-1, 4); got != "金 1 / 银 1 / 铜 0" {
+		t.Errorf("第一分公司小计 = %q，期望 金 1 / 银 1 / 铜 0", got)
+	}
+}
+
+// 单位积分总明细：总表的单位列按该条流水对应报名项的队名写全（分表没有单位列，表名就是单位）。
+func TestAllTeamDetailsShowsSquadAfterUnitName(t *testing.T) {
+	db := openEventDB(t)
+	seedSquads(t, db)
+	seedChannelRanks(t, db)
+
+	dst := filepath.Join(t.TempDir(), "总明细.xlsx")
+	if err := ExportAllTeamDetailsXLSX(db, dst, Options{}); err != nil {
+		t.Fatalf("导出总明细: %v", err)
+	}
+	rows := readSheet(t, dst, "积分总明细")
+
+	// 列序：单位/序号/大项/小项/组别/运动员/名次/成绩/来源/积分/备注；
+	// 行序按单位总分榜（第一分公司在前），单位内按名次：一队 10 分、二队 8 分，第二分公司 6 分。
+	want := []string{"第一分公司一队", "第一分公司二队", "第二分公司"}
+	for i, w := range want {
+		if got := cell(rows, 4+i, 0); got != w {
+			t.Errorf("总明细第 %d 行单位 = %q，期望 %q", i+1, got, w)
+		}
+	}
+	if got := cell(rows, 7, 0); got != "合计" {
+		t.Errorf("末行首列 = %q，期望 合计", got)
+	}
+}
+
+// 队名为空（不区分队伍）时，五份导出件的单位名列一个字都不多：这是老数据与单队单位的默认，
+// 导出件必须与升级前逐行一致。
+func TestEmptySquadKeepsPlainUnitName(t *testing.T) {
+	db := openEventDB(t)
+	seedSquads(t, db)
+	seedChannelRanks(t, db)
+
+	dir := t.TempDir()
+	entriesDst := filepath.Join(dir, "报名名单.xlsx")
+	if err := ExportEntriesXLSX(db, entriesDst, EntriesFilter{}, Options{}); err != nil {
+		t.Fatalf("导出报名名单: %v", err)
+	}
+	// 第三条报名（第二分公司）没有队名。
+	if got := cell(readSheet(t, entriesDst, "报名名单"), 6, 4); got != "第二分公司" {
+		t.Errorf("空队名的单位名 = %q，期望 第二分公司", got)
+	}
+
+	medalDst := filepath.Join(dir, "奖牌.xlsx")
+	if err := ExportMedalDetailXLSX(db, medalDst, Options{}); err != nil {
+		t.Fatalf("导出单位奖牌明细: %v", err)
+	}
+	if got := cell(readSheet(t, medalDst, "单位奖牌明细"), 6, 0); got != "第二分公司" {
+		t.Errorf("空队名的奖牌总表单位 = %q，期望 第二分公司", got)
+	}
+
+	detailDst := filepath.Join(dir, "总明细.xlsx")
+	if err := ExportAllTeamDetailsXLSX(db, detailDst, Options{}); err != nil {
+		t.Fatalf("导出总明细: %v", err)
+	}
+	if got := cell(readSheet(t, detailDst, "积分总明细"), 6, 0); got != "第二分公司" {
+		t.Errorf("空队名的总明细单位 = %q，期望 第二分公司", got)
+	}
+}

server/internal/export/team.go

@@ -23,6 +23,10 @@ type TeamDetailRow struct {
 	Remark      string
 	// individual 标记该条流水记到个人：合计要按 individual_to_team_weight 折算。
 	individual bool
+
+	// squad 是这条流水对应报名项的队名（entries.squad），只有总明细的「单位」列用它：
+	// 单位分表的表名就是单位（一份单位级清单），没有单位列可写，所以那里不展示队名。
+	squad string
 }
 
 // TeamDetailWorkbook 是「单位积分明细」的内容。

server/internal/export/team_all.go

@@ -94,8 +94,15 @@ func allTeamDetailRows(sheets []TeamDetailSheet, weight float64) [][]any {
 		unit := displayName(s.Team.Name, s.Team.ShortName)
 		rows, sub := teamDetailDataRows(s.Rows, weight)
 		total += sub
-		for _, row := range rows {
-			out = append(out, append([]any{unit}, row...))
+		for i, row := range rows {
+			// 队名接在单位名后面（口径：单位名+队名）：一行分是哪个队拿的，总表上要认得出来。
+			// 空队名时一个字都不加（老数据与单队单位的导出件与升级前逐行一致）。
+			// dataRows 逐行按原序产出，索引与 s.Rows 一一对应。
+			label := unit
+			if i < len(s.Rows) {
+				label = withSquad(unit, s.Rows[i].squad)
+			}
+			out = append(out, append([]any{label}, row...))
 		}
 	}
 	// 列序：单位 / 序号 / 大项 / 小项 / 组别 / 运动员 / 名次 / 成绩 / 来源 / 积分 / 备注。

server/internal/httpapi/channel_compare_guard_test.go

@@ -0,0 +1,90 @@
+package httpapi_test
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+	"testing"
+)
+
+// seedCompareNoneEventNoCategory 造一个 compare=none 的个人小项，**不带任何组别**。
+//
+// 这样的现场以前能把 basis=result 的通道存进去：recomputeLedgerTx 是逐组别算的
+// （scoring.go 里 `for _, cat := range cats`），没有组别就一轮都不跑，domain.ScoreEvent 的
+// ErrCompareRequired 根本到不了，通道配置就这么落库了。带组别的小项则会在这里撞 409，但那是
+// 原始领域错误（「domain: basis=result 的通道要求小项配置 compare=asc/desc」），操作员看不出该改什么。
+func seedCompareNoneEventNoCategory(t *testing.T, env *testEnv, ids seedIDs, code, name string) int64 {
+	t.Helper()
+	return env.insert(t,
+		`INSERT INTO events (sport_id, code, name, event_type, result_mode, result_type, compare, scored, multiplier, status)
+		 VALUES (?, ?, ?, 'individual', 'manual', 'none', 'none', 1, 1, 'ongoing')`, ids.sport, code, name)
+}
+
+// compare=none 的小项不得配 basis=result / basis=aggregate 的通道——这条守卫以前只在规则包导入里
+// （rules/diff.go checkCompareCompatible），管理端手工配的这条路没人拦：现场形态就是一个台球小项
+// （compare=none，名次靠人工录入）被配上 basis=result 的通道，一直配到发布才 409。
+func TestReplaceChannelsRejectsResultBasisOnCompareNoneEvent(t *testing.T) {
+	env := newTestEnv(t)
+	ids := env.seed(t)
+	client := recorderClient(t, env)
+	eventID := seedCompareNoneEventNoCategory(t, env, ids, "Z_CN", "台球")
+
+	var profileID int64
+	if err := env.ev.QueryRow(`SELECT id FROM scoring_profiles WHERE code = 'individual_top6'`).Scan(&profileID); err != nil {
+		t.Fatalf("读取积分模板: %v", err)
+	}
+	channels := fmt.Sprintf("/api/events/%d/channels", eventID)
+
+	// 两种 basis 都要拦，且提示要点名小项、说清原因是 compare=none、并给出可执行的改法。
+	for _, basis := range []string{"result", "aggregate"} {
+		status, resp := env.do(client, http.MethodPut, channels, map[string]any{
+			"channels": []map[string]any{{"scope": "athlete", "basis": basis, "profileId": profileID}},
+		}, true)
+		if status != http.StatusBadRequest || resp.Error == nil {
+			t.Fatalf("compare=none 配 basis=%s 应 400，得到 %d %+v", basis, status, resp.Error)
+		}
+		for _, want := range []string{"台球", "compare=none", basis, "手动录名次"} {
+			if !strings.Contains(resp.Error.Message, want) {
+				t.Fatalf("basis=%s 的 400 文案应含 %q，得到 %q", basis, want, resp.Error.Message)
+			}
+		}
+	}
+
+	// 整包拒收：一个字节都不写。
+	status, resp := env.do(client, http.MethodGet, channels, nil, false)
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("读通道列表应 200，得到 %d %+v", status, resp.Error)
+	}
+	if list := decodeData[[]map[string]any](t, resp); len(list) != 0 {
+		t.Fatalf("被拒的保存不该写下任何通道，得到 %+v", list)
+	}
+
+	// 合法的改法照常放行：改成 basis=manual。
+	status, resp = env.do(client, http.MethodPut, channels, map[string]any{
+		"channels": []map[string]any{{"scope": "athlete", "basis": "manual", "profileId": profileID}},
+	}, true)
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("compare=none 配 basis=manual 应 200，得到 %d %+v", status, resp.Error)
+	}
+}
+
+// 对照：有比较方向的小项照常可以配 basis=result / aggregate，这条守卫不能误伤正常配置。
+func TestReplaceChannelsAllowsResultBasisWhenCompareIsSet(t *testing.T) {
+	env := newTestEnv(t)
+	ids := env.seed(t)
+	client := recorderClient(t, env)
+
+	var profileID int64
+	if err := env.ev.QueryRow(`SELECT id FROM scoring_profiles WHERE code = 'individual_top6'`).Scan(&profileID); err != nil {
+		t.Fatalf("读取积分模板: %v", err)
+	}
+	status, resp := env.do(client, http.MethodPut, fmt.Sprintf("/api/events/%d/channels", ids.event), map[string]any{
+		"channels": []map[string]any{
+			{"scope": "athlete", "basis": "result", "profileId": profileID},
+			{"scope": "team", "basis": "aggregate", "profileId": profileID},
+		},
+	}, true)
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("compare=asc 的小项配 result/aggregate 应 200，得到 %d %+v", status, resp.Error)
+	}
+}

server/internal/httpapi/dto.go

@@ -112,10 +112,15 @@ type profileDTO struct {
 }
 
 type entryDTO struct {
-	ID          int64    `json:"id"`
-	EventID     int64    `json:"eventId"`
-	CategoryID  int64    `json:"categoryId"`
-	TeamID      int64    `json:"teamId"`
+	ID         int64 `json:"id"`
+	EventID    int64 `json:"eventId"`
+	CategoryID int64 `json:"categoryId"`
+	TeamID     int64 `json:"teamId"`
+	// Squad 是「这个单位在本组别的第几支队」（自由文本：一队 / 二队 / 青年队）。
+	// 空串 = 不区分队伍：单队单位与升级前的老数据都是它，行为与升级前完全一致（见迁移 0025）。
+	// 只对纯团体报名（athleteId 为空）有意义：带运动员的报名按 (组别, 单位, 运动员) 唯一，
+	// 同一个人在同一组别不会因为 squad 而多报一次。
+	Squad       string   `json:"squad"`
 	AthleteID   *int64   `json:"athleteId"`
 	MemberNames []string `json:"memberNames"`
 	Bib         *string  `json:"bib"`

server/internal/httpapi/entries_sheet_template.go

@@ -436,8 +436,8 @@ func entryTemplateHeader(language string) []string {
 // 联队（devdocs/19）怎么写，是模板必须教给填表人的事：单位编码写 `A+B`，加号左边是主单位，
 // 积分平均分、奖牌两边各记一枚。中英各一份，与表头语言一致。
 //
-// 文案只能挂在**不会变成数据的载体**上：表头行是导入器认模板的锚点（必须留在第 1 行、12 列
-// 一字不动），工作表名是「小项@组别」的范围锚点（也不能多出一张说明表，否则整份文件按分工作表
+// 文案只能挂在**不会变成数据的载体**上：表头行是导入器认模板的锚点（必须留在第 1 行、列名与
+// importColumns 逐列一致），工作表名是「小项@组别」的范围锚点（也不能多出一张说明表，否则整份文件按分工作表
 // 口径解析时会对不上号）。所以这里用两处：单位编码表头的**单元格批注**（红三角一眼能看见）
 // 与这一列的**输入提示**（点中格子就弹出来）。
 const (
@@ -505,6 +505,7 @@ var entryTemplateWidths = map[string]float64{
 	"heat":         8,
 	"status":       12,
 	"member_names": 26,
+	"squad":        12,
 }
 
 const defaultEntryTemplateWidth = 14
@@ -659,7 +660,7 @@ func writeEntriesTemplateXLSX(out io.Writer, sheets []entriesTemplateSheet) erro
 // 整列一条输入提示（点中格子就弹出）。
 //
 // 只动这两种载体，不碰任何单元格的值与行列结构：填好的表原样传回来时，导入器读到的仍是
-// 「第 1 行 12 列表头 + 数据行」，批注与输入提示不是数据。
+// 「第 1 行表头 + 数据行」（列名与 importColumns 一致），批注与输入提示不是数据。
 func writeEntryJointTeamHint(f *excelize.File, sheet entriesTemplateSheet) error {
 	column := entryTeamCodeColumn()
 	if column < 0 || column >= len(sheet.Headers) || sheet.JointHint == "" {

server/internal/httpapi/entries_sheet_template_test.go

@@ -187,16 +187,16 @@ func TestEntriesTemplateOneSheetPerEventCategory(t *testing.T) {
 	}
 }
 
-// sheetImportHeader 是分工作表模板的完整 12 列表头（含批次列），与服务端模板逐列一致。
+// sheetImportHeader 是分工作表模板的完整 13 列表头（含批次列与队伍列），与服务端模板逐列一致。
 // 既有测试用的 importHeader 少了 heat 列，这里不能复用它，否则每一列都会串位。
-const sheetImportHeader = "event_code,category,team_code,athlete_name,id_card,gender,age,bib,seed,heat,status,member_names"
+const sheetImportHeader = "event_code,category,team_code,athlete_name,id_card,gender,age,bib,seed,heat,status,member_names,squad"
 
 // entryTemplateHeaderForTest 是中文表头（与 importColumns 的中文别名、前端模板同源）。
 func entryTemplateHeaderForTest(t *testing.T) []string {
 	t.Helper()
 	return []string{
 		"项目编码", "组别", "单位编码", "姓名", "证件号", "性别", "年龄",
-		"号码布", "种子", "批次", "状态", "队员名单",
+		"号码布", "种子", "批次", "状态", "队员名单", "队伍",
 	}
 }
 
@@ -214,7 +214,7 @@ func TestEntriesTemplateEnglishHeader(t *testing.T) {
 	}
 	want := []string{
 		"event_code", "category", "team_code", "athlete_name", "id_card", "gender", "age",
-		"bib", "seed", "heat", "status", "member_names",
+		"bib", "seed", "heat", "status", "member_names", "squad",
 	}
 	if !equalStrings(rows[0], want) {
 		t.Fatalf("英文模板表头应为规范列名，得到 %v", rows[0])

server/internal/httpapi/entry_heat_test.go

@@ -7,7 +7,8 @@ import (
 	"testing"
 )
 
-// importHeaderHeat 是带批次列的 12 列表头（与 ImportSection 模板一致）。
+// importHeaderHeat 是带批次列的 12 列表头（升级前的列数，比现在少一个「队伍」列）。
+// 刻意写成字面量：它同时证明「现场手里列少的旧表格照常导入」，不跟着模板一起变。
 const importHeaderHeat = "event_code,category,team_code,athlete_name,id_card,gender,age,bib,seed,heat,status,member_names"
 
 // 批量设置批次：成功写库、GET 下发、再传 null 清除；重复提交幂等。

server/internal/httpapi/entry_squad.go

@@ -0,0 +1,107 @@
+package httpapi
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+)
+
+// 本文件是「队名」的手工修改：PUT /api/entries/{id}/squad（队名本身见迁移 0025）。
+//
+// 为什么需要这条接口：报名只有导入一条写入路径，而导入的 upsert 键是 (组别, 单位, 队名)。
+// 想把已经报的「二队」改成「青年队」，再导一次只会**新增第二支队**（老那条仍挂在库里）——
+// 「填错一个字就得删掉重建」在现场是不能接受的。
+
+// updateEntrySquad 改一条团体报名的队名，返回更新后的完整读数。
+//
+// **不重算**，这是有意的：squad 只是给现场看的标签（榜单、导出件、大屏把「第一分公司」
+// 显示成「第一分公司青年队」）。它不参与名次 / 积分 / 奖牌的任何一个口径——全仓读 squad 的
+// 只有导出与报名读数这两处展示代码，引擎（internal/domain）与 score_ledger / results /
+// channel_ranks 一个字都不看它。所以改它时算分输出的每个字节都不变，这里也就没有
+// recomputeLedgerTx：白算一遍不但慢，还会白白推一次榜（大屏会跟着闪一下没变的名次）。
+// 同档的另一个先例是批次 entries.heat，同样是纯展示字段，改它也不重算（见 setEntriesHeat）。
+func (s *server) updateEntrySquad(ctx context.Context, entryID int64, squad string) (entryDTO, error) {
+	// trim 统一收在这里：导入侧读单元格时已经 trim 过（handlers_config.go 的 cell()），
+	// 手工改走的是另一条路，不 trim 就会把「一队」与「一队 」当成两个队。
+	squad = strings.TrimSpace(squad)
+
+	entry, err := s.getEntry(ctx, entryID)
+	if err != nil {
+		return entryDTO{}, err
+	}
+	// 带运动员的报名按 (组别, 单位, 运动员) 唯一，队名根本不参与它的查重键
+	// （0025 的部分索引带 WHERE athlete_id IS NULL）。写进去既不生效，又会让人以为
+	// 「这个人报了两个队」，所以直接拒掉并说清原因。
+	if entry.AthleteID != nil {
+		return entryDTO{}, badRequest("这条报名带着运动员，队名只对团体报名生效：队名分的是「同一个单位在同一个组别的第几支队」，带运动员的报名按（组别、单位、运动员）唯一，改队名变不出第二支队", nil)
+	}
+
+	// 同组别同单位已经有这个队名时先拦下来：撞索引的报错是英文的约束原文，
+	// 现场看不出是哪个单位、哪个队，也不知道该改哪一格。
+	var other int64
+	err = s.ev.QueryRowContext(ctx,
+		`SELECT id FROM entries
+		  WHERE category_id = ? AND team_id = ? AND athlete_id IS NULL AND squad = ? AND id <> ?`,
+		entry.CategoryID, entry.TeamID, squad, entryID).Scan(&other)
+	switch {
+	case err == nil:
+		return entryDTO{}, badRequest(squadTakenMessage(entry.TeamCode, squad), nil)
+	case !errors.Is(err, sql.ErrNoRows):
+		return entryDTO{}, internal(err)
+	}
+
+	if _, err := s.ev.ExecContext(ctx, `UPDATE entries SET squad = ? WHERE id = ?`, squad, entryID); err != nil {
+		// 预检与 UPDATE 之间不是原子的（两个录入员同时把两条报名改成同一个队名，
+		// 或导入正好在这两步之间落库）：真撞上唯一索引时也要翻成同一句人话。
+		if isUniqueViolation(err) {
+			return entryDTO{}, badRequest(squadTakenMessage(entry.TeamCode, squad), nil)
+		}
+		return entryDTO{}, internal(err)
+	}
+	return s.getEntry(ctx, entryID)
+}
+
+// squadTakenMessage 是「这个队名在本组别已经被同单位占了」的现场文案。
+//
+// 队名非空那一档导入侧也在用（importedEntryConflictError 的并发分支）：两处说的若不是
+// 同一句话，操作员在导入里学到的那句到了改队名页面就不成立，只能重新猜系统在拦什么。
+//
+// 队名留空那一档与导入侧**故意不同**：那边点的是报名表里的「队伍列」，这里没有那一格可点，
+// 只能点「队名留空」。其余口径两边一致：空 = 不区分队伍，一个单位在一个组别只能有一条。
+func squadTakenMessage(teamCode, squad string) string {
+	if squad == "" {
+		return fmt.Sprintf("单位 %s 在本组别已经有一条不分队的团体报名：队名留空就是不区分队伍，一个单位在一个组别只能有一条；要派两个队请把两支队分别写清队名（例如 一队 / 二队）", teamCode)
+	}
+	return fmt.Sprintf("单位 %s 在本组别已经有一条队伍「%s」的报名：「同一个单位同一个组别的同一个队」只能报一条；要派两个队请换一个队伍名（例如 二队）", teamCode, squad)
+}
+
+// updateEntrySquadHandler 是 PUT /api/entries/{id}/squad：改一条团体报名的队名，
+// 成功后返回这条报名的完整读数（与份额那条接口一样，前端拿它直接刷新那一行）。
+//
+// 权限 / CSRF 与 PUT /api/entries/{id}/team-shares 同档：它改的也是报名。
+func (s *server) updateEntrySquadHandler(w http.ResponseWriter, r *http.Request) (any, error) {
+	id, err := pathID(r, "id")
+	if err != nil {
+		return nil, err
+	}
+	var in entrySquadPayload
+	if err := decodeJSON(r, &in); err != nil {
+		return nil, err
+	}
+	return nil, s.idempotent(w, r, in.RequestID, func() (any, error) {
+		before, err := s.getEntry(r.Context(), id)
+		if err != nil {
+			return nil, err
+		}
+		updated, err := s.updateEntrySquad(r.Context(), id, in.Squad)
+		if err != nil {
+			return nil, err
+		}
+		s.audit(r.Context(), "entry.squad.update", "entry", id,
+			map[string]any{"squad": before.Squad}, map[string]any{"squad": updated.Squad})
+		return updated, nil
+	})
+}

server/internal/httpapi/entry_squad_edit_test.go

@@ -0,0 +1,325 @@
+package httpapi_test
+
+import (
+	"database/sql"
+	"fmt"
+	"net/http"
+	"strings"
+	"testing"
+)
+
+// 手工改队名：PUT /api/entries/{id}/squad。
+//
+// 为什么要有这条接口：报名只有导入一条写入路径，而导入的 upsert 键是 (组别, 单位, 队名)。
+// 想把已经报的「二队」改成「青年队」，再导一次只会**新增第二支队**，老那条还挂在库里——
+// 现场「填错一个字就得删掉重建」是不能接受的。
+//
+// 口径（迁移 0025）：队名是自由文本、首尾空白 trim 掉；空串 = 不区分队伍（合法值，
+// 不是「把这条报名清掉」）；只对纯团体报名（athlete_id 为空）有意义。
+
+// updateSquad 调一次改队名接口。
+func updateSquad(t *testing.T, env *testEnv, client *http.Client, entryID int64, squad string, csrf bool) (int, envelope) {
+	t.Helper()
+	return env.do(client, http.MethodPut, fmt.Sprintf("/api/entries/%d/squad", entryID),
+		map[string]any{"squad": squad}, csrf)
+}
+
+// squadDumpThree 是「A 一队 / A 二队 / B 不分队」三条团体报名的落库事实。
+const squadDumpThree = "team_code=A squad=一队 \nteam_code=A squad=二队 \nteam_code=B squad= \n"
+
+// 现场场景：A 的「二队」填错了一个字，改成「青年队」——改的是**原来那一条**，
+// 不是新增第二支队，老那条也不该留下。
+func TestUpdateEntrySquadRenamesInPlace(t *testing.T) {
+	env, ids, client := recorderWithSeed(t)
+	eventID, _ := seedDoublesEvent(t, env, ids)
+	status, resp := importCSVWithHeader(t, env, client, importHeaderSquad,
+		squadImportRow("BADM", "男子", "A", "一队", "张伟/李强"),
+		squadImportRow("BADM", "男子", "A", "二队", "王五/赵六"),
+		squadImportRow("BADM", "男子", "B", "", "孙七/周八"),
+	)
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("导入应 200，得到 %d %+v", status, resp.Error)
+	}
+	if got := squadDump(t, env, eventID); got != squadDumpThree {
+		t.Fatalf("前置条件不成立：\n得到 %s期望 %s", got, squadDumpThree)
+	}
+
+	entryID := entryIDOfSquad(t, env, eventID, "二队")
+	status, resp = updateSquad(t, env, client, entryID, "青年队", true)
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("改队名应 200，得到 %d %+v", status, resp.Error)
+	}
+
+	// 返回更新后的完整读数（前端拿它直接刷新那一行）。
+	updated := decodeData[map[string]any](t, resp)
+	if updated["id"] != float64(entryID) {
+		t.Fatalf("回的应是原来那一条报名 %d，得到 %+v", entryID, updated["id"])
+	}
+	if updated["squad"] != "青年队" {
+		t.Fatalf("回显的队名 = %v，期望 青年队", updated["squad"])
+	}
+	if updated["teamCode"] != "A" || updated["teamName"] != "第一分公司" {
+		t.Fatalf("回显应带单位编码与名称（前端要显示「A 青年队」），得到 %+v", updated)
+	}
+	if updated["memberNames"] == nil {
+		t.Fatalf("回显应是完整读数（含队员名单），得到 %+v", updated)
+	}
+
+	// 落库：还是 3 条，队名换了，没有多出第四支队伍。
+	want := "team_code=A squad=一队 \nteam_code=A squad=青年队 \nteam_code=B squad= \n"
+	if got := squadDump(t, env, eventID); got != want {
+		t.Fatalf("改完队名落库不对：\n得到 %s期望 %s", got, want)
+	}
+	if n := countRows(t, env, `SELECT COUNT(*) FROM entries WHERE event_id = ?`, eventID); n != 3 {
+		t.Fatalf("改队名不该新增报名，得到 %d 条", n)
+	}
+
+	// 报名列表（录入页 / 大屏读的就是它）要带上新队名。
+	board := getEntryBoard(t, env, client, eventID)
+	found := false
+	for _, entry := range board.Entries {
+		if entry["id"] == float64(entryID) {
+			found = true
+			if entry["squad"] != "青年队" {
+				t.Fatalf("报名列表里的队名 = %v，期望 青年队", entry["squad"])
+			}
+		}
+	}
+	if !found {
+		t.Fatalf("报名列表里找不到报名 %d", entryID)
+	}
+
+	// 审计：照份额那套记前后值，事后对账能看出改过哪一格。
+	// waitAudit 取的是 after_json，改动前的队名在 before_json 里（同一行，等它落库后再读）。
+	after := waitAudit(t, env, "entry.squad.update", entryID)
+	if !strings.Contains(after, "青年队") {
+		t.Fatalf("审计的 after 应记下新队名，得到 %s", after)
+	}
+	var before sql.NullString
+	if err := env.ev.QueryRow(`SELECT before_json FROM audit_logs WHERE action = ? AND entity_id = ?`,
+		"entry.squad.update", entryID).Scan(&before); err != nil {
+		t.Fatalf("读审计的 before: %v", err)
+	}
+	if !strings.Contains(before.String, "二队") {
+		t.Fatalf("审计的 before 应记下原队名，得到 %s", before.String)
+	}
+}
+
+// 队名首尾空白一律 trim（导入侧读单元格时已经 trim 过，手工改走的是另一条路）；
+// 只留空白等于空串 = **不区分队伍**，是合法值，不是「把这条报名清掉」。
+func TestUpdateEntrySquadTrimsAndAcceptsBlank(t *testing.T) {
+	env, ids, client := recorderWithSeed(t)
+	eventID, _ := seedDoublesEvent(t, env, ids)
+	status, resp := importCSVWithHeader(t, env, client, importHeaderSquad,
+		squadImportRow("BADM", "男子", "A", "一队", "张伟/李强"),
+		squadImportRow("BADM", "男子", "A", "二队", "王五/赵六"),
+	)
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("导入应 200，得到 %d %+v", status, resp.Error)
+	}
+	two := entryIDOfSquad(t, env, eventID, "二队")
+
+	status, resp = updateSquad(t, env, client, two, "  青年队　", true)
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("队名带空白应 200，得到 %d %+v", status, resp.Error)
+	}
+	if got := decodeData[map[string]any](t, resp)["squad"]; got != "青年队" {
+		t.Fatalf("队名应 trim 首尾空白（含全角空格），得到 %q", got)
+	}
+	want := "team_code=A squad=一队 \nteam_code=A squad=青年队 \n"
+	if got := squadDump(t, env, eventID); got != want {
+		t.Fatalf("trim 后落库不对：\n得到 %s期望 %s", got, want)
+	}
+
+	// 只留空白 → 空串（不区分队伍）：报名还在，只是这条不再挂队名。
+	status, resp = updateSquad(t, env, client, two, "   ", true)
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("清空队名应 200，得到 %d %+v", status, resp.Error)
+	}
+	if got := decodeData[map[string]any](t, resp)["squad"]; got != "" {
+		t.Fatalf("只留空白的队名应落成空串，得到 %q", got)
+	}
+	want = "team_code=A squad=一队 \nteam_code=A squad= \n"
+	if got := squadDump(t, env, eventID); got != want {
+		t.Fatalf("清空队名后落库不对：\n得到 %s期望 %s", got, want)
+	}
+	if n := countRows(t, env, `SELECT COUNT(*) FROM entries WHERE event_id = ?`, eventID); n != 2 {
+		t.Fatalf("空队名是「不区分队伍」，不是删报名：应仍是 2 条，得到 %d 条", n)
+	}
+}
+
+// 拦下的请求必须给人话，且一个字节都不落库。
+func TestUpdateEntrySquadRejectsBadPayloads(t *testing.T) {
+	env, ids, client := recorderWithSeed(t)
+
+	// 第一个小项：A 报了「一队」与不分队各一条，B 也有一条「一队」。
+	eventID, _ := seedDoublesEvent(t, env, ids)
+	status, resp := importCSVWithHeader(t, env, client, importHeaderSquad,
+		squadImportRow("BADM", "男子", "A", "一队", "张伟/李强"),
+		squadImportRow("BADM", "男子", "A", "", "王五/赵六"),
+		squadImportRow("BADM", "男子", "B", "一队", "孙七/周八"),
+	)
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("导入应 200，得到 %d %+v", status, resp.Error)
+	}
+	baseline := squadDump(t, env, eventID)
+	soloEntry := entryIDOfSquad(t, env, eventID, "一队")
+
+	// 第二个小项：A 只有「一队」与「二队」两条，没有不分队那条——用来试「改成不分队会不会撞」。
+	soloEvent := env.insert(t, `INSERT INTO events (sport_id, code, name, event_type, result_mode, result_type,
+	        compare, scored, multiplier, status)
+		VALUES (?, 'VOL2', '排球', 'team', 'auto', 'count', 'desc', 1, 1, 'ongoing')`, ids.sport)
+	env.insert(t, `INSERT INTO event_categories (event_id, name, multiplier, sort_order)
+		VALUES (?, '男子', 1, 0)`, soloEvent)
+	if status, resp := importCSVWithHeader(t, env, client, "event_code,category,team_code,athlete_name,id_card,gender,age,bib,seed,status,member_names,squad",
+		squadImportRow("VOL2", "男子", "A", "一队", "张伟/李强"),
+		squadImportRow("VOL2", "男子", "A", "二队", "王五/赵六")); status != http.StatusOK || !resp.OK {
+		t.Fatalf("第二个小项导入失败：%d %+v", status, resp.Error)
+	}
+	twoEntry := entryIDOfSquad(t, env, soloEvent, "二队")
+
+	cases := []struct {
+		name    string
+		id      int64
+		squad   string
+		csrf    bool
+		status  int
+		wantMsg string
+	}{
+		{
+			name: "撞上同单位同组别的另一个队", id: twoEntry, squad: "一队", csrf: true,
+			status:  http.StatusBadRequest,
+			wantMsg: "单位 A 在本组别已经有一条队伍「一队」的报名",
+		},
+		{
+			name: "改成不分队，但已经有一条不分队的", id: soloEntry, squad: "   ", csrf: true,
+			status:  http.StatusBadRequest,
+			wantMsg: "单位 A 在本组别已经有一条不分队的团体报名",
+		},
+		{
+			// 队名只对纯团体报名生效：带运动员的报名按 (组别, 单位, 运动员) 唯一。
+			name: "带运动员的报名", id: ids.entryB, squad: "一队", csrf: true,
+			status:  http.StatusBadRequest,
+			wantMsg: "队名只对团体报名生效",
+		},
+		{
+			name: "报名不存在", id: 999999, squad: "一队", csrf: true,
+			status: http.StatusNotFound, wantMsg: "报名项不存在",
+		},
+		{
+			// 与 PUT /api/entries/{id}/team-shares 同档：改动报名必须带 CSRF。
+			name: "缺 CSRF", id: twoEntry, squad: "青年队", csrf: false,
+			status: http.StatusForbidden, wantMsg: "CSRF 校验失败",
+		},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			status, resp := updateSquad(t, env, client, tc.id, tc.squad, tc.csrf)
+			if status != tc.status {
+				t.Fatalf("应 %d，得到 %d %+v", tc.status, status, resp)
+			}
+			if resp.Error == nil || !strings.Contains(resp.Error.Message, tc.wantMsg) {
+				t.Fatalf("报错应含 %q，得到 %+v", tc.wantMsg, resp.Error)
+			}
+			// 报错里不该出现 SQLite 的英文原文：现场读不懂，照着它也找不到该改哪一格。
+			if strings.Contains(resp.Error.Message, "UNIQUE constraint failed") {
+				t.Fatalf("不该把 SQLite 原文丢给现场：%s", resp.Error.Message)
+			}
+		})
+	}
+
+	if got := squadDump(t, env, eventID); got != baseline {
+		t.Fatalf("被拒的请求改动了报名表：\n之前 %s之后 %s", baseline, got)
+	}
+	wantSolo := "team_code=A squad=一队 \nteam_code=A squad=二队 \n"
+	if got := squadDump(t, env, soloEvent); got != wantSolo {
+		t.Fatalf("被拒的请求改动了第二个小项的报名表：\n得到 %s期望 %s", got, wantSolo)
+	}
+}
+
+// 未登录一样进不来（与其它报名写接口同档）。
+func TestUpdateEntrySquadRequiresLogin(t *testing.T) {
+	env, _, client := recorderWithSeed(t)
+	anon, _ := env.client()
+	if status, resp := updateSquad(t, env, anon, 1, "一队", false); status != http.StatusUnauthorized {
+		t.Fatalf("未登录改队名应 401，得到 %d %+v", status, resp)
+	}
+	// 登录了但这条报名不存在 → 404（照本仓既有风格）。
+	if status, resp := updateSquad(t, env, client, 999999, "一队", true); status != http.StatusNotFound {
+		t.Fatalf("改不存在的报名应 404，得到 %d %+v", status, resp)
+	}
+}
+
+// 同一个 requestId 重复提交回放首次结果，不重复执行（与其它写接口同一套幂等）。
+func TestUpdateEntrySquadIdempotentByRequestID(t *testing.T) {
+	env, ids, client := recorderWithSeed(t)
+	eventID, _ := seedDoublesEvent(t, env, ids)
+	status, resp := importCSVWithHeader(t, env, client, importHeaderSquad,
+		squadImportRow("BADM", "男子", "A", "二队", "张伟/李强"),
+	)
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("导入应 200，得到 %d %+v", status, resp.Error)
+	}
+	entryID := entryIDOfSquad(t, env, eventID, "二队")
+	path := fmt.Sprintf("/api/entries/%d/squad", entryID)
+
+	if status, resp := env.do(client, http.MethodPut, path,
+		map[string]any{"squad": "青年队", "requestId": "squad-1"}, true); status != http.StatusOK {
+		t.Fatalf("第一次改队名应 200，得到 %d %+v", status, resp.Error)
+	}
+	// 同一个 requestId、换一个队名再来一次：必须是回放，库里仍是第一次的结果。
+	status, resp = env.do(client, http.MethodPut, path,
+		map[string]any{"squad": "少年队", "requestId": "squad-1"}, true)
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("重复提交应回放首次结果，得到 %d %+v", status, resp.Error)
+	}
+	if got := decodeData[map[string]any](t, resp)["squad"]; got != "青年队" {
+		t.Fatalf("回放的应是首次结果（青年队），得到 %v", got)
+	}
+	want := "team_code=A squad=青年队 \n"
+	if got := squadDump(t, env, eventID); got != want {
+		t.Fatalf("重复提交不该再改一次库：\n得到 %s期望 %s", got, want)
+	}
+}
+
+// 队名只是显示用的标签：改名前后**一切算分输出**逐字节相同。
+//
+// 这是「改队名不重算」这条决定的正面证据：积分流水、成绩名次、积分榜上的总分与金银铜
+// 一个都不该动。真要动了，说明队名混进了算分口径，那才是 bug。
+func TestUpdateEntrySquadDoesNotChangeScoring(t *testing.T) {
+	env, ids, client := recorderWithSeed(t)
+	eventID, _ := seedDoublesEvent(t, env, ids)
+	status, resp := importCSVWithHeader(t, env, client, importHeaderSquad,
+		squadImportRow("BADM", "男子", "A", "一队", "张伟/李强"),
+		squadImportRow("BADM", "男子", "A", "二队", "王五/赵六"),
+		squadImportRow("BADM", "男子", "B", "", "孙七/周八"),
+	)
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("导入应 200，得到 %d %+v", status, resp.Error)
+	}
+	publishResults(t, env, client, eventID, "squad",
+		map[string]any{"entryId": entryIDOfSquad(t, env, eventID, "一队"), "resultValue": 21, "resultText": "21", "status": "ok"},
+		map[string]any{"entryId": entryIDOfSquad(t, env, eventID, "二队"), "resultValue": 18, "resultText": "18", "status": "ok"},
+		map[string]any{"entryId": entryIDOfSquad(t, env, eventID, ""), "resultValue": 15, "resultText": "15", "status": "ok"},
+	)
+	assertStanding(t, env, client, ids.teamA, 25, 1, 1, 0)
+	assertStanding(t, env, client, ids.teamB, 8, 0, 0, 1)
+
+	// 算分输出：积分流水（含作废标记）与成绩名次，逐字节对拍。
+	scoring := func() string {
+		return tableDump(t, env, `SELECT id, entry_id, team_id, points, voided FROM score_ledger ORDER BY id`) +
+			tableDump(t, env, `SELECT entry_id, COALESCE(rank, 0), state FROM results ORDER BY entry_id`)
+	}
+	before := scoring()
+
+	status, resp = updateSquad(t, env, client, entryIDOfSquad(t, env, eventID, "二队"), "青年队", true)
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("改队名应 200，得到 %d %+v", status, resp.Error)
+	}
+
+	if after := scoring(); after != before {
+		t.Fatalf("改队名动了算分输出：\n之前 %s之后 %s", before, after)
+	}
+	assertStanding(t, env, client, ids.teamA, 25, 1, 1, 0)
+	assertStanding(t, env, client, ids.teamB, 8, 0, 0, 1)
+}

server/internal/httpapi/entry_squad_internal_test.go

@@ -0,0 +1,93 @@
+package httpapi
+
+import (
+	"database/sql"
+	"errors"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	_ "modernc.org/sqlite"
+
+	"git.yeij.top/AskaEth/Scoreboard/server/internal/store"
+)
+
+// 撞上唯一索引时给现场的必须是人话：SQLite 的原文是
+// 「UNIQUE constraint failed: entries.category_id, entries.team_id, entries.squad」，
+// 里面没有单位、没有队伍，操作员照着它找不出该改哪一格。
+//
+// 这条分支只有**并发导入同一份名单**（或库里那条报名正好在查重与落库之间建好）才会走到，
+// HTTP 层造不稳定，所以在函数级别钉住文案：三种情形（同一个队 / 不分队 / 同一个人）
+// 说的都得是「哪个单位、哪个队、怎么办」。
+func TestImportedEntryConflictErrorMessage(t *testing.T) {
+	db := openSquadTestDB(t)
+	s := &server{ev: db}
+	unique := errors.New("UNIQUE constraint failed: entries.category_id, entries.team_id, entries.squad")
+
+	athleteID := int64(7)
+	cases := []struct {
+		name string
+		in   entryDTO
+		want []string
+	}{
+		{
+			name: "同一个单位的同一个队",
+			in:   entryDTO{TeamID: 1, Squad: "一队"},
+			want: []string{"单位 A", "队伍「一队」", "同一个单位同一个组别的同一个队", "二队"},
+		},
+		{
+			name: "同一个单位的不分队报名",
+			in:   entryDTO{TeamID: 1},
+			want: []string{"单位 A", "不分队", "队伍列留空", "一队 / 二队"},
+		},
+		{
+			name: "同一个人在同一组别",
+			in:   entryDTO{TeamID: 1, AthleteID: &athleteID, Squad: "一队"},
+			want: []string{"单位 A", "同一个人在同一组别只能报一条"},
+		},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			err := s.importedEntryConflictError(t.Context(), tc.in, unique)
+			if err == nil {
+				t.Fatal("唯一键冲突应被翻译成人话，得到 nil")
+			}
+			msg := err.Error()
+			for _, want := range tc.want {
+				if !strings.Contains(msg, want) {
+					t.Errorf("报错里少了 %q：%s", want, msg)
+				}
+			}
+			// 英文的约束原文留给日志，不该出现在给现场看的这一句里。
+			if strings.Contains(msg, "UNIQUE constraint failed") {
+				t.Errorf("报错不该把 SQLite 原文丢给现场：%s", msg)
+			}
+		})
+	}
+
+	// 不是唯一键冲突的错误（外键、CHECK、锁超时）原样返回：
+	// 把它们说成「重复报名」会把排查方向带偏。
+	other := errors.New("FOREIGN KEY constraint failed")
+	if got := s.importedEntryConflictError(t.Context(), entryDTO{TeamID: 1}, other); got != other {
+		t.Fatalf("非唯一键冲突应原样返回，得到 %v", got)
+	}
+}
+
+// openSquadTestDB 开一个空的赛事库（跑完全部迁移），造一个单位 A 供报错文案使用。
+func openSquadTestDB(t *testing.T) *sql.DB {
+	t.Helper()
+	dsn := "file:" + filepath.Join(t.TempDir(), "event.db") + "?_pragma=foreign_keys(1)"
+	db, err := sql.Open("sqlite", dsn)
+	if err != nil {
+		t.Fatalf("打开赛事库: %v", err)
+	}
+	db.SetMaxOpenConns(1)
+	t.Cleanup(func() { _ = db.Close() })
+	if err := store.MigrateEvent(db); err != nil {
+		t.Fatalf("迁移赛事库: %v", err)
+	}
+	if _, err := db.Exec(`INSERT INTO teams(code, name) VALUES ('A', '第一分公司')`); err != nil {
+		t.Fatalf("造单位: %v", err)
+	}
+	return db
+}

server/internal/httpapi/entry_squad_test.go

@@ -0,0 +1,331 @@
+package httpapi_test
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+	"testing"
+)
+
+// 队伍（squad）：同一个单位在同一个组别可以派多个队参赛（羽毛球双打那种：一个单位两个队，
+// 两个队各占一个名次）。
+//
+// 口径（迁移 0025）：
+//   - squad 是自由文本（一队 / 二队 / 青年队 都能写），**空串 = 不区分队伍**——老数据与单队单位的
+//     默认值，行为与升级前一模一样（一个单位在这个组别一条团体报名）；
+//   - 只对**纯团体报名**（athlete_id 为空）放开：带运动员的报名仍按 (组别, 单位, 运动员) 唯一，
+//     同一个人在同一组别不会因为这次改动而报两次；
+//   - 一个单位两个队都进前三就是 2 枚牌，引擎本来就按报名逐条记牌，不走特判。
+
+// importHeaderSquad 是带「队伍」列的表头：新列**加在最后**，既有表格一列不错位。
+const importHeaderSquad = importHeader + ",squad"
+
+// importHeaderSquadZH 是中文别名表头（队伍 = importColumns 里 squad 的首选别名）。
+const importHeaderSquadZH = importHeaderZH + ",队伍"
+
+// squadImportRow 拼一行团体报名（无姓名 = 团体行），列序与 importHeaderSquad 一致。
+func squadImportRow(eventCode, category, teamCode, squad, members string) string {
+	return strings.Join([]string{eventCode, category, teamCode, "",
+		"", "", "", "", "", "registered", members, squad}, ",")
+}
+
+// importCSVWithHeader 用指定表头上传一份单表 CSV。
+func importCSVWithHeader(t *testing.T, env *testEnv, client *http.Client, header string, rows ...string) (int, envelope) {
+	t.Helper()
+	content := header + "\n" + strings.Join(rows, "\n") + "\n"
+	return env.postImport(t, client, "/api/entries/import", content, "")
+}
+
+// seedDoublesEvent 建一个「羽毛球双打」形态的小项：team 类型 + 按成绩排名的团体通道
+// （团体报名项各录各的成绩、各占各的名次），返回小项与组别 id。
+func seedDoublesEvent(t *testing.T, env *testEnv, ids seedIDs) (eventID, categoryID int64) {
+	t.Helper()
+	eventID = env.insert(t, `INSERT INTO events (sport_id, code, name, event_type, result_mode, result_type,
+	        compare, scored, multiplier, status)
+		VALUES (?, 'BADM', '羽毛球双打', 'team', 'auto', 'count', 'desc', 1, 1, 'ongoing')`, ids.sport)
+	categoryID = env.insert(t, `INSERT INTO event_categories (event_id, name, multiplier, sort_order)
+		VALUES (?, '男子', 1, 0)`, eventID)
+	env.exec(t, `INSERT INTO event_score_channels (event_id, scope, basis, profile_id, sort_order)
+		VALUES (?, 'team', 'result', ?, 0)`, eventID, profileIDByCode(t, env, "team_top6"))
+	return eventID, categoryID
+}
+
+// squadDump 导出某小项「单位 → 队伍」的落库事实（按报名 id 排序，稳定可比）。
+// 刻意不带报名 id：id 由种子数据占位，断言里写死 id 只会让用例变脆。
+func squadDump(t *testing.T, env *testEnv, eventID int64) string {
+	t.Helper()
+	return tableDump(t, env, fmt.Sprintf(
+		`SELECT t.code AS team_code, e.squad
+		   FROM entries e JOIN teams t ON t.id = e.team_id
+		  WHERE e.event_id = %d ORDER BY e.id`, eventID))
+}
+
+// 现场场景：一个单位派两个队报名。升级前第二条会被唯一索引拦住（一条团体报名），
+// 现在两条都要落库、各自有名次、各自拿牌。
+func TestImportSquadCreatesSecondTeamOfSameUnit(t *testing.T) {
+	env, ids, client := recorderWithSeed(t)
+	eventID, _ := seedDoublesEvent(t, env, ids)
+
+	status, resp := importCSVWithHeader(t, env, client, importHeaderSquad,
+		squadImportRow("BADM", "男子", "A", "一队", "张伟/李强"),
+		squadImportRow("BADM", "男子", "A", "二队", "王五/赵六"),
+		squadImportRow("BADM", "男子", "B", "", "孙七/周八"),
+	)
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("导入应 200，得到 %d %+v", status, resp.Error)
+	}
+	result := decodeData[entryImportResultBody](t, resp)
+	if len(result.Errors) != 0 {
+		t.Fatalf("不该有报错行：%v", result.Errors)
+	}
+	if result.Created != 3 {
+		t.Fatalf("一个单位两个队应是 3 条报名（A 两条 + B 一条），得到 created=%d updated=%d：%s",
+			result.Created, result.Updated, squadDump(t, env, eventID))
+	}
+
+	// 落库：两个队的 squad 各自留着，空串那条就是老口径「不区分队伍」。
+	rows, err := env.ev.Query(`SELECT t.code, e.squad FROM entries e JOIN teams t ON t.id = e.team_id
+	                              WHERE e.event_id = ? ORDER BY e.id`, eventID)
+	if err != nil {
+		t.Fatalf("读报名: %v", err)
+	}
+	defer func() { _ = rows.Close() }()
+	var got []string
+	for rows.Next() {
+		var code, squad string
+		if err := rows.Scan(&code, &squad); err != nil {
+			t.Fatalf("扫描报名: %v", err)
+		}
+		got = append(got, code+":"+squad)
+	}
+	want := "A:一队 A:二队 B:"
+	if joined := strings.Join(got, " "); joined != want {
+		t.Fatalf("落库的队伍不对：\n得到 %s\n期望 %s", joined, want)
+	}
+
+	// 名次：一队第 1、二队第 2、B 第 3 —— 两个队都进前三，A 拿 2 枚牌（金 1 银 1）。
+	publishResults(t, env, client, eventID, "squad",
+		map[string]any{"entryId": entryIDOfSquad(t, env, eventID, "一队"), "resultValue": 21, "resultText": "21", "status": "ok"},
+		map[string]any{"entryId": entryIDOfSquad(t, env, eventID, "二队"), "resultValue": 18, "resultText": "18", "status": "ok"},
+		map[string]any{"entryId": entryIDOfSquad(t, env, eventID, ""), "resultValue": 15, "resultText": "15", "status": "ok"},
+	)
+	assertStanding(t, env, client, ids.teamA, 25, 1, 1, 0)
+	assertStanding(t, env, client, ids.teamB, 8, 0, 0, 1)
+
+	// 报名列表要把队伍带出来（前端据此区分「A 一队 / A 二队」）。
+	board := getEntryBoard(t, env, client, eventID)
+	byID := map[float64]string{}
+	for _, entry := range board.Entries {
+		id, _ := entry["id"].(float64)
+		squad, _ := entry["squad"].(string)
+		byID[id] = squad
+	}
+	for _, want := range []struct {
+		squad string
+	}{{"一队"}, {"二队"}, {""}} {
+		id := float64(entryIDOfSquad(t, env, eventID, want.squad))
+		if byID[id] != want.squad {
+			t.Errorf("报名 %v 的队伍 = %q，期望 %q", id, byID[id], want.squad)
+		}
+	}
+}
+
+// 老表零变化：表里没有队伍列（或整列留空）时，一个单位在一个组别仍然只有一条团体报名——
+// 第二条是**更新**那一条，不是新增（升级前的行为一字不改）。
+func TestImportSquadKeepsLegacyBehaviourWhenColumnEmpty(t *testing.T) {
+	env, ids, client := recorderWithSeed(t)
+	eventID, _ := seedDoublesEvent(t, env, ids)
+
+	// 先走升级前的老表头（连队伍列都没有）。
+	status, resp := importCSV(t, env, client, jointImportRow("BADM", "男子", "A"))
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("不带队伍列的老表应照常导入，得到 %d %+v", status, resp.Error)
+	}
+	if result := decodeData[entryImportResultBody](t, resp); result.Created != 1 {
+		t.Fatalf("老表应新建 1 条：%+v", result)
+	}
+
+	// 同一份老表再传一次：更新那一条，不新增（老行为）。
+	status, resp = importCSV(t, env, client, jointImportRow("BADM", "男子", "A"))
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("老表重传应照常更新，得到 %d %+v", status, resp.Error)
+	}
+	result := decodeData[entryImportResultBody](t, resp)
+	if result.Created != 0 || result.Updated != 1 || result.Skipped != 0 {
+		t.Fatalf("同一份老表重传应是「新建 0 / 更新 1」，得到 %+v", result)
+	}
+
+	// 带队伍列的表格、但那一格留空：同样是不区分队伍的老口径（B 与 A 各一条）。
+	status, resp = importCSVWithHeader(t, env, client, importHeaderSquad,
+		squadImportRow("BADM", "男子", "B", "", "孙七/周八"))
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("队伍留空应照常导入，得到 %d %+v", status, resp.Error)
+	}
+	want := "team_code=A squad= \nteam_code=B squad= \n"
+	if got := squadDump(t, env, eventID); got != want {
+		t.Fatalf("老口径落库不对：\n得到 %s期望 %s", got, want)
+	}
+}
+
+// 同一个队重复导入是幂等的（后一行覆盖前一行）；换一个队伍名才是第二个队。
+func TestImportSquadSameTeamTwiceIsIdempotent(t *testing.T) {
+	env, ids, client := recorderWithSeed(t)
+	eventID, _ := seedDoublesEvent(t, env, ids)
+
+	status, resp := importCSVWithHeader(t, env, client, importHeaderSquad,
+		squadImportRow("BADM", "男子", "A", "一队", "张伟/李强"),
+		squadImportRow("BADM", "男子", "A", "一队", "张伟/李强/王五"),
+	)
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("导入应 200，得到 %d %+v", status, resp.Error)
+	}
+	result := decodeData[entryImportResultBody](t, resp)
+	if result.Created != 1 || result.Updated != 1 || result.Skipped != 0 {
+		t.Fatalf("同一个队重传应是「新建 1 / 更新 1」（后一行覆盖前一行），得到 %+v", result)
+	}
+	if got := countRows(t, env, `SELECT COUNT(*) FROM entries WHERE event_id = ?`, eventID); got != 1 {
+		t.Fatalf("同一个队重传后库里应只有 1 条报名，得到 %d 条：%s", got, squadDump(t, env, eventID))
+	}
+	// 后一行覆盖前一行：队员名单以最后一行写的为准。
+	if got := tableDump(t, env, fmt.Sprintf(`SELECT member_names FROM entries WHERE event_id = %d`, eventID)); !strings.Contains(got, "王五") {
+		t.Fatalf("后一行应覆盖前一行的队员名单，得到 %s", got)
+	}
+
+	// 换一个队伍名 = 第二个队：新增一条。
+	status, resp = importCSVWithHeader(t, env, client, importHeaderSquad,
+		squadImportRow("BADM", "男子", "A", "二队", "李四/赵六"))
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("导入第二个队应 200，得到 %d %+v", status, resp.Error)
+	}
+	if result := decodeData[entryImportResultBody](t, resp); result.Created != 1 {
+		t.Fatalf("第二个队应新增 1 条：%+v", result)
+	}
+}
+
+// 中文别名：队伍 / 队名 / 队伍名 都认（现场拿到的是中文模板）。
+func TestImportSquadChineseAliases(t *testing.T) {
+	for _, alias := range []string{"队伍", "队名", "队伍名"} {
+		t.Run(alias, func(t *testing.T) {
+			env, ids, client := recorderWithSeed(t)
+			eventID, _ := seedDoublesEvent(t, env, ids)
+
+			header := strings.TrimSuffix(importHeaderSquadZH, "队伍") + alias
+			status, resp := importCSVWithHeader(t, env, client, header,
+				squadImportRow("BADM", "男子", "A", "青年队", "张伟/李强"))
+			if status != http.StatusOK || !resp.OK {
+				t.Fatalf("中文表头 %s 应能导入，得到 %d %+v", alias, status, resp.Error)
+			}
+			if result := decodeData[entryImportResultBody](t, resp); result.Created != 1 {
+				t.Fatalf("应新建 1 条：%+v", result)
+			}
+			want := "team_code=A squad=青年队 \n"
+			if got := squadDump(t, env, eventID); got != want {
+				t.Fatalf("中文表头落库不对：\n得到 %s期望 %s", got, want)
+			}
+		})
+	}
+}
+
+// 带运动员的报名不受队伍影响：同一个人在同一组别写两个队伍名，仍是同一条报名（不会报两次），
+// 并且要有一条 notices 说清「队伍没写进库里」——那一格填了就不该悄悄消失。
+func TestImportSquadIgnoredForAthleteRows(t *testing.T) {
+	env, ids, client := recorderWithSeed(t)
+
+	// 另开一个个人小项：种子里的 M100 有两条报名，掺进来没法一眼看清新增了几条。
+	eventID := env.insert(t, `INSERT INTO events (sport_id, code, name, event_type, result_mode, result_type,
+	        compare, scored, multiplier, status)
+		VALUES (?, 'M200', '200米跑', 'individual', 'auto', 'time', 'asc', 1, 1, 'ongoing')`, ids.sport)
+	env.insert(t, `INSERT INTO event_categories (event_id, name, multiplier, sort_order)
+	               VALUES (?, '男子', 1, 0)`, eventID)
+
+	athleteRow := func(squad string) string {
+		return strings.Join([]string{"M200", "男子", "A", "张三", "110101199001011234", "男", "26",
+			"101", "", "registered", "", squad}, ",")
+	}
+
+	status, resp := importCSVWithHeader(t, env, client, importHeaderSquad, athleteRow("一队"))
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("导入个人行应 200，得到 %d %+v", status, resp.Error)
+	}
+	result := decodeData[entryImportResultBody](t, resp)
+	if result.Created != 1 {
+		t.Fatalf("个人行应新建 1 条：%+v", result)
+	}
+	if joined := strings.Join(result.Notices, "；"); !strings.Contains(joined, "队伍只对团体报名") {
+		t.Fatalf("个人行填了队伍要给一条提示，得到 %v", result.Notices)
+	}
+	if got := countRows(t, env, `SELECT COUNT(*) FROM entries WHERE event_id = ? AND squad <> ''`, eventID); got != 0 {
+		t.Fatalf("个人报名的 squad 必须是空串，得到 %d 条非空", got)
+	}
+
+	// 同一个人换个队伍名重传：还是同一条（同一个人在同一组别不会因为队伍报两次）。
+	status, resp = importCSVWithHeader(t, env, client, importHeaderSquad, athleteRow("二队"))
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("重传应 200，得到 %d %+v", status, resp.Error)
+	}
+	result = decodeData[entryImportResultBody](t, resp)
+	if result.Created != 0 || result.Updated != 1 {
+		t.Fatalf("同一个人换个队伍名重传应仍是那一条（新建 0 / 更新 1），得到 %+v", result)
+	}
+	if got := countRows(t, env, `SELECT COUNT(*) FROM entries WHERE event_id = ?`, eventID); got != 1 {
+		t.Fatalf("同一个人在同一组别应只有 1 条报名，得到 %d 条", got)
+	}
+}
+
+// 模板要在最后多一列「队伍 / squad」：新列追加在表尾，现场手里少一列的旧表格一列都不会错位。
+func TestEntriesTemplatePutsSquadLast(t *testing.T) {
+	env, _, client := recorderWithSeed(t)
+
+	for _, tc := range []struct{ lang, want string }{{"zh", "队伍"}, {"en", "squad"}} {
+		f, _ := env.fetchTemplate(t, client, tc.lang)
+		rows, err := f.GetRows(f.GetSheetList()[0])
+		if err != nil {
+			t.Fatalf("[%s] 读模板: %v", tc.lang, err)
+		}
+		header := rows[0]
+		if len(header) != 13 {
+			t.Fatalf("[%s] 模板表头应是 13 列（原 12 列 + 队伍），得到 %d 列：%v", tc.lang, len(header), header)
+		}
+		if header[len(header)-1] != tc.want {
+			t.Fatalf("[%s] 队伍列必须在最后一列（%q），得到 %q", tc.lang, tc.want, header[len(header)-1])
+		}
+	}
+}
+
+// 老模板（12 列，没有队伍列）照常导入：这是「新列加在最后」的全部意义——
+// 现场手里那些列少的表格一列都不会错位，导入结果与升级前完全一样。
+func TestImportSheetTemplateWithoutSquadColumnStillWorks(t *testing.T) {
+	env, ids, client := recorderWithSeed(t)
+	eventID, _ := seedDoublesEvent(t, env, ids)
+
+	const legacyHeader = "event_code,category,team_code,athlete_name,id_card,gender,age,bib,seed,heat,status,member_names"
+	data := buildTestXLSX(t, []testSheet{
+		{name: "羽毛球双打@男子", rows: [][]string{
+			strings.Split(legacyHeader, ","),
+			{"", "", "A", "", "", "", "", "301", "", "1", "registered", "张伟/李强"},
+		}},
+	})
+	status, resp := env.uploadEntries(t, client, "t.xlsx", data)
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("老模板应照常导入，得到 %d %+v", status, resp.Error)
+	}
+	result := decodeData[entryImportResultBody](t, resp)
+	if result.Created != 1 || len(result.Errors) != 0 {
+		t.Fatalf("应新建 1 条且无报错：%+v", result)
+	}
+	want := "team_code=A squad= \n"
+	if got := squadDump(t, env, eventID); got != want {
+		t.Fatalf("老模板落库的队伍应是空串（不区分队伍）：\n得到 %s期望 %s", got, want)
+	}
+}
+
+// entryIDOfSquad 取某小项里某个队的报名 id（空串 = 不区分队伍的那条）。
+func entryIDOfSquad(t *testing.T, env *testEnv, eventID int64, squad string) int64 {
+	t.Helper()
+	var id int64
+	if err := env.ev.QueryRow(`SELECT id FROM entries WHERE event_id = ? AND squad = ? ORDER BY id LIMIT 1`,
+		eventID, squad).Scan(&id); err != nil {
+		t.Fatalf("读队伍 %q 的报名: %v", squad, err)
+	}
+	return id
+}

server/internal/httpapi/handlers_config.go

@@ -1048,6 +1048,9 @@ var importColumns = []importColumn{
 	{name: "heat", aliases: []string{"批次", "批次号"}, optional: true},
 	{name: "status", aliases: []string{"状态", "报名状态"}},
 	{name: "member_names", aliases: []string{"队员名单"}},
+	// squad（队伍）挂在**最后**：新列追加在表尾，现场手里那些少一列的旧表格一列都不会错位。
+	// 空串 = 不区分队伍，与老口径一致；同一个单位在同一个组别派两个队就靠它区分（迁移 0025）。
+	{name: "squad", aliases: []string{"队伍", "队名", "队伍名"}, optional: true},
 }
 
 // label 是报错时用的列名：英文规范名 + 首选中文别名。缺列提示中英并列，
@@ -1228,6 +1231,9 @@ func (s *server) importEntriesWith(ctx context.Context, sheets []importSheet, de
 			categoryName := cell("category")
 			teamCode := cell("team_code")
 			athleteName := cell("athlete_name")
+			// 队伍是自由文本（一队 / 二队 / 青年队），不做任何归一：现场怎么写就怎么存，
+			// 「一队」与「一 队」是两个队（系统没有立场替现场合并）。
+			squad := cell("squad")
 			if teamCode == "" || (table.scope == nil && eventCode == "") {
 				result.Skipped++
 				if table.scope == nil {
@@ -1432,11 +1438,21 @@ func (s *server) importEntriesWith(ctx context.Context, sheets []importSheet, de
 				teamShares = nil
 			}
 
+			// 队伍只对**纯团体报名**（这一行没填姓名）生效。个人报名按 (组别, 单位, 运动员) 唯一，
+			// squad 不参与那条判断——填了就写不进库，所以要说一句，不能悄悄丢掉这一格。
+			if athleteID != nil && squad != "" {
+				result.Notices = append(result.Notices, prefix+fmt.Sprintf(
+					"第 %d 行填了队伍「%s」，但这一行有运动员姓名、按个人报名处理：队伍只对团体报名（不填姓名那几行）生效，这一格没有写进库里",
+					line, squad))
+				squad = ""
+			}
+
 			outcome, err := s.upsertImportedEntry(ctx, entryDTO{
 				EventID:     eventID,
 				CategoryID:  categoryID,
 				TeamID:      teamID,
 				TeamShares:  teamShares,
+				Squad:       squad,
 				AthleteID:   athleteID,
 				MemberNames: splitNames(cell("member_names")),
 				Bib:         nilIfEmpty(bib),

server/internal/httpapi/joint_team_template_test.go

@@ -10,7 +10,7 @@ import (
 // 积分平均分、奖牌两边各记一枚。
 //
 // 说明只能挂在「不会变成数据」的载体上：表头行是导入器认模板的锚点（必须留在第 1 行、
-// 12 列一成不变），工作表名是「小项@组别」的范围锚点（也不能多出说明表），
+// 列名与 importColumns 逐列一致），工作表名是「小项@组别」的范围锚点（也不能多出说明表），
 // 所以这里用**单元格批注**（表头「单位编码」那一格）+ **该列的输入提示**（选中即弹出）。
 func TestEntriesTemplateExplainsJointTeamCode(t *testing.T) {
 	env, _, client := recorderWithSeed(t)

server/internal/httpapi/payload.go

@@ -53,6 +53,14 @@ type entryTeamSharesPayload struct {
 	RequestID  string              `json:"requestId"`
 }
 
+// entrySquadPayload 是 PUT /api/entries/{id}/squad 的请求体：改一条团体报名的队名。
+// 队名是自由文本，服务端只 trim 首尾空白；空串（或只有空白）是**合法值**，
+// 表示「不区分队伍」，不是「清掉这条报名」（见迁移 0025 与 updateEntrySquad）。
+type entrySquadPayload struct {
+	Squad     string `json:"squad"`
+	RequestID string `json:"requestId"`
+}
+
 // entryBatchPayload 是报名项批量操作的请求体：
 // action 决定语义（scratch 退赛可恢复 / restore 恢复 / remove 物理移出报名），
 // ids 是勾选的报名项（重复会自动去重），reason 可选、只进审计便于事后对账。

server/internal/httpapi/repo_events.go

@@ -712,10 +712,29 @@ func (s *server) replaceChannels(ctx context.Context, eventID int64, in []channe
 
 	// 先确认小项存在（与 replaceCategories 同一处理由）：不做这一步，小项不存在时
 	// 非空表撞 event_id 外键、却被报成「profileId 不存在」，让人去查一个没问题的模板。
-	if _, err := eventByIDQ(ctx, tx, eventID); err != nil {
+	event, err := eventByIDQ(ctx, tx, eventID)
+	if err != nil {
 		return nil, err
 	}
 
+	// compare=none 的小项排不出名次（名次靠人工录入），把 basis=result / aggregate 的通道存进去，
+	// 要等到发布时才会被 domain.ScoreEvent 以 ErrCompareRequired 拒绝（409 STATE_INVALID）——
+	// 那时成绩已经录了一半，回退代价高。规则包导入侧早有这条守卫
+	// （rules/diff.go checkCompareCompatible），手工在管理端配的这条路一直没人拦，在这里补上：
+	// 保存前整包拒收，一个字节都不写，并把「哪条通道、为什么」说清楚。
+	if event.Compare == string(domain.CompareNone) {
+		for i, c := range in {
+			if c.Basis != string(domain.BasisResult) && c.Basis != string(domain.BasisAggregate) {
+				continue
+			}
+			return nil, badRequest(fmt.Sprintf(
+				"小项「%s」的比较方向是「不比较」（compare=none），排不出名次：第 %d 条通道的 basis=%s 要按成绩排名，"+
+					"服务端算不出分、发布会失败。请把它改成「手动录名次」（basis=manual），"+
+					"或先给小项设置比较方向（compare=asc/desc）",
+				event.Name, i+1, c.Basis), map[string]any{"index": i, "basis": c.Basis, "compare": event.Compare})
+		}
+	}
+
 	if _, err := tx.ExecContext(ctx, `DELETE FROM event_score_channels WHERE event_id = ?`, eventID); err != nil {
 		return nil, internal(err)
 	}
@@ -777,8 +796,9 @@ func (s *server) replaceChannels(ctx context.Context, eventID int64, in []channe
 
 // ---------- entries ----------
 
+// squad 挂在最后：列的追加不该动到既有列的下标（scanEntry 按位置扫，加在中间会整列错位）。
 const entryColumns = `e.id, e.event_id, e.category_id, e.team_id, e.athlete_id, e.member_names,
-	e.bib, e.seed, e.heat, e.status, e.remark, a.name, t.code, t.name, t.short_name, c.name`
+	e.bib, e.seed, e.heat, e.status, e.remark, a.name, t.code, t.name, t.short_name, c.name, e.squad`
 
 func scanEntry(row interface{ Scan(...any) error }) (entryDTO, error) {
 	var (
@@ -794,7 +814,8 @@ func scanEntry(row interface{ Scan(...any) error }) (entryDTO, error) {
 		categoryName   sql.NullString
 	)
 	if err := row.Scan(&e.ID, &e.EventID, &e.CategoryID, &e.TeamID, &athleteID, &memberNames,
-		&bib, &seed, &heat, &e.Status, &rem, &athleteName, &teamCode, &teamName, &shortName, &categoryName); err != nil {
+		&bib, &seed, &heat, &e.Status, &rem, &athleteName, &teamCode, &teamName, &shortName, &categoryName,
+		&e.Squad); err != nil {
 		return e, err
 	}
 	e.AthleteID = i64Ptr(athleteID)

server/internal/httpapi/repo_import.go

@@ -646,6 +646,10 @@ func staleScoredEntryError(item staleScopeEntry) error {
 
 // upsertImportedEntry 按「组别 + 单位 + 运动员」去重；返回落点信息，Created 表示新建。
 //
+// 纯团体报名（athlete_id 为空）另加**队伍**这一段：同一个单位在同一个组别可以派多个队参赛
+// （迁移 0025），所以查重键是「组别 + 单位 + 队伍」，队伍为空串就是「不区分队伍」的老口径。
+// 带运动员的报名照旧只认 (组别, 单位, 运动员)：同一个人在同一组别不会因为队伍多报一次。
+//
 // 旧 status 必须在 UPDATE 之前读出来：调用方要靠它判断「这次导入有没有把
 // 正常参赛改成退赛 / 失格」，进而决定要不要重算这一组（见 recomputeImportedScopes）。
 //
@@ -663,8 +667,8 @@ func (s *server) upsertImportedEntry(ctx context.Context, in entryDTO) (entryImp
 			in.CategoryID, in.TeamID, *in.AthleteID).Scan(&existing, &oldStatus)
 	} else {
 		err = s.ev.QueryRowContext(ctx,
-			`SELECT id, status FROM entries WHERE category_id = ? AND team_id = ? AND athlete_id IS NULL`,
-			in.CategoryID, in.TeamID).Scan(&existing, &oldStatus)
+			`SELECT id, status FROM entries WHERE category_id = ? AND team_id = ? AND athlete_id IS NULL AND squad = ?`,
+			in.CategoryID, in.TeamID, entrySquad(in)).Scan(&existing, &oldStatus)
 	}
 
 	status := orDefault(in.Status, "registered")
@@ -675,12 +679,12 @@ func (s *server) upsertImportedEntry(ctx context.Context, in entryDTO) (entryImp
 			return entryImportOutcome{}, err
 		}
 		res, err := s.ev.ExecContext(ctx,
-			`INSERT INTO entries (event_id, category_id, team_id, athlete_id, member_names, bib, seed, heat, status)
-			 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+			`INSERT INTO entries (event_id, category_id, team_id, athlete_id, member_names, bib, seed, heat, status, squad)
+			 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
 			in.EventID, in.CategoryID, in.TeamID, nullI64(in.AthleteID), marshalNames(in.MemberNames),
-			nullStr(in.Bib), nullStr(in.Seed), nullI64(in.Heat), status)
+			nullStr(in.Bib), nullStr(in.Seed), nullI64(in.Heat), status, entrySquad(in))
 		if err != nil {
-			return entryImportOutcome{}, err
+			return entryImportOutcome{}, s.importedEntryConflictError(ctx, in, err)
 		}
 		newID, err := res.LastInsertId()
 		if err != nil {
@@ -726,6 +730,48 @@ func (s *server) upsertImportedEntry(ctx context.Context, in entryDTO) (entryImp
 	}
 }
 
+// entrySquad 返回该写进 entries.squad 的值：**队伍只对纯团体报名有意义**。
+//
+// 带运动员的报名按 (组别, 单位, 运动员) 唯一（表级 UNIQUE，不含 squad）。那一路一律写空串，
+// 两件事同时成立：同一个人换个队伍写法重传仍是同一条（UPDATE，不会撞唯一键），
+// 库里也不会出现「个人报名带着一队 / 二队」这种没人会去看的字段值。
+func entrySquad(in entryDTO) string {
+	if in.AthleteID != nil {
+		return ""
+	}
+	return in.Squad
+}
+
+// importedEntryConflictError 把 INSERT 撞上唯一索引翻译成人话。
+//
+// 索引 idx_entries_team_squad_unique 的键是 (组别, 单位, 队伍) WHERE athlete_id IS NULL；
+// 上面的查重与这次 INSERT 不是原子的，两个人同时导同一份名单、或库里那条报名正好在这两步之间
+// 落库，就会撞上它。SQLite 原文是「UNIQUE constraint failed: entries.category_id,
+// entries.team_id, entries.squad」——现场看不出是哪个单位、哪个队，也不知道该改哪一格，
+// 所以在这里换成点名单位与队伍的一句话。
+//
+// 非唯一键冲突（外键、CHECK、锁超时）原样返回：那些不是「重复报名」，换成重复报名的说法会把人带偏。
+func (s *server) importedEntryConflictError(ctx context.Context, in entryDTO, err error) error {
+	if !isUniqueViolation(err) {
+		return err
+	}
+	teamCode, codeErr := s.teamCodeByID(ctx, in.TeamID)
+	if codeErr != nil {
+		// 连单位编码都查不出来时宁可回原始错误：猜一句「单位 X 重复」会把排查方向带错。
+		return err
+	}
+	if in.AthleteID != nil {
+		return fmt.Errorf("单位 %s 在本组别已经有这个人的报名：同一个人在同一组别只能报一条，请把重复行合并后再导入", teamCode)
+	}
+	if in.Squad == "" {
+		return fmt.Errorf("单位 %s 在本组别已经有一条不分队的团体报名：队伍列留空就是不区分队伍，一个单位在一个组别只能有一条；"+
+			"要派两个队请在队伍列分别写清（例如 一队 / 二队）", teamCode)
+	}
+	// 队名非空那一句与「手工改队名」接口共用（entry_squad.go）：两处说的若不是同一句话，
+	// 操作员在导入里学到的那句到了改队名页面就不成立。
+	return errors.New(squadTakenMessage(teamCode, in.Squad))
+}
+
 // recomputeImportedScopes 重算报名导入动过的 (小项, 组别)，并推小项与榜单。
 //
 // 改的是「谁还算数」，与批量退赛/恢复/移出、作废成绩、撤销发布同一口径：

server/internal/httpapi/server.go

@@ -279,6 +279,9 @@ func (s *server) routes(mux *http.ServeMux) {
 	// 联队份额（devdocs/19）：改一条报名的成员单位与权重，改完当场重算并推榜。
 	// 与其它报名写入同档权限（recorder）：它改的是报名，权限不该比报名导入更宽。
 	mux.HandleFunc("PUT /api/entries/{id}/team-shares", s.write(auth.RoleRecorder, s.updateEntryTeamSharesHandler))
+	// 队名（迁移 0025）：一个单位在一个组别可以派多个队，填错了要能直接改，不能靠「删掉重建」。
+	// 与上面那条同档权限（它改的也是报名）；队名只是展示标签，改它不重算（见 updateEntrySquad）。
+	mux.HandleFunc("PUT /api/entries/{id}/squad", s.write(auth.RoleRecorder, s.updateEntrySquadHandler))
 
 	// 成绩
 	mux.HandleFunc("GET /api/results", s.public(s.listResultsHandler))

server/internal/httpapi/team_manual_ranks_score_test.go

@@ -0,0 +1,82 @@
+package httpapi_test
+
+import (
+	"fmt"
+	"net/http"
+	"testing"
+)
+
+// 现场那份数据的服务端侧：台球（纯团体、名次靠人工录入）六个单位的名次只填在录入页底部的
+// 「团体名次」卡片里（channel_manual_ranks），服务端要按规则包 team_top6 算出 15/10/8/4/2/1，
+// 六个单位合计 40 分。
+//
+// 与 web/src/admin/tests/scoring-team-manual.test.ts 的第一个用例同输入同期望：录入页的实时预览
+// 曾只读行上的 rank，这份数据在预览里显示成每个单位 0 分，而服务端一直算的是 40 分。
+func TestTeamManualRanksSixUnitsProduce40Points(t *testing.T) {
+	env, ids, client := recorderWithSeed(t)
+
+	eventID := env.insert(t, `INSERT INTO events (sport_id, code, name, event_type, result_mode, result_type,
+	        compare, scored, multiplier, status)
+		VALUES (?, 'BALL', '台球', 'team', 'manual', 'none', 'none', 1, 1, 'ongoing')`, ids.sport)
+	categoryID := env.insert(t, `INSERT INTO event_categories (event_id, name, multiplier, sort_order)
+		VALUES (?, '混合组', 1, 0)`, eventID)
+	addTeamManualChannel(t, env, eventID)
+
+	// 六个参赛单位：名次不挂报名项，单位本身就是主体。
+	units := make([]int64, 0, 6)
+	ranks := make([]map[string]any, 0, 6)
+	for i := 1; i <= 6; i++ {
+		teamID := env.insert(t, `INSERT INTO teams (code, name, short_name, sort_order, active)
+			VALUES (?, ?, ?, ?, 1)`, fmt.Sprintf("T%d", i), fmt.Sprintf("第 %d 单位", i), fmt.Sprintf("T%d", i), i)
+		units = append(units, teamID)
+		ranks = append(ranks, map[string]any{"teamId": teamID, "rank": i})
+	}
+
+	status, resp := putTeamRanks(t, env, client, eventID, categoryID, ranks)
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("写六个单位的团体名次应 200，得到 %d %+v", status, resp.Error)
+	}
+
+	got := pointsByTeamDB(t, env, eventID)
+	want := []float64{15, 10, 8, 4, 2, 1}
+	total := 0.0
+	for i, teamID := range units {
+		total += got[teamID]
+		if got[teamID] != want[i] {
+			t.Fatalf("单位 %d（第 %d 名）= %v，期望 %v（全部：%v）", teamID, i+1, got[teamID], want[i], got)
+		}
+	}
+	if total != 40 {
+		t.Fatalf("六个单位合计 = %v，期望 40", total)
+	}
+
+	// 团体名次的分不挂任何报名项（现场成绩表里一行 rank 都没有）。
+	if n := countRows(t, env, `SELECT COUNT(*) FROM score_ledger
+	                            WHERE voided = 0 AND (entry_id IS NOT NULL OR result_id IS NOT NULL)`); n != 0 {
+		t.Fatalf("团体名次的流水不该挂报名项，得到 %d 条", n)
+	}
+}
+
+// pointsByTeamDB 读某小项未作废流水里各单位的分值合计。
+func pointsByTeamDB(t *testing.T, env *testEnv, eventID int64) map[int64]float64 {
+	t.Helper()
+	rows, err := env.ev.Query(`SELECT team_id, COALESCE(SUM(points), 0) FROM score_ledger
+		WHERE voided = 0 AND event_id = ? AND team_id IS NOT NULL GROUP BY team_id`, eventID)
+	if err != nil {
+		t.Fatalf("读流水: %v", err)
+	}
+	defer func() { _ = rows.Close() }()
+	out := make(map[int64]float64)
+	for rows.Next() {
+		var teamID int64
+		var points float64
+		if err := rows.Scan(&teamID, &points); err != nil {
+			t.Fatalf("扫流水: %v", err)
+		}
+		out[teamID] = points
+	}
+	if err := rows.Err(); err != nil {
+		t.Fatalf("遍历流水: %v", err)
+	}
+	return out
+}

server/migrations/event/0025_entry_squad.sql

@@ -0,0 +1,20 @@
+-- 团体项目的「队伍」：同一个单位在同一组别可以派多个队参赛（例如羽毛球双打，一个单位两个队，
+-- 名次可能出现「一个单位两个队各占一个名次」）。队伍的成绩、名次、积分各自记，最后都算到同一个
+-- 单位的总分上（两条报名各拿各的分，单位总分自然就是两队相加）。
+--
+-- 为什么加一列而不是新建「队伍单位」：那样榜单会多出单位、分数也归不到原单位头上。队伍只是
+-- 「这个单位在这一组别里的第几支队」，本质仍是同一个单位的报名。
+--
+-- squad 是**自由文本**（一队 / 二队 / 青年队 都能写），空串 = 不区分队伍 —— 这是老数据与
+-- 单队单位的默认值，行为与升级前完全一致。
+--
+-- 只对**纯团体报名**（athlete_id IS NULL）放开：带运动员的报名仍按 (组别, 单位, 运动员) 唯一，
+-- 同一个运动员不会因为这次改动而在同一组别报两次。
+ALTER TABLE entries ADD COLUMN squad TEXT NOT NULL DEFAULT '';
+
+-- 老的唯一索引只看 (组别, 单位)，一个单位在一个组别只能有一条团体报名 —— 正是它拦住第二个队。
+-- 换成带上 squad 的版本：squad 为空的老数据在新索引下仍然「一个单位一条」，等价。
+DROP INDEX IF EXISTS idx_entries_team_unique;
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_entries_team_squad_unique
+    ON entries(category_id, team_id, squad) WHERE athlete_id IS NULL;

server/migrations/event/migration_0025_test.go

@@ -0,0 +1,174 @@
+package event
+
+import (
+	"database/sql"
+	"fmt"
+	"strings"
+	"testing"
+
+	"git.yeij.top/AskaEth/Scoreboard/server/internal/store"
+)
+
+// 0025：团体项目的「队伍」（entries.squad）。
+//
+// 三条底线：
+//   - 老数据零变化：升级后既有报名的 squad 一律是空串，一个单位在一个组别仍然只能有一条
+//     纯团体报名（唯一索引换成带 squad 的版本后，空串这一档的约束与升级前**等价**）；
+//   - 只给纯团体报名放开：带运动员的报名仍按 (组别, 单位, 运动员) 唯一，同一个人在同一组别
+//     不会因为这次改动多报一次（表级 UNIQUE + 新的部分索引都不覆盖 athlete_id 非空的行）；
+//   - 幂等：重复执行迁移不报错、不改动任何一行。
+func TestMigration0025EntrySquad(t *testing.T) {
+	db := openEventDB(t)
+	applyBefore(t, db, "0025") // 回到「升级前」：库结构到 0024 为止
+
+	stmts := []string{
+		`INSERT INTO teams(code, name) VALUES ('A', '第一分公司')`,
+		`INSERT INTO teams(code, name) VALUES ('B', '第二分公司')`,
+		`INSERT INTO sports(code, name) VALUES ('SP1', '田径')`,
+		`INSERT INTO events(sport_id, code, name, event_type, result_mode, result_type, compare, scored, multiplier, status)
+		 VALUES (1, 'BADM', '羽毛球双打', 'team', 'auto', 'count', 'desc', 1, 1, 'ongoing')`,
+		`INSERT INTO event_categories(event_id, name, multiplier, sort_order) VALUES (1, '男子', 1, 0)`,
+		`INSERT INTO athletes(name, gender, team_id) VALUES ('张伟', '男', 1)`,
+		// 团体报名（athlete_id 为空）与个人报名各一条，升级后都要一字不动。
+		`INSERT INTO entries(event_id, category_id, team_id, athlete_id, member_names, status)
+		 VALUES (1, 1, 1, NULL, '["张伟","李强"]', 'registered')`,
+		`INSERT INTO entries(event_id, category_id, team_id, athlete_id, status) VALUES (1, 1, 2, 1, 'registered')`,
+	}
+
+	// 升级前：老索引拦住第二个队 —— 同一个单位在同一个组别只能有一条团体报名。
+	for _, s := range stmts {
+		if _, err := db.Exec(s); err != nil {
+			t.Fatalf("造老库数据 %q: %v", s, err)
+		}
+	}
+	if _, err := db.Exec(`INSERT INTO entries(event_id, category_id, team_id, athlete_id, status)
+	                      VALUES (1, 1, 1, NULL, 'registered')`); err == nil {
+		t.Fatal("升级前同一个单位的第二条团体报名应被唯一索引拦住")
+	}
+	if _, err := db.Exec(`SELECT squad FROM entries`); err == nil {
+		t.Fatal("升级前不该有 squad 列")
+	} else if !strings.Contains(err.Error(), "squad") {
+		t.Fatalf("查询报错应点明缺列 squad，实际 %v", err)
+	}
+
+	if err := store.MigrateEvent(db); err != nil {
+		t.Fatalf("升级赛事库: %v", err)
+	}
+
+	// 老数据零变化：既有报名一条不少、squad 一律空串。
+	if got := countRows(t, db, "entries"); got != 2 {
+		t.Fatalf("升级后报名数 = %d，期望 2", got)
+	}
+	if got := queryInt(t, db, `SELECT count(*) FROM entries WHERE squad <> ''`); got != 0 {
+		t.Errorf("老数据的 squad 必须是空串（不区分队伍），得到 %d 条非空", got)
+	}
+	if got := queryInt(t, db, `SELECT count(*) FROM entries WHERE team_id = 1 AND squad <> ''`); got != 0 {
+		t.Errorf("老数据的 squad 必须全部是空串，得到 %d 条非空", got)
+	}
+
+	// 老索引没了，换成带 squad 的那条（部分索引：只管 athlete_id 为空的行）。
+	if got := queryInt(t, db, `SELECT count(*) FROM sqlite_master WHERE type = 'index' AND name = 'idx_entries_team_unique'`); got != 0 {
+		t.Errorf("老索引 idx_entries_team_unique 应已被删除，还剩 %d 条", got)
+	}
+	if got := queryInt(t, db, `SELECT count(*) FROM sqlite_master WHERE type = 'index' AND name = 'idx_entries_team_squad_unique'`); got != 1 {
+		t.Errorf("应存在新索引 idx_entries_team_squad_unique，得到 %d 条", got)
+	}
+
+	// 空串这一档的约束与升级前**等价**：同一单位再加一条不分队的团体报名仍然被拒绝。
+	if _, err := db.Exec(`INSERT INTO entries(event_id, category_id, team_id, athlete_id, status)
+	                      VALUES (1, 1, 1, NULL, 'registered')`); err == nil {
+		t.Error("同一个单位同一个组别的第二条「不分队」团体报名应被拒绝（老口径不变）")
+	}
+	// 另一个单位的不分队报名照旧合法。
+	if _, err := db.Exec(`INSERT INTO entries(event_id, category_id, team_id, athlete_id, status)
+	                      VALUES (1, 1, 2, NULL, 'registered')`); err != nil {
+		t.Fatalf("另一个单位的团体报名应合法: %v", err)
+	}
+
+	// 这就是这次改动要放开的事：同一个单位派两个队。
+	if _, err := db.Exec(`INSERT INTO entries(event_id, category_id, team_id, athlete_id, status, squad)
+	                      VALUES (1, 1, 1, NULL, 'registered', '一队')`); err != nil {
+		t.Fatalf("同一个单位的第二个队应能报名: %v", err)
+	}
+	if _, err := db.Exec(`INSERT INTO entries(event_id, category_id, team_id, athlete_id, status, squad)
+	                      VALUES (1, 1, 1, NULL, 'registered', '二队')`); err != nil {
+		t.Fatalf("同一个单位的第三个队应能报名: %v", err)
+	}
+	// 同一个单位的同一个队仍然只能一条。
+	if _, err := db.Exec(`INSERT INTO entries(event_id, category_id, team_id, athlete_id, status, squad)
+	                      VALUES (1, 1, 1, NULL, 'registered', '一队')`); err == nil {
+		t.Error("同一个单位同一个组别的同一个队重复应被唯一索引拒绝")
+	}
+
+	// 带运动员的报名不受影响：同一个人换个单位也是同一个人，仍按 (组别, 单位, 运动员) 唯一。
+	if _, err := db.Exec(`INSERT INTO entries(event_id, category_id, team_id, athlete_id, status, squad)
+	                      VALUES (1, 1, 2, 1, 'registered', '一队')`); err == nil {
+		t.Error("同一个人在同一组别同一单位再报一次应被表级 UNIQUE 拒绝（squad 不参与个人报名）")
+	}
+	if _, err := db.Exec(`INSERT INTO entries(event_id, category_id, team_id, athlete_id, status, squad)
+	                      VALUES (1, 1, 1, 1, 'registered', '一队')`); err != nil {
+		t.Fatalf("同一个人在另一个单位报名应合法: %v", err)
+	}
+
+	// squad 是 NOT NULL DEFAULT ''：老代码（或漏写这一列的语句）插入后仍是空串，不会变成 NULL。
+	if _, err := db.Exec(`INSERT INTO teams(code, name) VALUES ('C', '第三分公司')`); err != nil {
+		t.Fatalf("补一个单位: %v", err)
+	}
+	if _, err := db.Exec(`INSERT INTO entries(event_id, category_id, team_id, athlete_id, status)
+	                      VALUES (1, 1, 3, NULL, 'registered')`); err != nil {
+		t.Fatalf("漏写 squad 的插入应照常成功（默认空串）: %v", err)
+	}
+	if got := queryInt(t, db, `SELECT count(*) FROM entries WHERE squad IS NULL`); got != 0 {
+		t.Errorf("squad 不允许为 NULL，得到 %d 条", got)
+	}
+
+	// 幂等：再跑一次迁移，行数与内容都不变（这条 SQL 里 ADD COLUMN 不可重放，靠记账跳过）。
+	before := dumpEntriesSquad(t, db)
+	if err := store.MigrateEvent(db); err != nil {
+		t.Fatalf("重复升级应无副作用: %v", err)
+	}
+	if got := dumpEntriesSquad(t, db); got != before {
+		t.Fatalf("重复迁移改动了报名：\n之前 %s\n之后 %s", before, got)
+	}
+
+	// 外键悬挂检查。
+	fkRows, err := db.Query(`PRAGMA foreign_key_check`)
+	if err != nil {
+		t.Fatalf("外键检查: %v", err)
+	}
+	defer func() { _ = fkRows.Close() }()
+	if fkRows.Next() {
+		t.Error("迁移后存在外键悬挂")
+	}
+
+	// 迁移登记数对得上（这条迁移被记账一次）。
+	if got, want := countRows(t, db, "schema_migrations"), migrationCount(t); got != want {
+		t.Errorf("迁移登记数 = %d，期望 %d", got, want)
+	}
+}
+
+// dumpEntriesSquad 把报名按稳定顺序导成文本（含 upgrade 后新增的队伍）。
+func dumpEntriesSquad(t *testing.T, db *sql.DB) string {
+	t.Helper()
+	var b strings.Builder
+	rows, err := db.Query(`SELECT id, team_id, COALESCE(athlete_id, 0), COALESCE(status, ''), squad
+	                         FROM entries ORDER BY id`)
+	if err != nil {
+		t.Fatalf("读报名: %v", err)
+	}
+	defer func() { _ = rows.Close() }()
+	for rows.Next() {
+		var (
+			id, teamID, athleteID int64
+			status, squad         string
+		)
+		if err := rows.Scan(&id, &teamID, &athleteID, &status, &squad); err != nil {
+			t.Fatalf("扫描报名: %v", err)
+		}
+		fmt.Fprintf(&b, "%d:%d:%d:%s:%s\n", id, teamID, athleteID, status, squad)
+	}
+	if err := rows.Err(); err != nil {
+		t.Fatalf("遍历报名: %v", err)
+	}
+	return b.String()
+}