feat: 赛事项目切换 + 记住上次打开的赛事（修「导入赛事包后没数据」）

根因：服务端启动只认 -project（缺省 default），Console 从不传；导入只是把包解到
event_projs/<名字>，没有任何切换入口 → 导入的赛事永远打不开，页面看到的是空的 default。

- 服务端 -project 缺省改为空串；解析顺序：显式 flag（并写回记忆）> <dataDir>/active_project.txt
  > default；backup/passwd 口径一致；启动日志打印生效项目与来源
- GET /api/projects（admin）列出各赛事（是否当前/是否有 event.db/大小/更新时间）
- POST /api/projects/activate（admin）：校验后原子写记忆文件 → 审计 → 返回
  {ok,name,restarting:true} → 触发优雅关闭；Console 对非用户发起的退出会自动拉起，
  重启后即打开新赛事（无需改 Console）。本来就是当前赛事则 restarting:false 不重启
- 管理端「导出」页新增赛事项目列表与「切换为当前赛事」；导入成功后提示「已导入为 X，
  但还不是当前赛事」并给「立即切换并重启服务端」；切换后轮询 /api/health 等它回来再刷新
- 文档：使用手册（导入≠切换、生效四步）、常见问题（导入后看不到数据）

自检：服务端 12 包全绿；前端 vue-tsc + build、node --test 66/66；console 14 文件通过。

server/internal/httpapi/projects.go

