fix(p2): 按审查清单修 103 条「建议修」+ 奖牌榜改名 + 两个守卫（dev_0.2.0）

## 奖牌榜改名（主人要求）
「团体奖牌榜」→「单位奖牌榜」，界面 / 大屏渲染页 / 导出件（工作表名与
下载文件名 `单位奖牌明细.xlsx`）/ 用户文档 全部统一；`DISPLAY_PAGES` 是
大屏控制页与大屏页的共同来源，改一处两边同时生效。旧名保留为别名，
老链接与老配置（`display.pages`）照常有效。真 Chromium 验证：14 个管理端
路由 + 7 个基础数据分区 0 报错，大屏页标题已是「单位奖牌榜」。

## P2 清单（123 条，103 条标「建议修」）
按 A/B/C/D 分组、以「文件所有权互斥」分 10 个代理并行推进，另有独立复核
代理逐条核对：61 条声称已修 / 55 条证实 / 4 条部分 / 0 条不成立 / 0 垃圾。

主要交付（按风险从高到低）：
- 写入侧校验：update 路径补必填与 TrimSpace、模板 rules 重复 rank、
  「小项不存在」的四种回答、`defaultProfileId` 外键、decodeJSON 的 8MB
  上限与 413（A01–A06、D02、D03 批量上限 500）
- 危险操作：一键恢复加互斥（第二个请求当场 409）、恢复超时不再说
  「未执行」、`ConfirmDialog` pending 时锁死 ESC/遮罩/关闭
- 认证：改密与撤会话进同一事务、滑动续期写库失败不再假装成功、
  CSRF Cookie 丢失自动补发、密码长度按字符（原按字节）、
  反代 403 只在可信代理透传原 Host 时采信 `X-Forwarded-Host`（全等比较）、
  过期会话定期清理、登出补审计、登录限流可配
- 数据可见性：导出「已发布未结算」行改为 `名次 — / 积分 — / 状态未结算`、
  单位积分明细成绩列与其它导出件逐字一致、空单位也打合计行、
  基础数据包命中「已彻底删除的单位」整行跳过并报界面路径、
  报名导入换单位给明确提示、勾选报名有冲突不再假报成功
- 导入/导出：赛事包上限 512MB（**它是唯一带字体/图片的包**，字体上限
  20MB）而 multipart 内存档位独立钉在 16MB、工作簿表名尾随空格、
  导出件路由与文件名契约补全
- 前端：一次写请求只生成一个 requestId（幂等缓存此前从未命中）、
  基础数据包补 `X-Request-Id`、示例数据模式禁写扩到撤销发布/存草稿、
  访客 401 不再是裸错误、模板 `{{else if}}` 不再静默吞内容
- Console：按设计退出（切赛事/恢复）不再判成崩溃、旧数据目录读不出来
  会记日志、渲染层日志按上限截断、`service.js` 补 17 例测试

## 测试
服务端用例 610 → 674（13 包全绿，新增老库跨九条迁移升级、panic 形状、
429 落 interceptions、三态对照、avg_mode 分母、会话失效、请求体上限等）
前端 449 → 531（vue-tsc + build 通过）；Console 28 → 54（19 个文件）。
另修复一条会让整包挂死 600s 的用例（测试主协程堵在 client.Do，defer
轮不到执行 → 改为可取消 + 探针超时，改坏也 7.5s 快速失败）。

## 两个新守卫（防止再出现「组件 setup 抛异常」这类盲区）
- `web/scripts/check-declaration-order.mjs` 已进测试命令：沿 watch/
  watchEffect 的 const 依赖链查 TDZ（正是「运动员页整块空白」的根因）
- `web/scripts/smoke-admin.mjs`（`pnpm smoke`）：真 Chromium 点遍 14 个
  管理端路由 + 7 个基础数据分区 + 大屏页，任何 console 错误即失败

## 文档
- `docs/升级说明.md` 新增 dev_0.2.0 一节（三件升级必知：改名、审计前缀
  与历史记录、密码口径；现场变化；赛事包上限；反代与 CSRF）
- 使用手册 / 常见问题 / 部署指南 / 上线检查清单按实现同步

server/internal/auth/auth.go

