feat: 备份恢复 / 图片清理 / 单位恢复 / 审计过滤 / 模板引擎 M1 + 两个导入缺陷修复

用户点名的三件事（模板功能、删死代码、剩余缺口）这一批全部落地，另修掉两个刚暴露的导入缺陷：

**新增能力**
- 备份恢复：`POST /api/backup/restore`（admin）。先把校验做在拍快照之前（只读打开 + integrity_check +
  关键表校验 + 异类库标志表互斥），再用 VACUUM INTO 拍「恢复前安全副本」，然后关连接、整文件替换、
  触发优雅重启；`-wal` 还在时直接拒绝（宁可失败也不让旧库 WAL 套到新库上）；恢复后审计直写"恢复之后
  还在的那份库"（不走通用 Auditor，否则记录只会落在被替换掉的旧文件上）。顺带修掉：裸服务端连续恢复
  第二次会在拍副本处崩出一句看不懂的 500，现在回 503「上次恢复后尚未重启，请先重启服务端」。
- 安全副本保留策略：每类库保留最近 5 份，独立于 .db 的 20 份滚动清理。
- 图片管理：`DELETE /api/uploads/{name}`（被引用 409 并列出引用点）、`GET /api/uploads/orphans`、
  `POST /api/uploads/orphans/delete`（只删列出的孤儿，宁漏勿误），全部 admin（与字体删除同档）；
  `deploy/backup.bat` 补上 uploads/ 归档（logs 不归档：可再生的诊断且会无上限增长）。
- 已彻底删除单位的恢复：`POST /api/teams/{id}/restore`（与 hideTeam 同档）。幂等；恢复不会把「停用」
  变成「启用」；真机确认恢复前后榜单逐字节一致、change_log 最大值不变（数据一行没动，不需要重算）。
  界面加「显示已彻底删除的单位」（仅 admin）与恢复按钮；非 admin 的删除确认框里写明"本账号无法自行恢复"。
- 审计日志按 `action` 过滤（子串模糊，输入里的 %/_/\ 转义成字面量）。
- 删除死表 recent_projects（新增 system 迁移 0006，未动已应用的迁移）。
- points_override 不再"设了没效果"：写入侧 400 + 引擎侧守卫，提示改用「积分调整」。
- 联队份额空壳清理（UnionAttribution/UnionSplit/Entry.TeamShares/resolvedShares 等；TeamShare 类型保留，
  因为 export/realtime/奖牌流水三处在生产路径上构造它）。
- 自定义大屏模板 M1：插值引擎（parseTemplate/renderTemplate），任何情况都不抛异常、未定义→空串+警告、
  警告按 (code,path) 合并计数、无 eval/innerHTML，57 个新用例。

**两个真缺陷（前两个已随 0.1.6 出包）**
- 基础数据包导入「排序」列口径不一致：小项/组别留空保持原值，单位/大项留空被写成 0（plan 没从库里
  现值起手）→ 四张表统一为「留空保持原值」。
- 同类第二处：布尔列「整列被删掉」被当成"取默认值"，会把库里所有停用的单位/大项静默改回启用 →
  改为「缺列 = 不动」（写侧与解析侧都收口，补了"缺列保持/空格子=是/显式否=停用"三组对照用例）。

**删死代码**
- createEntry / updateEntry / deleteEntry / entryEventID / checkCategoryInEvent / getEntry /
  normalizeEntryStatus / ExportBaseDataXLSX（全仓 grep 零引用）。⚠️ 随之记入文档：「组别必须属于该小项」
  这道校验现在只由导入路径"按小项+组别名解析"天然保证，将来若新增从请求体接收 categoryId 的接口，
  必须自己补校验（库层没有复合外键）。

**文档**
- devdocs 全面同步（01/02/03/04/05/06/07/09/11/12/13/README；含身份口径、延迟结算、大屏单栏新版式、
  新增路由与设置键、R18/R19 风险）；docs 复核 + 第二轮（身份口径三个易写反的分支、图片删除、备份覆盖、
  审计过滤、单位恢复、去掉硬编码版本号、上线检查清单 +5 项）；debug/使用说明 6 份逐份 diff 一致。