@@ -0,0 +1,215 @@
+package httpapi
+
+import (
+	"errors"
+	"fmt"
+	"io/fs"
+	"net/http"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"time"
+
+	"git.yeij.top/AskaEth/Scoreboard/server/internal/auth"
+	"git.yeij.top/AskaEth/Scoreboard/server/internal/export"
+)
+
+// ActiveProjectFile 是数据目录下记录「上次打开的赛事项目」的记忆文件名。
+// 服务端启动时按 显式 -project → 本文件 → default 的顺序解析当前赛事；
+// 切换赛事就是改这个文件再重启进程（Console 会代劳重启）。
+const ActiveProjectFile = "active_project.txt"
+
+// ReadActiveProject 读记忆文件里的赛事项目名：文件缺失、内容为空或其项目名不安全时返回空串，
+// 由调用方回落到 default。多行内容会被 SafeProjectName 当成控制字符拒绝。
+func ReadActiveProject(dataDir string) string {
+	if strings.TrimSpace(dataDir) == "" {
+		return ""
+	}
+	raw, err := os.ReadFile(activeProjectPath(dataDir))
+	if err != nil {
+		return ""
+	}
+	name, err := export.SafeProjectName(string(raw))
+	if err != nil {
+		return ""
+	}
+	return name
+}
+
+// WriteActiveProject 把当前赛事项目名写进记忆文件。
+// 先写同目录的临时文件再改名：改名是原子的，读取方（下次启动）不会看到半截项目名。
+func WriteActiveProject(dataDir, name string) error {
+	safe, err := export.SafeProjectName(name)
+	if err != nil {
+		return err
+	}
+	if strings.TrimSpace(dataDir) == "" {
+		return errors.New("httpapi: 数据目录为空，无法写入赛事项目记忆文件")
+	}
+	if err := os.MkdirAll(dataDir, 0o755); err != nil {
+		return fmt.Errorf("httpapi: 创建数据目录 %s: %w", dataDir, err)
+	}
+
+	tmp, err := os.CreateTemp(dataDir, ActiveProjectFile+".tmp-*")
+	if err != nil {
+		return fmt.Errorf("httpapi: 创建临时文件: %w", err)
+	}
+	path := tmp.Name()
+	if _, err := tmp.WriteString(safe + "\n"); err != nil {
+		_ = tmp.Close()
+		_ = os.Remove(path)
+		return fmt.Errorf("httpapi: 写入 %s: %w", path, err)
+	}
+	if err := tmp.Close(); err != nil {
+		_ = os.Remove(path)
+		return fmt.Errorf("httpapi: 关闭 %s: %w", path, err)
+	}
+	if err := os.Rename(path, activeProjectPath(dataDir)); err != nil {
+		_ = os.Remove(path)
+		return fmt.Errorf("httpapi: 重命名记忆文件: %w", err)
+	}
+	return nil
+}
+
+func activeProjectPath(dataDir string) string {
+	return filepath.Join(dataDir, ActiveProjectFile)
+}
+
+// projectInfo 是 GET /api/projects 里的一项赛事项目。
+type projectInfo struct {
+	Name string `json:"name"`
+	// Active 表示这是服务端当前打开的赛事（与启动时解析出的项目名比较）。
+	Active   bool `json:"active"`
+	HasEvent bool `json:"hasEvent"`
+	// SizeBytes 是整个项目目录占用的字节数（含 event.db 与 uploads）。
+	SizeBytes int64 `json:"sizeBytes"`
+	// UpdatedAt 取 event.db 的修改时间（RFC3339）；没有 event.db 时为空串。
+	UpdatedAt string `json:"updatedAt"`
+}
+
+// projectActivateResult 是切换赛事的结果；restarting 为 true 表示已写记忆文件并触发重启流程。
+type projectActivateResult struct {
+	Name       string `json:"name"`
+	Restarting bool   `json:"restarting"`
+}
+
+// projectRoutes 挂载赛事项目列表与切换（均为 admin）。
+func (s *server) projectRoutes(mux *http.ServeMux) {
+	mux.HandleFunc("GET /api/projects", s.read(auth.RoleAdmin, s.listProjects))
+	// 切赛事要走写路由：写记忆文件属于变更操作，需要 CSRF 与幂等保护。
+	mux.HandleFunc("POST /api/projects/activate", s.write(auth.RoleAdmin, s.activateProject))
+}
+
+// projectsRoot 是赛事项目根目录 <dataDir>/event_projs。
+func (s *server) projectsRoot() string {
+	return filepath.Join(s.dataDir, "event_projs")
+}
+
+// listProjects 列出可用的赛事项目：导入的包都落在 <dataDir>/event_projs/<项目名>/，
+// 管理端据此显示「哪些赛事导进来过」以及当前打开的是哪一个。
+func (s *server) listProjects(w http.ResponseWriter, r *http.Request) (any, error) {
+	entries, err := os.ReadDir(s.projectsRoot())
+	if err != nil {
+		// 全新安装还没有 event_projs 目录：回空列表，别让管理端看到一个 500。
+		if os.IsNotExist(err) {
+			return map[string]any{"projects": []projectInfo{}}, nil
+		}
+		return nil, internal(err)
+	}
+
+	active := currentProjectName(s.projectDir)
+	items := make([]projectInfo, 0, len(entries))
+	for _, e := range entries {
+		// 单个条目读不到就跳过：损坏或半截的目录不该让整个列表失败。
+		if !e.IsDir() || strings.HasPrefix(e.Name(), ".") {
+			// 点开头的是导入过程中的 .import-* 临时目录，不进列表。
+			continue
+		}
+		name, err := export.SafeProjectName(e.Name())
+		if err != nil {
+			// 被手工改坏的名字也不能当成可切换的项目。
+			continue
+		}
+		dir := filepath.Join(s.projectsRoot(), name)
+		item := projectInfo{Name: name, Active: name == active, SizeBytes: dirSize(dir)}
+		if info, err := os.Stat(filepath.Join(dir, "event.db")); err == nil && !info.IsDir() {
+			item.HasEvent = true
+			item.UpdatedAt = info.ModTime().UTC().Format(time.RFC3339)
+		}
+		items = append(items, item)
+	}
+	sort.Slice(items, func(i, j int) bool { return items[i].Name < items[j].Name })
+	return map[string]any{"projects": items}, nil
+}
+
+// activateProject 切换当前赛事：校验后写记忆文件，再触发优雅关闭，等 Console 自动拉起服务端。
+// 重启后服务端按记忆文件打开新项目——服务端自己不重启，避免中途丢掉正在运行的库连接。
+func (s *server) activateProject(w http.ResponseWriter, r *http.Request) (any, error) {
+	var req struct {
+		Name string `json:"name"`
+	}
+	if err := decodeJSON(r, &req); err != nil {
+		return nil, err
+	}
+	name, err := export.SafeProjectName(req.Name)
+	if err != nil {
+		return nil, badRequest(projectNameMessage(err), nil)
+	}
+
+	dir := filepath.Join(s.projectsRoot(), name)
+	if info, err := os.Stat(dir); err != nil || !info.IsDir() {
+		return nil, badRequest("赛事项目 "+name+" 不存在，请先导入赛事包", nil)
+	}
+	if info, err := os.Stat(filepath.Join(dir, "event.db")); err != nil || info.IsDir() {
+		return nil, badRequest("赛事项目 "+name+" 缺少 event.db，无法切换", nil)
+	}
+
+	active := currentProjectName(s.projectDir)
+	if active == name {
+		// 已经是当前赛事：不写文件也不重启，重复点击不会反复重启服务端。
+		return projectActivateResult{Name: name, Restarting: false}, nil
+	}
+
+	if err := WriteActiveProject(s.dataDir, name); err != nil {
+		return nil, internal(err)
+	}
+	s.audit(r.Context(), "project.activate", "project", 0, map[string]any{"from": active}, map[string]any{"to": name})
+
+	// 先写响应再触发关闭：srv.Shutdown 会等本次请求（含上面的审计落库）结束，不会截断响应。
+	writeJSON(w, http.StatusOK, map[string]any{
+		"ok":   true,
+		"data": projectActivateResult{Name: name, Restarting: true},
+	})
+	if s.shutdown == nil {
+		// 没接入优雅关闭（例如手工跑的裸服务端）：记忆文件已写好，下次重启即生效。
+		s.logger.Warn("服务端未接入优雅关闭，赛事切换将在下次重启后生效", "project", name)
+	} else {
+		go s.shutdown()
+	}
+	return nil, errHandled
+}
+
+// projectNameMessage 把 export.SafeProjectName 的错误整理成面向管理端的中文提示，
+// 去掉包名前缀与重复的「赛事项目名非法」。
+func projectNameMessage(err error) string {
+	detail := strings.TrimPrefix(err.Error(), "export: ")
+	// ErrUnsafeName 会被包成「赛事项目名非法: <细节>」，这里只留细节，避免同一句提示出现两遍。
+	detail = strings.TrimPrefix(detail, strings.TrimPrefix(export.ErrUnsafeName.Error(), "export: ")+": ")
+	return "赛事项目名非法：" + detail
+}
+
+// dirSize 统计目录下普通文件的总字节数；读不到的条目直接跳过，不影响列表返回。
+func dirSize(root string) int64 {
+	var total int64
+	_ = filepath.WalkDir(root, func(p string, d fs.DirEntry, err error) error {
+		if err != nil || d.IsDir() {
+			return nil
+		}
+		if info, err := d.Info(); err == nil {
+			total += info.Size()
+		}
+		return nil
+	})
+	return total
+}