@@ -52,10 +52,23 @@ const (
 	// touchInterval 是 last_seen_at 的回写节流窗口：没有续期时，活动时间最快每分钟写一次。
 	// 一次页面加载会打若干个请求，逐个回写纯属放大写压力；last_seen_at 只用于排障，分钟级足够。
 	touchInterval = time.Minute
+	// sessionPurgeInterval 是「清理过期会话行」的最小间隔。
+	// sessions 只增不减（每次登录一行，过期行与 token 哈希永久留存），需要一个清理动作；
+	// 单实例部署不值得为它常开一个 goroutine（还要在 main 里管生命周期），
+	// 于是挂在「查找会话」这条登录后必经的路径上按间隔做一次：只要有人在线，清理就不会停。
+	sessionPurgeInterval = time.Hour
 	// DefaultBcryptCost 满足文档「bcrypt cost ≥ 12」。
 	DefaultBcryptCost = 12
 	// DefaultLoginPerMinute 登录限流：5 次/分钟/IP。防爆破用，别跟着写限流一起放大。
 	DefaultLoginPerMinute = 5
+	// LoginRateKey 是系统库 settings 里存登录限流的键。0005 迁移种下 5，
+	// 但在本项改动之前全仓没有一行代码读它——现场按「系统设置」改这个键不起作用，
+	// 限流实际上只由编译期常量决定，属死配置。
+	LoginRateKey = "security.login_rate_per_minute"
+	// MinLoginPerMinute / MaxLoginPerMinute 是系统库那个键的可接受范围。
+	// 上限卡在 60：这是防爆破的闸门，配成几千等于把它关掉；越界或非法值按「未配置」回落默认。
+	MinLoginPerMinute = 1
+	MaxLoginPerMinute = 60
 	// DefaultWritePerMinute 写操作限流：120 次/分钟/用户。
 	//
 	// 原来定 30，现场一次批量导入 / 批量删除跑完就会撞上（第 7 次起全是 429），
@@ -90,6 +103,10 @@ type User struct {
 }
 
 // Session 是一次登录产生的服务端会话。
+//
+// IP / UserAgent 目前除本包外无人读（面板还没有「在线会话」视图），但保留写入：
+// 排查「这条会话是哪个 IP / 哪台设备开的」时它们才是唯一线索，
+// 而留存本身有上界——Lookup 里的过期行清理会把超过会话寿命的行连同这两列一起删掉（见 purgeExpiredSessions）。
 type Session struct {
 	ID        string
 	UserID    int64
@@ -104,8 +121,14 @@ type Options struct {
 	// SessionTTL 显式指定登录有效期（测试 / 嵌入用）。优先级最低的那一档默认值：
 	// 只要系统库 settings 里有有效的 security.session_hours（面板写的就是它），就以面板为准；
 	// 这里只在系统库里没有配置时兜底（例如测试用的空库）。
-	SessionTTL     time.Duration
-	BcryptCost     int
+	//
+	// 注意：生产构造点（main.go）不传这个字段，也没有对应的启动参数 / 配置文件字段——
+	// devdocs/05 里「面板 > 启动参数 > 内置默认」的中间那一档目前只存在于本字段，
+	// 实际只有测试在用（P2-C13）。要把它变成真的启动参数得先在 main.go 加 flag。
+	SessionTTL time.Duration
+	BcryptCost int
+	// LoginPerMinute 显式指定登录限流（测试 / 嵌入用）；优先级同 SessionTTL：
+	// 系统库 settings 里的 security.login_rate_per_minute 优先，本字段只在库里没有有效值时生效。
 	LoginPerMinute int
 	WritePerMinute int
 	// Secure 为 true 时 Cookie 带 Secure 标记（HTTPS 部署）。
@@ -123,7 +146,10 @@ type Service struct {
 	now           func() time.Time
 	// ttl 是当前生效的登录有效期；面板可以随时改（SetSessionTTL），
 	// 所以每个请求都会读它，必须用原子量而不是普通字段。
-	ttl          atomic.Int64
+	ttl atomic.Int64
+	// lastPurge 是上一次清理过期会话行的时刻（Unix 纳秒，0 = 还没清理过）。
+	// 请求会并发走到 Lookup，节流判断与「谁来做这次清理」都必须原子地一次完成。
+	lastPurge    atomic.Int64
 	loginLimiter *Limiter
 	writeLimiter *Limiter
 }
@@ -151,9 +177,13 @@ func New(db *sql.DB, opts Options) *Service {
 	if now == nil {
 		now = time.Now
 	}
-	loginLimit := opts.LoginPerMinute
-	if loginLimit == 0 {
-		loginLimit = DefaultLoginPerMinute
+	loginLimit, loginSource := DefaultLoginPerMinute, "内置默认"
+	// 与登录有效期同一条优先级：系统库设置 > 启动参数 > 内置默认。
+	// 0005 迁移早就种下了 security.login_rate_per_minute，但直到现在才有人读它。
+	if v, ok := loginRateFromSettings(db); ok {
+		loginLimit, loginSource = v, "系统设置"
+	} else if opts.LoginPerMinute > 0 {
+		loginLimit, loginSource = opts.LoginPerMinute, "启动参数"
 	}
 	writeLimit := opts.WritePerMinute
 	if writeLimit == 0 {
@@ -161,6 +191,7 @@ func New(db *sql.DB, opts Options) *Service {
 	}
 	logger.Info("登录有效期", "hours", ttl.Hours(), "source", source,
 		"滑动续期", true, "节流窗口", renewThreshold.String())
+	logger.Info("登录限流", "perMinute", loginLimit, "source", loginSource)
 	s := &Service{
 		db:            db,
 		log:           logger,
@@ -240,6 +271,31 @@ func sessionTTLFromSettings(db *sql.DB) (time.Duration, bool) {
 	return time.Duration(EffectiveSessionHours(values)) * time.Hour, true
 }
 
+// loginRateFromSettings 从系统库 settings 读登录限流（次/分钟/IP）。
+// 缺键、非法或越界一律 ok=false，由调用方回落到启动参数 / 内置默认——
+// 这个键是防爆破的闸门，配错了宁可用默认值，也不能因为库里写了个 0 就把闸门拿掉。
+func loginRateFromSettings(db *sql.DB) (int, bool) {
+	if db == nil {
+		return 0, false
+	}
+	var raw string
+	switch err := db.QueryRow(`SELECT value FROM settings WHERE key = ?`, LoginRateKey).Scan(&raw); {
+	case errors.Is(err, sql.ErrNoRows):
+		return 0, false
+	case err != nil:
+		slog.Warn("读取登录限流失败，本次用默认值", "err", err, "perMinute", DefaultLoginPerMinute)
+		return 0, false
+	}
+	n, err := strconv.Atoi(strings.TrimSpace(raw))
+	if err != nil || n < MinLoginPerMinute || n > MaxLoginPerMinute {
+		slog.Warn("登录限流配置非法，本次用默认值",
+			"value", raw, "perMinute", DefaultLoginPerMinute,
+			"min", MinLoginPerMinute, "max", MaxLoginPerMinute)
+		return 0, false
+	}
+	return n, true
+}
+
 // AllowLogin 按 IP 限流登录。
 func (s *Service) AllowLogin(ip string) bool { return s.loginLimiter.Allow(ip) }
 
@@ -282,6 +338,8 @@ func (s *Service) EnsureDefaultAdmin(ctx context.Context) (username, password st
 func RandomPassword(n int) (string, error) { return randomPassword(n) }
 
 // SetPassword 重置用户密码并作废其全部会话；mustChange 表示下次登录后强制改密。
+//
+// 「改密」与「作废会话」必须同成同败，因此两条语句进同一个事务（见 withUserSessionRevoke）。
 func (s *Service) SetPassword(ctx context.Context, username, password string, mustChange bool) error {
 	if password == "" {
 		return fmt.Errorf("密码不能为空")
@@ -297,43 +355,67 @@ func (s *Service) SetPassword(ctx context.Context, username, password string, mu
 	if mustChange {
 		must = 1
 	}
-	res, err := s.db.ExecContext(ctx,
-		`UPDATE users SET password_hash = ?, must_change_password = ?, updated_at = datetime('now') WHERE username = ?`,
-		string(hash), must, username)
-	if err != nil {
-		return fmt.Errorf("更新密码: %w", err)
-	}
-	if n, err := res.RowsAffected(); err == nil && n == 0 {
-		return fmt.Errorf("用户 %s 不存在", username)
-	}
-
-	var id int64
-	if err := s.db.QueryRowContext(ctx, `SELECT id FROM users WHERE username = ?`, username).Scan(&id); err != nil {
-		return fmt.Errorf("查询用户: %w", err)
-	}
-	return s.RevokeUserSessions(ctx, id)
+	return s.withUserSessionRevoke(ctx, username, func(tx *sql.Tx) error {
+		res, err := tx.ExecContext(ctx,
+			`UPDATE users SET password_hash = ?, must_change_password = ?, updated_at = datetime('now') WHERE username = ?`,
+			string(hash), must, username)
+		if err != nil {
+			return fmt.Errorf("更新密码: %w", err)
+		}
+		if n, err := res.RowsAffected(); err == nil && n == 0 {
+			return fmt.Errorf("用户 %s 不存在", username)
+		}
+		return nil
+	})
 }
 
 // SetUsername 修改用户名（供本机管理入口免登录调用），并作废该用户全部会话。
+// 与 SetPassword 同一口径：改名与撤会话要么都成、要么都不成。
 func (s *Service) SetUsername(ctx context.Context, oldUsername, newUsername string) error {
 	if newUsername == "" {
 		return fmt.Errorf("新用户名不能为空")
 	}
-	res, err := s.db.ExecContext(ctx,
-		`UPDATE users SET username = ?, updated_at = datetime('now') WHERE username = ?`,
-		newUsername, oldUsername)
-	if err != nil {
-		return fmt.Errorf("更新用户名: %w", err)
-	}
-	if n, err := res.RowsAffected(); err == nil && n == 0 {
-		return fmt.Errorf("用户 %s 不存在", oldUsername)
-	}
+	return s.withUserSessionRevoke(ctx, newUsername, func(tx *sql.Tx) error {
+		res, err := tx.ExecContext(ctx,
+			`UPDATE users SET username = ?, updated_at = datetime('now') WHERE username = ?`,
+			newUsername, oldUsername)
+		if err != nil {
+			return fmt.Errorf("更新用户名: %w", err)
+		}
+		if n, err := res.RowsAffected(); err == nil && n == 0 {
+			return fmt.Errorf("用户 %s 不存在", oldUsername)
+		}
+		return nil
+	})
+}
 
-	var id int64
-	if err := s.db.QueryRowContext(ctx, `SELECT id FROM users WHERE username = ?`, newUsername).Scan(&id); err != nil {
-		return fmt.Errorf("查询用户: %w", err)
+// withUserSessionRevoke 在一个事务里执行 fn（改用户行）并删掉该用户（改名后用 newName 定位）的全部会话行。
+//
+// 为什么要事务：改密 / 改名与「作废会话」是同一个安全动作的两半，中间态是危险的——
+// 撤会话失败而密码已改 = 「密码改了，但旧会话（可能正是被盗用的那个）仍然全有效」，
+// 用户以为已经止血、实际没有；反过来先撤会话再改密失败 = 人全被踢下线却没改成密码。
+// 事务保证外部只看得到两种结果：全做了，或什么都没做（此时旧密码与旧会话都还在，语义自洽）。
+//
+// system.db 的连接池上限是 1（store.Open），事务在提交前独占该连接，两条语句不会被别的请求插进来。
+func (s *Service) withUserSessionRevoke(ctx context.Context, username string, fn func(*sql.Tx) error) error {
+	tx, err := s.db.BeginTx(ctx, nil)
+	if err != nil {
+		return fmt.Errorf("开启事务: %w", err)
 	}
-	return s.RevokeUserSessions(ctx, id)
+	defer func() { _ = tx.Rollback() }()
+
+	if err := fn(tx); err != nil {
+		return err
+	}
+	// 用子查询定位 user_id：用户名唯一，省掉一次「读回 id」的往返（读了也是同一事务内的快照）。
+	if _, err := tx.ExecContext(ctx,
+		`DELETE FROM sessions WHERE user_id = (SELECT id FROM users WHERE username = ?)`, username); err != nil {
+		return fmt.Errorf("作废会话: %w", err)
+	}
+	if err := tx.Commit(); err != nil {
+		return fmt.Errorf("提交事务: %w", err)
+	}
+	return nil
 }
 
 // VerifyPassword 校验指定用户的原密码，不创建会话（供「修改密码」等场景使用）。
@@ -436,6 +518,10 @@ func (s *Service) Lookup(ctx context.Context, token string) (*User, *Session, er
 	sess.ExpiresAt = exp
 	u.Role = ParseRole(role)
 
+	// 过期会话行顺手清一次（节流见 sessionPurgeInterval）。放在续期之前：
+	// 续期那条分支会提前 return，放后面就永远轮不到它。
+	s.purgeExpiredSessions(ctx, now)
+
 	// 滑动续期：会话只要还在有效期内被使用，就把到期时间顺延到 now+有效期，
 	// 而不是「登录满 N 小时必死」——现场前一晚登录、比赛当天一直在用的人不该掉线。
 	//
@@ -444,13 +530,22 @@ func (s *Service) Lookup(ctx context.Context, token string) (*User, *Session, er
 	// 少顺延这 1 分钟不会让任何人提前掉线（前一次续期至少还剩一个有效期）。
 	if ttl := s.SessionTTL(); ttl > renewThreshold && exp.Sub(now) < ttl-renewThreshold {
 		renewed := now.Add(ttl)
-		_, _ = s.db.ExecContext(ctx, `UPDATE sessions SET last_seen_at = ?, expires_at = ? WHERE id = ?`,
-			now.Format(time.DateTime), renewed.Format(time.DateTime), sess.ID)
+		if _, err := s.db.ExecContext(ctx, `UPDATE sessions SET last_seen_at = ?, expires_at = ? WHERE id = ?`,
+			now.Format(time.DateTime), renewed.Format(time.DateTime), sess.ID); err != nil {
+			// 写库失败时不能只顺延内存里的到期时间：/api/auth/me 会拿 sess.ExpiresAt 重发 Cookie，
+			// 于是浏览器被告知「还有一整天」，库里却还是旧时刻——用户会在毫无征兆的情况下被登出，
+			// 排查时「服务端说没过期、库里已经过期」两边对不上。
+			// 这里的取舍是「放弃本次续期」：本次请求照常放行（会话此刻仍然有效），
+			// 库与内存保持同一个到期时间，等下一次请求再试。
+			s.log.Warn("会话续期写库失败，本次不续期", "err", err, "sessionId", sess.ID)
+			return &u, &sess, nil
+		}
 		sess.ExpiresAt = renewed
 		return &u, &sess, nil
 	}
 	// 没到续期点时也不是每个请求都写：last_seen_at 最快每 touchInterval 回写一次。
 	// 一个页面加载会打七八个请求，逐个写一遍纯属放大写压力，而「上次活动时间」精确到分钟就够用。
+	// 这条写失败无所谓：last_seen_at 只用于排障，不影响「会话还活着」的判定。
 	lastSeen, err := parseDBTime(lastSeenRaw)
 	if err != nil || now.Sub(lastSeen) >= touchInterval {
 		_, _ = s.db.ExecContext(ctx, `UPDATE sessions SET last_seen_at = ? WHERE id = ?`,
@@ -459,6 +554,34 @@ func (s *Service) Lookup(ctx context.Context, token string) (*User, *Session, er
 	return &u, &sess, nil
 }
 
+// purgeExpiredSessions 删掉已过期的会话行。
+//
+// sessions 只增不减：每次登录留一行，过期行连同 token 哈希永久躺在库里（含 ip / user_agent），
+// 这是无界增长也是个人信息留存。迁移里早就有 idx_sessions_expires_at 索引，就是为这件事准备的。
+// 节流到 sessionPurgeInterval 一次，且只在「有人带着会话访问」时触发——
+// 没人登录就没有新会话行，也就不需要清理。
+// 失败不吞：写 WARN，并把节流时间戳清掉，让下一次请求立刻重试。
+func (s *Service) purgeExpiredSessions(ctx context.Context, now time.Time) {
+	last := s.lastPurge.Load()
+	if last != 0 && now.Sub(time.Unix(0, last)) < sessionPurgeInterval {
+		return
+	}
+	// CAS 只有一个请求能拿到「本次清理」的资格，其余请求直接跳过（并发下只删一次）。
+	if !s.lastPurge.CompareAndSwap(last, now.UnixNano()) {
+		return
+	}
+	res, err := s.db.ExecContext(ctx,
+		`DELETE FROM sessions WHERE expires_at <= ?`, now.UTC().Format(time.DateTime))
+	if err != nil {
+		s.lastPurge.Store(0)
+		s.log.Warn("清理过期会话失败", "err", err)
+		return
+	}
+	if n, err := res.RowsAffected(); err == nil && n > 0 {
+		s.log.Info("清理过期会话", "rows", n)
+	}
+}
+
 // Logout 删除会话（服务端强制下线）。
 func (s *Service) Logout(ctx context.Context, token string) error {
 	if strings.TrimSpace(token) == "" {

server/internal/auth/session_cookie_test.go

@@ -0,0 +1,132 @@
+package auth
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+)
+
+// refreshResult 是一次 RefreshSessionCookies 写出的 Cookie（按名字索引）。
+func refreshResult(t *testing.T, svc *Service, sessionToken, csrfToken string, expiresAt time.Time) map[string]*http.Cookie {
+	t.Helper()
+	rec := httptest.NewRecorder()
+	svc.RefreshSessionCookies(rec, sessionToken, csrfToken, expiresAt)
+	out := map[string]*http.Cookie{}
+	for _, c := range rec.Result().Cookies() {
+		out[c.Name] = c
+	}
+	return out
+}
+
+// 滑动续期之后必须重发 Cookie，而且 Max-Age 要跟着「会话当前还剩多久」走：
+//
+//	Max-Age 是浏览器端的硬期限。写成完整有效期（登录时那个固定数）时，
+//	真出现「会话剩余寿命与有效期不一致」的时刻（有效期被改短、会话是旧口径建的），
+//	浏览器就会在服务端仍然认这条会话的时候把 Cookie 丢掉 —— 用户毫无征兆地被登出，
+//	而服务端日志上看这条会话一直是活的。这条之前的 0 覆盖正是这个承诺没人守。
+func TestRefreshSessionCookiesMaxAgeFollowsRemainingLife(t *testing.T) {
+	now := time.Date(2026, 9, 11, 20, 0, 0, 0, time.UTC)
+	db := newSettingsDB(t, nil)
+	svc := New(db, Options{Logger: quietLogger(), SessionTTL: 24 * time.Hour,
+		Now: func() time.Time { return now }})
+
+	// ① 续期恰好到「now + 24h」：Max-Age 是 24h 的秒数。
+	got := refreshResult(t, svc, "sess-token", "csrf-token", now.Add(24*time.Hour))
+	sess, csrf := got[CookieSession], got[CookieCSRF]
+	if sess == nil || csrf == nil {
+		t.Fatalf("续期必须同时重发会话与 CSRF Cookie，得到 %v", got)
+	}
+	if sess.Value != "sess-token" || csrf.Value != "csrf-token" {
+		t.Fatalf("Cookie 值必须沿用原值（CSRF 不轮换，避免和飞行中的写请求打架），得到 %q / %q",
+			sess.Value, csrf.Value)
+	}
+	if want := 24 * 60 * 60; sess.MaxAge != want || csrf.MaxAge != want {
+		t.Fatalf("Max-Age 应为剩余寿命 %d 秒，得到会话 %d / CSRF %d", want, sess.MaxAge, csrf.MaxAge)
+	}
+
+	// ② 关键对照：会话只剩 30 分钟时，Max-Age 必须是 1800，而不是有效期的 86400。
+	got = refreshResult(t, svc, "sess-token", "csrf-token", now.Add(30*time.Minute))
+	if got[CookieSession] == nil || got[CookieSession].MaxAge != 30*60 {
+		t.Fatalf("Max-Age 应跟会话的剩余寿命（1800），得到 %+v", got[CookieSession])
+	}
+	if got[CookieSession].MaxAge == 24*60*60 {
+		t.Fatalf("Max-Age 被写成了完整有效期：浏览器会比服务端早 23.5 小时丢掉 Cookie")
+	}
+
+	// ③ 到期时间已过：一个 Cookie 都不许写（不给已经失效的会话续期限）。
+	if got = refreshResult(t, svc, "sess-token", "csrf-token", now.Add(-time.Second)); len(got) != 0 {
+		t.Fatalf("已过期的会话不该重发任何 Cookie，得到 %v", got)
+	}
+
+	// ④ 没有会话 token 时不写；CSRF 空串时只写会话（不写一枚空值 Cookie 把票面清掉）。
+	if got = refreshResult(t, svc, "", "csrf-token", now.Add(time.Hour)); len(got) != 0 {
+		t.Fatalf("没有会话 token 时不该写任何 Cookie，得到 %v", got)
+	}
+	got = refreshResult(t, svc, "sess-token", "", now.Add(time.Hour))
+	if got[CookieSession] == nil || got[CookieCSRF] != nil {
+		t.Fatalf("CSRF token 为空时只该重发会话 Cookie，得到 %v", got)
+	}
+
+	// ⑤ 安全属性口径不变：会话 HttpOnly + SameSite=Lax + Path=/，CSRF 可被前端读取。
+	if !sess.HttpOnly || sess.SameSite != http.SameSiteLaxMode || sess.Path != "/" {
+		t.Fatalf("会话 Cookie 应 HttpOnly + SameSite=Lax + Path=/：%+v", sess)
+	}
+	if csrf.HttpOnly {
+		t.Fatalf("CSRF Cookie 必须可被前端读取（非 HttpOnly）：%+v", csrf)
+	}
+}
+
+// Secure 开关（HTTPS 部署）必须作用到重发的两枚 Cookie 上，否则续期一次就退回明文传输。
+func TestRefreshSessionCookiesKeepsSecureFlag(t *testing.T) {
+	now := time.Date(2026, 9, 11, 20, 0, 0, 0, time.UTC)
+	db := newSettingsDB(t, nil)
+	insecure := New(db, Options{Logger: quietLogger(), SessionTTL: time.Hour, Now: func() time.Time { return now }})
+	secure := New(db, Options{Logger: quietLogger(), SessionTTL: time.Hour, Secure: true,
+		Now: func() time.Time { return now }})
+
+	for _, tc := range []struct {
+		name   string
+		svc    *Service
+		secure bool
+	}{
+		{"默认（HTTP 部署）", insecure, false},
+		{"Secure=true（HTTPS 部署）", secure, true},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			got := refreshResult(t, tc.svc, "sess-token", "csrf-token", now.Add(time.Hour))
+			for _, name := range []string{CookieSession, CookieCSRF} {
+				if got[name] == nil {
+					t.Fatalf("应重发 %s，得到 %v", name, got)
+				}
+				if got[name].Secure != tc.secure {
+					t.Fatalf("%s 的 Secure 应为 %v，得到 %+v", name, tc.secure, got[name])
+				}
+			}
+		})
+	}
+}
+
+// 停用用户是「立即失效」的第二道闸：管理端撤会话那一步万一没跑到（异常分支、手工改库），
+// 会话行还在时 Lookup 也必须当它不存在——否则被停用的人只要不关页面就能继续写。
+func TestLookupRefusesInactiveUserWithLiveSession(t *testing.T) {
+	now := time.Date(2026, 9, 11, 20, 0, 0, 0, time.UTC)
+	db := newSettingsDB(t, nil)
+	svc := New(db, Options{Logger: quietLogger(), SessionTTL: 24 * time.Hour,
+		Now: func() time.Time { return now }})
+	userID := insertUser(t, db, "admin")
+	token := insertSession(t, db, userID, now.Add(24*time.Hour))
+
+	// 会话行还在（到期时间也没动），只把用户停用。
+	execTest(t, db, `UPDATE users SET active = 0 WHERE id = ?`, userID)
+
+	if _, _, err := svc.Lookup(context.Background(), token); err != ErrSessionNotFound {
+		t.Fatalf("停用用户的会话应查不到（ErrSessionNotFound），得到 %v", err)
+	}
+	// 对照：重新启用后同一条会话又能用了，证明上面拦的确实是「停用」而不是别的什么。
+	execTest(t, db, `UPDATE users SET active = 1 WHERE id = ?`, userID)
+	if _, _, err := svc.Lookup(context.Background(), token); err != nil {
+		t.Fatalf("重新启用后同一条会话应恢复可用，得到 %v", err)
+	}
+}

server/internal/auth/session_integrity_test.go

@@ -0,0 +1,323 @@
+package auth
+
+import (
+	"context"
+	"database/sql"
+	"sync"
+	"testing"
+	"time"
+
+	"golang.org/x/crypto/bcrypt"
+)
+
+// ---------- 测试脚手架 ----------
+
+// blockSessionExpiryUpdate 装一个只拦 expires_at 回写的触发器，模拟「续期那句 UPDATE 失败」
+// （库被锁 / 磁盘满 / 只读挂载）。last_seen_at 的单列回写不受影响——
+// 这两条路径必须能被区分开，否则测不出 A35 的分支。
+func blockSessionExpiryUpdate(t *testing.T, db *sql.DB) {
+	t.Helper()
+	execTest(t, db, `CREATE TRIGGER block_renew BEFORE UPDATE OF expires_at ON sessions
+	                 BEGIN SELECT RAISE(ABORT, '续期写库被拦下'); END`)
+}
+
+// blockSessionDelete 装一个拦 DELETE 的触发器，模拟「作废会话失败」。
+func blockSessionDelete(t *testing.T, db *sql.DB) {
+	t.Helper()
+	execTest(t, db, `CREATE TRIGGER block_revoke BEFORE DELETE ON sessions
+	                 BEGIN SELECT RAISE(ABORT, '撤会话被拦下'); END`)
+}
+
+func insertSessionRow(t *testing.T, db *sql.DB, id string, userID int64, expiresAt time.Time) string {
+	t.Helper()
+	token := "token-" + id
+	if _, err := db.Exec(
+		`INSERT INTO sessions (id, user_id, token_hash, expires_at, last_seen_at) VALUES (?, ?, ?, ?, ?)`,
+		id, userID, hashToken(token), expiresAt.UTC().Format(time.DateTime), expiresAt.UTC().Format(time.DateTime)); err != nil {
+		t.Fatalf("建会话 %s: %v", id, err)
+	}
+	return token
+}
+
+func countSessions(t *testing.T, db *sql.DB) int {
+	t.Helper()
+	var n int
+	if err := db.QueryRow(`SELECT COUNT(*) FROM sessions`).Scan(&n); err != nil {
+		t.Fatalf("统计会话: %v", err)
+	}
+	return n
+}
+
+func dbPasswordHash(t *testing.T, db *sql.DB, username string) string {
+	t.Helper()
+	var hash string
+	if err := db.QueryRow(`SELECT password_hash FROM users WHERE username = ?`, username).Scan(&hash); err != nil {
+		t.Fatalf("读密码哈希: %v", err)
+	}
+	return hash
+}
+
+func newAuthTestService(t *testing.T, db *sql.DB, opts Options) *Service {
+	t.Helper()
+	opts.Logger = quietLogger()
+	if opts.BcryptCost == 0 {
+		opts.BcryptCost = bcrypt.MinCost
+	}
+	return New(db, opts)
+}
+
+// ---------- A35：滑动续期写库失败 ----------
+
+// 续期写库失败时不能只顺延内存里的到期时间：库里还是旧到期时间，而 /auth/me 会拿内存里那个值
+// 重发 Cookie（浏览器端的 Max-Age 跟着顺延），于是「服务端说还有 24 小时、其实早已过期」，
+// 用户会在毫无征兆的情况下被登出，排查时两边还对不上。
+func TestLookupKeepsStoredExpiryWhenRenewFails(t *testing.T) {
+	db := newSettingsDB(t, nil)
+	now := time.Date(2026, 9, 11, 20, 0, 0, 0, time.UTC)
+	svc := newAuthTestService(t, db, Options{SessionTTL: 24 * time.Hour, Now: func() time.Time { return now }})
+	userID := insertUser(t, db, "admin")
+	// 剩余 23h58m：已越过续期节流窗口，本次查找本该顺延到 now+24h。
+	token := insertSession(t, db, userID, now.Add(24*time.Hour-2*time.Minute))
+	stored := dbExpiry(t, db)
+	blockSessionExpiryUpdate(t, db)
+
+	_, sess, err := svc.Lookup(context.Background(), token)
+	if err != nil {
+		t.Fatalf("续期写库失败不该让查找失败（会话此刻仍然有效）: %v", err)
+	}
+	if want := now.Add(24*time.Hour - 2*time.Minute); !sess.ExpiresAt.Equal(want) {
+		t.Fatalf("续期失败时必须保持库里的到期时间 %s，得到 %s", want, sess.ExpiresAt)
+	}
+	if got := dbExpiry(t, db); got != stored {
+		t.Fatalf("续期失败不该改动库里的到期时间：%s → %s", stored, got)
+	}
+
+	// 去掉触发器后重来：续期该恢复成正常顺延（证明确实是「失败才不续」而不是「永远不续」）。
+	execTest(t, db, `DROP TRIGGER block_renew`)
+	if _, sess, err := svc.Lookup(context.Background(), token); err != nil {
+		t.Fatalf("查询会话: %v", err)
+	} else if want := now.Add(24 * time.Hour); !sess.ExpiresAt.Equal(want) {
+		t.Fatalf("写库恢复后应顺延到 %s，得到 %s", want, sess.ExpiresAt)
+	}
+}
+
+// ---------- A36：改密与作废会话同成同败 ----------
+
+// 正常路径：密码换掉的同时会话被清空（两个动作在一个事务里）。
+func TestSetPasswordRevokesSessionsSeenAsOneAction(t *testing.T) {
+	db := newSettingsDB(t, nil)
+	svc := newAuthTestService(t, db, Options{SessionTTL: time.Hour})
+	userID := insertUser(t, db, "admin")
+	if err := svc.SetPassword(context.Background(), "admin", "old-password", false); err != nil {
+		t.Fatalf("初始化密码: %v", err)
+	}
+	insertSession(t, db, userID, time.Now().Add(time.Hour))
+
+	if err := svc.SetPassword(context.Background(), "admin", "new-password", false); err != nil {
+		t.Fatalf("改密应成功: %v", err)
+	}
+	if err := svc.VerifyPassword(context.Background(), userID, "new-password"); err != nil {
+		t.Fatalf("新密码应能通过校验: %v", err)
+	}
+	if err := svc.VerifyPassword(context.Background(), userID, "old-password"); err == nil {
+		t.Fatal("旧密码不该还能通过校验")
+	}
+	if n := countSessions(t, db); n != 0 {
+		t.Fatalf("改密后旧会话必须全部失效，库里还剩 %d 行", n)
+	}
+}
+
+// 失败路径（本条的要点）：撤会话失败时整件事必须回滚，
+// 绝不能留下「密码已改、旧会话仍全部有效」这种用户以为已经止血、实际没有的中间态。
+func TestSetPasswordRollsBackWhenRevokeFails(t *testing.T) {
+	db := newSettingsDB(t, nil)
+	svc := newAuthTestService(t, db, Options{SessionTTL: time.Hour})
+	userID := insertUser(t, db, "admin")
+	if err := svc.SetPassword(context.Background(), "admin", "old-password", false); err != nil {
+		t.Fatalf("初始化密码: %v", err)
+	}
+	insertSession(t, db, userID, time.Now().Add(time.Hour))
+	before := dbPasswordHash(t, db, "admin")
+
+	blockSessionDelete(t, db)
+	if err := svc.SetPassword(context.Background(), "admin", "new-password", false); err == nil {
+		t.Fatal("撤会话失败时改密必须整体失败")
+	}
+
+	if got := dbPasswordHash(t, db, "admin"); got != before {
+		t.Fatalf("事务失败后密码哈希必须原样（回滚），%s → %s", before, got)
+	}
+	if n := countSessions(t, db); n != 1 {
+		t.Fatalf("事务失败后旧会话必须仍然存在（与「什么都没变」自洽），库里 %d 行", n)
+	}
+	// 外部看到的就是「什么都没变」：旧密码仍然有效、旧会话仍然可用。
+	if err := svc.VerifyPassword(context.Background(), userID, "old-password"); err != nil {
+		t.Fatalf("回滚后旧密码应仍然有效: %v", err)
+	}
+	if err := svc.VerifyPassword(context.Background(), userID, "new-password"); err == nil {
+		t.Fatal("回滚后新密码不该生效")
+	}
+}
+
+// 并发路径：改密期间并发的会话查找只会看到「旧世界」或「新世界」，
+// 改密返回后旧 token 必须彻底查不到（不会出现「密码换了、会话还在」的残留）。
+func TestSetPasswordConcurrentLookupsLeaveNoStaleSession(t *testing.T) {
+	db := newSettingsDB(t, nil)
+	svc := newAuthTestService(t, db, Options{SessionTTL: time.Hour})
+	userID := insertUser(t, db, "admin")
+	if err := svc.SetPassword(context.Background(), "admin", "old-password", false); err != nil {
+		t.Fatalf("初始化密码: %v", err)
+	}
+	token := insertSession(t, db, userID, time.Now().Add(time.Hour))
+
+	stop := make(chan struct{})
+	var wg sync.WaitGroup
+	for i := 0; i < 4; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for {
+				select {
+				case <-stop:
+					return
+				default:
+					// 结果不校验：并发查找允许看到事务提交前的任意中间时刻。
+					_, _, _ = svc.Lookup(context.Background(), token)
+				}
+			}
+		}()
+	}
+
+	if err := svc.SetPassword(context.Background(), "admin", "new-password", false); err != nil {
+		t.Fatalf("改密应成功: %v", err)
+	}
+	close(stop)
+	wg.Wait()
+
+	// 改密返回之后，任何一条旧会话都不该还能用。
+	if _, _, err := svc.Lookup(context.Background(), token); err != ErrSessionNotFound {
+		t.Fatalf("改密后旧会话应查不到，得到 %v", err)
+	}
+	if n := countSessions(t, db); n != 0 {
+		t.Fatalf("改密后库里不该还剩会话行，得到 %d", n)
+	}
+}
+
+// 改名走同一条事务路径：改名成功则会话一并作废。
+func TestSetUsernameRevokesSessionsInSameTransaction(t *testing.T) {
+	db := newSettingsDB(t, nil)
+	svc := newAuthTestService(t, db, Options{SessionTTL: time.Hour})
+	userID := insertUser(t, db, "admin")
+	insertSession(t, db, userID, time.Now().Add(time.Hour))
+
+	if err := svc.SetUsername(context.Background(), "admin", "boss"); err != nil {
+		t.Fatalf("改名应成功: %v", err)
+	}
+	if n := countSessions(t, db); n != 0 {
+		t.Fatalf("改名后旧会话必须失效，库里还剩 %d 行", n)
+	}
+	// 再给他一条会话，才能让「撤会话」这一步真的去删行（DELETE 不命中行时不会触发触发器）。
+	insertSession(t, db, userID, time.Now().Add(time.Hour))
+	blockSessionDelete(t, db)
+	if err := svc.SetUsername(context.Background(), "boss", "chief"); err == nil {
+		t.Fatal("撤会话失败时改名必须整体失败")
+	}
+	var name string
+	if err := db.QueryRow(`SELECT username FROM users`).Scan(&name); err != nil {
+		t.Fatalf("读用户名: %v", err)
+	}
+	if name != "boss" {
+		t.Fatalf("事务失败后用户名必须回滚成 boss，得到 %q", name)
+	}
+}
+
+// ---------- D01：过期会话行清理 ----------
+
+// sessions 只增不减（每次登录一行，过期行与 token 哈希永久留存），
+// 挂在「查找会话」这条必经路径上按 sessionPurgeInterval 节流清理。
+func TestLookupPurgesExpiredSessions(t *testing.T) {
+	db := newSettingsDB(t, nil)
+	now := time.Date(2026, 9, 11, 20, 0, 0, 0, time.UTC)
+	svc := newAuthTestService(t, db, Options{SessionTTL: 24 * time.Hour, Now: func() time.Time { return now }})
+	userID := insertUser(t, db, "admin")
+	token := insertSessionRow(t, db, "live", userID, now.Add(24*time.Hour))
+	insertSessionRow(t, db, "old-1", userID, now.Add(-time.Hour))
+	insertSessionRow(t, db, "old-2", userID, now.Add(-48*time.Hour))
+
+	if _, _, err := svc.Lookup(context.Background(), token); err != nil {
+		t.Fatalf("查询会话: %v", err)
+	}
+	if n := countSessions(t, db); n != 1 {
+		t.Fatalf("过期会话行应被清掉，库里还剩 %d 行", n)
+	}
+
+	// 节流：同一小时内不再清第二次（每次请求都扫一遍过期行纯属白写库）。
+	insertSessionRow(t, db, "old-3", userID, now.Add(-time.Minute))
+	if _, _, err := svc.Lookup(context.Background(), token); err != nil {
+		t.Fatalf("查询会话: %v", err)
+	}
+	if n := countSessions(t, db); n != 2 {
+		t.Fatalf("节流窗口内不该再清一次，库里 %d 行", n)
+	}
+
+	// 越过节流窗口后继续清理，而且不能误删仍然有效的会话。
+	now = now.Add(sessionPurgeInterval + time.Minute)
+	if _, _, err := svc.Lookup(context.Background(), token); err != nil {
+		t.Fatalf("查询会话: %v", err)
+	}
+	if n := countSessions(t, db); n != 1 {
+		t.Fatalf("越过节流窗口后应清掉过期行、只留有效会话，库里 %d 行", n)
+	}
+}
+
+// ---------- C15：登录限流不再是死配置 ----------
+
+// 迁移 0005 种下的 security.login_rate_per_minute 此前没有任何代码读它，
+// 现场改这个键不起作用。现在它真的生效（越界 / 非法一律回落到内置默认）。
+func TestLoginRateFromSettings(t *testing.T) {
+	for _, tc := range []struct {
+		name  string
+		value string
+		want  int
+	}{
+		{"系统库设置生效", "2", 2},
+		{"上界 60 生效", "60", 60},
+		{"0 非法回默认", "0", DefaultLoginPerMinute},
+		{"负数非法回默认", "-1", DefaultLoginPerMinute},
+		{"超上限非法回默认", "61", DefaultLoginPerMinute},
+		{"非数字非法回默认", "五次", DefaultLoginPerMinute},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			db := newSettingsDB(t, map[string]string{LoginRateKey: tc.value})
+			svc := newAuthTestService(t, db, Options{})
+			if got := svc.loginLimiter.limit; got != tc.want {
+				t.Fatalf("登录限流应为 %d，得到 %d", tc.want, got)
+			}
+			// 行为断言，不只看字段：第 want+1 次必须被拦下。
+			for i := 0; i < tc.want; i++ {
+				if !svc.AllowLogin("1.2.3.4") {
+					t.Fatalf("第 %d 次应放行", i+1)
+				}
+			}
+			if svc.AllowLogin("1.2.3.4") {
+				t.Fatalf("第 %d 次应被限流", tc.want+1)
+			}
+		})
+	}
+
+	t.Run("系统库没有键时用启动参数兜底", func(t *testing.T) {
+		db := newSettingsDB(t, nil)
+		svc := newAuthTestService(t, db, Options{LoginPerMinute: 3})
+		if got := svc.loginLimiter.limit; got != 3 {
+			t.Fatalf("应回落到启动参数的 3，得到 %d", got)
+		}
+	})
+
+	t.Run("系统库有键时优先于启动参数", func(t *testing.T) {
+		db := newSettingsDB(t, map[string]string{LoginRateKey: "2"})
+		svc := newAuthTestService(t, db, Options{LoginPerMinute: 9})
+		if got := svc.loginLimiter.limit; got != 2 {
+			t.Fatalf("系统库设置应优先，期望 2，得到 %d", got)
+		}
+	})
+}