测试：服务端 13 包（连跑两遍）、前端 406 例、Console 28 例 + 18 文件语法检查 —— 全绿。
版本号 dev_0.1.6 → dev_0.1.7。

server/internal/domain/errors.go

@@ -13,4 +13,7 @@ var (
 	ErrManualAdjustmentDisabled = errors.New("domain: 人工调整未启用")
 	ErrAdjustmentReasonRequired = errors.New("domain: 人工调整必须填写理由")
 	ErrUnknownLedgerOp          = errors.New("domain: 未知的流水增量操作")
+	// ErrPointsOverrideUnsupported：成绩上的 pointsOverride 不被引擎读取。
+	// 与其静默忽略（设置成功但毫无效果），不如显式报错；加减分请走人工积分调整。
+	ErrPointsOverrideUnsupported = errors.New("domain: 成绩不接受 pointsOverride，请改用人工积分调整")
 )

server/internal/domain/helpers_test.go

@@ -79,7 +79,6 @@ type participant struct {
 	status      ResultStatus
 	entryStatus EntryStatus
 	state       ResultState
-	shares      []TeamShare
 }
 
 func fixture(ps []participant) ([]Entry, []Result) {
@@ -89,7 +88,7 @@ func fixture(ps []participant) ([]Entry, []Result) {
 		entries = append(entries, Entry{
 			ID: p.entryID, EventID: 1, CategoryID: 1, TeamID: p.teamID,
 			AthleteID: p.athleteID, AthleteName: p.name,
-			Status: p.entryStatus, TeamShares: p.shares,
+			Status: p.entryStatus,
 		})
 		state := p.state
 		if state == "" {

server/internal/domain/matrix_test.go

@@ -278,36 +278,3 @@ func TestMatrix15_RecordBonusSum(t *testing.T) {
 		t.Fatalf("sum 模式 = %+v，期望 15 分一条", got)
 	}
 }
-
-// case 16：一条成绩归属两个单位（联队）→ 按配置拆分或整体归属。
-func TestMatrix16_UnionEntry(t *testing.T) {
-	ps := []participant{{
-		entryID: 1, athleteID: 101, teamID: 1001, name: "联队选手", value: 1,
-		shares: []TeamShare{{TeamID: 1001, Weight: 3}, {TeamID: 1002, Weight: 2}},
-	}}
-	entries, results := fixture(ps)
-
-	split := mustScore(t, EventScoreInput{
-		Event: individualEvent(1), Category: testCategory(),
-		Channels: []ScoreChannel{athleteResultChannel(1)},
-		Profiles: map[int64]ScoringProfile{1: individualTop6()},
-		Entries:  entries, Results: results,
-		Options: ScoreOptions{UnionAttribution: UnionSplit},
-	})
-	byTeam := pointsByTeam(split.Ledger)
-	if !nearlyEqual(byTeam[1001], 6) || !nearlyEqual(byTeam[1002], 4) {
-		t.Fatalf("拆分归属 = %v，期望 1001:6 / 1002:4", byTeam)
-	}
-
-	whole := mustScore(t, EventScoreInput{
-		Event: individualEvent(1), Category: testCategory(),
-		Channels: []ScoreChannel{athleteResultChannel(1)},
-		Profiles: map[int64]ScoringProfile{1: individualTop6()},
-		Entries:  entries, Results: results,
-		Options: ScoreOptions{UnionAttribution: UnionWhole},
-	})
-	byTeam = pointsByTeam(whole.Ledger)
-	if !nearlyEqual(byTeam[1001], 10) || byTeam[1002] != 0 {
-		t.Fatalf("整体归属 = %v，期望 1001:10 / 1002:0", byTeam)
-	}
-}

server/internal/domain/records.go

@@ -146,19 +146,21 @@ func recordBonusLedger(in EventScoreInput) ([]LedgerEntry, error) {
 		if athleteID == 0 {
 			athleteID = e.AthleteID
 		}
-		for _, s := range e.resolvedShares(in.Options.UnionAttribution) {
-			out = append(out, LedgerEntry{
-				TeamID:      s.TeamID,
-				AthleteID:   athleteID,
-				EventID:     in.Event.ID,
-				CategoryID:  in.Category.ID,
-				EntryID:     e.ID,
-				SourceType:  SourceRecordBonus,
-				SourceID:    e.ID,
-				Points:      b.Points * s.Weight,
-				CountToTeam: true,
-			})
+		teamID := e.primaryTeamID()
+		if teamID == 0 {
+			continue
 		}
+		out = append(out, LedgerEntry{
+			TeamID:      teamID,
+			AthleteID:   athleteID,
+			EventID:     in.Event.ID,
+			CategoryID:  in.Category.ID,
+			EntryID:     e.ID,
+			SourceType:  SourceRecordBonus,
+			SourceID:    e.ID,
+			Points:      b.Points,
+			CountToTeam: true,
+		})
 	}
 	return out, nil
 }

server/internal/domain/records_test.go

@@ -162,36 +162,6 @@ func TestRecordBonusLedger(t *testing.T) {
 			t.Fatal("未产生加分流水")
 		}
 	})