server/internal/httpapi/projects_internal_test.go

@@ -0,0 +1,91 @@
+package httpapi
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// 记忆文件是「下次启动打开哪个赛事」的唯一依据：必须能原子写入、能被读回，
+// 且绝不能因为半截或非法内容把服务端指到一个奇怪的目录（P0：导入后页面空白）。
+func TestActiveProjectFileRoundTrip(t *testing.T) {
+	dir := t.TempDir()
+
+	if got := ReadActiveProject(dir); got != "" {
+		t.Fatalf("没有记忆文件时应返回空串，得到 %q", got)
+	}
+	if got := ReadActiveProject(""); got != "" {
+		t.Fatalf("数据目录为空时应返回空串，得到 %q", got)
+	}
+
+	if err := WriteActiveProject(dir, "秋季赛"); err != nil {
+		t.Fatalf("写记忆文件: %v", err)
+	}
+	if got := ReadActiveProject(dir); got != "秋季赛" {
+		t.Fatalf("读回的项目名应为 秋季赛，得到 %q", got)
+	}
+	raw, err := os.ReadFile(filepath.Join(dir, ActiveProjectFile))
+	if err != nil {
+		t.Fatalf("读记忆文件: %v", err)
+	}
+	if string(raw) != "秋季赛\n" {
+		t.Fatalf("记忆文件应是单行纯文本，得到 %q", raw)
+	}
+	// 临时文件必须已经改名掉，不能在数据目录里堆积。
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		t.Fatalf("读取数据目录: %v", err)
+	}
+	if len(entries) != 1 || entries[0].Name() != ActiveProjectFile {
+		t.Fatalf("数据目录里应只剩记忆文件，得到 %v", entries)
+	}
+
+	// 覆盖写：旧项目名必须被整体替换，不能留下半截。
+	if err := WriteActiveProject(dir, "冬季赛"); err != nil {
+		t.Fatalf("覆盖写记忆文件: %v", err)
+	}
+	if got := ReadActiveProject(dir); got != "冬季赛" {
+		t.Fatalf("覆盖后应读到 冬季赛，得到 %q", got)
+	}
+}
+
+func TestActiveProjectFileRejectsUnsafeContent(t *testing.T) {
+	for _, tc := range []struct{ name, content string }{
+		{"路径穿越", "../逃逸\n"},
+		{"多行", "好名字\n坏名字\n"},
+		{"只有空白", "   \n"},
+		{"保留名", "CON\n"},
+		{"分隔符", "a/b\n"},
+		{"含控制字符", "好\x00名字\n"},
+	} {
+		dir := t.TempDir()
+		if err := os.WriteFile(filepath.Join(dir, ActiveProjectFile), []byte(tc.content), 0o644); err != nil {
+			t.Fatalf("写记忆文件: %v", err)
+		}
+		if got := ReadActiveProject(dir); got != "" {
+			t.Errorf("%s：非法内容应回空串交由调用方回落 default，得到 %q", tc.name, got)
+		}
+	}
+
+	// 两侧空白要 trim：手工编辑或 Windows 记事本都会留下换行与空格。
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, ActiveProjectFile), []byte("  秋季赛  \r\n"), 0o644); err != nil {
+		t.Fatalf("写记忆文件: %v", err)
+	}
+	if got := ReadActiveProject(dir); got != "秋季赛" {
+		t.Fatalf("应 trim 掉空白后读回 秋季赛，得到 %q", got)
+	}
+}
+
+func TestWriteActiveProjectRejectsBadInput(t *testing.T) {
+	dir := t.TempDir()
+	if err := WriteActiveProject(dir, "../逃逸"); err == nil {
+		t.Fatal("非法项目名不该被写进记忆文件")
+	}
+	if err := WriteActiveProject("", "秋季赛"); err == nil {
+		t.Fatal("数据目录为空时不该静默成功")
+	}
+	if _, err := os.Stat(filepath.Join(dir, ActiveProjectFile)); !os.IsNotExist(err) {
+		t.Fatalf("非法输入不该留下记忆文件: %v", err)
+	}
+}

server/internal/httpapi/projects_test.go

@@ -0,0 +1,276 @@
+package httpapi_test
+
+import (
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"git.yeij.top/AskaEth/Scoreboard/server/internal/httpapi"
+)
+
+// projectItem 对应 GET /api/projects 的一项（字段名是前后端共用的契约）。
+type projectItem struct {
+	Name      string `json:"name"`
+	Active    bool   `json:"active"`
+	HasEvent  bool   `json:"hasEvent"`
+	SizeBytes int64  `json:"sizeBytes"`
+	UpdatedAt string `json:"updatedAt"`
+}
+
+type projectList struct {
+	Projects []projectItem `json:"projects"`
+}
+
+type projectActivateResult struct {
+	Name       string `json:"name"`
+	Restarting bool   `json:"restarting"`
+}
+
+// newProjectEnv 建一个「当前打开 active 项目」的测试环境，并返回数据目录与关闭回调的通知通道。
+func newProjectEnv(t *testing.T, active string) (*testEnv, string, chan struct{}) {
+	t.Helper()
+	var dataDir string
+	shutdown := make(chan struct{}, 1)
+	env := newTestEnvWith(t, func(o *httpapi.Options) {
+		dataDir = o.DataDir
+		o.ProjectDir = filepath.Join(o.DataDir, "event_projs", active)
+		o.Shutdown = func() { shutdown <- struct{}{} }
+	})
+	return env, dataDir, shutdown
+}
+
+// writeProjectDir 造一个赛事项目目录；hasEvent=false 时只有目录，模拟导入了一半的项目。
+func writeProjectDir(t *testing.T, dataDir, name string, hasEvent bool) {
+	t.Helper()
+	dir := filepath.Join(dataDir, "event_projs", name)
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		t.Fatalf("创建项目目录 %s: %v", name, err)
+	}
+	if !hasEvent {
+		return
+	}
+	if err := os.WriteFile(filepath.Join(dir, "event.db"), []byte("sqlite-bytes"), 0o644); err != nil {
+		t.Fatalf("写项目 %s 的赛事库: %v", name, err)
+	}
+}
+
+func readActiveProjectFile(t *testing.T, dataDir string) string {
+	t.Helper()
+	raw, err := os.ReadFile(filepath.Join(dataDir, httpapi.ActiveProjectFile))
+	if err != nil {
+		t.Fatalf("读取记忆文件: %v", err)
+	}
+	return strings.TrimSpace(string(raw))
+}
+
+func projectByName(t *testing.T, env *testEnv, client *http.Client) map[string]projectItem {
+	t.Helper()
+	status, body := env.do(client, http.MethodGet, "/api/projects", nil, false)
+	if status != http.StatusOK {
+		t.Fatalf("列出赛事项目应 200，得到 %d %+v", status, body.Error)
+	}
+	out := map[string]projectItem{}
+	for _, p := range decodeData[projectList](t, body).Projects {
+		out[p.Name] = p
+	}
+	return out
+}
+
+// 导入的赛事包落在 event_projs/<名字>/，管理端必须先看得到这些项目才可能切过去（P0：导入后页面空白）。
+func TestListProjectsReportsAvailability(t *testing.T) {
+	env, dataDir, _ := newProjectEnv(t, "test")
+	writeProjectDir(t, dataDir, "秋季赛", true)
+	writeProjectDir(t, dataDir, "缺库的赛", false)
+	// 导入中途的临时目录不该出现在列表里。
+	if err := os.MkdirAll(filepath.Join(dataDir, "event_projs", ".import-abc"), 0o755); err != nil {
+		t.Fatalf("创建导入临时目录: %v", err)
+	}
+	// 与赛事无关的文件也不该被当成项目。
+	if err := os.WriteFile(filepath.Join(dataDir, "event_projs", "README.txt"), []byte("x"), 0o644); err != nil {
+		t.Fatalf("写无关文件: %v", err)
+	}
+	env.createUser("admin", "admin-pass", "admin")
+	client, _ := env.client()
+	env.login(client, "admin", "admin-pass")
+
+	projects := projectByName(t, env, client)
+	if len(projects) != 3 {
+		t.Fatalf("应列出 test / 秋季赛 / 缺库的赛 三个项目，得到 %+v", projects)
+	}
+	if !projects["test"].Active || !projects["test"].HasEvent {
+		t.Errorf("test 应是当前项目且有赛事库，得到 %+v", projects["test"])
+	}
+	if projects["秋季赛"].Active {
+		t.Errorf("秋季赛 不是当前项目，不应标 active：%+v", projects["秋季赛"])
+	}
+	if !projects["秋季赛"].HasEvent || projects["秋季赛"].UpdatedAt == "" {
+		t.Errorf("秋季赛 有 event.db，hasEvent/updatedAt 应有效：%+v", projects["秋季赛"])
+	}
+	if _, err := time.Parse(time.RFC3339, projects["秋季赛"].UpdatedAt); err != nil {
+		t.Errorf("updatedAt 应是 RFC3339，得到 %q", projects["秋季赛"].UpdatedAt)
+	}
+	if projects["秋季赛"].SizeBytes < int64(len("sqlite-bytes")) {
+		t.Errorf("sizeBytes 应统计目录内文件，得到 %d", projects["秋季赛"].SizeBytes)
+	}
+	if projects["缺库的赛"].HasEvent || projects["缺库的赛"].UpdatedAt != "" {
+		t.Errorf("没有 event.db 的项目 hasEvent=false、updatedAt 为空：%+v", projects["缺库的赛"])
+	}
+}
+
+// event_projs 还不存在（全新安装）时回空列表而不是 500。
+func TestListProjectsMissingRoot(t *testing.T) {
+	env, dataDir, _ := newProjectEnv(t, "test")
+	if err := os.RemoveAll(filepath.Join(dataDir, "event_projs")); err != nil {
+		t.Fatalf("删除项目根目录: %v", err)
+	}
+	env.createUser("admin", "admin-pass", "admin")
+	client, _ := env.client()
+	env.login(client, "admin", "admin-pass")
+
+	if projects := projectByName(t, env, client); len(projects) != 0 {
+		t.Fatalf("项目根目录不存在时应回空列表，得到 %+v", projects)
+	}
+}
+
+// 列表是 admin 接口：没登录 403、低权限角色也 403。
+func TestListProjectsRequiresAdmin(t *testing.T) {
+	env := newTestEnv(t)
+	env.createUser("rec", "rec-pass", "recorder")
+	client, _ := env.client()
+
+	if status, _ := env.do(client, http.MethodGet, "/api/projects", nil, false); status != http.StatusForbidden {
+		t.Fatalf("未登录应 403，得到 %d", status)
+	}
+	env.login(client, "rec", "rec-pass")
+	if status, _ := env.do(client, http.MethodGet, "/api/projects", nil, false); status != http.StatusForbidden {
+		t.Fatalf("recorder 应 403，得到 %d", status)
+	}
+}
+
+// 切换赛事：写记忆文件 + 返回 restarting=true + 触发优雅关闭（Console 据此自动拉起新赛事）。
+func TestActivateProjectWritesMemoryAndRestarts(t *testing.T) {
+	env, dataDir, shutdown := newProjectEnv(t, "test")
+	writeProjectDir(t, dataDir, "秋季赛", true)
+	env.createUser("admin", "admin-pass", "admin")
+	client, _ := env.client()
+	env.login(client, "admin", "admin-pass")
+
+	status, body := env.do(client, http.MethodPost, "/api/projects/activate",
+		map[string]any{"name": "秋季赛"}, true)
+	if status != http.StatusOK {
+		t.Fatalf("切换赛事应 200，得到 %d %+v", status, body.Error)
+	}
+	res := decodeData[projectActivateResult](t, body)
+	if res.Name != "秋季赛" || !res.Restarting {
+		t.Fatalf("应返回 {name:秋季赛, restarting:true}，得到 %+v", res)
+	}
+	if got := readActiveProjectFile(t, dataDir); got != "秋季赛" {
+		t.Fatalf("记忆文件应记住新项目，得到 %q", got)
+	}
+	select {
+	case <-shutdown:
+	case <-time.After(3 * time.Second):
+		t.Fatal("切换赛事后应触发优雅关闭，等 Console 自动重启")
+	}
+}
+
+// 切到自己身上不能重启：管理端重复点击会把现场反复断服。
+func TestActivateCurrentProjectDoesNotRestart(t *testing.T) {
+	env, dataDir, shutdown := newProjectEnv(t, "test")
+	env.createUser("admin", "admin-pass", "admin")
+	client, _ := env.client()
+	env.login(client, "admin", "admin-pass")
+
+	status, body := env.do(client, http.MethodPost, "/api/projects/activate",
+		map[string]any{"name": "test"}, true)
+	if status != http.StatusOK {
+		t.Fatalf("切到当前项目应 200，得到 %d %+v", status, body.Error)
+	}
+	if res := decodeData[projectActivateResult](t, body); res.Restarting {
+		t.Fatalf("当前项目不该返回 restarting=true：%+v", res)
+	}
+	if _, err := os.Stat(filepath.Join(dataDir, httpapi.ActiveProjectFile)); !os.IsNotExist(err) {
+		t.Fatalf("切到当前项目不该写记忆文件: %v", err)
+	}
+	select {
+	case <-shutdown:
+		t.Fatal("切到当前项目不该触发关闭")
+	case <-time.After(200 * time.Millisecond):
+	}
+}
+
+// 校验失败一律 400 + 中文提示，且不能留下记忆文件、更不能重启（写文件的目录是脏的）。
+func TestActivateProjectValidation(t *testing.T) {
+	env, dataDir, shutdown := newProjectEnv(t, "test")
+	writeProjectDir(t, dataDir, "缺库的赛", false)
+	env.createUser("admin", "admin-pass", "admin")
+	client, _ := env.client()
+	env.login(client, "admin", "admin-pass")
+
+	for _, tc := range []struct{ name, want, exact string }{
+		{"../逃逸", "非法", `赛事项目名非法："../逃逸"`},
+		{"", "非法", "赛事项目名非法：名称为空"},
+		{"没导入过", "不存在", ""},
+		{"缺库的赛", "event.db", ""},
+	} {
+		status, body := env.do(client, http.MethodPost, "/api/projects/activate",
+			map[string]any{"name": tc.name}, true)
+		if status != http.StatusBadRequest {
+			t.Fatalf("名字 %q 应 400，得到 %d %+v", tc.name, status, body.Error)
+		}
+		if body.Error == nil || !strings.Contains(body.Error.Message, tc.want) {
+			t.Fatalf("名字 %q 的提示应含 %q，得到 %+v", tc.name, tc.want, body.Error)
+		}
+		if tc.exact != "" && body.Error.Message != tc.exact {
+			t.Fatalf("名字 %q 的提示应是 %q，得到 %q", tc.name, tc.exact, body.Error.Message)
+		}
+	}
+	if _, err := os.Stat(filepath.Join(dataDir, httpapi.ActiveProjectFile)); !os.IsNotExist(err) {
+		t.Fatalf("校验失败不该写记忆文件: %v", err)
+	}
+	select {
+	case <-shutdown:
+		t.Fatal("校验失败不该触发关闭")
+	case <-time.After(200 * time.Millisecond):
+	}
+}
+
+// recorder 能看到的项目也不能自己切：切换是 admin 操作。
+func TestActivateProjectRequiresAdmin(t *testing.T) {
+	env := newTestEnv(t)
+	env.createUser("rec", "rec-pass", "recorder")
+	client, _ := env.client()
+	env.login(client, "rec", "rec-pass")
+
+	status, _ := env.do(client, http.MethodPost, "/api/projects/activate",
+		map[string]any{"name": "test"}, true)
+	if status != http.StatusForbidden {
+		t.Fatalf("recorder 切换赛事应 403，得到 %d", status)
+	}
+}
+
+// 没接入优雅关闭（手工跑的裸服务端）时也不能 500：记忆文件写好，下次重启生效。
+func TestActivateProjectWithoutShutdownHook(t *testing.T) {
+	var dataDir string
+	env := newTestEnvWith(t, func(o *httpapi.Options) {
+		dataDir = o.DataDir
+		o.ProjectDir = filepath.Join(o.DataDir, "event_projs", "test")
+		o.Shutdown = nil
+	})
+	writeProjectDir(t, dataDir, "秋季赛", true)
+	env.createUser("admin", "admin-pass", "admin")
+	client, _ := env.client()
+	env.login(client, "admin", "admin-pass")
+
+	status, body := env.do(client, http.MethodPost, "/api/projects/activate",
+		map[string]any{"name": "秋季赛"}, true)
+	if status != http.StatusOK {
+		t.Fatalf("未接入关闭回调也应 200，得到 %d %+v", status, body.Error)
+	}
+	if res := decodeData[projectActivateResult](t, body); !res.Restarting {
+		t.Fatalf("记忆文件已写好，仍应返回 restarting=true：%+v", res)
+	}
+}

server/internal/httpapi/server.go

@@ -102,6 +102,7 @@ func New(opts Options) http.Handler {
 	mux := http.NewServeMux()
 	s.routes(mux)
 	s.exportRoutes(mux)
+	s.projectRoutes(mux)
 	s.rulesRoutes(mux)
 	s.systemRoutes(mux)
 	if opts.WS != nil {