-
-	t.Run("联队按份额拆分加分", func(t *testing.T) {
-		ps := []participant{{
-			entryID: 1, athleteID: 101, teamID: 1001, value: 1,
-			shares: []TeamShare{{TeamID: 1001, Weight: 3}, {TeamID: 1002, Weight: 2}},
-		}}
-		e2, r2 := fixture(ps)
-		cfg := bonusConfig(RecordBonusMax)
-		es := mustScore(t, EventScoreInput{
-			Event: individualEvent(1), Category: testCategory(),
-			Channels: []ScoreChannel{athleteResultChannel(1)},
-			Profiles: map[int64]ScoringProfile{1: individualTop6()},
-			Entries:  e2, Results: r2,
-			RecordBonus: &cfg,
-			RecordBreaks: []RecordBreak{{
-				ID: 1, EventID: 1, EntryID: 1, AthleteID: 101, TeamID: 1001,
-				Level: "meet", State: RecordBreakApproved,
-			}},
-			Options: ScoreOptions{UnionAttribution: UnionSplit},
-		})
-		var bonus float64
-		for _, e := range es.Ledger {
-			if e.SourceType == SourceRecordBonus && e.TeamID == 1002 {
-				bonus += e.Points
-			}
-		}
-		if !nearlyEqual(bonus, 0.8) {
-			t.Fatalf("单位1002 的加分 = %v，期望 2 × 0.4 = 0.8", bonus)
-		}
-	})
 }
 
 // recordBonusPointsOf 统计一次计分产出的破纪录加分总和。

server/internal/domain/scoring.go

@@ -11,9 +11,6 @@ const rankEpsilon = 1e-9
 
 // ScoreOptions 控制引擎的可选行为；零值即本次运动会的口径。
 type ScoreOptions struct {
-	// UnionAttribution 决定联队成绩的归属；空值等同 UnionWhole（整体记给主单位）。
-	// 未实现：生产链路没有赋值入口，联队份额也无处加载（见 UnionAttribution 注释）。
-	UnionAttribution UnionAttribution
 	// IncludeDrafts 为 true 时草稿成绩也参与计分；默认只算已发布（草稿不上屏也不计分）。
 	IncludeDrafts bool
 }
@@ -38,7 +35,9 @@ type EventScore struct {
 }
 
 // RankedResult 记录「某条报名项在某通道下拿到的名次与原始积分」。
-// Points 尚未按联队份额拆分、也未乘个人→单位系数，因此可直接用于奖牌判定与分项成绩表。
+// Points 尚未乘个人→单位系数，因此可直接用于奖牌判定与分项成绩表。
+// Shares 是该名次的归属单位；当前只有「整体归主单位」一种口径（联队未实现），
+// 保留份额结构是因为导出 / 实时快照等消费方按份额遍历。
 type RankedResult struct {
 	EntryID     int64
 	ResultID    int64
@@ -61,6 +60,13 @@ type RankedResult struct {
 // 计分与排名解耦：项目 scored=false 或没有通道时照样产出名次（Points=0），只是不写流水。
 // 没有通道时按小项自身的录入方式（result_mode）推导排名口径，见 rankOnlyChannel。
 func ScoreEvent(in EventScoreInput) (EventScore, error) {
+	// 引擎不读取 pointsOverride，静默忽略等于「设置成功但毫无效果」；
+	// 显式报错把问题暴露在计分环节，写入侧另有 400 拦截，两道都不放行。
+	for _, r := range in.Results {
+		if r.PointsOverride != nil {
+			return EventScore{}, fmt.Errorf("%w: 成绩 %d（报名项 %d）", ErrPointsOverrideUnsupported, r.ID, r.EntryID)
+		}
+	}
 	var out EventScore
 	rankOnly := len(in.Channels) == 0
 	// 只排名不计分：scored=false 或没有计分通道时都不产出任何流水（含破纪录加分）。
@@ -355,7 +361,7 @@ func rankedResult(in EventScoreInput, ch ScoreChannel, c candidate, rank int, po
 		AthleteID:   c.entry.AthleteID,
 		AthleteName: c.entry.AthleteName,
 		TeamID:      c.entry.primaryTeamID(),
-		Shares:      c.entry.resolvedShares(in.Options.UnionAttribution),
+		Shares:      wholeShare(c.entry.primaryTeamID()),
 		Rank:        rank,
 		Points:      points,
 		Status:      c.result.Status,
@@ -462,11 +468,11 @@ func scoreByAggregate(in EventScoreInput, ch ScoreChannel, profile ScoringProfil
 			}
 			if ch.Scope == ScopeTeam {
 				rr.TeamID = c.subject
-				rr.Shares = []TeamShare{{TeamID: c.subject, Weight: 1}}
+				rr.Shares = wholeShare(c.subject)
 			} else {
 				rr.AthleteID = c.subject
 				rr.AthleteName = c.entry.AthleteName
-				rr.Shares = c.entry.resolvedShares(in.Options.UnionAttribution)
+				rr.Shares = wholeShare(c.entry.primaryTeamID())
 			}
 			v := c.value
 			rr.ResultValue = &v
@@ -507,8 +513,8 @@ func validResultValue(r Result, found bool, opts ScoreOptions) (float64, bool) {
 	return *r.ResultValue, true
 }
 
-// ledgerFromRanked 把名次明细转成积分流水：按通道 scope 决定记给个人还是单位，
-// 联队按份额拆分；0 分不产生流水，避免流水表被零分噪声撑大。
+// ledgerFromRanked 把名次明细转成积分流水：按通道 scope 决定记给个人还是单位；
+// 0 分不产生流水，避免流水表被零分噪声撑大。
 // 流水是否计入单位总分由通道的 countToTeam 决定（个人通道可以只记个人）。
 func ledgerFromRanked(in EventScoreInput, ch ScoreChannel, ranked []RankedResult) []LedgerEntry {
 	var out []LedgerEntry
@@ -550,34 +556,10 @@ func ledgerFromRanked(in EventScoreInput, ch ScoreChannel, ranked []RankedResult
 	return out
 }
 
-// resolvedShares 解析报名项的归属：默认整体归主单位，联队模式才按份额拆分。
-func (e Entry) resolvedShares(mode UnionAttribution) []TeamShare {
-	shares := e.teamShares()
-	if len(shares) == 0 {
+// wholeShare 构造「主单位独占 100%」的归属份额。联队拆分未实现，这里只产出这一种口径。
+func wholeShare(teamID int64) []TeamShare {
+	if teamID == 0 {
 		return nil
 	}
-	if mode != UnionSplit {
-		return []TeamShare{{TeamID: e.primaryTeamID(), Weight: 1}}
-	}
-	return normalizeShares(shares)
-}
-
-// normalizeShares 把份额归一化到总和 1，避免配置里权重不标准导致总分被放大。
-func normalizeShares(shares []TeamShare) []TeamShare {
-	var sum float64
-	for _, s := range shares {
-		sum += s.Weight
-	}
-	out := make([]TeamShare, len(shares))
-	if sum <= 0 {
-		w := 1 / float64(len(shares))
-		for i, s := range shares {
-			out[i] = TeamShare{TeamID: s.TeamID, Weight: w}
-		}
-		return out
-	}
-	for i, s := range shares {
-		out[i] = TeamShare{TeamID: s.TeamID, Weight: s.Weight / sum}
-	}
-	return out
+	return []TeamShare{{TeamID: teamID, Weight: 1}}
 }

server/internal/domain/scoring_test.go

@@ -710,51 +710,21 @@ func TestOneAthleteMultipleEvents(t *testing.T) {
 	}
 }
 
-// TestUnionSharesNormalization 覆盖联队份额的归一化与退化情形。
-func TestUnionSharesNormalization(t *testing.T) {
-	score := func(shares []TeamShare, mode UnionAttribution) map[int64]float64 {
-		entries, results := fixture([]participant{{
-			entryID: 1, athleteID: 1, teamID: 1001, value: 1, shares: shares,
-		}})
-		return pointsByTeam(mustScore(t, EventScoreInput{
-			Event: individualEvent(1), Category: testCategory(),
-			Channels: []ScoreChannel{athleteResultChannel(1)},
-			Profiles: map[int64]ScoringProfile{1: individualTop6()},
-			Entries:  entries, Results: results,
-			Options: ScoreOptions{UnionAttribution: mode},
-		}).Ledger)
-	}
+// TestScoreEventRejectsPointsOverride：引擎不读 points_override，静默忽略就是
+// 「设置成功但毫无效果」；带它的成绩必须显式报错，不能照常算出别的分。
+func TestScoreEventRejectsPointsOverride(t *testing.T) {
+	entries, results := fixture([]participant{{entryID: 1, athleteID: 1, teamID: 1001, value: 1}})
+	override := 99.0
+	results[0].PointsOverride = &override
 
-	cases := []struct {
-		name   string
-		shares []TeamShare
-		mode   UnionAttribution
-		want   map[int64]float64
-	}{
-		{"份额 3:2 拆分为 6:4", []TeamShare{{1001, 3}, {1002, 2}}, UnionSplit, map[int64]float64{1001: 6, 1002: 4}},
-		{"份额 1:1 平分为 5:5", []TeamShare{{1001, 1}, {1002, 1}}, UnionSplit, map[int64]float64{1001: 5, 1002: 5}},
-		{"权重为 0 的份额被丢弃", []TeamShare{{1001, 0}, {1002, 1}}, UnionSplit, map[int64]float64{1002: 10}},
-		{"份额全非法时退回主单位", []TeamShare{{1001, 0}, {1002, 0}}, UnionSplit, map[int64]float64{1001: 10}},
-		{"无份额时归主单位", nil, UnionSplit, map[int64]float64{1001: 10}},
-		{"整体归属只记主单位", []TeamShare{{1001, 3}, {1002, 2}}, UnionWhole, map[int64]float64{1001: 10}},
-		{"归属口径空值等同整体", []TeamShare{{1001, 3}, {1002, 2}}, "", map[int64]float64{1001: 10}},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			got := score(tc.shares, tc.mode)
-			for id, want := range tc.want {
-				if !nearlyEqual(got[id], want) {
-					t.Fatalf("单位 %d 得分 = %v，期望 %v（全部 %v）", id, got[id], want, got)
-				}
-			}
-			for id, p := range got {
-				if p != 0 {
-					if _, ok := tc.want[id]; !ok {
-						t.Fatalf("单位 %d 不应得分，实际 %v", id, p)
-					}
-				}
-			}
-		})
+	_, err := ScoreEvent(EventScoreInput{
+		Event: individualEvent(1), Category: testCategory(),
+		Channels: []ScoreChannel{athleteResultChannel(1)},
+		Profiles: map[int64]ScoringProfile{1: individualTop6()},
+		Entries:  entries, Results: results,
+	})
+	if !errors.Is(err, ErrPointsOverrideUnsupported) {
+		t.Fatalf("带 pointsOverride 的成绩应报 ErrPointsOverrideUnsupported，实际 %v", err)
 	}
 }
 

server/internal/domain/standings.go

@@ -270,8 +270,8 @@ func pickMedalChannels(ranked []RankedResult, excludeTeam bool) []RankedResult {
 	return out
 }
 
-// teamMedals 统计团体奖牌榜。联队拆分时两个单位各记一枚：
-// 联合组队拿到的名次对每个成员单位都是「本单位取得的名次」。
+// teamMedals 统计团体奖牌榜。按 Shares 逐份额记牌：当前只有「主单位独占 100%」一种口径，
+// 将来若支持联队拆分，每个成员单位都会各记一枚。
 func teamMedals(in StandingsInput) map[int64]medalTally {
 	out := make(map[int64]medalTally)
 	for _, rr := range pickMedalChannels(in.Ranked, in.ExcludeTeamEventMedals) {

server/internal/domain/types.go

@@ -137,17 +137,6 @@ const (
 	SourceAdjustment  SourceType = "adjustment"
 )
 
-// UnionAttribution 联队（一条成绩归属多个单位）的归属口径。
-// 未实现：库中没有保存联队份额的表，加载器也不会填充 Entry.TeamShares，
-// ScoreOptions.UnionAttribution 在生产链路里没有任何赋值入口；
-// 规则包校验也不接受相关配置。这里只保留数据结构，本期不启用（devdocs 01 §115）。
-type UnionAttribution string
-
-const (
-	UnionWhole UnionAttribution = "whole" // 整体记给主单位
-	UnionSplit UnionAttribution = "split" // 按 TeamShares 的份额拆分（未实现）
-)
-
 // AdjustmentCategory 人工调整类别。
 type AdjustmentCategory string
 
@@ -268,8 +257,8 @@ type ScoringProfile struct {
 	Rules           []ScoringRule   `json:"rules"`
 }
 
-// TeamShare 联队中某单位的份额；Weight 为 0..1 的相对份额。
-// 未实现：没有建表、没有 loader 填充、也没有写入入口（见 UnionAttribution 注释）。
+// TeamShare 是一条成绩的归属单位份额。联队拆分未实现，引擎只产出「主单位独占 100%」；
+// 保留结构是因为导出 / 实时快照等消费方按份额遍历 RankedResult.Shares。
 type TeamShare struct {
 	TeamID int64   `json:"teamId"`
 	Weight float64 `json:"weight"`
@@ -284,7 +273,6 @@ type Entry struct {
 	AthleteID   int64       `json:"athleteId,omitempty"`
 	AthleteName string      `json:"athleteName,omitempty"` // 冗余姓名，便于引擎直接产出个人榜
 	MemberNames []string    `json:"memberNames,omitempty"`
-	TeamShares  []TeamShare `json:"teamShares,omitempty"` // 跨单位联队；空表示只属 TeamID（联队未实现，见 UnionAttribution）
 	Bib         string      `json:"bib,omitempty"`
 	Seed        string      `json:"seed,omitempty"`
 	Status      EntryStatus `json:"status"`
@@ -503,37 +491,7 @@ func (s ResultStatus) rankable() bool {
 	return s == "" || s == ResultStatusOK
 }
 
-// teamShares 返回报名项的归属份额；未配联队份额时就是「主单位独占 100%」。
-// 份额全部非法（权重 <= 0）时退回主单位，宁可按主单位记分也不要静默丢分。
-func (e Entry) teamShares() []TeamShare {
-	if len(e.TeamShares) == 0 {
-		if e.TeamID == 0 {
-			return nil
-		}
-		return []TeamShare{{TeamID: e.TeamID, Weight: 1}}
-	}
-	out := make([]TeamShare, 0, len(e.TeamShares))
-	for _, s := range e.TeamShares {
-		if s.TeamID != 0 && s.Weight > 0 {
-			out = append(out, s)
-		}
-	}
-	if len(out) == 0 {
-		if id := e.primaryTeamID(); id != 0 {
-			return []TeamShare{{TeamID: id, Weight: 1}}
-		}
-		return nil
-	}
-	return out
-}
-
 // primaryTeamID 是「整体归属」时接收全部分数的单位。
 func (e Entry) primaryTeamID() int64 {
-	if e.TeamID != 0 {
-		return e.TeamID
-	}
-	if len(e.TeamShares) > 0 {
-		return e.TeamShares[0].TeamID
-	}
-	return 0
+	return e.TeamID
 }

server/internal/domain/types_test.go

@@ -80,40 +80,10 @@ func TestProfilePointsAt(t *testing.T) {
 	}
 }
 
-func TestEntryTeamShares(t *testing.T) {
-	cases := []struct {
-		name  string
-		entry Entry
-		want  []TeamShare
-	}{
-		{"无份额归主单位", Entry{TeamID: 1}, []TeamShare{{1, 1}}},
-		{"无单位也无份额", Entry{}, nil},
-		{"保留正权重份额", Entry{TeamID: 1, TeamShares: []TeamShare{{1, 3}, {2, 2}}}, []TeamShare{{1, 3}, {2, 2}}},
-		{"过滤非法份额", Entry{TeamID: 1, TeamShares: []TeamShare{{1, 0}, {2, 1}}}, []TeamShare{{2, 1}}},
-		{"份额全非法退回主单位", Entry{TeamID: 1, TeamShares: []TeamShare{{1, 0}, {2, -1}}}, []TeamShare{{1, 1}}},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			got := tc.entry.teamShares()
-			if len(got) != len(tc.want) {
-				t.Fatalf("份额 = %+v，期望 %+v", got, tc.want)
-			}
-			for i := range got {
-				if got[i] != tc.want[i] {
-					t.Fatalf("份额 = %+v，期望 %+v", got, tc.want)
-				}
-			}
-		})
-	}
-}
-
 func TestPrimaryTeamID(t *testing.T) {
 	if got := (Entry{TeamID: 7}).primaryTeamID(); got != 7 {
 		t.Errorf("主单位 = %d，期望 7", got)
 	}
-	if got := (Entry{TeamShares: []TeamShare{{9, 1}}}).primaryTeamID(); got != 9 {
-		t.Errorf("无 TeamID 时取首个份额 = %d，期望 9", got)
-	}
 	if got := (Entry{}).primaryTeamID(); got != 0 {
 		t.Errorf("无归属时 = %d，期望 0", got)
 	}
@@ -154,15 +124,12 @@ func TestRankableStatuses(t *testing.T) {
 	}
 }
 
-func TestNormalizeShares(t *testing.T) {
-	got := normalizeShares([]TeamShare{{1, 3}, {2, 2}})
-	if !nearlyEqual(got[0].Weight, 0.6) || !nearlyEqual(got[1].Weight, 0.4) {
-		t.Fatalf("归一化 = %+v，期望 0.6/0.4", got)
+func TestWholeShare(t *testing.T) {
+	if got := wholeShare(0); got != nil {
+		t.Fatalf("无单位时应无份额，得到 %+v", got)
 	}
-	got = normalizeShares([]TeamShare{{1, 1}, {2, 1}, {3, 1}})
-	for _, s := range got {
-		if !nearlyEqual(s.Weight, 1.0/3) {
-			t.Fatalf("平均拆分 = %+v，期望各 1/3", got)
-		}
+	got := wholeShare(9)
+	if len(got) != 1 || got[0].TeamID != 9 || !nearlyEqual(got[0].Weight, 1) {
+		t.Fatalf("主单位独占份额 = %+v，期望 {9, 1}", got)
 	}
 }